@livedesk/hub 0.1.74 → 0.1.75

package/src/console-router-mapping.mjs

@@ -0,0 +1,187 @@
+import { randomUUID } from 'node:crypto';
+import { discoverConsoleUpnpGateway, reserveConsoleIceSocket, isPrivateRouterIPv4, isPublicRouterIPv4 } from './console-upnp-gateway.mjs';
+
+export const CONSOLE_ROUTER_MAPPING_BOUNDS = Object.freeze({
+  owners: 4, candidates: 8, setupMs: 8000, cleanupMs: 1800, leaseSeconds: 120, history: 8
+});
+
+export function parseRouterMappingCandidate(value) {
+  if (typeof value !== 'string' || value.length > 4096) return null;
+  const parts = value.trim().replace(/^a=/, '').split(/\s+/);
+  const port = Number(parts[5]);
+  if (!/^candidate:/i.test(parts[0]) || parts[1] !== '1' || parts[2]?.toLowerCase() !== 'udp'
+    || parts[6] !== 'typ' || !['host', 'srflx'].includes(parts[7])
+    || !(parts[7] === 'host' ? isPrivateRouterIPv4(parts[4]) : isPublicRouterIPv4(parts[4]))
+    || !Number.isInteger(port) || port < 1024 || port > 65535) return null;
+  const relatedPort = parts.includes('rport') ? Number(parts[parts.indexOf('rport') + 1]) : 0;
+  return { type: parts[7], address: parts[4], port, relatedPort };
+}
+
+function untilAborted(signal) {
+  return new Promise(resolve => {
+    if (signal.aborted) return resolve();
+    signal.addEventListener('abort', resolve, { once: true });
+  });
+}
+
+// One short-lived setup owner per authenticated peer. This never owns a peer,
+// frame, encoder or retransmit queue. Mapping removal does not close ICE.
+export function createConsoleRouterMapping(options = {}) {
+  const enabled = options.isEnabled || (() => false);
+  const discover = options.discover || discoverConsoleUpnpGateway;
+  const reserveSocket = options.reserveSocket || reserveConsoleIceSocket;
+  const bounds = CONSOLE_ROUTER_MAPPING_BOUNDS;
+  const setupMs = Math.min(bounds.setupMs, Math.max(1, Number(options.setupMs) || bounds.setupMs));
+  const cleanupMs = Math.min(bounds.cleanupMs, Math.max(1, Number(options.cleanupMs) || bounds.cleanupMs));
+  const owners = new Set();
+  const reservedPorts = new Map();
+  const history = [];
+  let historyEpoch = 0;
+  let attempts = 0, mapped = 0, cleanupUnconfirmed = 0;
+
+  function finish(owner) {
+    owners.delete(owner);
+    if (reservedPorts.get(owner.reservation) === owner) reservedPorts.delete(owner.reservation);
+    if (owner.historyEpoch === historyEpoch) history.push(Object.freeze({ owner: owner.key, state: owner.state, cleanup: owner.cleanup,
+      durationMs: Math.max(0, Date.now() - owner.startedAt) }));
+    if (history.length > bounds.history) history.shift();
+    owner.gateway = null;
+    owner.candidates.length = 0;
+    owner.finished = true;
+  }
+
+  const own = (entry, owner) => entry && entry.localAddress === owner.gateway.localAddress
+    && entry.port === owner.port && entry.description === owner.description;
+
+  async function cleanup(owner) {
+    if (!owner.attempted || !owner.gateway) return;
+    const controller = new AbortController();
+    owner.cleanupTimer = setTimeout(() => controller.abort(), cleanupMs);
+    try {
+      const entry = await owner.gateway.read(owner.externalPort, controller.signal);
+      if (entry === null) { owner.cleanup = 'absent'; return; }
+      if (!own(entry, owner)) { owner.cleanup = 'ownership-changed'; return; }
+      await owner.gateway.remove(owner.externalPort, controller.signal);
+      owner.cleanup = await owner.gateway.read(owner.externalPort, controller.signal) === null ? 'removed' : 'unconfirmed';
+    } catch { owner.cleanup = 'unconfirmed'; }
+    finally {
+      clearTimeout(owner.cleanupTimer);
+      owner.cleanupTimer = null;
+      if (owner.cleanup === 'unconfirmed') cleanupUnconfirmed += 1;
+    }
+  }
+
+  async function run(owner) {
+    attempts += 1;
+    const signal = owner.controller.signal;
+    owner.setupTimer = setTimeout(() => {
+      owner.state = 'setup-expired';
+      owner.controller.abort();
+    }, setupMs);
+    try {
+      owner.gateway = await discover(signal);
+      signal.throwIfAborted();
+      const range = owner.portRange;
+      const requestedPort = range?.portRangeBegin || 0;
+      const lastPort = range?.portRangeEnd || requestedPort;
+      if (!Number.isInteger(requestedPort) || !Number.isInteger(lastPort)
+        || requestedPort < 0 || (requestedPort > 0 && requestedPort < 1024)
+        || (requestedPort === 0 && lastPort !== 0)
+        || lastPort < requestedPort || lastPort > 65535 || lastPort - requestedPort >= 64) {
+        throw new Error('router-port-range-invalid');
+      }
+      for (let port = requestedPort; port <= lastPort; port++) {
+        try { owner.socket = await reserveSocket(owner.gateway, signal, port); break; }
+        catch (error) { if (error?.code !== 'EADDRINUSE' || port === lastPort) throw error; }
+      }
+      signal.throwIfAborted();
+      owner.port = owner.socket.port;
+      owner.externalPort = owner.socket.port;
+      owner.reservation = `${owner.gateway.address}:${owner.externalPort}`;
+      if (reservedPorts.has(owner.reservation)) { owner.state = 'port-busy'; return; }
+      reservedPorts.set(owner.reservation, owner);
+      if (await owner.gateway.read(owner.externalPort, signal) !== null) { owner.state = 'port-busy'; return; }
+      signal.throwIfAborted();
+      owner.attempted = true;
+      await owner.gateway.add(owner.externalPort, owner.port, owner.description, signal);
+      signal.throwIfAborted();
+      const accepted = await owner.gateway.read(owner.externalPort, signal);
+      if (!own(accepted, owner) || !accepted.enabled || !Number.isInteger(accepted.leaseSeconds)
+        || accepted.leaseSeconds < 1 || accepted.leaseSeconds > bounds.leaseSeconds) {
+        owner.state = 'lease-rejected';
+        return;
+      }
+      owner.state = 'mapped';
+      mapped += 1;
+      owner.resolveReady({ port: owner.port });
+      await untilAborted(signal);
+    } catch {
+      if (!signal.aborted) owner.state = 'unavailable';
+    } finally {
+      owner.resolveReady();
+      clearTimeout(owner.setupTimer);
+      owner.setupTimer = null;
+      await cleanup(owner);
+      await owner.socket?.close();
+      owner.socket = null;
+      finish(owner);
+    }
+  }
+
+  function createOwner(key, { portRange } = {}) {
+    if (!enabled() || owners.size >= bounds.owners || typeof key !== 'string'
+      || !/^[a-f0-9-]{36}:[a-f0-9-]{36}:\d{1,12}$/i.test(key)) return null;
+    const owner = { key, historyEpoch, portRange, socket: null, state: 'discovering', cleanup: 'not-needed', finished: false,
+      controller: new AbortController(), description: `VuvoDesk-ICE-${randomUUID()}`,
+      candidates: [], gateway: null, port: 0, reservation: '', attempted: false,
+      setupTimer: null, cleanupTimer: null, promise: null, startedAt: Date.now() };
+    const ready = new Promise(resolve => { owner.resolveReady = resolve; });
+    owners.add(owner);
+    const release = () => {
+      if (owner.finished) return owner.promise || Promise.resolve();
+      owner.state = 'released';
+      owner.controller.abort();
+      owner.resolveReady();
+      if (!owner.promise) finish(owner);
+      return owner.promise || Promise.resolve();
+    };
+    owner.release = release;
+    owner.promise = run(owner);
+    return Object.freeze({
+      ready,
+      async handoff() {
+        await owner.socket?.close();
+        owner.socket = null;
+        if (owner.controller.signal.aborted || owner.finished) return null;
+        return owner.state === 'mapped' ? { port: owner.port } : null;
+      },
+      observe(value) {
+        if (owner.finished || owner.controller.signal.aborted || !enabled() || owner.state !== 'mapped') return;
+        const candidate = parseRouterMappingCandidate(value);
+        if (!candidate || owner.candidates.length >= bounds.candidates
+          || owner.candidates.some(c => c.type === candidate.type && c.address === candidate.address && c.port === candidate.port)) return;
+        owner.candidates.push(candidate);
+        if (candidate.type === 'srflx'
+          && (candidate.address !== owner.gateway?.publicAddress || candidate.port !== owner.externalPort)) {
+          owner.state = 'candidate-mismatch';
+          owner.controller.abort();
+        }
+      },
+      release
+    });
+  }
+
+  return Object.freeze({
+    createOwner,
+    releaseAll: ({ forgetHistory = false } = {}) => {
+      if (forgetHistory) { historyEpoch += 1; history.length = 0; }
+      return Promise.all([...owners].map(owner => owner.release()));
+    },
+    inspect: () => ({ enabled: Boolean(enabled()), activeOwners: owners.size,
+      activeMappings: [...owners].filter(owner => owner.state === 'mapped').length,
+      pendingOperations: [...owners].filter(owner => owner.promise).length,
+      resourceTimers: [...owners].reduce((n, owner) => n + Number(!!owner.setupTimer) + Number(!!owner.cleanupTimer), 0),
+      resourceSockets: [...owners].filter(owner => owner.socket).length,
+      attempts, mapped, cleanupUnconfirmed, recent: history.map(value => ({ ...value })) })
+  });
+}

