type-atlas

Type Atlas es lo que uso para que todos mis agentes de código naveguen por todos mis proyectos de TypeScript en todas sus necesidades de navegación de código. La mayoría de esos proyectos son monorepos. Algunos son lo bastante grandes y complejos como para que entender cómo encaja un cambio en el resto del sistema sea una parte real del trabajo. Esta herramienta fue diseñada como un reemplazo completo de la metodología de navegación de código por defecto de un agente.

He estado iterando sobre esta herramienta durante meses basándome en cómo mis propios agentes de codificación trabajan realmente en mis proyectos. La mayor parte de lo que hace Type Atlas existe porque seguía viendo los mismos problemas:

• Los agentes razonan desde una visión incompleta del sistema. Pueden entender el archivo que encontraron, pero les falta el código circundante que determina cómo se supone que debe usarse.

• Los agentes reconstruyen cosas que ya existen. La capacidad ya está en el repositorio, pero el agente nunca la encuentra porque no sabe cómo se llama.

• Los agentes suelen leer o demasiado poco código (Claude) o demasiado (Codex). Demasiado poco les hace tomar decisiones sin suficiente contexto circundante. Demasiado llena la ventana de contexto con archivos completos y detalles de implementación que nunca importaron para la tarea.

• Los agentes se detienen repetidamente para ejecutar comprobaciones de tipos solo para encontrar errores que un IDE ya estaría mostrando. Eso añade latencia durante la implementación y retrasa la retroalimentación más de lo necesario.

• Los agentes operan fundamentalmente a ciegas. La navegación por búsqueda de cadenas nunca les da un atlas interno sólido del código base. Se ven obligados a tomar decisiones de implementación a partir de fragmentos de archivos y coincidencias que casualmente recuperaron, con estructura importante e información conocida por el compilador aún faltante.

A medida que los proyectos crecen, estos problemas se acumulan y empiezan a aparecer directamente en la calidad del código que escriben los agentes.

Navegación semántica de código

Los agentes de codificación navegan por el código mediante lecturas de archivos y búsquedas de cadenas por defecto. Eso les da el texto fuente y deja que el modelo reconstruya relaciones que el servicio de lenguaje de TypeScript ya conoce.

Type Atlas le da al agente acceso directo a esa información semántica:

• Un símbolo se resuelve a su definición y referencias reales, no a cada aparición del mismo texto.

• Los llamadores y las implementaciones se identifican por su relación con el símbolo.

• Los tipos inferidos provienen del servicio de lenguaje en lugar de reconstruirse a partir del código cercano.

• Los resultados conservan su rango de origen y el proyecto de TypeScript al que pertenecen.

Una coincidencia de texto sigue siendo útil cuando el texto es lo que el agente busca. Es un sustituto débil de la navegación semántica cuando la pregunta es sobre el programa en sí.

Encontrar lo que ya existe

Los códigos base grandes contienen código útil que un agente no tiene razón para conocer por nombre. La búsqueda de cadenas funciona mejor después de que el agente ya conoce suficiente vocabulario para formular la búsqueda.

Type Atlas le da otras vías de entrada:

• El agente puede describir el comportamiento en lenguaje natural y encontrar código basándose en lo que hace.

• Un resultado descubierto lleva de vuelta a un símbolo real y a un rango de origen exacto.

• Desde ese símbolo, el agente puede seguir relaciones reales a través del código base en lugar de adivinar otro identificador para buscar.

Esto es especialmente útil en monorepos grandes. Los helpers existentes y las implementaciones establecidas son más fáciles de descubrir antes de que el agente decida que necesita crear otro.

Diagnósticos durante el trabajo normal

Un desarrollador en un IDE ve la retroalimentación del compilador mientras trabaja. Los agentes de codificación suelen obtener esa retroalimentación deteniendo la implementación para ejecutar un comando de comprobación de tipos y luego esperando el resultado.

Type Atlas mueve gran parte de esa retroalimentación al trabajo que el agente ya estaba haciendo:

• Los diagnósticos relevantes pueden llegar con las respuestas normales de inteligencia de código.

• Los errores aparecen mientras el código afectado sigue siendo parte del contexto de trabajo actual del agente.

• Una suposición de tipo incorrecta puede detectarse antes de que se convierta en varias ediciones dependientes.

Todavía uso comprobaciones de tipos completas para la verificación. No necesitan ser la forma principal en que un agente se entera de errores mientras trabaja.

