@cerca.red/mapa 0.2.0

package/dist/identificadores.js

@@ -0,0 +1,104 @@
+/**
+ * Los identificadores de todo lo que este SDK mete en un estilo.
+ *
+ * Están aquí, en un solo archivo y como constantes, por una razón práctica:
+ * un identificador de capa escrito a mano en dos sitios es un `quitarCapa`
+ * que no quita nada, y `quitarCapa` de algo que no existe **no falla en
+ * MapLibre**. La capa se queda dibujada para siempre y nadie sabe por qué.
+ *
+ * El prefijo `cerca-` está para que se distingan a simple vista de las capas
+ * del mapa base, que vienen de Protomaps y no se tocan nunca.
+ */
+/** Las fuentes de datos que el SDK crea y mantiene. */
+export const FUENTES = {
+    negocios: "cerca-negocios",
+    /** Agregados entregados por el backend, nunca clusterizados por MapLibre. */
+    grupos: "cerca-grupos",
+    sedes: "cerca-sedes",
+    /**
+     * La selección va en su **propia fuente** y no en un estado de la fuente de
+     * negocios. No es duplicación: la clave de ordenación de símbolos de
+     * MapLibre no lee el estado de entidad, así que un negocio marcado como
+     * seleccionado seguiría dibujándose debajo de sus vecinos. Una fuente
+     * aparte, en una capa por encima, es la única forma de que lo elegido se
+     * vea encima de todo.
+     */
+    seleccion: "cerca-seleccion",
+    /** El halo de las ubicaciones aproximadas. Área, no alfiler. */
+    imprecision: "cerca-imprecision",
+    ubicacion: "cerca-ubicacion",
+    vehiculos: "cerca-vehiculos",
+    rutas: "cerca-rutas",
+    zonas: "cerca-zonas",
+    isocronas: "cerca-isocronas",
+};
+/** Las capas que el SDK dibuja, de abajo hacia arriba dentro de cada anclaje. */
+export const CAPAS = {
+    isocronas: "cerca-isocronas-relleno",
+    isocronasBorde: "cerca-isocronas-borde",
+    zonas: "cerca-zonas-relleno",
+    zonasBorde: "cerca-zonas-borde",
+    imprecision: "cerca-imprecision-relleno",
+    imprecisionBorde: "cerca-imprecision-borde",
+    rutasAlternativas: "cerca-rutas-alternativas",
+    rutaPrincipalContorno: "cerca-ruta-principal-contorno",
+    rutaPrincipal: "cerca-ruta-principal",
+    ubicacionHalo: "cerca-ubicacion-halo",
+    ubicacionPunto: "cerca-ubicacion-punto",
+    gruposCirculo: "cerca-grupos-circulo",
+    gruposCantidad: "cerca-grupos-cantidad",
+    gruposToque: "cerca-grupos-toque",
+    gruposServidorCirculo: "cerca-grupos-servidor-circulo",
+    gruposServidorCantidad: "cerca-grupos-servidor-cantidad",
+    gruposServidorToque: "cerca-grupos-servidor-toque",
+    negociosPunto: "cerca-negocios-punto",
+    negociosSimbolo: "cerca-negocios-simbolo",
+    sedesPunto: "cerca-sedes-punto",
+    vehiculos: "cerca-vehiculos-simbolo",
+    seleccion: "cerca-seleccion-punto",
+    seleccionArea: "cerca-seleccion-area",
+    /**
+     * Las capas invisibles que reciben los toques.
+     *
+     * Un alfiler de 9 px de radio se ve bien y **no se puede tocar** en un
+     * teléfono: CLAUDE.md §1 pide objetivos de 44 px, o sea 22 de radio.
+     * Agrandar el círculo pintado sería taparlo todo, así que encima va otro
+     * círculo del tamaño tocable con opacidad cero.
+     *
+     * Funciona porque la consulta de entidades dibujadas de MapLibre lee el
+     * índice espacial y **sí devuelve capas con opacidad cero** — lo que no
+     * devuelve es capas con la visibilidad apagada, que es una cosa distinta.
+     * Es la diferencia entre «transparente» y «no está».
+     */
+    negociosToque: "cerca-negocios-toque",
+    sedesToque: "cerca-sedes-toque",
+    vehiculosToque: "cerca-vehiculos-toque",
+    rutasToque: "cerca-rutas-toque",
+};
+/**
+ * Los puntos de inserción que el estilo base deja preparados.
+ *
+ * Son capas vacías con identificador estable que solo existen para tener
+ * dónde insertar. La alternativa —referenciar una capa concreta de Protomaps,
+ * como `roads_labels_minor`— se rompe en cada actualización del upstream, y
+ * se rompe en silencio: `agregarCapa` con un `antesDe` que no existe lanza en
+ * MapLibre, pero un identificador que cambió de significado no lanza nada,
+ * solo deja la capa en el sitio equivocado.
+ *
+ * El orden, de abajo hacia arriba: mapa base sin rótulos → **áreas** →
+ * **líneas** → rótulos del mapa base → **puntos** → **selección**.
+ *
+ * Los rótulos del mapa base van en medio a propósito: el nombre de la calle
+ * se tiene que seguir leyendo por debajo de un polígono de cobertura, y los
+ * alfileres tienen que quedar por encima de todo. Un mapa que tapa los
+ * nombres de las calles no sirve para lo único que se le pide.
+ */
+export const ANCLAS_POR_DEFECTO = {
+    areas: "cerca-ancla-areas",
+    lineas: "cerca-ancla-lineas",
+    puntos: "cerca-ancla-puntos",
+    seleccion: "cerca-ancla-seleccion",
+};
+/** El radio en píxeles que hace que un objetivo mida los 44 px que pide CLAUDE.md §1. */
+export const RADIO_TACTIL_MINIMO_EN_PX = 22;
+//# sourceMappingURL=identificadores.js.map

