@osmix/geoparquet 0.1.5 → 0.1.6

package/CHANGELOG.md

@@ -0,0 +1,74 @@
+# @osmix/geoparquet
+
+## 0.1.6
+
+### Patch Changes
+
+- 2a634cb: Fix publishing
+- Updated dependencies [2a634cb]
+  - @osmix/shared@0.0.12
+  - @osmix/core@0.1.7
+
+## 0.1.5
+
+### Patch Changes
+
+- 3c8ee95: Fix and simplify package exports
+- Updated dependencies [3c8ee95]
+  - @osmix/core@0.1.6
+  - @osmix/shared@0.0.11
+
+## 0.1.4
+
+### Patch Changes
+
+- Updated dependencies [12728ed]
+  - @osmix/shared@0.0.10
+  - @osmix/core@0.1.5
+
+## 0.1.3
+
+### Patch Changes
+
+- f32e4ee: General cleanup
+- Updated dependencies [f32e4ee]
+  - @osmix/core@0.1.4
+  - @osmix/shared@0.0.9
+
+## 0.1.2
+
+### Patch Changes
+
+- f468db5: Fix publishing (2)
+- Updated dependencies [f468db5]
+  - @osmix/core@0.1.3
+  - @osmix/shared@0.0.8
+
+## 0.1.1
+
+### Patch Changes
+
+- 68d6bd8: Fix publishing for packages.
+- Updated dependencies [68d6bd8]
+  - @osmix/core@0.1.2
+  - @osmix/shared@0.0.7
+
+## 0.1.0
+
+### Minor Changes
+
+- 31fa333: Add `@osmix/geoparquet` package for importing OSM data from OpenStreetMap US Layercake GeoParquet files.
+
+  Features:
+
+  - `fromGeoParquet()` function to create Osm indexes from GeoParquet files
+  - WKB geometry parsing for Point, LineString, Polygon, and MultiPolygon
+  - Support for file paths, URLs, and ArrayBuffer inputs
+  - Customizable column mapping for different parquet schemas
+
+### Patch Changes
+
+- 54fe002: Add fromGeoParquet to OsmixWorker and OsmixRemote
+- 31fa333: Import GeoParquet
+- Updated dependencies [d4f4b1f]
+  - @osmix/core@0.1.1

package/package.json

@@ -1,54 +1,31 @@
 {
-	"$schema": "https://json.schemastore.org/package",
+	"$schema": "https://json.schemastore.org/package.json",
 	"name": "@osmix/geoparquet",
 	"description": "Import OSM data from GeoParquet files.",
-	"version": "0.1.5",
+	"version": "0.1.6",
 	"type": "module",
-	"types": "./dist/index.d.ts",
-	"publishConfig": {
-		"access": "public"
-	},
 	"license": "MIT",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/conveyal/osmix.git"
 	},
-	"homepage": "https://github.com/conveyal/osmix#readme",
-	"bugs": {
-		"url": "https://github.com/conveyal/osmix/issues"
-	},
-	"sideEffects": false,
+	"main": "./dist/index.js",
 	"scripts": {
 		"build": "tsc -p tsconfig.build.json",
 		"bench": "bun test --bench",
-		"prepare": "bun run build",
-		"release": "bun publish",
 		"test": "bun test",
 		"typecheck": "tsgo --noEmit"
 	},
 	"devDependencies": {
-		"@types/bun": "catalog:",
-		"@types/geojson": "catalog:",
-		"typescript": "catalog:"
+		"@types/bun": "^1.3.9",
+		"@types/geojson": "^7946.0.16",
+		"typescript": "^5.9.0"
 	},
 	"dependencies": {
-		"@osmix/core": "workspace:*",
-		"@osmix/shared": "workspace:*",
-		"@placemarkio/geojson-rewind": "catalog:",
+		"@osmix/core": "0.1.7",
+		"@osmix/shared": "0.0.12",
+		"@placemarkio/geojson-rewind": "^1.0.3",
 		"hyparquet": "^1.24.1"
 	},
-	"exports": {
-		".": {
-			"types": "./src/index.ts",
-			"bun": "./src/index.ts",
-			"development|production": "./src/index.ts",
-			"default": "./dist/index.js"
-		}
-	},
-	"files": [
-		"dist",
-		"src",
-		"README.md",
-		"LICENSE"
-	]
-}
+	"types": "./dist/index.d.ts"
+}

package/test/download-monaco-highways.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# Download Monaco highway data from LayerCake (OSM US) using DuckDB
+# Monaco bounding box coordinates from MapTiler:
+# - xmin: 7.409205
+# - xmax: 7.448637
+# - ymin: 43.72335
+# - ymax: 43.75169
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+OUTPUT_DIR="$SCRIPT_DIR/../../../fixtures"
+OUTPUT_FILE="$OUTPUT_DIR/monaco-highways.parquet"
+
+echo "Downloading Monaco highway data from LayerCake..."
+echo "Output: $OUTPUT_FILE"
+
+duckdb <<EOF
+INSTALL spatial;
+LOAD spatial;
+
+COPY (
+    FROM 'https://data.openstreetmap.us/layercake/highways.parquet'
+    SELECT
+        id,
+        tags,
+        geometry
+    WHERE
+        bbox.xmin >= 7.409205 AND bbox.xmax <= 7.448637 AND
+        bbox.ymin >= 43.72335 AND bbox.ymax <= 43.75169
+) TO '$OUTPUT_FILE' WITH (FORMAT PARQUET);
+EOF
+
+if [ -f "$OUTPUT_FILE" ]; then
+    echo "Successfully downloaded Monaco highways to $OUTPUT_FILE"
+    echo "File size: $(ls -lh "$OUTPUT_FILE" | awk '{print $5}')"
+else
+    echo "Error: Failed to download file"
+    exit 1
+fi
+

