@lexnode/legal-data-sdk 1.30.0 → 1.32.0

package/dist/client.d.ts

@@ -1,114 +1,307 @@
 import type { paths } from "../schema.js";
 import type { Body, CallOptions, LexNodeResult, MethodOf, Query, RequestArgs, RetryPolicy } from "./types.js";
+/** As opções de `createLexNodeClient`. */
 export interface LexNodeClientOptions {
-    /** Base da API, por exemplo `https://api.lexnode.com.br`. */
+    /**
+     * Endereço da API, por exemplo `https://api.lexnode.com.br`. Precisa usar
+     * https, exceto no host local (`localhost`, `127.0.0.1` ou `::1`).
+     */
     baseUrl: string;
     /**
-     * Chave de CONTA (`Authorization: Bearer`). É credencial de servidor: ver o
-     * aviso de `createLexNodeClient`.
+     * Chave de API da conta, enviada como `Authorization: Bearer`. Guarde-a só
+     * no servidor.
      */
     apiKey: string;
-    /** Sub-tenant padrão (`X-Office-Id`). Cada chamada pode trocá-lo ou omiti-lo. */
+    /**
+     * Escritório (sub-tenant) atribuído a toda chamada, no cabeçalho
+     * `X-Office-Id`. Cada chamada pode trocá-lo ou omiti-lo em
+     * `CallOptions.officeId`.
+     */
     officeId?: string;
     /**
-     * Prazo de cada chamada, em ms. Padrão: 30 s. A ficha e o retrato de um
-     * processo, e a leitura que segue em segundo plano, levam o maior entre este
-     * prazo e a espera pela fonte mais 15 s — `waitSeconds`, ou o padrão de 20 s
-     * da API quando ele falta.
+     * Prazo de cada chamada, em ms. Padrão: 30 000. Na ficha e no retrato de um
+     * processo e em `processLookups.create`, o prazo é o maior entre este valor
+     * e a espera pela fonte mais 15 s — `waitSeconds` ou, sem ele, os 20 s
+     * padrão da API.
      */
     timeoutMs?: number;
-    /** Transporte alternativo — o `fetch` global é o padrão. */
+    /** O `fetch` a usar no lugar do global, por exemplo num teste. */
     fetch?: typeof globalThis.fetch;
-    /** Identifica a sua integração no `User-Agent`. */
+    /** Identifica a sua integração no cabeçalho `User-Agent`. */
     userAgent?: string;
-    /** Política de retentativa padrão. Ausente = desligada. */
+    /** Política de retentativa de toda chamada. Sem ela, nada é repetido. */
     retry?: RetryPolicy;
 }
 /**
- * O cliente de runtime do motor de dados jurídicos.
+ * Cria o cliente da API do LexNode.
  *
- * **Servidor apenas, e só por TLS.** A credencial é de CONTA: uma chave no
- * browser é uma chave publicada, e uma chave em `http://` é uma chave lida por
- * quem estiver no caminho — `baseUrl` sem https é recusada aqui, exceto em
- * host local. Um app com usuários finais fala com o próprio backend, e é o
- * backend que fala com o motor — atribuindo cada chamada ao seu sub-tenant por
- * `X-Office-Id`.
+ * Toda chamada envia `Authorization: Bearer`, `X-Request-Id`, `X-Trace-Id` e,
+ * quando houver, `X-Office-Id`, e devolve `{ data, meta }` tipados pela rota.
+ * O `meta` traz, além do que o contrato declara, o código HTTP (`status`) e os
+ * cabeçalhos de limite de vazão (`rateLimit`). Toda recusa da API e toda falha
+ * de rede ou de prazo é lançada como `LexNodeError`.
  *
- * Sem dependências de runtime: `fetch` global e `node:crypto`.
+ * Use só no servidor: a chave é da conta inteira. Um app com usuários finais
+ * chama o próprio backend, e o backend chama a API.
+ *
+ * Lança `LexNodeError` (`CLIENT_INVALID_REQUEST`) quando `baseUrl` não é uma
+ * URL válida ou não usa https fora do host local.
+ *
+ * @example
+ * ```ts
+ * const lexnode = createLexNodeClient({
+ *   baseUrl: "https://api.lexnode.com.br",
+ *   apiKey: process.env.LEXNODE_API_KEY!,
+ * });
+ *
+ * const { data, meta } = await lexnode.processes.get("00012345620268260100", {
+ *   tribunalAlias: "TJSP",
+ * });
+ * ```
  */
 export declare function createLexNodeClient(options: LexNodeClientOptions): {
+    /**
+     * Chama qualquer rota do contrato, tipada pelo caminho e pelo método.
+     *
+     * Use para as rotas sem método nomeado neste cliente. Recebe os parâmetros
+     * de caminho e de consulta em `params`, o corpo em `body` e as opções de
+     * `CallOptions`; devolve `{ data, meta }` e lança `LexNodeError` como os
+     * métodos nomeados.
+     *
+     * @example
+     * ```ts
+     * const { data } = await lexnode.request("/v1/precedents", "get", {
+     *   params: { query: { query: "dano moral", limit: 20 } },
+     * });
+     * ```
+     */
     request: <P extends keyof paths, M extends MethodOf<P>>(path: P, method: M, args: RequestArgs<P, M>) => Promise<LexNodeResult<P, M>>;
     tribunals: {
+        /**
+         * Lista os tribunais aceitos (`GET /v1/tribunals`). As demais rotas
+         * aceitam o tribunal pela sigla (`code`) que vem daqui.
+         */
         list: (query?: Query<"/v1/tribunals", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/tribunals", "get">>;
     };
     processes: {
+        /**
+         * Busca processos num tribunal (`POST /v1/processes/search`): 200 com o
+         * resultado ou 202 com a busca enfileirada. `searchProcesses` diz no
+         * tipo qual dos dois chegou.
+         */
         search: (body: Body<"/v1/processes/search", "post">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/processes/search", "post">>;
+        /**
+         * Lê a ficha de um processo (`GET /v1/processes/{processNumber}`).
+         * `waitSeconds` define quanto a API espera pela fonte processual; sem
+         * `timeoutMs`, o prazo da chamada acompanha essa espera.
+         */
         get: (processNumber: string, query: Query<"/v1/processes/{processNumber}", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/processes/{processNumber}", "get">>;
+        /**
+         * Lista as movimentações guardadas de um processo, sem consultar a fonte
+         * (`GET /v1/processes/{processNumber}/movements`). `degree` recorta a
+         * lista por grau.
+         */
         movements: (processNumber: string, query: Query<"/v1/processes/{processNumber}/movements", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/processes/{processNumber}/movements", "get">>;
+        /**
+         * Lê o retrato de um processo na fonte processual — o processo, as
+         * movimentações e as instâncias do número
+         * (`GET /v1/processes/{processNumber}/snapshot`). Como em `get`, o prazo
+         * da chamada acompanha `waitSeconds`.
+         */
         snapshot: (processNumber: string, query: Query<"/v1/processes/{processNumber}/snapshot", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/processes/{processNumber}/snapshot", "get">>;
+        /**
+         * Lista processos relacionados ao consultado: o mesmo número em outro
+         * tribunal e números citados nas movimentações
+         * (`GET /v1/processes/{processNumber}/related`).
+         */
         related: (processNumber: string, query: Query<"/v1/processes/{processNumber}/related", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/processes/{processNumber}/related", "get">>;
+        /**
+         * Lê o retrato de vários processos numa chamada
+         * (`POST /v1/processes/snapshot-batch`). Cada item traz o próprio
+         * resultado ou erro, e só os itens concluídos são cobrados.
+         */
         snapshotBatch: (body: Body<"/v1/processes/snapshot-batch", "post">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/processes/snapshot-batch", "post">>;
     };
     publications: {
+        /**
+         * Lista as publicações do diário que casam com os filtros
+         * (`GET /v1/publications`).
+         */
         list: (query?: Query<"/v1/publications", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/publications", "get">>;
+        /**
+         * Lê uma publicação completa pela chave que uma busca devolveu
+         * (`GET /v1/publications/{publicationKey}`), sem custo.
+         */
         read: (publicationKey: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/publications/{publicationKey}", "get">>;
+        /**
+         * Pesquisa jurisprudência por texto e guarda o resultado
+         * (`POST /v1/publications/text-searches`). Reenviar com o mesmo
+         * `requestId` devolve a busca já feita, sem nova cobrança.
+         */
         textSearch: (body: Body<"/v1/publications/text-searches", "post">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/publications/text-searches", "post">>;
         textAlerts: {
+            /**
+             * Salva uma vigília de texto (`POST /v1/publications/text-alerts`),
+             * que avisa por `PUBLICATION_TEXT_ALERT_MATCHED` quando publicações
+             * novas casam com a consulta.
+             */
             create: (body: Body<"/v1/publications/text-alerts", "post">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/publications/text-alerts", "post">>;
+            /**
+             * Lista as vigílias de texto da conta
+             * (`GET /v1/publications/text-alerts`).
+             */
             list: (query?: Query<"/v1/publications/text-alerts", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/publications/text-alerts", "get">>;
+            /**
+             * Remove uma vigília de texto
+             * (`DELETE /v1/publications/text-alerts/{alertId}`).
+             */
             delete: (alertId: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/publications/text-alerts/{alertId}", "delete">>;
         };
     };
     monitors: {
+        /**
+         * Cria um monitor (`POST /v1/monitors`). Um alvo já vigiado é recusado
+         * com 409 `MONITOR_ALREADY_EXISTS`, e `error.details.monitorId` traz o
+         * id do monitor existente.
+         */
         create: (body: Body<"/v1/monitors", "post">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/monitors", "post">>;
+        /**
+         * Lista os monitores da conta (`GET /v1/monitors`); use `paginate` para
+         * percorrer as páginas.
+         */
         list: (query?: Query<"/v1/monitors", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/monitors", "get">>;
+        /** Lê um monitor (`GET /v1/monitors/{monitorId}`). */
         get: (monitorId: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/monitors/{monitorId}", "get">>;
+        /**
+         * Muda o status de um monitor — `ACTIVE`, `PAUSED` ou `DISABLED`
+         * (`PATCH /v1/monitors/{monitorId}`).
+         */
         update: (monitorId: string, body: Body<"/v1/monitors/{monitorId}", "patch">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/monitors/{monitorId}", "patch">>;
+        /** Exclui um monitor (`DELETE /v1/monitors/{monitorId}`). */
         delete: (monitorId: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/monitors/{monitorId}", "delete">>;
+        /**
+         * Pede uma varredura do monitor sem esperar a agenda
+         * (`POST /v1/monitors/{monitorId}/sync`). O resultado chega em
+         * `MONITOR_SYNC_SUCCEEDED` ou `MONITOR_SYNC_FAILED`.
+         */
         sync: (monitorId: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/monitors/{monitorId}/sync", "post">>;
     };
     subscriptions: {
+        /**
+         * Declara interesse num processo (`POST /v1/subscriptions`). A conta
+         * passa a receber `PROCESS_MOVEMENT_CREATED`, com o `externalRef`
+         * informado, e `PROCESS_INSTANCE_DISCOVERED`. Repetir com o mesmo
+         * `reason` e `externalRef` devolve a mesma assinatura.
+         */
         create: (body: Body<"/v1/subscriptions", "post">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/subscriptions", "post">>;
+        /** Lista as assinaturas da conta (`GET /v1/subscriptions`). */
         list: (query?: Query<"/v1/subscriptions", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/subscriptions", "get">>;
+        /**
+         * Desativa as assinaturas da conta e do escritório da chamada que têm o
+         * `reason` e o `externalRef` informados (`DELETE /v1/subscriptions`).
+         */
         delete: (body: Body<"/v1/subscriptions", "delete">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/subscriptions", "delete">>;
     };
     processLookups: {
         /**
-         * A leitura de UM processo que segue em segundo plano quando a fonte não
-         * entrega dentro de `waitSeconds`: 200 com o processo, ou 202 com a
-         * consulta aberta. Repetir é seguro — o motor devolve a consulta já
-         * aberta da mesma leitura em vez de abrir outra —, então a retentativa
-         * vale para ela como para uma leitura.
+         * Lê um processo e segue em segundo plano quando a fonte não entrega
+         * dentro de `waitSeconds` (`POST /v1/processes/lookups`): 200 com o
+         * processo, ou 202 com a consulta aberta. Pedir a mesma leitura de novo
+         * devolve a mesma consulta, então a retentativa vale para esta chamada
+         * como para uma leitura. `lookupProcess` diz no tipo qual dos dois
+         * desfechos chegou.
          */
         create: (body: Body<"/v1/processes/lookups", "post">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/processes/lookups", "post">>;
+        /**
+         * Lê uma consulta em segundo plano, sem custo
+         * (`GET /v1/processes/lookups/{lookupId}`).
+         */
         get: (lookupId: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/processes/lookups/{lookupId}", "get">>;
+        /** Lista as consultas em segundo plano (`GET /v1/processes/lookups`). */
         list: (query?: Query<"/v1/processes/lookups", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/processes/lookups", "get">>;
+        /**
+         * Cancela uma consulta aberta e devolve os créditos retidos
+         * (`POST /v1/processes/lookups/{lookupId}/cancel`).
+         */
         cancel: (lookupId: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/processes/lookups/{lookupId}/cancel", "post">>;
     };
     searchJobs: {
+        /** Lê uma busca enfileirada (`GET /v1/search-jobs/{jobId}`). */
         get: (jobId: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/search-jobs/{jobId}", "get">>;
+        /** Lista as buscas enfileiradas (`GET /v1/search-jobs`). */
         list: (query?: Query<"/v1/search-jobs", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/search-jobs", "get">>;
+        /**
+         * Cancela uma busca que ainda não terminou e devolve os créditos
+         * retidos (`POST /v1/search-jobs/{jobId}/cancel`).
+         */
         cancel: (jobId: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/search-jobs/{jobId}/cancel", "post">>;
     };
     events: {
+        /**
+         * Lista os eventos da conta, do mais recente ao mais antigo, com o
+         * estado de entrega de cada um (`GET /v1/events`).
+         */
         list: (query?: Query<"/v1/events", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/events", "get">>;
+        /** Lê um evento (`GET /v1/events/{eventId}`). */
         get: (eventId: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/events/{eventId}", "get">>;
     };
     usage: {
+        /**
+         * Lê o uso do período: créditos usados e restantes, e o consumo por
+         * escritório (`GET /v1/usage`).
+         */
         get: (query?: Query<"/v1/usage", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/usage", "get">>;
     };
     webhooks: {
         endpoints: {
+            /** Lista os endpoints de webhook (`GET /v1/webhooks/endpoints`). */
             list: (query?: Query<"/v1/webhooks/endpoints", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/webhooks/endpoints", "get">>;
+            /**
+             * Cadastra um endpoint de webhook (`POST /v1/webhooks/endpoints`). O
+             * segredo de assinatura vem só nesta resposta, em `signingSecret`:
+             * guarde-o.
+             */
             create: (body: Body<"/v1/webhooks/endpoints", "post">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/webhooks/endpoints", "post">>;
+            /**
+             * Altera um endpoint, como a URL ou os eventos assinados
+             * (`PATCH /v1/webhooks/endpoints/{endpointId}`).
+             */
             update: (endpointId: string, body: Body<"/v1/webhooks/endpoints/{endpointId}", "patch">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/webhooks/endpoints/{endpointId}", "patch">>;
+            /**
+             * Exclui um endpoint
+             * (`DELETE /v1/webhooks/endpoints/{endpointId}`).
+             */
             delete: (endpointId: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/webhooks/endpoints/{endpointId}", "delete">>;
+            /**
+             * Envia na hora uma entrega de teste (`WEBHOOK_TEST`) ao endpoint e
+             * devolve o resultado
+             * (`POST /v1/webhooks/endpoints/{endpointId}/test`).
+             */
             test: (endpointId: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/webhooks/endpoints/{endpointId}/test", "post">>;
+            /**
+             * Gera um novo segredo de assinatura e invalida o anterior na hora
+             * (`POST /v1/webhooks/endpoints/{endpointId}/rotate-secret`). Atualize
+             * o seu receptor com o segredo novo, que vem só nesta resposta.
+             */
             rotateSecret: (endpointId: string, opts?: CallOptions) => Promise<LexNodeResult<"/v1/webhooks/endpoints/{endpointId}/rotate-secret", "post">>;
         };
+        /**
+         * Lista as entregas de webhook da conta
+         * (`GET /v1/webhooks/deliveries`).
+         */
         deliveries: (query?: Query<"/v1/webhooks/deliveries", "get">, opts?: CallOptions) => Promise<LexNodeResult<"/v1/webhooks/deliveries", "get">>;
+        /**
+         * Lê a fila e as entregas e falhas das últimas 24 h de cada endpoint
+         * (`GET /v1/webhooks/health`).
+         */
         health: (opts?: CallOptions) => Promise<LexNodeResult<"/v1/webhooks/health", "get">>;
+        /**
+         * Lista os tipos de evento que a conta produziu nos últimos 30 dias e
+         * que nenhum endpoint ativo assina
+         * (`GET /v1/webhooks/unsubscribed-event-types`).
+         */
         unsubscribedEventTypes: (opts?: CallOptions) => Promise<LexNodeResult<"/v1/webhooks/unsubscribed-event-types", "get">>;
     };
 };
+/** O cliente que `createLexNodeClient` devolve. */
 export type LexNodeClient = ReturnType<typeof createLexNodeClient>;

package/dist/client.js

@@ -3,49 +3,19 @@ import { LexNodeError } from "./errors.js";
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_RETRY_BASE_DELAY_MS = 500;
 const DEFAULT_RETRY_MAX_DELAY_MS = 8_000;
-/** Métodos cuja repetição não cria nada de novo, por definição do HTTP. */
 const IDEMPOTENT_METHODS = new Set(["get", "delete"]);
-/**
- * As escritas cuja repetição o CONTRATO declara segura, com o `X-Request-Id`
- * fixado pelo chamador.
- *
- * Só uma rota trata esse cabeçalho como chave de replay; nas demais ele é
- * rastreio, e repetir cria um segundo recurso — dois endpoints de webhook para
- * a mesma URL entregam cada evento em dobro, e o segredo do primeiro fica
- * órfão. Por isso a decisão é pela ROTA, nunca pela presença de um id.
- */
 const REQUEST_ID_IDEMPOTENT_WRITES = new Set([
     "post /v1/publications/text-searches",
 ]);
-/**
- * As chamadas em que quem chama escolhe, em `waitSeconds`, quanto o motor
- * espera pela fonte processual, e onde a espera viaja: na consulta das duas
- * leituras de UM processo, no corpo da leitura que segue em segundo plano.
- */
 const SOURCE_WAIT_ROUTES = new Map([
     ["get /v1/processes/{processNumber}", "query"],
     ["get /v1/processes/{processNumber}/snapshot", "query"],
     ["post /v1/processes/lookups", "body"],
 ]);
-/**
- * A espera que o motor aplica a essas leituras quando a chamada não traz
- * `waitSeconds`: o padrão do parâmetro no contrato.
- */
 const SOURCE_WAIT_API_DEFAULT_SECONDS = 20;
-/**
- * O que a chamada espera além da espera do motor: na ficha, até 10 s de
- * enriquecimento depois da fonte, e a rede.
- */
 const SOURCE_WAIT_MARGIN_MS = 15_000;
-/** O que um valor de cabeçalho não pode conter: `fetch` recusa montá-lo. */
 const FORBIDDEN_HEADER_CHARS = /[\r\n\0]/u;
-/** Hosts em que falar claro é desenvolvimento, não credencial exposta. */
 const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
-/**
- * A chave é de CONTA e viaja em todo pedido: sem TLS ela vai em texto claro
- * para quem estiver no caminho. É a mesma recusa que o motor aplica à própria
- * URL de produção — só o host local fica de fora, porque ali não há caminho.
- */
 function requireSecureBaseUrl(baseUrl) {
     let parsed;
     try {
@@ -65,12 +35,6 @@ function readHeaderNumber(headers, name) {
     const parsed = Number(raw);
     return Number.isFinite(parsed) ? parsed : null;
 }
-/**
- * O teto por minuto sai em TODA resposta autenticada, não só na recusa. Lê-lo
- * no sucesso é o que permite ao consumidor desacelerar ANTES de bater no 429.
- * O `Retry-After` só conta na recusa: no sucesso ele é a espera que a fonte
- * pediu a uma leitura socorrida pelo acervo, e sai em `meta.lakeRescue`.
- */
 function readRateLimit(headers, succeeded) {
     const limit = readHeaderNumber(headers, "RateLimit-Limit");
     const remaining = readHeaderNumber(headers, "RateLimit-Remaining");
@@ -111,14 +75,6 @@ function appendQuery(url, query) {
         }
     }
 }
-/**
- * O prazo da chamada que não trouxe `timeoutMs` próprio.
- *
- * Numa leitura que espera pela fonte, o motor pode levar a espera inteira
- * antes de responder — a de `waitSeconds` ou, sem ele, a padrão da API: o
- * prazo cobre essa espera mais a margem e nunca fica abaixo do prazo do
- * cliente. Nas outras rotas, vale o prazo do cliente.
- */
 function defaultCallTimeoutMs(method, path, carriers, clientTimeoutMs) {
     const carrier = SOURCE_WAIT_ROUTES.get(`${method} ${path}`);
     if (!carrier)
@@ -132,15 +88,6 @@ function defaultCallTimeoutMs(method, path, carriers, clientTimeoutMs) {
         : SOURCE_WAIT_API_DEFAULT_SECONDS;
     return Math.max(clientTimeoutMs, waitSeconds * 1_000 + SOURCE_WAIT_MARGIN_MS);
 }
-/**
- * Junta o prazo do cliente ao `signal` de quem chamou.
- *
- * Os dois abortam a mesma requisição, e trocar um pelo outro perde metade do
- * controle: sem o prazo, uma chamada sem resposta fica pendurada; sem o sinal
- * de quem chamou, o cancelamento da requisição de cima não alcança a de baixo.
- * O motivo do aborto é preservado para o prazo virar 504 e o cancelamento de
- * fora continuar sendo cancelamento.
- */
 function linkAbort(timeoutMs, caller) {
     const controller = new AbortController();
     let timedOut = false;
@@ -184,19 +131,6 @@ function sleep(ms, signal) {
         signal?.addEventListener("abort", onAbort, { once: true });
     });
 }
-/**
- * Se vale repetir esta chamada.
- *
- * A classe do erro diz se a condição passa sozinha; o método e a ROTA dizem se
- * repetir é seguro. Uma escrita fora da lista só é repetida quando quem chama
- * declara `idempotent: true` — quem conhece o próprio uso pode afirmar o que o
- * contrato não afirma, mas a afirmação é dele, e explícita.
- *
- * O tempo esgotado da fonte (`UPSTREAM_TIMEOUT`) numa leitura que espera por
- * ela não se repete: o motor já esperou tudo o que a chamada pediu, e repetir
- * na hora dobra a espera diante da mesma fonte lenta. As demais recusas
- * retentáveis dessas leituras seguem a política.
- */
 function mayRetry(error, method, path, options) {
     if (!(error instanceof LexNodeError) || !error.retryable)
         return false;
@@ -213,22 +147,11 @@ function mayRetry(error, method, path, options) {
 }
 function retryDelayMs(policy, attempt, error) {
     if (error.retryAfterSeconds !== null && error.retryAfterSeconds >= 0) {
-        return Math.min(error.retryAfterSeconds * 1_000, policy.maxDelayMs);
+        const asked = error.retryAfterSeconds * 1_000;
+        return asked > policy.maxDelayMs ? null : asked;
     }
     return Math.min(policy.baseDelayMs * 2 ** (attempt - 1), policy.maxDelayMs);
 }
-/**
- * O cliente de runtime do motor de dados jurídicos.
- *
- * **Servidor apenas, e só por TLS.** A credencial é de CONTA: uma chave no
- * browser é uma chave publicada, e uma chave em `http://` é uma chave lida por
- * quem estiver no caminho — `baseUrl` sem https é recusada aqui, exceto em
- * host local. Um app com usuários finais fala com o próprio backend, e é o
- * backend que fala com o motor — atribuindo cada chamada ao seu sub-tenant por
- * `X-Office-Id`.
- *
- * Sem dependências de runtime: `fetch` global e `node:crypto`.
- */
 export function createLexNodeClient(options) {
     requireSecureBaseUrl(options.baseUrl);
     const baseUrl = options.baseUrl.replace(/\/+$/u, "");
@@ -251,9 +174,6 @@ export function createLexNodeClient(options) {
             headers["user-agent"] = options.userAgent;
         if (bag.body !== undefined)
             headers["content-type"] = "application/json";
-        // Cabeçalho e corpo são montados ANTES de abrir o socket: o que o
-        // transporte recusa montar é defeito do pedido, não falha passageira de
-        // rede, e repetir o que nunca saiu só gasta as tentativas.
         for (const [name, value] of Object.entries(headers)) {
             if (FORBIDDEN_HEADER_CHARS.test(value)) {
                 throw LexNodeError.invalidRequest(`O cabeçalho ${name} tem quebra de linha ou caractere nulo.`);
@@ -278,20 +198,14 @@ export function createLexNodeClient(options) {
                 headers,
                 body: payload,
                 signal: link.signal,
-                // O contrato não redireciona; seguir um 30x entregaria ao consumidor o
-                // corpo de outro host como se fosse a resposta do motor.
                 redirect: "error",
             });
             rateLimit = readRateLimit(response.headers, response.ok);
-            // A leitura do corpo fica DENTRO do prazo: um corpo que trava depois dos
-            // cabeçalhos pendura a chamada por tempo indefinido se o vínculo já tiver
-            // sido desfeito aqui.
             raw = await response.text();
         }
         catch (error) {
             if (link.timedOut)
                 throw LexNodeError.timeout(timeoutMs, error);
-            // Cancelamento de quem chamou não é falha da API: sobe como veio.
             if (args.signal?.aborted)
                 throw error;
             throw LexNodeError.network(error);
@@ -324,13 +238,6 @@ export function createLexNodeClient(options) {
             },
         };
     }
-    /**
-     * A chamada genérica, tipada pela rota e pelo método do contrato.
-     *
-     * Uma função cobre a superfície inteira: rota nova ou campo novo no
-     * `openapi.json` chega tipado sem uma linha a mais aqui. Os métodos nomeados
-     * abaixo só dão nome ao que um consumidor usa todo dia.
-     */
     async function request(path, method, args) {
         const requestId = args.requestId ?? `req_${randomUUID()}`;
         const traceId = args.traceId ?? `trc_${randomUUID()}`;
@@ -354,7 +261,10 @@ export function createLexNodeClient(options) {
                     })) {
                     throw error;
                 }
-                await sleep(retryDelayMs(delays, round, error), args.signal);
+                const delay = retryDelayMs(delays, round, error);
+                if (delay === null)
+                    throw error;
+                await sleep(delay, args.signal);
                 round += 1;
             }
         }
@@ -430,13 +340,6 @@ export function createLexNodeClient(options) {
             delete: (body, opts = {}) => request("/v1/subscriptions", "delete", { body, ...opts }),
         },
         processLookups: {
-            /**
-             * A leitura de UM processo que segue em segundo plano quando a fonte não
-             * entrega dentro de `waitSeconds`: 200 com o processo, ou 202 com a
-             * consulta aberta. Repetir é seguro — o motor devolve a consulta já
-             * aberta da mesma leitura em vez de abrir outra —, então a retentativa
-             * vale para ela como para uma leitura.
-             */
             create: (body, opts = {}) => request("/v1/processes/lookups", "post", {
                 body,
                 idempotent: true,