@osmix/core 0.2.0 → 0.3.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

@@ -35,6 +35,19 @@ describe("Tags.search on Nodes", () => {
     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", () => {

package/test/typed-arrays.test.ts

@@ -1,6 +1,45 @@
 import { describe, expect, it } from "vitest";
 
-import { BufferConstructor, ResizeableTypedArray } from "../src/typed-arrays";
+import {
+  BufferConstructor,
+  ResizeableTypedArray,
+  TypedBufferAllocationError,
+} from "../src/typed-arrays";
+
+const INITIAL_BYTES = 64 * 1024;
+
+class FailingCreateArrayBuffer extends ArrayBuffer {
+  constructor() {
+    super(0);
+    throw new RangeError("create failed");
+  }
+}
+
+/** Allocates the first buffer, but can neither resize it nor allocate a larger one. */
+class FailingGrowArrayBuffer extends ArrayBuffer {
+  constructor(byteLength: number, options?: { maxByteLength?: number }) {
+    if (byteLength > INITIAL_BYTES) throw new RangeError("grow failed");
+    super(byteLength, options);
+  }
+
+  override resize(): void {
+    throw new RangeError("resize failed");
+  }
+}
+
+class FailingCompactArrayBuffer extends ArrayBuffer {
+  override transferToFixedLength(): ArrayBuffer {
+    throw new RangeError("compact failed");
+  }
+}
+
+/** Refuses any `maxByteLength` reservation, like a runtime out of address space. */
+class NoReserveArrayBuffer extends ArrayBuffer {
+  constructor(byteLength: number, options?: { maxByteLength?: number }) {
+    if (options?.maxByteLength !== undefined) throw new RangeError("no reservation");
+    super(byteLength);
+  }
+}
 
 describe("typed array helpers", () => {
   it("selects the appropriate buffer constructor", () => {
@@ -12,24 +51,73 @@ describe("typed array helpers", () => {
   });
 
   describe("ResizeableTypedArray", () => {
-    it("push stores values and returns the index", () => {
-      const arr = new ResizeableTypedArray(Float64Array);
+    it("reports structured create allocation failures", () => {
+      expect(
+        () =>
+          new ResizeableTypedArray(
+            Float64Array,
+            FailingCreateArrayBuffer as unknown as ArrayBufferConstructor,
+          ),
+      ).toThrowError(
+        expect.objectContaining({
+          name: "TypedBufferAllocationError",
+          code: "TYPED_BUFFER_ALLOCATION_FAILED",
+          operation: "create",
+          typedArray: "Float64Array",
+          bufferType: "array-buffer",
+          elementCount: INITIAL_BYTES / 8,
+          bytesPerElement: 8,
+          requiredBytes: INITIAL_BYTES,
+        }),
+      );
+    });
 
-      const first = arr.push(1.5);
-      const second = arr.push(2.5);
+    it("reports structured grow allocation failures", () => {
+      const arr = new ResizeableTypedArray(
+        Uint8Array,
+        FailingGrowArrayBuffer as unknown as ArrayBufferConstructor,
+      );
+      arr.pushMany(new Uint8Array(INITIAL_BYTES));
+
+      expect(() => arr.push(1)).toThrowError(
+        expect.objectContaining({
+          operation: "grow",
+          typedArray: "Uint8Array",
+          elementCount: INITIAL_BYTES * 2,
+          requiredBytes: INITIAL_BYTES * 2,
+        }),
+      );
+      expect(arr.length).toBe(INITIAL_BYTES);
+    });
 
-      expect(first).toBe(0);
-      expect(second).toBe(1);
-      expect(arr.length).toBe(2);
-      expect(arr.at(0)).toBe(1.5);
-      expect(arr.at(1)).toBe(2.5);
+    it("reports structured compact allocation failures", () => {
+      const arr = new ResizeableTypedArray(
+        Float64Array,
+        FailingCompactArrayBuffer as unknown as ArrayBufferConstructor,
+      );
+      arr.pushMany([1, 2, 3]);
+
+      try {
+        arr.compact();
+        expect.unreachable("Expected compact to fail");
+      } catch (error) {
+        expect(error).toBeInstanceOf(TypedBufferAllocationError);
+        expect(error).toMatchObject({
+          operation: "compact",
+          typedArray: "Float64Array",
+          elementCount: 3,
+          bytesPerElement: 8,
+          requiredBytes: 24,
+        });
+        expect((error as Error).cause).toBeInstanceOf(RangeError);
+      }
     });
 
-    it("should push many values", () => {
+    it("push stores values and returns the index", () => {
       const arr = new ResizeableTypedArray(Float64Array);
 
-      arr.pushMany([1.5, 2.5]);
-
+      expect(arr.push(1.5)).toBe(0);
+      expect(arr.push(2.5)).toBe(1);
       expect(arr.length).toBe(2);
       expect(arr.at(0)).toBe(1.5);
       expect(arr.at(1)).toBe(2.5);
@@ -37,98 +125,129 @@ describe("typed array helpers", () => {
 
     it("at supports negative indices and guards bounds", () => {
       const arr = new ResizeableTypedArray(Int16Array);
-
       arr.pushMany([10, 20, 30]);
 
-      expect(arr.length).toBe(3);
-      expect(Array.from(arr.slice(0, arr.length))).toEqual([10, 20, 30]);
       expect(arr.at(-1)).toBe(30);
       expect(arr.at(-3)).toBe(10);
       expect(() => arr.at(-4)).toThrow(/Index out of bounds/);
       expect(() => arr.at(3)).toThrow(/Index out of bounds/);
     });
 
-    it("pushMany appends arrays while preserving order", () => {
+    it("pushMany appends arrays while preserving order, across growth", () => {
       const arr = new ResizeableTypedArray(Uint32Array);
-
       arr.pushMany([1, 2, 3]);
       arr.pushMany(Uint32Array.from([4, 5]));
-
-      expect(arr.length).toBe(5);
-      expect(Array.from(arr.slice(0, arr.length))).toEqual([1, 2, 3, 4, 5]);
+      expect(Array.from(arr.array)).toEqual([1, 2, 3, 4, 5]);
+
+      // One call that needs several doublings grows once, to at least the needed size.
+      const many = Uint32Array.from({ length: 100_000 }, (_, i) => i);
+      arr.pushMany(many);
+      expect(arr.length).toBe(100_005);
+      expect(arr.at(-1)).toBe(99_999);
+      expect(arr.capacity).toBeGreaterThanOrEqual(100_005);
     });
 
-    it("slice returns a copy of the requested segment", () => {
+    it("exposes only stored items through array, iteration and slice", () => {
       const arr = new ResizeableTypedArray(Uint8Array);
-
       arr.pushMany([1, 2, 3, 4]);
 
-      const segment = arr.slice(1, 3);
+      expect(arr.capacity).toBeGreaterThan(4);
+      expect(arr.array.length).toBe(4);
+      expect([...arr]).toEqual([1, 2, 3, 4]);
 
+      const segment = arr.slice(1, 3);
       expect(segment).toBeInstanceOf(Uint8Array);
       expect(Array.from(segment)).toEqual([2, 3]);
-
       segment[0] = 99;
       expect(arr.at(1)).toBe(2);
     });
 
+    it("set grows and extends the length", () => {
+      const arr = new ResizeableTypedArray(Float32Array);
+      arr.set(100_000, 5);
+      expect(arr.length).toBe(100_001);
+      expect(arr.at(100_000)).toBe(5);
+      expect(arr.at(0)).toBe(0);
+    });
+
     it("compact trims unused capacity", () => {
       const arr = new ResizeableTypedArray(Float64Array);
-
       arr.pushMany([5, 6, 7]);
 
-      const previousCapacity = arr.array.length;
       const compacted = arr.compact();
-      const expectedByteLength = arr.length * Float64Array.BYTES_PER_ELEMENT;
 
       expect(compacted).toBe(arr.array);
-      expect(compacted.length).toBe(arr.length);
-      expect(compacted.length).toBeLessThan(previousCapacity);
-      expect(arr.array.buffer.byteLength).toBe(expectedByteLength);
+      expect(compacted.length).toBe(3);
+      expect(arr.capacity).toBe(3);
+      expect(arr.buffer.byteLength).toBe(3 * Float64Array.BYTES_PER_ELEMENT);
     });
 
-    it("from reuses an existing buffer and grows when needed", () => {
-      const backing = new ArrayBuffer(16);
+    it("grows again after compact", () => {
+      const arr = new ResizeableTypedArray(Uint16Array);
+      arr.pushMany([1, 2]);
+      arr.compact();
+      arr.push(3);
+      expect(Array.from(arr.array)).toEqual([1, 2, 3]);
+    });
+
+    it("from wraps a transferred buffer without allocating, and can grow past 2 MiB", () => {
+      // A finished column larger than 2 MiB, as received from another worker.
+      const backing = new ArrayBuffer(4 * 2 ** 20);
       new Uint32Array(backing).set([1, 2, 3, 4]);
 
       const arr = ResizeableTypedArray.from(Uint32Array, backing);
+      expect(arr.buffer).toBe(backing);
+      expect(arr.length).toBe(2 ** 20);
+      expect(arr.at(3)).toBe(4);
 
-      arr.bufferSize = arr.buffer.byteLength;
-      arr.maxByteLength = Math.max(arr.maxByteLength, arr.bufferSize * 2);
-      arr.items = arr.array.length;
+      arr.push(5);
+      expect(arr.length).toBe(2 ** 20 + 1);
+      expect(arr.at(-1)).toBe(5);
+      expect(arr.at(3)).toBe(4);
+    });
 
-      expect(arr.length).toBe(4);
-      expect(Array.from(arr.slice(0, arr.length))).toEqual([1, 2, 3, 4]);
+    it("falls back to reallocating when the runtime refuses a reservation", () => {
+      const arr = new ResizeableTypedArray(
+        Uint8Array,
+        NoReserveArrayBuffer as unknown as ArrayBufferConstructor,
+      );
+      const first = arr.buffer;
+      arr.pushMany(new Uint8Array(INITIAL_BYTES + 1).fill(7));
+      expect(arr.buffer).not.toBe(first);
+      expect(arr.length).toBe(INITIAL_BYTES + 1);
+      expect(arr.at(-1)).toBe(7);
+    });
 
-      arr.push(5);
+    it("projects the capacity a column reaches: doubling, then 1.5× above 256 MiB", () => {
+      const MiB = 2 ** 20;
+      expect(ResizeableTypedArray.capacityBytesFor(10, 8)).toBe(INITIAL_BYTES);
+      expect(ResizeableTypedArray.capacityBytesFor(3 * MiB, 8)).toBe(4 * MiB);
+      expect(ResizeableTypedArray.capacityBytesFor(300 * MiB, 8)).toBe(384 * MiB);
+      // Just over 2 GiB no longer asks for 4 GiB.
+      const capacity = ResizeableTypedArray.capacityBytesFor(2 * 1024 * MiB + 8, 8);
+      expect(capacity).toBeLessThan(3 * 1024 * MiB);
+      expect(capacity).toBeGreaterThanOrEqual(2 * 1024 * MiB + 8);
+    });
 
-      expect(arr.length).toBe(5);
-      expect(arr.array.length).toBe(8);
-      expect(Array.from(arr.slice(0, arr.length))).toEqual([1, 2, 3, 4, 5]);
+    it("grows in place without copying", () => {
+      const arr = new ResizeableTypedArray(Float64Array);
+      const first = arr.buffer;
+      for (let i = 0; i < 100_000; i++) arr.push(i);
+      expect(arr.buffer).toBe(first);
+      expect(arr.at(99_999)).toBe(99_999);
     });
 
     if (typeof SharedArrayBuffer !== "undefined") {
-      it("grows shared buffers in place", () => {
-        const backing = new SharedArrayBuffer(8, {
-          maxByteLength: 32,
-        });
-        const seed = new Uint8Array(backing);
-        seed.set([1, 2, 3, 4, 5, 6, 7, 8]);
+      it("grows a transferred growable shared buffer in place", () => {
+        const backing = new SharedArrayBuffer(8, { maxByteLength: 32 });
+        new Uint8Array(backing).set([1, 2, 3, 4, 5, 6, 7, 8]);
 
         const arr = ResizeableTypedArray.from(Uint8Array, backing);
-
-        arr.bufferSize = arr.buffer.byteLength;
-        arr.maxByteLength = backing.maxByteLength;
-        arr.items = arr.array.length;
-
-        const originalBuffer = arr.buffer;
-
         arr.push(9);
 
-        expect(arr.buffer).toBe(originalBuffer);
-        expect(arr.array.length).toBe(16);
-        expect(arr.buffer.byteLength).toBe(16);
-        expect(Array.from(arr.slice(0, 9))).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+        expect(arr.buffer).toBe(backing);
+        expect(arr.capacity).toBe(16);
+        expect(Array.from(arr.array)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
       });
     }
   });

package/src/types/geokdbush.d.ts

@@ -1,32 +0,0 @@
-declare module "geokdbush" {
-  import type KDBush from "kdbush";
-
-  /**
-   * Returns an array of the closest points from a given location in order of increasing distance.
-   * @param index - A KDBush index with geographic coordinates (lng, lat) in degrees.
-   * @param lng - Query point longitude in degrees.
-   * @param lat - Query point latitude in degrees.
-   * @param maxResults - Maximum number of points to return (default: Infinity).
-   * @param maxDistance - Maximum distance in kilometers (default: Infinity).
-   * @param predicate - Optional filter function called with index of each point.
-   * @returns Array of point indices from the index, sorted by distance.
-   */
-  export function around(
-    index: KDBush,
-    lng: number,
-    lat: number,
-    maxResults?: number,
-    maxDistance?: number,
-    predicate?: (index: number) => boolean,
-  ): number[];
-
-  /**
-   * Returns the great circle distance between two locations in kilometers.
-   * @param lng1 - First point longitude in degrees.
-   * @param lat1 - First point latitude in degrees.
-   * @param lng2 - Second point longitude in degrees.
-   * @param lat2 - Second point latitude in degrees.
-   * @returns Distance in kilometers.
-   */
-  export function distance(lng1: number, lat1: number, lng2: number, lat2: number): number;
-}

package/src/types/kdbush.d.ts

@@ -1,47 +0,0 @@
-declare module "kdbush" {
-  import type {
-    BufferConstructor,
-    BufferType,
-    TypedArray,
-    TypedArrayConstructor,
-  } from "../typed-arrays.ts";
-
-  export default class KDBush {
-    constructor(
-      length: number,
-      nodeSize?: number,
-      ArrayType?: TypedArrayConstructor,
-      BufferConstructor?: BufferConstructor,
-    );
-
-    /** Number of items in the index */
-    numItems: number;
-
-    /** Size of the KD-tree node */
-    nodeSize: number;
-
-    /** Serialized index data buffer */
-    data: BufferType;
-
-    /** Internal array of indices (used by geokdbush) */
-    ids: Uint16Array | Uint32Array;
-
-    /** Internal array of coordinates [x0, y0, x1, y1, ...] (used by geokdbush) */
-    coords: TypedArray;
-
-    /** Add a point before calling finish */
-    add(x: number, y: number): number;
-
-    /** Finalize the index after adding all points */
-    finish(): this;
-
-    /** Query points within a bounding box; returns internal point indexes */
-    range(minX: number, minY: number, maxX: number, maxY: number): number[];
-
-    /** Query points within a radius from (x, y); returns internal point indexes */
-    within(x: number, y: number, radius: number): number[];
-
-    /** Reconstruct an index from a serialized buffer */
-    static from(data: BufferType): KDBush;
-  }
-}