package/test/from-geoparquet.test.ts

@@ -0,0 +1,520 @@
+import { describe, expect, it } from "bun:test"
+import { GeoParquetOsmBuilder } from "../src/from-geoparquet"
+import type { GeoParquetRow } from "../src/types"
+
+/**
+ * Create WKB Point geometry.
+ */
+function createPointWkb(lon: number, lat: number): Uint8Array {
+	const buffer = new ArrayBuffer(21)
+	const view = new DataView(buffer)
+	let offset = 0
+
+	view.setUint8(offset, 1) // little endian
+	offset += 1
+	view.setUint32(offset, 1, true) // Point type
+	offset += 4
+	view.setFloat64(offset, lon, true)
+	offset += 8
+	view.setFloat64(offset, lat, true)
+
+	return new Uint8Array(buffer)
+}
+
+/**
+ * Create WKB LineString geometry.
+ */
+function createLineStringWkb(coords: [number, number][]): Uint8Array {
+	const buffer = new ArrayBuffer(1 + 4 + 4 + coords.length * 16)
+	const view = new DataView(buffer)
+	let offset = 0
+
+	view.setUint8(offset, 1) // little endian
+	offset += 1
+	view.setUint32(offset, 2, true) // LineString type
+	offset += 4
+	view.setUint32(offset, coords.length, true) // num points
+	offset += 4
+
+	for (const [lon, lat] of coords) {
+		view.setFloat64(offset, lon, true)
+		offset += 8
+		view.setFloat64(offset, lat, true)
+		offset += 8
+	}
+
+	return new Uint8Array(buffer)
+}
+
+/**
+ * Create WKB Polygon geometry.
+ */
+function createPolygonWkb(rings: [number, number][][]): Uint8Array {
+	const totalPoints = rings.reduce((sum, ring) => sum + ring.length, 0)
+	const buffer = new ArrayBuffer(
+		1 + 4 + 4 + rings.length * 4 + totalPoints * 16,
+	)
+	const view = new DataView(buffer)
+	let offset = 0
+
+	view.setUint8(offset, 1) // little endian
+	offset += 1
+	view.setUint32(offset, 3, true) // Polygon type
+	offset += 4
+	view.setUint32(offset, rings.length, true) // num rings
+	offset += 4
+
+	for (const ring of rings) {
+		view.setUint32(offset, ring.length, true)
+		offset += 4
+		for (const [lon, lat] of ring) {
+			view.setFloat64(offset, lon, true)
+			offset += 8
+			view.setFloat64(offset, lat, true)
+			offset += 8
+		}
+	}
+
+	return new Uint8Array(buffer)
+}
+
+/**
+ * Helper function to process rows using the builder.
+ */
+function processRows(
+	rows: GeoParquetRow[],
+	options?: { idColumn?: string; geometryColumn?: string; tagsColumn?: string },
+) {
+	const builder = new GeoParquetOsmBuilder({}, options, () => {})
+	builder.processGeoParquetRows(rows as unknown as Record<string, unknown>[])
+	return builder.buildOsm()
+}
+
+describe("@osmix/geoparquet: GeoParquetOsmBuilder", () => {
+	it("should convert Point features to Nodes", () => {
+		const rows: GeoParquetRow[] = [
+			{
+				type: "node",
+				id: 100n,
+				geometry: createPointWkb(-122.4194, 37.7749),
+				tags: { name: "San Francisco", population: "873965" },
+				bbox: [-122.4194, 37.7749, -122.4194, 37.7749],
+			},
+			{
+				type: "node",
+				id: 200n,
+				geometry: createPointWkb(-122.4094, 37.7849),
+				tags: { name: "Another Point" },
+				bbox: [-122.4094, 37.7849, -122.4094, 37.7849],
+			},
+		]
+
+		const osm = processRows(rows)
+
+		expect(osm.nodes.size).toBe(2)
+		expect(osm.ways.size).toBe(0)
+
+		// Get nodes by index to check values
+		const node1 = osm.nodes.getByIndex(0)
+		const node2 = osm.nodes.getByIndex(1)
+
+		expect(node1).toBeDefined()
+		expect(node1?.lon).toBeCloseTo(-122.4194, 4)
+		expect(node1?.lat).toBeCloseTo(37.7749, 4)
+		expect(node1?.tags?.["name"]).toBe("San Francisco")
+		expect(node1?.tags?.["population"]).toBe("873965")
+
+		expect(node2).toBeDefined()
+		expect(node2?.lon).toBeCloseTo(-122.4094, 4)
+		expect(node2?.lat).toBeCloseTo(37.7849, 4)
+	})
+
+	it("should convert Point features to Nodes with auto-generated IDs", () => {
+		const rows: GeoParquetRow[] = [
+			{
+				type: "node",
+				id: undefined as unknown as bigint, // No ID provided
+				geometry: createPointWkb(-122.4194, 37.7749),
+				tags: { name: "San Francisco" },
+				bbox: [-122.4194, 37.7749, -122.4194, 37.7749],
+			},
+		]
+
+		const osm = processRows(rows)
+
+		expect(osm.nodes.size).toBe(1)
+
+		// Auto-generated IDs start at -1
+		const node = osm.nodes.getById(-1)
+		expect(node).toBeDefined()
+		expect(node?.lon).toBeCloseTo(-122.4194, 4)
+		expect(node?.lat).toBeCloseTo(37.7749, 4)
+		expect(node?.tags?.["name"]).toBe("San Francisco")
+	})
+
+	it("should convert LineString features to Ways with Nodes", () => {
+		const rows: GeoParquetRow[] = [
+			{
+				type: "way",
+				id: undefined as unknown as bigint, // Auto-generate IDs
+				geometry: createLineStringWkb([
+					[-122.4194, 37.7749],
+					[-122.4094, 37.7849],
+					[-122.3994, 37.7949],
+				]),
+				tags: { highway: "primary", name: "Main Street" },
+				bbox: [-122.4194, 37.7749, -122.3994, 37.7949],
+			},
+		]
+
+		const osm = processRows(rows)
+
+		expect(osm.nodes.size).toBe(3)
+		expect(osm.ways.size).toBe(1)
+
+		const way = osm.ways.getById(-1)
+		expect(way).toBeDefined()
+		expect(way?.refs).toHaveLength(3)
+		expect(way?.tags?.["highway"]).toBe("primary")
+		expect(way?.tags?.["name"]).toBe("Main Street")
+
+		// Verify nodes were created with auto-generated IDs
+		const node1 = osm.nodes.getById(way!.refs[0]!)
+		const node2 = osm.nodes.getById(way!.refs[1]!)
+		const node3 = osm.nodes.getById(way!.refs[2]!)
+
+		expect(node1?.lon).toBeCloseTo(-122.4194, 4)
+		expect(node1?.lat).toBeCloseTo(37.7749, 4)
+		expect(node2?.lon).toBeCloseTo(-122.4094, 4)
+		expect(node2?.lat).toBeCloseTo(37.7849, 4)
+		expect(node3?.lon).toBeCloseTo(-122.3994, 4)
+		expect(node3?.lat).toBeCloseTo(37.7949, 4)
+	})
+
+	it("should convert Polygon features to Ways with area tags", () => {
+		const rows: GeoParquetRow[] = [
+			{
+				type: "way",
+				id: undefined as unknown as bigint, // Auto-generate IDs
+				geometry: createPolygonWkb([
+					[
+						[-122.4194, 37.7749],
+						[-122.4094, 37.7749],
+						[-122.4094, 37.7849],
+						[-122.4194, 37.7849],
+						[-122.4194, 37.7749], // closed
+					],
+				]),
+				tags: { building: "yes", name: "Test Building" },
+				bbox: [-122.4194, 37.7749, -122.4094, 37.7849],
+			},
+		]
+
+		const osm = processRows(rows)
+
+		expect(osm.nodes.size).toBe(4) // 4 unique nodes
+		expect(osm.ways.size).toBe(1)
+		expect(osm.relations.size).toBe(0)
+
+		const way = osm.ways.getById(-1)
+		expect(way).toBeDefined()
+		expect(way?.tags?.["building"]).toBe("yes")
+		expect(way?.tags?.["name"]).toBe("Test Building")
+		expect(way?.tags?.["area"]).toBe("yes")
+		expect(way?.refs).toHaveLength(5) // 4 unique + closing
+		expect(way?.refs[0]).toBe(way?.refs[4]) // Ring is closed
+	})
+
+	it("should convert Polygon with holes to relation with multiple Ways", () => {
+		const rows: GeoParquetRow[] = [
+			{
+				type: "relation",
+				id: undefined as unknown as bigint, // Auto-generate IDs
+				geometry: createPolygonWkb([
+					// Outer ring
+					[
+						[-122.4194, 37.7749],
+						[-122.4094, 37.7749],
+						[-122.4094, 37.7849],
+						[-122.4194, 37.7849],
+						[-122.4194, 37.7749],
+					],
+					// Hole
+					[
+						[-122.4164, 37.7779],
+						[-122.4144, 37.7779],
+						[-122.4144, 37.7799],
+						[-122.4164, 37.7799],
+						[-122.4164, 37.7779],
+					],
+				]),
+				tags: { building: "yes" },
+				bbox: [-122.4194, 37.7749, -122.4094, 37.7849],
+			},
+		]
+
+		const osm = processRows(rows)
+
+		expect(osm.ways.size).toBe(2)
+		expect(osm.relations.size).toBe(1)
+
+		// Get ways by index since IDs are auto-generated
+		const outerWay = osm.ways.getByIndex(0)
+		expect(outerWay).toBeDefined()
+		expect(outerWay?.tags?.["area"]).toBe("yes")
+		expect(outerWay?.tags?.["building"]).toBeUndefined() // Tags go on relation
+
+		const holeWay = osm.ways.getByIndex(1)
+		expect(holeWay).toBeDefined()
+		expect(holeWay?.tags?.["area"]).toBe("yes")
+
+		const relation = osm.relations.getById(-1)
+		expect(relation).toBeDefined()
+		expect(relation?.tags?.["type"]).toBe("multipolygon")
+		expect(relation?.tags?.["building"]).toBe("yes")
+		expect(relation?.members).toHaveLength(2)
+		expect(relation?.members[0]?.type).toBe("way")
+		expect(relation?.members[0]?.role).toBe("outer")
+		expect(relation?.members[1]?.type).toBe("way")
+		expect(relation?.members[1]?.role).toBe("inner")
+	})
+
+	it("should handle JSON string tags", () => {
+		const rows: GeoParquetRow[] = [
+			{
+				type: "node",
+				id: undefined as unknown as bigint,
+				geometry: createPointWkb(-122.4194, 37.7749),
+				tags: '{"name":"Test","highway":"primary"}',
+				bbox: [-122.4194, 37.7749, -122.4194, 37.7749],
+			},
+		]
+
+		const osm = processRows(rows)
+
+		const node = osm.nodes.getById(-1)
+		expect(node?.tags?.["name"]).toBe("Test")
+		expect(node?.tags?.["highway"]).toBe("primary")
+	})
+
+	it("should handle null tags", () => {
+		const rows: GeoParquetRow[] = [
+			{
+				type: "node",
+				id: undefined as unknown as bigint,
+				geometry: createPointWkb(-122.4194, 37.7749),
+				tags: null as unknown as string,
+				bbox: [-122.4194, 37.7749, -122.4194, 37.7749],
+			},
+		]
+
+		const osm = processRows(rows)
+
+		const node = osm.nodes.getById(-1)
+		expect(node?.tags).toBeUndefined()
+	})
+
+	it("should skip rows with missing geometry", () => {
+		const rows: GeoParquetRow[] = [
+			{
+				type: "node",
+				id: undefined as unknown as bigint,
+				geometry: undefined as unknown as Uint8Array,
+				tags: { name: "Missing geometry" },
+				bbox: [0, 0, 0, 0],
+			},
+			{
+				type: "node",
+				id: undefined as unknown as bigint,
+				geometry: createPointWkb(-122.4194, 37.7749),
+				tags: { name: "Valid point" },
+				bbox: [-122.4194, 37.7749, -122.4194, 37.7749],
+			},
+		]
+
+		const osm = processRows(rows)
+
+		expect(osm.nodes.size).toBe(1)
+		const node = osm.nodes.getById(-1)
+		expect(node?.tags?.["name"]).toBe("Valid point")
+	})
+
+	it("should reuse nodes when features share coordinates", () => {
+		const rows: GeoParquetRow[] = [
+			{
+				type: "way",
+				id: undefined as unknown as bigint,
+				geometry: createLineStringWkb([
+					[-122.4194, 37.7749],
+					[-122.4094, 37.7849],
+				]),
+				tags: { highway: "primary" },
+				bbox: [-122.4194, 37.7749, -122.4094, 37.7849],
+			},
+			{
+				type: "way",
+				id: undefined as unknown as bigint,
+				geometry: createLineStringWkb([
+					[-122.4094, 37.7849], // Shared coordinate
+					[-122.3994, 37.7949],
+				]),
+				tags: { highway: "secondary" },
+				bbox: [-122.4094, 37.7849, -122.3994, 37.7949],
+			},
+		]
+
+		const osm = processRows(rows)
+
+		// Should have 3 nodes (shared coordinate is reused)
+		expect(osm.nodes.size).toBe(3)
+		expect(osm.ways.size).toBe(2)
+
+		const way1 = osm.ways.getById(-1)
+		const way2 = osm.ways.getById(-2)
+
+		expect(way1?.refs).toHaveLength(2)
+		expect(way2?.refs).toHaveLength(2)
+		// Shared node
+		expect(way1?.refs[1]).toBe(way2?.refs[0])
+	})
+
+	it("should build indexes after processing", () => {
+		const rows: GeoParquetRow[] = [
+			{
+				type: "node",
+				id: undefined as unknown as bigint,
+				geometry: createPointWkb(-122.4194, 37.7749),
+				tags: { name: "Test" },
+				bbox: [-122.4194, 37.7749, -122.4194, 37.7749],
+			},
+		]
+
+		const osm = processRows(rows)
+
+		expect(osm.isReady()).toBe(true)
+		expect(osm.nodes.isReady()).toBe(true)
+		expect(osm.ways.isReady()).toBe(true)
+	})
+
+	it("should handle object tags", () => {
+		const rows: GeoParquetRow[] = [
+			{
+				type: "node",
+				id: undefined as unknown as bigint,
+				geometry: createPointWkb(-122.4194, 37.7749),
+				tags: { name: "Test", highway: "primary" },
+				bbox: [-122.4194, 37.7749, -122.4194, 37.7749],
+			},
+		]
+
+		const osm = processRows(rows)
+
+		const node = osm.nodes.getById(-1)
+		expect(node?.tags?.["name"]).toBe("Test")
+		expect(node?.tags?.["highway"]).toBe("primary")
+	})
+
+	it("should handle custom column names", () => {
+		const rows = [
+			{
+				type: "node",
+				osm_id: undefined,
+				geom: createPointWkb(-122.4194, 37.7749),
+				properties: { name: "Custom columns" },
+				bbox: [-122.4194, 37.7749, -122.4194, 37.7749],
+			},
+		] as unknown as GeoParquetRow[]
+
+		const osm = processRows(rows, {
+			idColumn: "osm_id",
+			geometryColumn: "geom",
+			tagsColumn: "properties",
+		})
+
+		expect(osm.nodes.size).toBe(1)
+		const node = osm.nodes.getById(-1)
+		expect(node?.tags?.["name"]).toBe("Custom columns")
+	})
+
+	it("should infer type from geometry when type column is missing", () => {
+		// Simple polygon without holes - should only create a way, not a relation
+		const simplePolygonRows: GeoParquetRow[] = [
+			{
+				type: undefined as unknown as "way", // Missing type
+				id: 123n,
+				geometry: createPolygonWkb([
+					[
+						[-122.4194, 37.7749],
+						[-122.4094, 37.7749],
+						[-122.4094, 37.7849],
+						[-122.4194, 37.7849],
+						[-122.4194, 37.7749],
+					],
+				]),
+				tags: { building: "yes" },
+				bbox: [-122.4194, 37.7749, -122.4094, 37.7849],
+			},
+		]
+
+		const osm1 = processRows(simplePolygonRows)
+
+		// Should create just a way, no relation
+		expect(osm1.ways.size).toBe(1)
+		expect(osm1.relations.size).toBe(0)
+
+		// Way should have the feature ID and tags
+		const way = osm1.ways.getById(123)
+		expect(way).toBeDefined()
+		expect(way?.tags?.["building"]).toBe("yes")
+		expect(way?.tags?.["area"]).toBe("yes")
+	})
+
+	it("should infer relation type for polygon with holes when type is missing", () => {
+		// Polygon with hole - should create a relation
+		const polygonWithHoleRows: GeoParquetRow[] = [
+			{
+				type: undefined as unknown as "relation", // Missing type
+				id: 456n,
+				geometry: createPolygonWkb([
+					// Outer ring
+					[
+						[-122.4194, 37.7749],
+						[-122.4094, 37.7749],
+						[-122.4094, 37.7849],
+						[-122.4194, 37.7849],
+						[-122.4194, 37.7749],
+					],
+					// Hole
+					[
+						[-122.4164, 37.7779],
+						[-122.4144, 37.7779],
+						[-122.4144, 37.7799],
+						[-122.4164, 37.7799],
+						[-122.4164, 37.7779],
+					],
+				]),
+				tags: { building: "yes" },
+				bbox: [-122.4194, 37.7749, -122.4094, 37.7849],
+			},
+		]
+
+		const osm2 = processRows(polygonWithHoleRows)
+
+		// Should create 2 ways (outer + hole) and 1 relation
+		expect(osm2.ways.size).toBe(2)
+		expect(osm2.relations.size).toBe(1)
+
+		// Relation should have the feature ID and tags
+		const relation = osm2.relations.getById(456)
+		expect(relation).toBeDefined()
+		expect(relation?.tags?.["type"]).toBe("multipolygon")
+		expect(relation?.tags?.["building"]).toBe("yes")
+		expect(relation?.members).toHaveLength(2)
+		expect(relation?.members[0]?.role).toBe("outer")
+		expect(relation?.members[1]?.role).toBe("inner")
+
+		// Ways should not have the feature ID (456 goes to relation)
+		const outerWay = osm2.ways.getByIndex(0)
+		expect(outerWay?.id).not.toBe(456)
+	})
+})

