fix: scan/fix all Node.js process.cwd() ternary checks to bare-process direct access in hyper-p2p-presence (index+tests) and hyper-spatial-index. Enhance hyper-spatial-index to v0.2.0: add deletePoint() with persistence cleanup, improved nearestNeighbor() with local+DB grid scanning/dedup, refactored queries, added hypercore dep, enhanced tests with delete verification. Updated READMEs, package.json, workspace docs. Scanned all modules for builtins, no Node.js usage. Concurrent improvements to novel P2P primitives. Git commit & push for autonomous Holepunch dev run on 2026-05-20.

README.md

@@ -21,10 +21,10 @@ This directory contains novel, production-grade, never-before-seen Bare and Pear
 - **Status**: Core + **chained delegation with parentSignature proofs + delegationDepth** + tests + README + docs
 - **Key Innovation**: First reusable capability system for P2P in the Bare ecosystem with transitive delegation proofs.
 
-### hyper-spatial-index (v0.1.0) [NEW]
+### hyper-spatial-index (v0.2.0)
 - **Location**: `./hyper-spatial-index/`
 - **Description**: Novel geospatial/spatial data indexing for P2P using grid-quadtree, Hyperbee persistence, range queries, nearest-neighbor, and Hyperswarm integration.
-- **Status**: Working code + tests + README + docs + examples + Mermaid
+- **Status**: Working code + tests + README + docs + examples + Mermaid + **deletePoint + enhanced nearestNeighbor with DB grid scanning + dedup + hypercore dep fix**
 - **Key Innovation**: First spatial indexing primitive for location-aware P2P applications in Bare/Pear.
 
 ## Development Rules (Strictly Followed)
@@ -48,6 +48,6 @@ This directory contains novel, production-grade, never-before-seen Bare and Pear
 - Publish to Pear registry when mature
 
 **Current Date**: 2026-05-20
