@posthaste/sdk 0.1.0 → 0.3.0

package/dist/client.js

@@ -13,6 +13,7 @@
  */
 import { HttpClient } from './http.js';
 import { autoPaginate as paginate, collect } from './pagination.js';
+import { bytesToBase64 } from './base64.js';
 export class Posthaste {
     http;
     account;
@@ -91,9 +92,30 @@ export class DomainsResource {
             options,
         });
     }
-    /** `GET /v1/domains` — every domain, newest first. Not paginated. */
-    list(options) {
-        return this.http.request({ method: 'GET', path: '/v1/domains', idempotent: true, options });
+    /**
+     * `GET /v1/domains` — one keyset page, newest first.
+     *
+     * `limit` defaults to 100, which is also its maximum, so on most accounts the
+     * first page is every domain. It is still a page: past a hundred domains the
+     * rest are behind `nextCursor`, and there is no `hasMore` here to tell you so.
+     * Use `autoPaginate` if the count is not bounded by something you control.
+     */
+    list(params = {}, options) {
+        return this.http.request({
+            method: 'GET',
+            path: '/v1/domains',
+            query: params,
+            idempotent: true,
+            options,
+        });
+    }
+    /** Every domain, across every page. */
+    autoPaginate(params = {}, options) {
+        return paginate((p) => this.list(p, options), params);
+    }
+    /** Drain `autoPaginate` into an array, up to `maxItems`. */
+    listAll(params = {}, maxItems = 1000, options) {
+        return collect(this.autoPaginate(params, options), maxItems);
     }
     /**
      * `POST /v1/domains/:id/verify` — look for the records and record the result.
@@ -202,10 +224,20 @@ export class EmailsResource {
      * the header.
      */
     async send(params, options) {
+        // Attachment bytes become base64 on the wire. A string is passed through
+        // untouched — it is expected to already BE base64, and encoding it again
+        // would corrupt the file on arrival.
+        const body = { ...params };
+        if (params.attachments) {
+            body.attachments = params.attachments.map((a) => ({
+                ...a,
+                content: typeof a.content === 'string' ? a.content : bytesToBase64(a.content),
+            }));
+        }
         const { status, text } = await this.http.send({
             method: 'POST',
             path: '/v1/emails',
-            body: params,
+            body,
             // The whole rule, in one expression.
             idempotent: Boolean(params.idempotencyKey),
             options,
@@ -222,8 +254,33 @@ export class EmailsResource {
              * the source of truth.
              */
             duplicate: parsed.status === 'duplicate',
+            ...(parsed.scheduledAt ? { scheduledAt: parsed.scheduledAt } : {}),
+            /*
+             * Passed through only when the API sent them, so a single-recipient
+             * result keeps exactly the shape it has always had — no empty arrays
+             * appearing on responses that never had them.
+             */
+            ...(parsed.groupId ? { groupId: parsed.groupId } : {}),
+            ...(parsed.emails ? { emails: parsed.emails } : {}),
+            ...(parsed.suppressed ? { suppressed: parsed.suppressed } : {}),
         };
     }
+    /**
+     * `DELETE /v1/emails/:id/schedule` — cancel a scheduled send.
+     *
+     * Succeeds until the message is released to delivery (which happens within
+     * about a minute of its scheduled time). A message that already released
+     * throws `not_scheduled` carrying its current status; a cancel retried
+     * after a lost response returns success again rather than erroring.
+     */
+    cancelSchedule(id, options) {
+        return this.http.request({
+            method: 'DELETE',
+            path: `/v1/emails/${encodeURIComponent(id)}/schedule`,
+            idempotent: true,
+            options,
+        });
+    }
 }
 // ---------------------------------------------------------------------------
 // Messages
@@ -268,6 +325,30 @@ export class MessagesResource {
             options,
         });
     }