package/test/monaco-parquet.test.ts

@@ -0,0 +1,249 @@
+import { describe, expect, it } from "bun:test"
+import { getFixturePath } from "@osmix/shared/fixtures"
+import { fromGeoParquet, GeoParquetOsmBuilder } from "../src"
+
+/**
+ * Integration tests using the Monaco highways GeoParquet fixture.
+ *
+ * The fixture was downloaded from LayerCake (https://openstreetmap.us/our-work/layercake/)
+ * using DuckDB with a bounding box filter for Monaco. The fixture has a flattened
+ * structure where each tag column is separate (highway, name, surface, etc.) rather
+ * than nested in a tags struct.
+ *
+ * Note: hyparquet automatically parses GeoParquet WKB geometry into GeoJSON objects.
+ *
+ * Monaco bounding box:
+ * - xmin: 7.409205, xmax: 7.448637
+ * - ymin: 43.72335, ymax: 43.75169
+ */
+
+describe("@osmix/geoparquet: Monaco highways fixture", () => {
+	const fixtureFile = () => Bun.file(getFixturePath("monaco.parquet"))
+	const getOsm = async () => fromGeoParquet(await fixtureFile().arrayBuffer())
+
+	it("should load the monaco.parquet fixture", async () => {
+		const file = fixtureFile()
+		expect(await file.exists()).toBe(true)
+
+		const size = file.size
+		expect(size).toBeGreaterThan(0)
+		expect(size).toBeLessThan(1_000_000) // Should be a small fixture
+	})
+
+	it("should read parquet rows with correct structure", async () => {
+		const builder = new GeoParquetOsmBuilder({ id: "monaco" }, { rowEnd: 5 })
+		const rows = await builder.readParquetRows(
+			await fixtureFile().arrayBuffer(),
+		)
+
+		expect(rows.length).toBe(5)
+
+		// Verify row structure
+		const firstRow = rows[0]!
+		expect(firstRow["id"]).toBeDefined()
+		expect(firstRow["geometry"]).toBeDefined()
+		// expect(firstRow.osm_type).toBeDefined()
+
+		// hyparquet parses GeoParquet WKB into GeoJSON automatically
+		expect(firstRow["geometry"].type).toBeDefined()
+		// Verify it's a geometry with coordinates (not a GeometryCollection)
+		expect(["Point", "LineString", "Polygon", "MultiPolygon"]).toContain(
+			firstRow["geometry"].type,
+		)
+	})
+
+	it("should convert highway features to OSM entities", async () => {
+		const osm = await getOsm()
+
+		// Should have created nodes and ways from the highway features
+		expect(osm.nodes.size).toBeGreaterThan(0)
+		expect(osm.ways.size).toBeGreaterThan(0)
+
+		// Monaco is small, so we expect reasonable numbers
+		// The highway extract should have a few hundred to a few thousand ways
+		expect(osm.ways.size).toBeGreaterThan(100)
+		expect(osm.ways.size).toBeLessThan(10_000)
+	})
+
+	it("should preserve highway tags from GeoParquet columns", async () => {
+		const osm = await getOsm()
+
+		// Find ways with highway tags
+		let highwayCount = 0
+		for (let i = 0; i < osm.ways.size; i++) {
+			const way = osm.ways.getByIndex(i)
+			if (way?.tags?.["highway"]) {
+				highwayCount++
+			}
+		}
+
+		// Most features should have highway tags since this is the highways layer
+		expect(highwayCount).toBeGreaterThan(0)
+	})
+
+	it("should have valid node coordinates within Monaco bounds", async () => {
+		const osm = await getOsm()
+
+		// Monaco bounding box (slightly expanded for node positions)
+		const minLon = 7.4
+		const maxLon = 7.45
+		const minLat = 43.72
+		const maxLat = 43.76
+
+		// Check that all nodes are within Monaco bounds
+		let validNodes = 0
+		for (let i = 0; i < osm.nodes.size; i++) {
+			const node = osm.nodes.getByIndex(i)
+			if (node) {
+				expect(node.lon).toBeGreaterThanOrEqual(minLon)
+				expect(node.lon).toBeLessThanOrEqual(maxLon)
+				expect(node.lat).toBeGreaterThanOrEqual(minLat)
+				expect(node.lat).toBeLessThanOrEqual(maxLat)
+				validNodes++
+			}
+		}
+
+		expect(validNodes).toBeGreaterThan(0)
+	})
+
+	it("should build spatial indexes after loading", async () => {
+		const osm = await getOsm()
+
+		// Indexes should be built
+		expect(osm.isReady()).toBe(true)
+		expect(osm.nodes.isReady()).toBe(true)
+		expect(osm.ways.isReady()).toBe(true)
+	})
+
+	it("should handle ways with multiple nodes", async () => {
+		const osm = await getOsm()
+		// Count ways with enough nodes
+		let validWays = 0
+		for (let i = 0; i < osm.ways.size; i++) {
+			const way = osm.ways.getByIndex(i)
+			if (way && way.refs.length >= 2) {
+				validWays++
+				// All node refs should resolve to actual nodes
+				for (const ref of way.refs) {
+					const node = osm.nodes.getById(ref)
+					expect(node).toBeDefined()
+				}
+			}
+		}
+
+		// Most ways should have at least 2 nodes (minimum for a LineString)
+		expect(validWays).toBeGreaterThan(0)
+	})
+
+	it("should handle maxRows option to limit features", async () => {
+		const builder = new GeoParquetOsmBuilder({ id: "monaco" }, { rowEnd: 10 })
+		const rows = await builder.readParquetRows(
+			await fixtureFile().arrayBuffer(),
+		)
+		builder.processGeoParquetRows(rows)
+		const osm = builder.buildOsm()
+
+		// Should only have processed 10 features
+		expect(rows.length).toBe(10)
+		// Note: Some rows may be Point geometries (crossings) which don't create ways
+		expect(osm.nodes.size + osm.ways.size).toBeGreaterThan(0)
+	})
+
+	it("should find common highway types in Monaco", async () => {
+		const osm = await getOsm()
+
+		const highwayTypes = new Map<string, number>()
+
+		for (let i = 0; i < osm.ways.size; i++) {
+			const way = osm.ways.getByIndex(i)
+			const highway = way?.tags?.["highway"]
+			if (highway && typeof highway === "string") {
+				highwayTypes.set(highway, (highwayTypes.get(highway) ?? 0) + 1)
+			}
+		}
+
+		// Monaco should have some common highway types
+		const allTypes = Array.from(highwayTypes.keys())
+		expect(allTypes.length).toBeGreaterThan(0)
+
+		// Common types that should exist in Monaco's dense urban area
+		const commonTypes = ["residential", "footway", "service", "path", "steps"]
+		const foundCommonTypes = commonTypes.filter((t) => highwayTypes.has(t))
+
+		// At least some common types should be present
+		expect(foundCommonTypes.length).toBeGreaterThan(0)
+	})
+
+	it("should handle surface and other highway attributes", async () => {
+		const osm = await getOsm()
+
+		// Check that some ways have additional attributes beyond just highway
+		let waysWithSurface = 0
+		let waysWithName = 0
+
+		for (let i = 0; i < osm.ways.size; i++) {
+			const way = osm.ways.getByIndex(i)
+			if (way?.tags) {
+				if (way.tags["surface"]) waysWithSurface++
+				if (way.tags["name"]) waysWithName++
+			}
+		}
+
+		// Some highways should have surface or name attributes
+		// (not all will, so we just check that at least some do)
+		expect(waysWithSurface + waysWithName).toBeGreaterThan(0)
+	})
+
+	it("should reuse nodes for connected highways", async () => {
+		const osm = await getOsm()
+
+		// Count how many ways reference the same nodes
+		const nodeRefCounts = new Map<number, number>()
+
+		for (let i = 0; i < osm.ways.size; i++) {
+			const way = osm.ways.getByIndex(i)
+			if (way) {
+				for (const ref of way.refs) {
+					nodeRefCounts.set(ref, (nodeRefCounts.get(ref) ?? 0) + 1)
+				}
+			}
+		}
+
+		// Some nodes should be shared between multiple ways (intersections)
+		const sharedNodes = Array.from(nodeRefCounts.values()).filter((c) => c > 1)
+		expect(sharedNodes.length).toBeGreaterThan(0)
+	})
+
+	it("should handle Point geometries (crossings)", async () => {
+		const osm = await getOsm()
+
+		// Find nodes with crossing tags (Point features become Nodes with tags)
+		let crossingCount = 0
+		for (let i = 0; i < osm.nodes.size; i++) {
+			const node = osm.nodes.getByIndex(i)
+			if (node?.tags?.["highway"] === "crossing") {
+				crossingCount++
+			}
+		}
+
+		// Monaco should have some pedestrian crossings
+		expect(crossingCount).toBeGreaterThan(0)
+	})
+
+	it("should count geometry types in the fixture", async () => {
+		const builder = new GeoParquetOsmBuilder({ id: "monaco" })
+		const rows = await builder.readParquetRows(
+			await fixtureFile().arrayBuffer(),
+		)
+
+		const typeCounts = new Map<string, number>()
+		for (const row of rows) {
+			const type = row["geometry"]?.type ?? "unknown"
+			typeCounts.set(type, (typeCounts.get(type) ?? 0) + 1)
+		}
+
+		// Highways layer should have mostly LineStrings (roads) and some Points (crossings)
+		expect(typeCounts.get("LineString") ?? 0).toBeGreaterThan(0)
+		expect(typeCounts.get("Point") ?? 0).toBeGreaterThan(0)
+	})
+})

