@cerca.red/mapa 0.2.0

package/dist/encuadre.d.ts

@@ -0,0 +1,64 @@
+import { type Caja } from "@cerca.red/geo";
+import type { DestinoDeCamara, Margenes, OpcionesDeEncuadre, VistaDelMapa } from "./puerto.ts";
+/**
+ * Cómo se encuadra algo, decidido **antes** de tocar el mapa.
+ *
+ * ## El fallo que este archivo existe para evitar
+ *
+ * `fitBounds` resuelve el zoom que hace caber una caja en la pantalla. Para
+ * una caja de **área cero** —un solo negocio, o tres sedes en la misma
+ * dirección— ese zoom es el máximo que el motor admite. El usuario aterriza
+ * encima de un tejado, sin una calle con nombre a la vista, y el mapa parece
+ * roto aunque hizo exactamente lo que se le pidió.
+ *
+ * No es un caso raro: es el caso más común de la ficha de un negocio.
+ *
+ * ## Por qué se devuelve un plan en vez de llamar al mapa
+ *
+ * Porque así se prueba sin mapa. La decisión —no moverse, volar a un punto
+ * con tope, o encuadrar una caja— es toda la lógica; ejecutarla son tres
+ * líneas. Partirlo deja la parte que se puede equivocar en Node y bajo
+ * pruebas, y la parte que necesita WebGL reducida a lo que no puede fallar.
+ */
+/**
+ * El zoom al que se aterriza cuando lo que hay que encuadrar es un punto.
+ *
+ * 16 y no 18: los archivos de país se construyen hasta z14 (ADR-024, que lo
+ * decidió midiendo contra el techo de caché del borde), así que por encima de
+ * ese nivel MapLibre sobreescala las teselas que ya tiene. Dos niveles de
+ * sobreescalado se ven bien —los rótulos y las líneas siguen nítidos porque
+ * son vectores—; cuatro se ven como un mapa borroso al que le falta detalle
+ * que no existe.
+ */
+export declare const ZOOM_DE_UN_PUNTO = 16;
+/** El margen que se deja alrededor de una caja encuadrada, si no dicen otro. */
+export declare const MARGENES_POR_DEFECTO: Margenes;
+export type PlanDeEncuadre = {
+    readonly tipo: "no-mover";
+    readonly porque: string;
+} | {
+    readonly tipo: "camara";
+    readonly destino: DestinoDeCamara;
+    readonly porque: string;
+} | {
+    readonly tipo: "caja";
+    readonly caja: Caja;
+    readonly porque: string;
+};
+/**
+ * Qué hacer para encuadrar `caja`, sabiendo dónde está la cámara.
+ *
+ * `porque` no es decoración: es lo que aparece en el mensaje de una prueba que
+ * falla y lo que permite distinguir «no se movió porque no había nada» de «no
+ * se movió y no sabemos por qué».
+ */
+export declare function planearEncuadre(caja: Caja | undefined, vistaActual: VistaDelMapa, opciones?: Pick<OpcionesDeEncuadre, "zoomMaximo">): PlanDeEncuadre;
+/**
+ * El modo de movimiento que corresponde a un plan.
+ *
+ * El vuelo de MapLibre es una curva que se aleja y se vuelve a acercar. Para
+ * cruzar la ciudad se ve bien; para ir a un punto que ya está en pantalla se
+ * ve como un tirón hacia atrás, y es exactamente lo que pasa al tocar un
+ * resultado de la lista con el mapa ya centrado en él.
+ */
+export declare function modoParaPlan(plan: PlanDeEncuadre): "vuelo" | "suave" | "salto";

package/dist/encuadre.js

@@ -0,0 +1,83 @@
+import { centroDeCaja, esCajaDegenerada } from "@cerca.red/geo";
+/**
+ * Cómo se encuadra algo, decidido **antes** de tocar el mapa.
+ *
+ * ## El fallo que este archivo existe para evitar
+ *
+ * `fitBounds` resuelve el zoom que hace caber una caja en la pantalla. Para
+ * una caja de **área cero** —un solo negocio, o tres sedes en la misma
+ * dirección— ese zoom es el máximo que el motor admite. El usuario aterriza
+ * encima de un tejado, sin una calle con nombre a la vista, y el mapa parece
+ * roto aunque hizo exactamente lo que se le pidió.
+ *
+ * No es un caso raro: es el caso más común de la ficha de un negocio.
+ *
+ * ## Por qué se devuelve un plan en vez de llamar al mapa
+ *
+ * Porque así se prueba sin mapa. La decisión —no moverse, volar a un punto
+ * con tope, o encuadrar una caja— es toda la lógica; ejecutarla son tres
+ * líneas. Partirlo deja la parte que se puede equivocar en Node y bajo
+ * pruebas, y la parte que necesita WebGL reducida a lo que no puede fallar.
+ */
+/**
+ * El zoom al que se aterriza cuando lo que hay que encuadrar es un punto.
+ *
+ * 16 y no 18: los archivos de país se construyen hasta z14 (ADR-024, que lo
+ * decidió midiendo contra el techo de caché del borde), así que por encima de
+ * ese nivel MapLibre sobreescala las teselas que ya tiene. Dos niveles de
+ * sobreescalado se ven bien —los rótulos y las líneas siguen nítidos porque
+ * son vectores—; cuatro se ven como un mapa borroso al que le falta detalle
+ * que no existe.
+ */
+export const ZOOM_DE_UN_PUNTO = 16;
+/** El margen que se deja alrededor de una caja encuadrada, si no dicen otro. */
+export const MARGENES_POR_DEFECTO = {
+    arriba: 48,
+    derecha: 48,
+    abajo: 48,
+    izquierda: 48,
+};
+/**
+ * Qué hacer para encuadrar `caja`, sabiendo dónde está la cámara.
+ *
+ * `porque` no es decoración: es lo que aparece en el mensaje de una prueba que
+ * falla y lo que permite distinguir «no se movió porque no había nada» de «no
+ * se movió y no sabemos por qué».
+ */
+export function planearEncuadre(caja, vistaActual, opciones = {}) {
+    if (caja === undefined) {
+        return {
+            tipo: "no-mover",
+            porque: "no hay nada que encuadrar",
+        };
+    }
+    const zoomMaximo = opciones.zoomMaximo ?? ZOOM_DE_UN_PUNTO;
+    if (esCajaDegenerada(caja)) {
+        // El punto entero de este archivo. Se va al centro con un zoom con tope,
+        // y **sin alejarse**: si la cámara ya estaba más cerca que el tope
+        // —porque el usuario había hecho zoom a mano— acercarse menos sería
+        // deshacerle el gesto.
+        return {
+            tipo: "camara",
+            destino: {
+                centro: centroDeCaja(caja),
+                zoom: Math.max(vistaActual.zoom, zoomMaximo),
+            },
+            porque: "la caja mide menos que una manzana: encuadrarla llevaría al zoom " +
+                "máximo, encima del tejado",
+        };
+    }
+    return { tipo: "caja", caja, porque: "hay una caja con área que encuadrar" };
+}
+/**
+ * El modo de movimiento que corresponde a un plan.
+ *
+ * El vuelo de MapLibre es una curva que se aleja y se vuelve a acercar. Para
+ * cruzar la ciudad se ve bien; para ir a un punto que ya está en pantalla se
+ * ve como un tirón hacia atrás, y es exactamente lo que pasa al tocar un
+ * resultado de la lista con el mapa ya centrado en él.
+ */
+export function modoParaPlan(plan) {
+    return plan.tipo === "camara" ? "suave" : "vuelo";
+}
+//# sourceMappingURL=encuadre.js.map

