@aoxborrow/registrar-client 0.5.0 → 0.7.0

package/dist/index.js

@@ -55,11 +55,61 @@ var TimeoutError = class extends RetryableRegistrarError {
 var ConnectionError = class extends RetryableRegistrarError {
   status = 503;
   // Service Unavailable
-  constructor(message) {
+  // true when the failure is known to have happened before the request left:
+  // DNS, connection refused, TLS handshake, or a proxy that never opened its
+  // tunnel. The registrar cannot have acted on it, so it is safe to re-send
+  // even for a write.
+  notSent;
+  constructor(message, details = {}) {
     super(message);
     this.name = "ConnectionError";
+    this.notSent = details.notSent ?? false;
+  }
+};
+var OutcomeUnknownError = class extends RegistrarError {
+  status = 504;
+  // Gateway Timeout
+  feature;
+  cause;
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "OutcomeUnknownError";
+    this.feature = details.feature;
+    this.cause = details.cause;
   }
 };
+var NOT_SENT = /* @__PURE__ */ Symbol.for("registrar-client.notSent");
+function markNotSent(error) {
+  if (typeof error === "object" && error !== null) {
+    Object.defineProperty(error, NOT_SENT, { value: true, enumerable: false });
+  }
+  return error;
+}
+var PRE_SEND_CODES = /* @__PURE__ */ new Set([
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ECONNREFUSED",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "EADDRNOTAVAIL",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "CERT_HAS_EXPIRED",
+  "CERT_NOT_YET_VALID",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+  "ERR_TLS_CERT_ALTNAME_INVALID"
+]);
+function wasNotSent(error) {
+  for (let e = error, depth = 0; e && typeof e === "object" && depth < 5; depth++) {
+    if (e[NOT_SENT] === true) return true;
+    const code = e.code;
+    if (typeof code === "string" && PRE_SEND_CODES.has(code)) return true;
+    e = e.cause;
+  }
+  return false;
+}
 var AuthenticationError = class extends RegistrarError {
   status = 401;
   // Unauthorized
@@ -226,6 +276,9 @@ function createDomain(data = {}) {
     deleted: data.deleted ?? false
   };
 }
+function asRead(opts) {
+  return { ...opts, call: { ...opts?.call, intent: "read" } };
+}
 
 // src/client.ts
 var RegistrarClient = class {
@@ -376,6 +429,7 @@ var DEFAULT_OPTIONS = {
 var USER_AGENT = "@aoxborrow/registrar-client";
 
 // src/http.ts
+var REST_SAFE_METHODS = ["GET", "HEAD"];
 var HttpClient = class {
   constructor(config) {
     this.config = config;
@@ -399,7 +453,20 @@ var HttpClient = class {
   async requestText(req) {
     return this.withRetries(req, () => this.send(req));
   }
-  // shared retry-with-backoff wrapper around a single-attempt operation
+  // Shared retry-with-backoff wrapper around a single-attempt operation.
+  //
+  // What may be re-sent depends on where the failure happened and on whether
+  // the call reads or writes:
+  //
+  //   failure                                        read    write
+  //   never sent (DNS, refused, TLS, proxy stage)    retry   retry
+  //   429                                            retry   retry
+  //   unknown (timeout, dropped mid-response, 5xx)   retry   OutcomeUnknownError
+  //   any other response                             fail    fail
+  //
+  // A write whose outcome is unknown may have been applied, so it is never
+  // re-sent: a second renewal charges twice, a second record-create leaves a
+  // duplicate. The caller re-reads the domain instead.
   async withRetries(req, attemptFn) {
     const retries = req.retries ?? this.config.options.retries;
     const backoff = req.backoff ?? this.config.options.backoff;
@@ -409,6 +476,14 @@ var HttpClient = class {
         return await attemptFn();
       } catch (error) {
         lastError = toRegistrarError(error);
+        if (this.intentOf(req) === "write" && isOutcomeUnknown(lastError)) {
+          const unknown = new OutcomeUnknownError(
+            `The registrar did not confirm this change, so it may or may not have been applied. Check the domain before trying again. (${lastError.message})`,
+            { feature: req.call?.feature, cause: lastError }
+          );
+          if (req.call) req.call.outcomeUnknown = unknown;
+          throw unknown;
+        }
         if (attempt >= retries || !lastError.shouldRetry()) {
           throw lastError;
         }
@@ -418,6 +493,14 @@ var HttpClient = class {
     }
     throw lastError ?? new RegistrarError("Request failed");
   }
+  // Whether a request only reads. A method the API reserves for reads wins;
+  // otherwise it is whatever the feature being served is, and a request that
+  // says nothing is assumed to write.
+  intentOf(req) {
+    const method = (req.method ?? "GET").toUpperCase();
+    if (this.config.safeMethods?.includes(method)) return "read";
+    return req.call?.intent ?? "write";
+  }
   // build the full URL for a request, applying query parameters
   buildUrl(req) {
     let base;
@@ -460,7 +543,8 @@ var HttpClient = class {
     try {
       let response;
       try {
-        response = await fetch(url, {
+        const doFetch = req.fetch ?? this.config.options.fetch ?? fetch;
+        response = await doFetch(url, {
           method: req.method ?? "GET",
           headers,
           body: req.body !== void 0 ? JSON.stringify(req.body) : void 0,
@@ -471,7 +555,9 @@ var HttpClient = class {
           if (externalSignal?.aborted) throw new AbortError("Request was aborted");
           throw new TimeoutError(`Request to '${url}' timed out after ${timeout}ms`);
         }
-        throw new ConnectionError(`Failed to reach '${url}': ${errorMessage(error)}`);
+        throw new ConnectionError(`Failed to reach '${url}': ${errorMessage(error)}`, {
+          notSent: wasNotSent(error)
+        });
       }
       if (!response.ok) {
         throw await this.toStatusError(response, url);
@@ -479,7 +565,17 @@ var HttpClient = class {
       if (response.status === 204) {
         return "";
       }
-      return await response.text();
+      try {
+        return await response.text();
+      } catch (error) {
+        if (isAbortError(error)) {
+          if (externalSignal?.aborted) throw new AbortError("Request was aborted");
+          throw new TimeoutError(`Response from '${url}' timed out after ${timeout}ms`);
+        }
+        throw new ConnectionError(
+          `Connection to '${url}' was lost while reading the response: ${errorMessage(error)}`
+        );
+      }
     } finally {
       clearTimeout(timeoutId);
       externalSignal?.removeEventListener("abort", onAbort);
@@ -515,6 +611,10 @@ var HttpClient = class {
     }
   }
 };
+function isOutcomeUnknown(error) {
+  if (error instanceof TimeoutError || error instanceof InvalidResponseError) return true;
+  return error instanceof ConnectionError && !error.notSent;
+}
 function isAbortError(error) {
   return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
 }
@@ -611,6 +711,33 @@ var CORE_FEATURE_SET = new Set(CORE_FEATURES);
 function isCoreFeature(feature) {
   return CORE_FEATURE_SET.has(feature);
 }
+var FEATURE_CALLS = {
+  testConnection: { intent: "read", optsIndex: 0 },
+  listDomains: { intent: "read", optsIndex: 0 },
+  getDomain: { intent: "read", optsIndex: 1 },
+  checkAvailability: { intent: "read", optsIndex: 1 },
+  getPricing: { intent: "read", optsIndex: 1 },
+  registerDomain: { intent: "write", optsIndex: 2 },
+  renewDomain: { intent: "write", optsIndex: 2 },
+  setAutoRenew: { intent: "write", optsIndex: 2 },
+  transferIn: { intent: "write", optsIndex: 2 },
+  updateNameservers: { intent: "write", optsIndex: 2 },
+  getNameservers: { intent: "read", optsIndex: 1 },
+  lockDomain: { intent: "write", optsIndex: 1 },
+  unlockDomain: { intent: "write", optsIndex: 1 },
+  setPrivacy: { intent: "write", optsIndex: 2 },
+  getContacts: { intent: "read", optsIndex: 1 },
+  updateContacts: { intent: "write", optsIndex: 2 },
+  getDnsRecords: { intent: "read", optsIndex: 1 },
+  setDnsRecords: { intent: "write", optsIndex: 2 },
+  getAuthCode: { intent: "write", optsIndex: 1 },
+  getDnssec: { intent: "read", optsIndex: 1 },
+  disableDnssec: { intent: "write", optsIndex: 1 },
+  getEmailForwarding: { intent: "read", optsIndex: 1 },
+  setEmailForwarding: { intent: "write", optsIndex: 2 },
+  getDomainForwarding: { intent: "read", optsIndex: 1 },
+  setDomainForwarding: { intent: "write", optsIndex: 2 }
+};
 
 // src/registrar.ts
 function selectBaseUrl(registrar, environment, urls) {
@@ -636,6 +763,9 @@ var BaseRegistrar = class {
   static get features() {
     return [...CORE_FEATURES, ...this.extendedFeatures];
   }
+  // HTTP methods this provider's API reserves for reads; see
+  // `HttpClientConfig.safeMethods`. REST providers set `REST_SAFE_METHODS`.
+  static safeMethods = [];
   // instance mirror of the static `features`
   get features() {
     return this.constructor.features;
@@ -654,7 +784,39 @@ var BaseRegistrar = class {
     this.credentials = credentials;
     this.environment = environment;
     this.options = { ...DEFAULT_OPTIONS, ...clientOptions };
-    this.http = new HttpClient({ ...httpConfig, options: this.options });
+    this.http = new HttpClient({
+      safeMethods: this.constructor.safeMethods,
+      ...httpConfig,
+      options: this.options
+    });
+    this.threadFeatureCalls();
+  }
+  // Wrap each feature method so its `RequestOptions` carry a `FeatureCall`:
+  // the read/write intent the HTTP layer needs to decide what may be re-sent,
+  // and a slot where it reports a write whose outcome is unknown. Providers
+  // already forward their options into every request, so nothing else changes.
+  //
+  // A feature calling another feature (a write re-reading the domain, say)
+  // goes through that feature's own wrapper, so the inner read is still a read.
+  // Providers fold most failures into an `OperationResult`; the unknown outcome
+  // is copied onto that result so it is not lost along with the error.
+  threadFeatureCalls() {
+    const self = this;
+    for (const [feature, { intent, optsIndex }] of Object.entries(FEATURE_CALLS)) {
+      const original = self[feature];
+      if (typeof original !== "function") continue;
+      self[feature] = (...args) => {
+        const call = { intent, feature };
+        const next = [...args];
+        while (next.length <= optsIndex) next.push(void 0);
+        next[optsIndex] = { ...next[optsIndex], call };
+        const result = original.apply(this, next);
+        if (!(result instanceof Promise)) return result;
+        return result.then(
+          (value) => call.outcomeUnknown && value !== null && typeof value === "object" && value.success === false ? { ...value, outcome: "unknown" } : value
+        );
+      };
+    }
   }
   testConnection(_opts) {
     return Promise.reject(
@@ -745,6 +907,8 @@ var BaseRegistrar = class {
 // src/registrars/cloudflare.ts
 var CloudflareRegistrar = class _CloudflareRegistrar extends BaseRegistrar {
   name = "cloudflare";
+  // a REST API: GET and HEAD never change state
+  static safeMethods = REST_SAFE_METHODS;
   static displayName = "Cloudflare";
   static website = "cloudflare.com";
   static helpText = 'Create an API token in your Cloudflare dashboard under My Profile > API Tokens. The token needs "Account.Registrar" read/write permissions. Find your Account ID in the URL or on the Overview page of any zone.';
@@ -1026,8 +1190,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;
     });
@@ -1602,6 +1766,8 @@ var SEARCH_BATCH_SIZE = 100;
 var SUPPORTED_DNS_TYPES = /* @__PURE__ */ new Set(["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SRV", "CAA"]);
 var DynadotRegistrar = class extends BaseRegistrar {
   name = "dynadot";
+  // a REST API: GET and HEAD never change state
+  static safeMethods = REST_SAFE_METHODS;
   static displayName = "Dynadot";
   static website = "dynadot.com";
   static helpText = "Under Tools > API in your Dynadot account, generate an API Key and API Secret. The account must be unlocked with API access enabled. The key identifies you; the secret signs requests (X-Signature) and is never sent directly.";
@@ -1789,14 +1955,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
         });
       }
     }
@@ -1833,13 +1999,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
     };
   }
   /**
@@ -2353,6 +2519,8 @@ var GANDI_TYPE_TO_FORWARD = {
 };
 var GandiRegistrar = class extends BaseRegistrar {
   name = "gandi";
+  // a REST API: GET and HEAD never change state
+  static safeMethods = REST_SAFE_METHODS;
   static displayName = "Gandi.net";
   static website = "gandi.net";
   static helpText = "Generate a Personal Access Token (PAT) in your Gandi account under Account Settings > Security. The token needs permission to manage domains. (Gandi has deprecated the legacy API Key; use a PAT.)";
@@ -2555,17 +2723,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);
     }
@@ -3003,9 +3171,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) {
@@ -3040,6 +3208,8 @@ var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var PRICE_MICRO_UNITS = 1e6;
 var GoDaddyRegistrar = class _GoDaddyRegistrar extends BaseRegistrar {
   name = "godaddy";
+  // a REST API: GET and HEAD never change state
+  static safeMethods = REST_SAFE_METHODS;
   static displayName = "GoDaddy";
   static website = "godaddy.com";
   static helpText = "Create a Personal Access Token (PAT) at https://developer.godaddy.com and paste it here. The PAT is GoDaddy's modern credential: it unlocks the v3 API (discovery, registration, DNS, nameservers) and also authenticates the legacy v1 API for management operations (renew, transfer, auto-renew, lock, privacy, contacts) \u2014 one token covers everything.";
@@ -3920,6 +4090,8 @@ function dnsFieldsDiffer(a, b) {
 var TOKEN_URL = "https://api.namebright.com/auth/token";
 var NameBrightRegistrar = class extends BaseRegistrar {
   name = "namebright";
+  // a REST API: GET and HEAD never change state
+  static safeMethods = REST_SAFE_METHODS;
   static displayName = "NameBright";
   static website = "namebright.com";
   static helpText = 'API access is not enabled by default \u2014 you must request it from NameBright (contact support / your account manager) before the API Management page is available. Once enabled, create an API Application under my.namebright.com > My Account > API Management. The Client ID is "<accountName>:<applicationName>"; NameBright issues the Client Secret. Note the application also enforces an IP whitelist.';
@@ -3958,7 +4130,8 @@ var NameBrightRegistrar = class extends BaseRegistrar {
         client_id: this.credentials.clientId,
         client_secret: this.credentials.clientSecret
       },
-      ...opts
+      // issuing a token changes nothing on the account, whatever it precedes
+      ...asRead(opts)
     });
     if (!res.access_token) {
       throw new AuthenticationError("NameBright: token endpoint returned no access_token");
@@ -4089,13 +4262,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);
@@ -4737,7 +4910,11 @@ var NamecheapRegistrar = class extends BaseRegistrar {
    * has no WhoisGuard allotted (e.g. TLDs that don't offer it).
    */
   async setPrivacy(domainName, enabled, opts) {
-    const cr = await this.command("namecheap.domains.getInfo", { DomainName: domainName }, opts);
+    const cr = await this.command(
+      "namecheap.domains.getInfo",
+      { DomainName: domainName },
+      asRead(opts)
+    );
     const id = cr.DomainGetInfoResult?.Whoisguard?.ID;
     if (id == null || String(id) === "0") {
       throw new Error(`${this.name}: ${domainName} has no WhoisGuard subscription to toggle`);
@@ -4928,9 +5105,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) {
@@ -4969,6 +5146,505 @@ 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", { notSent: error.notSent });
+      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";
+  // a REST API: GET and HEAD never change state
+  static safeMethods = REST_SAFE_METHODS;
+  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,
+      safeMethods: REST_SAFE_METHODS,
+      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,
+          method: old ? "PUT" : "POST",
+          path: old ? `${path}/${old.id}` : path,
+          body: record
+        });
+      }
+      for (const old of remaining) {
+        await this.http.request({
+          ...opts,
+          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 });
+      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";
@@ -5159,13 +5835,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)
     };
   }
   /**
@@ -5249,7 +5925,7 @@ var NameSiloRegistrar = class extends BaseRegistrar {
    */
   async disableDnssec(domainName, opts) {
     try {
-      const res = await this.call("dnsSecListRecords", { domain: domainName }, opts);
+      const res = await this.call("dnsSecListRecords", { domain: domainName }, asRead(opts));
       if (!replyOk(res)) return statusResult2(res);
       for (const d of ensureArray(res.reply?.ds_record)) {
         const del = await this.call(
@@ -5322,7 +5998,7 @@ var NameSiloRegistrar = class extends BaseRegistrar {
         desired.set(f.alias, list);
       }
       const currentAliases = new Set(
-        (await this.listEmailForwards(domainName, opts)).map((r) => r.alias).filter(Boolean)
+        (await this.listEmailForwards(domainName, asRead(opts))).map((r) => r.alias).filter(Boolean)
       );
       for (const alias of currentAliases) {
         if (!desired.has(alias)) {
@@ -5413,7 +6089,7 @@ var NameSiloRegistrar = class extends BaseRegistrar {
    * delegation nameservers aren't part of this list (see `updateNameservers`).
    */
   async setDnsRecords(domainName, records, opts) {
-    const listRes = await this.call("dnsListRecords", { domain: domainName }, opts);
+    const listRes = await this.call("dnsListRecords", { domain: domainName }, asRead(opts));
     if (!replyOk(listRes)) return { success: false, message: replyDetail(listRes) };
     const existing = ensureArray(listRes.reply?.resource_record);
     const existingByKey = /* @__PURE__ */ new Map();
@@ -5582,8 +6258,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;
@@ -5827,17 +6503,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)
     };
   }
   /**
@@ -5877,14 +6553,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;
@@ -5940,7 +6616,7 @@ var PorkbunRegistrar = class extends BaseRegistrar {
    * renewals aren't supported via the API.
    */
   async renewDomain(domainName, _years = 1, opts) {
-    const pricing = await this.tldPricing(extractTld(domainName), opts);
+    const pricing = await this.tldPricing(extractTld(domainName), asRead(opts));
     if (pricing.renewal == null) {
       throw new Error(`${this.name}: could not determine the renewal price for ${domainName}`);
     }
@@ -5971,7 +6647,7 @@ var PorkbunRegistrar = class extends BaseRegistrar {
    * aren't supported via the API.
    */
   async transferIn(domainName, input, opts) {
-    const pricing = await this.tldPricing(extractTld(domainName), opts);
+    const pricing = await this.tldPricing(extractTld(domainName), asRead(opts));
     if (pricing.transfer == null) {
       throw new Error(`${this.name}: could not determine the transfer price for ${domainName}`);
     }
@@ -6264,6 +6940,8 @@ function toDnsRecord3(r, domainName) {
 var WRITABLE_DNS_TYPES = /* @__PURE__ */ new Set(["A", "AAAA", "CNAME", "NS", "TXT", "MX"]);
 var SpaceshipRegistrar = class extends BaseRegistrar {
   name = "spaceship";
+  // a REST API: GET and HEAD never change state
+  static safeMethods = REST_SAFE_METHODS;
   static displayName = "Spaceship";
   static website = "spaceship.com";
   static helpText = 'Generate your API key and secret in the API Manager at Spaceship using the "New API key" button. The API requires both X-API-Key and X-API-Secret headers.';
@@ -6570,8 +7248,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",
@@ -6730,7 +7408,7 @@ function toSpaceshipRecord(r) {
   }
   return record;
 }
-function recordKey(type, name) {
+function recordKey2(type, name) {
   return `${(type ?? "").toUpperCase()}\0${name ?? "@"}`;
 }
 function fromSpaceshipContact(c) {
@@ -6774,6 +7452,7 @@ var registrars = {
   godaddy: GoDaddyRegistrar,
   namebright: NameBrightRegistrar,
   namecheap: NamecheapRegistrar,
+  namecom: NamecomRegistrar,
   namesilo: NameSiloRegistrar,
   porkbun: PorkbunRegistrar,
   spaceship: SpaceshipRegistrar
@@ -6783,6 +7462,6 @@ function createRegistrar(name, credentials, options) {
   return new RegistrarClass(credentials, options);
 }
 
-export { ALL_FEATURES, AbortError, AuthenticationError, AuthorizationError, BaseRegistrar, CORE_FEATURES, CloudflareRegistrar, ConfigurationError, ConnectionError, ConsentRequiredError, DEFAULT_OPTIONS, DynadotRegistrar, EXTENDED_FEATURES, Feature, GandiRegistrar, GoDaddyRegistrar, HttpClient, InvalidResponseError, MASKED_FORWARD_UNSUPPORTED, NameBrightRegistrar, NameSiloRegistrar, NamecheapRegistrar, NotFoundError, NotImplementedError, ParsingError, PorkbunRegistrar, RateLimitError, RegistrarClient, RegistrarError, RetryableRegistrarError, SpaceshipRegistrar, TimeoutError, USER_AGENT, backoffDelay, createDomain, createRegistrar, ensureArray, filterDomains, isCoreFeature, listPortfolio, normalizeDomain, normalizeNameservers, parseDate, parseXml, registrars, requireConsent, selectBaseUrl, settableForwards, sleep, toRegistrarError };
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map