@saulwade/swl-ses 1.0.0

package/habilidades/datos-etl/recursos/implementaciones-completas.md

@@ -0,0 +1,322 @@
+# Ingeniería de Datos y ETL — Implementaciones Completas
+
+## Calidad de Datos — Validación con Great Expectations
+
+```python
+# Usando Great Expectations para validación declarativa
+import great_expectations as gx
+
+def validar_pedidos(df: pd.DataFrame) -> ValidationResult:
+    """Valida el DataFrame de pedidos antes de cargar a Silver."""
+
+    context = gx.get_context()
+    suite = context.add_or_update_expectation_suite("pedidos_suite")
+
+    validator = context.get_validator(
+        batch_request=gx.core.BatchRequest(datasource_name="staging"),
+        expectation_suite=suite,
+    )
+
+    # Validaciones de integridad
+    validator.expect_column_to_exist("pedido_id")
+    validator.expect_column_values_to_not_be_null("pedido_id")
+    validator.expect_column_values_to_be_unique("pedido_id")
+
+    # Validaciones de dominio
+    validator.expect_column_values_to_be_in_set(
+        "estatus", {"PENDIENTE", "PAGADO", "ENVIADO", "CANCELADO"}
+    )
+    validator.expect_column_values_to_be_between(
+        "monto_total", min_value=0.01, max_value=999_999.99
+    )
+    validator.expect_column_values_to_match_regex(
+        "email_cliente", r"^[^@\s]+@[^@\s]+\.[^@\s]+$"
+    )
+
+    # Validación de freshness
+    validator.expect_column_max_to_be_between(
+        "fecha_pedido",
+        min_value=str(date.today() - timedelta(days=1)),
+        max_value=str(date.today() + timedelta(days=1)),
+    )
+
+    resultado = validator.validate()
+
+    if not resultado.success:
+        fallos = [
+            r for r in resultado.results if not r.success
+        ]
+        logger.error(
+            "validacion_datos_fallida",
+            total_expectativas=len(resultado.results),
+            total_fallos=len(fallos),
+            detalle=[str(f.expectation_config) for f in fallos[:5]],
+        )
+        raise ErrorCalidadDatos(
+            f"{len(fallos)} validaciones fallidas en pedidos",
+            {"fallos": len(fallos), "total": len(resultado.results)},
+        )
+
+    return resultado
+```
+
+---
+
+## CDC — Change Data Capture con Debezium
+
+```yaml
+# debezium-connector.json
+{
+  "name": "pedidos-cdc-connector",
+  "config": {
+    "connector.class": "io.debezium.connector.postgresql.PostgresConnector",
+    "database.hostname": "postgres-produccion",
+    "database.port": "5432",
+    "database.user": "debezium_user",
+    "database.password": "${file:/opt/secrets/debezium.properties:password}",
+    "database.dbname": "appdb",
+    "database.server.name": "appdb",
+    "table.include.list": "public.pedidos,public.usuarios",
+    "plugin.name": "pgoutput",
+    "publication.name": "debezium_pub",
+    "slot.name": "debezium_slot",
+    "topic.prefix": "cdc",
+    "transforms": "route",
+    "transforms.route.type": "org.apache.kafka.connect.transforms.ReplaceField$Value",
+    "key.converter": "io.confluent.kafka.serializers.KafkaAvroSerializer",
+    "value.converter": "io.confluent.kafka.serializers.KafkaAvroSerializer"
+  }
+}
+```
+
+```python
+# Consumidor CDC en Python
+from confluent_kafka import Consumer, KafkaError
+import json
+
+
+def procesar_evento_cdc(evento: dict) -> None:
+    """Procesa un evento CDC de Debezium."""
+    operacion = evento.get("op")  # c=create, u=update, d=delete, r=snapshot
+
+    match operacion:
+        case "c":
+            nuevo = evento["after"]
+            silver_pedidos.upsert(transformar_pedido(nuevo))
+
+        case "u":
+            antes = evento["before"]
+            despues = evento["after"]
+            silver_pedidos.upsert(transformar_pedido(despues))
+            auditar_cambio(antes, despues)
+
+        case "d":
+            eliminado = evento["before"]
+            silver_pedidos.marcar_eliminado(eliminado["id"])
+
+        case "r":
+            silver_pedidos.upsert(transformar_pedido(evento["after"]))
+
+
+consumer = Consumer({
+    "bootstrap.servers": "kafka:9092",
+    "group.id": "cdc-silver-processor",
+    "auto.offset.reset": "earliest",
+    "enable.auto.commit": False,
+})
+
+consumer.subscribe(["cdc.appdb.public.pedidos"])
+
+while True:
+    msg = consumer.poll(timeout=1.0)
+    if msg is None:
+        continue
+    if msg.error():
+        if msg.error().code() == KafkaError._PARTITION_EOF:
+            continue
+        raise KafkaError(msg.error())
+
+    try:
+        evento = json.loads(msg.value())
+        procesar_evento_cdc(evento)
+        consumer.commit(asynchronous=False)
+    except Exception as exc:
+        logger.error("error_procesando_cdc", error=str(exc), exc_info=True)
+        enviar_dlq(msg.value(), str(exc))
+        consumer.commit(asynchronous=False)
+```
+
+---
+
+## Evolución de Esquemas — Forward/Backward Compatibility
+
+```python
+# Estrategia: columnas nuevas siempre nullable o con default
+# NUNCA eliminar columnas en producción — deprecar primero
+
+# Migración segura — backward compatible
+"""
+-- BIEN: columna nueva con default
+ALTER TABLE silver.pedidos
+  ADD COLUMN IF NOT EXISTS canal_venta TEXT DEFAULT 'WEB';
+
+-- MAL: cambiar tipo de columna existente directamente
+-- ALTER TABLE silver.pedidos ALTER COLUMN monto TYPE BIGINT;
+
+-- BIEN: renombrar con período de transición
+ALTER TABLE silver.pedidos ADD COLUMN monto_centavos BIGINT;
+UPDATE silver.pedidos SET monto_centavos = (monto * 100)::BIGINT;
+-- (semana después, cuando todos los consumidores usen la nueva columna)
+ALTER TABLE silver.pedidos DROP COLUMN monto;
+ALTER TABLE silver.pedidos RENAME COLUMN monto_centavos TO monto;
+"""
+
+# Schema registry con Avro para streaming
+SCHEMA_PEDIDO_V1 = {
+    "type": "record",
+    "name": "Pedido",
+    "fields": [
+        {"name": "id",     "type": "string"},
+        {"name": "monto",  "type": "double"},
+        {"name": "estatus","type": "string"},
+    ]
+}
+
+# V2: campo nuevo con default — backward compatible
+SCHEMA_PEDIDO_V2 = {
+    "type": "record",
+    "name": "Pedido",
+    "fields": [
+        {"name": "id",          "type": "string"},
+        {"name": "monto",       "type": "double"},
+        {"name": "estatus",     "type": "string"},
+        {"name": "canal_venta", "type": "string", "default": "WEB"},
+    ]
+}
+```
+
+---
+
+## Patrones dbt — Transformaciones Declarativas
+
+```sql
+-- models/silver/pedidos_limpio.sql
+{{
+  config(
+    materialized='incremental',
+    unique_key='pedido_id',
+    on_schema_change='append_new_columns',
+    partition_by={
+      "field": "fecha_pedido",
+      "data_type": "date",
+      "granularity": "day"
+    }
+  )
+}}
+
+WITH fuente AS (
+  SELECT * FROM {{ source('bronze', 'pedidos_raw') }}
+  {% if is_incremental() %}
+    WHERE _ingestado_en > (SELECT MAX(_ingestado_en) FROM {{ this }})
+  {% endif %}
+),
+
+limpieza AS (
+  SELECT
+    TRIM(pedido_id)                            AS pedido_id,
+    LOWER(TRIM(email_cliente))                 AS email_cliente,
+    UPPER(TRIM(estatus))                       AS estatus,
+    ROUND(CAST(monto_total AS NUMERIC), 2)    AS monto_total,
+    DATE(fecha_pedido)                         AS fecha_pedido,
+    _ingestado_en,
+    EXTRACT(YEAR FROM DATE(fecha_pedido))      AS anio,
+    EXTRACT(MONTH FROM DATE(fecha_pedido))     AS mes,
+    CASE WHEN monto_total < 0 THEN TRUE ELSE FALSE END AS tiene_monto_negativo,
+    CASE WHEN email_cliente NOT LIKE '%@%'    THEN TRUE ELSE FALSE END AS email_invalido
+
+  FROM fuente
+  WHERE pedido_id IS NOT NULL
+)
+
+SELECT * FROM limpieza
+```
+
+```yaml
+# models/silver/schema.yml
+models:
+  - name: pedidos_limpio
+    description: "Pedidos normalizados de Bronze, deduplicados y validados"
+    columns:
+      - name: pedido_id
+        tests:
+          - not_null
+          - unique
+      - name: email_cliente
+        tests:
+          - not_null
+      - name: estatus
+        tests:
+          - accepted_values:
+              values: ["PENDIENTE", "PAGADO", "ENVIADO", "CANCELADO"]
+      - name: monto_total
+        tests:
+          - not_null
+          - dbt_utils.expression_is_true:
+              expression: ">= 0"
+```
+
+---
+
+## Linaje de Datos
+
+```python
+# linaje.py — registrar transformaciones para auditoría
+from dataclasses import dataclass
+from datetime import datetime, timezone
+
+
+@dataclass
+class NodoLinaje:
+    nombre: str
+    tipo: str  # "fuente", "transformacion", "destino"
+    ubicacion: str
+
+
+@dataclass
+class EventoLinaje:
+    run_id: str
+    pipeline: str
+    origen: NodoLinaje
+    destino: NodoLinaje
+    registros_entrada: int
+    registros_salida: int
+    registros_rechazados: int
+    timestamp: datetime
+    query_o_script: str | None = None
+
+
+class RegistroLinaje:
+    def registrar(self, evento: EventoLinaje) -> None:
+        db.execute("""
+            INSERT INTO meta.linaje_datos (
+                run_id, pipeline, origen_nombre, origen_tipo, origen_ubicacion,
+                destino_nombre, destino_tipo, destino_ubicacion,
+                registros_entrada, registros_salida, registros_rechazados,
+                timestamp, query_script
+            ) VALUES (
+                :run_id, :pipeline, :onom, :otipo, :oubic,
+                :dnom, :dtipo, :dubic,
+                :rent, :rsal, :rrec,
+                :ts, :qs
+            )
+        """, {
+            "run_id": evento.run_id, "pipeline": evento.pipeline,
+            "onom": evento.origen.nombre, "otipo": evento.origen.tipo,
+            "oubic": evento.origen.ubicacion,
+            "dnom": evento.destino.nombre, "dtipo": evento.destino.tipo,
+            "dubic": evento.destino.ubicacion,
+            "rent": evento.registros_entrada, "rsal": evento.registros_salida,
+            "rrec": evento.registros_rechazados,
+            "ts": evento.timestamp.isoformat(), "qs": evento.query_o_script,
+        })
+```