Las respuestas están construidas para el contexto del modelo

Hacer una respuesta más pequeña solo es útil cuando la información eliminada era innecesaria. Los modelos también usan la organización de lo que queda.

Type Atlas trata la estructura como parte de la información:

• Las etiquetas hacen explícito el papel de un resultado.

• La agrupación mantiene juntos los hechos relacionados.

• Los límites de archivo evitan que el código fuente no relacionado se mezcle.

• Las ubicaciones de origen permanecen adjuntas a lo que describen.

• Los árboles conservan su jerarquía en lugar de convertirse en una secuencia plana.

• Los diagnósticos conservan el código fuente necesario para entenderlos.

El mismo principio determina qué se omite. Los cuerpos de funciones pueden permanecer plegados cuando la firma es suficiente. La serialización repetida y el código fuente no relacionado no necesitan ocupar la ventana de contexto simplemente porque estaban disponibles.

El objetivo es la densidad de información útil. Menos tokens importan, pero eliminar la estructura que ayuda al modelo a entender esos tokens sería contraproducente.

Información para la siguiente decisión

Cada llamada a una herramienta es parte del proceso de razonamiento del agente. Una buena respuesta debería responder a la pregunta actual mientras deja al agente en una mejor posición para decidir qué inspeccionar a continuación.

Type Atlas mantiene la información de seguimiento útil cerca del resultado que la expuso:

• Un símbolo puede llegar con las relaciones necesarias para entender cómo participa en el código base.

• La estructura del repositorio puede incluir recuentos de líneas y el estado del árbol de trabajo junto con los archivos mismos.

• Los resultados de búsqueda incluyen rangos de origen concretos que se pueden seguir directamente.

• El contexto del proyecto permanece adjunto a medida que el agente se mueve de un resultado a otro.

Esto le da al agente mejor evidencia en cada rama de su investigación. Puede seguir relaciones que realmente existen en el programa en lugar de tratar cada coincidencia textual como una pista igualmente significativa.

El beneficio es una navegación de mayor calidad. Cada paso conserva más de la información necesaria para elegir el siguiente.

Conciencia de proyecto y alcance

Las preguntas de TypeScript dependen del contexto del proyecto. Eso se vuelve especialmente importante en un monorepo, donde una respuesta puede ser correcta dentro de un proyecto pero aún incompleta para el repositorio en su conjunto.

Type Atlas mantiene esos límites visibles:

• Los archivos se resuelven a través del proyecto de TypeScript que los posee.

• Los resultados indican el alcance del proyecto del que provienen cuando ese alcance importa.

• Los recuentos hacen explícito el tamaño de un resultado.

• Los límites se indican cuando una respuesta cubre menos que todo el repositorio.

• Las ubicaciones de origen se pueden pasar directamente a llamadas posteriores.

El agente obtiene suficiente información para entender qué cubre realmente una respuesta antes de confiar en ella.

Construido a partir del uso diario de agentes

Uso Type Atlas con mis propios agentes de codificación todos los días en todos mis proyectos de TypeScript. El comportamiento actual provino del uso repetido.

Gran parte del diseño se puede rastrear directamente hasta el comportamiento recurrente de los agentes:

• Las lecturas se pliegan porque los agentes gastaban contexto en cuerpos que no necesitaban.

• Los diagnósticos viajan con las respuestas normales porque los comandos repetidos de comprobación de tipos estaban desperdiciando tiempo de implementación.

• Las relaciones semánticas se agrupan porque los agentes seguían reconstruyendo la misma información a través de llamadas separadas.

• La búsqueda de código en lenguaje natural existe porque el código útil a menudo tiene un nombre que el agente nunca podría inferir de la tarea.

Así es como todavía trabajo en Type Atlas. Cuando sigo viendo a los agentes perder tiempo en el mismo problema de navegación o perder repetidamente el mismo tipo de información, cambio la herramienta.

Los ejemplos a continuación se capturan del servidor en ejecución contra un monorepo de prueba y se verifican por regresión con la implementación.

Instalación

codex mcp add type-atlas -- npx --yes @type-atlas/mcp@latest

claude mcp add --scope user type-atlas -- npx --yes @type-atlas/mcp@latest

code --add-mcp '{"name":"type-atlas","command":"npx","args":["--yes","@type-atlas/mcp@latest"]}'

