diff --git a/apps/web/src/views/pages.jsx b/apps/web/src/views/pages.jsx
index 674d7a0..b3e6787 100644
--- a/apps/web/src/views/pages.jsx
+++ b/apps/web/src/views/pages.jsx
@@ -393,6 +393,45 @@ export const ItemPage = ({
)}
/>
{item.data?.exit ?
+ Listen live
+ {item.data?.location_label ?? item.data?.jurisdiction ?? ''}
+ {item.data?.directory_present === false ? (
+ This scanner is no longer listed.
+ ) : (
+
+
+ Open scanner player ↗
+
+ {item.data?.stream_url ? (
+ <>
+ {' '}
+ ·{' '}
+
+ Open audio stream ↗
+
+
+ ) : null}
+ {item.data?.playlist_url ? (
+ <>
+ {' '}
+ ·{' '}
+
+ Media-player playlist ↗
+
+
+ ) : null}
+
+ )}
+ {item.data?.directory_url ? (
+
+ Source: ProScan public directory . Audio comes
+ directly from the scanner operator.
+
+ ) : null}
+
+ ) : null}
{nearby !== null ? (
Reported incidents in scanner coverage
diff --git a/docs/geographic-queries.md b/docs/geographic-queries.md
index 0f722c1..2c83d4c 100644
--- a/docs/geographic-queries.md
+++ b/docs/geographic-queries.md
@@ -93,6 +93,41 @@ geographic flags. The corresponding MCP tools expose the same fields;
a snapshot: concurrent arrivals or location changes can shift pages. Use the
existing ID/update cursors for synchronization with the default ordering.
+## Default public scanner directory
+
+`proscan-scanners` seeds the enabled `scanners-proscan` source on startup. It
+indexes the public [ProScan server directory](https://www.proscan.org/web_servers/list)
+every 15 minutes, keeping player URLs, location labels, scanner models and source
+attribution. No API key or manually supplied JSON catalog is needed.
+
+Each run visits up to 12 player pages, least recently checked first, within the
+worker deadline. It extracts explicitly advertised ``, nested audio
+sources, direct audio links and `.m3u`/`.pls` playlist links. ProScan's unclosed
+`` markup is supported. It never guesses a stream endpoint or downloads
+an audio stream. Listings appear even before their player has been checked.
+
+The scanner page links directly to the operator's player, audio URL and media
+playlist. `stream_access: "publicly-advertised"` identifies discovered links;
+`stream_reuse_allowed` remains false because link discovery is not a grant to
+record or redistribute audio. HTTP-only streams open at their source, avoiding
+mixed-content playback problems on NicheDB's HTTPS pages.
+
+Robots rules are checked per origin/path, including redirected player pages.
+Unavailable robots due to a server error, rate limit or network failure defer
+the visit. Missing robots (HTTP 4xx other than 429) has no rules. Authentication
+failures and challenges are not bypassed. Requests pin a validated public DNS
+address, revalidate redirects, cap text responses and use short timeouts.
+
+Disappearing directory entries are marked `directory_present: false` and their
+obsolete audio links are cleared. Transient player failures retain previously
+advertised links with `discovery_status: "unreachable"` and separate discovery
+and attempt timestamps. A failed/changed directory page does not erase records.
+
+Directory locations are labels, not verified radio coverage polygons. No county
+centroid or receiver location is invented: these entries retain unknown GPS
+coverage until a source supplies it, and therefore do not produce speculative
+nearby-crime associations.
+
## Permissioned scanner catalogs
Add a `scanner-directory` source in the `crime` collection with `config.url`
diff --git a/packages/adapters/src/index.js b/packages/adapters/src/index.js
index 308d0cc..0dd58a2 100644
--- a/packages/adapters/src/index.js
+++ b/packages/adapters/src/index.js
@@ -91,6 +91,7 @@ import { p0dcasters } from './p0dcasters.js';
import { buildingPermits } from './permits.js';
import { podcastindexCatalog } from './podcastindex-catalog.js';
import { podcasts } from './podcasts.js';
+import { proscanDirectory } from './proscan.js';
import { pypi } from './pypi.js';
import { redditDeals } from './redditdeals.js';
import { rogueIncidents, rogueResearch } from './rogueaitracker.js';
@@ -163,6 +164,7 @@ export const ADAPTERS = [
ecbFxRates,
socrataCrime,
scannerDirectory,
+ proscanDirectory,
ukPoliceCrime,
fbiCrimeEstimates,
usaspendingAwards,
diff --git a/packages/adapters/src/proscan.js b/packages/adapters/src/proscan.js
new file mode 100644
index 0000000..881a4e0
--- /dev/null
+++ b/packages/adapters/src/proscan.js
@@ -0,0 +1,359 @@
+import { createHash } from 'node:crypto';
+import { lookup } from 'node:dns/promises';
+import { request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { isIP } from 'node:net';
+import { decodeEntities, defineAdapter, stripHtml } from '@nichedb/core/adapter';
+import { publicWebUrl, robotsAllows } from '@nichedb/core/opensite';
+
+export const DIRECTORY_URL = 'https://www.proscan.org/web_servers/list';
+const AGENT = 'NicheDB/1.0 (+https://nichedb.dev; public scanner link index)';
+const text = (s) => decodeEntities(stripHtml(s)).trim();
+const attr = (tag, name) =>
+ decodeEntities(
+ tag
+ .match(new RegExp(`\\b${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, 'i'))
+ ?.slice(1)
+ .find((s) => s !== undefined) ?? '',
+ );
+export function scannerUrl(value, base) {
+ const u = publicWebUrl(value, base);
+ if (!u) return null;
+ const url = new URL(u);
+ if (url.username || url.password) return null;
+ url.hash = '';
+ return url.href;
+}
+export function parseDirectory(html) {
+ const entries = new Map();
+ for (const row of String(html).matchAll(/]*>([\s\S]*?)<\/tr>/gi)) {
+ const cells = [...row[1].matchAll(/]*>([\s\S]*?)<\/td>/gi)].map((m) => m[1]);
+ if (cells.length !== 9) continue;
+ const anchor = cells[1].match(/]*>/i)?.[0];
+ const player = scannerUrl(anchor ? attr(anchor, 'href') : text(cells[1]));
+ if (!player) continue;
+ const location = text(cells[2]);
+ const [country, region, ...areas] = location.split(',').map((s) => s.trim());
+ const updated = Number(text(cells[8]));
+ const description = text(cells[3]);
+ const id = `proscan:${createHash('sha256').update(player).digest('hex').slice(0, 24)}`;
+ entries.set(id, {
+ id,
+ player,
+ name: text(cells[0]) || description || `${location || 'Public'} scanner`,
+ description,
+ country: country || null,
+ region: region || null,
+ area: areas.join(', ') || null,
+ location,
+ scanner: text(cells[4]),
+ listedAt:
+ Number.isFinite(updated) && updated > 0 && updated < 4102444800
+ ? new Date(updated * 1000).toISOString()
+ : null,
+ reachable: cells[6].match(/class=['"]green['"]/i)
+ ? text(cells[6]).trim().startsWith('1')
+ : false,
+ });
+ }
+ return [...entries.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+
+/** Extract only links explicitly advertised by the player; never guess /stream. */
+export function audioLinks(html, base) {
+ const streams = [];
+ const playlists = [];
+ const clean = String(html).replace(//g, '');
+ for (const tag of clean.matchAll(/]*>/gi)) {
+ const src = attr(tag[0], 'src');
+ const url = src && scannerUrl(src, base);
+ if (url) streams.push(url);
+ }
+ for (const audio of clean.matchAll(/]*)>([\s\S]*?)<\/audio>/gi)) {
+ const own = scannerUrl(attr(audio[1], 'src'), base);
+ if (attr(audio[1], 'src') && own) streams.push(own);
+ for (const source of audio[2].matchAll(/]*>/gi)) {
+ const src = attr(source[0], 'src');
+ const url = src && scannerUrl(src, base);
+ if (url) streams.push(url);
+ }
+ }
+ for (const a of clean.matchAll(/]*>/gi)) {
+ const href = attr(a[0], 'href');
+ const url = href && scannerUrl(href, base);
+ if (!url) continue;
+ if (/\.(m3u8?|pls)(?:[?#]|$)/i.test(url)) playlists.push(url);
+ else if (/\.(mp3|aac|ogg)(?:[?#]|$)/i.test(url)) streams.push(url);
+ }
+ return { stream_url: streams[0] ?? null, playlist_url: playlists[0] ?? null };
+}
+
+export function publicAddress(address) {
+ if (
+ !isIP(address) ||
+ !publicWebUrl(`http://${address.includes(':') ? `[${address}]` : address}/`)
+ )
+ return false;
+ if (isIP(address) === 4) {
+ const [a, b] = address.split('.').map(Number);
+ if (
+ (a === 100 && b >= 64 && b <= 127) ||
+ (a === 198 && (b === 18 || b === 19)) ||
+ (a === 192 && b === 0)
+ )
+ return false;
+ }
+ if (isIP(address) === 6 && !/^[23][0-9a-f]{3}:/i.test(address)) return false;
+ return true;
+}
+
+/** Pin DNS to a public address, recheck every redirect, cap body size and time.
+ * No audio body is ever requested: this reader is for robots and HTML only.
+ */
+export async function readPublicText(
+ url,
+ {
+ resolve = lookup,
+ requestHttp = httpRequest,
+ requestHttps = httpsRequest,
+ timeoutMs = 5000,
+ maxBytes = 512 * 1024,
+ } = {},
+) {
+ const current = scannerUrl(url);
+ const end = Date.now() + timeoutMs;
+ if (!current) throw new Error('non-public scanner URL');
+ const u = new URL(current);
+ const hostname = u.hostname.replace(/^\[|\]$/g, '');
+ const remaining = end - Date.now();
+ if (remaining <= 0) throw new Error('scanner page timeout');
+ let timer;
+ const addresses = await Promise.race([
+ resolve(hostname, { all: true }),
+ new Promise((_, reject) => {
+ timer = setTimeout(() => reject(new Error('scanner DNS timeout')), remaining);
+ }),
+ ]).finally(() => clearTimeout(timer));
+ if (!addresses.length || addresses.some(({ address }) => !publicAddress(address)))
+ throw new Error('non-public scanner address');
+ const selected = addresses.find((a) => a.family === 4) ?? addresses[0];
+ const response = await new Promise((resolveResponse, reject) => {
+ const req = (u.protocol === 'https:' ? requestHttps : requestHttp)(
+ u,
+ {
+ headers: { 'user-agent': AGENT, accept: 'text/html,text/plain;q=0.9' },
+ lookup: (_host, options, callback) =>
+ options?.all
+ ? callback(null, [selected])
+ : callback(null, selected.address, selected.family),
+ },
+ (res) => {
+ const status = res.statusCode;
+ if ((status >= 300 && status < 400) || status >= 400) {
+ res.destroy();
+ clearTimeout(deadlineTimer);
+ resolveResponse({ status, location: res.headers.location, body: '', url: current });
+ return;
+ }
+ const ct = String(res.headers['content-type'] ?? '').toLowerCase();
+ if (ct && !ct.startsWith('text/') && !ct.includes('xhtml')) {
+ res.destroy();
+ clearTimeout(deadlineTimer);
+ reject(new Error('not a text page'));
+ return;
+ }
+ const chunks = [];
+ let bytes = 0;
+ res.on('data', (chunk) => {
+ bytes += chunk.length;
+ if (bytes > maxBytes) {
+ req.destroy(new Error('scanner page too large'));
+ return;
+ }
+ chunks.push(chunk);
+ });
+ res.on('end', () => {
+ clearTimeout(deadlineTimer);
+ resolveResponse({ status, body: Buffer.concat(chunks).toString('utf8'), url: current });
+ });
+ res.on('error', reject);
+ },
+ );
+ const deadlineTimer = setTimeout(
+ () => req.destroy(new Error('scanner page timeout')),
+ Math.max(1, end - Date.now()),
+ );
+ req.on('error', (e) => {
+ clearTimeout(deadlineTimer);
+ reject(e);
+ });
+ req.end();
+ });
+ return response;
+}
+
+export async function crawlPage(url, { read = readPublicText, policies = new Map() } = {}) {
+ let current = scannerUrl(url);
+ for (let redirects = 0; redirects < 4; redirects++) {
+ if (!current) throw new Error('non-public scanner redirect');
+ const u = new URL(current);
+ if (!policies.has(u.origin)) {
+ let robotsUrl = `${u.origin}/robots.txt`;
+ let r;
+ for (let hop = 0; hop < 4; hop++) {
+ r = await read(robotsUrl);
+ if (r.status >= 300 && r.status < 400 && r.location) {
+ robotsUrl = scannerUrl(r.location, robotsUrl);
+ if (!robotsUrl) throw new Error('non-public robots redirect');
+ } else break;
+ }
+ if (r.status >= 500 || r.status === 429 || (r.status >= 300 && r.status < 400))
+ throw new Error('robots unavailable; retry later');
+ policies.set(u.origin, r.status === 200 ? r.body : '');
+ }
+ if (!robotsAllows(policies.get(u.origin), u.pathname + u.search, AGENT))
+ throw new Error('robots disallows this page');
+ const r = await read(current);
+ if (r.status >= 300 && r.status < 400 && r.location) {
+ current = scannerUrl(r.location, current);
+ continue;
+ }
+ if (r.status !== 200) throw new Error(`player HTTP ${r.status}`);
+ if (/cf-chl-|checking your browser|verify you are human/i.test(r.body))
+ throw new Error('player challenge');
+ return { ...r, url: current };
+ }
+ throw new Error('too many scanner redirects');
+}
+
+export function toItem(entry, details = {}) {
+ return {
+ externalId: entry.id,
+ kind: 'scanner-stream',
+ title: entry.name,
+ url: entry.player,
+ summary: [entry.description, entry.location].filter(Boolean).join(' — '),
+ publishedAt: entry.listedAt,
+ timeKnown: Boolean(entry.listedAt),
+ tags: ['scanner', 'proscan', entry.country, entry.region, entry.area].filter(Boolean),
+ data: {
+ provider: 'ProScan public web-server directory',
+ source_id: entry.id,
+ directory_url: DIRECTORY_URL,
+ player_url: entry.player,
+ stream_url: details.stream_url ?? null,
+ playlist_url: details.playlist_url ?? null,
+ stream_access: details.stream_url ? 'publicly-advertised' : 'player-link',
+ // Discovery describes a link, not a grant of redistribution rights.
+ stream_reuse_allowed: false,
+ link_basis: 'public-directory-and-player-html',
+ country: entry.country,
+ state: entry.region,
+ area: entry.area,
+ location_label: entry.location,
+ scanner_model: entry.scanner,
+ directory_updated_at: entry.listedAt,
+ directory_reachable: entry.reachable,
+ directory_present: true,
+ coverage: null,
+ coverage_basis: 'unknown',
+ location_source: DIRECTORY_URL,
+ last_checked: details.last_checked ?? null,
+ stream_discovered_at: details.stream_discovered_at ?? null,
+ discovery_status: details.discovery_status ?? 'pending',
+ },
+ };
+}
+
+export async function pullDirectory({
+ cursor = {},
+ previous = async () => new Map(),
+ deadline = Date.now() + 90000,
+ read = readPublicText,
+ now = () => new Date(),
+ maxPlayers = 12,
+} = {}) {
+ const policies = new Map();
+ const listing = await crawlPage(DIRECTORY_URL, { read, policies });
+ const entries = parseDirectory(listing.body);
+ if (!entries.length)
+ throw new Error('ProScan directory has no recognized rows; preserving existing entries');
+ const old = await previous(entries.map((e) => e.id));
+ // Recheck least recently visited players first, independent of directory ordering.
+ const pending = [...entries].sort((a, b) =>
+ String(old.get(a.id)?.last_checked ?? '').localeCompare(
+ String(old.get(b.id)?.last_checked ?? ''),
+ ),
+ );
+ const updates = new Map();
+ let visited = 0;
+ for (const entry of pending) {
+ if (visited >= maxPlayers || Date.now() + 11000 > deadline) break;
+ visited++;
+ const checked = now().toISOString();
+ try {
+ const page = await crawlPage(entry.player, { read, policies });
+ const links = audioLinks(page.body, page.url ?? entry.player);
+ updates.set(entry.id, {
+ ...links,
+ last_checked: checked,
+ stream_discovered_at: links.stream_url ? checked : null,
+ discovery_status: links.stream_url ? 'advertised' : 'no-advertised-audio',
+ });
+ } catch (error) {
+ const blocked = /robots disallows|challenge|HTTP (401|403)/.test(error.message);
+ updates.set(entry.id, {
+ ...old.get(entry.id),
+ ...(blocked ? { stream_url: null, playlist_url: null } : {}),
+ last_checked: checked,
+ discovery_status: blocked ? 'restricted' : 'unreachable',
+ });
+ }
+ }
+ const ids = new Set(entries.map((e) => e.id));
+ // Previously indexed servers leaving the directory become inactive records,
+ // with obsolete live links cleared rather than looking current forever.
+ const missing = (cursor.ids ?? []).filter((id) => !ids.has(id));
+ const removed = missing.length ? await previous(missing) : new Map();
+ const tombstones = missing
+ .filter((id) => removed.has(id))
+ .map((id) => ({
+ externalId: id,
+ kind: 'scanner-stream',
+ title: removed.get(id).directory_title ?? 'Scanner no longer listed',
+ url: removed.get(id).player_url,
+ summary: 'This scanner is no longer listed in the ProScan directory.',
+ tags: ['scanner', 'proscan', 'inactive'],
+ data: {
+ ...removed.get(id),
+ directory_present: false,
+ stream_url: null,
+ playlist_url: null,
+ discovery_status: 'unlisted',
+ },
+ }));
+ const items = entries.map((entry) => {
+ const item = toItem(entry, updates.get(entry.id) ?? old.get(entry.id));
+ item.data.directory_title = entry.name;
+ return item;
+ });
+ return {
+ items: [...items, ...tombstones],
+ cursor: { ids: [...ids] },
+ note: `${entries.length} public scanner listings; ${visited} player pages checked; ${items.filter((i) => i.data.stream_url).length} advertised audio URLs`,
+ };
+}
+export const proscanDirectory = defineAdapter({
+ name: 'proscan-scanners',
+ title: 'ProScan public scanner directory',
+ collection: 'crime',
+ description:
+ 'Public scanner servers and the live audio links advertised on their player pages. Preserves directory location labels and attribution; no audio recording or proxying.',
+ docs: DIRECTORY_URL,
+ kinds: ['scanner-stream'],
+ cadenceMinutes: 15,
+ defaultSources: [{ slug: 'scanners-proscan', name: 'Public scanner feeds: ProScan' }],
+ async pull(ctx) {
+ return pullDirectory(ctx);
+ },
+});
diff --git a/test/proscan.test.js b/test/proscan.test.js
new file mode 100644
index 0000000..a3dfda3
--- /dev/null
+++ b/test/proscan.test.js
@@ -0,0 +1,183 @@
+import { describe, expect, test } from 'bun:test';
+import { EventEmitter } from 'node:events';
+import {
+ audioLinks,
+ crawlPage,
+ DIRECTORY_URL,
+ parseDirectory,
+ proscanDirectory,
+ publicAddress,
+ pullDirectory,
+ readPublicText,
+ scannerUrl,
+} from '../packages/adapters/src/proscan.js';
+
+const row = (url = 'http://scanner.example.org:5000/', name = 'Town & County') =>
+ `${name} listen US, Iowa, Example Dispatch & fire SDS200 0 1
2
1788959519 1789294216 Listen Live `;
+const reader = async (url) =>
+ url.endsWith('/robots.txt')
+ ? { status: 404, body: '' }
+ : { status: 200, body: url === DIRECTORY_URL ? html : player, url };
+
+describe('public ProScan links', () => {
+ test('parses location labels and stable URL IDs, deduplicates and skips malformed rows', () => {
+ const rows = parseDirectory(
+ `${html}${row()}${row('javascript:alert(1)')}bad ', 'https://scanner.example.org/')
+ .stream_url,
+ ).toBeNull();
+ });
+ test('default source is seeded, so an empty configuration is enough to ingest listings', () => {
+ expect(proscanDirectory.defaultSources[0].slug).toBe('scanners-proscan');
+ expect(proscanDirectory.collection).toBe('crime');
+ expect(proscanDirectory.needsEnv).toBeUndefined();
+ });
+ test('indexes all listings even with zero discovery budget; preserves known audio links', async () => {
+ const entry = parseDirectory(html)[0];
+ const previous = async () =>
+ new Map([
+ [
+ entry.id,
+ { stream_url: 'http://scanner.example.org:5000/live', last_checked: '2026-09-13' },
+ ],
+ ]);
+ const result = await pullDirectory({ read: reader, maxPlayers: 0, previous });
+ expect(result.items).toHaveLength(1);
+ expect(result.items[0].data.stream_url).toEndWith('/live');
+ expect(result.items[0].data.coverage).toBeNull();
+ expect(result.items[0].data.state).toBe('Iowa');
+ });
+ test('discovery records an advertised URL, not permission to rehost audio', async () => {
+ const result = await pullDirectory({ read: reader });
+ expect(result.items[0].data.stream_url).toEndWith('/HTMLAudioPlayerTown');
+ expect(result.items[0].data.stream_reuse_allowed).toBe(false);
+ expect(result.items[0].data.discovery_status).toBe('advertised');
+ });
+ test('robots restrictions and server removal clear stale stream links', async () => {
+ const entry = parseDirectory(html)[0];
+ const old = {
+ player_url: entry.player,
+ stream_url: `${entry.player}live`,
+ directory_title: 'Town',
+ };
+ const previous = async () => new Map([[entry.id, old]]);
+ const read = async (url) =>
+ url === DIRECTORY_URL
+ ? { status: 200, body: html }
+ : url.includes('proscan.org')
+ ? { status: 404, body: '' }
+ : { status: 200, body: 'User-agent: *\nDisallow: /' };
+ const result = await pullDirectory({ read, previous });
+ expect(result.items[0].data.stream_url).toBeNull();
+ expect(result.items[0].data.discovery_status).toBe('restricted');
+ const removed = await pullDirectory({
+ read: async (url) =>
+ url === DIRECTORY_URL
+ ? { status: 200, body: row('http://other.example.org/') }
+ : reader(url),
+ previous,
+ cursor: { ids: [entry.id] },
+ maxPlayers: 0,
+ });
+ expect(removed.items.find((i) => i.externalId === entry.id).data).toMatchObject({
+ directory_present: false,
+ stream_url: null,
+ playlist_url: null,
+ });
+ });
+ test('failed directory fetch never deletes existing data', async () => {
+ await expect(
+ pullDirectory({
+ read: async (url) => ({ status: 200, body: url === DIRECTORY_URL ? 'changed markup' : '' }),
+ }),
+ ).rejects.toThrow('no recognized rows');
+ });
+ test('redirected player paths get their own robots checks', async () => {
+ const calls = [];
+ const read = async (url) => {
+ calls.push(url);
+ return url === 'http://scanner.example.org/'
+ ? { status: 302, location: 'http://other.example.org/private' }
+ : url === 'http://other.example.org/robots.txt'
+ ? { status: 200, body: 'User-agent: *\nDisallow: /private' }
+ : { status: 404, body: '' };
+ };
+ await expect(crawlPage('http://scanner.example.org/', { read })).rejects.toThrow(
+ 'robots disallows',
+ );
+ expect(calls).not.toContain('http://other.example.org/private');
+ });
+ test('rejects private addresses including DNS results and credentials', async () => {
+ for (const address of [
+ '127.0.0.1',
+ '10.1.2.3',
+ '169.254.169.254',
+ '100.64.1.1',
+ '::1',
+ 'fc00::1',
+ 'ff02::1',
+ '::ffff:127.0.0.1',
+ ])
+ expect(publicAddress(address)).toBe(false);
+ expect(publicAddress('8.8.8.8')).toBe(true);
+ expect(scannerUrl('http://user:pass@example.org')).toBeNull();
+ await expect(
+ readPublicText('http://scanner.example.org/', {
+ resolve: async () => [{ address: '127.0.0.1', family: 4 }],
+ }),
+ ).rejects.toThrow('non-public scanner address');
+ });
+ test('pins a public DNS result and reads only bounded text responses', async () => {
+ const requestHttp = (url, options, callback) => {
+ expect(url.hostname).toBe('scanner.example.org');
+ options.lookup(url.hostname, {}, (error, address, family) => {
+ expect(error).toBeNull();
+ expect(address).toBe('8.8.8.8');
+ expect(family).toBe(4);
+ });
+ const req = new EventEmitter();
+ req.end = () =>
+ queueMicrotask(() => {
+ const res = new EventEmitter();
+ res.statusCode = 200;
+ res.headers = { 'content-type': 'text/html' };
+ res.destroy = () => {};
+ callback(res);
+ res.emit('data', Buffer.from(player));
+ res.emit('end');
+ });
+ req.destroy = (e) => req.emit('error', e);
+ return req;
+ };
+ const r = await readPublicText('http://scanner.example.org/', {
+ resolve: async () => [{ address: '8.8.8.8', family: 4 }],
+ requestHttp,
+ });
+ expect(r.body).toBe(player);
+ });
+});