@aoxborrow/registrar-client 0.4.0 → 0.6.0

package/dist/index.cjs

@@ -1028,8 +1028,8 @@ var CloudflareRegistrar = class _CloudflareRegistrar extends BaseRegistrar {
         available: c?.registrable ?? false
       };
       if (c?.tier) availability.premium = c.tier === "premium";
-      const price = toPrice(c?.pricing?.registration_cost);
-      if (price != null) availability.price = price;
+      const price2 = toPrice(c?.pricing?.registration_cost);
+      if (price2 != null) availability.price = price2;
       if (c?.pricing?.currency) availability.currency = c.pricing.currency;
       return availability;
     });
@@ -1791,14 +1791,14 @@ ${bodyStr}`;
         opts
       );
       for (const r of data.domain_result_list ?? []) {
-        const price = oneYearPrice(r.price_list);
+        const price2 = oneYearPrice(r.price_list);
         results.push({
           domainName: r.domain_name ?? "",
           available: r.available === "Yes",
           premium: r.premium != null ? r.premium.toLowerCase() === "yes" : void 0,
-          price: price?.registration,
-          currency: price?.currency,
-          period: price ? 1 : void 0
+          price: price2?.registration,
+          currency: price2?.currency,
+          period: price2 ? 1 : void 0
         });
       }
     }
@@ -1835,13 +1835,13 @@ ${bodyStr}`;
       opts
     );
     const result = (data.domain_result_list ?? [])[0];