package/dist/identificadores.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identificadores.js","sourceRoot":"","sources":["../src/identificadores.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,uDAAuD;AACvD,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,QAAQ,EAAE,gBAAgB;IAC1B,6EAA6E;IAC7E,MAAM,EAAE,cAAc;IACtB,KAAK,EAAE,aAAa;IACpB;;;;;;;OAOG;IACH,SAAS,EAAE,iBAAiB;IAC5B,gEAAgE;IAChE,WAAW,EAAE,mBAAmB;IAChC,SAAS,EAAE,iBAAiB;IAC5B,SAAS,EAAE,iBAAiB;IAC5B,KAAK,EAAE,aAAa;IACpB,KAAK,EAAE,aAAa;IACpB,SAAS,EAAE,iBAAiB;CACpB,CAAC;AAEX,iFAAiF;AACjF,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,SAAS,EAAE,yBAAyB;IACpC,cAAc,EAAE,uBAAuB;IACvC,KAAK,EAAE,qBAAqB;IAC5B,UAAU,EAAE,mBAAmB;IAC/B,WAAW,EAAE,2BAA2B;IACxC,gBAAgB,EAAE,yBAAyB;IAC3C,iBAAiB,EAAE,0BAA0B;IAC7C,qBAAqB,EAAE,+BAA+B;IACtD,aAAa,EAAE,sBAAsB;IACrC,aAAa,EAAE,sBAAsB;IACrC,cAAc,EAAE,uBAAuB;IACvC,aAAa,EAAE,sBAAsB;IACrC,cAAc,EAAE,uBAAuB;IACvC,WAAW,EAAE,oBAAoB;IACjC,qBAAqB,EAAE,+BAA+B;IACtD,sBAAsB,EAAE,gCAAgC;IACxD,mBAAmB,EAAE,6BAA6B;IAClD,aAAa,EAAE,sBAAsB;IACrC,eAAe,EAAE,wBAAwB;IACzC,UAAU,EAAE,mBAAmB;IAC/B,SAAS,EAAE,yBAAyB;IACpC,SAAS,EAAE,uBAAuB;IAClC,aAAa,EAAE,sBAAsB;IACrC;;;;;;;;;;;;OAYG;IACH,aAAa,EAAE,sBAAsB;IACrC,UAAU,EAAE,mBAAmB;IAC/B,cAAc,EAAE,uBAAuB;IACvC,UAAU,EAAE,mBAAmB;CACvB,CAAC;AAEX;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,KAAK,EAAE,mBAAmB;IAC1B,MAAM,EAAE,oBAAoB;IAC5B,MAAM,EAAE,oBAAoB;IAC5B,SAAS,EAAE,uBAAuB;CAC1B,CAAC;AASX,yFAAyF;AACzF,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,CAAC","sourcesContent":["/**\n * Los identificadores de todo lo que este SDK mete en un estilo.\n *\n * Están aquí, en un solo archivo y como constantes, por una razón práctica:\n * un identificador de capa escrito a mano en dos sitios es un `quitarCapa`\n * que no quita nada, y `quitarCapa` de algo que no existe **no falla en\n * MapLibre**. La capa se queda dibujada para siempre y nadie sabe por qué.\n *\n * El prefijo `cerca-` está para que se distingan a simple vista de las capas\n * del mapa base, que vienen de Protomaps y no se tocan nunca.\n */\n\n/** Las fuentes de datos que el SDK crea y mantiene. */\nexport const FUENTES = {\n  negocios: \"cerca-negocios\",\n  /** Agregados entregados por el backend, nunca clusterizados por MapLibre. */\n  grupos: \"cerca-grupos\",\n  sedes: \"cerca-sedes\",\n  /**\n   * La selección va en su **propia fuente** y no en un estado de la fuente de\n   * negocios. No es duplicación: la clave de ordenación de símbolos de\n   * MapLibre no lee el estado de entidad, así que un negocio marcado como\n   * seleccionado seguiría dibujándose debajo de sus vecinos. Una fuente\n   * aparte, en una capa por encima, es la única forma de que lo elegido se\n   * vea encima de todo.\n   */\n  seleccion: \"cerca-seleccion\",\n  /** El halo de las ubicaciones aproximadas. Área, no alfiler. */\n  imprecision: \"cerca-imprecision\",\n  ubicacion: \"cerca-ubicacion\",\n  vehiculos: \"cerca-vehiculos\",\n  rutas: \"cerca-rutas\",\n  zonas: \"cerca-zonas\",\n  isocronas: \"cerca-isocronas\",\n} as const;\n\n/** Las capas que el SDK dibuja, de abajo hacia arriba dentro de cada anclaje. */\nexport const CAPAS = {\n  isocronas: \"cerca-isocronas-relleno\",\n  isocronasBorde: \"cerca-isocronas-borde\",\n  zonas: \"cerca-zonas-relleno\",\n  zonasBorde: \"cerca-zonas-borde\",\n  imprecision: \"cerca-imprecision-relleno\",\n  imprecisionBorde: \"cerca-imprecision-borde\",\n  rutasAlternativas: \"cerca-rutas-alternativas\",\n  rutaPrincipalContorno: \"cerca-ruta-principal-contorno\",\n  rutaPrincipal: \"cerca-ruta-principal\",\n  ubicacionHalo: \"cerca-ubicacion-halo\",\n  ubicacionPunto: \"cerca-ubicacion-punto\",\n  gruposCirculo: \"cerca-grupos-circulo\",\n  gruposCantidad: \"cerca-grupos-cantidad\",\n  gruposToque: \"cerca-grupos-toque\",\n  gruposServidorCirculo: \"cerca-grupos-servidor-circulo\",\n  gruposServidorCantidad: \"cerca-grupos-servidor-cantidad\",\n  gruposServidorToque: \"cerca-grupos-servidor-toque\",\n  negociosPunto: \"cerca-negocios-punto\",\n  negociosSimbolo: \"cerca-negocios-simbolo\",\n  sedesPunto: \"cerca-sedes-punto\",\n  vehiculos: \"cerca-vehiculos-simbolo\",\n  seleccion: \"cerca-seleccion-punto\",\n  seleccionArea: \"cerca-seleccion-area\",\n  /**\n   * Las capas invisibles que reciben los toques.\n   *\n   * Un alfiler de 9 px de radio se ve bien y **no se puede tocar** en un\n   * teléfono: CLAUDE.md §1 pide objetivos de 44 px, o sea 22 de radio.\n   * Agrandar el círculo pintado sería taparlo todo, así que encima va otro\n   * círculo del tamaño tocable con opacidad cero.\n   *\n   * Funciona porque la consulta de entidades dibujadas de MapLibre lee el\n   * índice espacial y **sí devuelve capas con opacidad cero** — lo que no\n   * devuelve es capas con la visibilidad apagada, que es una cosa distinta.\n   * Es la diferencia entre «transparente» y «no está».\n   */\n  negociosToque: \"cerca-negocios-toque\",\n  sedesToque: \"cerca-sedes-toque\",\n  vehiculosToque: \"cerca-vehiculos-toque\",\n  rutasToque: \"cerca-rutas-toque\",\n} as const;\n\n/**\n * Los puntos de inserción que el estilo base deja preparados.\n *\n * Son capas vacías con identificador estable que solo existen para tener\n * dónde insertar. La alternativa —referenciar una capa concreta de Protomaps,\n * como `roads_labels_minor`— se rompe en cada actualización del upstream, y\n * se rompe en silencio: `agregarCapa` con un `antesDe` que no existe lanza en\n * MapLibre, pero un identificador que cambió de significado no lanza nada,\n * solo deja la capa en el sitio equivocado.\n *\n * El orden, de abajo hacia arriba: mapa base sin rótulos → **áreas** →\n * **líneas** → rótulos del mapa base → **puntos** → **selección**.\n *\n * Los rótulos del mapa base van en medio a propósito: el nombre de la calle\n * se tiene que seguir leyendo por debajo de un polígono de cobertura, y los\n * alfileres tienen que quedar por encima de todo. Un mapa que tapa los\n * nombres de las calles no sirve para lo único que se le pide.\n */\nexport const ANCLAS_POR_DEFECTO = {\n  areas: \"cerca-ancla-areas\",\n  lineas: \"cerca-ancla-lineas\",\n  puntos: \"cerca-ancla-puntos\",\n  seleccion: \"cerca-ancla-seleccion\",\n} as const;\n\nexport type Anclas = {\n  readonly areas: string;\n  readonly lineas: string;\n  readonly puntos: string;\n  readonly seleccion: string;\n};\n\n/** El radio en píxeles que hace que un objetivo mida los 44 px que pide CLAUDE.md §1. */\nexport const RADIO_TACTIL_MINIMO_EN_PX = 22;\n"]}

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `@cerca.red/mapa` — el SDK del mapa de Cerca, **sin MapLibre**.
+ *
+ * ## Qué se puede importar desde aquí, y por qué importa
+ *
+ * Todo lo de este punto de entrada es SSR-seguro: no toca `window`, ni el
+ * DOM, ni WebGL, ni `maplibre-gl`. Se puede importar desde un Server
+ * Component de Next sobre Cloudflare Workers sin que el build reviente, y se
+ * puede importar desde un Worker para calcular una caja o traducir una
+ * proyección sin arrastrar 250 KB de motor de mapas.
+ *
+ * **El mapa de verdad entra por `@cerca.red/mapa/navegador`.** Es una subruta
+ * explícita a propósito: importarla se ve en el diff, y quien la escribe sabe
+ * que acaba de meter WebGL en ese archivo. Un solo punto de entrada obligaría
+ * a rodeos como el que la PWA ya tiene documentado en
+ * `Cerca-PWA/scripts/banco-motores.ts` por el `exports` único de `@cerca/ui`,
+ * y aquí sería peor, porque lo que se arrastraría es el motor entero.
+ *
+ * La prueba `sin-dom.test.ts` de este paquete importa este archivo bajo el
+ * runtime de Workers y falla si algo de esto deja de ser cierto. Si esa prueba
+ * se pone roja, se arregla el import — no la prueba.
+ *
+ * Y `@cerca.red/mapa/doble` da un motor falso con la geometría de verdad, para
+ * que una superficie pruebe sus pantallas sin levantar un contexto WebGL.
+ */
+export { type MapaDeCerca, type OpcionesDeCrearMapa, type OpcionesDeSeleccion, type QueEncuadrar, crearMapaConMotor, } from "./sdk.ts";
+export { type BandaDeIsocrona, type EnfasisEnMapa, type GrupoEnMapa, type NegocioEnMapa, type PrecisionDeUbicacion, type RutaEnMapa, type ResultadosEnMapa, type SedeEnMapa, type SimboloDeMapa, type UbicacionDeUsuarioEnMapa, type VehiculoEnMapa, type ZonaEnMapa, } from "./proyecciones.ts";
+export { type CapaDelEstilo, type EspecificacionDeEstilo, type Expresion, type FabricaDeEstilo, type Tema, type TipoDeCapa, } from "./estilo.ts";
+export { type Desuscribir, type DestinoDeCamara, type EntidadDibujada, type EventoDeCamara, type EventoDePuntero, type EventosDeCapa, type EventosNativos, type ImagenDeSimbolo, type MapaNativo, type Margenes, type OpcionesDeEncuadre, type OpcionesDeFuente, type OpcionesDeMovimiento, type OrigenDeMovimiento, type PuntoEnPantalla, type VistaDelMapa, } from "./puerto.ts";
+export { type EventoDeCamaraPublico, type EventoDeClicEnMapa, type EventoDeError, type EventoDeGrupo, type EventoDeMapaListo, type EventoDeNegocio, type EventoDeNegocioEncima, type EventoDeRuta, type EventoDeSede, type EventoDeUbicacion, type EventoDeVehiculo, type EventosDelMapa, type TipoDeEvento, } from "./eventos.ts";
+export { type ModeloDelMapa, cajaDeNegocio, cajaDelModelo, modeloInicial, } from "./modelo.ts";
+export { MARGENES_POR_DEFECTO, ZOOM_DE_UN_PUNTO, type PlanDeEncuadre, planearEncuadre, } from "./encuadre.ts";
+export { type PaletaDelMapa, PALETAS_POR_DEFECTO, resolverPaleta, } from "./paleta.ts";
+export { ANCLAS_POR_DEFECTO, type Anclas, CAPAS, FUENTES, RADIO_TACTIL_MINIMO_EN_PX, } from "./identificadores.ts";
+export { type CapaExtra } from "./sincronizacion.ts";
+export { RUTA_DEL_WORKER_DE_MAPLIBRE, VERSION_DE_MAPLIBRE, } from "./worker-de-maplibre.ts";
+export { type ArchivoDeTeselas, type Manifiesto, ESQUEMA_QUE_SE_ENTIENDE, archivoQueCubre, leerManifiesto, urlDeProtocolo, } from "./manifiesto.ts";

