pelias-openstreetmap 8.3.1 → 8.4.0

package/.jshintrc

@@ -1,8 +1,8 @@
 {
-  "esversion": 6,
   "node": true,
   "curly": true,
   "eqeqeq": true,
+  "esversion": 11,
   "freeze": true,
   "immed": true,
   "indent": 2,
@@ -17,6 +17,6 @@
   "undef": true,
   "unused": false,
   "maxparams": 4,
-  "maxdepth": 5,
+  "maxdepth": 4,
   "maxlen": 140
 }

package/README.md

@@ -94,6 +94,24 @@ The OSM importer will look for a file with a name matching this value in the con
 
 If downloading from a remote URL, the filename must match the value in `sourceURL`.
 
+#### `imports.openstreetmap.layers`
+
+This is an object you can use to define your own layers based on OSM tags. For example, if you wanted a layer `coffee` for just coffee shops you could set:
+
+```
+{
+  "imports": {
+    "openstreetmap": {
+      "layers": {
+        "coffee": {
+          "tags": [ "amenity~cafe+name" ]
+        }
+      }
+    }
+  }
+}
+```
+
 #### `imports.openstreetmap.leveldbpath`
 
 This is the directory where temporary files will be stored in order to
@@ -106,6 +124,8 @@ Defaults to `tmp`.
 
 By default, the OSM importer imports both venue records and addresses. If set to false, only address records will be imported.
 
+You can also disable venue import by setting `imports.openstreetmap.layers.venue` to an empty value.
+
 #### `imports.openstreetmap.removeDisusedVenues`
 
 If set to boolean `true`, `venue`s with popularity below `0` (as determined by OSM tags) will be

package/config/addendum_whitelist.js

@@ -0,0 +1,25 @@
+
+/**
+  Tags stored verbatim in the OSM addendum of every imported record.
+
+  @see stream/addendum_mapper.js
+  @see https://github.com/pelias/api/pull/1255
+**/
+
+module.exports = [
+  'wheelchair',           // Wheelchair accessibility
+  'iata',                 // IATA airport codes
+  'icao',                 // ICAO airport codes
+  'wikidata',             // Wikidata concordance
+  'wikipedia',            // Wikipedia concordance
+  'operator',             // Operator name
+  'brand',                // Brand name
+  'website',              // Website URL
+  'phone',                // Telephone number
+  'opening_hours',        // Opening hours
+
+  // COVID-19
+  'opening_hours:covid19',
+  'delivery:covid19',
+  'safety:mask:covid19',
+];

package/config/features.js

@@ -2,52 +2,60 @@
 /**
  default list of tags to extract from the pbf file when running
  imports. @see: https://github.com/pelias/pbf2json for more info.
-**/
 
-// default tags imported
-const tags = [
-  'addr:housenumber+addr:street',
-  'addr:housenumber+addr:place'  // @ref https://github.com/pelias/pelias/issues/787#issuecomment-477137803
-];
+ addressTags: extracted so address_extractor can assign the address layer downstream.
+              these are not a layer themselves — address classification is structural,
+              not tag-based.
 
-// tags corresponding to venues
-const venue_tags = [
-  'amenity+name',
-  'building+name',
-  'shop+name',
-  'office+name',
-  'public_transport+name',
-  'cuisine+name',
-  'railway~station+name',
-  'railway~tram_stop+name',
-  'railway~halt+name',
-  'railway~subway_entrance+name',
-  'railway~train_station_entrance+name',
-  'highway~pedestrian+area~yes+name',
-  'place~square+name',
-  'sport+name',
-  'natural+name',
-  'tourism+name',
-  'leisure+name',
-  'historic+name',
-  'man_made+name',
-  'landuse+name',
-  'waterway+name',
-  'aerialway+name',
-  'craft+name',
-  'military+name',
-  'aeroway~terminal+name',
-  'aeroway~aerodrome+name',
-  'aeroway~helipad+name',
-  'aeroway~airstrip+name',
-  'aeroway~heliport+name',
-  'aeroway~areodrome+name',
-  'aeroway~spaceport+name',
-  'aeroway~landing_strip+name',
-  'aeroway~airfield+name',
-  'aeroway~airport+name',
-  'brand+name',
-  'healthcare+name'
-];
+ layers: keyed by output layer name. order determines classifier priority (first match wins).
+         add custom layers here (e.g. river, protected_area) to extend the importer.
+**/
 