-    const price = oneYearPrice(result?.price_list);
+    const price2 = oneYearPrice(result?.price_list);
     return {
       tld,
-      currency: price?.currency ?? "USD",
-      registration: price?.registration,
-      renewal: price?.renewal,
-      transfer: price?.transfer
+      currency: price2?.currency ?? "USD",
+      registration: price2?.registration,
+      renewal: price2?.renewal,
+      transfer: price2?.transfer
     };
   }
   /**
@@ -2557,17 +2557,17 @@ var GandiRegistrar = class extends BaseRegistrar {
       const products = resp.products ?? [];
       const product = products.find((p) => p.process === "create") ?? products[0];
       const status = product?.status ?? "";
-      const price = product?.prices?.[0];
+      const price2 = product?.prices?.[0];
       const result = {
         domainName: product?.name ?? domainName,
         available: status.startsWith("available"),
-        premium: status.includes("premium") || price?.type === "premium"
+        premium: status.includes("premium") || price2?.type === "premium"
       };
-      const amount = pickPrice(price);
+      const amount = pickPrice(price2);
       if (amount != null) result.price = amount;
       if (resp.currency) result.currency = resp.currency;
-      if (price?.duration_unit === "y" && price.min_duration != null) {
-        result.period = price.min_duration;
+      if (price2?.duration_unit === "y" && price2.min_duration != null) {
+        result.period = price2.min_duration;
       }
       results.push(result);
     }
@@ -3005,9 +3005,9 @@ function fromGandiContact(c) {
     country: c.country ?? ""
   };
 }
-function pickPrice(price) {
-  if (!price) return void 0;
-  const value = price.price_after_taxes ?? price.price_before_taxes;
+function pickPrice(price2) {
+  if (!price2) return void 0;
+  const value = price2.price_after_taxes ?? price2.price_before_taxes;
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function parseDsRecord(ds) {
@@ -4091,13 +4091,13 @@ var NameBrightRegistrar = class extends BaseRegistrar {
         { path: `purchase/availability/${encodeURIComponent(domainName)}` },
         opts
       );
-      const price = res.Promotion?.PromotionPrice ?? res.UnitPrice;
+      const price2 = res.Promotion?.PromotionPrice ?? res.UnitPrice;
       const result = {
         domainName: res.DomainName ?? domainName,
         available: res.Status === "AvailableForRegistration"
       };
-      if (typeof price === "number" && Number.isFinite(price) && price > 0) {
-        result.price = price;
+      if (typeof price2 === "number" && Number.isFinite(price2) && price2 > 0) {
+        result.price = price2;
         result.currency = "USD";
       }
       results.push(result);
@@ -4419,7 +4419,10 @@ var NamecheapRegistrar = class extends BaseRegistrar {
   static configFields = [
     { name: "username", label: "Username", type: "text", required: true },
     { name: "apiKey", label: "API Key", type: "password", required: true },
-    { name: "clientIp", label: "Client IP", type: "text", required: false, default: "0.0.0.0" }
+    // Required: Namecheap rejects any request whose ClientIp isn't on the
+    // account's whitelist, so a placeholder like 0.0.0.0 only defers the
+    // failure to the first call. Make the user supply the whitelisted IP.
+    { name: "clientIp", label: "Client IP", type: "text", required: true }
   ];
   // Namecheap runs a sandbox at api.sandbox.namecheap.com (separate account at
   // sandbox.namecheap.com with its own API key)
@@ -4927,9 +4930,9 @@ function splitDomain(domain) {
   const dot = domain.indexOf(".");
   return dot === -1 ? { sld: domain, tld: "" } : { sld: domain.slice(0, dot), tld: domain.slice(dot + 1) };
 }
-function toPrice2(price) {
-  if (!price?.["@_Price"]) return void 0;
-  const n = Number(price["@_Price"]);
+function toPrice2(price2) {
+  if (!price2?.["@_Price"]) return void 0;
+  const n = Number(price2["@_Price"]);
   return Number.isFinite(n) ? n : void 0;
 }
 function fromNcContact(c) {
@@ -4968,6 +4971,501 @@ function toNcContactParams(prefix, c) {
   return params;
 }
 
+// src/registrars/namecom.ts
+var NamecomHttpClient = class extends HttpClient {
+  async request(req) {
+    try {
+      return await super.request(req);
+    } catch (error) {
+      if (error instanceof ParsingError) throw new ParsingError("namecom: invalid JSON response");
+      if (error instanceof ConnectionError)
+        throw new ConnectionError("namecom: network request failed");
+      throw error;
+    }
+  }
+  async toStatusError(response, url) {
+    await response.body?.cancel().catch(() => void 0);
+    const error = await super.toStatusError(
+      new Response(null, {
+        status: response.status,
+        headers: response.headers
+      }),
+      url
+    );
+    if (error instanceof RateLimitError) {
+      const retryAfter = response.headers.get("retry-after");
+      const seconds = retryAfter == null ? NaN : Number(retryAfter);
+      const date = retryAfter == null ? NaN : Date.parse(retryAfter);
+      const reset = response.headers.get("x-ratelimit-reset");
+      error.retryAfter = Number.isFinite(seconds) ? Math.max(0, seconds) : Number.isFinite(date) ? Math.max(0, (date - Date.now()) / 1e3) : reset != null && Number.isFinite(Number(reset)) ? Math.max(0, Number(reset) - Date.now() / 1e3) : void 0;
+    }
+    return error;
+  }
+};
+var NamecomRegistrar = class extends BaseRegistrar {
+  name = "namecom";
+  static displayName = "Name.com";
+  static website = "name.com";
+  static supportsSandbox = true;
+  static configFields = [
+    { name: "username", label: "Username", type: "text", required: true },
+    { name: "apiToken", label: "API token", type: "password", required: true }
+  ];
+  static helpText = "Get an API token at https://www.name.com/account/settings/api. Accounts with 2FA must enable API Access. Sandbox requires your -test username and a separate sandbox token; select the sandbox environment explicitly.";
+  static extendedFeatures = [Feature.GetAuthCode];
+  requiresNameserversFetch = false;
+  constructor(credentials, options) {
+    const username = credentials.username ?? "";
+    if (username.includes(":"))
+      throw new ConfigurationError("namecom: username cannot contain a colon");
+    const auth = btoa(
+      Array.from(
+        new TextEncoder().encode(`${username}:${credentials.apiToken ?? ""}`),
+        (byte) => String.fromCharCode(byte)
+      ).join("")
+    );
+    const config = {
+      baseUrl: selectBaseUrl("namecom", options?.environment, {
+        production: "https://api.name.com/core/v1",
+        sandbox: "https://api.dev.name.com/core/v1"
+      }),
+      headers: { Authorization: `Basic ${auth}` }
+    };
+    super(credentials, config, options);
+    this.http = new NamecomHttpClient({ ...config, options: this.options });
+  }
+  async testConnection(opts) {
+    try {
+      await this.http.request({ path: "/domains", query: { perPage: 1, 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 domains = await this.pages("/domains", "domains", requestOpts);
+    return filterDomains(
+      domains.map((d) => this.toDomain(d)),
+      search
+    );
+  }
+  async getDomain(domainName, opts) {
+    return this.toDomain(await this.rawDomain(domainName, opts));
+  }
+  async getNameservers(domainName, opts) {
+    return (await this.getDomain(domainName, opts)).nameservers;
+  }
+  async getAuthCode(domainName, opts) {
+    const result = await this.http.request({
+      path: `${domainPath(domainName)}:getAuthCode`,
+      ...opts
+    });
+    if (!result?.authCode) throw new InvalidResponseError("namecom: missing authorization code");
+    return result.authCode;
+  }
+  async checkAvailability(domainNames, opts) {
+    const results = [];
+    for (let i = 0; i < domainNames.length; i += 50) {
+      const res = await this.http.request({
+        method: "POST",
+        path: "/domains:checkAvailability",
+        body: {
+          domainNames: domainNames.slice(i, i + 50).map(normalizeDomain),
+          purchaseType: "registration"
+        },
+        ...opts
+      });
+      if (!Array.isArray(res?.results))
+        throw new InvalidResponseError("namecom: missing availability results");
+      results.push(
+        ...res.results.map((r) => ({
+          domainName: r.domainName,
+          available: (r.purchasable ?? false) && (!r.purchaseType || r.purchaseType === "registration"),
+          premium: r.premium ?? false,
+          price: price(r.purchasePrice),
+          currency: "USD"
+          // Discovery quotes the TLD's minimum term, which isn't always one year.
+        }))
+      );
+    }
+    return results;
+  }
+  async getPricing(tldOrDomain, opts) {
+    const name = normalizeDomain(tldOrDomain);
+    if (name.startsWith(".") || !name.includes(".")) {
+      const tld = name.replace(/^\./, "");
+      const entries = await this.pages("/tldpricing", "pricing", opts, {
+        tlds: tld,
+        duration: 1
+      });
+      const entry = entries.find((p) => p.tld.toLowerCase() === tld && p.duration === 1);
+      if (!entry) throw new NotFoundError(`namecom: no one-year pricing for .${tld}`);
+      return {
+        tld,
+        currency: "USD",
+        registration: price(entry.registrationPrice),
+        renewal: price(entry.renewalPrice),
+        transfer: price(entry.transferInPrice)
+      };
+    }
+    const result = await this.domainPricing(name, 1, opts);
+    return {
+      tld: name.slice(name.indexOf(".") + 1),
+      currency: "USD",
+      registration: price(result.purchasePrice),
+      renewal: price(result.renewalPrice),
+      transfer: price(result.transferPrice)
+    };
+  }
+  async registerDomain(domainName, input, opts) {
+    const years = validYears(input.years ?? 1);
+    if (!input.contacts.registrant)
+      throw new ConfigurationError("namecom: a registrant contact is required");
+    const contacts = toContacts(input.contacts);
+    const availability = (await this.checkAvailability([domainName], opts)).find(
+      (result) => normalizeDomain(result.domainName) === normalizeDomain(domainName)
+    );
+    if (!availability?.available)
+      return { success: false, message: "namecom: domain is not available for registration" };
+    const pricing = await this.domainPricing(domainName, years, opts);
+    const purchasePrice = purchaseQuote(pricing, "purchasePrice", availability.premium);
+    return this.purchase(
+      "/domains",
+      {
+        domain: {
+          domainName: normalizeDomain(domainName),
+          contacts,
+          nameservers: input.nameservers,
+          privacyEnabled: input.privacy,
+          autorenewEnabled: input.autoRenew
+        },
+        purchaseType: "registration",
+        years,
+        purchasePrice
+      },
+      domainName,
+      "registration",
+      opts
+    );
+  }
+  async renewDomain(domainName, years = 1, opts) {
+    validYears(years);
+    const pricing = await this.domainPricing(domainName, years, opts);
+    return this.purchase(
+      `${domainPath(domainName)}:renew`,
+      {
+        years,
+        purchasePrice: purchaseQuote(pricing, "renewalPrice")
+      },
+      domainName,
+      "renewal",
+      opts
+    );
+  }
+  async transferIn(domainName, input, opts) {
+    if (!input.authCode) throw new ConfigurationError("namecom: an authorization code is required");
+    if (input.years != null || input.contacts != null || input.autoRenew != null) {
+      throw new ConfigurationError(
+        "namecom: transferIn does not accept years, contacts or autoRenew; the registry determines the term"
+      );
+    }
+    const pricing = await this.domainPricing(domainName, void 0, opts);
+    return this.purchase(
+      "/transfers",
+      {
+        domainName: normalizeDomain(domainName),
+        authCode: input.authCode,
+        privacyEnabled: input.privacy,
+        purchasePrice: purchaseQuote(pricing, "transferPrice")
+      },
+      domainName,
+      "transfer",
+      opts
+    );
+  }
+  setAutoRenew(domainName, enabled, opts) {
+    return this.patchDomain(domainName, { autorenewEnabled: enabled }, opts);
+  }
+  lockDomain(domainName, opts) {
+    return this.patchDomain(domainName, { locked: true }, opts);
+  }
+  unlockDomain(domainName, opts) {
+    return this.patchDomain(domainName, { locked: false }, opts);
+  }
+  setPrivacy(domainName, enabled, opts) {
+    return this.patchDomain(domainName, { privacyEnabled: enabled }, opts);
+  }
+  updateNameservers(domainName, nameservers, opts) {
+    return this.mutate(
+      { method: "POST", path: `${domainPath(domainName)}:setNameservers`, body: { nameservers } },
+      opts
+    );
+  }
+  async getContacts(domainName, opts) {
+    const result = {};
+    const raw = await this.rawDomain(domainName, opts);
+    for (const role of CONTACT_ROLES) {
+      const c = raw.contacts?.[role];
+      if (c)
+        result[role] = {
+          firstName: c.firstName ?? "",
+          lastName: c.lastName ?? "",
+          organization: c.companyName ?? void 0,
+          email: c.email ?? "",
+          phone: c.phone ?? "",
+          fax: c.fax ?? void 0,
+          address1: c.address1 ?? "",
+          address2: c.address2 ?? void 0,
+          city: c.city ?? "",
+          state: c.state ?? void 0,
+          postalCode: c.zip ?? "",
+          country: c.country ?? ""
+        };
+    }
+    return result;
+  }
+  updateContacts(domainName, contacts, opts) {
+    return this.mutate(
+      {
+        method: "POST",
+        path: `${domainPath(domainName)}:setContacts`,
+        body: { contacts: toContacts(contacts) }
+      },
+      opts
+    );
+  }
+  async getDnsRecords(domainName, opts) {
+    return (await this.pages(`${domainPath(domainName)}/records`, "records", opts)).map(fromRecord);
+  }
+  // No bulk replace endpoint. Reconcile by id: preserve identical records, update
+  // existing type/host pairs, create additions, then delete stale records. This
+  // avoids duplicate-record errors and does not empty the zone before creation.
+  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 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");
+      const remaining = [...existing];
+      const pending = [];
+      for (const record of desired) {
+        const index = remaining.findIndex((r) => sameRecord(r, record));
+        if (index >= 0) remaining.splice(index, 1);
+        else if (!pending.some((r) => sameRecord(r, record))) pending.push(record);
+      }
+      for (const record of pending) {
+        const index = remaining.findIndex((r) => recordKey(r) === recordKey(record));
+        const old = index >= 0 ? remaining.splice(index, 1)[0] : void 0;
+        await this.http.request({
+          ...opts,
+          retries: 0,
+          method: old ? "PUT" : "POST",
+          path: old ? `${path}/${old.id}` : path,
+          body: record
+        });
+      }
+      for (const old of remaining) {
+        await this.http.request({
+          ...opts,
+          retries: 0,
+          method: "DELETE",
+          path: `${path}/${old.id}`
+        });
+      }
+      return { success: true, message: "DNS records updated successfully" };
+    } catch (error) {
+      return {
+        success: false,
+        message: `${toRegistrarError(error).message}. DNS replacement is not atomic; read the zone before retrying.`
+      };
+    }
+  }
+  patchDomain(domainName, body, opts) {
+    return this.mutate({ method: "PATCH", path: domainPath(domainName), body }, opts);
+  }
+  rawDomain(domainName, opts) {
+    return this.http.request({ path: domainPath(domainName), ...opts });
+  }
+  domainPricing(domainName, years, opts) {
+    return this.http.request({
+      path: `${domainPath(domainName)}:getPricing`,
+      query: { years },
+      ...opts
+    });
+  }
+  toDomain(d) {
+    if (!d?.domainName)
+      throw new InvalidResponseError("namecom: domain response missing domainName");
+    return createDomain({
+      domainName: normalizeDomain(d.domainName),
+      registrar: this.name,
+      // Core exposes locks, not a lifecycle status or a scheduled renewal date.
+      status: (d.locks ?? []).join(","),
+      createdDate: d.createDate,
+      expirationDate: d.expireDate,
+      autoRenew: d.autorenewEnabled ?? false,
+      locked: d.locked ?? false,
+      privacy: d.privacyEnabled ?? false,
+      nameservers: d.nameservers
+    });
+  }
+  async pages(path, key, opts, query) {
+    const result = [];
+    let page = 1;
+    while (true) {
+      const res = await this.http.request({
+        path,
+        query: { perPage: 1e3, page, ...query },
+        ...opts
+      });
+      const items = res?.[key];
+      if (!res || items != null && !Array.isArray(items))
+        throw new InvalidResponseError("namecom: invalid list response");
+      result.push(...items ?? []);
+      const next = res.nextPage;
+      if (next == null || next === 0) return result;
+      if (!Number.isInteger(next) || next <= page)
+        throw new InvalidResponseError("namecom: invalid pagination cursor");
+      page = next;
+    }
+  }
+  async mutate(req, opts) {
+    try {
+      await this.http.request({ ...req, ...opts, retries: 0 });
+      return { success: true, message: "Domain updated successfully" };
+    } catch (error) {
+      return { success: false, message: toRegistrarError(error).message };
+    }
+  }
+  async purchase(path, body, domainName, operation, opts) {
+    try {
+      const res = await this.http.request({
+        method: "POST",
+        path,
+        body,
+        ...opts,
+        retries: 0
+      });
+      const returnedName = res?.domain?.domainName ?? res?.transfer?.domainName;
+      if (!Number.isInteger(res?.order) || (res.order ?? 0) <= 0 || !returnedName || normalizeDomain(returnedName) !== normalizeDomain(domainName)) {
+        throw new InvalidResponseError(
+          "namecom: purchase response missing order or matching domain"
+        );
+      }
+      return {
+        success: true,
+        message: `Domain ${operation} request accepted (order ${res.order}); verify final domain/transfer status`
+      };
+    } catch (error) {
+      const e = toRegistrarError(error);
+      const uncertain = e.status < 0 || e.status === 408 || e.status >= 500 || e.name === "AbortError" || e instanceof ParsingError;
+      return {
+        success: false,
+        message: e.message + (uncertain ? ". Outcome unknown; check Name.com orders and domain/transfer status before retrying." : "")
+      };
+    }
+  }
+};
+var CONTACT_ROLES = ["registrant", "admin", "tech", "billing"];
+function toContacts(contacts) {
+  const result = {};
+  for (const role of CONTACT_ROLES) {
+    const c = contacts[role];
+    if (!c) continue;
+    const required = [
+      "firstName",
+      "lastName",
+      "email",
+      "phone",
+      "address1",
+      "city",
+      "state",
+      "postalCode",
+      "country"
+    ];
+    if (required.some((k) => !c[k]?.trim()))
+      throw new ConfigurationError(`namecom: ${role} must be a complete contact, including state`);
+    result[role] = {
+      firstName: c.firstName,
+      lastName: c.lastName,
+      companyName: c.organization,
+      email: c.email,
+      phone: c.phone.replace(".", ""),
+      fax: c.fax?.replace(".", ""),
+      address1: c.address1,
+      address2: c.address2,
+      city: c.city,
+      state: c.state,
+      zip: c.postalCode,
+      country: c.country.toUpperCase()
+    };
+  }
+  if (Object.keys(result).length === 0)
+    throw new ConfigurationError("namecom: at least one contact is required");
+  return result;
+}
+function domainPath(domainName) {
+  return `/domains/${encodeURIComponent(normalizeDomain(domainName))}`;
+}
+function validYears(years) {
+  if (!Number.isInteger(years) || years < 1 || years > 10)
+    throw new ConfigurationError("namecom: years must be an integer from 1 to 10");
+  return years;
+}
+function price(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function purchaseQuote(pricing, field, premium = false) {
+  const value = price(pricing?.[field]);
+  if (value == null)
+    throw new RegistrarError(
+      `namecom: ${field} unavailable for the requested term; no purchase submitted`
+    );
+  return premium || pricing.premium ? value : void 0;
+}
+var DNS_TYPES = /* @__PURE__ */ new Set(["A", "AAAA", "ANAME", "CNAME", "MX", "NS", "SRV", "TXT"]);
+function toRecord(r) {
+  const type = r.type.toUpperCase();
+  if (!DNS_TYPES.has(type))
+    throw new ConfigurationError(`namecom: DNS type ${type} is not supported`);
+  const ttl = r.ttl ?? 300;
+  if (!Number.isInteger(ttl) || ttl < 300)
+    throw new ConfigurationError("namecom: DNS TTL must be an integer of at least 300 seconds");
+  for (const value of [r.priority, r.weight, r.port]) {
+    if (value != null && (!Number.isInteger(value) || value < 0 || value > 65535))
+      throw new ConfigurationError("namecom: invalid DNS priority, weight or port");
+  }
+  if (!r.value.trim()) throw new ConfigurationError("namecom: DNS answer is required");
+  return {
+    type,
+    host: !r.name || r.name === "@" ? "" : r.name,
+    answer: type === "SRV" ? `${r.weight ?? 0} ${r.port ?? 0} ${r.value}` : r.value,
+    ttl,
+    ...["MX", "SRV"].includes(type) ? { priority: r.priority ?? 0 } : {}
+  };
+}
+function fromRecord(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;
+  if (type === "SRV") {
+    const match = /^(\d+)\s+(\d+)\s+(.+)$/.exec(r.answer);
+    if (!match) throw new InvalidResponseError("namecom: invalid SRV answer");
+    record.weight = Number(match[1]);
+    record.port = Number(match[2]);
+    record.value = match[3];
+  }
+  return record;
+}
+function recordKey(r) {
+  return `${r.type.toUpperCase()}\0${(r.host === "@" ? "" : r.host ?? "").toLowerCase()}`;
+}
+function sameRecord(a, b) {
+  return recordKey(a) === recordKey(b) && a.answer === b.answer && (a.ttl ?? 300) === (b.ttl ?? 300) && (a.priority ?? 0) === (b.priority ?? 0);
+}
+
 // src/registrars/namesilo.ts
 var NameSiloRegistrar = class extends BaseRegistrar {
   name = "namesilo";
@@ -5158,13 +5656,13 @@ var NameSiloRegistrar = class extends BaseRegistrar {
     if (!node || typeof node !== "object") {
       throw new NotFoundError(`NameSilo: no pricing found for TLD '${tld}'`);
     }
-    const price = node;
+    const price2 = node;
     return {
       tld,
       currency: "USD",
-      registration: toPrice3(price.registration),
-      renewal: toPrice3(price.renew),
-      transfer: toPrice3(price.transfer)
+      registration: toPrice3(price2.registration),
+      renewal: toPrice3(price2.renew),
+      transfer: toPrice3(price2.transfer)
     };
   }
   /**
@@ -5581,8 +6079,8 @@ function extractAvailEntries(group) {
       const premiumRaw = o.premium ?? o["@premium"] ?? o["@_premium"];
       const durationRaw = o.duration ?? o["@duration"] ?? o["@_duration"];
       const entry = { name };
-      const price = toPrice3(priceRaw);
-      if (price != null && price > 0) entry.price = price;
+      const price2 = toPrice3(priceRaw);
+      if (price2 != null && price2 > 0) entry.price = price2;
       if (premiumRaw != null && text(premiumRaw) !== "") entry.premium = isYes(premiumRaw);
       const duration = toPrice3(durationRaw);
       if (duration != null && duration > 0) entry.duration = duration;
@@ -5826,17 +6324,17 @@ var PorkbunRegistrar = class extends BaseRegistrar {
   async tldPricing(tld, opts) {
     const res = await this.call("/pricing/get", {}, opts);
     if (!isOk3(res)) throw new Error(res.message ?? "API request failed");
-    const price = res.pricing?.[tld];
-    if (!price) {
+    const price2 = res.pricing?.[tld];
+    if (!price2) {
       throw new NotFoundError(`${this.name}: no pricing found for TLD .${tld}`);
     }
     return {
       tld,
       currency: "USD",
       // Porkbun prices are always quoted in USD
-      registration: toPrice4(price.registration),
-      renewal: toPrice4(price.renewal),
-      transfer: toPrice4(price.transfer)
+      registration: toPrice4(price2.registration),
+      renewal: toPrice4(price2.renewal),
+      transfer: toPrice4(price2.transfer)
     };
   }
   /**
@@ -5876,14 +6374,14 @@ var PorkbunRegistrar = class extends BaseRegistrar {
       );
       if (!isOk3(res)) throw new Error(res.message ?? "API request failed");
       const info = res.response ?? {};
-      const price = toPrice4(info.price);
+      const price2 = toPrice4(info.price);
       results.push({
         domainName,
         available: info.avail === "yes",
         premium: info.premium === "yes",
-        price,
-        currency: price != null ? "USD" : void 0,
-        period: price != null ? 1 : void 0
+        price: price2,
+        currency: price2 != null ? "USD" : void 0,
+        period: price2 != null ? 1 : void 0
       });
     }
     return results;
@@ -6569,8 +7067,8 @@ var SpaceshipRegistrar = class extends BaseRegistrar {
           ...opts
         });
       }
-      const keep = new Set(items.map((r) => recordKey(r.type, r.name)));
-      const stale = existing.filter((r) => (r.group?.type ?? "custom") === "custom").filter((r) => !keep.has(recordKey(r.type, r.name))).map(({ group: _group, ...rr }) => rr);
+      const keep = new Set(items.map((r) => recordKey2(r.type, r.name)));
+      const stale = existing.filter((r) => (r.group?.type ?? "custom") === "custom").filter((r) => !keep.has(recordKey2(r.type, r.name))).map(({ group: _group, ...rr }) => rr);
       if (stale.length > 0) {
         await this.http.request({
           method: "DELETE",
@@ -6729,7 +7227,7 @@ function toSpaceshipRecord(r) {
   }
   return record;
 }
-function recordKey(type, name) {
+function recordKey2(type, name) {
   return `${(type ?? "").toUpperCase()}\0${name ?? "@"}`;
 }
 function fromSpaceshipContact(c) {
@@ -6773,6 +7271,7 @@ var registrars = {
   godaddy: GoDaddyRegistrar,
   namebright: NameBrightRegistrar,
   namecheap: NamecheapRegistrar,
+  namecom: NamecomRegistrar,
   namesilo: NameSiloRegistrar,
   porkbun: PorkbunRegistrar,
   spaceship: SpaceshipRegistrar
@@ -6804,6 +7303,7 @@ exports.MASKED_FORWARD_UNSUPPORTED = MASKED_FORWARD_UNSUPPORTED;
 exports.NameBrightRegistrar = NameBrightRegistrar;
 exports.NameSiloRegistrar = NameSiloRegistrar;
 exports.NamecheapRegistrar = NamecheapRegistrar;
+exports.NamecomRegistrar = NamecomRegistrar;
 exports.NotFoundError = NotFoundError;
 exports.NotImplementedError = NotImplementedError;
 exports.ParsingError = ParsingError;