package/dist/encuadre.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encuadre.js","sourceRoot":"","sources":["../src/encuadre.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAS3E;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAEnC,gFAAgF;AAChF,MAAM,CAAC,MAAM,oBAAoB,GAAa;IAC5C,MAAM,EAAE,EAAE;IACV,OAAO,EAAE,EAAE;IACX,KAAK,EAAE,EAAE;IACT,SAAS,EAAE,EAAE;CACd,CAAC;AAeF;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAC7B,IAAsB,EACtB,WAAyB,EACzB,WAAmD,EAAE;IAErD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,OAAO;YACL,IAAI,EAAE,UAAU;YAChB,MAAM,EAAE,2BAA2B;SACpC,CAAC;IACJ,CAAC;IAED,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,IAAI,gBAAgB,CAAC;IAE3D,IAAI,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3B,yEAAyE;QACzE,mEAAmE;QACnE,oEAAoE;QACpE,uBAAuB;QACvB,OAAO;YACL,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE;gBACP,MAAM,EAAE,YAAY,CAAC,IAAI,CAAC;gBAC1B,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,UAAU,CAAC;aAC7C;YACD,MAAM,EACJ,mEAAmE;gBACnE,2BAA2B;SAC9B,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,qCAAqC,EAAE,CAAC;AAC/E,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAC1B,IAAoB;IAEpB,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC;AACpD,CAAC","sourcesContent":["import { type Caja, centroDeCaja, esCajaDegenerada } from \"@cerca.red/geo\";\n\nimport type {\n  DestinoDeCamara,\n  Margenes,\n  OpcionesDeEncuadre,\n  VistaDelMapa,\n} from \"./puerto.ts\";\n\n/**\n * Cómo se encuadra algo, decidido **antes** de tocar el mapa.\n *\n * ## El fallo que este archivo existe para evitar\n *\n * `fitBounds` resuelve el zoom que hace caber una caja en la pantalla. Para\n * una caja de **área cero** —un solo negocio, o tres sedes en la misma\n * dirección— ese zoom es el máximo que el motor admite. El usuario aterriza\n * encima de un tejado, sin una calle con nombre a la vista, y el mapa parece\n * roto aunque hizo exactamente lo que se le pidió.\n *\n * No es un caso raro: es el caso más común de la ficha de un negocio.\n *\n * ## Por qué se devuelve un plan en vez de llamar al mapa\n *\n * Porque así se prueba sin mapa. La decisión —no moverse, volar a un punto\n * con tope, o encuadrar una caja— es toda la lógica; ejecutarla son tres\n * líneas. Partirlo deja la parte que se puede equivocar en Node y bajo\n * pruebas, y la parte que necesita WebGL reducida a lo que no puede fallar.\n */\n\n/**\n * El zoom al que se aterriza cuando lo que hay que encuadrar es un punto.\n *\n * 16 y no 18: los archivos de país se construyen hasta z14 (ADR-024, que lo\n * decidió midiendo contra el techo de caché del borde), así que por encima de\n * ese nivel MapLibre sobreescala las teselas que ya tiene. Dos niveles de\n * sobreescalado se ven bien —los rótulos y las líneas siguen nítidos porque\n * son vectores—; cuatro se ven como un mapa borroso al que le falta detalle\n * que no existe.\n */\nexport const ZOOM_DE_UN_PUNTO = 16;\n\n/** El margen que se deja alrededor de una caja encuadrada, si no dicen otro. */\nexport const MARGENES_POR_DEFECTO: Margenes = {\n  arriba: 48,\n  derecha: 48,\n  abajo: 48,\n  izquierda: 48,\n};\n\nexport type PlanDeEncuadre =\n  | { readonly tipo: \"no-mover\"; readonly porque: string }\n  | {\n      readonly tipo: \"camara\";\n      readonly destino: DestinoDeCamara;\n      readonly porque: string;\n    }\n  | {\n      readonly tipo: \"caja\";\n      readonly caja: Caja;\n      readonly porque: string;\n    };\n\n/**\n * Qué hacer para encuadrar `caja`, sabiendo dónde está la cámara.\n *\n * `porque` no es decoración: es lo que aparece en el mensaje de una prueba que\n * falla y lo que permite distinguir «no se movió porque no había nada» de «no\n * se movió y no sabemos por qué».\n */\nexport function planearEncuadre(\n  caja: Caja | undefined,\n  vistaActual: VistaDelMapa,\n  opciones: Pick<OpcionesDeEncuadre, \"zoomMaximo\"> = {},\n): PlanDeEncuadre {\n  if (caja === undefined) {\n    return {\n      tipo: \"no-mover\",\n      porque: \"no hay nada que encuadrar\",\n    };\n  }\n\n  const zoomMaximo = opciones.zoomMaximo ?? ZOOM_DE_UN_PUNTO;\n\n  if (esCajaDegenerada(caja)) {\n    // El punto entero de este archivo. Se va al centro con un zoom con tope,\n    // y **sin alejarse**: si la cámara ya estaba más cerca que el tope\n    // —porque el usuario había hecho zoom a mano— acercarse menos sería\n    // deshacerle el gesto.\n    return {\n      tipo: \"camara\",\n      destino: {\n        centro: centroDeCaja(caja),\n        zoom: Math.max(vistaActual.zoom, zoomMaximo),\n      },\n      porque:\n        \"la caja mide menos que una manzana: encuadrarla llevaría al zoom \" +\n        \"máximo, encima del tejado\",\n    };\n  }\n\n  return { tipo: \"caja\", caja, porque: \"hay una caja con área que encuadrar\" };\n}\n\n/**\n * El modo de movimiento que corresponde a un plan.\n *\n * El vuelo de MapLibre es una curva que se aleja y se vuelve a acercar. Para\n * cruzar la ciudad se ve bien; para ir a un punto que ya está en pantalla se\n * ve como un tirón hacia atrás, y es exactamente lo que pasa al tocar un\n * resultado de la lista con el mapa ya centrado en él.\n */\nexport function modoParaPlan(\n  plan: PlanDeEncuadre,\n): \"vuelo\" | \"suave\" | \"salto\" {\n  return plan.tipo === \"camara\" ? \"suave\" : \"vuelo\";\n}\n"]}