-module.exports = {tags,venue_tags};
+module.exports = {
+  addressTags: [
+    'addr:housenumber+addr:street',
+    'addr:housenumber+addr:place'  // @ref https://github.com/pelias/pelias/issues/787#issuecomment-477137803
+  ],
+  layers: {
+    venue: {
+      tags: [
+        'amenity+name',
+        'building+name',
+        'shop+name',
+        'office+name',
+        'public_transport+name',
+        'cuisine+name',
+        'railway~station+name',
+        'railway~tram_stop+name',
+        'railway~halt+name',
+        'railway~subway_entrance+name',
+        'railway~train_station_entrance+name',
+        'highway~pedestrian+area~yes+name',
+        'place~square+name',
+        'sport+name',
+        'natural+name',
+        'tourism+name',
+        'leisure+name',
+        'historic+name',
+        'man_made+name',
+        'landuse+name',
+        'waterway+name',
+        'aerialway+name',
+        'craft+name',
+        'military+name',
+        'aeroway~terminal+name',
+        'aeroway~aerodrome+name',
+        'aeroway~helipad+name',
+        'aeroway~airstrip+name',
+        'aeroway~heliport+name',
+        'aeroway~areodrome+name',
+        'aeroway~spaceport+name',
+        'aeroway~landing_strip+name',
+        'aeroway~airfield+name',
+        'aeroway~airport+name',
+        'brand+name',
+        'healthcare+name'
+      ]
+    }
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pelias-openstreetmap",
-  "version": "8.3.1",
+  "version": "8.4.0",
   "engines": {
     "node": ">=10.0.0"
   },
@@ -15,6 +15,8 @@
     "end-to-end": "export NODE_ENV=test && node test/end-to-end.js;",
     "lint": "jshint .",
     "start": "./bin/start",
+    "taginfo": "node scripts/generate_taginfo.js",
+    "prepublishOnly": "npm run taginfo",
     "test": "npm run units",
     "ci": "node ./test/ci-config.js && npm test && npm run end-to-end",
     "units": "./bin/test",

package/schema.js

@@ -21,7 +21,14 @@ module.exports = Joi.object().keys({
       download: Joi.array().items(Joi.object().keys({
         sourceURL: Joi.string()
       }).requiredKeys('sourceURL').unknown(true)),
-      deduplicate: Joi.boolean()
+      deduplicate: Joi.boolean(),
+      addressTags: Joi.array().items(Joi.string()),
+      layers: Joi.object().pattern(
+        Joi.string(),
+        Joi.object().keys({
+          tags: Joi.array().items(Joi.string())
+        })
+      )
     }).requiredKeys('datapath', 'leveldbpath', 'import').unknown(true)
   }).requiredKeys('openstreetmap').unknown(true)
 }).requiredKeys('imports').unknown(true);

