@oconde/radar 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+## 0.3.0
+
+### Novo
+
+- `traceFetch`: cada `fetch` de saída vira um log `http.client` com método, host, caminho (sem a query, com trechos que parecem segredo mascarados), status e duração, ou o erro com a causa (`fetch failed (ECONNREFUSED)`). Para os hosts de `propagateTo`, o SDK manda o `x-request-id` da requisição atual, sem trocar um que o app já tenha posto. Chamadas para o próprio Radar ficam de fora. Desligado por padrão.
+
+### Correções
+
+- O nome da função inferido do código original não se confunde mais com chaves e com a palavra `function` dentro de comentários de várias linhas (como os de JSDoc).
+
+## 0.2.0
+
+### Novo
+
+- `@oconde/radar/sveltekit`: `radarHandle` (contexto, `x-request-id`, log `http.request`; opção `requestId` para usar o id do app), `radarHandleError`, `radarClientErrors` (rota que recebe erros do navegador), `moveClientSourceMaps` e `composeServerSourceMaps`.
+- `@oconde/radar/browser`: `reportClientError`, `handleErrorWithRadar` e `listenForClientErrors`, sem dependência de Node.
+- Erros do navegador trazem o que a pessoa fez logo antes: `listenForClientErrors` guarda o último clique ou envio de formulário (elemento e texto visível, nunca o valor digitado; links com texto longo, números ou `@` vão sem o texto, e e-mails e números viram `<email>` e `<número>`) e a rota grava em `ui.action`, `ui.element`, `ui.label` e `ui.msBefore`. No modo `requestDetail: 'route'` o texto do elemento não é enviado. `captureActions: false` desliga.
+- Frames do navegador ganham o nome da função do código original (inferido do source map), em vez de ficarem sem nome.
+- Comando `radar-sourcemaps [buildDir]`: depois do `vite build`, tira os source maps de `build/client` e reescreve os caminhos para continuarem apontando para o código. Também junta os dois níveis de mapa do servidor (o do Vite e o do `adapter-node`), para a stack do servidor apontar direto para o arquivo em `src/`, e não para `.svelte-kit/output/server`.
+- `radar.withContext`, `radar.checkIn` e `radar.cron` para workers e tarefas agendadas.
+- `radar.captureException` para quem já tem a exceção montada.
+
+### Mudanças de comportamento
+
+- **Agrupamento de erros:** frames que, pelo source map, caem em `node_modules` deixam de contar como código do app, e arquivos gerados com `sourcemap: 'hidden'` passam a usar o `.map` ao lado. As duas coisas mudam a impressão digital de alguns erros: no deploy que atualizar o SDK, erros já conhecidos podem reaparecer como novos uma vez.
+- `radarHandleError()` e `handleErrorWithRadar()` sem handler interno imprimem o erro no console e deixam o SvelteKit usar a mensagem padrão (antes devolviam "Internal Error", inclusive no 404).
+- Um `x-request-id` com caracteres fora do ASCII imprimível é trocado por um id gerado.
+- Check-ins cortam `environment` em 64 caracteres, `release` em 128 e `durationMs` em 7 dias, como o servidor exige.
+
+### Correções
+
+- Express: segredos em parâmetros do caminho (como `/reset/:token`) eram enviados sem máscara quando a requisição terminava no middleware de erro do app.
+
+## 0.1.0
+
+Primeira versão: NestJS, Express, logs, erros com trecho de código, requisições e mascaramento de dados sensíveis.

package/PROTOCOL.md