package/dist/index.js

@@ -0,0 +1,33 @@
+/**
+ * `@cerca.red/mapa` — el SDK del mapa de Cerca, **sin MapLibre**.
+ *
+ * ## Qué se puede importar desde aquí, y por qué importa
+ *
+ * Todo lo de este punto de entrada es SSR-seguro: no toca `window`, ni el
+ * DOM, ni WebGL, ni `maplibre-gl`. Se puede importar desde un Server
+ * Component de Next sobre Cloudflare Workers sin que el build reviente, y se
+ * puede importar desde un Worker para calcular una caja o traducir una
+ * proyección sin arrastrar 250 KB de motor de mapas.
+ *
+ * **El mapa de verdad entra por `@cerca.red/mapa/navegador`.** Es una subruta
+ * explícita a propósito: importarla se ve en el diff, y quien la escribe sabe
+ * que acaba de meter WebGL en ese archivo. Un solo punto de entrada obligaría
+ * a rodeos como el que la PWA ya tiene documentado en
+ * `Cerca-PWA/scripts/banco-motores.ts` por el `exports` único de `@cerca/ui`,
+ * y aquí sería peor, porque lo que se arrastraría es el motor entero.
+ *
+ * La prueba `sin-dom.test.ts` de este paquete importa este archivo bajo el
+ * runtime de Workers y falla si algo de esto deja de ser cierto. Si esa prueba
+ * se pone roja, se arregla el import — no la prueba.
+ *
+ * Y `@cerca.red/mapa/doble` da un motor falso con la geometría de verdad, para
+ * que una superficie pruebe sus pantallas sin levantar un contexto WebGL.
+ */
+export { crearMapaConMotor, } from "./sdk.js";
+export { cajaDeNegocio, cajaDelModelo, modeloInicial, } from "./modelo.js";
+export { MARGENES_POR_DEFECTO, ZOOM_DE_UN_PUNTO, planearEncuadre, } from "./encuadre.js";
+export { PALETAS_POR_DEFECTO, resolverPaleta, } from "./paleta.js";
+export { ANCLAS_POR_DEFECTO, CAPAS, FUENTES, RADIO_TACTIL_MINIMO_EN_PX, } from "./identificadores.js";
+export { RUTA_DEL_WORKER_DE_MAPLIBRE, VERSION_DE_MAPLIBRE, } from "./worker-de-maplibre.js";
+export { ESQUEMA_QUE_SE_ENTIENDE, archivoQueCubre, leerManifiesto, urlDeProtocolo, } from "./manifiesto.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAKL,iBAAiB,GAClB,MAAM,UAAU,CAAC;AA6DlB,OAAO,EAEL,aAAa,EACb,aAAa,EACb,aAAa,GACd,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAEhB,eAAe,GAChB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAEL,mBAAmB,EACnB,cAAc,GACf,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,kBAAkB,EAElB,KAAK,EACL,OAAO,EACP,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,GACpB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAGL,uBAAuB,EACvB,eAAe,EACf,cAAc,EACd,cAAc,GACf,MAAM,iBAAiB,CAAC","sourcesContent":["/**\n * `@cerca.red/mapa` — el SDK del mapa de Cerca, **sin MapLibre**.\n *\n * ## Qué se puede importar desde aquí, y por qué importa\n *\n * Todo lo de este punto de entrada es SSR-seguro: no toca `window`, ni el\n * DOM, ni WebGL, ni `maplibre-gl`. Se puede importar desde un Server\n * Component de Next sobre Cloudflare Workers sin que el build reviente, y se\n * puede importar desde un Worker para calcular una caja o traducir una\n * proyección sin arrastrar 250 KB de motor de mapas.\n *\n * **El mapa de verdad entra por `@cerca.red/mapa/navegador`.** Es una subruta\n * explícita a propósito: importarla se ve en el diff, y quien la escribe sabe\n * que acaba de meter WebGL en ese archivo. Un solo punto de entrada obligaría\n * a rodeos como el que la PWA ya tiene documentado en\n * `Cerca-PWA/scripts/banco-motores.ts` por el `exports` único de `@cerca/ui`,\n * y aquí sería peor, porque lo que se arrastraría es el motor entero.\n *\n * La prueba `sin-dom.test.ts` de este paquete importa este archivo bajo el\n * runtime de Workers y falla si algo de esto deja de ser cierto. Si esa prueba\n * se pone roja, se arregla el import — no la prueba.\n *\n * Y `@cerca.red/mapa/doble` da un motor falso con la geometría de verdad, para\n * que una superficie pruebe sus pantallas sin levantar un contexto WebGL.\n */\n\nexport {\n  type MapaDeCerca,\n  type OpcionesDeCrearMapa,\n  type OpcionesDeSeleccion,\n  type QueEncuadrar,\n  crearMapaConMotor,\n} from \"./sdk.ts\";\n\nexport {\n  type BandaDeIsocrona,\n  type EnfasisEnMapa,\n  type GrupoEnMapa,\n  type NegocioEnMapa,\n  type PrecisionDeUbicacion,\n  type RutaEnMapa,\n  type ResultadosEnMapa,\n  type SedeEnMapa,\n  type SimboloDeMapa,\n  type UbicacionDeUsuarioEnMapa,\n  type VehiculoEnMapa,\n  type ZonaEnMapa,\n} from \"./proyecciones.ts\";\n\nexport {\n  type CapaDelEstilo,\n  type EspecificacionDeEstilo,\n  type Expresion,\n  type FabricaDeEstilo,\n  type Tema,\n  type TipoDeCapa,\n} from \"./estilo.ts\";\n\nexport {\n  type Desuscribir,\n  type DestinoDeCamara,\n  type EntidadDibujada,\n  type EventoDeCamara,\n  type EventoDePuntero,\n  type EventosDeCapa,\n  type EventosNativos,\n  type ImagenDeSimbolo,\n  type MapaNativo,\n  type Margenes,\n  type OpcionesDeEncuadre,\n  type OpcionesDeFuente,\n  type OpcionesDeMovimiento,\n  type OrigenDeMovimiento,\n  type PuntoEnPantalla,\n  type VistaDelMapa,\n} from \"./puerto.ts\";\n\nexport {\n  type EventoDeCamaraPublico,\n  type EventoDeClicEnMapa,\n  type EventoDeError,\n  type EventoDeGrupo,\n  type EventoDeMapaListo,\n  type EventoDeNegocio,\n  type EventoDeNegocioEncima,\n  type EventoDeRuta,\n  type EventoDeSede,\n  type EventoDeUbicacion,\n  type EventoDeVehiculo,\n  type EventosDelMapa,\n  type TipoDeEvento,\n} from \"./eventos.ts\";\n\nexport {\n  type ModeloDelMapa,\n  cajaDeNegocio,\n  cajaDelModelo,\n  modeloInicial,\n} from \"./modelo.ts\";\n\nexport {\n  MARGENES_POR_DEFECTO,\n  ZOOM_DE_UN_PUNTO,\n  type PlanDeEncuadre,\n  planearEncuadre,\n} from \"./encuadre.ts\";\n\nexport {\n  type PaletaDelMapa,\n  PALETAS_POR_DEFECTO,\n  resolverPaleta,\n} from \"./paleta.ts\";\n\nexport {\n  ANCLAS_POR_DEFECTO,\n  type Anclas,\n  CAPAS,\n  FUENTES,\n  RADIO_TACTIL_MINIMO_EN_PX,\n} from \"./identificadores.ts\";\n\nexport { type CapaExtra } from \"./sincronizacion.ts\";\n\nexport {\n  RUTA_DEL_WORKER_DE_MAPLIBRE,\n  VERSION_DE_MAPLIBRE,\n} from \"./worker-de-maplibre.ts\";\n\nexport {\n  type ArchivoDeTeselas,\n  type Manifiesto,\n  ESQUEMA_QUE_SE_ENTIENDE,\n  archivoQueCubre,\n  leerManifiesto,\n  urlDeProtocolo,\n} from \"./manifiesto.ts\";\n"]}

