libp2r2p 0.10.22 → 0.10.24

package/README.md

@@ -820,6 +820,24 @@ The NIP-94 extension also carries optional `download` intent; see
 
 ## Reliable IndexedDB queue reservations
 
+`queue.putBy(indexName, item, { existingOnly = false })` atomically inserts or
+replaces an item through a declared unique, non-multiEntry index. Its key is
+extracted from the item's index keyPath, including nested paths and compound
+keys. Existing items retain their position; new keys append to the tail. It
+returns `true` after commit, or `false` without inserting when `existingOnly`
+is true and the key is absent. This allows late progress checkpoints to avoid
+recreating a cancelled record. Values are cloned before asynchronous work.
+
+Unknown, non-unique or multiEntry indexes throw `ValidationError` with
+`QUEUE_PUT_INDEX_INVALID`; missing or invalid IndexedDB keys use
+`QUEUE_PUT_KEY_INVALID`. Cloning, storage and other unique-index failures retain
+their operational errors. Lookup, replacement and byte accounting share one
+transaction and roll back together. Capacity policy matches `setAt` for a
+replacement and `push` for an insertion. Replacing a reserved item invalidates
+the old token: its `ack`, `nack` and `renew` return false. Successful writes wake
+local waiting consumers. Like the other indexed methods, `putBy` is exclusive
+to `idb-queue`; the Web Storage queue's common API is unchanged.
+
 `createQueue({ prefix, evictionPolicy: 'reject', maxBytes })` opts out of
 capacity eviction. Oversized items reject with `QUEUE_ITEM_TOO_LARGE`, full
 queues with `QUEUE_CAPACITY_EXCEEDED`; browser quota errors propagate without

package/idb-queue/index.js

@@ -725,6 +725,34 @@ export async function createQueue ({
     })
   }
 
