nixamp 0.28.45 → 0.29.1

package/src/decoder-policy.ts

@@ -0,0 +1,33 @@
+/**
+ * What a decoder may open while reading one source.
+ *
+ * ffmpeg follows references inside what it reads: an .m3u8 names segments, a
+ * concat list names files, a playlist on disk can name a URL. A file in
+ * somebody's library is untrusted input, and without a list of protocols it
+ * can make this machine fetch any address it likes, on the LAN included. So
+ * a file on disk may open files and pipes and nothing else, and a link may
+ * open the network protocols a stream needs and not the local file system.
+ *
+ * Sources this does not recognise (an ingest URL, a lavfi graph) are left
+ * alone rather than broken: the list is for what comes out of a library or a
+ * pasted link, which is where untrusted references come from.
+ */
+
+/** A file in a library: itself, and the pipes the pipeline is built from. */
+export const LOCAL_PROTOCOLS = "file,pipe,fd";
+
+/** A link: the network, as streams use it, and never `file`. */
+export const REMOTE_PROTOCOLS = [
+  "http", "https", "tcp", "tls", "crypto", "data", "httpproxy",
+  "rtmp", "rtmps", "rtmpt", "rtmpts", "rtmpe", "rtmpte", "ffrtmpcrypt", "ffrtmphttp",
+].join(",");
+
+/** The `-protocol_whitelist` to put before this source's `-i`, or nothing. */
+export function protocolArgs(source: string): string[] {
+  if (source === "-" || source.startsWith("pipe:")) return ["-protocol_whitelist", LOCAL_PROTOCOLS];
+  if (/^(https?|rtmp[a-z]*):\/\//i.test(source)) return ["-protocol_whitelist", REMOTE_PROTOCOLS];
+  if (/^file:/i.test(source)) return ["-protocol_whitelist", LOCAL_PROTOCOLS];
+  // Any other scheme (two letters or more, so `C:\` is still a path).
+  if (/^[a-z][a-z0-9+.-]+:/i.test(source)) return [];
+  return ["-protocol_whitelist", LOCAL_PROTOCOLS];
+}

package/src/destinations.ts

@@ -0,0 +1,78 @@
+/**
+ * Whether a link somebody else pasted may be fetched from this machine.
+ *
+ * A member -- any nixamp.com account -- may put a link on the air on a server
+ * that is not theirs. Fetching it is a request from inside the owner's
+ * network, so a link to the router, the cloud metadata address or a service
+ * on localhost would be the member reaching things only the owner can. The
+ * owner may fetch what they like: it is their network. A member's link has to
+ * resolve to a public address, every address it resolves to, at every hop
+ * this code follows.
+ *
+ * What it cannot see: a redirect yt-dlp or ffmpeg follows on its own, and a
+ * name that resolves differently a second later. The decoder's protocol list
+ * (decoder-policy.ts) keeps those off the file system; keeping them off the
+ * LAN entirely needs the fetch to happen here, which is later work.
+ */
+import { lookup as dnsLookup } from "node:dns/promises";
+import { isIP } from "node:net";
+
+export type Lookup = (host: string) => Promise<string[]>;
+
+const defaultLookup: Lookup = async (host) =>
+  (await dnsLookup(host, { all: true, verbatim: true })).map((one) => one.address);
+
+function v4Number(address: string): number {
+  return address.split(".").reduce((sum, part) => sum * 256 + Number(part), 0);
+}
+
+function inV4(address: string, base: string, bits: number): boolean {
+  const mask = bits === 0 ? 0 : (0xffffffff << (32 - bits)) >>> 0;
+  return ((v4Number(address) & mask) >>> 0) === ((v4Number(base) & mask) >>> 0);
+}
+
+const PRIVATE_V4: Array<[string, number]> = [
+  ["0.0.0.0", 8], ["10.0.0.0", 8], ["100.64.0.0", 10], ["127.0.0.0", 8],
+  ["169.254.0.0", 16], ["172.16.0.0", 12], ["192.0.0.0", 24], ["192.0.2.0", 24],
+  ["192.168.0.0", 16], ["198.18.0.0", 15], ["198.51.100.0", 24], ["203.0.113.0", 24],
+  ["224.0.0.0", 4], ["240.0.0.0", 4],
+];
+
+/** Not somewhere on the public internet: loopback, private, link-local, reserved. */
+export function isPrivateAddress(address: string): boolean {
+  const kind = isIP(address);
+  if (kind === 4) return PRIVATE_V4.some(([base, bits]) => inV4(address, base, bits));
+  if (kind !== 6) return true;
+  const lower = address.toLowerCase();
+  const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
+  if (mapped) return isPrivateAddress(mapped[1]!);
+  if (lower === "::" || lower === "::1") return true;
+  const first = parseInt(lower.split(":")[0] || "0", 16);
+  // fc00::/7 unique local, fe80::/10 link-local, ff00::/8 multicast.
+  if ((first & 0xfe00) === 0xfc00) return true;
+  if ((first & 0xffc0) === 0xfe80) return true;
+  if ((first & 0xff00) === 0xff00) return true;
+  return false;
+}
+
+/** "" when this link may be fetched for a member, else why not. */
+export async function refusedDestination(link: string, lookup: Lookup = defaultLookup): Promise<string> {
+  let url: URL;
+  try {
+    url = new URL(link);
+  } catch {
+    return "that is not a link";
+  }
+  if (!/^(https?|rtmps?):$/i.test(url.protocol)) return "only http, https and rtmp links can be played here";
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  if (host === "" || /^localhost$/i.test(host) || /\.localhost$/i.test(host)) return "that link points at this machine";
+  let addresses: string[];
+  try {
+    addresses = isIP(host) ? [host] : await lookup(host);
+  } catch {
+    return "that link's host does not resolve";
+  }
+  if (addresses.length === 0) return "that link's host does not resolve";
+  if (addresses.some(isPrivateAddress)) return "that link points inside a private network, which only this server's owner may play";
+  return "";
+}

package/src/library.ts

@@ -23,6 +23,8 @@ import { stateDir } from "./daemon.ts";
 export interface Config {
   /** The folder the daemon serves when it is not told which. */
   library?: string;
+  /** Whether this machine is listed in the public directory; unset until chosen. */
+  publish?: boolean;
 }
 
 export function configPath(): string {
@@ -34,7 +36,10 @@ export function readConfig(): Config {
     const parsed = JSON.parse(readFileSync(configPath(), "utf8")) as unknown;
     if (typeof parsed !== "object" || parsed === null) return {};
     const record = parsed as Record<string, unknown>;
-    return { ...(typeof record["library"] === "string" ? { library: record["library"] } : {}) };
+    return {
+      ...(typeof record["library"] === "string" ? { library: record["library"] } : {}),
+      ...(typeof record["publish"] === "boolean" ? { publish: record["publish"] } : {}),
+    };
   } catch {
     return {};
   }

package/src/links.ts

@@ -156,6 +156,11 @@ export function playlistFrom(text: string, base: string): { hls: boolean; source
   return { hls: false, sources: entries.map((entry) => entry.source), image };
 }
 
+/** Asked of every address before it is fetched: "" to go ahead, else why not. */
+export type Guard = (url: string) => Promise<string>;
+
+const PLAYLIST_MAX_REDIRECTS = 5;
+
 /**
  * A pasted .m3u, read and turned into a channel's worth of entries. Fetched
  * here rather than by yt-dlp, which would take the first entry and stop, or
@@ -163,14 +168,28 @@ export function playlistFrom(text: string, base: string): { hls: boolean; source
  */
 export async function resolvePlaylist(
   url: string,
-  options: { timeoutMs?: number; fetcher?: typeof fetch } = {},
+  options: { timeoutMs?: number; fetcher?: typeof fetch; guard?: Guard } = {},
 ): Promise<ResolvedLink | { error: string }> {
   const get = options.fetcher ?? fetch;
   const abort = new AbortController();
   const timer = setTimeout(() => abort.abort(), options.timeoutMs ?? PLAYLIST_FETCH_TIMEOUT_MS);
   let text = "";
   try {
-    const answer = await get(url, { signal: abort.signal, headers: { "user-agent": "nixamp" }, redirect: "follow" });
+    // Followed here, one hop at a time, when there is a guard: a public
+    // address that redirects to the router is the router.
+    let at = url;
+    let answer: Response;
+    for (let hop = 0; ; hop += 1) {
+      if (options.guard) {
+        const refused = await options.guard(at);
+        if (refused) return { error: refused };
+      }
+      answer = await get(at, { signal: abort.signal, headers: { "user-agent": "nixamp" }, redirect: options.guard ? "manual" : "follow" });
+      const next = answer.headers.get("location");
+      if (!options.guard || answer.status < 300 || answer.status >= 400 || !next) break;
+      if (hop >= PLAYLIST_MAX_REDIRECTS) return { error: "that playlist redirects too many times" };
+      at = new URL(next, at).toString();
+    }
     if (!answer.ok) return { error: `that playlist could not be fetched (HTTP ${answer.status})` };
     text = (await answer.text()).slice(0, PLAYLIST_MAX_BYTES);
   } catch (error) {
@@ -493,10 +512,10 @@ export const RESOLVE_TIMEOUT_MS = 60_000;
 export async function resolveLink(
   ytdlp: string[] | null,
   url: string,
-  options: { cookies?: string; timeoutMs?: number; format?: string } = {},
+  options: { cookies?: string; timeoutMs?: number; format?: string; guard?: Guard } = {},
 ): Promise<ResolvedLink | { error: string }> {
   if (isDirectMedia(url)) return directLink(url);
-  if (isPlaylistLink(url)) return resolvePlaylist(url, { timeoutMs: options.timeoutMs });
+  if (isPlaylistLink(url)) return resolvePlaylist(url, { timeoutMs: options.timeoutMs, guard: options.guard });
   // Without yt-dlp, a link is taken as the media it may well be: an IPTV
   // feed has no extension and no page behind it, and ffprobe -- asked next,
   // before anything goes on the air -- tells a stream from a web page in a

package/src/playlist-input.ts

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { protocolArgs } from "./decoder-policy.ts";
 import type { Readable } from "node:stream";
 import { codecsOf } from "./audio.ts";
 
@@ -11,24 +12,72 @@ export interface PlaylistInput {
   video: boolean;
   width?: number;
   height?: number;
+  /**
+   * Back to the top when the end is reached, instead of finishing: a
+   * station, which plays until somebody stops it.
+   */
+  repeat?: boolean;
+  /**
+   * The order to play a list of this length in, asked at the top of every
+   * pass: a station-wide shuffle is one order for everybody listening, drawn
+   * again each time round. Unset is the list's own order.
+   */
+  order?: (length: number) => number[];
+  /** Read at every entry boundary, so an edit to the list lands on the next track. */
+  current?: () => string[];
+  /** Entries already known not to play, passed over without being tried. */
+  excluded?: (file: string) => boolean;
+  /**
+   * Pass over an entry that will not play, instead of failing the stream.
+   * For a station, where the next track is what a listener should hear. A
+   * folder live leaves it unset: there a missing entry is usually a file
+   * still arriving, and the channel redials and waits for it.
+   */
+  passOver?: boolean;
+  /** Told when an entry is passed over because it would not play. */
+  onFailure?: (event: { at: number; file: string; reason: string }) => void;
 }
 
+/**
+ * How many entries in a row may fail before the list is given up on. A
+ * corrupt file is skipped; a list where nothing plays is an error, said once,
+ * not a loop.
+ */
+export const MAX_FAILURES_IN_A_ROW = 5;
+
 /** Decode each file independently; feed one persistent muxer a fixed stream
  * profile and continuous timestamps. A concat demuxer cannot decode a list
  * whose input codecs differ. Only one entry is encoded at a time, with pipe
  * backpressure bounding read-ahead independently of the directory's size. */
 export class PlaylistInputStream {
-  private entries: { at: number; start: number; position: number }[] = [];
+  private entries: { at: number; file: string; start: number; position: number }[] = [];
   error: Error | null = null;
   complete = false;
   constructor(private readonly options: PlaylistInput) {}
 
+  /** Every entry that has started, in the order it started, with where it sits in the stream. */
+  get history(): ReadonlyArray<{ at: number; file: string; start: number; position: number }> {
+    return this.entries;
+  }
+
   place(seconds: number): { at: number; position: number } {
     const entry = this.entries.findLast(one => seconds >= one.start) ?? this.entries[0];
     return entry ? { at: entry.at, position: Math.max(0, seconds - entry.start + entry.position) }
       : { at: this.options.at, position: this.options.position };
   }
 
+  /** The decoder for the entry that is on, so skip() can end it early. */
+  private stopCurrent: (() => void) | null = null;
+  private skipping = false;
+
+  /** End the entry that is on and go to the next. False when nothing is on. */
+  skip(): boolean {
+    if (!this.stopCurrent) return false;
+    this.skipping = true;
+    this.stopCurrent();
+    return true;
+  }
+
   async *open(signal: AbortSignal): AsyncGenerator<Buffer> {
     const o = this.options;
     const [command, ...prefix] = o.ffmpeg as [string, ...string[]];
@@ -36,59 +85,132 @@ export class PlaylistInputStream {
     const width = Math.max(2, Math.floor((o.width || 1280) * ratio / 2) * 2);
     const height = Math.max(2, Math.floor((o.height || 720) * ratio / 2) * 2);
     let offset = 0;
+    let failuresInARow = 0;
+    let first = true;
     try {
-      for (let at = o.at; at < o.files.length && !signal.aborted; at++) {
-        const file = o.files[at]!;
-        const codecs = await codecsOf({ ffmpeg: o.ffmpeg, ffprobe: o.ffprobe, play: null }, file, [], AbortSignal.any([signal, AbortSignal.timeout(10_000)]));
-        if (signal.aborted) return;
-        if (!codecs.audio && !codecs.video) throw new Error(`Cannot decode playlist entry ${at + 1}`);
-        const position = at === o.at ? o.position : 0;
-        const duration = (codecs.duration ?? 0) - position;
-        if (duration <= 0) throw new Error(`No playable duration for playlist entry ${at + 1}`);
-        this.entries.push({ at, start: offset, position });
-        const hasVideo = Boolean(codecs.video);
-        const extra = o.video && !hasVideo
-          ? ["-f", "lavfi", "-i", `color=c=black:s=${width}x${height}:r=30`]
-          : o.video && !codecs.audio ? ["-f", "lavfi", "-i", "anullsrc=r=48000:cl=stereo"] : [];
-        const args = [
-          ...prefix, "-hide_banner", "-loglevel", "error", "-nostdin", "-filter_threads", "2",
-          "-threads", "2", ...(position > 0 ? ["-ss", String(position)] : []), "-i", file,
-          ...extra, "-t", String(duration),
-          ...(o.video ? [
-            "-map", hasVideo ? "0:v:0" : "1:v:0", "-map", codecs.audio ? "0:a:0" : "1:a:0",
-            "-vf", `fps=30,scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2,setsar=1,setpts=PTS-STARTPTS`,
-            "-c:v", "libx264", "-threads", "2", "-preset", "veryfast", "-tune", "zerolatency",
-            "-crf", "23", "-pix_fmt", "yuv420p", "-g", "60", "-keyint_min", "60", "-sc_threshold", "0",
-          ] : ["-map", "0:a:0", "-vn"]),
-          "-af", "aresample=48000,asetpts=PTS-STARTPTS", "-c:a", "aac", "-b:a", "160k", "-ac", "2",
-          "-mpegts_flags", "+initial_discontinuity", "-output_ts_offset", String(offset), "-mpegts_copyts", "1", "-muxdelay", "0", "-muxpreload", "0",
-          "-f", "mpegts", "pipe:1",
-        ];
-        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
-        let tail = "";
-        child.stderr.on("data", chunk => { tail = (tail + chunk.toString()).slice(-1500); });
-        const closed = new Promise<number | null>((resolve) => {
-          child.once("error", error => { tail = error.message; resolve(-1); });
-          child.once("close", code => resolve(code));
-        });
-        const abort = (): void => { child.kill("SIGKILL"); };
-        signal.addEventListener("abort", abort, { once: true });
-        try {
-          for await (const chunk of child.stdout as Readable) {
+      const orderFor = (list: string[]): number[] =>
+        o.order ? o.order(list.length).filter((one) => one >= 0 && one < list.length) : list.map((_, index) => index);
+      let files = o.current?.() ?? o.files;
+      if (files.length === 0) throw new Error("The playlist is empty");
+      let order = orderFor(files);
+      let step = Math.min(o.at, order.length);
+      let played = 0;
+      let last = "";
+      for (;;) {
+        if (signal.aborted) break;
+        // Asked at every boundary, so an edit lands on the next track. The
+        // list goes on after the file that just played, where the new list
+        // has it; a shuffled list draws a new order.
+        if (o.current) {
+          const fresh = o.current();
+          if (fresh.length !== files.length || fresh.some((one, index) => one !== files[index])) {
+            if (fresh.length === 0) throw new Error("The playlist is empty");
+            files = fresh;
+            order = orderFor(files);
+            const where = last ? files.indexOf(last) : -1;
+            step = o.order ? 0 : where >= 0 ? where + 1 : Math.min(step, files.length);
+          }
+        }
+        if (step >= order.length) {
+          if (!o.repeat) break;
+          // A pass where everything was passed over is a list with nothing
+          // to play, and repeating it would be the loop this exists to avoid.
+          if (played === 0) throw new Error("Nothing in this playlist would play");
+          played = 0;
+          order = orderFor(files);
+          step = 0;
+          continue;
+        }
+        {
+          const at = order[step]!;
+          step += 1;
+          const file = files[at]!;
+          last = file;
+          if (o.excluded?.(file)) continue;
+          const position = first && step - 1 === o.at ? o.position : 0;
+          first = false;
+          let reached = 0;
+          try {
+            const codecs = await codecsOf({ ffmpeg: o.ffmpeg, ffprobe: o.ffprobe, play: null }, file, [], AbortSignal.any([signal, AbortSignal.timeout(10_000)]));
             if (signal.aborted) return;
-            yield chunk as Buffer;
+            if (!codecs.audio && !codecs.video) throw new Error(`Cannot decode playlist entry ${at + 1}`);
+            const duration = (codecs.duration ?? 0) - position;
+            if (duration <= 0) throw new Error(`No playable duration for playlist entry ${at + 1}`);
+            this.entries.push({ at, file, start: offset, position });
+            const hasVideo = Boolean(codecs.video);
+            const extra = o.video && !hasVideo
+              ? ["-f", "lavfi", "-i", `color=c=black:s=${width}x${height}:r=30`]
+              : o.video && !codecs.audio ? ["-f", "lavfi", "-i", "anullsrc=r=48000:cl=stereo"] : [];
+            const args = [
+              ...prefix, "-hide_banner", "-loglevel", "error", "-nostdin", "-filter_threads", "2",
+              // How far this entry got, so an entry cut short -- skipped, or
+              // broken halfway -- moves the clock by what was played and the
+              // next one starts where this one stopped, not after a gap.
+              "-progress", "pipe:3", "-stats_period", "0.5",
+              "-threads", "2", ...(position > 0 ? ["-ss", String(position)] : []), ...protocolArgs(file), "-i", file,
+              ...extra, "-t", String(duration),
+              ...(o.video ? [
+                "-map", hasVideo ? "0:v:0" : "1:v:0", "-map", codecs.audio ? "0:a:0" : "1:a:0",
+                "-vf", `fps=30,scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2,setsar=1,setpts=PTS-STARTPTS`,
+                "-c:v", "libx264", "-threads", "2", "-preset", "veryfast", "-tune", "zerolatency",
+                "-crf", "23", "-pix_fmt", "yuv420p", "-g", "60", "-keyint_min", "60", "-sc_threshold", "0",
+              ] : ["-map", "0:a:0", "-vn"]),
+              "-af", "aresample=48000,asetpts=PTS-STARTPTS", "-c:a", "aac", "-b:a", "160k", "-ac", "2",
+              "-mpegts_flags", "+initial_discontinuity", "-output_ts_offset", String(offset), "-mpegts_copyts", "1", "-muxdelay", "0", "-muxpreload", "0",
+              "-f", "mpegts", "pipe:1",
+            ];
+            const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe", "pipe"] });
+            let tail = "";
+            child.stderr!.on("data", chunk => { tail = (tail + chunk.toString()).slice(-1500); });
+            (child.stdio[3] as Readable | null)?.on("data", (chunk: Buffer) => {
+              const found = /out_time_us=(\d+)/g;
+              let match: RegExpExecArray | null;
+              while ((match = found.exec(chunk.toString())) !== null) reached = Math.max(reached, Number(match[1]) / 1e6);
+            });
+            const closed = new Promise<number | null>((resolve) => {
+              child.once("error", error => { tail = error.message; resolve(-1); });
+              child.once("close", code => resolve(code));
+            });
+            const abort = (): void => { child.kill("SIGKILL"); };
+            signal.addEventListener("abort", abort, { once: true });
+            this.stopCurrent = abort;
+            let skipped = false;
+            try {
+              for await (const chunk of child.stdout as Readable) {
+                if (signal.aborted) return;
+                yield chunk as Buffer;
+              }
+              const code = await closed;
+              if (signal.aborted) return;
+              skipped = this.skipping;
+              if (code !== 0 && !skipped) throw new Error(`Playlist entry ${at + 1} failed: ${tail.trim()}`);
+            } finally {
+              this.stopCurrent = null;
+              this.skipping = false;
+              signal.removeEventListener("abort", abort);
+              abort();
+              await closed;
+            }
+            failuresInARow = 0;
+            played += 1;
+            // Match the frame grid used above so rounding cannot accumulate a
+            // backwards timestamp over hundreds of short files.
+            const length = skipped ? Math.min(duration, reached) : duration;
+            offset += o.video ? Math.ceil(length * 30) / 30 : length;
+          } catch (error) {
+            if (signal.aborted || !o.passOver) throw error;
+            // Passed over, not dialled again: the next entry is what a
+            // listener should hear, and a file that will not decode now will
+            // not decode in two seconds either.
+            const reason = error instanceof Error ? error.message : String(error);
+            o.onFailure?.({ at, file, reason });
+            if (reached > 0) offset += o.video ? Math.ceil(reached * 30) / 30 : reached;
+            failuresInARow += 1;
+            if (failuresInARow >= Math.min(MAX_FAILURES_IN_A_ROW, Math.max(1, files.length))) {
+              throw new Error(`Nothing in this playlist would play: ${reason}`);
+            }
           }
-          const code = await closed;
-          if (signal.aborted) return;
-          if (code !== 0) throw new Error(`Playlist entry ${at + 1} failed: ${tail.trim()}`);
-        } finally {
-          signal.removeEventListener("abort", abort);
-          abort();
-          await closed;
         }
-        // Match the frame grid used above so rounding cannot accumulate a
-        // backwards timestamp over hundreds of short files.
-        offset += o.video ? Math.ceil(duration * 30) / 30 : duration;
       }
       this.complete = !signal.aborted;
     } catch (error) {

package/src/publish-choice.ts

@@ -0,0 +1,35 @@
+/**
+ * Whether this server goes in the public directory.
+ *
+ * A listing is a phone code and a link anybody can open, so it is a thing
+ * somebody chose, not a thing that happens because a daemon had no terminal
+ * to ask on. The choice is asked once, or taken from a flag, and written into
+ * config.json beside the library, and every later start reads it back.
+ *
+ * Servers that were listed before the choice was written down keep being
+ * listed: a daemon without a terminal used to publish by itself, and quietly
+ * taking it off the directory on an update would be changing somebody's
+ * choice for them. A server new to this machine is not listed until asked.
+ */
+export type PublishFlag = "ask" | "yes" | "no";
+
+/**
+ * "yes" or "no" when the answer is already known, "ask" when there is a
+ * person at the terminal to ask.
+ */
+export function publishChoice(
+  flag: PublishFlag,
+  recorded: boolean | undefined,
+  interactive: boolean,
+  established: boolean,
+): "yes" | "no" | "ask" {
+  if (flag !== "ask") return flag;
+  if (recorded !== undefined) return recorded ? "yes" : "no";
+  if (interactive) return "ask";
+  return established ? "yes" : "no";
+}
+
+/** Whether to write the answer down: only a choice nobody had made yet. */
+export function shouldRecord(flag: PublishFlag, recorded: boolean | undefined): boolean {
+  return flag === "ask" && recorded === undefined;
+}