package/dist/manifiesto.d.ts

@@ -0,0 +1,97 @@
+import { type Caja, type Coordenada } from "@cerca.red/geo";
+/**
+ * El manifiesto: de dónde sale la URL de un archivo de teselas.
+ *
+ * ## La regla que este archivo hace cumplir
+ *
+ * **La URL de un `.pmtiles` solo sale del manifiesto.** No se escribe en un
+ * componente, no se compone con plantillas, no se guarda en una variable de
+ * entorno de la superficie. ADR-024 puso URLs **absolutas** dentro del
+ * manifiesto exactamente para que quien las lea no tenga que construir nada, y
+ * ADR-027 lo llama «el punto de todo el documento».
+ *
+ * La razón no es orden: es que promover un puntero a una versión anterior
+ * **es** el rollback. Basta con que una superficie arme
+ * `.../colombia/2026-09-07.pmtiles` a mano para que revertir deje de revertir
+ * en esa superficie, y eso no falla — sigue funcionando, con el archivo malo.
+ *
+ * ## Dos formas, y por qué no son la misma
+ *
+ * Lo que **entra** es el documento que escribe el pipeline
+ * (`guiones/teselas/manifiesto.ts`, esquema 1): un objeto con `archivo` en
+ * singular, `zoom.minimo`, `caja`, `licencia.atribucion`. Es su formato y lo
+ * decide él; este paquete lo lee, no lo define.
+ *
+ * Lo que **sale** es una lista de archivos. No es capricho: ADR-024 ya dejó
+ * escrito qué pasa el día que Colombia crezca —el país a zoom bajo y archivos
+ * por ciudad a zoom alto, «seleccionados por el manifiesto según dónde esté
+ * mirando el usuario»—. Un tipo que hoy fuera un objeto suelto obligaría ese
+ * día a cambiar cada superficie que lo lee; con la lista de un elemento, el
+ * día que el manifiesto traiga dos, aquí no cambia nada.
+ *
+ * ## Por qué la validación es estricta y ruidosa
+ *
+ * Porque el manifiesto lo produce otro programa, en otro repositorio y en otro
+ * momento. Un documento con un campo renombrado no rompe nada al leerse:
+ * produce `undefined`, que se convierte en `"pmtiles://undefined"`, que
+ * MapLibre pide y falla como un error de red. La traza dice «no se pudo cargar
+ * la fuente» y no dice que el manifiesto cambió de forma.
+ *
+ * Así que se valida entero, al entrar, con el nombre del campo en el mensaje.
+ * Y `manifiesto.test.ts` lee el `cartografia/ejemplo-manifiesto.json` que
+ * genera el pipeline de verdad: si el formato cambia ahí, esta prueba se pone
+ * roja aquí, que es donde tiene que doler.
+ */
+/**
+ * La versión de formato que este lector entiende.
+ *
+ * Un lector viejo tiene que poder decir «esto no lo entiendo» en vez de leer
+ * un campo que ahora significa otra cosa. El pipeline sube este número cuando
+ * un campo cambia de significado, no cuando añade uno nuevo — así que un
+ * manifiesto con esquema mayor se rechaza y uno con campos de más se acepta.
+ */
+export declare const ESQUEMA_QUE_SE_ENTIENDE = 1;
+/** Un archivo de teselas publicado, con todo lo que hace falta para pedirlo. */
+export interface ArchivoDeTeselas {
+    /** URL absoluta. Se usa tal cual. */
+    readonly url: string;
+    readonly bytes: number;
+    /** La suma de verificación con la que se publicó. */
+    readonly sha256: string;
+    readonly zoomMinimo: number;
+    readonly zoomMaximo: number;
+    /** La caja que cubre este archivo. */
+    readonly caja: Caja;
+    /** Las capas que trae. El estilo espera exactamente estas. */
+    readonly capas: readonly string[];
+}
+export interface Manifiesto {
+    readonly esquema: number;
+    readonly region: string;
+    readonly version: string;
+    /** Los archivos de esta versión. Hoy siempre uno; ver arriba. */
+    readonly archivos: readonly ArchivoDeTeselas[];
+    /**
+     * La atribución, copiada de dentro del archivo de teselas.
+     *
+     * Es **texto legal** (CLAUDE.md §11): se muestra tal cual, no se recorta ni
+     * se reescribe. Viene de los metadatos del propio `.pmtiles`, que es lo que
+     * evita que una superficie se quede sin ella por olvido.
+     */
+    readonly atribucion: string;
+    /** A qué versión apuntaba antes. Existe para poder decir a qué se revirtió. */
+    readonly anterior: string | undefined;
+}
+/** La URL con el protocolo puesto, que es lo que espera MapLibre. */
+export declare function urlDeProtocolo(archivo: ArchivoDeTeselas): string;
+/**
+ * El archivo que cubre una coordenada, con **el mayor detalle disponible**.
+ *
+ * Cuando haya un archivo de país y uno de ciudad, los dos contienen el centro
+ * de Pereira; el que sirve es el de más zoom. Se elige por `zoomMaximo` y no
+ * por el orden de la lista porque el orden es una convención que nadie
+ * comprueba.
+ */
+export declare function archivoQueCubre(manifiesto: Manifiesto, coordenada: Coordenada): ArchivoDeTeselas | undefined;
+/** Valida un manifiesto recién descargado, o falla diciendo qué le falta. */
+export declare function leerManifiesto(documento: unknown): Manifiesto;

