@osmix/core 0.1.10 → 0.3.0

package/test/relations.bench.ts

@@ -0,0 +1,32 @@
+import { describe, test } from "vitest";
+
+import { Osm } from "../src/osm";
+
+function createManyMemberRelations() {
+  const osm = new Osm({ id: "relations-benchmark" });
+  osm.nodes.addNode({ id: 1, lon: 0, lat: 0 });
+  for (let id = 0; id < 10_000; id++) osm.ways.addWay({ id, refs: [1] });
+  for (let relationId = 0; relationId < 100; relationId++) {
+    osm.relations.addRelation({
+      id: relationId,
+      members: Array.from({ length: 100 }, (_, index) => ({
+        type: "way" as const,
+        ref: relationId * 100 + index,
+        role: "",
+      })),
+    });
+  }
+  osm.buildIndexes();
+  return osm;
+}
+
+const osm = createManyMemberRelations();
+osm.relations.isWayMember(0);
+
+describe("relation way membership cache", () => {
+  test("1000 repeated cached lookups", async ({ bench }) => {
+    await bench("1000 repeated cached lookups", () => {
+      for (let i = 0; i < 1000; i++) osm.relations.isWayMember(i);
+    }).run();
+  });
+});

package/test/relations.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { Osm, type Osm as OsmType } from "../src/osm";
+
+function createOsmWithRelations(): OsmType {
+  const osm = new Osm({ id: "relations" });
+  osm.nodes.addNode({ id: 1, lon: -120, lat: 46 });
+  osm.nodes.addNode({ id: 2, lon: -120.01, lat: 46.01 });
+  osm.nodes.addNode({ id: 3, lon: -120.02, lat: 46.02 });
+  osm.ways.addWay({ id: 10, refs: [1, 2], tags: { highway: "primary" } });
+  osm.ways.addWay({ id: 20, refs: [2, 3], tags: { highway: "secondary" } });
+  osm.relations.addRelation({
+    id: 100,
+    members: [
+      { type: "way", ref: 10, role: "outer" },
+      { type: "node", ref: 1, role: "label" },
+      { type: "way", ref: 10, role: "outer" },
+    ],
+  });
+  osm.relations.addRelation({
+    id: 200,
+    members: [
+      { type: "way", ref: 20, role: "outer" },
+      { type: "relation", ref: 100, role: "child" },
+    ],
+  });
+  osm.buildIndexes();
+  return osm;
+}
+
+/** Way membership for every way in `osm`, as sorted way IDs. */
+function wayMemberIds(osm: OsmType): number[] {
+  const ids: number[] = [];
+  for (let i = 0; i < osm.ways.size; i++) {
+    if (osm.relations.isWayMember(i)) ids.push(osm.ways.ids.at(i));
+  }
+  return ids.sort((a, b) => a - b);
+}
+
+/** Osm with ways 10, 20 and 30 and no relations. */
+function createOsmWithWays(): OsmType {
+  const osm = new Osm();
+  osm.nodes.addNode({ id: 1, lon: 0, lat: 0 });
+  for (const id of [10, 20, 30]) osm.ways.addWay({ id, refs: [1] });
+  return osm;
+}
+
+describe("relation way membership cache", () => {
+  it("reports no members when there are no relations", () => {
+    const osm = createOsmWithWays();
+    osm.buildIndexes();
+
+    expect(wayMemberIds(osm)).toEqual([]);
+  });
+
+  it("collects unique direct and nested way members", () => {
+    expect(wayMemberIds(createOsmWithRelations())).toEqual([10, 20]);
+  });
+
+  it("does not traverse relations again while the cache is warm", () => {
+    const osm = createOsmWithRelations();
+    const getByIndex = vi.spyOn(osm.relations, "getByIndex");
+
+    osm.relations.isWayMember(0);
+    const callsAfterFirstLookup = getByIndex.mock.calls.length;
+    osm.relations.isWayMember(1);
+
+    expect(callsAfterFirstLookup).toBeGreaterThan(0);
+    expect(getByIndex).toHaveBeenCalledTimes(callsAfterFirstLookup);
+  });
+
+  // Relations cannot be added after their ID index is built, so these tests only index nodes and
+  // ways. Membership resolution without nested relations never consults the relation ID index.
+  it("invalidates the cache when a relation is added", () => {
+    const osm = createOsmWithWays();
+    osm.nodes.buildIndex();
+    osm.ways.buildIndex();
+    osm.relations.addRelation({ id: 1, members: [{ type: "way", ref: 10, role: "" }] });
+    expect(wayMemberIds(osm)).toEqual([10]);
+
+    osm.relations.addRelation({ id: 2, members: [{ type: "way", ref: 20, role: "" }] });
+
+    expect(wayMemberIds(osm)).toEqual([10, 20]);
+  });
+
+  it("invalidates the cache when relations are added in bulk", () => {
+    const osm = createOsmWithWays();
+    osm.stringTable.add("");
+    osm.nodes.buildIndex();
+    osm.ways.buildIndex();
+    osm.relations.addRelation({ id: 1, members: [{ type: "way", ref: 10, role: "" }] });
+    expect(wayMemberIds(osm)).toEqual([10]);
+
+    osm.relations.addRelations(
+      [{ id: 2, keys: [], vals: [], memids: [20], roles_sid: [0], types: [1] }],
+      new Uint32Array([0]),
+    );
+
+    expect(wayMemberIds(osm)).toEqual([10, 20]);
+  });
+
+  it("ignores way members that are not in the dataset", () => {
+    const osm = createOsmWithWays();
+    osm.relations.addRelation({
+      id: 1,
+      members: [
+        { type: "way", ref: 30, role: "" },
+        { type: "way", ref: 99, role: "" },
+      ],
+    });
+    osm.buildIndexes();
+
+    expect(wayMemberIds(osm)).toEqual([30]);
+  });
+
+  it("starts with an empty cache after transfer and reconstruction", () => {
+    const source = createOsmWithRelations();
+    const reconstructed = new Osm(source);
+    const getByIndex = vi.spyOn(reconstructed.relations, "getByIndex");
+
+    expect(wayMemberIds(reconstructed)).toEqual([10, 20]);
+    expect(getByIndex.mock.calls.length).toBeGreaterThan(0);
+  });
+});

