georeference 0.0.0-stage → 1.0.0

package/docs/getting-started.fr.md

@@ -0,0 +1,79 @@
+# Prise en main
+
+[English](getting-started.md) · [Accueil](../README.fr.md)
+
+## Générer directement les fichiers
+
+Commencez par [la génération en une commande](generation.fr.md) : `npx georeference` génère les fichiers de pays sans ajouter de dépendance au projet. Le SDK est optionnel. Le guide explique aussi comment utiliser une version locale. Les sections suivantes couvrent la préparation avancée des sources, les exports et l'amorçage en base.
+
+## Construire et créer un instantané
+
+Prérequis : Node.js 24.18.x, npm et assez d'espace disque pour les instantanés/exports. PostgreSQL n'est nécessaire que pour l'amorçage d'une base PostgreSQL. SQLite utilise le module `node:sqlite` intégré à Node.
+
+```sh
+npm ci
+npm run build
+node dist/cli.js --help
+node dist/cli.js snapshot --input examples/sample.ndjson --metadata examples/metadata.json --output data/example.sqlite
+node dist/cli.js inspect --snapshot data/example.sqlite
+```
+
+Les entités fournies sont fictives. Le fichier de métadonnées contient `contractVersion`, `datasetVersion` et `sources` ; chaque source déclare `name`, `url`, `license`, `attribution` et `revision`. Les entités ont les champs stables `id`, `entityType`, `name`, `countryId` et `parentId`. Les champs facultatifs sont `codes`, les `names` localisés, le `level` administratif, les `coordinates` et la `boundary` Polygon/MultiPolygon.
+
+Un pays se référence lui-même dans `countryId` et possède `parentId: null`. Tout autre parent doit exister dans l'instantané. Les objets de coordonnées utilisent les champs nommés `longitude` et `latitude` ; les positions GeoJSON suivent `[longitude, latitude]`. La création valide le graphe et les géométries. Utilisez un nouveau chemin de sortie plutôt que d'écraser un instantané existant.
+
+## Sélectionner et exporter
+
+```sh
+node dist/cli.js export --snapshot data/example.sqlite --country XZ --types locality --coordinates --format ndjson --compression gzip --output exports/localities
+node dist/cli.js verify --package exports/localities
+node dist/cli.js export --snapshot data/example.sqlite --subdivision example:region --format json --layout hierarchical --output exports/region-tree
+node dist/cli.js export --snapshot data/example.sqlite --format geojson --coordinates --boundaries --output exports/map-layers
+```
+
+Les filtres de pays acceptent les IDs stables ou les codes pays. Plusieurs IDs/types se séparent par des virgules. Le filtre de subdivision inclut ses descendants administratifs ; il n'effectue pas d'intersection spatiale. Les ancêtres nécessaires sont ajoutés par défaut et signalés comme contexte. `--no-ancestors` rend explicites les références externes à la sélection ; un importeur doit les résoudre en cible.
+
+Coordonnées et frontières sont exclues tant qu'elles ne sont pas demandées. Une géométrie absente reste absente ; le manifeste indique la couverture. La combinaison format/organisation doit être prise en charge ; consulter [les formats](formats.fr.md).
+
+Les paquets contiennent `manifest.json` et les fichiers de données. La vérification contrôle leur intégrité. Conservez le manifeste avec les fichiers partagés. Gzip compresse chaque fichier dans le répertoire ; le lecteur le décompresse. Avec ZIP, la sortie contient un manifeste externe et `package.zip` ; l'archive contient les fichiers et un manifeste interne. Vérifiez le répertoire initial pour l'intégrité de l'archive, puis extrayez `package.zip` dans un **nouveau répertoire** et vérifiez/importez ce répertoire extrait. La compression constitue un transport, pas un nouveau contrat de données.
+
+## Utiliser des fichiers GeoNames réels
+
+Téléchargez les fichiers souhaités depuis [les exports GeoNames](https://download.geonames.org/export/dump/), conservez leur licence et extrayez vous-même les archives ZIP. Importez ensuite les fichiers texte locaux :
+
+```sh
+node dist/cli.js geonames --countries data/countryInfo.txt --admin1 data/admin1CodesASCII.txt --admin2 data/admin2Codes.txt --places data/cities1000.txt --version geonames-2026-11-11 --output data/geonames.sqlite
+```
+
+Seuls `--countries`, `--version` et `--output` sont obligatoires. L'importeur ne télécharge rien sur le réseau. Il accepte les lieux habités GeoNames, et non toutes les classes de points géographiques. Chaque fichier reçoit une révision de provenance SHA-256. Voir [la couverture et les limites](data-sources.fr.md).
+
+## Amorcer PostgreSQL
+
+Exportez du JSON, NDJSON ou CSV normalisé, puis examinez l'aperçu avant l'application :
+
+```sh
+node dist/cli.js export --snapshot data/example.sqlite --format ndjson --coordinates --output exports/seed
+node dist/cli.js seed --package exports/seed --create-schema
+node dist/cli.js seed --package exports/seed --create-schema --apply
+```
+
+Définissez `DATABASE_URL` dans votre terminal ou gestionnaire de secrets avant ces commandes. N'enregistrez pas les identifiants de connexion dans des fichiers suivis ou dans les paquets exportés. Les commandes ci-dessus ciblent le schéma standard ; les tables applicatives existantes nécessitent un mapping explicite. Voir [l'amorçage](seeding.fr.md) pour l'ordre des révisions, les champs gérés et la reprise.
+
+## SDK optionnel
+
+Seules les applications qui souhaitent consulter un instantané via l'API locale doivent installer la bibliothèque avec `npm install georeference`. Vous pouvez aussi construire et installer une archive locale avec `npm pack` puis `npm install /chemin/vers/georeference-1.0.0.tgz`. La génération de fichiers n'en a pas besoin.
+
+```ts
+import { Snapshot, createClient } from 'georeference';
+
+const snapshot = Snapshot.open('data/example.sqlite');
+try {
+  const client = createClient(snapshot);
+  console.log(client.getEntity('example:locality'));
+  console.log(client.getCountry('example:country'));
+} finally {
+  snapshot.close();
+}
+```
+
+Le SDK lit l'instantané local ; il ne synchronise pas une base applicative. Gardez l'instantané ouvert pendant les itérations et fermez-le après usage. Installez le paquet compilé avec `npm install georeference`, ou construisez/installez-le depuis ce dépôt.