package/dist/estilo.d.ts

@@ -0,0 +1,88 @@
+/**
+ * La forma de un estilo de MapLibre, declarada aquí en vez de importada.
+ *
+ * ## Por qué no se importa de `maplibre-gl`
+ *
+ * Porque este archivo lo lee el núcleo del SDK, que corre en Node y dentro de
+ * workerd, y `maplibre-gl` toca `window` al importarse. Importar «solo el
+ * tipo» tampoco vale: un `import type` desaparece al compilar, pero mete el
+ * paquete en las dependencias de un módulo que tiene que poder instalarse sin
+ * un navegador, y basta con que alguien quite el `type` un día para que el
+ * punto de entrada por defecto arrastre 250 KB al bundle del servidor.
+ *
+ * Lo que hay aquí es la parte de la especificación 8 que este SDK escribe: lo
+ * suficiente para construir capas y fuentes con el editor ayudando, y no la
+ * especificación entera. `[clave: string]: unknown` deja pasar lo demás, que
+ * es lo que hace que un estilo real de `@cerca.red/mapa-estilos` encaje sin
+ * conversión.
+ *
+ * Y esto es exactamente lo que ADR-027 llama «el puerto»: la lista escrita de
+ * lo que hay que revisar el día que salga MapLibre 7.
+ */
+/** Los tipos de capa que este SDK dibuja. No es la lista completa de la especificación. */
+export type TipoDeCapa = "background" | "fill" | "line" | "symbol" | "circle" | "raster" | (string & {});
+/**
+ * Una expresión de la especificación de estilos: `["get", "nombre"]`,
+ * `["case", …]`, un número, un color.
+ *
+ * Se deja abierta a propósito. Tipar las expresiones de MapLibre de verdad
+ * cuesta cientos de líneas de tipos recursivos que el compilador tarda en
+ * resolver, y lo que se gana es atrapar errores que el propio MapLibre ya
+ * reporta en carga con un mensaje mejor.
+ */
+export type Expresion = unknown;
+export interface CapaDelEstilo {
+    readonly id: string;
+    readonly type: TipoDeCapa;
+    readonly source?: string;
+    readonly "source-layer"?: string;
+    readonly filter?: Expresion;
+    readonly minzoom?: number;
+    readonly maxzoom?: number;
+    readonly layout?: Readonly<Record<string, Expresion>>;
+    readonly paint?: Readonly<Record<string, Expresion>>;
+    readonly metadata?: unknown;
+}
+export interface EspecificacionDeEstilo {
+    readonly version: 8;
+    readonly name?: string;
+    readonly sources: Readonly<Record<string, unknown>>;
+    readonly layers: readonly CapaDelEstilo[];
+    readonly sprite?: string | readonly unknown[];
+    readonly glyphs?: string;
+    readonly [clave: string]: unknown;
+}
+/** Los dos temas que el mapa sabe pintar. */
+export type Tema = "claro" | "oscuro";
+/**
+ * Lo que el SDK le pide a quien sepa construir un estilo.
+ *
+ * Es una **función pura**: mismas opciones, mismo documento. Eso es lo que
+ * permite regenerar el estilo entero al cambiar de tema —que es como se cambia
+ * el tema en MapLibre— sin que el SDK tenga que saber una sola cosa sobre
+ * colores.
+ *
+ * La URL de teselas llega ya compuesta desde el manifiesto (ADR-024): quien
+ * implemente esto no la construye, la recibe.
+ *
+ * **No lleva la atribución, y esa ausencia es deliberada.** El texto de
+ * OpenStreetMap viaja dentro del `.pmtiles`, en sus metadatos, y
+ * `new Protocol({ metadata: true })` lo publica solo — por eso esa petición
+ * extra no es opcional. Ofrecer aquí un canal para pasarla sería ofrecer un
+ * canal para duplicarla, y un texto legal duplicado es como una superficie
+ * termina sirviendo un mapa sin él. Si un archivo llegara sin ese metadato,
+ * eso es un defecto del archivo, no algo que el estilo deba tapar.
+ *
+ * Sobre `tema`: el SDK sabe pintar lo suyo —alfileres, rutas, zonas— en claro
+ * y en oscuro. Que el **mapa base** también cambie depende de que la fábrica
+ * sepa hacerlo; si no lo sabe, cambiarán los colores de Cerca sobre un mapa
+ * base que se queda igual. Quien implemente esto y solo tenga un tema, que
+ * estreche con su propia guarda de tipos, como se hace con el idioma.
+ */
+export interface FabricaDeEstilo {
+    (opciones: {
+        readonly urlDeTeselas: string;
+        readonly tema: Tema;
+        readonly idioma: string;
+    }): EspecificacionDeEstilo;
+}