package/habilidades/dbml-experto/SKILL.md

@@ -0,0 +1,339 @@
+---
+name: dbml-experto
+description: >
+  Experto en DBML (Database Markup Language) — lenguaje declarativo para describir
+  esquemas de bases de datos. Cubre sintaxis (tables, refs, enums, indexes, notes,
+  projects), parseo programático con @dbml/core cuando está instalado, fallback a
+  heurísticas de texto plano cuando no, y casos de uso en proyectos data-heavy:
+  análisis de schema, migración entre dialectos (PG/MySQL/MSSQL), detección de
+  relaciones huérfanas, generación de DDL. Cargar cuando un proyecto contenga
+  archivos .dbml, o cuando el usuario mencione dbdiagram.io, chartdb.io, schema
+  as code o DBML explícitamente. NO cargar para SQL plano, Prisma schema, TypeORM
+  entities u otros DSLs de schema — son otros skills distintos.
+version: "1.0.0"
+herramientasPermitidas: [Read]
+evolvable: true  # default para skill estandar
+exclusiones:
+  - "No cargar para SQL plano (DDL, DML, migraciones) — para SQL cargar `postgresql-experto` o `sql-optimizacion`."
+  - "No cargar para Prisma schema (.prisma), TypeORM entities o SQLAlchemy declarative — son DSLs incompatibles con DBML."
+  - "No cargar para generar diagramas visuales de arquitectura — para diagramas cargar `diagrama-arquitectura` o `generacion-mermaid`."
+  - "No cargar para aplicar migraciones a una base de datos real — este skill es análisis estático de DBML, no ejecución de DDL."
+---
+# DBML Experto — Parseo y análisis de esquemas DBML
+
+## Cuándo cargar esta skill
+
+- El proyecto contiene archivos `.dbml` o un directorio `db/` con `.dbml`.
+- El usuario menciona `dbdiagram.io`, `chartdb.io`, "schema as code", "DBML",
+  o pide migrar entre dialectos SQL.
+- Un agente `datos-swl` o revisor de lenguaje necesita analizar relaciones
+  programáticamente y el proyecto usa DBML como fuente de verdad del schema.
+
+**No cargar** cuando:
+- El schema está en SQL plano (usar skills de SQL/backend-* correspondientes).
+- El schema está en Prisma (`.prisma`), TypeORM, SQLAlchemy declarative — son otros DSLs.
+- La tarea es solo leer un diagrama sin modificar ni analizar relaciones.
+
+---
+
+## Dependencia opcional — `@dbml/core`
+
+Esta skill **funciona sin dependencias** usando heurísticas de texto plano, pero
+gana precisión si el proyecto del usuario tiene `@dbml/core` instalado.
+
+### Detectar si está disponible
+
+```bash
+# En el proyecto del usuario
+test -d node_modules/@dbml/core && echo "DISPONIBLE" || echo "NO_INSTALADO"
+```
+
+### Si NO está disponible y la tarea requiere parseo estructural
+
+Sugerir al usuario instalarlo en **su** proyecto (nunca en swl-ses):
+
+```bash
+npm install --save-dev @dbml/core
+```
+
+Documentado también en `MANUAL_USO.md` → "Dependencias externas — referencia
+detallada" → `@dbml/core`.
+
+### Si SÍ está disponible — patrón de uso
+
+```javascript
+const fs = require('node:fs');
+const { importer } = require('@dbml/core');
+
+const texto = fs.readFileSync('db/schema.dbml', 'utf8');
+const schema = importer.import(texto, 'dbml');
+
+// schema.tables[i]
+//   .name, .note, .fields[], .indexes[]
+// schema.refs[i]
+//   .endpoints[0].tableName, .endpoints[0].fieldNames
+//   .endpoints[1].tableName, .endpoints[1].fieldNames
+//   .onDelete, .onUpdate
+// schema.enums[i]
+//   .name, .values[]
+```
+
+---
+
+## Sintaxis DBML esencial
+
+### Tabla básica
+
+```dbml
+Table users {
+  id int [pk, increment]
+  email varchar [unique, not null]
+  name varchar
+  created_at timestamp [default: `now()`]
+}
+```
+
+| Modificador | Significado |
+|-------------|-------------|
+| `pk` | Primary key |
+| `increment` | Auto-incremento (serial/identity) |
+| `unique` | Restricción UNIQUE |
+| `not null` | NOT NULL |
+| `default: X` | Valor default (usar backticks para expresiones) |
+| `note: 'texto'` | Comentario asociado al campo |
+| `ref: > tabla.campo` | Relación inline |
+
+### Relaciones (refs)
+
+Tres formas equivalentes:
+
+```dbml
+# A. Inline en el campo
+Table posts {
+  id int [pk]
+  user_id int [ref: > users.id]   // many-to-one
+}
+
+# B. Referencia separada
+Ref: posts.user_id > users.id
+
+# C. Bloque de referencias
+Ref user_post {
+  users.id < posts.user_id [delete: cascade, update: no action]
+}
+```
+
+Cardinalidades:
+- `>` many-to-one (de hijo hacia padre)
+- `<` one-to-many
+- `-` one-to-one
+- `<>` many-to-many (requiere tabla pivote explícita)
+
+### Índices
+
+```dbml
+Table users {
+  id int [pk]
+  email varchar
+  country varchar
+
+  Indexes {
+    email [unique]
+    (country, email) [name: 'idx_country_email']
+    `lower(email)` [type: btree]
+  }
+}
+```
+
+### Enums
+
+```dbml
+Enum order_status {
+  pending
+  paid
+  shipped [note: 'el producto salió del almacén']
+  cancelled
+}
+
+Table orders {
+  id int [pk]
+  status order_status [not null, default: 'pending']
+}
+```
+
+### Agrupación en Projects y TableGroups
+
+```dbml
+Project mi_sistema {
+  database_type: 'PostgreSQL'
+  Note: 'Esquema principal de la aplicación'
+}
+
+TableGroup facturacion {
+  orders
+  order_items
+  payments
+}
+```
+
+---
+
+## Casos de uso en SWL
+
+### 1. Análisis de relaciones huérfanas
+
+Detectar refs cuyo endpoint apunta a tablas/campos inexistentes:
+
+```javascript
+const tablas = new Map(schema.tables.map(t => [t.name, new Set(t.fields.map(f => f.name))]));
+
+const huérfanas = schema.refs.filter(r => {
+  for (const ep of r.endpoints) {
+    const cols = tablas.get(ep.tableName);
+    if (!cols) return true;
+    for (const fn of ep.fieldNames) if (!cols.has(fn)) return true;
+  }
+  return false;
+});
+```
+
+### 2. Detección de tablas sin PK
+
+```javascript
+const sinPK = schema.tables.filter(t =>
+  !t.fields.some(f => f.pk) &&
+  !t.indexes?.some(i => i.pk)
+);
+```
+
+Reportar como anti-patrón (excepto tablas de log append-only declaradas en note).
+
+### 3. Migración entre dialectos
+
+Convertir tipos DBML → dialecto específico. Tabla base (extender según necesidad):
+
+| DBML | PostgreSQL | MySQL | MSSQL | SQLite |
+|------|-----------|-------|-------|--------|
+| `int` | `integer` | `int` | `int` | `integer` |
+| `bigint` | `bigint` | `bigint` | `bigint` | `integer` |
+| `varchar` | `varchar(255)` | `varchar(255)` | `nvarchar(255)` | `text` |
+| `text` | `text` | `text` | `nvarchar(max)` | `text` |
+| `timestamp` | `timestamp` | `datetime` | `datetime2` | `text` |
+| `boolean` | `boolean` | `tinyint(1)` | `bit` | `integer` |
+| `uuid` | `uuid` | `char(36)` | `uniqueidentifier` | `text` |
+| `json` | `jsonb` | `json` | `nvarchar(max)` | `text` |
+
+Reglas al migrar:
+- `timestamp with tz` → `timestamptz` (PG) / `datetime` (MySQL sin tz) / `datetimeoffset` (MSSQL).
+- Defaults con funciones (`` `now()` ``) requieren ajuste por dialecto.
+- `increment` → `SERIAL`/`IDENTITY`/`AUTOINCREMENT` según dialecto.
+- Reglas `on delete cascade` se soportan en todos; `on delete set null` requiere columna nullable.
+
+### 4. Fallback sin `@dbml/core` — heurísticas de texto
+
+Si el usuario no puede instalar la dependencia, usar regex conservadoras:
+
+```javascript
+// Extraer nombres de tablas
+const tablas = [...texto.matchAll(/^\s*Table\s+(\w+)\s*\{/gm)].map(m => m[1]);
+
+// Extraer refs inline
+const refsInline = [...texto.matchAll(/\[ref:\s*[<>\-]\s*(\w+)\.(\w+)/g)]
+  .map(m => ({ tabla: m[1], campo: m[2] }));
+
+// Extraer refs separadas
+const refsSep = [...texto.matchAll(/^\s*Ref(?:\s+\w+)?\s*:?\s*(\w+)\.(\w+)\s*([<>\-]+)\s*(\w+)\.(\w+)/gm)]
+  .map(m => ({ fromTabla: m[1], fromCampo: m[2], card: m[3], toTabla: m[4], toCampo: m[5] }));
+```
+
+**Limitaciones del fallback**:
+- No resuelve tipos compuestos ni enums referenciados.
+- Puede fallar con comentarios embebidos o strings con llaves.
+- No valida sintaxis.
+
+Siempre reportar al usuario: "Análisis hecho sin `@dbml/core` — precisión
+limitada, considera instalarlo si vas a tomar decisiones estructurales."
+
+---
+
+## Patrones buenos y malos en DBML
+
+### BIEN — nombres consistentes
+
+```dbml
+Table users {
+  id int [pk, increment]
+  organization_id int [ref: > organizations.id]
+}
+```
+
+### MAL — inconsistencia snake_case vs camelCase
+
+```dbml
+Table users {
+  id int [pk]
+  organizationId int [ref: > organizations.id]  // mezclar convenciones rompe tooling
+}
+```
+
+### BIEN — documentar decisiones con `Note`
+
+```dbml
+Table events {
+  id bigint [pk, increment]
+  payload jsonb [not null]
+
+  Note: 'Append-only. No usar UPDATE. Particionada por mes vía pg_partman.'
+}
+```
+
+### MAL — relaciones implícitas sin `Ref`
+
+```dbml
+Table orders {
+  id int [pk]
+  user_id int  // sin [ref] ni Ref separada: relación invisible al parser
+}
+```
+
+---
+
+## Integración con otros skills y agentes
+
+- **`datos-swl`** (agente): invoca esta skill al detectar `.dbml` en el proyecto.
+- **`revisor-impacto`** (`/swl:revisar-impacto`): puede cruzar refs DBML con el
+  grafo de código para detectar tablas sin consumidores.
+- **`migrador-swl`** (agente): usa la tabla de migración de tipos para generar
+  scripts DDL multi-dialecto.
+- **`seguridad.md`** (regla): aplicar revisión de nombres sensibles en columnas
+  (email, password, ssn, etc.) independientemente del DSL.
+
+---
+
+## Lo que esta skill NO hace
+
+- **No genera diagramas visuales** — para eso usar `dbdiagram.io`, `chartdb.io` o
+  el skill `generacion-mermaid` con output ER.
+- **No ejecuta migraciones** — solo analiza y genera SQL como texto. El usuario
+  aplica manualmente con su herramienta de migración.
+- **No valida contra una BD real** — es análisis estático del DBML.
+- **No reemplaza** Prisma/TypeORM/SQLAlchemy — esos son ORMs, DBML es solo el
+  schema declarativo.
+
+---
+
+## Gotchas / Errores comunes no obvios
+
+**Las heurísticas de texto plano (sin `@dbml/core`) fallan al parsear tablas con `Note` multilínea**: el regex `^\s*Table\s+(\w+)\s*\{` no coincide cuando la tabla tiene un bloque `Note: '''...'''` antes de los campos, porque la llave de apertura `{` está en la misma línea que `Note`. Causa: DBML permite bloques de texto multilínea con comillas triples que pueden contener llaves. Fix: al usar heurísticas de fallback, reportar explícitamente al usuario que el análisis puede ser incompleto si el schema usa notas multilínea. Para schemas complejos, insistir en instalar `@dbml/core`.
+
+**Las cardinalidades `<>` (many-to-many) en DBML no generan tabla pivote automáticamente**: definir `Ref: users.id <> posts.id` es válido en DBML pero no corresponde a ninguna implementación real de muchos a muchos en SQL — las BDs relacionales requieren tabla intermedia explícita. Causa: DBML permite la cardinalidad `<>` como notación conceptual, pero los parsers de DDL la ignoran o la rechazan. Fix: para relaciones many-to-many, siempre crear la tabla pivote explícita (`user_posts { user_id int [ref: > users.id], post_id int [ref: > posts.id] }`) en lugar de usar `<>` directo.
+
+**`@dbml/core` lanza error de parseo en schemas con nombres de tabla que contienen guiones**: `Table mi-tabla { ... }` es inválido en DBML — los identificadores solo permiten letras, números y guión bajo. Causa: DBML sigue convenciones de identificadores SQL donde el guión es un operador de resta, no parte del nombre. Fix: usar snake_case (`mi_tabla`) o PascalCase (`MiTabla`) para nombres de tablas. Si el schema existente tiene guiones, renombrar antes de parsear con `@dbml/core`.
+
+**El fallback de heurísticas extrae refs inline pero omite los bloques `Ref` separados al final del archivo**: el regex para refs inline (`\[ref: > tabla.campo\]`) funciona, pero el regex para bloques separados `Ref: tabla1.campo > tabla2.campo` puede no capturar todas las variantes de formato (con nombre de ref, con acción on delete). Causa: el formato de bloques `Ref` tiene más variantes sintácticas que los refs inline. Fix: después del análisis heurístico, buscar explícitamente líneas que empiecen con `Ref` y reportarlas por separado al usuario para revisión manual.
+
+## Referencias
+
+- DBML oficial: https://dbml.dbdiagram.io/docs/
+- `@dbml/core` en npm: https://www.npmjs.com/package/@dbml/core
+- Instalación y atribución: `MANUAL_USO.md` → Dependencias externas → `@dbml/core`.