package/test/renumber.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+
+import { Osm } from "../src/osm.ts";
+import { renumberNegativeIds } from "../src/renumber.ts";
+
+function mixedIds() {
+  const osm = new Osm({ id: "mixed" });
+  osm.nodes.addNode({ id: 5, lon: 0, lat: 0 });
+  osm.nodes.addNode({ id: -1, lon: 0.001, lat: 0, tags: { name: "New entrance" } });
+  osm.nodes.addNode({ id: -2, lon: 0.002, lat: 0 });
+  osm.ways.addWay({ id: 7, refs: [5, -1], tags: { highway: "footway" } });
+  osm.ways.addWay({ id: -3, refs: [-1, -2], tags: { highway: "footway" } });
+  osm.relations.addRelation({
+    id: -1,
+    members: [
+      { type: "node", ref: -2, role: "stop" },
+      { type: "way", ref: -3, role: "" },
+      { type: "way", ref: 7, role: "" },
+    ],
+    tags: { type: "route" },
+  });
+  osm.buildIndexes();
+  osm.buildSpatialIndexes();
+  return osm;
+}
+
+describe("renumberNegativeIds", () => {
+  it("gives each type's negative IDs new ones after its highest ID and follows every reference", () => {
+    const input = mixedIds();
+    const { osm, idMap } = renumberNegativeIds(input);
+    expect(idMap).toEqual({
+      nodes: { "-1": 6, "-2": 7 },
+      ways: { "-3": 8 },
+      relations: { "-1": 1 },
+    });
+    expect(osm.nodes.getById(6)?.tags).toEqual({ name: "New entrance" });
+    expect(osm.ways.getById(7)?.refs).toEqual([5, 6]);
+    expect(osm.ways.getById(8)?.refs).toEqual([6, 7]);
+    expect(osm.relations.getById(1)?.members.map((member) => member.ref)).toEqual([7, 8, 7]);
+    expect([...osm.nodes].every((node) => node.id > 0)).toBe(true);
+    // The input keeps its IDs.
+    expect(input.nodes.getById(-1)).not.toBeNull();
+  });
+
+  it("is deterministic and a no-op without negative IDs", () => {
+    expect(renumberNegativeIds(mixedIds()).idMap).toEqual(renumberNegativeIds(mixedIds()).idMap);
+    const positive = new Osm({ id: "positive" });
+    positive.nodes.addNode({ id: 1, lon: 0, lat: 0 });
+    positive.buildIndexes();
+    const { osm, idMap } = renumberNegativeIds(positive);
+    expect(idMap).toEqual({ nodes: {}, ways: {}, relations: {} });
+    expect([...osm.nodes]).toEqual([...positive.nodes]);
+  });
+});

