@oconde/radar 0.0.0-stage → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+## 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/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fernando Conde
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/PROTOCOL.md

@@ -0,0 +1,185 @@
+# Protocolo Radar v1
+
+Este documento descreve o envio de eventos ao Radar para quem escreve um SDK em outra linguagem. A fonte da verdade dos tipos é `src/protocol/index.ts`.
+
+## Envio
+
+```
+POST https://radar-ingest.oconde.dev/api/v1/events
+Authorization: Bearer rk_<40 caracteres>
+Content-Type: application/json
+Content-Encoding: gzip            (opcional)
+```
+
+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
+
+```ts
+export const PROTOCOL_VERSION = 1;
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+export type EventBatch = {
+  v: 1;
+  sdk: { name: string; version: string };
+  environment?: string;
+  release?: string;
+  dropped?: number;
+  events: RadarEvent[];
+};
+
+export type RadarEvent = LogEvent | ErrorEvent;
+
+export type LogEvent = {
+  type: 'log';
+  ts: number;
+  level: LogLevel;
+  message: string;
+  requestId?: string;
+  attrs?: Record<string, unknown>;
+  request?: RequestInfo;
+  user?: UserInfo;
+};
+
+export type ErrorEvent = {
+  type: 'error';
+  ts: number;
+  level: 'error' | 'fatal';
+  handled: boolean;
+  requestId?: string;
+  exception: ExceptionInfo;
+  request?: RequestInfo;
+  user?: UserInfo;
+  runtime?: RuntimeInfo;
+  attrs?: Record<string, unknown>;
+};
+
+export type ExceptionInfo = {
+  type: string;
+  message: string;
+  frames: StackFrame[];
+  cause?: ExceptionInfo;
+};
+
+export type StackFrame = {
+  fn?: string;
+  file: string;
+  line?: number;
+  col?: number;
+  inApp: boolean;
+  context?: { pre: string[]; line: string; post: string[] };
+};
+
+export type RequestInfo = {
+  method: string;
+  url: string;
+  route?: string;
+  params?: Record<string, string>;
+  query?: Record<string, unknown>;
+  headers?: Record<string, string>;
+  body?: unknown;
+  ip?: string;
+  userAgent?: string;
+  status?: number;
+  durationMs?: number;
+};
+
+export type UserInfo = { id?: string; email?: string; name?: string };
+
+export type RuntimeInfo = {
+  name: 'node';
+  version: string;
+  host?: string;
+  pid?: number;
+  memoryMb?: number;
+  uptimeS?: number;
+};
+
+export type IngestResponse = { accepted: number; dropped: number };
+
+export type IngestErrorCode =
+  | 'invalid_key'
+  | 'account_disabled'
+  | 'payload_too_large'
+  | 'invalid_batch'
+  | 'quota_exceeded'
+  | 'rate_limited';
+
+export type IngestError = { error: { code: IngestErrorCode; message: string } };
+```
+
+- `ts` em milissegundos desde a época. Se estiver mais de 24 h longe do relógio do servidor, vale a hora de recebimento.
+- `message` do log é a chave do evento. Convenção: mensagem estável (`webhook.olx.lead`, `http.request`, `api listening`) e o que varia vai em `attrs`. A regra de ausência compara a `message` exata.
+- `dropped` é quantos eventos o SDK descartou desde o último lote aceito (fila cheia); o servidor soma em `usage_daily.dropped` e a tela do projeto mostra.
+
+## Respostas
+
+| Status | Corpo | Quando | O SDK faz |
+|---|---|---|---|
+| 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 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.
+
+
+## Limites recomendados no SDK
+
+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 |
+|---|---|
+| `message` | 2000 caracteres |
+| strings em `attrs`, `query`, `body` | 2000 caracteres |
+| `attrs` serializado | 16 KB |
+| `body` serializado | 16 KB |
+| headers | 50 |
+| frames por exceção | 50 |
+| frames com `context` | 10 do próprio app, 5 linhas antes e depois, 300 caracteres por linha |
+| cadeia de `cause` | 5 níveis |
+| profundidade de objetos | 6 |
+| itens por array | 50 |
+| `requestId` | 128 caracteres |

package/README.md

@@ -1,3 +1,120 @@
-# Temporary Holding Version
+# @oconde/radar
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+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
+
+```bash
+npm install @oconde/radar
+```
+
+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
+
+```ts
+import { Module } from '@nestjs/common';
+import { RadarModule } from '@oconde/radar/nest';
+
+@Module({
+  imports: [RadarModule.forRoot({ key: process.env.RADAR_KEY, release: process.env.GIT_SHA })],
+})
+export class AppModule {}
+```
+
+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
+import { radar } from '@oconde/radar';
+
+radar.info('webhook.olx.lead', { leadId });
+```
+
+## Express
+
+```ts
+import { radar } from '@oconde/radar';
+
+radar.init({ key: process.env.RADAR_KEY });
+app.use(radar.middleware());
+```
+
+Depois das rotas, para os erros dos handlers chegarem ao Radar:
+
+```ts
+import type { ErrorRequestHandler } from 'express';
+
+const reportErrors: ErrorRequestHandler = (error, req, res, next) => {
+  radar.captureError(error);
+  next(error);
+};
+
+app.use(reportErrors);
+```
+
+Exemplo completo em [Express e Node](https://radar.oconde.dev/docs/sdk/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, release: process.env.GIT_SHA });
+
+export const handle = sequence(radarHandle(), yourHandle);
+export const handleError = radarHandleError();
+```
+
+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 })`.
+
+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:
+
+```ts title="src/routes/api/radar/client-errors/+server.ts"
+import { radarClientErrors } from '@oconde/radar/sveltekit';
+
+export const POST = radarClientErrors();
+```
+
+```ts
+import { handleErrorWithRadar, listenForClientErrors } from '@oconde/radar/browser';
+
+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 `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/).
+
+## Tarefas agendadas
+
+```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/).
+
+## Erros com o seu código
+
+Ligue no `tsconfig` para os erros mostrarem as linhas do TypeScript:
+
+```json
+{ "compilerOptions": { "sourceMap": true, "inlineSources": true } }
+```
+
+## Na documentação
+
+- [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)
+
+## Licença
+
+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
+`);