@aoxborrow/registrar-client 0.6.0 → 0.8.0

package/README.md

@@ -387,9 +387,9 @@ a provider-specific workflow. Transfers accept `authCode` and optional `privacy`
 explicit `years`, `contacts` or `autoRenew` are rejected before submission because
 Core cannot apply them in its transfer request. Update settings after completion.
 
-Every mutation disables automatic retries, including per-request retry overrides.
-Transport/parse failures after a purchase report an unknown outcome: inspect
-Name.com orders and domain/transfer status before retrying. An accepted order is
+Mutations follow the shared [retry rules](#retries): a request Name.com may have
+received is never re-sent. Transport/parse failures after a purchase report an
+unknown outcome: inspect Name.com orders and domain/transfer status before retrying. An accepted order is
 reported as accepted, not proof of final registry completion. Read operations
 retain the shared retry policy and honor `Retry-After` / `X-RateLimit-Reset`.
 HTTP errors retain typed status information but omit provider response bodies,
@@ -482,8 +482,12 @@ implementations**:
 Extend `BaseRegistrar`, pass a `baseUrl` + auth headers to `super()`, add the
 static `displayName` / `configFields` / `helpText` metadata, override the
 operations the API supports (mapping payloads to the shared types in
-`src/types.ts`), and add the class to `src/registrars/index.ts`. The existing
-providers under `src/registrars/` are working references.
+`src/types.ts`), and add the class to `src/registrars/index.ts`. Forward the
+`opts` you are given into every `this.http` request: they carry the timeout and
+signal, and tell the [retry rules](#retries) whether the call reads or writes.
+For a REST API set `static safeMethods = REST_SAFE_METHODS`; otherwise wrap any
+lookup a write performs first in `asRead(opts)`. The existing providers under
+`src/registrars/` are working references.
 
 **New providers are welcome** — if you've wired up a registrar, open a PR.
 
@@ -493,6 +497,67 @@ All failures throw a typed subclass of `RegistrarError` (`AuthenticationError`,
 `NotFoundError`, `RateLimitError`, `TimeoutError`, `NotImplementedError`, …),
 each carrying an HTTP-style `status`.
 
+## Retries
+
+Requests retry with exponential backoff (`retries`, default 2). What may be
+re-sent depends on where the failure happened and on whether the call reads or
+writes, and is the same for every provider:
+
+HTTP 429 honors valid `Retry-After` delay-seconds and HTTP dates. Missing or
+invalid headers use the provider's fallback or the configured backoff: Dynadot
+waits a conservative 60 seconds, and Name.com waits until its
+`X-RateLimit-Reset` time. An explicit zero or past date remains
+an immediate retry instruction from the server.
+
+| Failure                                                                    | Read  | Write                                  |
+| -------------------------------------------------------------------------- | ----- | -------------------------------------- |
+| The registrar never saw it: DNS failure, connection refused, TLS handshake | Retry | Retry                                  |
+| `429`, honoring `Retry-After`                                              | Retry | Retry                                  |
+| Outcome unknown: timeout, connection dropped mid-response, `5xx`           | Retry | **Not re-sent.** `OutcomeUnknownError` |
+| Any other response                                                         | Fail  | Fail                                   |
+
+Reads and writes are told apart by feature, not by HTTP method (`FEATURE_CALLS`
+lists every one). The method is no guide: Namecheap sends writes as `GET`, and
+Porkbun sends reads as `POST`. `getAuthCode` counts as a write because some
+registrars regenerate the code.
+
+A write often reads first: current DNS records, a price, a zone id. Those
+lookups changed nothing, so they are retried like any read and never reported as
+an unknown outcome. REST providers get this from the HTTP method
+(`static safeMethods = REST_SAFE_METHODS` treats `GET` and `HEAD` as reads);
+providers whose method means nothing wrap the lookup's options in `asRead(opts)`.
+
+A write whose outcome is unknown may have been applied, and a second renewal
+charges twice. So the library reports it and leaves the decision to you: re-read
+the domain, then retry if nothing changed. Providers that throw raise
+`OutcomeUnknownError`; providers that return an `OperationResult` set
+`outcome: 'unknown'` on it:
+
+```ts
+const result = await client.renewDomain('example.com', 1);
+if (!result.success && result.outcome === 'unknown') {
+  const domain = await client.getDomain('example.com'); // did it go through?
+}
+```
+
+Only positive evidence counts as "never sent": a pre-connection error code from
+Node's `fetch`, or an error a custom transport marked with `markNotSent`.
+Browsers and Workers report network failures opaquely, so there they count as
+unknown.
+
+### Custom transport
+
+Pass `fetch` to route every request through your own transport, such as a
+proxy:
+
+```ts
+const registrar = createRegistrar('namecheap', credentials, { fetch: proxiedFetch });
+```
+
+If the transport can fail before the request leaves, for instance a proxy that
+refuses the tunnel, throw `markNotSent(error)` so the failure is retried even
+for writes.
+
 ## Security
 
 Credentials are sent as request **headers** wherever the registrar's API

package/dist/index.cjs

@@ -57,11 +57,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
@@ -228,6 +278,9 @@ function createDomain(data = {}) {
     deleted: data.deleted ?? false
   };
 }