package/scripts/generate_taginfo.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Generates taginfo.json describing which OSM tags Pelias reads.
+ *
+ * Sources of truth pulled in at generation time:
+ *   - config/features.js          (venue detection tags, address filter keys)
+ *   - config/addendum_whitelist.js (metadata tags stored in the OSM addendum)
+ *   - schema/name_osm.js           (name/alias tags)
+ *   - schema/address_*.js          (address tags)
+ *
+ * Published to npm and served by jsDelivr:
+ *   https://cdn.jsdelivr.net/npm/pelias-openstreetmap/taginfo.json
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const pkg          = require('../package.json');
+const features     = require('../config/features');
+const nameSchema   = require('../schema/name_osm');
+const karlsruhe    = require('../schema/address_karlsruhe');
+const osmAddr      = require('../schema/address_osm');
+const tiger        = require('../schema/address_tiger');
+const naptan       = require('../schema/address_naptan');
+const addendumKeys = require('../config/addendum_whitelist');
+
+const OBJECT_TYPES = ['node', 'way', 'relation'];
+
+function entry(key, description, value) {
+  const e = { key };
+  if (value !== undefined) {
+    e.value = value;
+  }
+  e.object_types = OBJECT_TYPES;
+  e.description  = description;
+  return e;
+}
+
+// ---------------------------------------------------------------------------
+// Venue detection tags — derived from config/features.js
+// Format: 'amenity+name', 'railway~station+name', 'highway~pedestrian+area~yes+name'
+// '+' = AND conditions; '~' = key=value; 'name' and 'area~yes' are secondary filters
+// ---------------------------------------------------------------------------
+function parseVenueTags(patterns) {
+  const seen    = new Set();
+  const entries = [];
+  for (const pattern of patterns) {
+    const parts = pattern.split('+').filter(p => p !== 'name' && p !== 'area~yes');
+    for (const part of parts) {
+      const [key, value] = part.split('~');
+      const id = value ? `${key}=${value}` : key;
+      if (!seen.has(id)) {
+        seen.add(id);
+        entries.push({ key, value });
+      }
+    }
+  }
+  return entries;
+}
+
+const venueTags = parseVenueTags(features.layers.venue.tags).map(({ key, value }) => {
+  const desc = value ?
+    `${key}=${value} features with a name are imported as venues` :
+    `Features with any ${key} tag and a name are imported as venues`;
+  return entry(key, desc, value);
+});
+
+// ---------------------------------------------------------------------------
+// Address tags — derived from all address schemas + features.addressTags
+// ---------------------------------------------------------------------------
+const addressDescriptions = {
+  'addr:housenumber': 'House number; required (with addr:street or addr:place) to create an address record',
+  'addr:street':      'Street name for address records',
+  'addr:place':       'Named settlement used instead of a street for rural addresses',
+  'addr:housename':   'Building or house name, imported as the address name',
+  'addr:postcode':    'Postal/ZIP code',
+  'postal_code':      'Postal code (OSM standard key, alternative to addr:postcode)',
+  'tiger:zip_left':   'US TIGER-imported postal code for the left side of the street',
+  'tiger:zip_right':  'US TIGER-imported postal code for the right side of the street',
+  'naptan:Street':    'Street name from the UK NaPTAN bus stop dataset',
+};
+
+const addressKeys = new Set([
+  ...Object.keys(karlsruhe),
+  ...Object.keys(osmAddr),
+  ...Object.keys(tiger),
+  ...Object.keys(naptan),
+  // pbf2json filter patterns like 'addr:housenumber+addr:street'
+  ...features.addressTags.flatMap(p => p.split('+')),
+]);
+
+const addressTags = [...addressKeys].map(k =>
+  entry(k, addressDescriptions[k] || 'Address field used by the Pelias OSM importer')
+);
+
+// ---------------------------------------------------------------------------
+// Name tags — derived from schema/name_osm.js
+// Localized name tags (name:en, name:fr, …) are read dynamically via iso-639-3
+// ---------------------------------------------------------------------------
+const nameDescriptions = {
+  name:       'Primary display name; the main search term for a record',
+  loc_name:   'Local name; indexed as an alias',
+  alt_name:   'Alternative name; indexed as an alias',
+  short_name: 'Short name; indexed as an alias',
+};
+
+const nameTags = [
+  ...Object.keys(nameSchema).map(k =>
+    entry(k, nameDescriptions[k] || 'Name variant indexed as an alias')
+  ),
+  // Localised names are resolved at import time from iso-639-3 (e.g. name:en, name:fr)
+  entry('name:*', 'Language-specific names (e.g. name:en, name:fr) are indexed as localized aliases'),
+];
+
+// ---------------------------------------------------------------------------
+// Addendum / metadata tags — derived from config/addendum_whitelist.js
+// ---------------------------------------------------------------------------
+const addendumTags = addendumKeys.map(k =>
+  entry(k, `${k} is stored verbatim in the OSM addendum of every imported record`)
+);
+
+// ---------------------------------------------------------------------------
+// Assemble, deduplicate (venue tags take precedence), and write
+// ---------------------------------------------------------------------------
+const seen = new Set();
+const tags = [...venueTags, ...addressTags, ...nameTags, ...addendumTags].filter(t => {
+  const id = t.value !== undefined ? `${t.key}=${t.value}` : t.key;
+  if (seen.has(id)) {
+    return false;
+  }
+  seen.add(id);
+  return true;
+});
+
+const output = {
+  data_format: 1,
+  data_url: `https://cdn.jsdelivr.net/npm/${pkg.name}/taginfo.json`,
+  project: {
+    name:          'Pelias Geocoder — OpenStreetMap importer',
+    description:   'Imports OpenStreetMap data into the Pelias geocoding engine',
+    project_url:   pkg.homepage,
+    doc_url:       `${pkg.homepage}#readme`,
+    icon_url:      'https://github.com/pelias.png',
+    contact_name:  'Pelias Team',
+    contact_email: 'team@pelias.io',
+  },
+  tags,
+};
+
+const outPath = path.join(__dirname, '..', 'taginfo.json');
+fs.writeFileSync(outPath, JSON.stringify(output, null, 2) + '\n');
+console.log(`taginfo.json written (${tags.length} tag entries)`);