package/test/spatial-index-rebuild.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+
+import { Osm } from "../src/osm.ts";
+
+function buildIndexedOsm() {
+  const osm = new Osm();
+  osm.nodes.addNode({ id: 1, lon: 0, lat: 0 });
+  osm.nodes.addNode({ id: 2, lon: 1, lat: 1 });
+  osm.ways.addWay({ id: 10, refs: [1, 2], tags: { highway: "path" } });
+  osm.relations.addRelation({
+    id: 100,
+    members: [{ type: "way", ref: 10, role: "" }],
+    tags: { type: "route" },
+  });
+  osm.buildIndexes();
+  osm.buildSpatialIndexes();
+  return osm;
+}
+
+describe("spatial index rebuilds", () => {
+  it("reuses built way and relation indexes", () => {
+    const osm = buildIndexedOsm();
+    const waysIndex = osm.ways.buildSpatialIndex();
+    const relationsIndex = osm.relations.buildSpatialIndex();
+
+    osm.buildSpatialIndexes();
+
+    expect(osm.ways.buildSpatialIndex()).toBe(waysIndex);
+    expect(osm.relations.buildSpatialIndex()).toBe(relationsIndex);
+    expect(osm.ways.intersects([-1, -1, 2, 2])).toEqual([0]);
+    expect(osm.relations.intersects([-1, -1, 2, 2])).toEqual([0]);
+  });
+});

package/test/storage-compaction.test.ts

