nixamp 0.23.3 → 0.23.5

package/README.md

@@ -309,8 +309,19 @@ A line can be said rather than typed. The microphone button beside the box
 is tap, talk, tap: the page records, brings the sound to 16 kHz mono itself,
 and sends nixamp.com a small WAV with the room's name on it; the ear posts
 the words to the room in the same request, and the line appears. Said is
-sent. A line you would rather see first is typed; a wrong one is taken down
+sent, unless the **Edit before sending** switch under the box is on, in
+which case the words wait in the box for Send. A wrong line is taken down
 with its ✕.
+
+**On the phone, too.** Every live room has a six-digit code on the party
+line (see below), and when anybody is on the phone in a room, each trollbox
+line is read aloud to them: "chovy says: …", in a voice that is theirs as
+far as a machine can manage. The Account panel sets it: a woman's voice, a
+man's, any, or a provider voice id; or an OpenProfile URL, whose `Voice`,
+`Gender` or `Pronouns` decide. Nothing set picks one from the account, so
+the same person is always the same voice. The voices are Telnyx's Kokoro
+ones, open weights, no bill beyond the call; `NIXAMP_VOICE_FEMALE` and
+`NIXAMP_VOICE_MALE` swap in others (an ElevenLabs id, say).
 The ear is [Whisper](https://github.com/openai/whisper) run through
 [Transformers.js](https://github.com/huggingface/transformers.js), an
 Apache-2.0 library carrying MIT-licensed models, on nixamp.com's own CPU.

package/dist/catalogs.d.ts

@@ -61,8 +61,10 @@ export declare function preferPlus(source: string): string;
 export declare function entryId(source: string): string;
 /**
  * Parse an extended m3u: `#EXTINF:-1 tvg-name="CNN" group-title="News",CNN HD`
- * decorates the URL on the next line, and `#EXTGRP:News` names the group for
- * lists that write it that way instead.
+ * decorates the URL on the next line, `#EXTGRP:News` names the group for
+ * lists that write it that way instead, and `#EXTIMG:https://...` is the
+ * picture for lists (a podcast's episodes, say) that carry one that way
+ * rather than as a tvg-logo attribute.
  */
 export declare function parseCatalog(text: string, base: string): CatalogEntry[];
 export interface Group {

package/dist/handles.d.ts

@@ -11,6 +11,24 @@
  * field and never travel in the same response.
  */
 import type { Queryable } from "./follows.ts";
+/** What the room knows about somebody: the name, how they sound, where the rest is written. */
+export interface Persona {
+    handle: string;
+    /** female, male, "" for whichever, or a provider voice id they named. */
+    voice: string;
+    /** The URL of their OpenProfile.md, or "". */
+    profile: string;
+}
+/** A voice as it may be kept: a sex, nothing, or a provider's voice id. */
+export declare function cleanVoice(value: unknown): {
+    voice: string;
+    error: string;
+};
+/** An OpenProfile address as it may be kept: an http(s) URL, or nothing. */
+export declare function cleanProfile(value: unknown): {
+    profile: string;
+    error: string;
+};
 /**
  * What a handle may be.
  *
@@ -35,6 +53,20 @@ export declare class Handles {
     constructor(db: Queryable);
     private ensure;
     of(userId: string): Promise<string>;
+    /** Everything the room knows about somebody. Empty strings for whatever they never said. */
+    persona(userId: string): Promise<Persona>;
+    /**
+     * How somebody sounds, and where their profile is. Either may be given
+     * alone; what is not given is kept. A row exists only once a handle does,
+     * so somebody who never picked one is given the fallback handle first.
+     */
+    describe(userId: string, fallbackHandle: string, wanted: {
+        voice?: unknown;
+        profile?: unknown;
+    }): Promise<{
+        persona: Persona | null;
+        error: string;
+    }>;
     /**
      * Handles for a page of rows, in one query.
      *

package/dist/handles.js

@@ -7,7 +7,46 @@ const SCHEMA = `
     updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
   );
   CREATE UNIQUE INDEX IF NOT EXISTS ${TABLE}_lower ON ${TABLE} (lower(handle));
+  ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS voice TEXT NOT NULL DEFAULT '';
+  ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS profile TEXT NOT NULL DEFAULT '';
 `;
+/** A voice as it may be kept: a sex, nothing, or a provider's voice id. */
+export function cleanVoice(value) {
+    if (value === undefined || value === null)
+        return { voice: "", error: "" };
+    if (typeof value !== "string")
+        return { voice: "", error: "a voice is a word" };
+    const word = value.trim();
+    if (word === "" || word === "any")
+        return { voice: "", error: "" };
+    const lower = word.toLowerCase();
+    if (lower === "female" || lower === "male")
+        return { voice: lower, error: "" };
+    if (/^[A-Za-z][A-Za-z0-9_.-]{2,80}$/.test(word) && word.includes("."))
+        return { voice: word, error: "" };
+    return { voice: "", error: "female, male, any, or a voice id like Telnyx.KokoroTTS.am_adam" };
+}
+/** An OpenProfile address as it may be kept: an http(s) URL, or nothing. */
+export function cleanProfile(value) {
+    if (value === undefined || value === null)
+        return { profile: "", error: "" };
+    if (typeof value !== "string")
+        return { profile: "", error: "a profile is a URL" };
+    const text = value.trim();
+    if (text === "")
+        return { profile: "", error: "" };
+    try {
+        const url = new URL(text);
+        if (url.protocol !== "https:" && url.protocol !== "http:")
+            return { profile: "", error: "a profile is an http(s) URL" };
+        if (url.href.length > 500)
+            return { profile: "", error: "that URL is too long" };
+        return { profile: url.href, error: "" };
+    }
+    catch {
+        return { profile: "", error: "a profile is a URL, like https://you.example/.well-known/openprofile.md" };
+    }
+}
 /**
  * What a handle may be.
  *
@@ -69,6 +108,36 @@ export class Handles {
         const { rows } = await this.db.query(`SELECT handle FROM ${TABLE} WHERE user_id = $1`, [userId]);
         return rows[0] ? String(rows[0]["handle"] ?? "") : "";
     }
+    /** Everything the room knows about somebody. Empty strings for whatever they never said. */
+    async persona(userId) {
+        await this.ensure();
+        const { rows } = await this.db.query(`SELECT handle, voice, profile FROM ${TABLE} WHERE user_id = $1`, [userId]);
+        const row = rows[0];
+        return {
+            handle: row ? String(row["handle"] ?? "") : "",
+            voice: row ? String(row["voice"] ?? "") : "",
+            profile: row ? String(row["profile"] ?? "") : "",
+        };
+    }
+    /**
+     * How somebody sounds, and where their profile is. Either may be given
+     * alone; what is not given is kept. A row exists only once a handle does,
+     * so somebody who never picked one is given the fallback handle first.
+     */
+    async describe(userId, fallbackHandle, wanted) {
+        const voice = wanted.voice === undefined ? null : cleanVoice(wanted.voice);
+        if (voice?.error)
+            return { persona: null, error: voice.error };
+        const profile = wanted.profile === undefined ? null : cleanProfile(wanted.profile);
+        if (profile?.error)
+            return { persona: null, error: profile.error };
+        await this.ensure();
+        const had = await this.persona(userId);
+        const handle = had.handle || cleanHandle(fallbackHandle) || fallbackHandle;
+        await this.db.query(`INSERT INTO ${TABLE} (user_id, handle, voice, profile) VALUES ($1, $2, $3, $4)
+       ON CONFLICT (user_id) DO UPDATE SET voice = EXCLUDED.voice, profile = EXCLUDED.profile, updated_at = NOW()`, [userId, handle, voice ? voice.voice : had.voice, profile ? profile.profile : had.profile]);
+        return { persona: await this.persona(userId), error: "" };
+    }
     /**
      * Handles for a page of rows, in one query.
      *

package/dist/links.d.ts

@@ -68,6 +68,7 @@ export declare const PLAYLIST_FETCH_TIMEOUT_MS = 15000;
 export declare function playlistFrom(text: string, base: string): {
     hls: boolean;
     sources: string[];
+    image: string;
 };
 /**
  * A pasted .m3u, read and turned into a channel's worth of entries. Fetched

package/dist/links.js

@@ -97,12 +97,14 @@ export const PLAYLIST_FETCH_TIMEOUT_MS = 15_000;
  */
 export function playlistFrom(text, base) {
     if (/^#EXT-X-/m.test(text))
-        return { hls: true, sources: [] };
-    const sources = parseCatalog(text, base)
-        .map((entry) => entry.source)
-        .filter((source) => /^(https?|rtmps?):\/\//i.test(source))
+        return { hls: true, sources: [], image: "" };
+    const entries = parseCatalog(text, base)
+        .filter((entry) => /^(https?|rtmps?):\/\//i.test(entry.source))
         .slice(0, PLAYLIST_MAX_ENTRIES);
-    return { hls: false, sources };
+    // The picture of the list is the first picture in it: a podcast's episodes
+    // all wear the show's art, and the newest is first.
+    const image = entries.map((entry) => pictureUrl(entry.logo)).find((one) => one !== "") ?? "";
+    return { hls: false, sources: entries.map((entry) => entry.source), image };
 }
 /**
  * A pasted .m3u, read and turned into a channel's worth of entries. Fetched
@@ -147,7 +149,7 @@ export async function resolvePlaylist(url, options = {}) {
         extractor: "playlist",
         ext: "",
         page: url,
-        thumbnail: "",
+        thumbnail: list.image,
         about: "",
         playlist: list.sources,
     };

package/dist/partyline.d.ts

@@ -255,6 +255,15 @@ export declare class PartyLine {
      * the room do not hear every arrival welcomed.
      */
     private greet;
+    /**
+     * A line said into a room, to everybody on the phone in it. What the
+     * trollbox becomes on the party line: the handle and the words, in the
+     * voice of whoever typed them. False when nobody is on the phone there,
+     * which is most of the time and costs nothing.
+     */
+    say(code: string, text: string, voice: string): Promise<boolean>;
+    /** Whether anybody is on the phone in a room, before a line is worth reading. */
+    hasCallers(code: string): boolean;
     /**
      * How many people are on the phone for a stream.
      *

package/dist/partyline.js

@@ -583,6 +583,30 @@ export class PartyLine {
             call_control_ids: [leg],
         });
     }
+    /**
+     * A line said into a room, to everybody on the phone in it. What the
+     * trollbox becomes on the party line: the handle and the words, in the
+     * voice of whoever typed them. False when nobody is on the phone there,
+     * which is most of the time and costs nothing.
+     */
+    async say(code, text, voice) {
+        const room = this.rooms.get(code);
+        if (!room || room.conferenceId === null || room.callers === 0)
+            return false;
+        const said = text.replace(/\s+/g, " ").trim().slice(0, 500);
+        if (said === "")
+            return false;
+        const answer = await this.request(`/conferences/${encodeURIComponent(room.conferenceId)}/actions/speak`, {
+            payload: said,
+            voice: voice || this.voice,
+        });
+        return answer !== null;
+    }
+    /** Whether anybody is on the phone in a room, before a line is worth reading. */
+    hasCallers(code) {
+        const room = this.rooms.get(code);
+        return room !== undefined && room.conferenceId !== null && room.callers > 0;
+    }
     /**
      * How many people are on the phone for a stream.
      *

package/dist/server.d.ts

@@ -32,6 +32,7 @@ import { Rooms } from "./rooms.ts";
 import { Trollbox } from "./trollbox.ts";
 import { Speech } from "./speech.ts";
 import { Captions } from "./captions.ts";
+import { Profiles } from "./voices.ts";
 import { type Codecs } from "./audio.ts";
 import { type Tools, type Track } from "./audio.ts";
 import { type Command, type RemoteTrack, type Snapshot } from "./protocol.ts";
@@ -698,6 +699,8 @@ export interface HandlerOptions {
     trollbox?: Trollbox;
     /** Speech to text: a line said out loud, heard here. Needs the optional model. */
     speech?: Speech;
+    /** Other people's OpenProfiles, for the voice their lines are read in. */
+    profiles?: Profiles;
     /** Tickets: a paid pass to one event's room. Absent means every show is free. */
     tickets?: Tickets;
     /**

package/dist/server.js

@@ -67,6 +67,7 @@ import { Rooms } from "./rooms.js";
 import { Trollbox, TrollboxError, fallbackHandle, roomFor } from "./trollbox.js";
 import { MAX_BYTES as SPEECH_BYTES, Speech, SpeechError, isWav, languageOf } from "./speech.js";
 import { Captions } from "./captions.js";
+import { Profiles, spokenLine, telnyxVoiceFor, voicesFromEnv } from "./voices.js";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.js";
 import { applyRemoteConfig, createPaywall, FREE_LISTENERS, paywallFromEnv, } from "./paywall.js";
 import { isRemote, isTransportStream, playsInBrowser, sourceLabel } from "./sources.js";
@@ -2186,6 +2187,35 @@ export function createHandler(engine, options) {
         // Separate from the address on purpose. The address is a credential and
         // a way to reach somebody; publishing it in a directory listing or an
         // invite would be publishing what they log in with.
+        /**
+         * A trollbox line, read aloud to whoever is on the phone in that room.
+         * The room's code comes from the directory (one per channel, one for
+         * the server's own stream), the voice from the author's account or
+         * OpenProfile. Never awaited by the poster: the phone is a side effect
+         * of the chat, and a slow Telnyx must not slow the box.
+         */
+        const readOnThePhone = (where, authorId, handle, body) => {
+            const partyLine = options.partyLine;
+            const listing = (options.directory?.list() ?? []).find((one) => {
+                try {
+                    return new URL(one.url).origin === where.server;
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (!partyLine || !listing)
+                return;
+            const code = where.channel === "live" || where.channel === "main" ? listing.code : listing.channelCodes[where.channel] ?? "";
+            if (!code || !partyLine.hasCallers(code))
+                return;
+            void (async () => {
+                const persona = (await options.handles?.persona(authorId)) ?? { handle, voice: "", profile: "" };
+                const profile = persona.profile && options.profiles ? await options.profiles.voiceOf(persona.profile) : null;
+                const voice = telnyxVoiceFor({ userId: authorId, voice: persona.voice, profile }, voicesFromEnv());
+                await partyLine.say(code, spokenLine(handle, body), voice);
+            })().catch(() => undefined);
+        };
         /*
          * The trollbox: the chat for one live room, keyed by the server and
          * the channel so every viewer of a stream is in the same box whichever
@@ -2235,6 +2265,7 @@ export function createHandler(engine, options) {
                     }
                     const handle = (await options.handles?.of(who.id)) || fallbackHandle(who.id);
                     const line = await trollbox.post(where, who.id, handle, body.body);
+                    readOnThePhone(where, who.id, line.handle, line.body);
                     json(response, 201, { message: { id: line.id, handle: line.handle, body: line.body, createdAt: line.createdAt, mine: true } });
                     return;
                 }
@@ -2306,6 +2337,7 @@ export function createHandler(engine, options) {
                 if (where && options.trollbox && heard.text !== "") {
                     const handle = (await options.handles?.of(who.id)) || fallbackHandle(who.id);
                     const line = await options.trollbox.post(where, who.id, handle, heard.text);
+                    readOnThePhone(where, who.id, line.handle, line.body);
                     json(response, 201, {
                         text: heard.text, seconds: heard.seconds, model: speech.model,
                         message: { id: line.id, handle: line.handle, body: line.body, createdAt: line.createdAt, mine: true },
@@ -2329,8 +2361,12 @@ export function createHandler(engine, options) {
                 json(response, 401, { error: "not signed in" });
                 return;
             }
+            // The handle, and since 0.23.4 the voice a line is read in on the
+            // phone and the OpenProfile it may be read from. Any of the three may
+            // be sent alone; what is not sent is kept.
             if (request.method === "GET") {
-                json(response, 200, { handle: await handles.of(who.id) });
+                const persona = await handles.persona(who.id);
+                json(response, 200, { ...persona, handle: persona.handle || fallbackHandle(who.id), chosen: persona.handle !== "" });
                 return;
             }
             if (request.method === "PUT" || request.method === "POST") {
@@ -2342,12 +2378,22 @@ export function createHandler(engine, options) {
                     json(response, 400, { error: "bad JSON" });
                     return;
                 }
-                const claimed = await handles.claim(who.id, body.handle);
-                if (claimed.error) {
-                    json(response, 409, { error: claimed.error });
-                    return;
+                if (body.handle !== undefined) {
+                    const claimed = await handles.claim(who.id, body.handle);
+                    if (claimed.error) {
+                        json(response, 409, { error: claimed.error });
+                        return;
+                    }
                 }
-                json(response, 200, { handle: claimed.handle });
+                if (body.voice !== undefined || body.profile !== undefined) {
+                    const described = await handles.describe(who.id, fallbackHandle(who.id), { voice: body.voice, profile: body.profile });
+                    if (described.error) {
+                        json(response, 422, { error: described.error });
+                        return;
+                    }
+                }
+                const persona = await handles.persona(who.id);
+                json(response, 200, { ...persona, handle: persona.handle || fallbackHandle(who.id), chosen: persona.handle !== "" });
                 return;
             }
             json(response, 405, { error: "GET or PUT" });
@@ -3117,6 +3163,18 @@ export function createHandler(engine, options) {
                 return;
             }
             links.set(link, resolved);
+            // A channel already on -- put back by a restart, which forgets where
+            // it came from -- learns its picture and its line from the link pasted
+            // again, rather than waiting to be taken off and put on.
+            const already = options.channels.info(channelId);
+            if (already) {
+                if (!already.art && resolved.thumbnail)
+                    already.art = resolved.thumbnail;
+                if (!already.about && resolved.about)
+                    already.about = resolved.about;
+                if (already.art || already.about)
+                    options.rememberChannels?.(rememberedNow(options.channels));
+            }
             if (!options.channels.has(channelId)) {
                 // Asked of the site first, once, with the headers yt-dlp said to
                 // send. A media address that answers nothing is a site refusing
@@ -5166,6 +5224,8 @@ export async function serve(argv, version = "0.1.0") {
         ...(rooms ? { rooms } : {}),
         ...(trollbox ? { trollbox } : {}),
         ...(speech ? { speech } : {}),
+        // Other people's OpenProfiles, read for the voice a line is spoken in.
+        ...(accounts ? { profiles: new Profiles() } : {}),
         ...(tickets ? { tickets } : {}),
         ...(authServer ? { authServer } : {}),
         ...(parties ? { parties } : {}),

package/dist/voices.d.ts

@@ -0,0 +1,44 @@
+export type VoiceKind = "female" | "male" | "";
+/** Kokoro, through Telnyx: af_heart is the default woman, am_adam the default man. */
+export declare const DEFAULT_VOICES: Record<Exclude<VoiceKind, "">, string>;
+/** The word a person used for themselves, as a voice: female, male, or nothing to go on. */
+export declare function voiceKindOf(value: unknown): VoiceKind;
+export interface ProfileVoice {
+    /** What the profile said outright, when it did: female, male, or a provider voice id. */
+    voice: string;
+    gender: string;
+    pronouns: string;
+}
+/**
+ * The parts of an OpenProfile.md that say how somebody sounds. The identity
+ * block is the bullets under the first `#`; `Gender` may also sit under
+ * `## Match`, where the spec put it first. Everything else is ignored.
+ */
+export declare function readProfileVoice(markdown: string): ProfileVoice;
+/**
+ * The Telnyx voice for somebody, from what is known about them. A voice
+ * named outright (`ElevenLabs.…`, `Telnyx.KokoroTTS.…`, `Polly.…`) is used
+ * as written; a sex picks the configured voice for it; nothing at all
+ * picks one by the account id, so it stays the same tomorrow.
+ */
+export declare function telnyxVoiceFor(who: {
+    userId: string;
+    voice?: string;
+    profile?: ProfileVoice | null;
+}, voices?: Record<Exclude<VoiceKind, "">, string>): string;
+/** The voices to use per sex, from the environment when it says so. */
+export declare function voicesFromEnv(env?: NodeJS.ProcessEnv): Record<Exclude<VoiceKind, "">, string>;
+/** What a line sounds like read aloud: who said it, then what. */
+export declare function spokenLine(handle: string, body: string): string;
+/**
+ * Somebody's OpenProfile, fetched and kept an hour. A profile is read on
+ * every line they say, and a line a second is the trollbox's own limit.
+ */
+export declare class Profiles {
+    private readonly fetcher;
+    private readonly now;
+    private readonly ttlMs;
+    private readonly kept;
+    constructor(fetcher?: typeof fetch, now?: () => number, ttlMs?: number);
+    voiceOf(url: string): Promise<ProfileVoice | null>;
+}

package/dist/voices.js

@@ -0,0 +1,156 @@
+/**
+ * The voice a person's words are read in, on the phone.
+ *
+ * A trollbox line is text; the party line is a phone call. Reading one into
+ * the other needs a voice, and the voice should be theirs as far as a
+ * machine can manage: a man's line in a man's voice, a woman's in a woman's,
+ * anybody else's in whichever they asked for. Where that comes from, in
+ * order: the voice they set on their nixamp account; their OpenProfile
+ * (`Voice`, then `Gender`, then `Pronouns`; see logicsrc.com/openprofile);
+ * and failing both, one picked from their id, so the same person is always
+ * the same voice even when nobody was told which.
+ *
+ * The voices are Telnyx's Kokoro ones: an open-weights model, no bill beyond
+ * the call. ElevenLabs or anything else Telnyx speaks is a configuration
+ * away, per sex, because "better" and "paid" are the same word there.
+ */
+import { createHash } from "node:crypto";
+/** Kokoro, through Telnyx: af_heart is the default woman, am_adam the default man. */
+export const DEFAULT_VOICES = {
+    female: "Telnyx.KokoroTTS.af_heart",
+    male: "Telnyx.KokoroTTS.am_adam",
+};
+/** The word a person used for themselves, as a voice: female, male, or nothing to go on. */
+export function voiceKindOf(value) {
+    if (typeof value !== "string")
+        return "";
+    const word = value.trim().toLowerCase();
+    if (word === "")
+        return "";
+    if (/^(f|female|woman|women|girl|she|her|she\/her|fem|feminine|lady)$/.test(word))
+        return "female";
+    if (/^(m|male|man|men|boy|he|him|he\/him|masc|masculine|guy)$/.test(word))
+        return "male";
+    if (/^she\b/.test(word))
+        return "female";
+    if (/^he\b/.test(word))
+        return "male";
+    return "";
+}
+/**
+ * The parts of an OpenProfile.md that say how somebody sounds. The identity
+ * block is the bullets under the first `#`; `Gender` may also sit under
+ * `## Match`, where the spec put it first. Everything else is ignored.
+ */
+export function readProfileVoice(markdown) {
+    const found = { voice: "", gender: "", pronouns: "" };
+    let section = "";
+    let started = false;
+    for (const raw of markdown.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line.startsWith("# ") && !started) {
+            started = true;
+            continue;
+        }
+        if (line.startsWith("## ")) {
+            section = line.slice(3).trim().toLowerCase();
+            continue;
+        }
+        const inIdentity = started && section === "";
+        const inMatch = /^(match|dating|matching|partner|looking for)$/.test(section);
+        if (!inIdentity && !inMatch)
+            continue;
+        const item = /^[-*]\s+(?:\*\*)?([A-Za-z ]+?)(?:\*\*)?\s*:\s*(.+)$/.exec(line);
+        if (!item)
+            continue;
+        const key = (item[1] ?? "").trim().toLowerCase();
+        const value = (item[2] ?? "").trim();
+        if (key === "voice" && !found.voice)
+            found.voice = value;
+        if (key === "gender" && !found.gender)
+            found.gender = value;
+        if (key === "pronouns" && !found.pronouns)
+            found.pronouns = value;
+    }
+    return found;
+}
+/**
+ * The Telnyx voice for somebody, from what is known about them. A voice
+ * named outright (`ElevenLabs.…`, `Telnyx.KokoroTTS.…`, `Polly.…`) is used
+ * as written; a sex picks the configured voice for it; nothing at all
+ * picks one by the account id, so it stays the same tomorrow.
+ */
+export function telnyxVoiceFor(who, voices = DEFAULT_VOICES) {
+    const asked = (who.voice ?? "").trim();
+    if (asked.includes("."))
+        return asked;
+    const fromProfile = who.profile?.voice.trim() ?? "";
+    if (fromProfile.includes("."))
+        return fromProfile;
+    const kind = voiceKindOf(asked) || voiceKindOf(fromProfile) || voiceKindOf(who.profile?.gender) || voiceKindOf(who.profile?.pronouns);
+    if (kind)
+        return voices[kind];
+    const digit = createHash("sha1").update(who.userId).digest()[0];
+    return digit % 2 === 0 ? voices.female : voices.male;
+}
+/** The voices to use per sex, from the environment when it says so. */
+export function voicesFromEnv(env = process.env) {
+    return {
+        female: env["NIXAMP_VOICE_FEMALE"] || DEFAULT_VOICES.female,
+        male: env["NIXAMP_VOICE_MALE"] || DEFAULT_VOICES.male,
+    };
+}
+/** What a line sounds like read aloud: who said it, then what. */
+export function spokenLine(handle, body) {
+    const said = body.replace(/\s+/g, " ").trim();
+    return `${handle.replace(/-/g, " ")} says: ${said}`;
+}
+/**
+ * Somebody's OpenProfile, fetched and kept an hour. A profile is read on
+ * every line they say, and a line a second is the trollbox's own limit.
+ */
+export class Profiles {
+    fetcher;
+    now;
+    ttlMs;
+    kept = new Map();
+    constructor(fetcher = fetch, now = () => Date.now(), ttlMs = 60 * 60 * 1000) {
+        this.fetcher = fetcher;
+        this.now = now;
+        this.ttlMs = ttlMs;
+    }
+    async voiceOf(url) {
+        let where;
+        try {
+            where = new URL(url);
+            if (where.protocol !== "https:" && where.protocol !== "http:")
+                return null;
+        }
+        catch {
+            return null;
+        }
+        const had = this.kept.get(where.href);
+        if (had && this.now() - had.at < this.ttlMs)
+            return had.voice;
+        try {
+            const response = await this.fetcher(where.href, {
+                headers: { accept: "text/markdown, text/plain;q=0.9, */*;q=0.1" },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok)
+                return had?.voice ?? null;
+            const text = (await response.text()).slice(0, 64 * 1024);
+            const voice = readProfileVoice(text);
+            this.kept.set(where.href, { at: this.now(), voice });
+            if (this.kept.size > 5000) {
+                for (const [key, one] of this.kept)
+                    if (this.now() - one.at > this.ttlMs)
+                        this.kept.delete(key);
+            }
+            return voice;
+        }
+        catch {
+            return had?.voice ?? null;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.23.3",
+  "version": "0.23.5",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",