package/dist/estilo.js

@@ -0,0 +1,23 @@
+/**
+ * La forma de un estilo de MapLibre, declarada aquí en vez de importada.
+ *
+ * ## Por qué no se importa de `maplibre-gl`
+ *
+ * Porque este archivo lo lee el núcleo del SDK, que corre en Node y dentro de
+ * workerd, y `maplibre-gl` toca `window` al importarse. Importar «solo el
+ * tipo» tampoco vale: un `import type` desaparece al compilar, pero mete el
+ * paquete en las dependencias de un módulo que tiene que poder instalarse sin
+ * un navegador, y basta con que alguien quite el `type` un día para que el
+ * punto de entrada por defecto arrastre 250 KB al bundle del servidor.
+ *
+ * Lo que hay aquí es la parte de la especificación 8 que este SDK escribe: lo
+ * suficiente para construir capas y fuentes con el editor ayudando, y no la
+ * especificación entera. `[clave: string]: unknown` deja pasar lo demás, que
+ * es lo que hace que un estilo real de `@cerca.red/mapa-estilos` encaje sin
+ * conversión.
+ *
+ * Y esto es exactamente lo que ADR-027 llama «el puerto»: la lista escrita de
+ * lo que hay que revisar el día que salga MapLibre 7.
+ */
+export {};
+//# sourceMappingURL=estilo.js.map

package/dist/estilo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"estilo.js","sourceRoot":"","sources":["../src/estilo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG","sourcesContent":["/**\n * La forma de un estilo de MapLibre, declarada aquí en vez de importada.\n *\n * ## Por qué no se importa de `maplibre-gl`\n *\n * Porque este archivo lo lee el núcleo del SDK, que corre en Node y dentro de\n * workerd, y `maplibre-gl` toca `window` al importarse. Importar «solo el\n * tipo» tampoco vale: un `import type` desaparece al compilar, pero mete el\n * paquete en las dependencias de un módulo que tiene que poder instalarse sin\n * un navegador, y basta con que alguien quite el `type` un día para que el\n * punto de entrada por defecto arrastre 250 KB al bundle del servidor.\n *\n * Lo que hay aquí es la parte de la especificación 8 que este SDK escribe: lo\n * suficiente para construir capas y fuentes con el editor ayudando, y no la\n * especificación entera. `[clave: string]: unknown` deja pasar lo demás, que\n * es lo que hace que un estilo real de `@cerca.red/mapa-estilos` encaje sin\n * conversión.\n *\n * Y esto es exactamente lo que ADR-027 llama «el puerto»: la lista escrita de\n * lo que hay que revisar el día que salga MapLibre 7.\n */\n\n/** Los tipos de capa que este SDK dibuja. No es la lista completa de la especificación. */\nexport type TipoDeCapa =\n  | \"background\"\n  | \"fill\"\n  | \"line\"\n  | \"symbol\"\n  | \"circle\"\n  | \"raster\"\n  // Cualquier otro tipo que traiga un estilo construido por otro —el sabor de\n  // Protomaps trae `hillshade` y `color-relief`, y MapLibre añade tipos en\n  // cada versión menor—. Enumerarlos todos convertiría este tipo en una lista\n  // que envejece con el upstream y que, al quedarse corta, obligaría a forzar\n  // el estilo entero con un `as`: ahí se pierde la comprobación de todo lo\n  // demás, que es lo que sí importa. Los seis de arriba son los que este SDK\n  // **escribe**, y siguen apareciendo en el autocompletado.\n  | (string & {});\n\n/**\n * Una expresión de la especificación de estilos: `[\"get\", \"nombre\"]`,\n * `[\"case\", …]`, un número, un color.\n *\n * Se deja abierta a propósito. Tipar las expresiones de MapLibre de verdad\n * cuesta cientos de líneas de tipos recursivos que el compilador tarda en\n * resolver, y lo que se gana es atrapar errores que el propio MapLibre ya\n * reporta en carga con un mensaje mejor.\n */\nexport type Expresion = unknown;\n\nexport interface CapaDelEstilo {\n  readonly id: string;\n  readonly type: TipoDeCapa;\n  readonly source?: string;\n  readonly \"source-layer\"?: string;\n  readonly filter?: Expresion;\n  readonly minzoom?: number;\n  readonly maxzoom?: number;\n  readonly layout?: Readonly<Record<string, Expresion>>;\n  readonly paint?: Readonly<Record<string, Expresion>>;\n  // `unknown` y no un objeto: la especificación no dice nada sobre lo que\n  // cabe aquí, y tiparlo más estrecho hace que un estilo válido de terceros\n  // deje de encajar.\n  readonly metadata?: unknown;\n}\n\nexport interface EspecificacionDeEstilo {\n  readonly version: 8;\n  readonly name?: string;\n  readonly sources: Readonly<Record<string, unknown>>;\n  readonly layers: readonly CapaDelEstilo[];\n  readonly sprite?: string | readonly unknown[];\n  readonly glyphs?: string;\n  readonly [clave: string]: unknown;\n}\n\n/** Los dos temas que el mapa sabe pintar. */\nexport type Tema = \"claro\" | \"oscuro\";\n\n/**\n * Lo que el SDK le pide a quien sepa construir un estilo.\n *\n * Es una **función pura**: mismas opciones, mismo documento. Eso es lo que\n * permite regenerar el estilo entero al cambiar de tema —que es como se cambia\n * el tema en MapLibre— sin que el SDK tenga que saber una sola cosa sobre\n * colores.\n *\n * La URL de teselas llega ya compuesta desde el manifiesto (ADR-024): quien\n * implemente esto no la construye, la recibe.\n *\n * **No lleva la atribución, y esa ausencia es deliberada.** El texto de\n * OpenStreetMap viaja dentro del `.pmtiles`, en sus metadatos, y\n * `new Protocol({ metadata: true })` lo publica solo — por eso esa petición\n * extra no es opcional. Ofrecer aquí un canal para pasarla sería ofrecer un\n * canal para duplicarla, y un texto legal duplicado es como una superficie\n * termina sirviendo un mapa sin él. Si un archivo llegara sin ese metadato,\n * eso es un defecto del archivo, no algo que el estilo deba tapar.\n *\n * Sobre `tema`: el SDK sabe pintar lo suyo —alfileres, rutas, zonas— en claro\n * y en oscuro. Que el **mapa base** también cambie depende de que la fábrica\n * sepa hacerlo; si no lo sabe, cambiarán los colores de Cerca sobre un mapa\n * base que se queda igual. Quien implemente esto y solo tenga un tema, que\n * estreche con su propia guarda de tipos, como se hace con el idioma.\n */\nexport interface FabricaDeEstilo {\n  (opciones: {\n    readonly urlDeTeselas: string;\n    readonly tema: Tema;\n    readonly idioma: string;\n  }): EspecificacionDeEstilo;\n}\n"]}