@@ -0,0 +1,269 @@
+import { inspectBackingBuffers } from "@osmix/shared/backing-buffers";
+import { describe, expect, it } from "vitest";
+
+import { OSM_CONTENT_HASH_VERSION, OSM_TRANSFER_VERSION, Osm } from "../src/osm.ts";
+import StringTable from "../src/stringtable.ts";
+import { Tags } from "../src/tags.ts";
+
+describe("sparse tag storage", () => {
+  it("rejects duplicate and out-of-order tagged entity indexes", () => {
+    const tags = new Tags(new StringTable());
+    tags.addTagKeysAndValues(2, [0], [1]);
+
+    expect(() => tags.addTagKeysAndValues(2, [0], [1])).toThrow(/added out of order/);
+    expect(() => tags.addTagKeysAndValues(1, [0], [1])).toThrow(/added out of order/);
+  });
+
+  it("preserves tags across rank boundaries and supports more than 255 tags", () => {
+    const osm = new Osm({ id: "sparse-tags" });
+    const manyTags = Object.fromEntries(
+      Array.from({ length: 300 }, (_, index) => [`key-${index}`, `value-${index}`]),
+    );
+    const taggedIndexes = new Set([0, 255, 256, 511, 512]);
+
+    for (let index = 0; index <= 512; index++) {
+      osm.nodes.addNode({
+        id: index + 1,
+        lon: index / 10,
+        lat: index / 20,
+        tags: index === 0 ? manyTags : taggedIndexes.has(index) ? { boundary: `${index}` } : {},
+      });
+    }
+    osm.buildIndexes();
+
+    expect(osm.nodes.tags.cardinality(0)).toBe(300);
+    expect(osm.nodes.tags.cardinality(1)).toBe(0);
+    expect(osm.nodes.tags.cardinality(255)).toBe(1);
+    expect(osm.nodes.tags.cardinality(256)).toBe(1);
+    expect(osm.nodes.tags.cardinality(511)).toBe(1);
+    expect(osm.nodes.tags.cardinality(512)).toBe(1);
+    expect([...osm.nodes.tags.taggedEntityIndexes()]).toEqual([0, 255, 256, 511, 512]);
+    expect(osm.nodes.tags.taggedEntityCount).toBe(5);
+    expect(Object.keys(osm.nodes.getByIndex(0).tags ?? {})).toHaveLength(300);
+
+    const transferables = osm.transferables();
+    expect(transferables.transferVersion).toBe(OSM_TRANSFER_VERSION);
+    expect(transferables.contentHashVersion).toBe(OSM_CONTENT_HASH_VERSION);
+    expect(transferables.nodes.taggedEntityBits.byteLength).toBe(
+      Math.ceil(513 / 32) * Uint32Array.BYTES_PER_ELEMENT,
+    );
+    expect(transferables.nodes.tagRankCheckpoints.byteLength).toBe(
+      (Math.ceil(513 / 256) + 1) * Uint32Array.BYTES_PER_ELEMENT,
+    );
+    expect(transferables.nodes.tagOffsets.byteLength).toBe(
+      (taggedIndexes.size + 1) * Uint32Array.BYTES_PER_ELEMENT,
+    );
+    expect(osm.info().spatialIndexes).toEqual({
+      nodes: { all: false, tagged: false },
+      ways: false,
+      relations: false,
+    });
+
+    const reconstructed = new Osm(transferables);
+    expect([...reconstructed.nodes.tags.taggedEntityIndexes()]).toEqual([0, 255, 256, 511, 512]);
+    expect(reconstructed.nodes.getByIndex(512).tags).toEqual({ boundary: "512" });
+  });
+
+  it("stores and searches an all-tagged collection across rank boundaries", () => {
+    const osm = new Osm({ id: "all-tagged" });
+    const entityCount = 257;
+
+    for (let index = 0; index < entityCount; index++) {
+      osm.nodes.addNode({
+        id: index + 1,
+        lon: index / 10,
+        lat: index / 20,
+        tags: { shared: index % 2 === 0 ? "even" : "odd", position: `${index}` },
+      });
+    }
+    osm.buildIndexes();
+
+    expect(osm.nodes.tags.taggedEntityCount).toBe(entityCount);
+    expect([...osm.nodes.tags.taggedEntityIndexes()]).toEqual(
+      Array.from({ length: entityCount }, (_, index) => index),
+    );
+    for (const index of [0, 31, 32, 255, 256]) {
+      expect(osm.nodes.tags.cardinality(index)).toBe(2);
+      expect(osm.nodes.getByIndex(index).tags).toEqual({
+        shared: index % 2 === 0 ? "even" : "odd",
+        position: `${index}`,
+      });
+    }
+    expect([...osm.nodes].map(({ id }) => id)).toEqual(
+      Array.from({ length: entityCount }, (_, index) => index + 1),
+    );
+    expect(osm.nodes.search("shared")).toHaveLength(entityCount);
+    expect(osm.nodes.search("shared", "even").map(({ id }) => id)).toEqual(
+      Array.from({ length: 129 }, (_, index) => index * 2 + 1),
+    );
+
+    const transferables = osm.transferables();
+    expect(new Uint32Array(transferables.nodes.taggedEntityBits)).toEqual(
+      new Uint32Array([
+        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+        0xffffffff, 1,
+      ]),
+    );
+    expect(new Uint32Array(transferables.nodes.tagRankCheckpoints)).toEqual(
+      new Uint32Array([0, 256, 257]),
+    );
+    expect(new Uint32Array(transferables.nodes.tagOffsets)).toEqual(
+      new Uint32Array(Array.from({ length: entityCount + 1 }, (_, index) => index * 2)),
+    );
+    expect(Tags.getBytesRequired(entityCount, entityCount)).toBe(
+      9 * Uint32Array.BYTES_PER_ELEMENT +
+        3 * Uint32Array.BYTES_PER_ELEMENT +
+        (entityCount + 1) * Uint32Array.BYTES_PER_ELEMENT,
+    );
+
+    const reconstructed = new Osm(transferables);
+    expect(reconstructed.nodes.tags.taggedEntityCount).toBe(entityCount);
+    expect(reconstructed.nodes.getByIndex(256).tags).toEqual({
+      shared: "even",
+      position: "256",
+    });
+    expect(reconstructed.nodes.search("shared", "odd")).toHaveLength(128);
+    expect([...reconstructed.nodes.tags.taggedEntityIndexes()]).toHaveLength(entityCount);
+  });
+
+  it("stores and round-trips an all-untagged collection with only the offset sentinel", () => {
+    const osm = new Osm({ id: "all-untagged" });
+    const entityCount = 257;
+
+    for (let index = 0; index < entityCount; index++) {
+      osm.nodes.addNode({ id: index + 1, lon: index / 10, lat: index / 20 });
+    }
+    osm.buildIndexes();
+
+    expect(osm.nodes.tags.taggedEntityCount).toBe(0);
+    expect([...osm.nodes.tags.taggedEntityIndexes()]).toEqual([]);
+    for (const index of [0, 31, 32, 255, 256]) {
+      expect(osm.nodes.tags.cardinality(index)).toBe(0);
+      expect(osm.nodes.getByIndex(index).tags).toBeUndefined();
+    }
+    expect([...osm.nodes].every((node) => node.tags === undefined)).toBe(true);
+    expect(osm.nodes.search("missing-key")).toEqual([]);
+
+    const transferables = osm.transferables();
+    expect(new Uint32Array(transferables.nodes.taggedEntityBits)).toEqual(new Uint32Array(9));
+    expect(new Uint32Array(transferables.nodes.tagRankCheckpoints)).toEqual(
+      new Uint32Array([0, 0, 0]),
+    );
+    expect(new Uint32Array(transferables.nodes.tagOffsets)).toEqual(new Uint32Array([0]));
+    expect(transferables.nodes.tagKeys.byteLength).toBe(0);
+    expect(transferables.nodes.tagVals.byteLength).toBe(0);
+    expect(Tags.getBytesRequired(entityCount, 0)).toBe(
+      9 * Uint32Array.BYTES_PER_ELEMENT +
+        3 * Uint32Array.BYTES_PER_ELEMENT +
+        Uint32Array.BYTES_PER_ELEMENT,
+    );
+
+    const reconstructed = new Osm(transferables);
+    expect(reconstructed.nodes.tags.taggedEntityCount).toBe(0);
+    expect([...reconstructed.nodes.tags.taggedEntityIndexes()]).toEqual([]);
+    expect(reconstructed.nodes.getByIndex(256)).toEqual({
+      id: 257,
+      lon: 25.6,
+      lat: 12.8,
+    });
+    expect(reconstructed.nodes.search("missing-key")).toEqual([]);
+  });
+
+  it("preserves plain load diagnostics through info and transfer", () => {
+    const osm = new Osm();
+    osm.buildIndexes();
+    osm.setLoadDiagnostics({
+      requestedProfile: "auto",
+      selectedProfile: "view",
+      reasons: [{ code: "large", level: "warning", message: "View selected" }],
+      bytes: {
+        residentTypedBuffers: 100,
+        projectedTypedBufferPeak: 200,
+        largestPlannedAllocation: 50,
+        storageBytes: 75,
+      },
+      budgets: { workingSet: 150, singleAllocation: 60 },
+      phaseTimingsMs: { parse: 10 },
+      counters: { taggedNodes: 0, wayReferences: 0, relationMembers: 0 },
+    });
+
+    expect(osm.info().loadDiagnostics?.selectedProfile).toBe("view");
+    expect(new Osm(osm.transferables()).info().loadDiagnostics).toEqual(osm.info().loadDiagnostics);
+  });
+});
+
+describe("indexed way references", () => {
+  it("stores resolved node indexes and losslessly preserves sparse missing IDs", () => {
+    const osm = new Osm({ id: "way-refs" });
+    osm.nodes.addNode({ id: 10, lon: 1, lat: 2 });
+    osm.nodes.addNode({ id: 20, lon: 3, lat: 4 });
+    osm.ways.addWay({ id: 100, refs: [999, 10, 998] });
+    osm.ways.addWay({ id: 101, refs: [10, 997, 20] });
+    osm.buildIndexes();
+
+    expect(osm.ways.getRefIds(0)).toEqual([999, 10, 998]);
+    expect(osm.ways.getRefIds(1)).toEqual([10, 997, 20]);
+    expect(() => osm.ways.getCoordinates(0)).toThrow("Node 999 not found for way geometry");
+
+    const transferables = osm.transferables();
+    expect(transferables.ways.refs.byteLength).toBe(6 * Uint32Array.BYTES_PER_ELEMENT);
+    expect(new Uint32Array(transferables.ways.missingRefPositions)).toEqual(
+      new Uint32Array([0, 2, 4]),
+    );
+    expect(new Float64Array(transferables.ways.missingRefIds)).toEqual(
+      new Float64Array([999, 998, 997]),
+    );
+
+    const reconstructed = new Osm(transferables);
+    expect(reconstructed.ways.getRefIds(0)).toEqual([999, 10, 998]);
+    expect(reconstructed.ways.getRefIds(1)).toEqual([10, 997, 20]);
+  });
+
+  it("produces the same content hash for pending IDs and directly indexed refs", () => {
+    const deferred = new Osm({ id: "deferred" });
+    deferred.nodes.addNode({ id: 10, lon: 1, lat: 2 });
+    deferred.nodes.addNode({ id: 20, lon: 3, lat: 4 });
+    deferred.ways.addWay({ id: 100, refs: [10, 20] });
+    deferred.buildIndexes();
+
+    const direct = new Osm({ id: "direct" });
+    direct.nodes.addNode({ id: 10, lon: 1, lat: 2 });
+    direct.nodes.addNode({ id: 20, lon: 3, lat: 4 });
+    direct.nodes.buildIndex();
+    direct.ways.addWays(
+      [{ id: 100, keys: [], vals: [], refs: [10, 10] }],
+      new Uint32Array(),
+      undefined,
+      (id) => direct.nodes.ids.getIndexFromId(id),
+    );
+    direct.buildIndexes();
+
+    expect(direct.ways.getRefIds(0)).toEqual([10, 20]);
+    expect(direct.contentHash()).toBe(deferred.contentHash());
+  });
+});
+
+describe("empty spatial capabilities", () => {
+  it("marks requested empty way and relation indexes as built", () => {
+    const osm = new Osm({ id: "empty-spatial-indexes" });
+    osm.buildIndexes();
+
+    osm.ways.buildSpatialIndex();
+    osm.relations.buildSpatialIndex();
+
+    expect(osm.ways.hasSpatialIndex()).toBe(true);
+    expect(osm.relations.hasSpatialIndex()).toBe(true);
+    expect(osm.info().spatialIndexes).toMatchObject({
+      ways: true,
+      relations: true,
+    });
+
+    const transferables = osm.transferables();
+    const inspection = inspectBackingBuffers(transferables);
+    expect(inspection.arrayBuffers).toBe(0);
+
+    const restored = new Osm(transferables);
+    expect(restored.ways.hasSpatialIndex()).toBe(true);
+    expect(restored.relations.hasSpatialIndex()).toBe(true);
+  });
+});