package/dist/manifiesto.js

@@ -0,0 +1,156 @@
+import { cajaContiene, esCaja, } from "@cerca.red/geo";
+/**
+ * El manifiesto: de dónde sale la URL de un archivo de teselas.
+ *
+ * ## La regla que este archivo hace cumplir
+ *
+ * **La URL de un `.pmtiles` solo sale del manifiesto.** No se escribe en un
+ * componente, no se compone con plantillas, no se guarda en una variable de
+ * entorno de la superficie. ADR-024 puso URLs **absolutas** dentro del
+ * manifiesto exactamente para que quien las lea no tenga que construir nada, y
+ * ADR-027 lo llama «el punto de todo el documento».
+ *
+ * La razón no es orden: es que promover un puntero a una versión anterior
+ * **es** el rollback. Basta con que una superficie arme
+ * `.../colombia/2026-09-07.pmtiles` a mano para que revertir deje de revertir
+ * en esa superficie, y eso no falla — sigue funcionando, con el archivo malo.
+ *
+ * ## Dos formas, y por qué no son la misma
+ *
+ * Lo que **entra** es el documento que escribe el pipeline
+ * (`guiones/teselas/manifiesto.ts`, esquema 1): un objeto con `archivo` en
+ * singular, `zoom.minimo`, `caja`, `licencia.atribucion`. Es su formato y lo
+ * decide él; este paquete lo lee, no lo define.
+ *
+ * Lo que **sale** es una lista de archivos. No es capricho: ADR-024 ya dejó
+ * escrito qué pasa el día que Colombia crezca —el país a zoom bajo y archivos
+ * por ciudad a zoom alto, «seleccionados por el manifiesto según dónde esté
+ * mirando el usuario»—. Un tipo que hoy fuera un objeto suelto obligaría ese
+ * día a cambiar cada superficie que lo lee; con la lista de un elemento, el
+ * día que el manifiesto traiga dos, aquí no cambia nada.
+ *
+ * ## Por qué la validación es estricta y ruidosa
+ *
+ * Porque el manifiesto lo produce otro programa, en otro repositorio y en otro
+ * momento. Un documento con un campo renombrado no rompe nada al leerse:
+ * produce `undefined`, que se convierte en `"pmtiles://undefined"`, que
+ * MapLibre pide y falla como un error de red. La traza dice «no se pudo cargar
+ * la fuente» y no dice que el manifiesto cambió de forma.
+ *
+ * Así que se valida entero, al entrar, con el nombre del campo en el mensaje.
+ * Y `manifiesto.test.ts` lee el `cartografia/ejemplo-manifiesto.json` que
+ * genera el pipeline de verdad: si el formato cambia ahí, esta prueba se pone
+ * roja aquí, que es donde tiene que doler.
+ */
+/**
+ * La versión de formato que este lector entiende.
+ *
+ * Un lector viejo tiene que poder decir «esto no lo entiendo» en vez de leer
+ * un campo que ahora significa otra cosa. El pipeline sube este número cuando
+ * un campo cambia de significado, no cuando añade uno nuevo — así que un
+ * manifiesto con esquema mayor se rechaza y uno con campos de más se acepta.
+ */
+export const ESQUEMA_QUE_SE_ENTIENDE = 1;
+/** La URL con el protocolo puesto, que es lo que espera MapLibre. */
+export function urlDeProtocolo(archivo) {
+    return `pmtiles://${archivo.url}`;
+}
+/**
+ * El archivo que cubre una coordenada, con **el mayor detalle disponible**.
+ *
+ * Cuando haya un archivo de país y uno de ciudad, los dos contienen el centro
+ * de Pereira; el que sirve es el de más zoom. Se elige por `zoomMaximo` y no
+ * por el orden de la lista porque el orden es una convención que nadie
+ * comprueba.
+ */
+export function archivoQueCubre(manifiesto, coordenada) {
+    let elegido;
+    for (const archivo of manifiesto.archivos) {
+        if (!cajaContiene(archivo.caja, coordenada))
+            continue;
+        if (elegido === undefined || archivo.zoomMaximo > elegido.zoomMaximo) {
+            elegido = archivo;
+        }
+    }
+    return elegido;
+}
+/** Valida un manifiesto recién descargado, o falla diciendo qué le falta. */
+export function leerManifiesto(documento) {
+    const raiz = objeto(documento, "el manifiesto");
+    const esquema = numero(raiz["esquema"], "el manifiesto: 'esquema'");
+    if (esquema > ESQUEMA_QUE_SE_ENTIENDE) {
+        throw new TypeError(`el manifiesto: es de esquema ${esquema} y este lector entiende hasta ` +
+            `el ${ESQUEMA_QUE_SE_ENTIENDE}. Un campo puede haber cambiado de ` +
+            `significado, así que leerlo sería peor que no leerlo. Hay que subir ` +
+            `la versión de @cerca.red/mapa en esta superficie.`);
+    }
+    const licencia = objeto(raiz["licencia"], "el manifiesto: 'licencia'");
+    const anterior = raiz["anterior"];
+    return {
+        esquema,
+        region: texto(raiz["region"], "el manifiesto: 'region'"),
+        version: texto(raiz["version"], "el manifiesto: 'version'"),
+        // El pipeline escribe `archivo` en singular. Aquí se normaliza a una
+        // lista de un elemento; ver el bloque de arriba.
+        archivos: [leerArchivo(raiz["archivo"], "el manifiesto: 'archivo'")],
+        atribucion: texto(licencia["atribucion"], "el manifiesto: 'licencia.atribucion'"),
+        anterior: typeof anterior === "string" ? anterior : undefined,
+    };
+}
+function leerArchivo(crudo, donde) {
+    const archivo = objeto(crudo, donde);
+    const url = texto(archivo["url"], `${donde}.url`);
+    if (!/^https?:\/\//.test(url)) {
+        throw new TypeError(`${donde}.url: se esperaba una URL absoluta y llegó "${url}". El ` +
+            `manifiesto las lleva absolutas a propósito (ADR-024): una relativa ` +
+            `obligaría a quien la lee a componerla, que es justo lo que deja el ` +
+            `rollback sin efecto.`);
+    }
+    const caja = archivo["caja"];
+    if (!esCaja(caja)) {
+        throw new TypeError(`${donde}.caja: se esperaba una caja [oeste, sur, este, norte] en ` +
+            `grados y llegó ${JSON.stringify(caja)}.`);
+    }
+    const zoom = objeto(archivo["zoom"], `${donde}.zoom`);
+    const zoomMinimo = numero(zoom["minimo"], `${donde}.zoom.minimo`);
+    const zoomMaximo = numero(zoom["maximo"], `${donde}.zoom.maximo`);
+    if (zoomMaximo < zoomMinimo) {
+        throw new TypeError(`${donde}.zoom: el máximo (${zoomMaximo}) es menor que el mínimo ` +
+            `(${zoomMinimo}). Con los dos cambiados el mapa no pide ninguna ` +
+            `tesela y se queda en blanco sin error.`);
+    }
+    const capas = archivo["capas"];
+    if (!Array.isArray(capas) || capas.some((c) => typeof c !== "string")) {
+        throw new TypeError(`${donde}.capas: se esperaba una lista de nombres de capa. Es lo que ` +
+            `dice qué trae el archivo, y sin ella no hay forma de saber si el ` +
+            `estilo espera algo que no está.`);
+    }
+    return {
+        url,
+        bytes: numero(archivo["bytes"], `${donde}.bytes`),
+        sha256: texto(archivo["sha256"], `${donde}.sha256`),
+        zoomMinimo,
+        zoomMaximo,
+        caja,
+        capas: capas,
+    };
+}
+function objeto(valor, donde) {
+    if (typeof valor !== "object" || valor === null || Array.isArray(valor)) {
+        throw new TypeError(`${donde}: se esperaba un objeto JSON y llegó ${JSON.stringify(valor)}.`);
+    }
+    return valor;
+}
+function texto(valor, donde) {
+    if (typeof valor !== "string" || valor === "") {
+        throw new TypeError(`${donde}: se esperaba un texto no vacío y llegó ${JSON.stringify(valor)}.`);
+    }
+    return valor;
+}
+function numero(valor, donde) {
+    if (typeof valor !== "number" || !Number.isFinite(valor)) {
+        throw new TypeError(`${donde}: se esperaba un número y llegó ${JSON.stringify(valor)}.`);
+    }
+    return valor;
+}
+//# sourceMappingURL=manifiesto.js.map

