@limitry/sdk 1.0.0-rc.8 → 1.0.0-rc.9

package/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 What changed in the Limitry TypeScript SDK (`@limitry/sdk`). Generated from the source on each release; newest first.
 
+## 1.0.0-rc.9 (2026-10-22)
+
+### Added
+
+- `POST /v1/checks` can now answer `503` with the code `busy` when
+  Limitry is deciding too many checks for those subjects at once. Nothing
+  was charged. `guard` and `reserve` (TypeScript and Python) send the
+  check again with the same key, within the same 30 seconds they give
+  `moving`, before the limit's fail mode decides. Each retry of `busy` or
+  `moving` now waits the answer's `Retry-After` plus a random backoff that
+  grows with each try, so clients don't all come back at the same moment.
+  Older SDK versions treat `busy` as Limitry being unreachable after their
+  usual two quick retries, so the fail mode decides; upgrade to retry it.
+
+### Changed
+
+- A very busy workspace's counts are now spread over more of Limitry's
+  servers as its traffic grows. While some of them move, which takes a few
+  seconds, checks, commits and releases on those subjects answer `503`
+  with the new error code `moving` and `Retry-After: 1`; nothing is
+  counted. `guard` and `reserve` (TypeScript and Python) and the CLI send
+  the same request again with the same Idempotency-Key for up to 30
+  seconds, each try with its own time budget, before a limit's fail mode
+  applies, so work is neither run uncounted nor left uncommitted.
+- When `guard` gets no answer to its check in time and the limit fails
+  open (so your work runs), it now sends the same check once more in the
+  background, with the same Idempotency-Key and the header
+  `limitry-finish-only: 1`: Limitry finishes a check it was part way
+  through, and never decides one afresh, so a check that never arrived
+  charges nothing. A limit that fails closed sends nothing more.
+
+  `POST /v1/checks` answers `204` (no body) to such a resend when there was
+  nothing to finish, so `checks.create` is typed to allow no decision; a
+  check sent without `limitry-finish-only` always gets one.
+
+### Fixed
+
+- A reservation (`mode: "reserve"`) now starts a subject's period, as a
+  plain check does: on a `billing_date` limit with no billing date set
+  yet, the first reservation's time becomes the subject's billing date,
+  and on a `first_use` limit it starts the period. Before, reservations
+  made before the subject's first commit could each count in a period of
+  their own, so a monthly limit could let more through than its amount.
+  A reservation you release still starts the period, with nothing used in
+  it.
+- A `503 moving` answer with `Retry-After: 0` is now retried after at least
+  a second, not at once, and still for at most 30 seconds. A client made
+  with `maxRetries: 0` no longer sends the SDK's internal
+  `x-limitry-moving` header to the API.
+
 ## 1.0.0-rc.8 (2026-10-21)
 
 ### Added

package/dist/index.d.ts

@@ -87,7 +87,7 @@ declare function createBaseClient(options: ClientOptions): import("openapi-fetch
                 id: string;
             };
             retryAfterSeconds: number | null;