package/test/tags-search.test.ts

@@ -1,60 +1,93 @@
-import { describe, expect, it } from "bun:test"
-import type { OsmNode, OsmWay } from "@osmix/shared/types"
-import { Nodes } from "../src/nodes"
-import StringTable from "../src/stringtable"
-import { Ways } from "../src/ways"
+import type { OsmNode, OsmWay } from "@osmix/types";
+import { describe, expect, it } from "vitest";
+
+import { Nodes } from "../src/nodes";
+import StringTable from "../src/stringtable";
+import { Ways } from "../src/ways";
 
 describe("Tags.search on Nodes", () => {
-	it("finds by key and key+value", () => {
-		const st = new StringTable()
-		const nodes = new Nodes(st)
-		const node1: OsmNode = { id: 1, lon: -1, lat: 1, tags: { curb: "yes" } }
-		const node2: OsmNode = { id: 2, lon: -2, lat: 2, tags: { curb: "no" } }
-		const node3: OsmNode = { id: 3, lon: -3, lat: 3 }
-		nodes.addNode(node1)
-		nodes.addNode(node2)
-		nodes.addNode(node3)
-		nodes.buildIndex()
-
-		const allCurb = nodes.search("curb")
-		expect(allCurb).toEqual([node1, node2])
-		const curbYes = nodes.search("curb", "yes")
-		expect(curbYes).toEqual([node1])
-		const curbNo = nodes.search("curb", "no")
-		expect(curbNo).toEqual([node2])
-		const none = nodes.search("highway")
-		expect(none).toEqual([])
-	})
-})
+  it("returns null for an unknown ID in an empty collection", () => {
+    const nodes = new Nodes(new StringTable());
+    nodes.buildIndex();
+
+    expect(nodes.getNodeLonLat({ id: 999 })).toBeNull();
+  });
+
+  it("finds by key and key+value", () => {
+    const st = new StringTable();
+    const nodes = new Nodes(st);
+    const node1: OsmNode = { id: 1, lon: -1, lat: 1, tags: { curb: "yes" } };
+    const node2: OsmNode = { id: 2, lon: -2, lat: 2, tags: { curb: "no" } };
+    const node3: OsmNode = { id: 3, lon: -3, lat: 3 };
+    nodes.addNode(node1);
+    nodes.addNode(node2);
+    nodes.addNode(node3);
+    nodes.buildIndex();
+
+    expect(nodes.getNodeLonLat({ id: 999 })).toBeNull();
+
+    const allCurb = nodes.search("curb");
+    expect(allCurb).toEqual([node1, node2]);
+    const curbYes = nodes.search("curb", "yes");
+    expect(curbYes).toEqual([node1]);
+    const curbNo = nodes.search("curb", "no");
+    expect(curbNo).toEqual([node2]);
+    const none = nodes.search("highway");
+    expect(none).toEqual([]);
+  });
+
+  it("returns no matches for a shared string-table key absent from the collection", () => {
+    const st = new StringTable();
+    const nodes = new Nodes(st);
+    nodes.addNode({ id: 1, lon: -1, lat: 1, tags: { curb: "yes" } });
+    nodes.buildIndex();
+
+    const ways = new Ways(st, nodes);
+    ways.addWay({ id: 10, refs: [1], tags: { highway: "residential" } });
+    ways.buildIndex();
+
+    expect(nodes.search("highway")).toEqual([]);
+  });
+});
 
 describe("Tags.search on Ways", () => {
-	it("finds by key and key+value", () => {
-		const st = new StringTable()
-		const nodes = new Nodes(st)
-		const ways = new Ways(st, nodes)
-		const way1: OsmWay = {
-			id: 10,
-			refs: [1, 2],
-			tags: { highway: "residential" },
-		}
-		const way2: OsmWay = { id: 11, refs: [2, 3], tags: { area: "yes" } }
-		const way3: OsmWay = {
-			id: 12,
-			refs: [3, 4],
-			tags: { highway: "primary", area: "no" },
-		}
-		ways.addWay(way1)
-		ways.addWay(way2)
-		ways.addWay(way3)
-		ways.buildIndex()
-
-		const allHighway = ways.search("highway")
-		expect(allHighway).toEqual([way1, way3])
-		const areaYes = ways.search("area", "yes")
-		expect(areaYes).toEqual([way2])
-		const areaAll = ways.search("area")
-		expect(areaAll).toEqual([way2, way3])
-		const areaNo = ways.search("area", "no")
-		expect(areaNo).toEqual([way3])
-	})
-})
+  it("rejects block-local tag indexes missing from the string table map", () => {
+    const st = new StringTable();
+    const nodes = new Nodes(st);
+    const ways = new Ways(st, nodes);
+
+    expect(() =>
+      ways.addWays([{ id: 1, keys: [9], vals: [0], refs: [1] }], new Uint32Array()),
+    ).toThrow("Tag key not found");
+  });
+
+  it("finds by key and key+value", () => {
+    const st = new StringTable();
+    const nodes = new Nodes(st);
+    const ways = new Ways(st, nodes);
+    const way1: OsmWay = {
+      id: 10,
+      refs: [1, 2],
+      tags: { highway: "residential" },
+    };
+    const way2: OsmWay = { id: 11, refs: [2, 3], tags: { area: "yes" } };
+    const way3: OsmWay = {
+      id: 12,
+      refs: [3, 4],
+      tags: { highway: "primary", area: "no" },
+    };
+    ways.addWay(way1);
+    ways.addWay(way2);
+    ways.addWay(way3);
+    ways.buildIndex();
+
+    const allHighway = ways.search("highway");
+    expect(allHighway).toEqual([way1, way3]);
+    const areaYes = ways.search("area", "yes");
+    expect(areaYes).toEqual([way2]);
+    const areaAll = ways.search("area");
+    expect(areaAll).toEqual([way2, way3]);
+    const areaNo = ways.search("area", "no");
+    expect(areaNo).toEqual([way3]);
+  });
+});