@@ -11,7 +11,7 @@ Content-Type: application/json
 Content-Encoding: gzip            (opcional)
 ```
 
-Limites: corpo de até 1 MB depois de descompactado, até 500 eventos por lote.
+Limites: até 500 eventos por lote e 1 MB de corpo, tanto nos bytes recebidos quanto no JSON depois de descompactado. `Content-Encoding` aceita só `gzip` ou nenhum.
 
 ## Tipos
 
@@ -117,14 +117,48 @@ export type IngestError = { error: { code: IngestErrorCode; message: string } };
 
 | Status | Corpo | Quando | O SDK faz |
 |---|---|---|---|
-| 202 | `IngestResponse` | lote aceito, mesmo que parcialmente: eventos inválidos ou de `type` desconhecido entram em `dropped` | segue |
-| 400 | `invalid_batch` | o envelope não é um `EventBatch` (sem `v: 1`, sem `events`) | descarta o lote, avisa uma vez |
+| 202 | `IngestResponse` | lote aceito, mesmo que parcialmente: eventos inválidos, de `type` desconhecido ou acima da cota do dia entram em `dropped` | segue |
+| 400 | `invalid_batch` | JSON inválido, `Content-Encoding` diferente de `gzip`, ou o envelope não é um `EventBatch` (sem `v: 1`, sem `sdk`, sem `events`) | descarta o lote, avisa uma vez |
 | 401 | `invalid_key` | chave ausente, inexistente ou revogada | pausa os envios por 10 min, descarta a fila, avisa uma vez |
-| 403 | `account_disabled` | conta desativada | igual ao 401 |
-| 413 | `payload_too_large` | acima de 1 MB ou 500 eventos | descarta o lote |
-| 429 | `quota_exceeded` / `rate_limited`, com `Retry-After` em segundos | cota do dia ou excesso de requisições | devolve o lote à fila e espera o `Retry-After` |
+| 403 | `account_disabled` | conta desativada ou projeto apagado | igual ao 401 |
+| 413 | `payload_too_large` | acima de 1 MB ou de 500 eventos | descarta o lote |
+| 429 | `rate_limited`, com `Retry-After: 1` | excesso de requisições da mesma chave | devolve o lote à fila e espera o `Retry-After` |
+| 429 | `quota_exceeded`, com `Retry-After` até a virada do dia | a cota do dia acabou e nenhum evento do lote coube | devolve o lote à fila e espera o `Retry-After` |
 | 5xx / rede | — | servidor fora | devolve o lote à fila e tenta com espera crescente |
 
+Quando a cota do dia acaba, o Radar avisa uma vez por dia em todos os canais ativos da conta.
+
+## Check-in de tarefa agendada
+
+```
+POST https://radar-ingest.oconde.dev/api/v1/checkins/<slug>
+Authorization: Bearer rk_<40 caracteres>
+Content-Type: application/json
+
+{ "status": "in_progress" | "ok" | "error", "checkInId"?: string, "durationMs"?: number, "environment"?: string, "release"?: string }
+```
+
+- `slug`: `^[a-z0-9][a-z0-9-]{0,63}$`, o mesmo do monitor criado no Radar, no projeto da chave.
+- `checkInId` (até 64 caracteres) liga o `in_progress` ao `ok` ou `error` da mesma execução. Sem ele, `ok` e `error` fecham a execução aberta mais recente.
+- `202 { "accepted": true }`. `404 unknown_monitor` quando o slug não existe no projeto da chave, `400 invalid_checkin` para corpo fora do formato, e `401`, `403` e `429` como no envio de eventos.
+- O SDK manda na hora, sem fila, e nunca lança: `radar.checkIn(slug, status, { checkInId, durationMs })` ou `radar.cron(slug, fn)`.
+
+Exemplo para um script sem o SDK:
+
+```bash
+curl -fsS -X POST -H "Authorization: Bearer $RADAR_KEY" -H 'content-type: application/json' \
+  -d '{"status":"ok"}' https://radar-ingest.oconde.dev/api/v1/checkins/walg-archive-check
+```
+
+## Resumo de release
+
+```
+GET https://radar-ingest.oconde.dev/api/v1/releases/<release>
+Authorization: Bearer rk_<40 caracteres>
+```
+
+`200 { "release", "firstSeen": iso | null, "newIssues": n, "events": n, "issues": [{ "title", "culprit", "count", "url" }] }`, com até 5 erros (mais ocorrências primeiro), só do projeto da chave. Serve para o pipeline de deploy olhar a release logo depois de publicar.
+
 ## Compatibilidade
 
 O v1 só cresce: campo opcional novo pode; mudar o significado, tornar obrigatório ou remover não pode. O servidor ignora campos desconhecidos. Mudança que quebra vira `/api/v2/events`, com o v1 mantido.
@@ -132,7 +166,9 @@ O v1 só cresce: campo opcional novo pode; mudar o significado, tornar obrigató
 
 ## Limites recomendados no SDK
 
-O servidor corta o que passar destes limites; o SDK deve cortar antes de enviar.
+O servidor também corta, com regras um pouco diferentes: a `message` do log em 2000 bytes (UTF-8), a mensagem da exceção em 2000 caracteres, `attrs`, `query` e headers em 16 KB, `params` em 4 KB e `body` em 16 KB. Um campo JSON acima do limite vira `{ "_truncated": "<começo do JSON>" }`. Abaixo de 64 níveis de profundidade o servidor troca o valor por `null`; o SDK corta em 6.
+
+O SDK deve cortar antes de enviar:
 
 | Item | Limite |
 |---|---|

package/README.md

@@ -1,6 +1,8 @@
 # @oconde/radar
 
-SDK do [Radar](https://radar.oconde.dev) para Node.js e NestJS: logs, erros com trecho de código e contexto de requisição. Sem dependências em runtime.
+SDK do [Radar](https://radar.oconde.dev) para Node.js, NestJS e SvelteKit: logs, erros com trecho de código, contexto de requisição, tarefas agendadas e erros do navegador. Sem dependências em runtime.
+
+**Documentação completa: https://radar.oconde.dev/docs/**
 
 ## Instalação
 
@@ -8,7 +10,7 @@ SDK do [Radar](https://radar.oconde.dev) para Node.js e NestJS: logs, erros com
 npm install @oconde/radar
 ```
 
