nixamp 0.1.0

package/dist/protocol.js

@@ -0,0 +1,53 @@
+/**
+ * The wire format between a running nixamp and any remote that drives it.
+ *
+ * Kept free of node imports on purpose: the browser client type-checks against
+ * this same file, so a change to the protocol breaks both sides at once rather
+ * than one of them at runtime.
+ */
+export const COMMAND_TYPES = ["play", "toggle", "stop", "next", "prev", "select"];
+/**
+ * Commands arrive as untrusted JSON from a browser on the LAN, so nothing is
+ * assumed: an unknown type or a non-integer index is a null, not a throw.
+ */
+export function parseCommand(input) {
+    if (typeof input !== "object" || input === null)
+        return null;
+    const record = input;
+    const type = record.type;
+    if (typeof type !== "string")
+        return null;
+    const index = record.index;
+    const validIndex = typeof index === "number" && Number.isInteger(index) && index >= 0;
+    switch (type) {
+        case "toggle":
+        case "stop":
+        case "next":
+        case "prev":
+            return { type };
+        case "play":
+            return validIndex ? { type: "play", index: index } : { type: "play" };
+        case "select":
+            return validIndex ? { type: "select", index: index } : null;
+        default:
+            return null;
+    }
+}
+/** The name a remote shows for a track. */
+export function remoteName(track) {
+    return track.artist ? `${track.artist} — ${track.title}` : track.title;
+}
+export function emptySnapshot() {
+    return {
+        revision: 0,
+        tracks: [],
+        index: 0,
+        playing: false,
+        position: 0,
+        bars: [],
+        levels: [0, 0],
+        silent: true,
+        note: "",
+        root: "",
+    };
+}

package/dist/serve.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/serve.js

@@ -0,0 +1,10 @@
+/**
+ * The server on its own, with no terminal UI attached.
+ *
+ * `nixamp serve` reaches the same code through main.ts, but the desktop app
+ * spawns this file directly: it pulls in no TUI, so what it has to load is the
+ * four modules that decode and serve and nothing else.
+ */
+import { version } from "./meta.js";
+import { serve } from "./server.js";
+await serve(process.argv.slice(2), version());

package/dist/server.d.ts

@@ -0,0 +1,105 @@
+import { type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { type Tools, type Track } from "./audio.ts";
+import { type Command, type RemoteTrack, type Snapshot } from "./protocol.ts";
+export declare const SERVE_BAND_COUNT = 24;
+export declare const DEFAULT_PORT = 4321;
+export interface ServeOptions {
+    root: string;
+    port: number;
+    host: string;
+    /** Directory of built PWA files to serve at `/`, when there is one. */
+    web: string | null;
+    /** Stream the library's bytes to remotes. Off keeps the audio on this box. */
+    media: boolean;
+}
+/**
+ * Flags are parsed by hand: three of them do not justify a dependency, and the
+ * failure mode of a wrong `--port` should be a message rather than NaN.
+ */
+export declare function parseServeArgs(argv: string[]): ServeOptions;
+export declare function contentType(path: string): string;
+export interface ByteRange {
+    start: number;
+    end: number;
+}
+/**
+ * `Range: bytes=0-` and friends. Anything malformed, unsatisfiable or
+ * multi-range is a null, which the caller answers with the whole file —
+ * the behaviour a browser expects when it cannot have the range it asked for.
+ */
+export declare function parseRange(header: string | undefined, size: number): ByteRange | null;
+/**
+ * Resolve a URL path inside a directory, or null when it escapes.
+ * `..` in a request path is the oldest bug in static file serving.
+ */
+export declare function safeJoin(rootDir: string, urlPath: string): string | null;
+/** What the HTTP layer needs from a player. Tests hand it a fake. */
+export interface Engine {
+    snapshot(): Snapshot;
+    command(command: Command): void;
+    subscribe(listener: (snapshot: Snapshot) => void): () => void;
+    /** Absolute path of a track, or undefined when the index is not one. */
+    trackPath(index: number): string | undefined;
+    stop(): void;
+}
+export declare function toRemoteTracks(tracks: Track[]): RemoteTrack[];
+/**
+ * The headless player: the terminal app's engine without the terminal.
+ * One ffmpeg decodes, ffplay makes the sound, and every sample is measured on
+ * its way past so a remote can draw the same spectrum the TUI would.
+ */
+export declare class PlayerEngine implements Engine {
+    private readonly tracks;
+    private readonly root;
+    /** Frames a second pushed to remotes. */
+    private readonly fps;
+    private readonly listeners;
+    private readonly analyser;
+    private readonly edges;
+    private readonly stream;
+    private pending;
+    private revision;
+    /** Pushes are coalesced: the analyser fires far faster than a remote can draw. */
+    private timer;
+    private dirty;
+    private state;
+    constructor(tracks: Track[], root: string, tools: Tools, 
+    /** Frames a second pushed to remotes. */
+    fps?: number);
+    private readonly silent;
+    private consume;
+    snapshot(): Snapshot;
+    trackPath(index: number): string | undefined;
+    command(command: Command): void;
+    private clamp;
+    private step;
+    private start;
+    private halt;
+    subscribe(listener: (snapshot: Snapshot) => void): () => void;
+    private push;
+    stop(): void;
+}
+/** An engine with no library behind it, for the hosted PWA. */
+export declare class EmptyEngine implements Engine {
+    private readonly note;
+    constructor(note?: string);
+    snapshot(): Snapshot;
+    command(): void;
+    subscribe(listener: (snapshot: Snapshot) => void): () => void;
+    trackPath(): undefined;
+    stop(): void;
+}
+export interface HandlerOptions {
+    web: string | null;
+    media: boolean;
+    version: string;
+}
+/**
+ * The whole HTTP surface, as a plain function of a request — so a test can
+ * drive it with a real socket and no ffmpeg in sight.
+ */
+export declare function createHandler(engine: Engine, options: HandlerOptions): (request: IncomingMessage, response: ServerResponse) => Promise<void>;
+export declare function createServer(engine: Engine, options: HandlerOptions): Server;
+/** Where a remote on another device should point its browser. */
+export declare function addressesFor(host: string, port: number): string[];
+export declare function serve(argv: string[], version?: string): Promise<void>;