-        }>;
+        } | undefined>;
     };
     limits: {
         archive: (limitId: string | number, options?: import("./resources.ts").RequestOptions) => Promise<undefined>;

package/dist/index.js

@@ -3,7 +3,7 @@ import createOpenApiClient from "openapi-fetch";
 import { apiErrorFrom } from "./errors.js";
 import * as product from "./product/index.js";
 import { resources } from "./resources.gen.js";
-import { withRetries } from "./retry.js";
+import { withoutMovingHeader, withRetries } from "./retry.js";
 import { verifyWebhook } from "./webhooks.js";
 export { ApiError, apiErrorFrom } from "./errors.js";
 export { verifyWebhook, WebhookVerificationError, } from "./webhooks.js";
@@ -35,7 +35,7 @@ function createBaseClient(options) {
     const client = createOpenApiClient({
         baseUrl: `${origin}/v1`,
         fetch: options.maxRetries === 0
-            ? send
+            ? withoutMovingHeader(send)
             : withRetries(send, { maxRetries: options.maxRetries }),
     });
     client.use({

package/dist/product/limits.d.ts

@@ -33,6 +33,17 @@ import type { BaseClient, Schemas } from "../index.ts";
  * `Unavailable` while `open` — the default, and the answer before any
  * decision was seen — lets the work run unmetered.
  *
+ * A subject being handed over between Limitry's servers (a split, a few
+ * seconds) answers `503 moving`: Limitry was reached and charged nothing,
+ * so it is not "unreachable" — the check (or commit, or release) is sent
+ * again with the same key for up to 30 s, each attempt with its own
+ * `timeoutMs`, before the fail mode applies. A fail-open product never
+ * runs uncounted through a handover. A limiter with too many checks
+ * inside at once answers `503 busy` the same way (charged nothing; retry
+ * with the same key): both share those 30 s, and each wait is the
+ * answer's Retry-After plus full jitter on a growing backoff, so clients
+ * turned away together don't all come back together.
+ *
  * Retries are safe (docs/product idempotency): each guard or reserve
  * sends one Idempotency-Key, which the client's own retries reuse, so a
  * check counts once however often it is sent. A reservation whose check
@@ -103,7 +114,13 @@ export declare class LimitReached extends Error {
 export declare class Unavailable extends Error {
     constructor();
 }
-export declare function createLimits(client: BaseClient, options?: LimitsOptions): {
+export type LimitsInternals = {
+    /** Waits (tests pass a fake). */
+    sleep?: (ms: number) => Promise<void>;
+    /** 0 ≤ x < 1 for the jitter (tests pass a fixed one). */
+    random?: () => number;
+};
+export declare function createLimits(client: BaseClient, options?: LimitsOptions, internals?: LimitsInternals): {
     /**
      * Where a subject stands on every limit on it (and on `shared`
      * subjects): used, remaining, resetsAt — for showing an end user. Call

package/dist/product/limits.js

@@ -1,4 +1,5 @@
 import { apiErrorFrom } from "../errors.js";
+import { MOVING_HEADER, MOVING_MS, retryWaitMs } from "../retry.js";
 /** The largest cost a commit takes. */
 const MAX_COST = 1_000_000_000;
 function checkedCost(units) {
@@ -40,8 +41,17 @@ const UNREACHABLE = Symbol("unreachable");
 const TIMED_OUT = Symbol("timed out");
 /** How long a settle (or a replay to find a hold) may take, retries included. */
 const SETTLE_TIMEOUT_MS = 5000;
-export function createLimits(client, options = {}) {
+const wait = (ms) => new Promise((done) => setTimeout(done, ms));
+/** Seconds of a `Retry-After`, as ms (none: undefined; `retryWaitMs` floors it at a second). */
+function retryAfterMs(response) {
+    const value = response.headers.get("retry-after");
+    const seconds = value === null ? NaN : Number(value);
+    return Number.isFinite(seconds) ? seconds * 1000 : undefined;
+}
+export function createLimits(client, options = {}, internals = {}) {
     const timeoutMs = options.timeoutMs ?? 1500;
+    const sleep = internals.sleep ?? wait;
+    const random = internals.random ?? Math.random;
     /** The last fail mode seen per subject + action (closed if any limit is). */
     const remembered = new Map();
     const key = (s, action) => `${s.kind}\u0000${s.id}\u0000${action}`;
@@ -57,9 +67,24 @@ export function createLimits(client, options = {}) {
     };
     /**
      * The decision — or UNREACHABLE (network error, 5xx, past the plan, the
-     * flood guard's 429), or TIMED_OUT (no answer within `wait`).
+     * flood guard's 429), or TIMED_OUT (no answer within `wait`). A
+     * `moving` or `busy` answer is asked again, with the same key, for up
+     * to 30 s in all: each attempt has its own `wait`.
      */
-    async function check(body, idempotencyKey, wait = timeoutMs) {
+    async function check(body, idempotencyKey, wait = timeoutMs, finishOnly = false) {
+        let waited = 0;
+        for (let tries = 0;; tries++) {
+            const answer = await checkOnce(body, idempotencyKey, wait, finishOnly);
+            if (answer.kind !== "later")
+                return answer.value;
+            const pause = retryWaitMs(answer.retryAfterMs, tries, random);
+            if (waited + pause > MOVING_MS)
+                return UNREACHABLE;
+            waited += pause;
+            await sleep(pause);
+        }
+    }
+    async function checkOnce(body, idempotencyKey, wait, finishOnly) {
         let timer;
         // Raced as well as aborted: a custom fetch (a service binding, a
         // test) may ignore the signal.
@@ -70,11 +95,19 @@ export function createLimits(client, options = {}) {
             try {
                 const { data, error, response } = await client.POST("/checks", {
                     body,
-                    headers: { "idempotency-key": idempotencyKey },
+                    headers: {
+                        "idempotency-key": idempotencyKey,
+                        // `moving` and `busy` come back here at once: this loop
+                        // retries them.
+                        [MOVING_HEADER]: "return",
+                        ...(finishOnly ? { "limitry-finish-only": "1" } : {}),
+                    },
                     signal: AbortSignal.timeout(wait),
                 });
                 if (data)
                     return data;
+                if (isRetryLater(response, error))
+                    return { later: retryAfterMs(response) };
                 // Past the plan's allowance (402 plan_limit_reached), or stopped by
                 // the edge's flood guard (429): no decision — each limit's fail
                 // mode applies, as if Limitry were unreachable.
@@ -97,7 +130,9 @@ export function createLimits(client, options = {}) {
             const answer = await Promise.race([asked, late]);
             if (answer instanceof Error)
                 throw answer;
-            return answer;
+            if (typeof answer === "object" && "later" in answer)
+                return { kind: "later", retryAfterMs: answer.later };
+            return { kind: "answer", value: answer };
         }
         finally {
             clearTimeout(timer);
@@ -109,23 +144,40 @@ export function createLimits(client, options = {}) {
      * same expires by itself.
      */
     async function settle(id, action, cost) {
-        try {
-            if (action === "commit") {
-                await client.POST("/reservations/{reservationId}/commit", {
-                    params: { path: { reservationId: id } },
-                    body: { cost: cost ?? 0 },
-                    signal: AbortSignal.timeout(SETTLE_TIMEOUT_MS),
-                });
+        // A commit lost would leave work uncounted: `moving` or `busy` is
+        // asked again, with the same key, for up to 30 s, each attempt with
+        // its own budget.
+        const idempotencyKey = crypto.randomUUID();
+        let waited = 0;
+        for (let tries = 0;; tries++) {
+            let retryMs = null;
+            try {
+                const headers = {
+                    "idempotency-key": idempotencyKey,
+                    [MOVING_HEADER]: "return",
+                };
+                const { error, response } = action === "commit"
+                    ? await client.POST("/reservations/{reservationId}/commit", {
+                        params: { path: { reservationId: id } },
+                        body: { cost: cost ?? 0 },
+                        headers,
+                        signal: AbortSignal.timeout(SETTLE_TIMEOUT_MS),
+                    })
+                    : await client.POST("/reservations/{reservationId}/release", {
+                        params: { path: { reservationId: id } },
+                        headers,
+                        signal: AbortSignal.timeout(SETTLE_TIMEOUT_MS),
+                    });
+                if (isRetryLater(response, error))
+                    retryMs = retryWaitMs(retryAfterMs(response), tries, random);
             }
-            else {
-                await client.POST("/reservations/{reservationId}/release", {
-                    params: { path: { reservationId: id } },
-                    signal: AbortSignal.timeout(SETTLE_TIMEOUT_MS),
-                });
+            catch {
+                // The reservation expires on its own.
             }
-        }
-        catch {
-            // The reservation expires on its own.
+            if (retryMs === null || waited + retryMs > MOVING_MS)
+                return;
+            waited += retryMs;
+            await sleep(retryMs);
         }
     }
     /**
@@ -167,16 +219,26 @@ export function createLimits(client, options = {}) {
         },
         /** Checks `cost`, runs `fn` only if allowed, and returns its result. */
         async guard(request, fn) {
-            const decision = await check({
+            const body = {
                 subject: request.subject,
                 shared: request.shared,
                 action: request.action,
                 cost: request.cost ?? 1,
-            }, crypto.randomUUID());
+            };
+            const idempotencyKey = crypto.randomUUID();
+            const decision = await check(body, idempotencyKey);
             if (decision === UNREACHABLE || decision === TIMED_OUT) {
                 if (failMode(request.subject, request.action) === "closed") {
                     throw new Unavailable();
                 }
+                if (decision === TIMED_OUT) {
+                    // No answer in time, and the work runs (fail open): the check may
+                    // be part way (held on some of Limitry's servers, across
+                    // subjects). Sent once more with the same key, in the background,
+                    // ONLY TO FINISH it — Limitry never decides it afresh then, so a
+                    // check that never arrived charges nothing.
+                    void check(body, idempotencyKey, SETTLE_TIMEOUT_MS, true).catch(() => { });
+                }
                 return fn();
             }
             remember(request.subject, request.action, decision);
@@ -257,3 +319,9 @@ export function createLimits(client, options = {}) {
         },
     };
 }
+/** `503 moving` or `503 busy`: nothing was charged — retry with the same key. */
+function isRetryLater(response, error) {
+    const code = error?.error
+        ?.code;
+    return response.status === 503 && (code === "moving" || code === "busy");
+}

package/dist/resources.gen.d.ts

@@ -16,7 +16,7 @@ export declare function resources(client: RawClient): {
                 id: string;
             };
             retryAfterSeconds: number | null;
-        }>;
+        } | undefined>;
     };
     limits: {
         archive: (limitId: string | number, options?: RequestOptions) => Promise<undefined>;

package/dist/retry.d.ts

@@ -13,9 +13,29 @@
  * handed back to the caller rather than slept through. A request whose
  * own signal aborted (a caller's timeout) is never retried: the caller
  * decided.
+ *
+ * A `503 moving` (a subject handed over between Limitry's servers, a few
+ * seconds) or `503 busy` (too many checks inside one of them at once) is
+ * retried for up to MOVING_MS whatever `maxRetries` says: nothing was
+ * charged, and the same key gets the answer once it lands. Each wait is
+ * the Retry-After (at least a second) plus full jitter on a capped
+ * exponential backoff (`retryWaitMs`), so clients turned away together
+ * don't come back together. A caller that keeps its own time budget (the
+ * guard and reserve helpers) sends `MOVING_HEADER: return` and gets
+ * either answer back at once.
  */
 export declare const DEFAULT_MAX_RETRIES = 2;
 export declare const MAX_WAIT_MS = 20000;
+/**
+ * How long a `moving` or `busy` answer is retried, all told: a handover's
+ * freeze lasts at most 30 s.
+ */
+export declare const MOVING_MS = 30000;
+/** Sent by a caller that retries `moving` and `busy` itself (never reaches the API). */
+export declare const MOVING_HEADER = "x-limitry-moving";
+/** The backoff added to a `moving` or `busy` wait: full jitter under base × 2^n, capped. */
+export declare const JITTER_BASE_MS = 250;
+export declare const JITTER_CAP_MS = 4000;
 /** The longest key a caller may pass where a client derives keys from it. */
 export declare const MAX_BASE_KEY = 200;
 type Fetch = (request: Request) => Promise<Response>;
@@ -26,7 +46,25 @@ export type RetryOptions = {
     key?: (method: string, path: string) => string | Promise<string>;
     /** Waits (tests pass a fake). */
     sleep?: (ms: number) => Promise<void>;
+    /** 0 ≤ x < 1 for the jitter (tests pass a fixed one). */
+    random?: () => number;
 };
+/**
+ * The wait before retrying a `moving` or `busy` answer, the `attempt`th
+ * in a row (0 first): the server's Retry-After, at least a second (a 0,
+ * or a date past, must not spin), plus full jitter — anywhere from 0 to
+ * min(JITTER_CAP_MS, JITTER_BASE_MS × 2^attempt).
+ */
+export declare function retryWaitMs(retryAfterMs: number | undefined, attempt: number, random?: () => number): number;
+/** A `503` that says retry later with the same key: `moving` or `busy` (else null). */
+export declare function retryLater(response: Response): Promise<"moving" | "busy" | null>;
+/** A `503` whose error code is `moving`. */
+export declare function isMoving(response: Response): Promise<boolean>;
+/**
+ * `fetch` that only drops MOVING_HEADER (a client with retries off): the
+ * header is between the SDK's own parts, never sent to the API.
+ */
+export declare function withoutMovingHeader(fetch: Fetch): Fetch;
 /** `fetch` with the rule above. Each request is one logical call. */
 export declare function withRetries(fetch: Fetch, options?: RetryOptions): Fetch;
 /**

package/dist/retry.js

@@ -13,11 +13,31 @@
  * handed back to the caller rather than slept through. A request whose
  * own signal aborted (a caller's timeout) is never retried: the caller
  * decided.
+ *
+ * A `503 moving` (a subject handed over between Limitry's servers, a few
+ * seconds) or `503 busy` (too many checks inside one of them at once) is
+ * retried for up to MOVING_MS whatever `maxRetries` says: nothing was
+ * charged, and the same key gets the answer once it lands. Each wait is
+ * the Retry-After (at least a second) plus full jitter on a capped
+ * exponential backoff (`retryWaitMs`), so clients turned away together
+ * don't come back together. A caller that keeps its own time budget (the
+ * guard and reserve helpers) sends `MOVING_HEADER: return` and gets
+ * either answer back at once.
  */
 const WRITES = new Set(["POST", "PUT", "PATCH", "DELETE"]);
 const RETRY_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
 export const DEFAULT_MAX_RETRIES = 2;
 export const MAX_WAIT_MS = 20_000;
+/**
+ * How long a `moving` or `busy` answer is retried, all told: a handover's
+ * freeze lasts at most 30 s.
+ */
+export const MOVING_MS = 30_000;
+/** Sent by a caller that retries `moving` and `busy` itself (never reaches the API). */
+export const MOVING_HEADER = "x-limitry-moving";
+/** The backoff added to a `moving` or `busy` wait: full jitter under base × 2^n, capped. */
+export const JITTER_BASE_MS = 250;
+export const JITTER_CAP_MS = 4_000;
 /** The longest key a caller may pass where a client derives keys from it. */
 export const MAX_BASE_KEY = 200;
 const wait = (ms) => new Promise((done) => setTimeout(done, ms));
@@ -35,6 +55,34 @@ function retryAfter(response) {
     const date = Date.parse(value);
     return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now());
 }
+/**
+ * The wait before retrying a `moving` or `busy` answer, the `attempt`th
+ * in a row (0 first): the server's Retry-After, at least a second (a 0,
+ * or a date past, must not spin), plus full jitter — anywhere from 0 to
+ * min(JITTER_CAP_MS, JITTER_BASE_MS × 2^attempt).
+ */
+export function retryWaitMs(retryAfterMs, attempt, random = Math.random) {
+    const floor = Math.max(1_000, retryAfterMs ?? 1_000);
+    const ceiling = Math.min(JITTER_CAP_MS, JITTER_BASE_MS * 2 ** attempt);
+    return floor + random() * ceiling;
+}
+/** A `503` that says retry later with the same key: `moving` or `busy` (else null). */
+export async function retryLater(response) {
+    if (response.status !== 503)
+        return null;
+    try {
+        const body = (await response.clone().json());
+        const code = body.error?.code;
+        return code === "moving" || code === "busy" ? code : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** A `503` whose error code is `moving`. */
+export async function isMoving(response) {
+    return (await retryLater(response)) === "moving";
+}
 async function retryable(response) {
     if (RETRY_STATUSES.has(response.status))
         return true;
@@ -48,11 +96,31 @@ async function retryable(response) {
         return false;
     }
 }
+/**
+ * `fetch` that only drops MOVING_HEADER (a client with retries off): the
+ * header is between the SDK's own parts, never sent to the API.
+ */
+export function withoutMovingHeader(fetch) {
+    return (request) => {
+        if (!request.headers.has(MOVING_HEADER))
+            return fetch(request);
+        const headers = new Headers(request.headers);
+        headers.delete(MOVING_HEADER);
+        return fetch(new Request(request, { headers }));
+    };
+}
 /** `fetch` with the rule above. Each request is one logical call. */
 export function withRetries(fetch, options = {}) {
     const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
     const sleep = options.sleep ?? wait;
+    const random = options.random ?? Math.random;
     return async (request) => {
+        const returnMoving = request.headers.get(MOVING_HEADER) === "return";
+        if (request.headers.has(MOVING_HEADER)) {
+            const headers = new Headers(request.headers);
+            headers.delete(MOVING_HEADER);
+            request = new Request(request, { headers });
+        }
         if (WRITES.has(request.method) && !request.headers.has("idempotency-key")) {
             const url = new URL(request.url);
             const key = options.key
@@ -62,10 +130,12 @@ export function withRetries(fetch, options = {}) {
             headers.set("idempotency-key", key);
             request = new Request(request, { headers });
         }
+        let movingWaited = 0;
+        let movingTries = 0;
         for (let attempt = 0;; attempt++) {
             const last = attempt >= maxRetries;
             // Send a copy while a retry may follow: a body is read once.
-            const sending = last ? request : request.clone();
+            const sending = request.clone();
             let response;
             try {
                 response = await fetch(sending);
@@ -76,6 +146,20 @@ export function withRetries(fetch, options = {}) {
                 await sleep(backoff(attempt));
                 continue;
             }
+            const later = await retryLater(response);
+            if (later && returnMoving)
+                return response;
+            if (later) {
+                // Retried apart from maxRetries, for up to MOVING_MS.
+                const delay = retryWaitMs(retryAfter(response), movingTries++, random);
+                if (movingWaited + delay > MOVING_MS)
+                    return response;
+                movingWaited += delay;
+                await response.body?.cancel();
+                await sleep(delay);
+                attempt--;
+                continue;
+            }
             if (last || !(await retryable(response)))
                 return response;
             const delay = retryAfter(response) ?? backoff(attempt);

package/dist/v1.gen.d.ts

@@ -1470,6 +1470,13 @@ export interface operations {
                     "application/json": components["schemas"]["CheckDecision"];
                 };
             };
+            /** @description Sent with `limitry-finish-only: 1` (a client finishing an earlier try with the same Idempotency-Key, after a timeout), and there was no earlier try to finish: nothing was decided or charged. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             /** @description Invalid request (code: invalid_request). */
             400: {
                 headers: {
@@ -1524,7 +1531,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorEnvelope"];
                 };
             };
-            /** @description Checks are unavailable (code: internal_error). */
+            /** @description The subject is moving between Limitry's servers, a few seconds (code: moving, with Retry-After): retry with the same Idempotency-Key — nothing was charged (anything held is given back, or finished by the retry). Or too many checks for these subjects are being decided at once (code: busy, with Retry-After): nothing was charged — retry with the same Idempotency-Key after Retry-After, with backoff. Or checks are unavailable, or a check across Limitry's servers couldn't be confirmed in time and may have been charged (code: internal_error): retry with the same Idempotency-Key. */
             503: {
                 headers: {
                     [name: string]: unknown;
@@ -2251,7 +2258,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorEnvelope"];
                 };
             };
-            /** @description Checks are unavailable (code: internal_error). */
+            /** @description The reservation's subject is moving between Limitry's servers, a few seconds (code: moving, with Retry-After): retry — the same settle answers the same. Or checks are unavailable (code: internal_error). */
             503: {
                 headers: {
                     [name: string]: unknown;
@@ -2336,7 +2343,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorEnvelope"];
                 };
             };
-            /** @description Checks are unavailable (code: internal_error). */
+            /** @description The reservation's subject is moving between Limitry's servers, a few seconds (code: moving, with Retry-After): retry — the same settle answers the same. Or checks are unavailable (code: internal_error). */
             503: {
                 headers: {
                     [name: string]: unknown;
@@ -2417,7 +2424,7 @@ export interface operations {
                     "application/json": components["schemas"]["ErrorEnvelope"];
                 };
             };
-            /** @description Checks are unavailable (code: internal_error). */
+            /** @description The reservation's subject is moving between Limitry's servers, a few seconds (code: moving, with Retry-After): retry — the same settle answers the same. Or checks are unavailable (code: internal_error). */
             503: {
                 headers: {
                     [name: string]: unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limitry/sdk",
-  "version": "1.0.0-rc.8",
+  "version": "1.0.0-rc.9",
   "description": "Limitry API client",
   "type": "module",
   "exports": {