-Node 20 ou mais novo. Funciona em ESM e CommonJS, do NestJS 10 em diante.
+Node 20 ou mais novo. Funciona em ESM e CommonJS, do NestJS 10 em diante. Gere a chave do projeto no painel do Radar e ponha em `RADAR_KEY`.
 
 ## NestJS
 
@@ -22,103 +24,105 @@ import { RadarModule } from '@oconde/radar/nest';
 export class AppModule {}
 ```
 
-Com `ConfigService`:
+O módulo registra o contexto por requisição, um log `http.request` por requisição e a captura dos erros 5xx. Nos services:
 
 ```ts
-RadarModule.forRootAsync({
-  inject: [ConfigService],
-  useFactory: (config: ConfigService) => ({ key: config.get('RADAR_KEY') }),
-});
-```
+import { radar } from '@oconde/radar';
 
-O módulo registra sozinho o contexto por requisição, um log `http.request` por requisição e a captura dos erros 5xx lançados nos handlers. Chame `app.enableShutdownHooks()` para o Radar enviar a fila ao desligar.
+radar.info('webhook.olx.lead', { leadId });
+```
 
-Nos services, nada precisa ser injetado:
+## Express
 
 ```ts
 import { radar } from '@oconde/radar';
 
-radar.info('webhook.olx.lead', { leadId });
+radar.init({ key: process.env.RADAR_KEY });
+app.use(radar.middleware());
 ```
 