+    /**
+     * `GET /v1/messages/:id/attachments/:attachmentId` — the stored bytes.
+     *
+     * The attachment id comes from `get(id).content.attachments[].id`. Returns
+     * the exact bytes that were sent; the server serves them with
+     * `Content-Disposition: attachment` and only ever an inert content type,
+     * echoed here for callers who re-serve the file.
+     */
+    async downloadAttachment(messageId, attachmentId, options) {
+        const { bytes, headers } = await this.http.sendBinary({
+            method: 'GET',
+            path: `/v1/messages/${encodeURIComponent(messageId)}/attachments/${encodeURIComponent(attachmentId)}`,
+            idempotent: true,
+            options,
+        });
+        const disposition = headers.get('content-disposition') ?? '';
+        const star = /filename\*=UTF-8''([^;]+)/i.exec(disposition);
+        const plain = /filename="([^"]*)"/i.exec(disposition);
+        return {
+            bytes,
+            contentType: headers.get('content-type') ?? 'application/octet-stream',
+            filename: star ? decodeURIComponent(star[1]) : (plain?.[1] ?? null),
+        };
+    }
     /**
      * `GET /v1/stats/messages` — daily volume with the previous window for
      * comparison.
@@ -376,9 +457,28 @@ export class WebhooksResource {
             options,
         });
     }
-    /** `GET /v1/webhooks` — newest first. Not paginated. Never includes secrets. */
-    list(options) {
-        return this.http.request({ method: 'GET', path: '/v1/webhooks', idempotent: true, options });
+    /**
+     * `GET /v1/webhooks` — one keyset page, newest first. Never includes secrets.
+     *
+     * `limit` defaults to 50 and caps at 100. There is no `hasMore` on this
+     * endpoint; `nextCursor` is the end-of-list signal.
+     */
+    list(params = {}, options) {
+        return this.http.request({
+            method: 'GET',
+            path: '/v1/webhooks',
+            query: params,
+            idempotent: true,
+            options,
+        });
+    }
+    /** Every webhook, across every page. */
+    autoPaginate(params = {}, options) {
+        return paginate((p) => this.list(p, options), params);
+    }
+    /** Drain `autoPaginate` into an array, up to `maxItems`. */
+    listAll(params = {}, maxItems = 1000, options) {
+        return collect(this.autoPaginate(params, options), maxItems);
     }
     /** `DELETE /v1/webhooks/:id` — 204, or 404 for an unknown id. */
     delete(id, options) {
@@ -399,15 +499,33 @@ export class ApiKeysResource {
         this.http = http;
     }
     /**
-     * `GET /v1/api-keys` — the 100 most recent keys, revoked ones included.
+     * `GET /v1/api-keys` — one keyset page of keys, revoked ones included.
+     *
+     * `limit` defaults to 50 and caps at 100, and revoked keys count towards it —
+     * so an account that has rotated its credentials a few times will have more
+     * than one page. No `hasMore`; `nextCursor` is the end-of-list signal.
      *
      * Read only, and that is the whole resource. Creating and revoking keys
      * requires a signed-in owner or admin and refuses a Bearer key outright: a
      * server-side credential that could mint more credentials would make every
      * narrow key one request away from a full one.
      */
-    list(options) {
-        return this.http.request({ method: 'GET', path: '/v1/api-keys', idempotent: true, options });
+    list(params = {}, options) {
+        return this.http.request({
+            method: 'GET',
+            path: '/v1/api-keys',
+            query: params,
+            idempotent: true,
+            options,
+        });
+    }
+    /** Every key, across every page. */
+    autoPaginate(params = {}, options) {
+        return paginate((p) => this.list(p, options), params);
+    }
+    /** Drain `autoPaginate` into an array, up to `maxItems`. */
+    listAll(params = {}, maxItems = 1000, options) {
+        return collect(this.autoPaginate(params, options), maxItems);
     }
 }
 // ---------------------------------------------------------------------------
@@ -429,24 +547,73 @@ export class BillingResource {
     get(options) {
         return this.http.request({ method: 'GET', path: '/v1/billing', idempotent: true, options });
     }
-    /** `GET /v1/billing/history` — the hash-chained commercial record, oldest first, plus its verification. */
-    history(options) {
+    /**
+     * `GET /v1/billing/history` — one page of the hash-chained commercial record,
+     * plus its verification.
+     *
+     * THE ODD ONE OUT, in two ways that a caller who assumes the house style will
+     * get wrong:
+     *
+     *   - It reads FORWARD. Events come back oldest first, and the page resumes
+     *     from `after`, not `before`. That is not a stylistic choice: a hash chain
+     *     is verified from its start, and a record that renders in a different
+     *     order than it verifies in is one people stop trusting.
+     *   - `after` is a SEQUENCE NUMBER — a `BillingEvent.seq` — not a prefixed id.
+     *     Passing an id gets `400 invalid_request`. `nextCursor` is that number
+     *     rendered as a string, so passing it straight back is correct.
+     *
+     * `limit` defaults to 100 and caps at 200. `chain` is verified over the whole
+     * account history rather than over the page, so it means the same thing on
+     * every page.
+     */
+    history(params = {}, options) {
         return this.http.request({
             method: 'GET',
             path: '/v1/billing/history',
+            query: params,
             idempotent: true,
             options,
         });
     }
-    /** `GET /v1/billing/invoices` — the 100 most recent, newest first. Not paginated. */
-    invoices(options) {
+    /**
+     * Every billing event, oldest first, across every page.
+     *
+     * Note that this yields the EVENTS only. `chain` is per-response, so if you
+     * need the verification as well, call `history` and read it from there.
+     */
+    autoPaginateHistory(params = {}, options) {
+        // `after`, not `before` — the whole reason this endpoint needs a helper.
+        return paginate((p) => this.history(p, options), params, 'after');
+    }
+    /** Drain `autoPaginateHistory` into an array, up to `maxItems`. */
+    listAllHistory(params = {}, maxItems = 1000, options) {
+        return collect(this.autoPaginateHistory(params, options), maxItems);
+    }
+    /**
+     * `GET /v1/billing/invoices` — one keyset page, newest first.
+     *
+     * `limit` defaults to 50 and caps at 100, and there is no `hasMore` here. An
+     * account past its fiftieth invoice that reads only `data` is silently short
+     * of its own financial record — follow `nextCursor`, or use
+     * `autoPaginateInvoices`.
+     */
+    invoices(params = {}, options) {
         return this.http.request({
             method: 'GET',
             path: '/v1/billing/invoices',
+            query: params,
             idempotent: true,
             options,
         });
     }
+    /** Every invoice, across every page. */
+    autoPaginateInvoices(params = {}, options) {
+        return paginate((p) => this.invoices(p, options), params);
+    }
+    /** Drain `autoPaginateInvoices` into an array, up to `maxItems`. */
+    listAllInvoices(params = {}, maxItems = 1000, options) {
+        return collect(this.autoPaginateInvoices(params, options), maxItems);
+    }
     /** `GET /v1/billing/invoices/:id` — the same document plus the supplier block. */
     invoice(id, options) {
         return this.http.request({

package/dist/errors.d.ts

@@ -15,7 +15,12 @@
  */
 export type KnownErrorType = 'unauthorized' | 'unauthenticated' | 'forbidden' | 'csrf_failed' | 'email_unverified' | 'invalid_request' | 'not_found' | 'conflict'
 /** Inbound addresses. Not reachable through this SDK — see the README. */
- | 'address_taken' | 'invalid_address' | 'domain_not_found' | 'domain_not_verified' | 'suppressed' | 'rate_limited' | 'daily_limit_reached' | 'monthly_limit_reached' | 'domain_limit_reached' | 'domain_in_use' | 'token_required' | 'cloudflare_token_invalid' | 'cloudflare_zone_not_found' | 'cloudflare_write_failed' | 'suppression_protected' | 'suppression_platform' | 'not_configured' | 'provider_error' | 'already_subscribed' | 'internal' | 'unknown_error' | 'connection_error' | 'timeout';
+ | 'address_taken' | 'invalid_address' | 'domain_not_found' | 'domain_not_verified' | 'suppressed' | 'rate_limited' | 'daily_limit_reached' | 'monthly_limit_reached'
+/** The platform's own daily ceiling, not this account's. Short and transient:
+ *  nothing about the account changes it, and it clears without any action —
+ *  so it is `isRateLimited`, never `isQuotaExhausted`. Sends a `Retry-After`
+ *  of a few minutes, because the wait is not a clock a client can compute. */
+ | 'platform_paused' | 'bulk_send_refused' | 'attachments_too_many' | 'attachments_too_large' | 'attachment_type_blocked' | 'attachment_invalid' | 'schedule_too_far' | 'not_scheduled' | 'domain_limit_reached' | 'domain_in_use' | 'token_required' | 'cloudflare_token_invalid' | 'cloudflare_zone_not_found' | 'cloudflare_write_failed' | 'suppression_protected' | 'suppression_platform' | 'not_configured' | 'provider_error' | 'already_subscribed' | 'internal' | 'unknown_error' | 'connection_error' | 'timeout';
 export type PosthasteErrorType = KnownErrorType | (string & {});
 /** One entry of `error.fields`, present on some — not all — 400s. */
 export interface FieldError {
@@ -52,8 +57,10 @@ export declare class PosthasteError extends Error {
     readonly fields?: FieldError[];
     /**
      * How long to wait, in seconds, when the server said. Taken from
-     * `error.retryAfterSeconds` (rate limiting) or the `Retry-After` header
-     * (quota exhaustion), in that order.
+     * `error.retryAfterSeconds` (the per-key rate limiter puts it in the body) or
+     * the `Retry-After` header (quota exhaustion and `platform_paused` use the
+     * header), in that order — the body wins because only it is specific to the
+     * one refusal you got.
      */
     readonly retryAfterSeconds?: number;
     /** The parsed body. `undefined` when there was nothing parseable. */
@@ -68,9 +75,44 @@ export declare class PosthasteError extends Error {
      * a wall for the rest of the month. This SDK never retries these in-process.
      */
     get isQuotaExhausted(): boolean;
-    /** True for the per-key request-rate limiter, which is short and transient. */
+    /**
+     * True for the short, transient throttles — the per-key request-rate limiter
+     * and the platform-wide daily send ceiling.
+     *
+     * Grouped because a caller treats them identically: honour `Retry-After` and
+     * come back. Neither is a statement about the account, and unlike
+     * `isQuotaExhausted` neither needs a plan change or a wait until midnight.
+     *
+     * `platform_paused` in particular must never be folded in with the quota
+     * refusals just because it is also a 429. It says the platform's own daily
+     * total is full, not that the caller has spent anything — nothing about the
+     * account changes it, upgrading does not clear it, and it frees as the day's
+     * total drains rather than on a calendar boundary. Telling a customer to
+     * upgrade for it would be wrong twice over.
+     */
     get isRateLimited(): boolean;
+    /**
+     * Which address was suppressed, and why — `undefined` on every other error.
+     *
+     * The distinction in `reason` is the one that matters, and it is not
+     * cosmetic: a `complaint` or a `spam_trap` is permanent and must never be
+     * retried or cleared, while a `hard_bounce` (a mailbox that was full) or a
+     * `manual` entry can legitimately go stale. Reading it off `body` by hand is
+     * exactly the kind of untyped digging this SDK exists to remove.
+     */
+    get suppression(): {
+        address: string;
+        reason: SuppressionReason;
+    } | undefined;
 }
+/**
+ * Why an address is on the suppression list.
+ *
+ * Widened with `(string & {})` for the same reason the error union is: a new
+ * reason added server-side must not fail to type-check in a caller pinned to
+ * an older SDK.
+ */
+export type SuppressionReason = 'hard_bounce' | 'complaint' | 'spam_trap' | 'manual' | 'unsubscribe' | (string & {});
 export declare function isPosthasteError(value: unknown): value is PosthasteError;
 /**
  * Turn a response body into an error.

package/dist/errors.js

@@ -24,8 +24,10 @@ export class PosthasteError extends Error {
     fields;
     /**
      * How long to wait, in seconds, when the server said. Taken from
-     * `error.retryAfterSeconds` (rate limiting) or the `Retry-After` header
-     * (quota exhaustion), in that order.
+     * `error.retryAfterSeconds` (the per-key rate limiter puts it in the body) or
+     * the `Retry-After` header (quota exhaustion and `platform_paused` use the
+     * header), in that order — the body wins because only it is specific to the
+     * one refusal you got.
      */
     retryAfterSeconds;
     /** The parsed body. `undefined` when there was nothing parseable. */
@@ -52,9 +54,43 @@ export class PosthasteError extends Error {
     get isQuotaExhausted() {
         return this.type === 'daily_limit_reached' || this.type === 'monthly_limit_reached';
     }
-    /** True for the per-key request-rate limiter, which is short and transient. */
+    /**
+     * True for the short, transient throttles — the per-key request-rate limiter
+     * and the platform-wide daily send ceiling.
+     *
+     * Grouped because a caller treats them identically: honour `Retry-After` and
+     * come back. Neither is a statement about the account, and unlike
+     * `isQuotaExhausted` neither needs a plan change or a wait until midnight.
+     *
+     * `platform_paused` in particular must never be folded in with the quota
+     * refusals just because it is also a 429. It says the platform's own daily
+     * total is full, not that the caller has spent anything — nothing about the
+     * account changes it, upgrading does not clear it, and it frees as the day's
+     * total drains rather than on a calendar boundary. Telling a customer to
+     * upgrade for it would be wrong twice over.
+     */
     get isRateLimited() {
-        return this.type === 'rate_limited';
+        return this.type === 'rate_limited' || this.type === 'platform_paused';
+    }
+    /**
+     * Which address was suppressed, and why — `undefined` on every other error.
+     *
+     * The distinction in `reason` is the one that matters, and it is not
+     * cosmetic: a `complaint` or a `spam_trap` is permanent and must never be
+     * retried or cleared, while a `hard_bounce` (a mailbox that was full) or a
+     * `manual` entry can legitimately go stale. Reading it off `body` by hand is
+     * exactly the kind of untyped digging this SDK exists to remove.
+     */
+    get suppression() {
+        if (this.type !== 'suppressed')
+            return undefined;
+        const rejection = this.body?.error;
+        if (typeof rejection?.address !== 'string' || typeof rejection.reason !== 'string') {
+            // An older API deployment that predates the structured fields. Absent is
+            // the honest answer; a fabricated reason would be worse than none.
+            return undefined;
+        }
+        return { address: rejection.address, reason: rejection.reason };
     }
 }
 export function isPosthasteError(value) {

package/dist/http.d.ts

@@ -22,6 +22,11 @@ export interface PosthasteResponse {
         get(name: string): string | null;
     };
     text(): Promise<string>;
+    /**
+     * Optional so an injected `fetch` written against the older contract keeps
+     * working. Only attachment downloads need it; the global fetch has it.
+     */
+    arrayBuffer?(): Promise<ArrayBuffer>;
 }
 export interface PosthasteRequestInit {
     method: string;
@@ -90,7 +95,7 @@ export interface InternalRequest {
     options?: RequestOptions;
 }
 /** Kept in step with package.json — it is the only place it is stated twice. */
-export declare const SDK_VERSION = "0.1.0";
+export declare const SDK_VERSION = "0.3.0";
 export declare class HttpClient {
     private readonly apiKey;
     private readonly baseUrl;
@@ -117,22 +122,53 @@ export declare class HttpClient {
         status: number;
         text: string;
     }>;
+    /**
+     * A GET that returns bytes, not JSON — attachment downloads.
+     *
+     * Requires the response to support `arrayBuffer()`; the global fetch does,
+     * and an injected fetch that does not gets a clear error rather than a
+     * corrupted file — reading binary through `text()` mangles every byte
+     * sequence that is not valid UTF-8, which is most of them.
+     */
+    sendBinary(req: InternalRequest): Promise<{
+        status: number;
+        bytes: Uint8Array;
+        headers: {
+            get(name: string): string | null;
+        };
+    }>;
     /**
      * How long to wait before repeating this request, or `null` for "do not".
      *
      * The decision branches on `error.type` and NOT on the status, which is the
-     * whole point. All three of these are 429:
+     * whole point. All FOUR of these are 429, and they mean four different things:
      *
      *   `rate_limited` — the per-key request limiter. Transient, measured in
      *     seconds, and exactly what a retry is for.
-     *   `daily_limit_reached` — the warmup cap. `Retry-After` is the seconds
-     *     until midnight UTC.
+     *   `platform_paused` — the platform-wide daily send ceiling. Also transient,
+     *     and NOT a statement about this account: nothing the customer does
+     *     clears it and upgrading does not help, so it belongs with
+     *     `rate_limited` and never with the two below. Its `Retry-After` is a few
+     *     minutes, because the wait is neither a calendar boundary nor a clock a
+     *     client can compute.
+     *   `daily_limit_reached` — the account's warmup cap. `Retry-After` is the
+     *     seconds until midnight UTC.
      *   `monthly_limit_reached` — the plan allowance. `Retry-After` can be
      *     weeks.
      *
      * A retry loop written against the status treats the last two as a hiccup and
      * hammers a wall it cannot get through until the calendar moves — burning the
-     * caller's own rate limit on requests that are all going to be refused.
+     * caller's own rate limit on requests that are all going to be refused. The
+     * inverse mistake is just as bad: classing `platform_paused` with them tells a
+     * customer their allowance is spent when it is not, and stops a retry that
+     * would have succeeded a few minutes later.
+     *
+     * `platform_paused` is therefore retryable here. Whether it is retried
+     * IN-PROCESS is a separate question, settled below by `maxRetryDelayMs` on the
+     * honest length of the wait rather than by the type: a several-minute
+     * `Retry-After` exceeds the 60s default, so the error comes back to the caller
+     * to schedule — which is right for a request handler, and different from the
+     * quota rule, which refuses in-process retries however short the wait.
      */
     private retryDelayFor;
     private backoff;

package/dist/http.js

@@ -15,7 +15,7 @@ const DEFAULT_MAX_RETRY_DELAY_MS = 60_000;
 const BASE_BACKOFF_MS = 500;
 const MAX_BACKOFF_MS = 8_000;
 /** Kept in step with package.json — it is the only place it is stated twice. */
-export const SDK_VERSION = '0.1.0';
+export const SDK_VERSION = '0.3.0';
 const defaultSleep = (ms) => new Promise((resolve) => {
     const timer = setTimeout(resolve, ms);
     // Never hold a process open just to wait out a retry.
@@ -133,22 +133,88 @@ export class HttpClient {
             attempt += 1;
         }
     }
+    /**
+     * A GET that returns bytes, not JSON — attachment downloads.
+     *
+     * Requires the response to support `arrayBuffer()`; the global fetch does,
+     * and an injected fetch that does not gets a clear error rather than a
+     * corrupted file — reading binary through `text()` mangles every byte
+     * sequence that is not valid UTF-8, which is most of them.
+     */
+    async sendBinary(req) {
+        const url = this.buildUrl(req.path, req.query);
+        const headers = {
+            ...this.extraHeaders,
+            ...(req.options?.headers ?? {}),
+            'user-agent': this.userAgent,
+            authorization: `Bearer ${this.apiKey}`,
+        };
+        let attempt = 0;
+        for (;;) {
+            let response;
+            try {
+                response = await this.attempt(url, { method: req.method, headers }, req.options);
+            }
+            catch (cause) {
+                const error = transportError(cause);
+                if (attempt < this.maxRetries) {
+                    await this.backoff(attempt, undefined);
+                    attempt += 1;
+                    continue;
+                }
+                throw error;
+            }
+            if (response.status < 400) {
+                if (typeof response.arrayBuffer !== 'function') {
+                    throw new Error('the injected fetch response does not implement arrayBuffer(), which binary downloads require');
+                }
+                return {
+                    status: response.status,
+                    bytes: new Uint8Array(await response.arrayBuffer()),
+                    headers: response.headers,
+                };
+            }
+            const text = await response.text();
+            const error = errorFromResponse(response.status, text, response.headers.get('retry-after') ?? null);
+            const wait = this.retryDelayFor(error, req, attempt);
+            if (wait === null)
+                throw error;
+            await this.sleep(wait);
+            attempt += 1;
+        }
+    }
     /**
      * How long to wait before repeating this request, or `null` for "do not".
      *
      * The decision branches on `error.type` and NOT on the status, which is the
-     * whole point. All three of these are 429:
+     * whole point. All FOUR of these are 429, and they mean four different things:
      *
      *   `rate_limited` — the per-key request limiter. Transient, measured in
      *     seconds, and exactly what a retry is for.
-     *   `daily_limit_reached` — the warmup cap. `Retry-After` is the seconds
-     *     until midnight UTC.
+     *   `platform_paused` — the platform-wide daily send ceiling. Also transient,
+     *     and NOT a statement about this account: nothing the customer does
+     *     clears it and upgrading does not help, so it belongs with
+     *     `rate_limited` and never with the two below. Its `Retry-After` is a few
+     *     minutes, because the wait is neither a calendar boundary nor a clock a
+     *     client can compute.
+     *   `daily_limit_reached` — the account's warmup cap. `Retry-After` is the
+     *     seconds until midnight UTC.
      *   `monthly_limit_reached` — the plan allowance. `Retry-After` can be
      *     weeks.
      *
      * A retry loop written against the status treats the last two as a hiccup and
      * hammers a wall it cannot get through until the calendar moves — burning the
-     * caller's own rate limit on requests that are all going to be refused.
+     * caller's own rate limit on requests that are all going to be refused. The
+     * inverse mistake is just as bad: classing `platform_paused` with them tells a
+     * customer their allowance is spent when it is not, and stops a retry that
+     * would have succeeded a few minutes later.
+     *
+     * `platform_paused` is therefore retryable here. Whether it is retried
+     * IN-PROCESS is a separate question, settled below by `maxRetryDelayMs` on the
+     * honest length of the wait rather than by the type: a several-minute
+     * `Retry-After` exceeds the 60s default, so the error comes back to the caller
+     * to schedule — which is right for a request handler, and different from the
+     * quota rule, which refuses in-process retries however short the wait.
      */
     retryDelayFor(error, req, attempt) {
         if (attempt >= this.maxRetries)

package/dist/index.d.ts

@@ -8,8 +8,8 @@ export { Posthaste } from './client.js';
 export { AccountResource, ApiKeysResource, BillingResource, DomainsResource, EmailsResource, MessagesResource, SuppressionsResource, WebhooksResource, } from './client.js';
 export { PosthasteError, isPosthasteError, type PosthasteErrorType, type KnownErrorType, type FieldError, } from './errors.js';
 export { SDK_VERSION, type PosthasteOptions, type RequestOptions, type FetchLike, type PosthasteRequestInit, type PosthasteResponse, } from './http.js';
-export { autoPaginate, collect, type PageFetcher } from './pagination.js';
+export { autoPaginate, collect, type CursorParam, type CursorParams, type PageFetcher, type WalkablePage, } from './pagination.js';
 export { verifyWebhook, parseWebhookEvent, SIGNATURE_HEADER, DELIVERY_ID_HEADER, ATTEMPT_HEADER, type VerifyWebhookOptions, type WebhookVerifyResult, type WebhookVerifyFailure, } from './webhooks.js';
 export type { AccountId, ApiKeyId, DomainId, EventId, InvoiceId, MessageId, PaymentId, PrefixedId, SubscriptionId, SuppressionId, WebhookId, } from './ids.js';
-export { EVENT_TYPES, MESSAGE_STATUSES, SCOPES, SUPPRESSION_REASONS, type Account, type AccountPlan, type AccountSending, type AccountStatus, type AccountSubscriptionSummary, type ApiKey, type Billing, type BillingCharge, type BillingEvent, type BillingHistory, type BillingPayment, type BillingPlan, type BillingProfile, type BillingSubscription, type ChainVerification, type CheckStatus, type CloudflarePublishResult, type ConnectCloudflareParams, type CreateDomainParams, type CreateSuppressionParams, type CreateWebhookParams, type CreatedDomain, type CreatedSuppression, type CreatedWebhook, type DnsHost, type DnsRecord, type Domain, type DomainSetup, type DomainStatus, type DomainVerification, type EventType, type Invoice, type InvoiceDetail, type KeyEnvironment, type List, type ListMessagesParams, type ListSuppressionsParams, type Message, type MessageContent, type MessageStats, type MessageStatsParams, type MessageStatus, type MessageSummary, type Page, type PaginationParams, type PaymentStatus, type PlanId, type RecordCheck, type Scope, type SendEmailParams, type SendEmailResult, type StatsDay, type StatsTotals, type SubscriptionStatus, type Suppression, type SuppressionReason, type Usage, type UsageDay, type WaybillEntry, type Webhook, type WebhookEvent, type WebhookStatus, } from './types.js';
+export { EVENT_TYPES, MESSAGE_STATUSES, SCOPES, SUPPRESSION_REASONS, type Account, type AccountPlan, type AccountSending, type AccountStatus, type AccountSubscriptionSummary, type ApiKey, type Billing, type BillingCharge, type BillingEvent, type BillingHistory, type BillingPayment, type BillingPlan, type BillingProfile, type BillingSubscription, type ChainVerification, type CheckStatus, type CloudflarePublishResult, type ConnectCloudflareParams, type CreateDomainParams, type CreateSuppressionParams, type CreateWebhookParams, type CreatedDomain, type CreatedSuppression, type CreatedWebhook, type CursorPage, type DnsHost, type DnsRecord, type Domain, type DomainSetup, type DomainStatus, type DomainVerification, type EventType, type Invoice, type InvoiceDetail, type KeyEnvironment, type List, type ListApiKeysParams, type ListBillingHistoryParams, type ListDomainsParams, type ListInvoicesParams, type ListMessagesParams, type ListSuppressionsParams, type ListWebhooksParams, type Message, type AttachmentMeta, type MessageContent, type MessageStats, type MessageStatsParams, type MessageStatus, type MessageSummary, type Page, type PaginationParams, type PaymentStatus, type PlanId, type RecordCheck, type Scope, type SendAttachment, type SendEmailParams, type SendEmailResult, type SentCopy, type StatsDay, type StatsTotals, type SubscriptionStatus, type Suppression, type SuppressionReason, type Usage, type UsageDay, type WaybillEntry, type Webhook, type WebhookEvent, type WebhookStatus, } from './types.js';
 export { Posthaste as default } from './client.js';

package/dist/index.js

@@ -8,7 +8,7 @@ export { Posthaste } from './client.js';
 export { AccountResource, ApiKeysResource, BillingResource, DomainsResource, EmailsResource, MessagesResource, SuppressionsResource, WebhooksResource, } from './client.js';
 export { PosthasteError, isPosthasteError, } from './errors.js';
 export { SDK_VERSION, } from './http.js';
-export { autoPaginate, collect } from './pagination.js';
+export { autoPaginate, collect, } from './pagination.js';
 export { verifyWebhook, parseWebhookEvent, SIGNATURE_HEADER, DELIVERY_ID_HEADER, ATTEMPT_HEADER, } from './webhooks.js';
 export { EVENT_TYPES, MESSAGE_STATUSES, SCOPES, SUPPRESSION_REASONS, } from './types.js';
 export { Posthaste as default } from './client.js';