+function asRead(opts) {
+  return { ...opts, call: { ...opts?.call, intent: "read" } };
+}
 
 // src/client.ts
 var RegistrarClient = class {
@@ -378,6 +431,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;
@@ -401,7 +455,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;
@@ -411,6 +478,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;
         }
@@ -420,6 +495,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;
@@ -462,7 +545,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,
@@ -473,7 +557,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);
@@ -481,7 +567,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);
@@ -503,8 +599,8 @@ var HttpClient = class {
       case 404:
         return new NotFoundError(message);
       case 429: {
-        const retryAfter = Number(response.headers.get("retry-after"));
-        return new RateLimitError(message, Number.isFinite(retryAfter) ? retryAfter : void 0);
+        const retryAfter = parseRetryAfter(response.headers.get("retry-after")) ?? this.config.rateLimitFallbackSeconds;
+        return new RateLimitError(message, retryAfter);
       }
       default: {
         if (response.status >= 500) {
@@ -517,6 +613,23 @@ var HttpClient = class {
     }
   }
 };
+function parseRetryAfter(value) {
+  const text2 = value?.trim();
+  if (!text2) return void 0;
+  if (/^\d+$/.test(text2)) {
+    const seconds = Number(text2);
+    return Number.isSafeInteger(seconds) ? seconds : void 0;
+  }
+  const zonedDate = /^(?:[a-z]{3}, \d{2} [a-z]{3} \d{4}|[a-z]+, \d{2}-[a-z]{3}-\d{2}) \d{2}:\d{2}:\d{2} GMT$/i;
+  const asctimeDate = /^[a-z]{3} [a-z]{3} (?: \d|\d{2}) \d{2}:\d{2}:\d{2} \d{4}$/i;
+  if (!zonedDate.test(text2) && !asctimeDate.test(text2)) return void 0;
+  const date = Date.parse(asctimeDate.test(text2) ? `${text2} GMT` : text2);
+  return Number.isFinite(date) ? Math.max(0, Math.ceil((date - Date.now()) / 1e3)) : void 0;
+}
+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";
 }
@@ -613,6 +726,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) {
@@ -638,6 +778,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;
@@ -656,7 +799,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(
@@ -747,6 +922,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.';
@@ -1604,6 +1781,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.";
@@ -1634,7 +1813,10 @@ var DynadotRegistrar = class extends BaseRegistrar {
           production: "https://api.dynadot.com",
           sandbox: "https://api-sandbox.dynadot.com"
         }),
-        headers: { Authorization: `Bearer ${credentials.apiKey}` }
+        headers: { Authorization: `Bearer ${credentials.apiKey}` },
+        // HTTP 429 can omit Retry-After. Avoid exhausting all attempts inside
+        // Dynadot's regular-tier minute window in that case.
+        rateLimitFallbackSeconds: 60
       },
       options
     );
@@ -2355,6 +2537,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.)";
@@ -3042,6 +3226,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.";
@@ -3922,6 +4108,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.';
@@ -3960,7 +4148,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");
@@ -4568,9 +4757,10 @@ var NamecheapRegistrar = class extends BaseRegistrar {
   }
   /**
    * Availability via domains.check (batched at 50 per request, Namecheap's cap).
-   * The check response only carries a price for *premium* names
-   * (`PremiumRegistrationPrice`); regular registration pricing comes from
-   * `getPricing`, so `price` is set only for premium results.
+   * The check response only carries prices for *premium* names
+   * (`PremiumRegistrationPrice`, `PremiumRenewalPrice`); regular pricing comes
+   * from `getPricing`, so `price` and `renewalPrice` are set only for premium
+   * results.
    */
   async checkAvailability(domainNames, opts) {
     const results = [];
@@ -4583,12 +4773,16 @@ var NamecheapRegistrar = class extends BaseRegistrar {
       );
       for (const el of ensureArray(cr.DomainCheckResult)) {
         const premium = el["@_IsPremiumName"] === "true";
-        const premiumPrice = premium ? Number(el["@_PremiumRegistrationPrice"]) : NaN;
+        const premiumPrice = (attr) => {
+          const n = premium ? Number(attr) : NaN;
+          return Number.isFinite(n) && n > 0 ? n : void 0;
+        };
         results.push({
           domainName: el["@_Domain"] ?? "",
           available: el["@_Available"] === "true",
           premium,
-          price: Number.isFinite(premiumPrice) && premiumPrice > 0 ? premiumPrice : void 0
+          price: premiumPrice(el["@_PremiumRegistrationPrice"]),
+          renewalPrice: premiumPrice(el["@_PremiumRenewalPrice"])
         });
       }
     }