package/test/wkb.test.ts

@@ -0,0 +1,296 @@
+import { describe, expect, it } from "bun:test"
+import { parseWkb } from "../src/wkb"
+
+/**
+ * Helper to create a WKB Point with properly encoded float64 coordinates.
+ */
+function createPointWkb(
+	lon: number,
+	lat: number,
+	littleEndian = true,
+): Uint8Array {
+	const buffer = new ArrayBuffer(21)
+	const view = new DataView(buffer)
+	let offset = 0
+
+	view.setUint8(offset, littleEndian ? 1 : 0)
+	offset += 1
+	view.setUint32(offset, 1, littleEndian) // Point type
+	offset += 4
+	view.setFloat64(offset, lon, littleEndian)
+	offset += 8
+	view.setFloat64(offset, lat, littleEndian)
+
+	return new Uint8Array(buffer)
+}
+
+describe("@osmix/geoparquet: WKB Parser", () => {
+	it("should parse a Point geometry (little endian)", () => {
+		const wkb = createPointWkb(-122.4194, 37.7749, true)
+
+		const geometry = parseWkb(wkb)
+
+		expect(geometry.type).toBe("Point")
+		if (geometry.type === "Point") {
+			expect(geometry.coordinates[0]).toBeCloseTo(-122.4194, 4)
+			expect(geometry.coordinates[1]).toBeCloseTo(37.7749, 4)
+		}
+	})
+
+	it("should parse a Point geometry (big endian)", () => {
+		const wkb = createPointWkb(-122.4194, 37.7749, false)
+
+		const geometry = parseWkb(wkb)
+
+		expect(geometry.type).toBe("Point")
+		if (geometry.type === "Point") {
+			expect(geometry.coordinates[0]).toBeCloseTo(-122.4194, 4)
+			expect(geometry.coordinates[1]).toBeCloseTo(37.7749, 4)
+		}
+	})
+
+	it("should parse a LineString geometry", () => {
+		// WKB LineString with 3 points
+		const buffer = new ArrayBuffer(1 + 4 + 4 + 3 * 16)
+		const view = new DataView(buffer)
+		let offset = 0
+
+		// Byte order: little endian
+		view.setUint8(offset, 1)
+		offset += 1
+
+		// Geometry type: LineString (2)
+		view.setUint32(offset, 2, true)
+		offset += 4
+
+		// Number of points: 3
+		view.setUint32(offset, 3, true)
+		offset += 4
+
+		// Point 1: -122.4194, 37.7749
+		view.setFloat64(offset, -122.4194, true)
+		offset += 8
+		view.setFloat64(offset, 37.7749, true)
+		offset += 8
+
+		// Point 2: -122.4094, 37.7849
+		view.setFloat64(offset, -122.4094, true)
+		offset += 8
+		view.setFloat64(offset, 37.7849, true)
+		offset += 8
+
+		// Point 3: -122.3994, 37.7949
+		view.setFloat64(offset, -122.3994, true)
+		offset += 8
+		view.setFloat64(offset, 37.7949, true)
+
+		const wkb = new Uint8Array(buffer)
+		const geometry = parseWkb(wkb)
+
+		expect(geometry.type).toBe("LineString")
+		if (geometry.type === "LineString") {
+			expect(geometry.coordinates).toHaveLength(3)
+			expect(geometry.coordinates[0]?.[0]).toBeCloseTo(-122.4194, 4)
+			expect(geometry.coordinates[0]?.[1]).toBeCloseTo(37.7749, 4)
+			expect(geometry.coordinates[1]?.[0]).toBeCloseTo(-122.4094, 4)
+			expect(geometry.coordinates[1]?.[1]).toBeCloseTo(37.7849, 4)
+			expect(geometry.coordinates[2]?.[0]).toBeCloseTo(-122.3994, 4)
+			expect(geometry.coordinates[2]?.[1]).toBeCloseTo(37.7949, 4)
+		}
+	})
+
+	it("should parse a Polygon geometry", () => {
+		// WKB Polygon with 1 ring of 5 points (closed)
+		const buffer = new ArrayBuffer(1 + 4 + 4 + 4 + 5 * 16)
+		const view = new DataView(buffer)
+		let offset = 0
+
+		// Byte order: little endian
+		view.setUint8(offset, 1)
+		offset += 1
+
+		// Geometry type: Polygon (3)
+		view.setUint32(offset, 3, true)
+		offset += 4
+
+		// Number of rings: 1
+		view.setUint32(offset, 1, true)
+		offset += 4
+
+		// Number of points in ring: 5
+		view.setUint32(offset, 5, true)
+		offset += 4
+
+		// Points (closed ring)
+		const coords = [
+			[-122.4194, 37.7749],
+			[-122.4094, 37.7749],
+			[-122.4094, 37.7849],
+			[-122.4194, 37.7849],
+			[-122.4194, 37.7749], // closed
+		]
+
+		for (const [lon, lat] of coords) {
+			view.setFloat64(offset, lon!, true)
+			offset += 8
+			view.setFloat64(offset, lat!, true)
+			offset += 8
+		}
+
+		const wkb = new Uint8Array(buffer)
+		const geometry = parseWkb(wkb)
+
+		expect(geometry.type).toBe("Polygon")
+		if (geometry.type === "Polygon") {
+			expect(geometry.coordinates).toHaveLength(1)
+			expect(geometry.coordinates[0]).toHaveLength(5)
+			expect(geometry.coordinates[0]?.[0]?.[0]).toBeCloseTo(-122.4194, 4)
+			expect(geometry.coordinates[0]?.[0]?.[1]).toBeCloseTo(37.7749, 4)
+		}
+	})
+
+	it("should parse a MultiPolygon geometry", () => {
+		// Helper to create polygon WKB
+		const createPolygonWkb = (
+			coords: [number, number][][],
+		): [ArrayBuffer, number] => {
+			const totalPoints = coords.reduce((sum, ring) => sum + ring.length, 0)
+			const size = 1 + 4 + 4 + coords.length * 4 + totalPoints * 16
+			const buffer = new ArrayBuffer(size)
+			const view = new DataView(buffer)
+			let offset = 0
+
+			// Byte order
+			view.setUint8(offset, 1)
+			offset += 1
+
+			// Polygon type
+			view.setUint32(offset, 3, true)
+			offset += 4
+
+			// Number of rings
+			view.setUint32(offset, coords.length, true)
+			offset += 4
+
+			for (const ring of coords) {
+				view.setUint32(offset, ring.length, true)
+				offset += 4
+				for (const [lon, lat] of ring) {
+					view.setFloat64(offset, lon, true)
+					offset += 8
+					view.setFloat64(offset, lat, true)
+					offset += 8
+				}
+			}
+
+			return [buffer, size]
+		}
+
+		// Create MultiPolygon with 2 polygons
+		const poly1Coords: [number, number][][] = [
+			[
+				[-122.4194, 37.7749],
+				[-122.4094, 37.7749],
+				[-122.4094, 37.7849],
+				[-122.4194, 37.7849],
+				[-122.4194, 37.7749],
+			],
+		]
+
+		const poly2Coords: [number, number][][] = [
+			[
+				[-122.3994, 37.7649],
+				[-122.3894, 37.7649],
+				[-122.3894, 37.7749],
+				[-122.3994, 37.7749],
+				[-122.3994, 37.7649],
+			],
+		]
+
+		const [poly1Buffer, poly1Size] = createPolygonWkb(poly1Coords)
+		const [poly2Buffer, poly2Size] = createPolygonWkb(poly2Coords)
+
+		// MultiPolygon header + 2 polygons
+		const multiBuffer = new ArrayBuffer(1 + 4 + 4 + poly1Size + poly2Size)
+		const multiView = new DataView(multiBuffer)
+		let offset = 0
+
+		// Byte order
+		multiView.setUint8(offset, 1)
+		offset += 1
+
+		// MultiPolygon type (6)
+		multiView.setUint32(offset, 6, true)
+		offset += 4
+
+		// Number of geometries
+		multiView.setUint32(offset, 2, true)
+		offset += 4
+
+		// Copy polygon 1
+		new Uint8Array(multiBuffer, offset, poly1Size).set(
+			new Uint8Array(poly1Buffer),
+		)
+		offset += poly1Size
+
+		// Copy polygon 2
+		new Uint8Array(multiBuffer, offset, poly2Size).set(
+			new Uint8Array(poly2Buffer),
+		)
+
+		const wkb = new Uint8Array(multiBuffer)
+		const geometry = parseWkb(wkb)
+
+		expect(geometry.type).toBe("MultiPolygon")
+		if (geometry.type === "MultiPolygon") {
+			expect(geometry.coordinates).toHaveLength(2)
+			expect(geometry.coordinates[0]).toHaveLength(1)
+			expect(geometry.coordinates[1]).toHaveLength(1)
+		}
+	})
+
+	it("should handle EWKB with SRID flag", () => {
+		// EWKB Point with SRID (SRID flag: 0x20000000)
+		const buffer = new ArrayBuffer(1 + 4 + 4 + 16)
+		const view = new DataView(buffer)
+		let offset = 0
+
+		// Byte order: little endian
+		view.setUint8(offset, 1)
+		offset += 1
+
+		// Geometry type: Point (1) with SRID flag (0x20000001)
+		view.setUint32(offset, 0x20000001, true)
+		offset += 4
+
+		// SRID: 4326
+		view.setUint32(offset, 4326, true)
+		offset += 4
+
+		// Point: -122.4194, 37.7749
+		view.setFloat64(offset, -122.4194, true)
+		offset += 8
+		view.setFloat64(offset, 37.7749, true)
+
+		const wkb = new Uint8Array(buffer)
+		const geometry = parseWkb(wkb)
+
+		expect(geometry.type).toBe("Point")
+		if (geometry.type === "Point") {
+			expect(geometry.coordinates[0]).toBeCloseTo(-122.4194, 4)
+			expect(geometry.coordinates[1]).toBeCloseTo(37.7749, 4)
+		}
+	})
+
+	it("should throw on unsupported geometry type", () => {
+		const wkb = new Uint8Array([
+			0x01, // little endian
+			0x64,
+			0x00,
+			0x00,
+			0x00, // Invalid type (100)
+		])
+
+		expect(() => parseWkb(wkb)).toThrow("Unsupported WKB geometry type: 100")
+	})
+})

package/tsconfig.build.json

@@ -0,0 +1,5 @@
+{
+	"$schema": "https://json.schemastore.org/tsconfig",
+	"extends": "./tsconfig.json",
+	"include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"$schema": "https://json.schemastore.org/tsconfig",
+	"extends": "@osmix/shared/tsconfig/base.json",
+	"exclude": ["node_modules", "dist"],
+	"include": ["src", "test"],
+	"compilerOptions": {
+		"outDir": "./dist"
+	}
+}