nixamp 0.5.4 → 0.5.5

package/dist/main.js

@@ -12,7 +12,7 @@ import { resolve } from "node:path";
 import { detectTools, formatTime, peaks, RATE, Stream, toMono, } from "./audio.js";
 import { Analyser, bandEdges, bands, decay } from "./fft.js";
 import { version } from "./meta.js";
-import { displayName, loadSource } from "./playlist.js";
+import { displayName, loadSource, loadTagged } from "./playlist.js";
 import { isRemote } from "./sources.js";
 import { DEFAULT_PORT } from "./server.js";
 const FFT_SIZE = 2048;
@@ -317,7 +317,7 @@ export async function main() {
     // The titles, arriving into a player that is already up. Not awaited, and
     // applied only if the list is still the one it describes.
     if (!isRemote(target)) {
-        void loadSource(tools, target, true)
+        void loadTagged(tools, target)
             .then((tagged) => {
             if (tagged.length !== state.tracks.length)
                 return;

package/dist/playlist.d.ts

@@ -24,4 +24,19 @@ export declare function loadSource(tools: Tools, source: string, probeTags?: boo
  * the caller decides when to pay for it. Untagged entries still play.
  */
 export declare function loadPlaylist(tools: Tools, root: string, probeTags?: boolean): Track[];
+/**
+ * The same tags, read without holding the process still.
+ *
+ * `probe` is a spawnSync per file, so reading a library inside one async
+ * function never yields: the listening socket keeps accepting connections,
+ * the kernel completes their handshakes, and the process answers none of them
+ * until the last file is done. From outside that is indistinguishable from a
+ * firewall -- a connection that opens and then says nothing -- and on a library
+ * of any size it lasts minutes.
+ *
+ * One turn of the event loop per file fixes it. A request then waits for one
+ * ffprobe rather than for the whole library, and the tagging still finishes in
+ * about the time it did.
+ */
+export declare function loadTagged(tools: Tools, source: string): Promise<Track[]>;
 export declare function displayName(track: Track): string;

package/dist/playlist.js

@@ -121,6 +121,32 @@ export function loadPlaylist(tools, root, probeTags = true) {
         artist: "", album: "", duration: 0,
     });
 }
+/**
+ * The same tags, read without holding the process still.
+ *
+ * `probe` is a spawnSync per file, so reading a library inside one async
+ * function never yields: the listening socket keeps accepting connections,
+ * the kernel completes their handshakes, and the process answers none of them
+ * until the last file is done. From outside that is indistinguishable from a
+ * firewall -- a connection that opens and then says nothing -- and on a library
+ * of any size it lasts minutes.
+ *
+ * One turn of the event loop per file fixes it. A request then waits for one
+ * ffprobe rather than for the whole library, and the tagging still finishes in
+ * about the time it did.
+ */
+export async function loadTagged(tools, source) {
+    // A URL is one thing and is never probed; a playlist carries its own titles.
+    if (isRemote(source) || isPlaylistFile(source))
+        return loadSource(tools, source, true);
+    const paths = findAudio(source);
+    const tracks = [];
+    for (const path of paths) {
+        tracks.push(probe(tools, path));
+        await new Promise((done) => setImmediate(done));
+    }
+    return tracks;
+}
 export function displayName(track) {
     return track.artist ? `${track.artist} — ${track.title}` : track.title;
 }

package/dist/server.js

@@ -39,7 +39,7 @@ import { extname, join, normalize, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { detectTools, peaks, RATE, Stream, toMono, } from "./audio.js";
 import { Analyser, bandEdges, bands, decay } from "./fft.js";
-import { loadSource } from "./playlist.js";
+import { loadSource, loadTagged } from "./playlist.js";
 import { emptySnapshot, parseCommand, } from "./protocol.js";
 const FFT_SIZE = 2048;
 export const SERVE_BAND_COUNT = 24;
@@ -2131,7 +2131,7 @@ export async function serve(argv, version = "0.1.0") {
     // awaited: nothing downstream needs it, and a library that takes a minute to
     // read should cost nobody a minute of silence.
     if (tracks.length > 0 && !isRemote(root)) {
-        void loadSource(tools, root, true)
+        void loadTagged(tools, root)
             .then((tagged) => engine.retag(tagged, root))
             .catch(() => {
             // Filenames are a working player. A failure here is worth nothing but

package/package.json

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

package/src/main.ts

@@ -15,7 +15,7 @@ import {
 } from "./audio.ts";
 import { Analyser, bandEdges, bands, decay } from "./fft.ts";
 import { version } from "./meta.ts";
-import { displayName, loadSource } from "./playlist.ts";
+import { displayName, loadSource, loadTagged } from "./playlist.ts";
 import { isRemote } from "./sources.ts";
 import { DEFAULT_PORT } from "./server.ts";
 import type { DaemonState } from "./daemon.ts";
@@ -352,7 +352,7 @@ export async function main(): Promise<void> {
   // The titles, arriving into a player that is already up. Not awaited, and
   // applied only if the list is still the one it describes.
   if (!isRemote(target)) {
-    void loadSource(tools, target, true)
+    void loadTagged(tools, target)
       .then((tagged) => {
         if (tagged.length !== state.tracks.length) return;
         if (tagged.some((track, at) => track.path !== state.tracks[at]?.path)) return;

package/src/playlist.ts

@@ -132,6 +132,33 @@ export function loadPlaylist(tools: Tools, root: string, probeTags = true): Trac
     });
 }
 
+/**
+ * The same tags, read without holding the process still.
+ *
+ * `probe` is a spawnSync per file, so reading a library inside one async
+ * function never yields: the listening socket keeps accepting connections,
+ * the kernel completes their handshakes, and the process answers none of them
+ * until the last file is done. From outside that is indistinguishable from a
+ * firewall -- a connection that opens and then says nothing -- and on a library
+ * of any size it lasts minutes.
+ *
+ * One turn of the event loop per file fixes it. A request then waits for one
+ * ffprobe rather than for the whole library, and the tagging still finishes in
+ * about the time it did.
+ */
+export async function loadTagged(tools: Tools, source: string): Promise<Track[]> {
+  // A URL is one thing and is never probed; a playlist carries its own titles.
+  if (isRemote(source) || isPlaylistFile(source)) return loadSource(tools, source, true);
+
+  const paths = findAudio(source);
+  const tracks: Track[] = [];
+  for (const path of paths) {
+    tracks.push(probe(tools, path));
+    await new Promise<void>((done) => setImmediate(done));
+  }
+  return tracks;
+}
+
 export function displayName(track: Track): string {
   return track.artist ? `${track.artist} — ${track.title}` : track.title;
 }

package/src/server.ts

@@ -76,7 +76,7 @@ import {
   type Tools, type Track,
 } from "./audio.ts";
 import { Analyser, bandEdges, bands, decay } from "./fft.ts";
-import { loadSource } from "./playlist.ts";
+import { loadSource, loadTagged } from "./playlist.ts";
 import {
   emptySnapshot, parseCommand,
   type Command, type RemoteTrack, type Snapshot,
@@ -2448,7 +2448,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
   // awaited: nothing downstream needs it, and a library that takes a minute to
   // read should cost nobody a minute of silence.
   if (tracks.length > 0 && !isRemote(root)) {
-    void loadSource(tools, root, true)
+    void loadTagged(tools, root)
       .then((tagged) => engine.retag(tagged, root))
       .catch(() => {
         // Filenames are a working player. A failure here is worth nothing but

package/web/dist/sw.js

@@ -1,5 +1,5 @@
 /* nixamp service worker — generated, do not edit */
-const CACHE = "nixamp-1788937565929";
+const CACHE = "nixamp-1788938369729";
 const PRECACHE = [
   "/",
   "/apple-touch-icon.png",