package/dist/manifiesto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifiesto.js","sourceRoot":"","sources":["../src/manifiesto.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type Caja,\n  cajaContiene,\n  type Coordenada,\n  esCaja,\n} from \"@cerca.red/geo\";\n\n/**\n * El manifiesto: de dónde sale la URL de un archivo de teselas.\n *\n * ## La regla que este archivo hace cumplir\n *\n * **La URL de un `.pmtiles` solo sale del manifiesto.** No se escribe en un\n * componente, no se compone con plantillas, no se guarda en una variable de\n * entorno de la superficie. ADR-024 puso URLs **absolutas** dentro del\n * manifiesto exactamente para que quien las lea no tenga que construir nada, y\n * ADR-027 lo llama «el punto de todo el documento».\n *\n * La razón no es orden: es que promover un puntero a una versión anterior\n * **es** el rollback. Basta con que una superficie arme\n * `.../colombia/2026-09-07.pmtiles` a mano para que revertir deje de revertir\n * en esa superficie, y eso no falla — sigue funcionando, con el archivo malo.\n *\n * ## Dos formas, y por qué no son la misma\n *\n * Lo que **entra** es el documento que escribe el pipeline\n * (`guiones/teselas/manifiesto.ts`, esquema 1): un objeto con `archivo` en\n * singular, `zoom.minimo`, `caja`, `licencia.atribucion`. Es su formato y lo\n * decide él; este paquete lo lee, no lo define.\n *\n * Lo que **sale** es una lista de archivos. No es capricho: ADR-024 ya dejó\n * escrito qué pasa el día que Colombia crezca —el país a zoom bajo y archivos\n * por ciudad a zoom alto, «seleccionados por el manifiesto según dónde esté\n * mirando el usuario»—. Un tipo que hoy fuera un objeto suelto obligaría ese\n * día a cambiar cada superficie que lo lee; con la lista de un elemento, el\n * día que el manifiesto traiga dos, aquí no cambia nada.\n *\n * ## Por qué la validación es estricta y ruidosa\n *\n * Porque el manifiesto lo produce otro programa, en otro repositorio y en otro\n * momento. Un documento con un campo renombrado no rompe nada al leerse:\n * produce `undefined`, que se convierte en `\"pmtiles://undefined\"`, que\n * MapLibre pide y falla como un error de red. La traza dice «no se pudo cargar\n * la fuente» y no dice que el manifiesto cambió de forma.\n *\n * Así que se valida entero, al entrar, con el nombre del campo en el mensaje.\n * Y `manifiesto.test.ts` lee el `cartografia/ejemplo-manifiesto.json` que\n * genera el pipeline de verdad: si el formato cambia ahí, esta prueba se pone\n * roja aquí, que es donde tiene que doler.\n */\n\n/**\n * La versión de formato que este lector entiende.\n *\n * Un lector viejo tiene que poder decir «esto no lo entiendo» en vez de leer\n * un campo que ahora significa otra cosa. El pipeline sube este número cuando\n * un campo cambia de significado, no cuando añade uno nuevo — así que un\n * manifiesto con esquema mayor se rechaza y uno con campos de más se acepta.\n */\nexport const ESQUEMA_QUE_SE_ENTIENDE = 1;\n\n/** Un archivo de teselas publicado, con todo lo que hace falta para pedirlo. */\nexport interface ArchivoDeTeselas {\n  /** URL absoluta. Se usa tal cual. */\n  readonly url: string;\n  readonly bytes: number;\n  /** La suma de verificación con la que se publicó. */\n  readonly sha256: string;\n  readonly zoomMinimo: number;\n  readonly zoomMaximo: number;\n  /** La caja que cubre este archivo. */\n  readonly caja: Caja;\n  /** Las capas que trae. El estilo espera exactamente estas. */\n  readonly capas: readonly string[];\n}\n\nexport interface Manifiesto {\n  readonly esquema: number;\n  readonly region: string;\n  readonly version: string;\n  /** Los archivos de esta versión. Hoy siempre uno; ver arriba. */\n  readonly archivos: readonly ArchivoDeTeselas[];\n  /**\n   * La atribución, copiada de dentro del archivo de teselas.\n   *\n   * Es **texto legal** (CLAUDE.md §11): se muestra tal cual, no se recorta ni\n   * se reescribe. Viene de los metadatos del propio `.pmtiles`, que es lo que\n   * evita que una superficie se quede sin ella por olvido.\n   */\n  readonly atribucion: string;\n  /** A qué versión apuntaba antes. Existe para poder decir a qué se revirtió. */\n  readonly anterior: string | undefined;\n}\n\n/** La URL con el protocolo puesto, que es lo que espera MapLibre. */\nexport function urlDeProtocolo(archivo: ArchivoDeTeselas): string {\n  return `pmtiles://${archivo.url}`;\n}\n\n/**\n * El archivo que cubre una coordenada, con **el mayor detalle disponible**.\n *\n * Cuando haya un archivo de país y uno de ciudad, los dos contienen el centro\n * de Pereira; el que sirve es el de más zoom. Se elige por `zoomMaximo` y no\n * por el orden de la lista porque el orden es una convención que nadie\n * comprueba.\n */\nexport function archivoQueCubre(\n  manifiesto: Manifiesto,\n  coordenada: Coordenada,\n): ArchivoDeTeselas | undefined {\n  let elegido: ArchivoDeTeselas | undefined;\n  for (const archivo of manifiesto.archivos) {\n    if (!cajaContiene(archivo.caja, coordenada)) continue;\n    if (elegido === undefined || archivo.zoomMaximo > elegido.zoomMaximo) {\n      elegido = archivo;\n    }\n  }\n  return elegido;\n}\n\n/** Valida un manifiesto recién descargado, o falla diciendo qué le falta. */\nexport function leerManifiesto(documento: unknown): Manifiesto {\n  const raiz = objeto(documento, \"el manifiesto\");\n\n  const esquema = numero(raiz[\"esquema\"], \"el manifiesto: 'esquema'\");\n  if (esquema > ESQUEMA_QUE_SE_ENTIENDE) {\n    throw new TypeError(\n      `el manifiesto: es de esquema ${esquema} y este lector entiende hasta ` +\n        `el ${ESQUEMA_QUE_SE_ENTIENDE}. Un campo puede haber cambiado de ` +\n        `significado, así que leerlo sería peor que no leerlo. Hay que subir ` +\n        `la versión de @cerca.red/mapa en esta superficie.`,\n    );\n  }\n\n  const licencia = objeto(raiz[\"licencia\"], \"el manifiesto: 'licencia'\");\n  const anterior = raiz[\"anterior\"];\n\n  return {\n    esquema,\n    region: texto(raiz[\"region\"], \"el manifiesto: 'region'\"),\n    version: texto(raiz[\"version\"], \"el manifiesto: 'version'\"),\n    // El pipeline escribe `archivo` en singular. Aquí se normaliza a una\n    // lista de un elemento; ver el bloque de arriba.\n    archivos: [leerArchivo(raiz[\"archivo\"], \"el manifiesto: 'archivo'\")],\n    atribucion: texto(\n      licencia[\"atribucion\"],\n      \"el manifiesto: 'licencia.atribucion'\",\n    ),\n    anterior: typeof anterior === \"string\" ? anterior : undefined,\n  };\n}\n\nfunction leerArchivo(crudo: unknown, donde: string): ArchivoDeTeselas {\n  const archivo = objeto(crudo, donde);\n  const url = texto(archivo[\"url\"], `${donde}.url`);\n\n  if (!/^https?:\\/\\//.test(url)) {\n    throw new TypeError(\n      `${donde}.url: se esperaba una URL absoluta y llegó \"${url}\". El ` +\n        `manifiesto las lleva absolutas a propósito (ADR-024): una relativa ` +\n        `obligaría a quien la lee a componerla, que es justo lo que deja el ` +\n        `rollback sin efecto.`,\n    );\n  }\n\n  const caja = archivo[\"caja\"];\n  if (!esCaja(caja)) {\n    throw new TypeError(\n      `${donde}.caja: se esperaba una caja [oeste, sur, este, norte] en ` +\n        `grados y llegó ${JSON.stringify(caja)}.`,\n    );\n  }\n\n  const zoom = objeto(archivo[\"zoom\"], `${donde}.zoom`);\n  const zoomMinimo = numero(zoom[\"minimo\"], `${donde}.zoom.minimo`);\n  const zoomMaximo = numero(zoom[\"maximo\"], `${donde}.zoom.maximo`);\n  if (zoomMaximo < zoomMinimo) {\n    throw new TypeError(\n      `${donde}.zoom: el máximo (${zoomMaximo}) es menor que el mínimo ` +\n        `(${zoomMinimo}). Con los dos cambiados el mapa no pide ninguna ` +\n        `tesela y se queda en blanco sin error.`,\n    );\n  }\n\n  const capas = archivo[\"capas\"];\n  if (!Array.isArray(capas) || capas.some((c) => typeof c !== \"string\")) {\n    throw new TypeError(\n      `${donde}.capas: se esperaba una lista de nombres de capa. Es lo que ` +\n        `dice qué trae el archivo, y sin ella no hay forma de saber si el ` +\n        `estilo espera algo que no está.`,\n    );\n  }\n\n  return {\n    url,\n    bytes: numero(archivo[\"bytes\"], `${donde}.bytes`),\n    sha256: texto(archivo[\"sha256\"], `${donde}.sha256`),\n    zoomMinimo,\n    zoomMaximo,\n    caja,\n    capas: capas as readonly string[],\n  };\n}\n\nfunction objeto(valor: unknown, donde: string): Record<string, unknown> {\n  if (typeof valor !== \"object\" || valor === null || Array.isArray(valor)) {\n    throw new TypeError(\n      `${donde}: se esperaba un objeto JSON y llegó ${JSON.stringify(valor)}.`,\n    );\n  }\n  return valor as Record<string, unknown>;\n}\n\nfunction texto(valor: unknown, donde: string): string {\n  if (typeof valor !== \"string\" || valor === \"\") {\n    throw new TypeError(\n      `${donde}: se esperaba un texto no vacío y llegó ${JSON.stringify(valor)}.`,\n    );\n  }\n  return valor;\n}\n\nfunction numero(valor: unknown, donde: string): number {\n  if (typeof valor !== \"number\" || !Number.isFinite(valor)) {\n    throw new TypeError(\n      `${donde}: se esperaba un número y llegó ${JSON.stringify(valor)}.`,\n    );\n  }\n  return valor;\n}\n"]}