Cualquier otro cliente adopta la forma estándar:

{
  "mcpServers": {
    "type-atlas": {
      "command": "npx",
      "args": ["--yes", "@type-atlas/mcp@latest"]
    }
  }
}

Un cliente que inicia servidores sin tu PATH de shell no encontrará npx por nombre; dale la ruta absoluta de which npx cuando eso ocurra. En Windows, un cliente que no pueda lanzar el shim npx.cmd necesita "command": "cmd" con "args": ["/c", "npx", "--yes", "@type-atlas/mcp@latest"].

Los clientes leen la configuración de MCP al inicio, así que reinicia después. @latest se resuelve en cada inicio de proceso; fija una versión si no quieres que el comportamiento de la herramienta cambie bajo tus pies.

search_code, related_code, investigate_code y search_dependency_code ejecutan un índice semántico a través de uvx y necesitan uv. Sin él, esas cuatro reportan que falta uv, explore_symbol elimina su sección de código relacionado, y el resto no se ve afectado.

Recomendado

Instalar el servidor no cambia lo que un agente usa. Algunos agentes, Claude entre ellos, ensamblarán lo que su shell permita, encadenado, y producirán una justificación nueva cada vez, así que nombrar algunos comandos a evitar no sirve. La instrucción tiene que descartar toda la categoría y nombrar las excepciones. Añade esto a AGENTS.md o CLAUDE.md:

Type Atlas MCP es la herramienta obligatoria para leer y navegar código en TypeScript y JavaScript. Esto no es una preferencia. Ningún comando de shell es un sustituto aceptable, sea lo que sea que lo componga, y tampoco lo es una lectura de archivo simple. Los únicos respaldos válidos son un servidor que está caído, una llamada que dio error, o un archivo que no es ni TS ni JS.

--require-intent

Esta bandera opcional requiere una frase de decisión para herramientas de exploración amplia como la búsqueda de repositorio y los símbolos del espacio de trabajo. Las lecturas dirigidas y las búsquedas semánticas no se ven afectadas, y la intención nunca se refleja en las respuestas de la herramienta.

Related MCP server: agent-workspace-mcp

Resultados de llamadas a herramientas

Las rutas son relativas al espacio de trabajo, las coordenadas son de base uno, así que una ubicación en una respuesta es entrada válida para la siguiente llamada. Las herramientas de edición devuelven parches; nada se escribe por ti.

Todo lo siguiente se captura del servidor en ejecución contra fixtures/ledger mediante la suite de escenarios, que reproduce las mismas llamadas y falla ante la deriva. Nada aquí está escrito a mano, y cambiar lo que una herramienta responde cambia este archivo en el mismo commit. La fuente es README.mdoc. Cada herramienta tiene una página con más casos en docs/tools.

list_files

Estructura, recuentos de líneas y git status en un solo árbol, usando las letras de insignia que los editores ya usan. Los archivos eliminados obtienen una fila aunque existan solo en la respuesta de git. Las carpetas plegadas dicen lo que contienen en lugar de desaparecer.

Entrada del agente

tool: List files
workspace: fixtures/ledger
# working tree arranged: currency.ts edited · rounding.ts created · index.ts deleted
directory: packages/money
depth: 2

# answered in 57ms

Respuesta

packages/money/
├  src/ · 3 changed
│  ├  currency.ts · 21 loc · M +2
│  ├  index.ts · D -12
│  ├  money.ts · 58 loc
│  ├  rounding-mode.ts · 15 loc
│  └  rounding.ts · 11 loc · U
├  tests/
│  ├  money.test.ts · 15 loc
│  └  rounding-parity.ts · 15 loc
├  package.json · 19 loc
└  tsconfig.json · 20 loc

inspect_symbol

Hover, definiciones, definiciones de tipos, implementaciones, llamadores, llamadas y referencias en una sola llamada. Las referencias son el residuo después de que los llamadores y las definiciones se contabilizan, así que un uso se lista una vez. En comparación con llamar a esas herramientas por separado, es 4 veces menos caracteres y 7 veces menos viajes de ida y vuelta.

Entrada del agente

tool: Inspect symbol
workspace: fixtures/ledger
file: packages/accounts/src/journal.ts
symbol: Journal

# answered in 49ms

Respuesta

Journal [class] · packages/accounts/src/journal.ts:24:14-24:21 · range 24:1-73:2 · packages/accounts/tsconfig.json