@@ -4739,7 +4933,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`);
@@ -4979,7 +5177,7 @@ var NamecomHttpClient = class extends HttpClient {
     } 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 new ConnectionError("namecom: network request failed", { notSent: error.notSent });
       throw error;
     }
   }
@@ -4992,18 +5190,19 @@ var NamecomHttpClient = class extends HttpClient {
       }),
       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;
+    if (error instanceof RateLimitError && error.retryAfter === void 0) {
+      const reset = response.headers.get("x-ratelimit-reset")?.trim();
+      if (reset && /^\d+(?:\.\d+)?$/.test(reset)) {
+        error.retryAfter = Math.max(0, Math.ceil(Number(reset) - Date.now() / 1e3));
+      }
     }
     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;
@@ -5032,7 +5231,11 @@ var NamecomRegistrar = class extends BaseRegistrar {
       headers: { Authorization: `Basic ${auth}` }
     };
     super(credentials, config, options);
-    this.http = new NamecomHttpClient({ ...config, options: this.options });
+    this.http = new NamecomHttpClient({
+      ...config,
+      safeMethods: REST_SAFE_METHODS,
+      options: this.options
+    });
   }
   async testConnection(opts) {
     try {
@@ -5260,7 +5463,6 @@ var NamecomRegistrar = class extends BaseRegistrar {
         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
@@ -5269,7 +5471,6 @@ var NamecomRegistrar = class extends BaseRegistrar {
       for (const old of remaining) {
         await this.http.request({
           ...opts,
-          retries: 0,
           method: "DELETE",
           path: `${path}/${old.id}`
         });
@@ -5333,7 +5534,7 @@ var NamecomRegistrar = class extends BaseRegistrar {
   }
   async mutate(req, opts) {
     try {
-      await this.http.request({ ...req, ...opts, retries: 0 });
+      await this.http.request({ ...req, ...opts });
       return { success: true, message: "Domain updated successfully" };
     } catch (error) {
       return { success: false, message: toRegistrarError(error).message };
@@ -5746,7 +5947,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(
@@ -5819,7 +6020,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)) {
@@ -5910,7 +6111,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();
@@ -6437,7 +6638,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}`);
     }
@@ -6468,7 +6669,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}`);
     }
@@ -6761,6 +6962,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.';
@@ -7294,6 +7497,7 @@ exports.ConsentRequiredError = ConsentRequiredError;
 exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
 exports.DynadotRegistrar = DynadotRegistrar;
 exports.EXTENDED_FEATURES = EXTENDED_FEATURES;
+exports.FEATURE_CALLS = FEATURE_CALLS;
 exports.Feature = Feature;
 exports.GandiRegistrar = GandiRegistrar;
 exports.GoDaddyRegistrar = GoDaddyRegistrar;
@@ -7306,8 +7510,10 @@ exports.NamecheapRegistrar = NamecheapRegistrar;
 exports.NamecomRegistrar = NamecomRegistrar;
 exports.NotFoundError = NotFoundError;
 exports.NotImplementedError = NotImplementedError;
+exports.OutcomeUnknownError = OutcomeUnknownError;
 exports.ParsingError = ParsingError;
 exports.PorkbunRegistrar = PorkbunRegistrar;
+exports.REST_SAFE_METHODS = REST_SAFE_METHODS;
 exports.RateLimitError = RateLimitError;
 exports.RegistrarClient = RegistrarClient;
 exports.RegistrarError = RegistrarError;
@@ -7315,6 +7521,7 @@ exports.RetryableRegistrarError = RetryableRegistrarError;
 exports.SpaceshipRegistrar = SpaceshipRegistrar;
 exports.TimeoutError = TimeoutError;
 exports.USER_AGENT = USER_AGENT;
+exports.asRead = asRead;
 exports.backoffDelay = backoffDelay;
 exports.createDomain = createDomain;
 exports.createRegistrar = createRegistrar;
@@ -7322,6 +7529,7 @@ exports.ensureArray = ensureArray;
 exports.filterDomains = filterDomains;
 exports.isCoreFeature = isCoreFeature;
 exports.listPortfolio = listPortfolio;
+exports.markNotSent = markNotSent;
 exports.normalizeDomain = normalizeDomain;
 exports.normalizeNameservers = normalizeNameservers;
 exports.parseDate = parseDate;
@@ -7332,5 +7540,6 @@ exports.selectBaseUrl = selectBaseUrl;
 exports.settableForwards = settableForwards;
 exports.sleep = sleep;
 exports.toRegistrarError = toRegistrarError;
+exports.wasNotSent = wasNotSent;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map