package/dist/eventos.d.ts

@@ -0,0 +1,127 @@
+import type { Caja, Coordenada } from "@cerca.red/geo";
+import type { Desuscribir, OrigenDeMovimiento, PuntoEnPantalla, VistaDelMapa } from "./puerto.ts";
+/**
+ * Los eventos que emite el SDK, y el emisor que los reparte.
+ *
+ * ## Las dos decisiones que hay aquí, y que no son de estilo
+ *
+ * **Los eventos de cámara llevan quién los causó.** Es lo que rompe el bucle
+ * lista↔mapa. Una pantalla de resultados escucha `mapa:movimiento` para
+ * recargar; si el evento no dijera el origen, recargaría también cuando el
+ * movimiento lo hizo ella misma al encuadrar lo que el usuario tocó en la
+ * lista — y esa recarga mueve el mapa, que emite otro evento. El bucle no se
+ * ve como un bucle: se ve como una pantalla que parpadea y consulta de más.
+ *
+ * **Los eventos de puntero dicen si hubo un puntero.** Un canvas no es
+ * accesible por sí solo, así que el recorrido con teclado va por una lista
+ * real al lado. Quien la escucha necesita poder decidir distinto: abrir una
+ * tarjeta flotante bajo el dedo tiene sentido con un dedo, y no lo tiene con
+ * la tecla Tab.
+ */
+export interface EventoDeMapaListo {
+    readonly vista: VistaDelMapa;
+}
+export interface EventoDeCamaraPublico {
+    readonly vista: VistaDelMapa;
+    readonly origen: OrigenDeMovimiento;
+}
+export interface EventoDeClicEnMapa {
+    readonly coordenada: Coordenada;
+    readonly punto: PuntoEnPantalla;
+    readonly desdePuntero: boolean;
+}
+export interface EventoDeNegocio {
+    readonly id: string;
+    readonly ubicacion: Coordenada;
+    readonly desdePuntero: boolean;
+}
+export interface EventoDeSede {
+    readonly id: string;
+    readonly negocio: string;
+    readonly ubicacion: Coordenada;
+    readonly desdePuntero: boolean;
+}
+/**
+ * Se tocó un grupo.
+ *
+ * Lleva la cantidad porque quien escucha suele querer decidir: expandir el
+ * grupo acercando la cámara, o abrir una lista con los que hay dentro. El SDK
+ * ya acerca la cámara por su cuenta; el evento existe para que la superficie
+ * pueda hacer además lo suyo.
+ */
+interface EventoDeGrupoBase {
+    readonly id: string;
+    readonly cantidad: number;
+    readonly ubicacion: Coordenada;
+    readonly desdePuntero: boolean;
+}
+/** Un grupo calculado por MapLibre o entregado ya agregado por el servidor. */
+export type EventoDeGrupo = (EventoDeGrupoBase & {
+    readonly origen: "local";
+    readonly caja?: undefined;
+}) | (EventoDeGrupoBase & {
+    readonly origen: "servidor";
+    readonly caja: Caja;
+});
+export interface EventoDeRuta {
+    readonly id: string;
+    readonly desdePuntero: boolean;
+}
+export interface EventoDeVehiculo {
+    readonly id: string;
+    readonly ubicacion: Coordenada;
+    readonly desdePuntero: boolean;
+}
+/** El puntero entró o salió de un negocio. `id` es `undefined` al salir. */
+export interface EventoDeNegocioEncima {
+    readonly id: string | undefined;
+}
+/** La ubicación del usuario que el SDK tiene puesta cambió. `undefined` si se quitó. */
+export interface EventoDeUbicacion {
+    readonly ubicacion: Coordenada | undefined;
+}
+export interface EventoDeError {
+    readonly error: Error;
+}
+/** El catálogo completo de eventos del SDK. */
+export interface EventosDelMapa {
+    readonly "mapa:listo": EventoDeMapaListo;
+    readonly "mapa:clic": EventoDeClicEnMapa;
+    readonly "mapa:movimiento": EventoDeCamaraPublico;
+    readonly "mapa:zoom": EventoDeCamaraPublico;
+    readonly "mapa:error": EventoDeError;
+    readonly "negocio:clic": EventoDeNegocio;
+    readonly "negocio:encima": EventoDeNegocioEncima;
+    readonly "sede:clic": EventoDeSede;
+    readonly "grupo:clic": EventoDeGrupo;
+    readonly "ruta:eleccion": EventoDeRuta;
+    readonly "vehiculo:clic": EventoDeVehiculo;
+    readonly "ubicacion:cambio": EventoDeUbicacion;
+}
+export type TipoDeEvento = keyof EventosDelMapa;
+type Manejador<T extends TipoDeEvento> = (evento: EventosDelMapa[T]) => void;
+/**
+ * Un emisor pequeño, con dos propiedades que sí importan.
+ *
+ * **Un manejador que lanza no se lleva a los demás por delante.** Si el
+ * tercero de cinco oyentes de `negocio:clic` revienta, los otros cuatro
+ * tienen que recibir el evento igual: son componentes distintos de la
+ * pantalla y uno roto no debe apagar el resto. El error sale por
+ * `mapa:error`, que es donde se puede ver.
+ *
+ * **Se recorre una copia de la lista.** Un manejador que se da de baja a sí
+ * mismo dentro del propio evento —lo que hace `unaVez`— modificaría el
+ * conjunto que se está recorriendo, y eso salta oyentes en silencio.
+ */
+export declare class EmisorDeEventos {
+    #private;
+    /** Dónde van los errores que lanzan los manejadores. */
+    alFallar(manejador: (error: Error, tipo: TipoDeEvento) => void): void;
+    cuando<T extends TipoDeEvento>(tipo: T, manejador: Manejador<T>): Desuscribir;
+    unaVez<T extends TipoDeEvento>(tipo: T, manejador: Manejador<T>): Desuscribir;
+    emitir<T extends TipoDeEvento>(tipo: T, evento: EventosDelMapa[T]): void;
+    /** Cuántos oyentes hay de un tipo. Existe para que `destruir` se pueda comprobar. */
+    cuantosOyentes(tipo?: TipoDeEvento): number;
+    quitarTodos(): void;
+}
+export {};