```typescript
class Journal<TMeta = undefined>
```

An append-only journal of balanced entries. `TMeta` carries whatever a
consumer attaches to each entry — an import batch id, an approval trail —
without the journal knowing its shape.

## Callers (4)

packages/accounts/tests/journal.test.ts
├  test("posts a balanced transfer through the overload") callback [function] 5:56-14:2 · calls 6:23-6:30
└  test("refuses an unbalanced entry") callback [function] 16:37-29:2 · calls 17:23-17:30
packages/reports/src/balance.ts
└  balancesAsOf [variable] 23:14-23:26 · range 23:14-51:2 · calls 24:12-24:19
packages/importers/src/csv.ts
└  importStatement [variable] 28:14-28:29 · range 28:14-47:2 · calls 29:12-29:19

## Mentions that are not calls (4 of 9 references · 5 relevant projects searched)

packages/accounts/tests/journal.test.ts:3:25-3:32:  import { credit, debit, Journal, UnbalancedEntryError } from "../src/index.ts";
packages/accounts/src/index.ts:11:22-11:29:  export { type Entry, Journal, UnbalancedEntryError } from "./journal.ts";
packages/reports/src/balance.ts:4:8-4:15:  type Journal,
packages/importers/src/csv.ts:1:10-1:17:  import { Journal, type Entry, credit, debit, type AccountPath } from "@ledger/accounts";

references lists all 9, with paging.

read_file

El argumento es un array, así que varios archivos llegan en una sola llamada. Los cuerpos se pliegan a firmas por defecto y el encabezado dice cuántas líneas se ahorraron; fold: false los devuelve.

Entrada del agente

tool: Read files
workspace: fixtures/ledger
file: ["packages/accounts/src/posting.ts","packages/money/src/rounding-mode.ts"]

# answered in 7ms

Respuesta

2 files · 42 lines · 6 folded to signatures, pass fold: false for the bodies

=== packages/accounts/src/posting.ts · 32 lines ===

 1 | import { type Money, negate } from "@ledger/money";
 2 | import type { AccountPath } from "./account.ts";
 3 |
 4 | /**
 5 |  * One side of a journal entry. The discriminant is the bookkeeping side, so
 6 |  * every consumer's switch is checked for exhaustiveness by the compiler.
 7 |  */
 8 | export type Posting =
 9 |   | { readonly side: "debit"; readonly account: AccountPath; readonly amount: Money }
10 |   | { readonly side: "credit"; readonly account: AccountPath; readonly amount: Money };
11 |
12 | export const debit = (account: AccountPath, amount: Money): Posting => ({
13 |   side: "debit",
14 |   account,
15 |   amount,
16 | });
17 |
18 | export const credit = (account: AccountPath, amount: Money): Posting => ({
19 |   side: "credit",
20 |   account,
21 |   amount,
22 | });
23 |
24 | /** A posting's effect on a debit-normal running balance. */
25 | export const signedAmount = (posting: Posting): Money => {
   |   ... 26-31 folded
32 | };

=== packages/money/src/rounding-mode.ts · 15 lines ===

 1 | /** How sub-minor precision resolves when a statement and the books disagree. */
 2 | export enum RoundingMode {
 3 |   HalfUp = "half-up",
 4 |   HalfEven = "half-even",
 5 |   Truncate = "truncate",
 6 | }
 7 |
 8 | /** Per-institution conventions, as observed in their exports. */
 9 | const bankRounding: Readonly<Record<string, RoundingMode>> = {
10 |   "first-national": RoundingMode.HalfEven,
11 |   "harbor-credit": RoundingMode.HalfUp,
12 | };
13 |
14 | export const roundingModeOf = (bank: string): RoundingMode =>
15 |   bankRounding[bank] ?? RoundingMode.HalfEven;

occurrences

Texto literal, agrupado por archivo, con el número de archivos escaneados. Las herramientas semánticas clasifican lo que existe, lo cual es inútil para confirmar que un token ha desaparecido tras un teardown; un cero aquí viene con el mismo recuento de escaneo, así que significa algo.

Entrada del agente

tool: Occurrences
workspace: fixtures/ledger
text: signedAmount

# answered in 12ms

Respuesta

"signedAmount" occurs 12 times in 7 files · 67 files scanned under the workspace · 1 file of declared build output not scanned.