-**This Run**: Scanned for Node.js builtins/globals (fixed process.cwd ternaries to bare-process direct access in hyper-p2p-presence). Enhanced hyper-p2p-capabilities with novel chained delegation (parentSignature proofs, delegationDepth, verifyDelegatedCapability + tests + Mermaid). Created brand new novel module hyper-spatial-index (grid-quadtree spatial indexing, Hyperbee persistence, range/nearest queries, Hyperswarm, full docs/tests/examples/Mermaid). All modules 100% Bare compatible, production-grade, with working code + tests. Git commit & push completed.
+**This Run**: Scanned and fixed all remaining Node.js process.cwd() ternary checks across hyper-p2p-presence (index + tests) and hyper-spatial-index to use direct bare-process.cwd(). Improved hyper-spatial-index (v0.2.0): added production-grade deletePoint() with persistence cleanup, enhanced nearestNeighbor() with local+DB grid scanning + deduplication + larger search radius, refactored rangeQuery for clarity, added hypercore to package.json deps, updated tests with delete verification + more points, enhanced README and package metadata. All modules remain 100% Bare/Pear compatible, no Node builtins, full docs/tests/examples/Mermaid. Concurrent improvements + scan/fix. Git commit & push completed.
 
 *All work performed exclusively inside /root/user-data/342128351638585344/projects/modules/*

hyper-p2p-presence/index.js

@@ -21,7 +21,7 @@ class HyperP2PPresence extends EventEmitter {
     super()
     this.keyPair = opts.keyPair || crypto.keyPair()
     this.topic = opts.topic || null
-    const cwd = process.cwd ? process.cwd() : '.'
+    const cwd = process.cwd()
     this.storageDir = opts.storageDir || path.join(cwd, 'hyper-p2p-presence-storage')
     this.announceIntervalMs = opts.announceInterval || DEFAULT_ANNOUNCE_INTERVAL
     this.expiryMs = opts.expiry || DEFAULT_EXPIRY

hyper-p2p-presence/test/test.js

@@ -6,7 +6,7 @@ const fs = require('bare-fs/promises')
 const process = require('bare-process')
 
 test('hyper-p2p-presence basic lifecycle', async (t) => {
-  const cwd = process.cwd ? process.cwd() : '.'
+  const cwd = process.cwd()
   const storageDir = path.join(cwd, 'test-presence-storage-' + Date.now())
   
   const presence = new HyperP2PPresence({
@@ -46,7 +46,7 @@ test('hyper-p2p-presence basic lifecycle', async (t) => {
 })
 
 test('hyper-p2p-presence filters work', async (t) => {
-  const cwd = process.cwd ? process.cwd() : '.'
+  const cwd = process.cwd()
   const storageDir = path.join(cwd, 'test-presence-filter-' + Date.now())
   
   const presence = new HyperP2PPresence({

hyper-spatial-index/README.md

@@ -15,10 +15,11 @@ A completely original, never-before-seen module providing efficient spatial data
 
 - ✅ Grid/Quadtree spatial bucketing persisted to Hyperbee
 - ✅ Range queries (bounding box)
-- ✅ Nearest neighbor search
+- ✅ Nearest neighbor search (enhanced: local + DB grid scan with dedup)
+- ✅ Delete points with persistence cleanup
 - ✅ Local in-memory + persistent storage
 - ✅ Hyperswarm peer location announcements
-- ✅ Event-driven (point-inserted, peer-connected)
+- ✅ Event-driven (point-inserted, point-deleted, peer-connected, ready, closed)
 - ✅ Full Bare/Pear compatible (bare-fs, bare-path, bare-timers, bare-process, bare-events, bare-crypto)
 - ✅ Production patterns: graceful close, error handling, storage isolation
 

hyper-spatial-index/index.js

@@ -24,7 +24,7 @@ class SpatialIndex extends EventEmitter {
   constructor (opts = {}) {
     super()
     this.keyPair = opts.keyPair || crypto.keyPair()
-    const cwd = process.cwd ? process.cwd() : '.'
+    const cwd = process.cwd()
     this.storageDir = opts.storageDir || path.join(cwd, 'hyper-spatial-index-storage')
     this.gridSize = opts.gridSize || DEFAULT_GRID_SIZE
     this.swarm = null
@@ -80,11 +80,37 @@ class SpatialIndex extends EventEmitter {
     return point
   }
 
+  async deletePoint (id) {
+    if (this.localPoints.has(id)) {
+      const point = this.localPoints.get(id)
+      this.localPoints.delete(id)
+
+      // Remove from persisted storage (filter out the id)
+      const key = this._getGridKey(point.x, point.y)
+      const existing = (await this.bee.get(key))?.value || []
+      const filtered = existing.filter(p => p.id !== id)
+      if (filtered.length > 0) {
+        await this.bee.put(key, filtered)
+      } else {
+        await this.bee.del(key)
+      }
+
+      this.emit('point-deleted', { id })
+      return true
+    }
+    return false
+  }
+
   async rangeQuery (minX, minY, maxX, maxY) {
     const results = []
-    // Simple scan (in production: optimized quadtree traversal)
+    // Simple grid scan (production: optimized quadtree traversal + indexing)
-    for (let gx = Math.floor(minX / this.gridSize); gx <= Math.floor(maxX / this.gridSize); gx++) {
+    const minGx = Math.floor(minX / this.gridSize)
-      for (let gy = Math.floor(minY / this.gridSize); gy <= Math.floor(maxY / this.gridSize); gy++) {
+    const maxGx = Math.floor(maxX / this.gridSize)
+    const minGy = Math.floor(minY / this.gridSize)
+    const maxGy = Math.floor(maxY / this.gridSize)
+
+    for (let gx = minGx; gx <= maxGx; gx++) {
+      for (let gy = minGy; gy <= maxGy; gy++) {
         const key = `grid:${gx}:${gy}`
         const val = await this.bee.get(key)
         if (val && val.value) {
@@ -100,14 +126,45 @@ class SpatialIndex extends EventEmitter {
   }
 
   async nearestNeighbor (x, y, k = 1) {
-    // Simple brute force for demo (real impl would use spatial index)
+    // Enhanced: combines local cache + persisted points from nearby grids for better accuracy
     const all = []
+    const searchRadiusGrids = 2 // search neighboring grids
+    const gx = Math.floor(x / this.gridSize)
+    const gy = Math.floor(y / this.gridSize)
+
+    // Check local first
     for (const [id, p] of this.localPoints) {
       const dist = Math.sqrt((p.x - x) ** 2 + (p.y - y) ** 2)
       all.push({ ...p, distance: dist })
     }
-    all.sort((a, b) => a.distance - b.distance)
+
-    return all.slice(0, k)
+    // Scan nearby grids from DB for more candidates
+    for (let dx = -searchRadiusGrids; dx <= searchRadiusGrids; dx++) {
+      for (let dy = -searchRadiusGrids; dy <= searchRadiusGrids; dy++) {
+        const key = `grid:${gx + dx}:${gy + dy}`
+        const val = await this.bee.get(key)
+        if (val && val.value) {
+          for (const p of val.value) {
+            if (!this.localPoints.has(p.id)) { // avoid dups
+              const dist = Math.sqrt((p.x - x) ** 2 + (p.y - y) ** 2)
+              all.push({ ...p, distance: dist })
+            }
+          }
+        }
+      }
+    }
+
+    // Dedup and sort
+    const seen = new Set()
+    const unique = []
+    for (const item of all) {
+      if (!seen.has(item.id)) {
+        seen.add(item.id)
+        unique.push(item)
+      }
+    }
+    unique.sort((a, b) => a.distance - b.distance)
+    return unique.slice(0, k)
   }
 
   async close () {

hyper-spatial-index/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hyper-spatial-index",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Novel spatial data indexing primitive for P2P applications in Bare/Pear. Quadtree-based geospatial indexing with Hyperbee persistence, range queries, nearest-neighbor search, and Hyperswarm integration for dynamic location-aware P2P networks.",
   "main": "index.js",
   "keywords": ["holepunch", "bare", "pear", "p2p", "spatial", "geo", "index", "quadtree", "hyperbee", "geospatial"],
@@ -11,6 +11,7 @@
     "bare-crypto": "^1.0.0",
     "b4a": "^1.6.0",
     "hyperbee": "^2.0.0",
+    "hypercore": "^2.0.0",
     "hyperswarm": "^4.0.0",
     "bare-path": "^3.0.0",
     "bare-fs": "^4.0.0"

hyper-spatial-index/test/test.js

@@ -10,14 +10,21 @@ test('hyper-spatial-index basic insert and query', async (t) => {
 
   await index.insert('p1', 100, 100, { name: 'TestPoint' })
   await index.insert('p2', 1500, 1500, { name: 'FarPoint' })
+  await index.insert('p3', 200, 200, { name: 'NearPoint' })
 
   const range = await index.rangeQuery(0, 0, 500, 500)
-  t.is(range.length, 1, 'range query returns correct points')
+  t.is(range.length, 2, 'range query returns correct points')
-  t.is(range[0].id, 'p1')
+  t.ok(range.some(p => p.id === 'p1'))
 
-  const nearest = await index.nearestNeighbor(120, 120, 1)
+  const nearest = await index.nearestNeighbor(120, 120, 2)
-  t.is(nearest.length, 1)
+  t.is(nearest.length, 2)
-  t.is(nearest[0].id, 'p1')
+  t.is(nearest[0].id, 'p1') // closest
+
+  // Test delete
+  const deleted = await index.deletePoint('p3')
+  t.ok(deleted, 'deletePoint returns true')
+  const afterDelete = await index.rangeQuery(0, 0, 500, 500)
+  t.is(afterDelete.length, 1, 'point removed after delete')
 
   await index.close()
   t.pass('closed successfully')