package/dist/modelo.d.ts

@@ -0,0 +1,154 @@
+import { type Caja, type ColeccionDeEntidades } from "@cerca.red/geo";
+import type { Tema } from "./estilo.ts";
+import type { BandaDeIsocrona, GrupoEnMapa, NegocioEnMapa, ResultadosEnMapa, RutaEnMapa, UbicacionDeUsuarioEnMapa, VehiculoEnMapa, ZonaEnMapa } from "./proyecciones.ts";
+import type { Margenes } from "./puerto.ts";
+/**
+ * El modelo: lo que el SDK sabe que hay que dibujar.
+ *
+ * ## La decisión que sostiene todo el paquete
+ *
+ * **El SDK tiene el modelo y el mapa es una proyección.** No al revés.
+ *
+ * La razón inmediata es que cambiar de tema o de idioma en MapLibre es
+ * reemplazar el estilo entero, y el estilo nuevo llega **sin** las fuentes ni
+ * las capas de Cerca. Si el estado viviera en el mapa, cambiar de tema
+ * perdería los negocios, la ruta y la selección — y no de forma ruidosa: el
+ * mapa se quedaría bonito y vacío.
+ *
+ * La razón de fondo es que hace fiel al doble de pruebas. Si el estado está
+ * aquí, en objetos planos y funciones puras, entonces lo que se prueba en
+ * Node es el comportamiento de verdad y no una imitación: la conversión de
+ * `NegocioEnMapa` a GeoJSON, qué caja hay que encuadrar, qué pasa al
+ * seleccionar algo que no existe. Lo que queda para WebGL es solo que el
+ * motor pinte lo que se le dio.
+ *
+ * ## Inmutable
+ *
+ * Cada operación devuelve un modelo nuevo. No es dogma: el SDK compara el
+ * modelo anterior con el nuevo para decidir qué fuentes tocar, y esa
+ * comparación es imposible si el objeto se modificó por debajo.
+ */
+export interface ModeloDelMapa {
+    readonly resultados: ResultadosEnMapa;
+    readonly seleccionado: string | undefined;
+    readonly ubicacion: UbicacionDeUsuarioEnMapa | undefined;
+    readonly vehiculos: readonly VehiculoEnMapa[];
+    readonly rutas: readonly RutaEnMapa[];
+    readonly zonas: readonly ZonaEnMapa[];
+    readonly isocronas: readonly BandaDeIsocrona[];
+    readonly tema: Tema;
+    readonly idioma: string;
+    readonly margenes: Margenes;
+    /**
+     * Con cuánto radio se dibuja una ubicación marcada como aproximada.
+     *
+     * Vive aquí y **no** en `NegocioEnMapa` a propósito. Que una ubicación sea
+     * aproximada lo decide Cerca; con cuántos metros de área se representa esa
+     * imprecisión es una decisión de dibujo, y meterla en la proyección sería
+     * el primer campo de la acumulación que ADR-027 dice que mata la frontera.
+     */
+    readonly radioDeImprecisionEnMetros: number;
+}
+/** El modelo de un mapa recién creado. */
+export declare function modeloInicial(parciales?: (Partial<Omit<ModeloDelMapa, "resultados">> & {
+    readonly resultados?: ResultadosEnMapa;
+    readonly negocios?: never;
+}) | (Partial<Omit<ModeloDelMapa, "resultados">> & {
+    readonly resultados?: never;
+    readonly negocios?: readonly NegocioEnMapa[];
+})): ModeloDelMapa;
+/** Los negocios del modo actual; vacío mientras se muestran grupos del servidor. */
+export declare function negociosDelModelo(modelo: ModeloDelMapa): readonly NegocioEnMapa[];
+/** Los grupos explícitos del modo actual; vacío mientras se muestran negocios. */
+export declare function gruposDelModelo(modelo: ModeloDelMapa): readonly GrupoEnMapa[];
+/** Las propiedades con las que viaja un negocio a la fuente GeoJSON. */
+interface PropiedadesDeNegocio extends Record<string, unknown> {
+    readonly id: string;
+    readonly enfasis: string;
+    readonly rotulo?: string;
+    readonly simbolo?: string;
+}
+/**
+ * Los negocios, como colección GeoJSON.
+ *
+ * El `id` va **dos veces**: como identificador de la entidad y como
+ * propiedad. No es descuido. El identificador de entidad es lo que necesita
+ * el estado de entidad —el resalte al pasar por encima— y tiene que ser
+ * numérico o una cadena; la propiedad es lo que se lee al consultar lo
+ * dibujado bajo el dedo, porque MapLibre **pierde el identificador de la
+ * entidad al agrupar** y solo conserva las propiedades.
+ */
+export declare function coleccionDeNegocios(modelo: ModeloDelMapa): ColeccionDeEntidades<PropiedadesDeNegocio>;
+interface PropiedadesDeGrupo extends Record<string, unknown> {
+    readonly id: string;
+    readonly cantidad: number;
+    readonly rotulo?: string;
+}
+/** Los agregados del servidor, en una fuente sin clustering local. */
+export declare function coleccionDeGrupos(modelo: ModeloDelMapa): ColeccionDeEntidades<PropiedadesDeGrupo>;
+interface PropiedadesDeSede extends Record<string, unknown> {
+    readonly id: string;
+    readonly negocio: string;
+    readonly rotulo?: string;
+}
+/** Las sedes de todos los negocios, aplanadas en una sola colección. */
+export declare function coleccionDeSedes(modelo: ModeloDelMapa): ColeccionDeEntidades<PropiedadesDeSede>;
+/**
+ * El negocio seleccionado, solo. En su propia fuente porque tiene que
+ * dibujarse **encima** de sus vecinos, y la clave de ordenación de símbolos
+ * no lee el estado de entidad.
+ */
+export declare function coleccionDeSeleccion(modelo: ModeloDelMapa): ColeccionDeEntidades<PropiedadesDeNegocio>;
+/**
+ * Las áreas de las ubicaciones aproximadas.
+ *
+ * Esta es la función que hace visible una decisión que en una lista es una
+ * etiqueta: «no se da por exacta una ubicación que nadie verificó». En un
+ * mapa, un alfiler afirma un punto. Si nadie verificó ese punto, el alfiler
+ * está afirmando algo que Cerca no sabe, y el usuario que camina hasta ahí
+ * descubre el error caminando.
+ *
+ * Un negocio aproximado sale **como área y sin punto**: aparece en esta
+ * colección y se filtra de la de negocios. Dibujar las dos cosas sería
+ * desdecirse en el mismo mapa.
+ */
+export declare function coleccionDeImprecision(modelo: ModeloDelMapa): ColeccionDeEntidades<{
+    id: string;
+}>;
+/** Los negocios con ubicación exacta: los únicos que se dibujan como alfiler. */
+export declare function negociosExactos(modelo: ModeloDelMapa): readonly NegocioEnMapa[];
+/** La ubicación del usuario: el punto y, si se sabe, su área de incertidumbre. */
+export declare function coleccionDeUbicacion(modelo: ModeloDelMapa): ColeccionDeEntidades<Record<string, unknown>>;
+export declare function coleccionDeVehiculos(modelo: ModeloDelMapa): ColeccionDeEntidades<Record<string, unknown>>;
+/**
+ * Las rutas, con `principal` resuelto.
+ *
+ * La regla de desempate está aquí y no en el filtro del estilo porque una
+ * expresión de MapLibre no puede decidir «la primera si ninguna se marcó»:
+ * con dos principales dibujaría las dos encima, y con cero no dibujaría
+ * ninguna en la capa gruesa — la ruta elegida se vería como una alternativa.
+ */
+export declare function coleccionDeRutas(modelo: ModeloDelMapa): ColeccionDeEntidades<Record<string, unknown>>;
+/** Cuál de las rutas es la principal: la primera marcada, o la primera a secas. */
+export declare function indiceDeRutaPrincipal(rutas: readonly RutaEnMapa[]): number;
+export declare function coleccionDeZonas(modelo: ModeloDelMapa): ColeccionDeEntidades<Record<string, unknown>>;
+/**
+ * Las isócronas, **de mayor a menor**.
+ *
+ * El orden importa y no es estético: las bandas se solapan —la de 15 minutos
+ * contiene entera a la de 5— y en una capa de relleno se dibujan en el orden
+ * de la colección. Con la pequeña primero, la grande la tapa y el mapa
+ * enseña un solo polígono plano.
+ */
+export declare function coleccionDeIsocronas(modelo: ModeloDelMapa): ColeccionDeEntidades<Record<string, unknown>>;
+/**
+ * La caja de todo lo que hay dibujado, o de una parte.
+ *
+ * Recorre las sedes además de los negocios: una cadena con cinco locales
+ * encuadrada solo por su sede principal deja las otras cuatro fuera de
+ * pantalla, y el mapa parece correcto.
+ */
+export declare function cajaDelModelo(modelo: ModeloDelMapa, que?: "todo" | "grupos" | "negocios" | "rutas" | "zonas"): Caja | undefined;
+/** La caja de un negocio y sus sedes. Lo que se encuadra al seleccionarlo. */
+export declare function cajaDeNegocio(negocio: NegocioEnMapa): Caja | undefined;
+export {};