packages/accounts/src/index.ts:12:39 · export { credit, debit, type Posting, signedAmount } from "./posting.ts";
packages/accounts/src/journal.ts
├  3:39  · import { credit, debit, type Posting, signedAmount } from "./posting.ts";
└  52:12 · .map(signedAmount)
packages/accounts/src/posting.ts:25:14 · export const signedAmount = (posting: Posting): Money => {
packages/reconcile/src/drift.ts
├  4:24  · import { type Posting, signedAmount } from "@ledger/accounts";
└  20:37 · const journalTotal = postings.map(signedAmount).reduce((total, amount) => total + amount);
packages/reconcile/src/matching.ts
├  1:55  · // DELIBERATELY BROKEN — the imports for `money` and `signedAmount` are
└  14:20 · const amount = signedAmount(posting);
packages/reports/src/balance.ts
├  6:3   · signedAmount,
└  34:57 · add(own.get(posting.account) ?? zero(currency), signedAmount(posting)),
packages/rules/src/builtin.ts
├  1:10  · import { signedAmount } from "@ledger/accounts";
└  26:12 · .map(signedAmount)

search_code

Encuentra código por lo que hace, para cuando no puedes adivinar cómo se llama. Los resultados vuelven en orden de relevancia, cada uno con el rango de archivo del que proviene, para que la siguiente llamada tenga a dónde ir. Las respuestas en vivo también incluyen un porcentaje de relevancia por resultado; se omite abajo porque las puntuaciones de embedding detrás de ellas difieren entre máquinas y estos casos se comparan byte por byte.

Entrada del agente

tool: Search code
workspace: fixtures/ledger
query: walking an account up through each of its ancestor accounts
snippetLines: 6

# answered in 20ms

Respuesta

Search: walking an account up through each of its ancestor accounts

5 matches · no identifier to anchor on, so these are ranked by meaning alone

=== 1 · packages/accounts/src/account.ts:21-35 ===

Structure: parentPath
Symbol: parentPath [variable] · selection 21:14-21:24 · range 21:14-24:2

21 | export const parentPath = (path: AccountPath): AccountPath | undefined => {
22 |   const at = path.lastIndexOf(":");
23 |   return at === -1 ? undefined : path.slice(0, at);
24 | };
25 |
26 | /** Every ancestor from root to the account itself: `a`, `a:b`, `a:b:c`. */

=== 2 · packages/reports/src/balance.ts:1-23 ===

Structure: BalanceLine
Symbol: BalanceLine [interface] · selection 11:18-11:29 · range 11:1-16:2

1 | import {
2 |   type AccountPath,
3 |   type Entry,
4 |   type Journal,
5 |   lineage,
6 |   signedAmount,

=== 3 · packages/accounts/src/journal.ts:59-73 ===

Structure: Journal > history
Symbol: history [method] · selection 60:3-60:10 · range 60:3-64:4

59 |   /** Entries touching an account, oldest first. */
60 |   history(account: AccountPath): readonly Entry<TMeta>[] {
61 |     return this.entries.filter((entry) =>
62 |       entry.postings.some((posting) => posting.account === account),
63 |     );
64 |   }

=== 4 · packages/reports/src/statement.ts:1-11 ===

Structure: statementLine
Symbol: statementLine [variable] · selection 8:14-8:27 · range 8:14-11:2

1 | import { type Account, normalBalance } from "@ledger/accounts";
2 | import { format, type Money, negate } from "@ledger/money";
3 |
4 | /**
5 |  * One rendered statement line. The sign follows the account's normal side:
6 |  * a liability holding a credit balance reads as positive on its statement.

=== 5 · packages/accounts/src/posting.ts:1-24 ===

Structure: credit
Symbol: credit [variable] · selection 18:14-18:20 · range 18:14-22:3

1 | import { type Money, negate } from "@ledger/money";
2 | import type { AccountPath } from "./account.ts";
3 |
4 | /**
5 |  * One side of a journal entry. The discriminant is the bookkeeping side, so
6 |  * every consumer's switch is checked for exhaustiveness by the compiler.

diagnostics

La comprobación de todo el programa del propio compilador, por proyecto, no un pase por archivo. Una edición en un archivo normalmente rompe otro distinto, y esta es la llamada que encuentra ese archivo.

Entrada del agente

tool: Diagnostics
workspace: fixtures/ledger
file: packages/reconcile/src/drift.ts

# answered in 23ms

Respuesta

packages/reconcile/src/drift.ts · 4 problems · packages/reconcile/tsconfig.json

=== packages/reconcile/src/drift.ts ===

error ts(2365) 16:33-16:52 — inside lines.reduce() callback
  Operator '+' cannot be applied to types 'number' and 'Money'.
   14 | /** Statement total, computed by someone who forgot Money is not a number.…
   15 | export const statementTotal = (lines: readonly StatementLine[]): number =>
   16 |   lines.reduce((total, line) => total + line.amount, 0);
      |                                 ^^^^^^^^^^^^^^^^^^^
   17 |
   18 | /** Drift between the journal's view and the bank's view of one day. */

error ts(2365) 20:77-20:91 — inside reduce() callback
  Operator '+' cannot be applied to types 'import("packages/money/src/money").Money' and 'import("packages/money/src/money").Money'.
   18 | /** Drift between the journal's view and the bank's view of one day. */
   19 | export const drift = (postings: readonly Posting[], statement: readonly St…
   20 |   const journalTotal = postings.map(signedAmount).reduce((total, amount) =…
      |                                                                             ^^^^^^^^^^^^^^
   21 |   return format(money(journalTotal - statementTotal(statement), "usd"));
   22 | };

error ts(2345) 21:65-21:70 — inside drift
  Argument of type '"usd"' is not assignable to parameter of type 'Currency'.
   19 | export const drift = (postings: readonly Posting[], statement: readonly St…
   20 |   const journalTotal = postings.map(signedAmount).reduce((total, amount) =…
   21 |   return format(money(journalTotal - statementTotal(statement), "usd"));
      |                                                                 ^^^^^
   22 | };
   23 |

error ts(2362) 21:23-21:35 — inside drift
  The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.
   19 | export const drift = (postings: readonly Posting[], statement: readonly St…
   20 |   const journalTotal = postings.map(signedAmount).reduce((total, amount) =…
   21 |   return format(money(journalTotal - statementTotal(statement), "usd"));
      |                       ^^^^^^^^^^^^
   22 | };
   23 |

workspace_symbols

Encuentra una declaración por nombre en todos los proyectos que la sesión ha cargado, cuando sabes aproximadamente cómo se llama y nada sobre dónde vive.

Entrada del agente

tool: Workspace symbols
workspace: fixtures/ledger
file: packages/importers/src/statement-parser.ts
query: Parser

# answered in 100ms

Respuesta

3 symbols matching Parser · 8 projects loaded · packages/importers/tsconfig.json

CsvStatementParser [class] · packages/importers/src/statement-parser.ts:25:1-35:2
FixedWidthStatementParser [class] · packages/importers/src/statement-parser.ts:41:1-64:2
StatementParser [class] · packages/importers/src/statement-parser.ts:7:1-23:2

file_references

Quién importa este módulo. La pregunta a nivel de módulo, respondida sin elegir un símbolo dentro de él primero.

Entrada del agente

tool: File references
workspace: fixtures/ledger
file: packages/money/src/money.ts

# answered in 134ms

Respuesta

packages/money/src/money.ts · referenced from 90 places · 6 relevant projects searched · packages/money/tsconfig.json

1-20 of 90 places · pass offset: 20 for the rest

packages/accounts/src/journal.ts
├  1:10  — at module level
└  53:15 — inside post
packages/money/src/index.ts
├  3:3 — at module level
├  4:3 — at module level
└  5:3 — at module level
packages/money/tests/money.test.ts
├  2:10  — at module level
├  2:15  — at module level
├  2:38  — at module level
├  5:10  — inside test("adds amounts of one currency exactly") callback
├  9:16  — inside expect() callback
├  9:67  — inside test("refuses to combine currencies") callback
├  13:10 — inside test("formats major and minor units per currency") callback
└  14:10 — inside test("formats major and minor units per currency") callback
packages/reports/src/balance.ts
├  8:10  — at module level
├  34:9  — inside balancesAsOf
└  41:28 — inside balancesAsOf
packages/reports/src/statement.ts
├  2:10  — at module level
└  10:40 — inside statementLine
packages/rules/src/builtin.ts
├  2:10  — at module level
└  28:58 — inside closedPeriodsBalance

Paquetes

Desarrollo

vp install
vp run check
vp run check:distribution

CONTRIBUTING.md tiene el proceso de cambios y publicación.