+  async function putBy (indexName, item, { existingOnly = false } = {}) {
+    const definition = indexDefinitions.find(index => index.name === indexName)
+    if (!definition?.unique || definition.multiEntry) throw new ValidationError('QUEUE_PUT_INDEX_INVALID')
+    // Snapshot before awaiting IndexedDB so the lookup key and stored value
+    // cannot diverge if the caller changes its object during the transaction.
+    const value = structuredClone(item)
+    const readKey = path => path.split('.').reduce((part, key) => part?.[key], value)
+    const key = Array.isArray(definition.keyPath) ? definition.keyPath.map(readKey) : readKey(definition.keyPath)
+    try { indexedDB.cmp(key, key) } catch { throw new ValidationError('QUEUE_PUT_KEY_INVALID') }
+    const requiredBytes = itemForStorage(0, value).byteSize
+    const written = await mutate(async (tx, state) => {
+      const { result: previous } = await run('get', [key], ITEMS_STORE, indexName, { tx })
+      if (previous) {
+        const index = previous.position - state.head
+        await putItem(tx, state, previous.position, value, {
+          direction: evictionDirectionFor('setAt', { index, length: state.tail - state.head }),
+          protectedPositions: new Set([previous.position])
+        })
+      } else {
+        if (existingOnly) return false
+        await pushInTransaction(tx, state, value)
+      }
+      return true
+    }, { requiredBytes })
+    if (written) wake()
+    return written
+  }
+
   async function getBy (indexName, query) {
     // Explicit index operations avoid scanning queue values in JavaScript.
     return snapshot(async tx => {
@@ -899,6 +927,7 @@ export async function createQueue ({
     removeWhere,
     some,
     clear,
+    putBy,
     getBy,
     someBy,
     removeBy,

package/network/README.md

@@ -1,18 +1,30 @@
 # Connectivity
 
-`isOnline({ signal } = {})` returns a boolean after probing public connectivity
-endpoints, or immediately returns `false` when the browser reports offline.
-Concurrent calls without a signal share one check. A supplied abort signal
-cancels the caller's independent check. Each endpoint has a five-second timeout.
+`isOnline({ signal, strict = false } = {})` returns a boolean after probing
+public connectivity endpoints, or immediately returns `false` when the browser
+reports offline. The first candidate probes alone with a 2.5-second timeout; if
+it is still pending after 1 second, the remaining candidates start in parallel
+with four-second timeouts and the first success wins, keeping the worst case near
+five seconds instead of serializing every timeout. Concurrent calls without a
+signal share one check per mode. A supplied abort signal cancels the caller's
+independent check immediately.
+
+By default a probe only proves the endpoint is reachable (`no-cors`), so HTTP
+errors and captive portals still resolve. With `strict: true`, probes use
+CORS-enabled endpoints and require `response.ok` plus the expected body marker,
+which rejects captive portals and error pages. `createConnectivityMonitor({
+strict })` and `onOnline(handler, { strict })` select the same mode; shared
+checks, monitors and listeners are kept per mode.
 
 `onOnline(handler)` returns an idempotent unsubscribe function. It notifies
 asynchronously after confirmed initial connectivity and each detected recovery.
 The native `online` event only triggers a check; it is not sufficient evidence.
-Listeners share a monitor with retries at 5, 15, 30, then 60 seconds (20% jitter),
-checks on focus/visibility/network changes, and a 60-second interval while online.
-Unsubscribing the last listener removes timers/listeners and aborts its probe.
-Handler failures are isolated and logged. `createConnectivityMonitor(options)`
-creates an independent monitor with an optional custom `check({ signal })`.
+Listeners of a mode share a monitor with retries at 5, 15, 30, then 60 seconds
+(20% jitter), checks on focus/visibility/network changes, and a 60-second interval
+while online. Unsubscribing the last listener removes timers/listeners and aborts
+its probe. Handler failures are isolated and logged.
+`createConnectivityMonitor(options)` creates an independent monitor with an
+optional custom `check({ signal })` and `strict` default.
 
 Successful probes do not guarantee a particular relay or HTTP server is reachable.
 Handle request failures, cancellations, and timeouts separately. Browsers can

package/network/index.js

@@ -7,28 +7,74 @@ const CONNECTIVITY_PROBE_URLS = [
   { url: 'https://captive.apple.com/hotspot-detect.html' },
   { method: 'GET', url: 'https://connectivity-check.ubuntu.com' }
 ]
-let sharedCheck
+// CORS-enabled endpoints let the strict mode validate the response instead of
+// merely proving the host is reachable.
+const STRICT_CONNECTIVITY_PROBE_URLS = [
+  { url: 'https://captive.apple.com/hotspot-detect.html', method: 'GET', marker: 'Success' },
+  { url: 'https://1.1.1.1/cdn-cgi/trace', method: 'GET', marker: 'ip=' },
+  { url: 'https://cloudflare.com/cdn-cgi/trace', method: 'GET', marker: 'ip=' }
+]
+const FIRST_PROBE_TIMEOUT_MS = 2500
+const HEDGE_DELAY_MS = 1000
+const REMAINING_PROBE_TIMEOUT_MS = 4000
+const sharedChecks = new Map()
 
-// Treat the browser's offline flag as a fast failure; confirm online status with a probe.
-export async function isOnline ({ signal } = {}) {
+// Treat the browser's offline flag as a fast failure; confirm online status with
+// probes. The default mode only proves the hosts are reachable, while strict mode
+// requires CORS responses with an expected body and rejects captive portals.
+export async function isOnline ({ signal, strict = false } = {}) {
   if (signal?.aborted) throw signal.reason
   if (globalThis.navigator?.onLine === false) return false
-  if (signal) return hasInternetConnectivity(signal)
-  sharedCheck ??= hasInternetConnectivity().finally(() => { sharedCheck = null })
-  return sharedCheck
+  if (signal) return hasInternetConnectivity(signal, strict)
+  const key = strict ? 'strict' : 'lenient'
+  if (!sharedChecks.has(key)) {
+    sharedChecks.set(key, hasInternetConnectivity(undefined, strict).finally(() => { sharedChecks.delete(key) }))
+  }
+  return sharedChecks.get(key)
 }
 
-async function hasInternetConnectivity (signal) {
-  for (const candidate of shuffle(CONNECTIVITY_PROBE_URLS)) {
-    if (signal?.aborted) throw signal.reason
+// The first candidate answers the common case alone. When it is still pending
+// after HEDGE_DELAY_MS, the remaining candidates race in parallel so one slow or
+// blocked host cannot serialize every timeout.
+async function hasInternetConnectivity (signal, strict) {
+  if (signal?.aborted) throw signal.reason
+  const candidates = shuffle(strict ? STRICT_CONNECTIVITY_PROBE_URLS : CONNECTIVITY_PROBE_URLS)
+  const [first, ...rest] = candidates
+  if (!first) return false
+  const controller = new AbortController()
+  const onAbort = () => controller.abort(signal?.reason)
+  signal?.addEventListener('abort', onAbort, { once: true })
+  if (signal?.aborted) onAbort()
+  let hedgeTimer
+  let onHedgeAbort
+  try {
+    let startHedge
+    const firstAttempt = ping(first, { strict, signal: controller.signal, timeout: FIRST_PROBE_TIMEOUT_MS })
+    const hedge = new Promise((resolve, reject) => {
+      startHedge = resolve
+      hedgeTimer = setTimeout(resolve, HEDGE_DELAY_MS)
+      if (signal) {
+        onHedgeAbort = () => reject(signal.reason)
+        signal.addEventListener('abort', onHedgeAbort, { once: true })
+        if (signal.aborted) onHedgeAbort()
+      }
+    }).then(() => Promise.any(rest.map(candidate => ping(candidate, { strict, signal: controller.signal, timeout: REMAINING_PROBE_TIMEOUT_MS }))))
+    // A definitive failure releases the hedge immediately; a slow probe waits
+    // for the hedge delay so a working network still costs one request.
+    firstAttempt.catch(() => startHedge())
     try {
-      await ping(candidate.url, { method: candidate.method, signal })
+      await Promise.any([firstAttempt, hedge])
       return true
     } catch {
       if (signal?.aborted) throw signal.reason
+      return false
     }
+  } finally {
+    clearTimeout(hedgeTimer)
+    if (onHedgeAbort) signal?.removeEventListener('abort', onHedgeAbort)
+    controller.abort()
+    signal?.removeEventListener('abort', onAbort)
   }
-  return false
 }
 
 function shuffle (list) {
@@ -41,7 +87,8 @@ function shuffle (list) {
 }
 
 // Bound each probe and release its timer and abort listener on every exit path.
-async function ping (url, { method = 'HEAD', timeout = 5000, signal } = {}) {
+async function ping (candidate, { strict = false, timeout, signal } = {}) {
+  if (signal?.aborted) throw signal.reason
   const controller = new AbortController()
   let timer
   let onAbort
@@ -58,19 +105,29 @@ async function ping (url, { method = 'HEAD', timeout = 5000, signal } = {}) {
     if (signal?.aborted) onAbort()
   })
   try {
-    await Promise.race([
-      fetch(url, { method, mode: 'no-cors', cache: 'no-store', redirect: 'follow', signal: controller.signal }),
+    const response = await Promise.race([
+      fetch(candidate.url, {
+        method: candidate.method ?? (strict ? 'GET' : 'HEAD'),
+        mode: strict ? 'cors' : 'no-cors',
+        cache: 'no-store',
+        redirect: 'follow',
+        signal: controller.signal
+      }),
       stopped
     ])
+    if (!strict) return
+    if (!response.ok) throw new Error('PING_STATUS')
+    if (!(await response.text()).includes(candidate.marker)) throw new Error('PING_BODY')
   } finally {
     clearTimeout(timer)
     signal?.removeEventListener('abort', onAbort)
   }
 }
 
-// A monitor owns one probe loop, regardless of how many consumers subscribe.
+// A monitor owns one probe loop per mode, regardless of how many consumers subscribe.
 export function createConnectivityMonitor ({
-  check = isOnline,
+  check,
+  strict = false,
   eventTarget = globalThis.window,
   document = globalThis.document,
   _setTimeout = globalThis.setTimeout,
@@ -78,7 +135,8 @@ export function createConnectivityMonitor ({
   _random = Math.random,
   reportError = error => console.error('Online listener failed', error)
 } = {}) {
-  if (typeof check !== 'function') throw new ValidationError('INVALID_CONNECTIVITY_CHECK')
+  if (check !== undefined && typeof check !== 'function') throw new ValidationError('INVALID_CONNECTIVITY_CHECK')
+  const runCheck = check ?? (options => isOnline({ ...options, strict }))
   const listeners = new Set()
   const setTimer = (...args) => Reflect.apply(_setTimeout, globalThis, args)
   const clearTimer = (...args) => Reflect.apply(_clearTimeout, globalThis, args)
@@ -106,7 +164,7 @@ export function createConnectivityMonitor ({
     current.timer = null
     current.pending = true
     try {
-      const online = await check({ signal: current.controller.signal })
+      const online = await runCheck({ signal: current.controller.signal })
       if (session !== current) return
       current.online = online === true && globalThis.navigator?.onLine !== false
       if (current.online) {
@@ -173,10 +231,15 @@ export function createConnectivityMonitor ({
   return { onOnline }
 }
 
-let defaultMonitor
+const defaultMonitors = new Map()
 
-// Share probes, capped backoff and wake-up listeners across callers in this realm.
-export function onOnline (handler) {
-  defaultMonitor ??= createConnectivityMonitor()
-  return defaultMonitor.onOnline(handler)
+// Share probes, capped backoff and wake-up listeners per mode in this realm.
+export function onOnline (handler, { strict = false } = {}) {
+  const key = strict ? 'strict' : 'lenient'
+  let monitor = defaultMonitors.get(key)
+  if (!monitor) {
+    monitor = createConnectivityMonitor({ strict })
+    defaultMonitors.set(key, monitor)
+  }
+  return monitor.onOnline(handler)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.10.22",
+  "version": "0.10.24",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",