package/dist/eventos.js

@@ -0,0 +1,69 @@
+/**
+ * Un emisor pequeño, con dos propiedades que sí importan.
+ *
+ * **Un manejador que lanza no se lleva a los demás por delante.** Si el
+ * tercero de cinco oyentes de `negocio:clic` revienta, los otros cuatro
+ * tienen que recibir el evento igual: son componentes distintos de la
+ * pantalla y uno roto no debe apagar el resto. El error sale por
+ * `mapa:error`, que es donde se puede ver.
+ *
+ * **Se recorre una copia de la lista.** Un manejador que se da de baja a sí
+ * mismo dentro del propio evento —lo que hace `unaVez`— modificaría el
+ * conjunto que se está recorriendo, y eso salta oyentes en silencio.
+ */
+export class EmisorDeEventos {
+    #oyentes = new Map();
+    #alFallarUnManejador;
+    /** Dónde van los errores que lanzan los manejadores. */
+    alFallar(manejador) {
+        this.#alFallarUnManejador = manejador;
+    }
+    cuando(tipo, manejador) {
+        const existentes = this.#oyentes.get(tipo) ?? new Set();
+        existentes.add(manejador);
+        this.#oyentes.set(tipo, existentes);
+        return () => {
+            existentes.delete(manejador);
+        };
+    }
+    unaVez(tipo, manejador) {
+        const quitar = this.cuando(tipo, ((evento) => {
+            quitar();
+            manejador(evento);
+        }));
+        return quitar;
+    }
+    emitir(tipo, evento) {
+        const oyentes = this.#oyentes.get(tipo);
+        if (oyentes === undefined || oyentes.size === 0)
+            return;
+        for (const manejador of [...oyentes]) {
+            try {
+                manejador(evento);
+            }
+            catch (fallo) {
+                const error = fallo instanceof Error ? fallo : new Error(String(fallo));
+                // Un manejador de `mapa:error` que lanza no puede reentrar en el
+                // propio `mapa:error`: eso es una recursión infinita disfrazada de
+                // manejo de errores.
+                if (tipo === "mapa:error")
+                    continue;
+                this.#alFallarUnManejador?.(error, tipo);
+            }
+        }
+    }
+    /** Cuántos oyentes hay de un tipo. Existe para que `destruir` se pueda comprobar. */
+    cuantosOyentes(tipo) {
+        if (tipo !== undefined)
+            return this.#oyentes.get(tipo)?.size ?? 0;
+        let total = 0;
+        for (const oyentes of this.#oyentes.values())
+            total += oyentes.size;
+        return total;
+    }
+    quitarTodos() {
+        this.#oyentes.clear();
+        this.#alFallarUnManejador = undefined;
+    }
+}
+//# sourceMappingURL=eventos.js.map

package/dist/eventos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventos.js","sourceRoot":"","sources":["../src/eventos.ts"],"names":[],"mappings":"AA+HA;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,eAAe;IACjB,QAAQ,GAAG,IAAI,GAAG,EAA8C,CAAC;IAC1E,oBAAoB,CACuC;IAE3D,wDAAwD;IACxD,QAAQ,CAAC,SAAqD;QAC5D,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAC;IACxC,CAAC;IAED,MAAM,CACJ,IAAO,EACP,SAAuB;QAEvB,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,EAAE,CAAC;QACxD,UAAU,CAAC,GAAG,CAAC,SAAoC,CAAC,CAAC;QACrD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QACpC,OAAO,GAAG,EAAE;YACV,UAAU,CAAC,MAAM,CAAC,SAAoC,CAAC,CAAC;QAC1D,CAAC,CAAC;IACJ,CAAC;IAED,MAAM,CACJ,IAAO,EACP,SAAuB;QAEvB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,MAAyB,EAAE,EAAE;YAC9D,MAAM,EAAE,CAAC;YACT,SAAS,CAAC,MAAM,CAAC,CAAC;QACpB,CAAC,CAAiB,CAAC,CAAC;QACpB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,CAAyB,IAAO,EAAE,MAAyB;QAC/D,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACxC,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,CAAC;YAAE,OAAO;QAExD,KAAK,MAAM,SAAS,IAAI,CAAC,GAAG,OAAO,CAAC,EAAE,CAAC;YACrC,IAAI,CAAC;gBACF,SAA0B,CAAC,MAAM,CAAC,CAAC;YACtC,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,MAAM,KAAK,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;gBACxE,iEAAiE;gBACjE,mEAAmE;gBACnE,qBAAqB;gBACrB,IAAI,IAAI,KAAK,YAAY;oBAAE,SAAS;gBACpC,IAAI,CAAC,oBAAoB,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;YAC3C,CAAC;QACH,CAAC;IACH,CAAC;IAED,qFAAqF;IACrF,cAAc,CAAC,IAAmB;QAChC,IAAI,IAAI,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC;QAClE,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;YAAE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;QACpE,OAAO,KAAK,CAAC;IACf,CAAC;IAED,WAAW;QACT,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAC;IACxC,CAAC;CACF","sourcesContent":["import type { Caja, Coordenada } from \"@cerca.red/geo\";\n\nimport type {\n  Desuscribir,\n  OrigenDeMovimiento,\n  PuntoEnPantalla,\n  VistaDelMapa,\n} from \"./puerto.ts\";\n\n/**\n * Los eventos que emite el SDK, y el emisor que los reparte.\n *\n * ## Las dos decisiones que hay aquí, y que no son de estilo\n *\n * **Los eventos de cámara llevan quién los causó.** Es lo que rompe el bucle\n * lista↔mapa. Una pantalla de resultados escucha `mapa:movimiento` para\n * recargar; si el evento no dijera el origen, recargaría también cuando el\n * movimiento lo hizo ella misma al encuadrar lo que el usuario tocó en la\n * lista — y esa recarga mueve el mapa, que emite otro evento. El bucle no se\n * ve como un bucle: se ve como una pantalla que parpadea y consulta de más.\n *\n * **Los eventos de puntero dicen si hubo un puntero.** Un canvas no es\n * accesible por sí solo, así que el recorrido con teclado va por una lista\n * real al lado. Quien la escucha necesita poder decidir distinto: abrir una\n * tarjeta flotante bajo el dedo tiene sentido con un dedo, y no lo tiene con\n * la tecla Tab.\n */\n\nexport interface EventoDeMapaListo {\n  readonly vista: VistaDelMapa;\n}\n\nexport interface EventoDeCamaraPublico {\n  readonly vista: VistaDelMapa;\n  readonly origen: OrigenDeMovimiento;\n}\n\nexport interface EventoDeClicEnMapa {\n  readonly coordenada: Coordenada;\n  readonly punto: PuntoEnPantalla;\n  readonly desdePuntero: boolean;\n}\n\nexport interface EventoDeNegocio {\n  readonly id: string;\n  readonly ubicacion: Coordenada;\n  readonly desdePuntero: boolean;\n}\n\nexport interface EventoDeSede {\n  readonly id: string;\n  readonly negocio: string;\n  readonly ubicacion: Coordenada;\n  readonly desdePuntero: boolean;\n}\n\n/**\n * Se tocó un grupo.\n *\n * Lleva la cantidad porque quien escucha suele querer decidir: expandir el\n * grupo acercando la cámara, o abrir una lista con los que hay dentro. El SDK\n * ya acerca la cámara por su cuenta; el evento existe para que la superficie\n * pueda hacer además lo suyo.\n */\ninterface EventoDeGrupoBase {\n  readonly id: string;\n  readonly cantidad: number;\n  readonly ubicacion: Coordenada;\n  readonly desdePuntero: boolean;\n}\n\n/** Un grupo calculado por MapLibre o entregado ya agregado por el servidor. */\nexport type EventoDeGrupo =\n  | (EventoDeGrupoBase & {\n      readonly origen: \"local\";\n      readonly caja?: undefined;\n    })\n  | (EventoDeGrupoBase & {\n      readonly origen: \"servidor\";\n      readonly caja: Caja;\n    });\n\nexport interface EventoDeRuta {\n  readonly id: string;\n  readonly desdePuntero: boolean;\n}\n\nexport interface EventoDeVehiculo {\n  readonly id: string;\n  readonly ubicacion: Coordenada;\n  readonly desdePuntero: boolean;\n}\n\n/** El puntero entró o salió de un negocio. `id` es `undefined` al salir. */\nexport interface EventoDeNegocioEncima {\n  readonly id: string | undefined;\n}\n\n/** La ubicación del usuario que el SDK tiene puesta cambió. `undefined` si se quitó. */\nexport interface EventoDeUbicacion {\n  readonly ubicacion: Coordenada | undefined;\n}\n\nexport interface EventoDeError {\n  readonly error: Error;\n}\n\n/** El catálogo completo de eventos del SDK. */\nexport interface EventosDelMapa {\n  readonly \"mapa:listo\": EventoDeMapaListo;\n  readonly \"mapa:clic\": EventoDeClicEnMapa;\n  readonly \"mapa:movimiento\": EventoDeCamaraPublico;\n  readonly \"mapa:zoom\": EventoDeCamaraPublico;\n  readonly \"mapa:error\": EventoDeError;\n  readonly \"negocio:clic\": EventoDeNegocio;\n  readonly \"negocio:encima\": EventoDeNegocioEncima;\n  readonly \"sede:clic\": EventoDeSede;\n  readonly \"grupo:clic\": EventoDeGrupo;\n  readonly \"ruta:eleccion\": EventoDeRuta;\n  readonly \"vehiculo:clic\": EventoDeVehiculo;\n  readonly \"ubicacion:cambio\": EventoDeUbicacion;\n}\n\nexport type TipoDeEvento = keyof EventosDelMapa;\n\ntype Manejador<T extends TipoDeEvento> = (evento: EventosDelMapa[T]) => void;\n\n/**\n * Un emisor pequeño, con dos propiedades que sí importan.\n *\n * **Un manejador que lanza no se lleva a los demás por delante.** Si el\n * tercero de cinco oyentes de `negocio:clic` revienta, los otros cuatro\n * tienen que recibir el evento igual: son componentes distintos de la\n * pantalla y uno roto no debe apagar el resto. El error sale por\n * `mapa:error`, que es donde se puede ver.\n *\n * **Se recorre una copia de la lista.** Un manejador que se da de baja a sí\n * mismo dentro del propio evento —lo que hace `unaVez`— modificaría el\n * conjunto que se está recorriendo, y eso salta oyentes en silencio.\n */\nexport class EmisorDeEventos {\n  readonly #oyentes = new Map<TipoDeEvento, Set<Manejador<TipoDeEvento>>>();\n  #alFallarUnManejador:\n    ((error: Error, tipo: TipoDeEvento) => void) | undefined;\n\n  /** Dónde van los errores que lanzan los manejadores. */\n  alFallar(manejador: (error: Error, tipo: TipoDeEvento) => void): void {\n    this.#alFallarUnManejador = manejador;\n  }\n\n  cuando<T extends TipoDeEvento>(\n    tipo: T,\n    manejador: Manejador<T>,\n  ): Desuscribir {\n    const existentes = this.#oyentes.get(tipo) ?? new Set();\n    existentes.add(manejador as Manejador<TipoDeEvento>);\n    this.#oyentes.set(tipo, existentes);\n    return () => {\n      existentes.delete(manejador as Manejador<TipoDeEvento>);\n    };\n  }\n\n  unaVez<T extends TipoDeEvento>(\n    tipo: T,\n    manejador: Manejador<T>,\n  ): Desuscribir {\n    const quitar = this.cuando(tipo, ((evento: EventosDelMapa[T]) => {\n      quitar();\n      manejador(evento);\n    }) as Manejador<T>);\n    return quitar;\n  }\n\n  emitir<T extends TipoDeEvento>(tipo: T, evento: EventosDelMapa[T]): void {\n    const oyentes = this.#oyentes.get(tipo);\n    if (oyentes === undefined || oyentes.size === 0) return;\n\n    for (const manejador of [...oyentes]) {\n      try {\n        (manejador as Manejador<T>)(evento);\n      } catch (fallo: unknown) {\n        const error = fallo instanceof Error ? fallo : new Error(String(fallo));\n        // Un manejador de `mapa:error` que lanza no puede reentrar en el\n        // propio `mapa:error`: eso es una recursión infinita disfrazada de\n        // manejo de errores.\n        if (tipo === \"mapa:error\") continue;\n        this.#alFallarUnManejador?.(error, tipo);\n      }\n    }\n  }\n\n  /** Cuántos oyentes hay de un tipo. Existe para que `destruir` se pueda comprobar. */\n  cuantosOyentes(tipo?: TipoDeEvento): number {\n    if (tipo !== undefined) return this.#oyentes.get(tipo)?.size ?? 0;\n    let total = 0;\n    for (const oyentes of this.#oyentes.values()) total += oyentes.size;\n    return total;\n  }\n\n  quitarTodos(): void {\n    this.#oyentes.clear();\n    this.#alFallarUnManejador = undefined;\n  }\n}\n"]}