-Quem prefere injeção usa `RadarService`, que tem os mesmos métodos.
-
-Erros lançados em guards e pipes não passam pelo interceptor. Se o app não tem filtro de exceção próprio, registre o do Radar:
+Depois das rotas, para os erros dos handlers chegarem ao Radar:
 
 ```ts
-import { APP_FILTER } from '@nestjs/core';
-import { RadarExceptionFilter } from '@oconde/radar/nest';
+import type { ErrorRequestHandler } from 'express';
 
-providers: [{ provide: APP_FILTER, useClass: RadarExceptionFilter }];
+const reportErrors: ErrorRequestHandler = (error, req, res, next) => {
+  radar.captureError(error);
+  next(error);
+};
+
+app.use(reportErrors);
 ```
 
-Se já tem, acrescente no `catch` dele: `if (status >= 500) radar.captureError(exception)`. O mesmo erro nunca é enviado duas vezes.
+Exemplo completo em [Express e Node](https://radar.oconde.dev/docs/sdk/express/).
 
-## Express
+## SvelteKit
 
 ```ts
+import { sequence } from '@sveltejs/kit/hooks';
 import { radar } from '@oconde/radar';
+import { radarHandle, radarHandleError } from '@oconde/radar/sveltekit';
 
-radar.init({ key: process.env.RADAR_KEY });
-app.use(radar.middleware());
+radar.init({ key: process.env.RADAR_KEY, release: process.env.GIT_SHA });
+
+export const handle = sequence(radarHandle(), yourHandle);
+export const handleError = radarHandleError();
 ```
 
-## API
+Se o app já gera o próprio id de requisição, passe-o e coloque o `radarHandle` depois do handle que o cria: `radarHandle({ requestId: (event) => event.locals.requestId })`.
 
-| Função | O que faz |
-|---|---|
-| `radar.init(options)` | configura uma vez; chamadas seguintes são ignoradas |
-| `radar.debug/info/warn/error(message, data?)` | log com `data` como atributos; dentro de uma requisição sai com o `requestId` e o usuário |
-| `radar.logRequest(title, data?, { level?, redact? }?)` | log com a requisição atual inteira: método, URL, rota, params, query, headers, body, IP |
-| `radar.captureError(error, data?)` | erro com stack, trecho de código, requisição, usuário e runtime |
-| `radar.setUser({ id, email, name })` | usuário da requisição atual |
-| `radar.track(name, fn, data?)` | mede `fn`, registra sucesso ou falha com `durationMs`, captura e relança o erro |
-| `radar.middleware()` | middleware Express de contexto (`x-request-id`) |
-| `radar.flush(timeoutMs?)` / `radar.close(timeoutMs?)` | envia a fila; `close` também desliga |
-| `radar.settings` | opções em uso (só leitura); `radar.settings.console` diz se o Radar já imprime no stdout, útil para um logger próprio não duplicar linhas |
+Erros do navegador vão por uma rota do próprio app, sem expor a chave. Ela limita tamanho e frequência por visitante e no total; atrás de proxy, configure `ADDRESS_HEADER`/`XFF_DEPTH` do adapter-node para o IP do visitante ser o real:
 
-Mensagens de log são chaves estáveis (`webhook.olx.lead`); o que varia vai em `data`.
+```ts title="src/routes/api/radar/client-errors/+server.ts"
+import { radarClientErrors } from '@oconde/radar/sveltekit';
 
-## Opções
+export const POST = radarClientErrors();
+```
 
-| Opção | Padrão | |
-|---|---|---|
-| `key` | — | sem chave nada é enviado |
-| `endpoint` | `https://radar-ingest.oconde.dev` | |
-| `environment` | `NODE_ENV` ou `production` | |
-| `release` | — | ex.: o SHA do commit |
-| `console` | `false` | imprime cada log como JSON no stdout, mesmo sem chave |
-| `minLevel` | `info` | |
-| `redact` | `mask` | `none` guarda tokens e senhas inteiros |
-| `requestDetail` | `full` | `route` manda da requisição só o método e a rota (`/students/:studentId`), com status e duração: sem URL concreta, query, params, headers, corpo, IP nem user agent. Para apps com dado sensível (saúde, LGPD) |
-| `logRequests` | `true` | log `http.request` automático |
-| `ignorePaths` | `['/healthz', '/health']` | |
-| `captureUnhandled` | `true` | `uncaughtException` e `unhandledRejection`; o processo cai como cairia sem o Radar |
-| `debug` | `false` | mostra problemas internos do SDK |
+```ts
+import { handleErrorWithRadar, listenForClientErrors } from '@oconde/radar/browser';
 
-## Dados sensíveis
+listenForClientErrors();
+export const handleError = handleErrorWithRadar();
+```
+
+O erro do navegador chega com o que a pessoa fez logo antes (por exemplo, "clicou no botão Aplicar cupom"): o último clique ou envio de formulário até 10 s antes, com o texto visível do elemento e nunca o que foi digitado. `listenForClientErrors({ captureActions: false })` desliga.
 
-Com `redact: 'mask'` (padrão), o SDK mascara antes de enviar:
+Com `build: { sourcemap: 'hidden' }` no Vite e `radar-sourcemaps` depois do build, os mapas saem de `build/client`, os do servidor passam a apontar direto para `src/`, e os erros mostram o código original. Detalhes em [SvelteKit](https://radar.oconde.dev/docs/sdk/sveltekit/) e [Erros do navegador](https://radar.oconde.dev/docs/sdk/browser/).
 
-- headers e chaves (no corpo, na query, nos parâmetros da rota, no caminho da URL e nos atributos) cujo nome tenha uma destas palavras: `password`, `senha`, `secret`, `token`, `auth`, `authorization`, `cookie`, `apikey`, `api key`, `private key`, `access key`, `signature`, `jwt`, `session`, `credential`, `cpf`, `card`, `cvv`, `cvc`, `pin`, `otp`, além da chave `key` sozinha e dos headers `x-…-key`, `x-…-secret` e `x-…-token`. A comparação é por palavra: `cardio` e `passos` não são mascarados;
-- qualquer valor com cara de credencial (`Bearer …`, `Basic …`, JWT), seja qual for a chave.
+## Tarefas agendadas
 
-Tokens e chaves saem como `Bearer eyJh…5x9Q #a1b2c3d4`: dá para ver se veio, qual era e se dois valores são iguais. Senhas, CPF, cartão, CVV, PIN e OTP saem só como `••• #a1b2c3d4`, sem nenhum pedaço do valor. A impressão digital é um HMAC com chave derivada da chave do projeto, então não dá para descobrir o valor por força bruta sem ela.
+```ts
+await radar.cron('nightly-report', () => buildReport());
+```
+
+`radar.cron` avisa o Radar no início, no fim e na falha, e o Radar alerta se a tarefa atrasar ou falhar. Em scripts sem o SDK, o check-in é um `POST` (veja o [PROTOCOL.md](PROTOCOL.md)). Para jobs e workers, `radar.withContext(fn)` dá a cada execução o próprio `requestId`. Detalhes em [Tarefas agendadas](https://radar.oconde.dev/docs/sdk/cron/).
+
+## Chamadas para outros serviços
+
+```ts
+radar.init({ key: process.env.RADAR_KEY, traceFetch: { propagateTo: ['api.spinlab.dev', '.oconde.dev'] } });
+```
 
-`redact: 'none'` (no `init` ou por chamada de `logRequest`) guarda os valores inteiros.
+Com `traceFetch`, cada `fetch` que o app faz vira um log `http.client` com método, host, caminho (sem a query, e com trechos que parecem token mascarados), status e duração, ou o erro quando a chamada nem chega a responder. Dentro de uma requisição, o log entra na linha do tempo dela. Para os hosts de `propagateTo` (o nome exato, `.dominio` para os subdomínios ou uma RegExp), o SDK manda o `x-request-id` da requisição atual, e o Radar mostra a mesma requisição nos dois projetos. `traceFetch: true` registra as chamadas sem mandar o id para ninguém. Chamadas para o próprio Radar ficam de fora.
 
-## Trecho de código nos erros
+## Erros com o seu código
 
-O SDK lê os source maps sozinho. Em projetos TypeScript, ligue no `tsconfig`:
+Ligue no `tsconfig` para os erros mostrarem as linhas do TypeScript:
 
 ```json
 { "compilerOptions": { "sourceMap": true, "inlineSources": true } }
 ```
 
-Com `inlineSources`, o código vai dentro do `.map` e a imagem de produção não precisa conter `src/`.
+## Na documentação
 
-## Garantias
+- [Começar em 5 minutos](https://radar.oconde.dev/docs/start/getting-started/)
+- [Todas as opções](https://radar.oconde.dev/docs/sdk/options/)
+- [Dados sensíveis e `requestDetail: 'route'`](https://radar.oconde.dev/docs/sdk/sensitive-data/)
+- [Garantias: fila, lotes e o que acontece quando o Radar cai](https://radar.oconde.dev/docs/sdk/guarantees/)
+- [Referência da API](https://radar.oconde.dev/docs/reference/sdk-api/)
+- [Protocolo de envio](https://radar.oconde.dev/docs/reference/protocol/) (também em [PROTOCOL.md](PROTOCOL.md), para quem escreve um SDK em outra linguagem)
 
-Nenhuma função lança erro para o app (exceto `track`, que relança o erro de `fn`). A fila fica em memória (até 1000 eventos), é enviada a cada 2 s ou 100 eventos e tenta de novo com espera crescente se o Radar estiver fora. O SDK não registra `SIGTERM`.
+## Licença
 
-Formato dos dados enviados: [PROTOCOL.md](PROTOCOL.md).
+MIT

package/dist/bin/radar-sourcemaps.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+
+// src/sveltekit/sourcemaps.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+
+// src/sveltekit/vlq.ts
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var DIGITS = new Map([...ALPHABET].map((char, index) => [char, index]));
+var FIELDS = 5;
+function decodeGroup(group) {
+  const values = [];
+  let value = 0;
+  let factor = 1;
+  for (const char of group) {
+    const digit = DIGITS.get(char);
+    if (digit === void 0) throw new Error(`invalid source map mapping: ${group}`);
+    value += digit % 32 * factor;
+    if (digit >= 32) {
+      factor *= 32;
+      continue;
+    }
+    const magnitude = Math.floor(value / 2);
+    values.push(value % 2 === 1 ? -magnitude : magnitude);
+    value = 0;
+    factor = 1;
+  }
+  return values;
+}
+function encodeValue(delta) {
+  let value = delta < 0 ? -delta * 2 + 1 : delta * 2;
+  let encoded = "";
+  do {
+    const digit = value % 32;
+    value = Math.floor(value / 32);
+    encoded += ALPHABET[value > 0 ? digit + 32 : digit];
+  } while (value > 0);
+  return encoded;
+}
+function decodeMappings(mappings) {
+  const state = new Array(FIELDS).fill(0);
+  return mappings.split(";").map((line) => {
+    state[0] = 0;
+    const segments = [];
+    for (const group of line.split(",")) {
+      if (!group) continue;
+      const values = decodeGroup(group).slice(0, FIELDS);
+      segments.push(values.map((delta, field) => state[field] = (state[field] ?? 0) + delta));
+    }
+    return segments;
+  });
+}
+function encodeMappings(lines) {
+  const state = new Array(FIELDS).fill(0);
+  return lines.map((segments) => {
+    state[0] = 0;
+    return segments.map(
+      (segment) => segment.map((value, field) => {
+        const delta = value - (state[field] ?? 0);
+        state[field] = value;
+        return encodeValue(delta);
+      }).join("")
+    ).join(",");
+  }).join(";");
+}
+
+// src/sveltekit/sourcemaps.ts
+function filesUnder(directory) {
+  return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const full = join(directory, entry.name);
+    if (entry.isDirectory()) return filesUnder(full);
+    return entry.isFile() ? [full] : [];
+  });
+}
+function rebase(source, fromDir, root, toDir) {
+  if (typeof source !== "string" || isAbsolute(source) || source.includes("://")) return source;
+  return relative(toDir, resolve(fromDir, root, source)).split(sep).join("/");
+}
+function moveMap(file, target, originalDir) {
+  try {
+    const map = JSON.parse(readFileSync(file, "utf8"));
+    if (Array.isArray(map.sources)) {
+      const root = typeof map.sourceRoot === "string" ? map.sourceRoot : "";
+      map.sources = map.sources.map((source) => rebase(source, originalDir, root, dirname(target)));
+      delete map.sourceRoot;
+    }
+    writeFileSync(target, JSON.stringify(map));
+    unlinkSync(file);
+  } catch {
+    renameSync(file, target);
+  }
+}
+function moveClientSourceMaps(buildDir2 = "build") {
+  const clientDir = resolve(buildDir2, "client");
+  const mapsDir = resolve(buildDir2, "client-maps");
+  const generatedDir = resolve(buildDir2, "..", ".svelte-kit/output/client");
+  if (!existsSync(clientDir)) return -1;
+  let moved2 = 0;
+  for (const file of filesUnder(clientDir)) {
+    if (file.endsWith(".map.gz") || file.endsWith(".map.br")) {
+      unlinkSync(file);
+      continue;
+    }
+    if (!file.endsWith(".map")) continue;
+    const path = relative(clientDir, file);
+    const target = join(mapsDir, path);
+    mkdirSync(dirname(target), { recursive: true });
+    const generated = join(generatedDir, path);
+    moveMap(file, target, dirname(existsSync(generated) ? generated : file));
+    moved2 += 1;
+  }
+  return moved2;
+}
+function parseSourceMap(file) {
+  try {
+    const raw = JSON.parse(readFileSync(file, "utf8"));
+    if (typeof raw.mappings !== "string" || !Array.isArray(raw.sources)) return null;
+    const root = typeof raw.sourceRoot === "string" ? raw.sourceRoot : "";
+    return {
+      raw,
+      lines: decodeMappings(raw.mappings),
+      sources: raw.sources.map((source) => typeof source === "string" ? source : ""),
+      contents: Array.isArray(raw.sourcesContent) ? raw.sourcesContent.map((content) => typeof content === "string" ? content : null) : [],
+      names: Array.isArray(raw.names) ? raw.names.map(String) : [],
+      baseDir: resolve(dirname(file), root)
+    };
+  } catch {
+    return null;
+  }
+}
+function isUrl(source) {
+  return source.includes("://");
+}
+function isInside(directory, path) {
+  const rel = relative(directory, path);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+function traceSegment(map, line, column) {
+  const segments = map.lines[line];
+  if (!segments || segments.length === 0) return null;
+  let low = 0;
+  let high = segments.length - 1;
+  let found = -1;
+  while (low <= high) {
+    const middle = low + high >> 1;
+    if ((segments[middle]?.[0] ?? 0) <= column) {
+      found = middle;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  const segment = segments[Math.max(found, 0)];
+  return segment && segment.length >= 4 ? segment : null;
+}
+var ComposedTable = class {
+  constructor(outputDir) {
+    this.outputDir = outputDir;
+  }
+  outputDir;
+  sources = [];
+  contents = [];
+  names = [];
+  sourceIndex = /* @__PURE__ */ new Map();
+  nameIndex = /* @__PURE__ */ new Map();
+  source(baseDir, source, content) {
+    const key = isUrl(source) || isAbsolute(source) ? source : relative(this.outputDir, resolve(baseDir, source)).split(sep).join("/");
+    const existing = this.sourceIndex.get(key);
+    if (existing !== void 0) return existing;
+    this.sourceIndex.set(key, this.sources.length);
+    this.sources.push(key);
+    this.contents.push(content);
+    return this.sources.length - 1;
+  }
+  name(value) {
+    const existing = this.nameIndex.get(value);
+    if (existing !== void 0) return existing;
+    this.nameIndex.set(value, this.names.length);
+    this.names.push(value);
+    return this.names.length - 1;
+  }
+};
+function composeMap(file, generatedDir, generatedMaps) {
+  const outer = parseSourceMap(file);
+  if (!outer) return false;
+  const inners = outer.sources.map((source) => {
+    if (isUrl(source)) return null;
+    const path = resolve(outer.baseDir, source);
+    if (!isInside(generatedDir, path)) return null;
+    if (!generatedMaps.has(path)) generatedMaps.set(path, parseSourceMap(`${path}.map`));
+    return generatedMaps.get(path) ?? null;
+  });
+  if (inners.every((inner) => inner === null)) return false;
+  const table = new ComposedTable(dirname(file));
+  let traced = 0;
+  const lines = outer.lines.map(
+    (segments) => segments.map((segment) => {
+      const [column = 0, sourceIndex = 0, line = 0, originalColumn = 0, nameIndex] = segment;
+      if (segment.length < 4) return [column];
+      const inner = inners[sourceIndex];
+      const original = inner ? traceSegment(inner, line, originalColumn) : null;
+      if (inner && original) {
+        traced += 1;
+        const [, innerSource = 0, innerLine = 0, innerColumn = 0, innerName] = original;
+        const source2 = table.source(inner.baseDir, inner.sources[innerSource] ?? "", inner.contents[innerSource] ?? null);
+        const name2 = innerName !== void 0 ? inner.names[innerName] : nameIndex !== void 0 ? outer.names[nameIndex] : void 0;
+        return name2 === void 0 ? [column, source2, innerLine, innerColumn] : [column, source2, innerLine, innerColumn, table.name(name2)];
+      }
+      const source = table.source(outer.baseDir, outer.sources[sourceIndex] ?? "", outer.contents[sourceIndex] ?? null);
+      const name = nameIndex !== void 0 ? outer.names[nameIndex] : void 0;
+      return name === void 0 ? [column, source, line, originalColumn] : [column, source, line, originalColumn, table.name(name)];
+    })
+  );
+  if (traced === 0) return false;
+  const { sourceRoot: _root, ignoreList: _ignore, x_google_ignoreList: _googleIgnore, ...rest } = outer.raw;
+  const composed2 = { ...rest, sources: table.sources, sourcesContent: table.contents, names: table.names, mappings: encodeMappings(lines) };
+  writeFileSync(file, JSON.stringify(composed2));
+  return true;
+}
+function composeServerSourceMaps(buildDir2 = "build") {
+  const serverDir = resolve(buildDir2, "server");
+  const generatedDir = resolve(buildDir2, "..", ".svelte-kit/output/server");
+  if (!existsSync(serverDir) || !existsSync(generatedDir)) return 0;
+  const generatedMaps = /* @__PURE__ */ new Map();
+  let composed2 = 0;
+  for (const file of filesUnder(serverDir)) {
+    if (file.endsWith(".map") && composeMap(file, generatedDir, generatedMaps)) composed2 += 1;
+  }
+  return composed2;
+}
+
+// src/bin/radar-sourcemaps.ts
+var buildDir = process.argv[2] ?? "build";
+var moved = moveClientSourceMaps(buildDir);
+if (moved < 0) {
+  process.stderr.write(`radar: ${buildDir}/client not found; run it after vite build
+`);
+  process.exit(1);
+}
+process.stdout.write(`radar: ${moved} source maps moved from ${buildDir}/client to ${buildDir}/client-maps
+`);
+var composed = composeServerSourceMaps(buildDir);
+process.stdout.write(`radar: ${composed} server source maps in ${buildDir}/server now point to the original sources
+`);