package/stream/addendum_mapper.js

@@ -7,23 +7,7 @@
 
 const through = require('through2');
 const peliasLogger = require('pelias-logger').get('openstreetmap');
-const whitelist = [
-  'wheelchair', // Wheelchair accessibility
-  'iata', // IATA airport codes
-  'icao', // ICAO airport codes
-  'wikidata', // Wikidata concordance
-  'wikipedia', // Wikipedia concordance
-  'operator', // Operator name
-  'brand', // Brand name
-  'website', // Website URL
-  'phone', // Telephone number
-  'opening_hours', // Opening hours
-
-  // COVID-19
-  'opening_hours:covid19',
-  'delivery:covid19',
-  'safety:mask:covid19'
-];
+const whitelist = require('../config/addendum_whitelist');
 
 module.exports = function(){
 

package/stream/document_constructor.js

@@ -8,6 +8,11 @@ const through = require('through2');
 const Document = require('pelias-model').Document;
 const peliasLogger = require( 'pelias-logger' ).get( 'openstreetmap' );
 const _ = require('lodash');
+const settings = require('pelias-config').generate(require('../schema'));
+const resolveFeatures = require('../util/resolveFeatures');
+const { classify } = require('../util/layerClassifier');
+
+const { layers } = resolveFeatures(settings);
 
 module.exports = function(){
 
@@ -19,8 +24,10 @@ module.exports = function(){
       }
       var uniqueId = [ item.type, item.id ].join('/');
 
-      // we need to assume it will be a venue and later if it turns out to be an address it will get changed
-      var doc = new Document( 'openstreetmap', 'venue', uniqueId );
+      // classify the layer from OSM tags; address_extractor assigns the address
+      // layer downstream — the classifier only covers named layers (venue, etc.)
+      var layer = classify(item.tags || {}, layers);
+      var doc = new Document( 'openstreetmap', layer, uniqueId );
 
       // Set latitude / longitude
       if( item.hasOwnProperty('lat') && item.hasOwnProperty('lon') ){

package/stream/importPipeline.js

@@ -13,6 +13,7 @@ streams.tagMapper = require('./tag_mapper');
 streams.addressesWithoutStreet = require('./addresses_without_street');
 streams.adminLookup = require('pelias-wof-admin-lookup').create;
 streams.addressExtractor = require('./address_extractor');
+streams.venueFilter = require('./venueFilter');
 streams.categoryMapper = require('./category_mapper');
 streams.addendumMapper = require('./addendum_mapper');
 streams.popularityMapper = require('./popularity_mapper');
@@ -26,6 +27,7 @@ streams.import = function(){
     .pipe( streams.addressesWithoutStreet() )
     .pipe( streams.tagMapper() )
     .pipe( streams.addressExtractor() )
+    .pipe( streams.venueFilter() )
     .pipe( streams.blacklistStream() )
     .pipe( streams.categoryMapper( categoryDefaults ) )
     .pipe( streams.addendumMapper() )

package/stream/pbf.js

@@ -7,7 +7,7 @@
 var fs = require('fs'),
     pbf2json = require('pbf2json'),
     settings = require('pelias-config').generate(require('../schema')),
-    features = require('../config/features'),
+    resolveFeatures = require('../util/resolveFeatures'),
     path = require('path');
 
 // Create a new pbf parser stream
@@ -46,11 +46,11 @@ function config(opts){
   if(!opts.tags){
     // check if we import venues
     opts.importVenues = settings.imports.openstreetmap.import[0].importVenues;
-    if(opts.importVenues){
-      opts.tags = features.tags.concat(features.venue_tags);
-    } else {
-      opts.tags = features.tags;
-    }
+    const features = resolveFeatures(settings);
+    const layerTags = opts.importVenues === false ?
+      [] :
+      Object.values(features.layers).flatMap(l => l.tags ?? []);
+    opts.tags = features.addressTags.concat(layerTags);
   }
   return opts;
 }

package/stream/venueFilter.js

@@ -0,0 +1,30 @@
+'use strict';
+
+/**
+ * When importVenues is false, drop any record that is not in the address layer.
+ * This prevents named POIs that also have address tags from leaking through as
+ * venue records when venue import is disabled.
+ *
+ * Note: the preferred way to control which layers are imported is now to set
+ * `imports.openstreetmap.layers` in pelias.json. Setting `importVenues: false`
+ * is equivalent to `layers: {}` and is retained for backward compatibility.
+ */
+
+const through = require('through2');
+const settings = require('pelias-config').generate(require('../schema'));
+
+module.exports = function() {
+  const importVenues = settings.imports.openstreetmap.import[0].importVenues;
+
+  // passthrough when venues are enabled (default)
+  if (importVenues !== false) {
+    return through.obj();
+  }
+
+  return through.obj(function(doc, enc, next) {
+    if (doc.getLayer() === 'address') {
+      this.push(doc);
+    }
+    next();
+  });
+};

package/taginfo.json

@@ -0,0 +1,590 @@
+{
+  "data_format": 1,
+  "data_url": "https://cdn.jsdelivr.net/npm/pelias-openstreetmap/taginfo.json",
+  "project": {
+    "name": "Pelias Geocoder — OpenStreetMap importer",
+    "description": "Imports OpenStreetMap data into the Pelias geocoding engine",
+    "project_url": "https://github.com/pelias/openstreetmap",
+    "doc_url": "https://github.com/pelias/openstreetmap#readme",
+    "icon_url": "https://github.com/pelias.png",
+    "contact_name": "Pelias Team",
+    "contact_email": "team@pelias.io"
+  },
+  "tags": [
+    {
+      "key": "amenity",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any amenity tag and a name are imported as venues"
+    },
+    {
+      "key": "building",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any building tag and a name are imported as venues"
+    },
+    {
+      "key": "shop",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any shop tag and a name are imported as venues"
+    },
+    {
+      "key": "office",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any office tag and a name are imported as venues"
+    },
+    {
+      "key": "public_transport",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any public_transport tag and a name are imported as venues"
+    },
+    {
+      "key": "cuisine",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any cuisine tag and a name are imported as venues"
+    },
+    {
+      "key": "railway",
+      "value": "station",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "railway=station features with a name are imported as venues"
+    },
+    {
+      "key": "railway",
+      "value": "tram_stop",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "railway=tram_stop features with a name are imported as venues"
+    },
+    {
+      "key": "railway",
+      "value": "halt",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "railway=halt features with a name are imported as venues"
+    },
+    {
+      "key": "railway",
+      "value": "subway_entrance",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "railway=subway_entrance features with a name are imported as venues"
+    },
+    {
+      "key": "railway",
+      "value": "train_station_entrance",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "railway=train_station_entrance features with a name are imported as venues"
+    },
+    {
+      "key": "highway",
+      "value": "pedestrian",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "highway=pedestrian features with a name are imported as venues"
+    },
+    {
+      "key": "place",
+      "value": "square",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "place=square features with a name are imported as venues"
+    },
+    {
+      "key": "sport",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any sport tag and a name are imported as venues"
+    },
+    {
+      "key": "natural",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any natural tag and a name are imported as venues"
+    },
+    {
+      "key": "tourism",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any tourism tag and a name are imported as venues"
+    },
+    {
+      "key": "leisure",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any leisure tag and a name are imported as venues"
+    },
+    {
+      "key": "historic",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any historic tag and a name are imported as venues"
+    },
+    {
+      "key": "man_made",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any man_made tag and a name are imported as venues"
+    },
+    {
+      "key": "landuse",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any landuse tag and a name are imported as venues"
+    },
+    {
+      "key": "waterway",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any waterway tag and a name are imported as venues"
+    },
+    {
+      "key": "aerialway",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any aerialway tag and a name are imported as venues"
+    },
+    {
+      "key": "craft",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any craft tag and a name are imported as venues"
+    },
+    {
+      "key": "military",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any military tag and a name are imported as venues"
+    },
+    {
+      "key": "aeroway",
+      "value": "terminal",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "aeroway=terminal features with a name are imported as venues"
+    },
+    {
+      "key": "aeroway",
+      "value": "aerodrome",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "aeroway=aerodrome features with a name are imported as venues"
+    },
+    {
+      "key": "aeroway",
+      "value": "helipad",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "aeroway=helipad features with a name are imported as venues"
+    },
+    {
+      "key": "aeroway",
+      "value": "airstrip",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "aeroway=airstrip features with a name are imported as venues"
+    },
+    {
+      "key": "aeroway",
+      "value": "heliport",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "aeroway=heliport features with a name are imported as venues"
+    },
+    {
+      "key": "aeroway",
+      "value": "areodrome",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "aeroway=areodrome features with a name are imported as venues"
+    },
+    {
+      "key": "aeroway",
+      "value": "spaceport",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "aeroway=spaceport features with a name are imported as venues"
+    },
+    {
+      "key": "aeroway",
+      "value": "landing_strip",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "aeroway=landing_strip features with a name are imported as venues"
+    },
+    {
+      "key": "aeroway",
+      "value": "airfield",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "aeroway=airfield features with a name are imported as venues"
+    },
+    {
+      "key": "aeroway",
+      "value": "airport",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "aeroway=airport features with a name are imported as venues"
+    },
+    {
+      "key": "brand",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any brand tag and a name are imported as venues"
+    },
+    {
+      "key": "healthcare",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Features with any healthcare tag and a name are imported as venues"
+    },
+    {
+      "key": "addr:housename",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Building or house name, imported as the address name"
+    },
+    {
+      "key": "addr:housenumber",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "House number; required (with addr:street or addr:place) to create an address record"
+    },
+    {
+      "key": "addr:street",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Street name for address records"
+    },
+    {
+      "key": "addr:postcode",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Postal/ZIP code"
+    },
+    {
+      "key": "postal_code",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Postal code (OSM standard key, alternative to addr:postcode)"
+    },
+    {
+      "key": "tiger:zip_left",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "US TIGER-imported postal code for the left side of the street"
+    },
+    {
+      "key": "tiger:zip_right",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "US TIGER-imported postal code for the right side of the street"
+    },
+    {
+      "key": "naptan:Street",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Street name from the UK NaPTAN bus stop dataset"
+    },
+    {
+      "key": "addr:place",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Named settlement used instead of a street for rural addresses"
+    },
+    {
+      "key": "name",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Primary display name; the main search term for a record"
+    },
+    {
+      "key": "loc_name",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Local name; indexed as an alias"
+    },
+    {
+      "key": "alt_name",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Alternative name; indexed as an alias"
+    },
+    {
+      "key": "short_name",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Short name; indexed as an alias"
+    },
+    {
+      "key": "name:*",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "Language-specific names (e.g. name:en, name:fr) are indexed as localized aliases"
+    },
+    {
+      "key": "wheelchair",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "wheelchair is stored verbatim in the OSM addendum of every imported record"
+    },
+    {
+      "key": "iata",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "iata is stored verbatim in the OSM addendum of every imported record"
+    },
+    {
+      "key": "icao",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "icao is stored verbatim in the OSM addendum of every imported record"
+    },
+    {
+      "key": "wikidata",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "wikidata is stored verbatim in the OSM addendum of every imported record"
+    },
+    {
+      "key": "wikipedia",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "wikipedia is stored verbatim in the OSM addendum of every imported record"
+    },
+    {
+      "key": "operator",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "operator is stored verbatim in the OSM addendum of every imported record"
+    },
+    {
+      "key": "website",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "website is stored verbatim in the OSM addendum of every imported record"
+    },
+    {
+      "key": "phone",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "phone is stored verbatim in the OSM addendum of every imported record"
+    },
+    {
+      "key": "opening_hours",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "opening_hours is stored verbatim in the OSM addendum of every imported record"
+    },
+    {
+      "key": "opening_hours:covid19",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "opening_hours:covid19 is stored verbatim in the OSM addendum of every imported record"
+    },
+    {
+      "key": "delivery:covid19",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "delivery:covid19 is stored verbatim in the OSM addendum of every imported record"
+    },
+    {
+      "key": "safety:mask:covid19",
+      "object_types": [
+        "node",
+        "way",
+        "relation"
+      ],
+      "description": "safety:mask:covid19 is stored verbatim in the OSM addendum of every imported record"
+    }
+  ]
+}

package/util/layerClassifier.js

@@ -0,0 +1,44 @@
+'use strict';
+
+/**
+ * Test a single pbf2json tag condition against an OSM tags object.
+ * Supports 'key' (key must exist) or 'key~value' (key must equal value).
+ */
+function conditionMatchesTags(condition, tags) {
+  const tildeIdx = condition.indexOf('~');
+  if (tildeIdx === -1) {
+    return Object.prototype.hasOwnProperty.call(tags, condition);
+  }
+  const key = condition.slice(0, tildeIdx);
+  const value = condition.slice(tildeIdx + 1);
+  return tags[key] === value;
+}
+
+/**
+ * Test whether a full pbf2json pattern string matches a tags object.
+ * Pattern conditions are separated by '+' and all must match (AND logic).
+ */
+function patternMatchesTags(pattern, tags) {
+  return pattern.split('+').every(cond => conditionMatchesTags(cond, tags));
+}
+
+/**
+ * Classify an OSM tags object against the features config.
+ * Iterates layers in declaration order and returns the first matching layer.
+ * Falls back to 'venue' if no patterns match.
+ *
+ * @param {Object} tags     - OSM tags from a pbf2json record
+ * @param {Object} features - the features.js keyed-by-layer export
+ * @returns {string} layer name
+ */
+function classify(tags, features) {
+  const matchesTags = p => patternMatchesTags(p, tags);
+  for (const [layer, config] of Object.entries(features)) {
+    if (Array.isArray(config.tags) && config.tags.some(matchesTags)) {
+      return layer;
+    }
+  }
+  return 'venue';
+}
+
+module.exports = { patternMatchesTags, classify };

package/util/resolveFeatures.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const defaults = require('../config/features');
+
+/**
+ * Resolve the effective features config by merging pelias.json overrides
+ * with the defaults from config/features.js.
+ *
+ * If `imports.openstreetmap.layers` is set in pelias.json it fully replaces
+ * the default layer set. Same for `addressTags`. This lets operators add
+ * custom layers (e.g. protected_area) or restrict which tags are extracted
+ * without touching the source code.
+ *
+ * @param {Object} settings - result of pelias-config generate()
+ * @returns {{ addressTags: string[], layers: Object }}
+ */
+function resolveFeatures(settings) {
+  const osmConfig = (settings && settings.imports && settings.imports.openstreetmap) || {};
+  return {
+    addressTags: osmConfig.addressTags || defaults.addressTags,
+    layers:      osmConfig.layers      || defaults.layers
+  };
+}
+
+module.exports = resolveFeatures;