package/dist/identificadores.d.ts

@@ -0,0 +1,109 @@
+/**
+ * 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 declare const FUENTES: {
+    readonly negocios: "cerca-negocios";
+    /** Agregados entregados por el backend, nunca clusterizados por MapLibre. */
+    readonly grupos: "cerca-grupos";
+    readonly 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.
+     */
+    readonly seleccion: "cerca-seleccion";
+    /** El halo de las ubicaciones aproximadas. Área, no alfiler. */
+    readonly imprecision: "cerca-imprecision";
+    readonly ubicacion: "cerca-ubicacion";
+    readonly vehiculos: "cerca-vehiculos";
+    readonly rutas: "cerca-rutas";
+    readonly zonas: "cerca-zonas";
+    readonly isocronas: "cerca-isocronas";
+};
+/** Las capas que el SDK dibuja, de abajo hacia arriba dentro de cada anclaje. */
+export declare const CAPAS: {
+    readonly isocronas: "cerca-isocronas-relleno";
+    readonly isocronasBorde: "cerca-isocronas-borde";
+    readonly zonas: "cerca-zonas-relleno";
+    readonly zonasBorde: "cerca-zonas-borde";
+    readonly imprecision: "cerca-imprecision-relleno";
+    readonly imprecisionBorde: "cerca-imprecision-borde";
+    readonly rutasAlternativas: "cerca-rutas-alternativas";
+    readonly rutaPrincipalContorno: "cerca-ruta-principal-contorno";
+    readonly rutaPrincipal: "cerca-ruta-principal";
+    readonly ubicacionHalo: "cerca-ubicacion-halo";
+    readonly ubicacionPunto: "cerca-ubicacion-punto";
+    readonly gruposCirculo: "cerca-grupos-circulo";
+    readonly gruposCantidad: "cerca-grupos-cantidad";
+    readonly gruposToque: "cerca-grupos-toque";
+    readonly gruposServidorCirculo: "cerca-grupos-servidor-circulo";
+    readonly gruposServidorCantidad: "cerca-grupos-servidor-cantidad";
+    readonly gruposServidorToque: "cerca-grupos-servidor-toque";
+    readonly negociosPunto: "cerca-negocios-punto";
+    readonly negociosSimbolo: "cerca-negocios-simbolo";
+    readonly sedesPunto: "cerca-sedes-punto";
+    readonly vehiculos: "cerca-vehiculos-simbolo";
+    readonly seleccion: "cerca-seleccion-punto";
+    readonly 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á».
+     */
+    readonly negociosToque: "cerca-negocios-toque";
+    readonly sedesToque: "cerca-sedes-toque";
+    readonly vehiculosToque: "cerca-vehiculos-toque";
+    readonly 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 declare const ANCLAS_POR_DEFECTO: {
+    readonly areas: "cerca-ancla-areas";
+    readonly lineas: "cerca-ancla-lineas";
+    readonly puntos: "cerca-ancla-puntos";
+    readonly seleccion: "cerca-ancla-seleccion";
+};
+export type Anclas = {
+    readonly areas: string;
+    readonly lineas: string;
+    readonly puntos: string;
+    readonly seleccion: string;
+};
+/** El radio en píxeles que hace que un objetivo mida los 44 px que pide CLAUDE.md §1. */
+export declare const RADIO_TACTIL_MINIMO_EN_PX = 22;