package/docs/getting-started.md

@@ -0,0 +1,79 @@
+# Getting started
+
+[Français](getting-started.fr.md) · [Home](../README.md)
+
+## Generate files directly
+
+Start with [one-shot generation](generation.md): `npx georeference` generates country files without adding a dependency to your project. The SDK is optional. The guide also explains how to run a local build. The following sections cover advanced source preparation, exports and database seeding.
+
+## Build and create a snapshot
+
+Requirements: Node.js 24.18.x, npm, and disk space for snapshots/exports. PostgreSQL is needed only for seeding into PostgreSQL. SQLite support comes from Node's built-in `node:sqlite` module.
+
+```sh
+npm ci
+npm run build
+node dist/cli.js --help
+node dist/cli.js snapshot --input examples/sample.ndjson --metadata examples/metadata.json --output data/example.sqlite
+node dist/cli.js inspect --snapshot data/example.sqlite
+```
+
+The included entities are fictional. The metadata file specifies `contractVersion`, `datasetVersion`, and `sources`; each source declares `name`, `url`, `license`, `attribution`, and `revision`. Input entities have stable `id`, `entityType`, `name`, `countryId`, and `parentId`. Optional fields are `codes`, localized `names`, administrative `level`, `coordinates`, and Polygon/MultiPolygon `boundary`.
+
+Countries refer to themselves through `countryId` and have `parentId: null`. Every other parent must exist in the snapshot. Coordinate objects use named `longitude` and `latitude`; GeoJSON positions use `[longitude, latitude]`. Creating a snapshot validates the graph and geometry. Supply a new output path rather than overwriting an existing snapshot.
+
+## Select and export
+
+```sh
+node dist/cli.js export --snapshot data/example.sqlite --country XZ --types locality --coordinates --format ndjson --compression gzip --output exports/localities
+node dist/cli.js verify --package exports/localities
+node dist/cli.js export --snapshot data/example.sqlite --subdivision example:region --format json --layout hierarchical --output exports/region-tree
+node dist/cli.js export --snapshot data/example.sqlite --format geojson --coordinates --boundaries --output exports/map-layers
+```
+
+Country filters accept stable IDs or country codes. Multiple IDs/types use comma-separated values. Subdivision filters include descendants by administrative membership; they do not perform spatial intersection. Required ancestors are added by default and reported as context. `--no-ancestors` makes references outside the selection explicit; an importer must resolve them in the target.
+
+Coordinates and boundaries are excluded unless requested. Missing geometry stays missing; the manifest reports coverage. A requested format/layout combination must be supported; consult [formats](formats.md).
+
+Export packages contain `manifest.json` and data files. Verification checks file integrity. Preserve the manifest when sharing files. Gzip compresses each payload inside the directory; the package reader decompresses it. With ZIP, the output directory contains an outer manifest and `package.zip`; the archive contains the payload files and an inner manifest. Verify the original directory for archive integrity, then extract `package.zip` to a **new directory** and verify/seed that extracted directory. Compression is transport packaging, not a new data contract.
+
+## Use real GeoNames inputs
+
+Download the desired files from [GeoNames exports](https://download.geonames.org/export/dump/), retain their license, and extract any ZIP archives yourself. Then ingest local text files:
+
+```sh
+node dist/cli.js geonames --countries data/countryInfo.txt --admin1 data/admin1CodesASCII.txt --admin2 data/admin2Codes.txt --places data/cities1000.txt --version geonames-2026-11-11 --output data/geonames.sqlite
+```
+
+Only `--countries`, `--version`, and `--output` are mandatory. The importer does not fetch data from the network. It accepts GeoNames populated-place records, not every feature class. Each supplied file receives a SHA-256 provenance revision. See [source coverage and limitations](data-sources.md).
+
+## Seed PostgreSQL
+
+Export normalized JSON, NDJSON, or CSV, then preview before applying:
+
+```sh
+node dist/cli.js export --snapshot data/example.sqlite --format ndjson --coordinates --output exports/seed
+node dist/cli.js seed --package exports/seed --create-schema
+node dist/cli.js seed --package exports/seed --create-schema --apply
+```
+
+Set `DATABASE_URL` in your shell or secret manager before running the seed commands. Do not put credentials in tracked files or exported packages. The commands above target the standard schema; existing application tables require an explicit mapping. See [seeding](seeding.md) for revision ordering, field ownership, and recovery.
+
+## Optional SDK
+
+Only applications that want the local snapshot query API need to install the library with `npm install georeference`. You can also build and install a local archive with `npm pack` and `npm install /path/to/georeference-1.0.0.tgz`. File generation needs no such installation.
+
+```ts
+import { Snapshot, createClient } from 'georeference';
+
+const snapshot = Snapshot.open('data/example.sqlite');
+try {
+  const client = createClient(snapshot);
+  console.log(client.getEntity('example:locality'));
+  console.log(client.getCountry('example:country'));
+} finally {
+  snapshot.close();
+}
+```
+
+The SDK reads the local snapshot and does not synchronize an application database. Keep the snapshot open while iterating and close it when finished. Install the compiled package with `npm install georeference`, or build/install it from this repository.

package/docs/seeding.fr.md

@@ -0,0 +1,71 @@
+# Import et amorçage PostgreSQL
+
+[English](seeding.md) · [Accueil](../README.fr.md)
+
+## Aperçu puis application
+
+Le seeder lit des paquets GeoReference normalisés et vérifiés, pas du SQL téléchargé arbitrairement. Utilisez JSON, NDJSON ou le profil machine CSV. Le CSV transformé pour tableur, les couches GeoJSON, les scripts SQL et les fichiers SQLite exportés ne constituent pas des entrées interchangeables pour le seeder. Les imports V1 sont bornés à 128 Mio décompressés et 500 000 entités ; scindez les plus grands jeux en paquets géographiques mesurés. Gzip est lu directement ; ZIP doit être extrait avec son manifeste interne dans un nouveau répertoire.
+
+Définissez `DATABASE_URL` hors des fichiers suivis. Pour la table GeoReference standard :
+
+```sh
+node dist/cli.js seed --package exports/seed --create-schema
+node dist/cli.js seed --package exports/seed --create-schema --apply
+```
+
+Sans `--apply`, la commande produit un plan en lecture seule. `--create-schema` permet de créer les objets standards lors de l'application ; cela n'autorise pas à modifier arbitrairement les schémas existants. La cible par défaut est `public.georeference_entities`.
+
+## Mises à jour et identité stable
+
+- `--mode upsert`, par défaut, crée les lignes manquantes et actualise les champs gérés réellement présents. La source est prioritaire pour ces champs ; examinez cette politique si vous avez modifié localement le référentiel.
+- Les champs facultatifs absents sont préservés. Coordonnées/frontières ne sont gérées que si le paquet les demandait. Un null explicite n'a pas le même sens qu'un champ absent.
+- `--mode insert-only` ajoute les nouvelles entités, ignore les modifications des lignes existantes et signale les conflits. Aucun de ces modes ne supprime une entité absente du paquet.
+- Rejouer le même contenu laisse les lignes inchangées intactes, sans doublons ni mises à jour artificielles simplement parce qu'un nouvel import est lancé.
+- Les relations se résolvent par identité stable ; les parents nécessaires doivent être présents dans le paquet ou dans la cible. Un parent externe doit être un pays/une subdivision compatible, jamais une localité. Un export géographique partiel ne prouve jamais qu'une entité absente doit être supprimée.
+- En insert-only, les nouveaux enfants sont validés contre les parents réellement conservés en cible lorsque leurs mises à jour sont ignorées. Un UPSERT partiel ne peut déplacer un parent vers un autre pays ou changer son type si des enfants conservés deviennent incohérents ; incluez le sous-arbre concerné dans la mise à jour.
+
+Le seeder applique la priorité à la source pour les champs gérés. Fusion automatique des modifications locales, migrations, synchronisation destructive et mappings universels d'ORM restent hors V1.
+
+## Ordonner explicitement les nouvelles révisions
+
+Les versions de données sont opaques : `release-b` ne se compare pas de façon fiable à `2026.11`. Le premier import utilise la révision `0` par défaut. Un jeu/paquet modifié exige une révision entière explicite strictement supérieure :
+
+```sh
+node dist/cli.js seed --package exports/updated-seed --revision 1 --apply
+```
+
+Les révisions inférieures/égales en conflit sont refusées. `--allow-downgrade` constitue une dérogation explicite, pas une reprise par défaut. Conservez la même révision pour reprendre le même import interrompu.
+
+## Préserver les clés applicatives existantes
+
+Utilisez `--mapping path/to/mapping.json` pour mapper les champs canoniques vers les colonnes prises en charge de votre table. Exemple :
+
+```json
+{
+  "schema": "public",
+  "table": "places",
+  "localIdColumn": "id",
+  "columns": {
+    "id": "georeference_id",
+    "entityType": "entity_type",
+    "countryId": "country_id",
+    "parentId": "parent_id"
+  }
+}
+```
+
+Ici, `id` est une clé primaire entière serial/identity existante, et `georeference_id` l'identifiant stable sous forme de chaîne. Son unicité doit être imposée par une vraie clé primaire ou contrainte/index UNIQUE non partiel à une seule colonne ; une déclaration de mapping ou une clé unique composite ne suffit pas. Le seeder préserve les IDs locaux et les utilise pour les relations ; il ne remplace pas les clés de l'application. Les autres colonnes gérées doivent avoir des noms/types compatibles ou un mapping explicite. Préservez les champs métier et fournissez leurs valeurs par défaut obligatoires. Le mapping V1 couvre les clés entières serial/identity, pas tous les schémas personnalisés/composites.
+
+## Transactions, reprise et visibilité
+
+`--batch-size` borne chaque lot (`500` par défaut). Un lot et son curseur de reprise sont commités ensemble. Une erreur ultérieure peut laisser visibles des lots précédents ; l'import entier ne constitue pas une publication atomique. Relancez le même paquet avec les mêmes mapping, mode, révision et taille de lot pour reprendre. Un import terminé rejoué compare à nouveau les lignes et préserve les valeurs inchangées.
+
+Un import interrompu doit se terminer avec les mêmes paquet, mapping, mode et taille de lot avant qu'un autre import commence sur cette cible. Ne changez pas de paquet ou de mapping pour contourner un curseur de reprise en attente.
+
+Un verrou consultatif sérialise les imports vers la même cible. Les utilisateurs de la bibliothèque doivent fournir une **connexion/session dédiée**, pas un pool susceptible de changer de session entre les requêtes. La CLI ouvre un client PostgreSQL dédié. Un point de reprise n'est valable qu'après commit de sa transaction.
+
+Manifestes et empreintes détectent corruption et fichiers manquants ; ils ne constituent pas une signature garantissant l'identité de l'émetteur. Examinez provenance et mapping, puis utilisez l'aperçu avant d'appliquer un paquet à une base existante.
+
+## Périmètre de validation
+
+Les tests exercent la sémantique PostgreSQL via PGlite et comprennent un test d'intégration `pg` activé par `DATABASE_URL`. La CI fournit un service PostgreSQL pour ce parcours. Un test de service sauté/non exécuté ne prouve pas la compatibilité d'une version serveur ; consultez le résultat CI exact de la révision utilisée.

package/docs/seeding.md

@@ -0,0 +1,71 @@
+# PostgreSQL import and seeding
+
+[Français](seeding.fr.md) · [Home](../README.md)
+
+## Preview, then apply
+
+The seeder reads verified, normalized GeoReference packages, not arbitrary downloaded SQL. Use JSON, NDJSON, or the machine-profile CSV. Spreadsheet-transformed CSV, GeoJSON layers, SQL scripts, and SQLite export files are not interchangeable seeder inputs. V1 package imports are bounded to 128 MiB of uncompressed data and 500,000 records; split larger imports into measured geographic packages. Gzip is read directly; ZIP must first be extracted with its inner manifest into a new directory.
+
+Set `DATABASE_URL` outside tracked files. For the standard GeoReference table:
+
+```sh
+node dist/cli.js seed --package exports/seed --create-schema
+node dist/cli.js seed --package exports/seed --create-schema --apply
+```
+
+Without `--apply`, the command produces a read-only plan. `--create-schema` allows creation of the standard objects when applying; it is not permission to alter arbitrary existing application schemas. The default target is `public.georeference_entities`.
+
+## Updates and stable identity
+
+- Default `--mode upsert` creates missing records and updates source-managed fields that are actually present. Source values win for those fields; review this policy before importing locally edited reference fields.
+- Optional fields absent from input are preserved. Coordinates/boundaries are managed only when the package requested them. An explicit null and an absent field have different meanings.
+- `--mode insert-only` creates new records, skips changes to existing records, and reports conflicts. Neither mode deletes entities absent from the package.
+- Replaying identical content leaves unchanged rows unchanged. It must not produce duplicates or artificial updates merely because a new import run occurred.
+- Foreign keys are resolved through stable identities; required parents must be in the package or already present in the target. An external parent must be a compatible country/subdivision, never a locality. A partial geographic export is never evidence that absent entities should be removed.
+- Insert-only validates new children against the existing parents actually retained when incoming parent updates are skipped. A partial UPSERT cannot move a parent to another country or change its type if retained target children would become inconsistent; include the affected subtree in the update.
+
+The seeder uses **source-wins** for managed fields. Automatic merging of local edits, migrations, destructive synchronization, and universal ORM mappings are outside V1.
+
+## Order new dataset revisions explicitly
+
+Dataset version labels are opaque: `release-b` cannot be reliably compared with `2026.11`. The first import defaults to revision `0`. A changed dataset/package requires a strictly higher explicit integer revision:
+
+```sh
+node dist/cli.js seed --package exports/updated-seed --revision 1 --apply
+```
+
+Older/equal conflicting revisions are rejected. `--allow-downgrade` is an explicit override, not a default recovery mechanism. Preserve the same revision when resuming the same interrupted import.
+
+## Existing application keys
+
+Use `--mapping path/to/mapping.json` for a supported mapping of canonical fields to your existing columns. For example:
+
+```json
+{
+  "schema": "public",
+  "table": "places",
+  "localIdColumn": "id",
+  "columns": {
+    "id": "georeference_id",
+    "entityType": "entity_type",
+    "countryId": "country_id",
+    "parentId": "parent_id"
+  }
+}
+```
+
+Here `id` is an existing integer serial/identity primary key, while `georeference_id` is the stable string identifier. Its uniqueness must be enforced by a real, non-partial, single-column PRIMARY KEY or UNIQUE constraint/index; a mapping declaration or a composite unique key does not suffice. The seeder preserves local IDs and maps relationships to them; it does not replace the application's primary keys. Other managed columns must have compatible names/types or explicit mappings. Preserve unrelated business columns and supply their required defaults yourself. V1's local-key mapping supports integer serial/identity keys, not every custom/composite key design.
+
+## Transactions, recovery, and visibility
+
+`--batch-size` bounds each batch (default `500`). Each batch and its recovery cursor commit together. A later failure may leave earlier batches visible; the entire import is not one atomic publication. Rerun the same package, mapping, mode, revision, and batch size to resume. A completed replay performs comparisons again so unchanged records remain unchanged.
+
+An interrupted import must finish with the same package, mapping, mode, and batch size before a different import can start on that target. Do not switch packages or mappings to bypass a pending recovery cursor.
+
+An advisory lock serializes imports for the same target. Library callers must supply a **dedicated connection/session**, not a pool that can switch sessions between queries. The CLI opens a dedicated PostgreSQL client. A checkpoint is useful only after its transaction has committed.
+
+Manifests and checksums detect corruption and missing files; they are not a signature proving the sender's identity. Review provenance and mappings, and use the dry-run before applying a package to an existing application.
+
+## Validation scope
+
+The test suite exercises PostgreSQL semantics using PGlite and includes a `pg` integration test selected by `DATABASE_URL`. CI provisions a PostgreSQL service for that integration path. An unexecuted/skipped service test is not a tested server-version claim; consult the actual CI result for the revision being used.

package/examples/README.md

@@ -0,0 +1,7 @@
+# Synthetic example / Exemple fictif
+
+`sample.ndjson` and `metadata.json` describe a fictional country, two administrative levels, and one locality. Names, codes, coordinates, and the square boundary are test/demo values; they are not a real geographic reference. Both files are licensed under the repository's MIT license.
+
+`sample.ndjson` et `metadata.json` décrivent un pays fictif, deux niveaux administratifs et une localité. Les noms, codes, coordonnées et la frontière carrée servent à la démonstration ; ils ne constituent pas un référentiel géographique réel. Ces deux fichiers sont distribués sous la licence MIT du dépôt.
+
+Run the commands in the [English guide](../docs/getting-started.md) or [guide français](../docs/getting-started.fr.md). Generated snapshots and export directories are intentionally ignored by Git.

package/examples/metadata.json

@@ -0,0 +1,13 @@
+{
+  "contractVersion": "1.0",
+  "datasetVersion": "example-1",
+  "sources": [
+    {
+      "name": "GeoReference synthetic example",
+      "url": "https://example.invalid/georeference-fixture",
+      "license": "MIT",
+      "attribution": "Synthetic example by GeoReference contributors; not real geographic data.",
+      "revision": "fixture-1"
+    }
+  ]
+}

package/examples/sample.ndjson

@@ -0,0 +1,4 @@
+{"id":"example:country","entityType":"country","name":"Example Republic","countryId":"example:country","parentId":null,"codes":{"iso2":"XZ","iso3":"XZZ"},"names":{"en":"Example Republic","fr":"République exemple"},"boundary":{"type":"Polygon","coordinates":[[[10,0],[12,0],[12,2],[10,2],[10,0]]]}}
+{"id":"example:region","entityType":"subdivision","name":"Northern Region","countryId":"example:country","parentId":"example:country","level":1,"names":{"en":"Northern Region","fr":"Région du Nord"}}
+{"id":"example:district","entityType":"subdivision","name":"River District","countryId":"example:country","parentId":"example:region","level":2}
+{"id":"example:locality","entityType":"locality","name":"Harbor d'Été","countryId":"example:country","parentId":"example:district","coordinates":{"longitude":11,"latitude":1}}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "georeference",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Versioned geographic datasets, portable exports and repeatable database seeding.",
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "author": "Osiris Balonga",
+  "engines": {
+    "node": ">=24.18.0 <25"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./seeding": "./dist/seeding/index.js"
+  },
+  "bin": {
+    "georeference": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "README.fr.md",
+    "CONTRIBUTING.md",
+    "CONTRIBUTING.fr.md",
+    "SECURITY.md",
+    "SECURITY.fr.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "docs",
+    "examples"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "node --test tests/*.test.ts",
+    "test:postgres": "node --test tests/postgres.integration.test.ts",
+    "check": "npm run typecheck && npm test && npm run build",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "csv-parse": "^7.0.3",
+    "csv-stringify": "^6.6.0",
+    "pg": "^8.16.3",
+    "yazl": "^3.3.1"
+  },
+  "devDependencies": {
+    "@electric-sql/pglite": "^0.3.14",
+    "@types/node": "^24.10.0",
+    "@types/pg": "^8.15.6",
+    "@types/yazl": "^3.3.0",
+    "typescript": "^5.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Osiris-Balonga/georeference.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Osiris-Balonga/georeference/issues"
+  },
+  "homepage": "https://github.com/Osiris-Balonga/georeference#readme"
+}