package/src/console-router-mapping.test.mjs

@@ -0,0 +1,287 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { setTimeout as delay } from 'node:timers/promises';
+import { createConsoleRouterMapping, parseRouterMappingCandidate } from './console-router-mapping.mjs';
+import { parseDefaultRouterRoute, parseUpnpService, routerUrl, createUpnpSoapGateway, reserveConsoleIceSocket } from './console-upnp-gateway.mjs';
+import { createConsoleIceSetupGate } from './console-ice-setup-gate.mjs';
+
+const key = n => `11111111-1111-4111-8111-111111111111:22222222-2222-4222-8222-222222222222:${n}`;
+const reflected = (port = 54443) => `candidate:2 1 UDP 123 8.8.8.8 ${port} typ srflx raddr 0.0.0.0 rport 0`;
+function observe(handle, port = 54443) { handle.observe(candidate(port)); handle.observe(reflected(port)); }
+const candidate = (port = 54443, address = '192.168.0.4') => `candidate:1 1 UDP 123 ${address} ${port} typ host`;
+async function waitFor(condition) {
+  const end = Date.now() + 1000;
+  while (!condition() && Date.now() < end) await delay(2);
+  assert.ok(condition(), 'condition did not settle');
+}
+function fixture(extra = {}) {
+  const entries = new Map();
+  const calls = [];
+  const gateway = {
+    address: '192.168.0.1', localAddress: '192.168.0.4', publicAddress: '8.8.8.8',
+    async read(port) { calls.push(['read', port]); return entries.get(port) || null; },
+    async add(port, internalPort, description) {
+      calls.push(['add', port]);
+      entries.set(port, { port: internalPort, description, localAddress: gateway.localAddress, enabled: true, leaseSeconds: 120 });
+    },
+    async remove(port) { calls.push(['remove', port]); entries.delete(port); },
+    ...extra
+  };
+  let nextPort = 54443;
+  const manager = createConsoleRouterMapping({ isEnabled: () => true, discover: async () => gateway,
+    reserveSocket: async () => ({ port: nextPort++, async close() {} }) });
+  return { entries, calls, gateway, manager };
+}
+
+test('mapping is opt-in and only accepts private host UDP candidates on unprivileged ports', async () => {
+  let calls = 0;
+  const disabled = createConsoleRouterMapping({ discover: async () => { calls++; } });
+  assert.equal(disabled.createOwner(key(1)), null);
+  assert.equal(calls, 0);
+  for (const value of [candidate(80), candidate(70000), candidate(5000, '203.0.113.2'),
+    candidate().replace('UDP', 'TCP'), candidate().replace('typ host', 'typ srflx'),
+    candidate().replace('typ host', 'typ relay'), 'x'.repeat(4097)]) assert.equal(parseRouterMappingCandidate(value), null);
+  assert.deepEqual(parseRouterMappingCandidate(candidate()), { type: 'host', address: '192.168.0.4', port: 54443, relatedPort: 0 });
+});
+
+test('exact concurrent owners release only their own actual candidate ports, with no renewal', async () => {
+  const { entries, calls, manager } = fixture();
+  const a = manager.createOwner(key(1)), b = manager.createOwner(key(2));
+  try {
+    observe(a); observe(b, 54444);
+    await waitFor(() => manager.inspect().activeMappings === 2);
+    await a.release();
+    a.observe(candidate(54445)); // stale callback after cleanup cannot restart work
+    assert.equal(entries.has(54443), false);
+    assert.equal(entries.has(54444), true);
+    assert.equal(calls.filter(c => c[0] === 'add').length, 2);
+    assert.equal(manager.inspect().activeMappings, 1);
+  } finally { await manager.releaseAll(); }
+  assert.equal(entries.size, 0);
+  assert.equal(manager.inspect().activeOwners, 0);
+  assert.equal(manager.inspect().resourceTimers, 0);
+  assert.doesNotMatch(JSON.stringify(manager.inspect()), /192\.168|VuvoDesk-ICE-/);
+});
+
+test('existing mappings and changed ownership are never overwritten or deleted', async () => {
+  const { entries, calls, manager } = fixture();
+  const foreign = { port: 54443, localAddress: '192.168.0.9', description: 'another-program', leaseSeconds: 0 };
+  entries.set(54443, foreign);
+  observe(manager.createOwner(key(1)));
+  await waitFor(() => manager.inspect().activeOwners === 0);
+  assert.deepEqual(calls, [['read', 54443]]);
+  assert.equal(entries.get(54443), foreign);
+  const a = manager.createOwner(key(2)); observe(a, 54444);
+  await waitFor(() => manager.inspect().activeMappings === 1);
+  entries.set(54444, { ...foreign, port: 54444 });
+  await a.release();
+  assert.equal(calls.some(c => c[0] === 'remove'), false);
+  assert.equal(manager.inspect().recent.at(-1).cleanup, 'ownership-changed');
+});
+
+test('a reserved port is mapped before native candidates can start STUN', async () => {
+  const f = fixture();
+  const a = f.manager.createOwner(key(1));
+  await a.ready;
+  assert.equal(f.entries.get(54443).port, 54443);
+  assert.deepEqual(await a.handoff(), { port: 54443 });
+  a.observe(candidate()); a.observe(reflected());
+  await a.release();
+  assert.deepEqual(f.calls.filter(c => c[0] === 'remove'), [['remove', 54443]]);
+});
+
+test('workspace cleanup suppresses late history and cancels a stalled discovery', async () => {
+  const manager = createConsoleRouterMapping({ isEnabled: () => true,
+    discover: signal => new Promise((resolve, reject) => signal.addEventListener('abort', () => reject(new Error('aborted')), { once: true })) });
+  const a = manager.createOwner(key(1)); observe(a);
+  await manager.releaseAll({ forgetHistory: true });
+  assert.equal(manager.inspect().activeOwners, 0);
+  assert.equal(manager.inspect().pendingOperations, 0);
+  assert.equal(manager.inspect().resourceTimers, 0);
+  assert.deepEqual(manager.inspect().recent, []);
+});
+
+test('rejected permanent leases are removed and an expired entry is not renewed', async () => {
+  const f = fixture();
+  const originalAdd = f.gateway.add;
+  f.gateway.add = async (...args) => { await originalAdd(...args); f.entries.get(args[0]).leaseSeconds = 0; };
+  observe(f.manager.createOwner(key(1)));
+  await waitFor(() => f.manager.inspect().activeOwners === 0);
+  assert.equal(f.entries.size, 0);
+  assert.equal(f.manager.inspect().recent[0].state, 'lease-rejected');
+  f.gateway.add = originalAdd;
+  const a = f.manager.createOwner(key(2)); observe(a);
+  await waitFor(() => f.manager.inspect().activeMappings === 1);
+  f.entries.clear(); // ipTIME can expire a lease; setup owner does not renew it
+  await a.release();
+  assert.equal(f.manager.inspect().recent.at(-1).cleanup, 'absent');
+  assert.equal(f.calls.filter(c => c[0] === 'add').length, 2);
+});
+
+test('cancellation after an in-flight add removes a late mapping before the slot is reusable', async () => {
+  let completeAdd;
+  const f = fixture();
+  const originalAdd = f.gateway.add;
+  f.gateway.add = (...args) => new Promise(resolve => { completeAdd = async () => { await originalAdd(...args); resolve(); }; });
+  const a = f.manager.createOwner(key(1)); observe(a);
+  await waitFor(() => !!completeAdd);
+  const closing = a.release();
+  assert.equal(f.manager.inspect().activeOwners, 1);
+  await completeAdd(); await closing;
+  assert.equal(f.entries.size, 0);
+  assert.equal(f.manager.inspect().resourceTimers, 0);
+  assert.equal(f.manager.inspect().recent[0].cleanup, 'removed');
+});
+
+test('stalled socket reservation expires with zero mutations, and bounds remain exact', async () => {
+  const f = fixture();
+  const manager = createConsoleRouterMapping({ isEnabled: () => true, discover: async () => f.gateway, setupMs: 15,
+    reserveSocket: (_route, signal) => new Promise((resolve, reject) => signal.addEventListener('abort', () => reject(new Error('cancelled')), { once: true })) });
+  const handles = [1, 2, 3, 4].map(n => manager.createOwner(key(n)));
+  assert.equal(manager.createOwner(key(5)), null);
+  handles.forEach(h => h.observe(candidate(5000, '10.0.0.2')));
+  await waitFor(() => manager.inspect().activeOwners === 0);
+  assert.equal(f.calls.length, 0);
+  assert.equal(manager.inspect().resourceTimers, 0);
+  assert.equal(manager.inspect().recent[0].state, 'setup-expired');
+  for (let n = 10; n < 30; n++) await manager.createOwner(key(n)).release();
+  assert.equal(manager.inspect().recent.length, 8);
+});
+
+test('route parsing uses only the current local interface and pins every URL to that gateway', () => {
+  const interfaces = { en0: [{ family: 'IPv4', internal: false, address: '192.168.0.4' }] };
+  const expected = { address: '192.168.0.1', localAddress: '192.168.0.4' };
+  assert.deepEqual(parseDefaultRouterRoute('win32', '{"gateway":"192.168.0.1","address":"192.168.0.4"}', interfaces), expected);
+  assert.deepEqual(parseDefaultRouterRoute('linux', '[{"gateway":"192.168.0.1","prefsrc":"192.168.0.4"}]', interfaces), expected);
+  assert.deepEqual(parseDefaultRouterRoute('darwin', 'gateway: 192.168.0.1\ninterface: en0', interfaces), expected);
+  assert.throws(() => parseDefaultRouterRoute('win32', '{"gateway":"192.168.0.1","address":"192.168.0.8"}', interfaces));
+  for (const url of ['http://127.0.0.1/', 'https://192.168.0.1/', 'http://other.invalid/', 'http://user@192.168.0.1/']) {
+    assert.throws(() => routerUrl(url, expected.address));
+  }
+  const doc = '<service><serviceType>urn:schemas-upnp-org:service:WANIPConnection:1</serviceType><controlURL>/control</controlURL></service>';
+  assert.equal(parseUpnpService(doc, 'http://192.168.0.1/desc', expected.address).control.href, 'http://192.168.0.1/control');
+  assert.throws(() => parseUpnpService(doc.replace('/control', 'http://127.0.0.1/'), 'http://192.168.0.1/desc', expected.address));
+  assert.throws(() => parseUpnpService('<!DOCTYPE anything>' + doc, 'http://192.168.0.1/desc', expected.address));
+});
+
+test('SOAP reports absence only for 714, sends a temporary UDP lease, and bounds responses', async () => {
+  const requests = [];
+  let body = '<errorCode>714</errorCode>', status = 500;
+  const gateway = createUpnpSoapGateway({ address: '192.168.0.1', localAddress: '192.168.0.4' },
+    { control: new URL('http://192.168.0.1/control'), service: 'urn:schemas-upnp-org:service:WANIPConnection:1' },
+    async (url, options) => { requests.push(options); return new Response(body, { status }); });
+  const signal = new AbortController().signal;
+  assert.equal(await gateway.read(54443, signal), null);
+  body = '<errorCode>401</errorCode>';
+  await assert.rejects(gateway.read(54443, signal), /router-request-rejected/);
+  status = 200; body = '<u:AddPortMappingResponse/>';
+  await gateway.add(54443, 50000, 'fixture', signal);
+  assert.match(requests.at(-1).body, /<NewInternalPort>50000<\/NewInternalPort>/);
+  assert.match(requests.at(-1).body, /<NewProtocol>UDP<\/NewProtocol>/);
+  assert.match(requests.at(-1).body, /<NewLeaseDuration>120<\/NewLeaseDuration>/);
+  assert.equal(requests.at(-1).redirect, 'error');
+  body = 'x'.repeat(8193);
+  await assert.rejects(gateway.read(54443, signal), /router-response-too-large/);
+});
+
+test('trickled candidates wait in order for native setup and duplicates consume no extra reservation', () => {
+  const gate = createConsoleIceSetupGate();
+  const lan = candidate(50000);
+  const publicCandidate = reflected(55000);
+  const ipv6 = 'candidate:3 1 UDP 123 2001:4860::1 50000 typ host';
+  assert.equal(gate.defer(lan, '0'), true);
+  assert.equal(gate.defer(publicCandidate, '0'), true);
+  assert.equal(gate.defer(publicCandidate, '0'), true);
+  assert.equal(gate.defer(ipv6, '0'), true);
+  assert.equal(gate.inspect().candidates, 3);
+  const applied = [];
+  gate.flush((...args) => applied.push(args), () => true);
+  assert.deepEqual(applied, [[lan, '0'], [publicCandidate, '0'], [ipv6, '0']]);
+  assert.equal(gate.defer(publicCandidate, '0'), false);
+  assert.equal(gate.inspect().candidates, 0);
+});
+
+test('setup candidate bounds and closed/replaced-owner cleanup retain no deferred callbacks', () => {
+  const gate = createConsoleIceSetupGate();
+  for (let i = 0; i < 16; i++) gate.defer(reflected(50000 + i), '0');
+  assert.equal(gate.defer(reflected(50000), '0'), true);
+  assert.throws(() => gate.defer(reflected(50016), '0'), /candidate-invalid/);
+  const applied = [];
+  gate.flush(value => applied.push(value), () => applied.length === 0);
+  assert.equal(applied.length, 1);
+  assert.equal(gate.inspect().candidates, 0);
+  const cancelled = createConsoleIceSetupGate();
+  cancelled.defer(reflected(), '0'); cancelled.close();
+  cancelled.flush(() => assert.fail('retired candidate applied'), () => true);
+  assert.deepEqual(cancelled.inspect(), { waiting: false, candidates: 0 });
+});
+
+test('setup readiness resolves at accepted mapping or cancellation without waiting for lease expiry', async () => {
+  const f = fixture();
+  const a = f.manager.createOwner(key(1));
+  observe(a);
+  await a.ready;
+  assert.equal(f.manager.inspect().activeMappings, 1);
+  await a.release();
+  const b = f.manager.createOwner(key(2));
+  await b.release(); await b.ready;
+  assert.equal(f.manager.inspect().activeOwners, 0);
+});
+
+test('native preconnect reserves a vacant socket before mapping and hands it off exactly once', async () => {
+  const f = fixture();
+  let socketOpen = false, closes = 0;
+  const manager = createConsoleRouterMapping({ isEnabled: () => true, discover: async () => f.gateway,
+    reserveSocket: async () => {
+      socketOpen = true;
+      return { port: 53000, async close() { if (socketOpen) closes++; socketOpen = false; } };
+    } });
+  const a = manager.createOwner(key(10), { preconnect: true });
+  assert.deepEqual(await a.ready, { port: 53000 });
+  assert.equal(socketOpen, true);
+  assert.equal(f.entries.get(53000).port, 53000);
+  assert.deepEqual(await a.handoff(), { port: 53000 });
+  assert.equal(socketOpen, false);
+  assert.equal(manager.inspect().resourceSockets, 0);
+  a.observe(candidate(53000)); a.observe(reflected(53000));
+  await a.release();
+  assert.equal(f.entries.size, 0);
+  assert.equal(closes, 1);
+  assert.equal(manager.inspect().resourceTimers, 0);
+});
+
+test('preconnect cancellation drains its reserved socket and a changed STUN port removes its mapping', async () => {
+  const f = fixture();
+  let closed = 0;
+  const manager = createConsoleRouterMapping({ isEnabled: () => true, discover: async () => f.gateway,
+    reserveSocket: async () => ({ port: 53000, async close() { closed++; } }) });
+  const a = manager.createOwner(key(1), { preconnect: true });
+  await a.ready; await a.release();
+  assert.equal(closed, 1);
+  assert.equal(f.entries.size, 0);
+  const b = manager.createOwner(key(2), { preconnect: true });
+  await b.ready; await b.handoff();
+  b.observe(reflected(53001));
+  await waitFor(() => manager.inspect().activeOwners === 0);
+  assert.equal(f.entries.size, 0);
+  assert.equal(manager.inspect().recent.at(-1).state, 'candidate-mismatch');
+});
+
+test('real UDP reservations release on handoff, collision and cancellation during bind', async () => {
+  const udpCount = () => process.getActiveResourcesInfo().filter(name => name === 'UDPWrap').length;
+  const baseline = udpCount();
+  const route = { localAddress: '127.0.0.1' };
+  const controller = new AbortController();
+  const socket = await reserveConsoleIceSocket(route, controller.signal);
+  try {
+    assert.ok(socket.port >= 1024 && socket.port <= 65535);
+    await assert.rejects(reserveConsoleIceSocket(route, controller.signal, socket.port), { code: 'EADDRINUSE' });
+  } finally { await socket.close(); await socket.close(); }
+  const successor = await reserveConsoleIceSocket(route, controller.signal, socket.port);
+  await successor.close();
+  const cancelled = new AbortController();
+  const pending = reserveConsoleIceSocket(route, cancelled.signal);
+  cancelled.abort();
+  await assert.rejects(pending, /router-socket-reservation-unavailable/);
+  await waitFor(() => udpCount() === baseline);
+});