nixamp 0.55.2 → 0.57.0

package/src/label-profiles.ts

@@ -0,0 +1,212 @@
+/**
+ * Who is in each AI label band: an OpenProfile page per member and one for
+ * the band, so the same people sing, appear on covers and in videos every
+ * time instead of whoever an image model draws next.
+ *
+ *     <artist folder>/artist.md                 the band: genre, sound, members, discography
+ *     <artist folder>/members/<slug>.md         a member: role, look, voice, personality...
+ *     <artist folder>/members/<slug>.jpg        their reference portrait
+ *
+ * The pages are the source of truth once written: a person may edit a
+ * member's look or voice by hand, and what is generated next reads the page
+ * back (readMember). Members are invented once, by a language model, as
+ * fictional people; the portrait is drawn from the look and kept.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { askJson } from "./ai-text.ts";
+
+export interface Member {
+  slug: string;
+  name: string;
+  /** What they do in the band: "lead vocals", "lead guitar", "drums"... */
+  role: string;
+  /** How they look, in enough detail to draw the same person again: age, face, hair, build, signature clothes. */
+  look: string;
+  /** How they sound, for a singer; how they play, for the rest. */
+  voice: string;
+  personality: string;
+  influences: string;
+  bio: string;
+}
+
+export function memberSlug(name: string): string {
+  return name.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "member";
+}
+
+function line(text: string): string {
+  return text.replace(/[\r\n]+/g, " ").trim();
+}
+
+/** A member's OpenProfile page. */
+export function memberMarkdown(member: Member, band: { name: string; holder: string }): string {
+  return [
+    `# ${member.name}`,
+    "",
+    "- **Kind**: fictional musician, made with AI",
+    `- **Band**: [${band.name}](../artist.md)`,
+    `- **Role**: ${line(member.role)}`,
+    `- **Avatar**: [portrait](${member.slug}.jpg)`,
+    `- **Parent**: ${band.holder}`,
+    "",
+    line(member.bio),
+    "",
+    "## Look",
+    "",
+    line(member.look),
+    "",
+    "## Voice",
+    "",
+    line(member.voice),
+    "",
+    "## Personality",
+    "",
+    line(member.personality),
+    "",
+    "## Influences",
+    "",
+    line(member.influences),
+    "",
+  ].join("\n");
+}
+
+/** A member's page read back, so hand edits win; null when it is not one of ours. */
+export function readMember(text: string, slug: string): Member | null {
+  const name = /^#\s+(.+)$/m.exec(text)?.[1]?.trim() ?? "";
+  if (!name) return null;
+  const field = (label: string): string => new RegExp(`^- \\*\\*${label}\\*\\*:\\s*(.+)$`, "m").exec(text)?.[1]?.trim() ?? "";
+  const section = (heading: string): string => {
+    const match = new RegExp(`^##\\s+${heading}\\s*$([\\s\\S]*?)(?=^##\\s|$(?![\\s\\S]))`, "m").exec(text);
+    return (match?.[1] ?? "").trim().replace(/\s+/g, " ");
+  };
+  // The bio is the prose between the fields and the first section.
+  const bio = (/^- \*\*Parent\*\*:.*$\n+([\s\S]*?)(?=^##\s)/m.exec(text)?.[1] ?? "").trim().replace(/\s+/g, " ");
+  return { slug, name, role: field("Role"), look: section("Look"), voice: section("Voice"), personality: section("Personality"), influences: section("Influences"), bio };
+}
+
+/** The band's OpenProfile page. */
+export function bandMarkdown(band: {
+  name: string; genre: string; sound: string; voice: string; bio: string; themes: string; holder: string;
+  members: Member[]; albums: Array<{ year: number; title: string }>;
+}): string {
+  return [
+    `# ${band.name}`,
+    "",
+    "- **Kind**: band, fictional, made with AI",
+    `- **Genre**: ${band.genre}`,
+    `- **Label**: ${band.holder}`,
+    `- **Members**: ${band.members.map((one) => `[${one.name}](members/${one.slug}.md) (${one.role})`).join(", ")}`,
+    "",
+    line(band.bio),
+    "",
+    "## Sound",
+    "",
+    line(band.sound),
+    "",
+    "## Lead voice",
+    "",
+    line(band.voice),
+    "",
+    "## Themes",
+    "",
+    line(band.themes),
+    "",
+    "## Discography",
+    "",
+    ...(band.albums.length ? band.albums.map((one) => `- ${one.year} · ${one.title}`) : ["- (first album on its way)"]),
+    "",
+  ].join("\n");
+}
+
+const MEMBERS_SYSTEM = [
+  "You cast the members of a fictional band (or the one person behind a solo act) for an AI record label.",
+  "Everyone is invented: never a real person, never a lookalike of one. Give each a full name, their role, and a look described",
+  "precisely enough that an illustrator could draw the same person every time: age range, face, skin tone, hair, build, signature outfit and accessories.",
+  "Answer as JSON: {\"members\": [{\"name\": \"\", \"role\": \"\", \"look\": \"at most 300 characters\", \"voice\": \"how they sing or play, at most 150 characters\",",
+  "\"personality\": \"at most 150 characters\", \"influences\": \"styles and eras, never named artists, at most 120 characters\", \"bio\": \"one or two sentences\"}]}.",
+].join(" ");
+
+/** The band's people, invented once: one for a solo act, three to five for a band. */
+export async function inventMembers(
+  band: { name: string; genre: string; sound: string; voice: string; bio: string },
+  ask: typeof askJson,
+): Promise<Member[]> {
+  const answer = await ask({
+    system: MEMBERS_SYSTEM,
+    prompt: [
+      `Act: ${band.name} (${band.genre})`,
+      `Sound: ${band.sound}`,
+      `Lead voice: ${band.voice}`,
+      band.bio ? `Who they are: ${band.bio}` : "",
+      "If the name reads as one person's, cast that one person as the solo artist (role: vocals and the instrument that fits); otherwise cast the band, the lead singer first, matching the lead voice.",
+    ].filter(Boolean).join("\n"),
+    maxTokens: 2000,
+    timeoutMs: 90_000,
+  });
+  const list = Array.isArray(answer.value["members"]) ? answer.value["members"] as Array<Record<string, unknown>> : [];
+  const seen = new Set<string>();
+  const members = list
+    .map((one) => {
+      const name = line(String(one?.["name"] ?? "")).slice(0, 60);
+      return {
+        slug: memberSlug(name), name,
+        role: line(String(one?.["role"] ?? "")).slice(0, 80),
+        look: line(String(one?.["look"] ?? "")).slice(0, 500),
+        voice: line(String(one?.["voice"] ?? "")).slice(0, 300),
+        personality: line(String(one?.["personality"] ?? "")).slice(0, 300),
+        influences: line(String(one?.["influences"] ?? "")).slice(0, 200),
+        bio: line(String(one?.["bio"] ?? "")).slice(0, 500),
+      };
+    })
+    .filter((one) => one.name && one.look.length > 20 && !seen.has(one.slug) && seen.add(one.slug))
+    .slice(0, 6);
+  if (members.length === 0) throw new Error("the model cast nobody");
+  return members;
+}
+
+/** How the band looks on stage, for a cover or a scene: every member by name, role and look. */
+export function castLine(members: Member[]): string {
+  return members.map((one) => `${one.name} (${one.role}): ${one.look}`).join("; ");
+}
+
+/** The portrait prompt for a member: the same person every time it is used as a reference. */
+export function portraitPrompt(member: Member, band: { name: string; genre: string }): string {
+  return `Photographic portrait of ${member.look}. ${member.role} in the ${band.genre} band ${band.name}. Head and shoulders, three-quarter view, natural expression, soft studio light, plain dark background, sharp focus, 85mm lens. No text, no logos.`;
+}
+
+/** Writes the member pages and portraits that are missing; returns the members as the pages now say. */
+export async function writeMembers(folder: string, members: Member[], band: { name: string; genre: string; holder: string }, draw: ((prompt: string) => Promise<Buffer | null>) | null): Promise<Member[]> {
+  const dir = join(folder, "members");
+  mkdirSync(dir, { recursive: true });
+  const out: Member[] = [];
+  for (const member of members) {
+    const page = join(dir, `${member.slug}.md`);
+    let current = member;
+    try {
+      current = readMember(readFileSync(page, "utf8"), member.slug) ?? member;
+    } catch {
+      writeFileSync(page, memberMarkdown(member, band));
+    }
+    const portrait = join(dir, `${member.slug}.jpg`);
+    let drawn = true;
+    try { readFileSync(portrait); } catch { drawn = false; }
+    if (!drawn && draw) {
+      const picture = await draw(portraitPrompt(current, band)).catch(() => null);
+      if (picture) writeFileSync(portrait, picture);
+    }
+    out.push(current);
+  }
+  return out;
+}
+
+/** The members as their pages say now (hand edits included), in the order given. */
+export function readMembers(folder: string, slugs: string[]): Member[] {
+  return slugs.flatMap((slug) => {
+    try {
+      const member = readMember(readFileSync(join(folder, "members", `${slug}.md`), "utf8"), slug);
+      return member ? [member] : [];
+    } catch {
+      return [];
+    }
+  });
+}

package/src/label-routes.ts

@@ -20,9 +20,12 @@ import { adCsp, withPageAd, type GuideAds } from "./station-guide.ts";
 // MP3 or a zip needs a grant from nixamp.com's store (music-store.ts).
 const FILE = /^\/api\/v1\/label\/([a-f0-9]{10})\/([a-f0-9]{8})\/(\d{1,3}\.(?:txt|mp3)|cover\.jpg)$/;
 
+/** An artist's OpenProfile pages and portraits: artist.md, members/<slug>.md, members/<slug>.jpg. */
+const PROFILE = /^\/api\/v1\/label\/([a-f0-9]{10})\/(artist\.md|members\/[a-z0-9-]{1,40}\.(?:md|jpg))$/;
+
 /** Whether this path is the label's public face (an MP3 or the zip still asks for its grant). */
 export function isPublicLabelPath(path: string): boolean {
-  return path === "/label" || path === "/api/v1/label" || path === "/api/v1/label/zip" || FILE.test(path);
+  return path === "/label" || path === "/api/v1/label" || path === "/api/v1/label/zip" || FILE.test(path) || PROFILE.test(path);
 }
 
 /** nixamp.com's page that sells this: a song, an album or everything by the artist. */
@@ -146,6 +149,16 @@ export async function handleLabelRoutes(
         response.end();
         return true;
       }
+      const profile = PROFILE.exec(path);
+      if (profile) {
+        const found = label.profileFile(profile[1]!, profile[2]!);
+        if (!found) {
+          ctx.json(response, 404, { error: "no such profile", code: "not_found" });
+          return true;
+        }
+        sendFile(request, response, found.path, found.type, "");
+        return true;
+      }
       const [, artist, album, what] = FILE.exec(path)!;
       if (what!.endsWith(".mp3")) {
         const scope = ctx.grants && grant ? await ctx.grants.check(grant) : null;
@@ -270,6 +283,11 @@ audio{width:100%;max-width:360px;height:36px}
 details{margin-top:4px}summary{cursor:pointer;color:var(--muted);font-size:.9rem}
 pre.lyrics{white-space:pre-wrap;font:inherit;font-size:.95rem;margin:8px 0 0;padding:12px;border-radius:8px;background:var(--bg)}
 .dl{font-size:.85rem}.soon{color:var(--muted);font-size:.85rem}
+ul.members{list-style:none;margin:12px 0 4px;padding:0;display:flex;flex-wrap:wrap;gap:10px}
+ul.members a{display:flex;gap:8px;align-items:center;color:var(--fg);text-decoration:none;border:1px solid var(--line);border-radius:999px;padding:4px 12px 4px 4px}
+ul.members a:hover,ul.members a:focus-visible{border-color:var(--accent)}
+ul.members img{width:40px;height:40px;border-radius:50%;object-fit:cover;background:var(--line)}
+ul.members span{display:grid;line-height:1.2}ul.members .role{color:var(--muted);font-size:.8rem}
 a.buy{display:inline-block;font-weight:700;text-decoration:none;border:1px solid var(--accent);border-radius:999px;padding:2px 10px}
 footer{margin-top:48px;color:var(--muted);font-size:.85rem}footer a{color:inherit}
 `;
@@ -285,6 +303,16 @@ export const LABEL_CSP = [
 
 type Shop = { site: string; server: string } | undefined;
 
+/** The band: each member's portrait, name and role, linking to their OpenProfile page. */
+function renderMembers(artist: PublicArtist): string {
+  if (!artist.members?.length) return "";
+  const base = `/api/v1/label/${artist.key}`;
+  return `<ul class="members">${artist.members.map((member) => `<li><a href="${base}/members/${escape(member.slug)}.md" title="${escape(member.bio)}">`
+    + `<img src="${base}/members/${escape(member.slug)}.jpg" alt="" width="56" height="56" loading="lazy">`
+    + `<span><strong>${escape(member.name)}</strong><span class="role">${escape(member.role)}</span></span></a></li>`).join("")}</ul>`
+    + `<p class="dl"><a href="${base}/artist.md">${escape(artist.name)}'s profile</a></p>`;
+}
+
 function price(cents: number): string {
   return cents < 100 ? `${cents}¢` : `$${(cents / 100).toFixed(cents % 100 ? 2 : 0)}`;
 }
@@ -313,7 +341,7 @@ export function renderLabel(view: ReturnType<AiLabel["publicView"]>, shop?: Shop
   const nav = view.genres.length > 1 ? `<nav class="genres" aria-label="Genres">${view.genres.map((one) => `<a href="#${escape(one.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}">${escape(one.genre)}</a>`).join("")}</nav>` : "";
   const sections = view.genres.map((genre) => `<section class="genre" id="${escape(genre.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}" aria-labelledby="g-${escape(genre.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}">`
     + `<h2 id="g-${escape(genre.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}">${escape(genre.genre)}${genre.station ? ` <a href="/watch/${escape(genre.station)}">Listen live, free →</a>` : ""}</h2>`
-    + genre.artists.map((artist) => `<article class="artist"><h3>${escape(artist.name)}</h3>${artist.bio ? `<p class="bio">${escape(artist.bio)}</p>` : ""}`
+    + genre.artists.map((artist) => `<article class="artist"><h3>${escape(artist.name)}</h3>${artist.bio ? `<p class="bio">${escape(artist.bio)}</p>` : ""}${renderMembers(artist)}`
       + `${shop ? `<p>${buy(shop, "artist", artist.key, "", 0, "everything by them")}</p>` : ""}`
       + `${artist.albums.map((album) => renderAlbum(artist, album, shop)).join("")}</article>`).join("")
     + `</section>`).join("");

package/src/library.ts

@@ -39,6 +39,19 @@ export interface Config {
   limits?: Record<string, unknown>;
   /** Proxies whose X-Forwarded-For is believed for listener shares (`nixamp station shares trust ADDRESS`). */
   trustedProxies?: string[];
+  /** Seconds with nobody listening before a station sleeps; 0 never. 60 when unset. */
+  stationIdleSeconds?: number;
+}
+
+/** A station with nobody listening sleeps after this many seconds, unless config or NIXAMP_STATION_IDLE says otherwise. */
+export const DEFAULT_STATION_IDLE_SECONDS = 60;
+
+/** How long a station waits with nobody listening before it sleeps: env, then config, then 60; 0 is never. */
+export function stationIdleSeconds(env: Record<string, string | undefined>, config: Config): number {
+  const raw = env["NIXAMP_STATION_IDLE"];
+  if (raw !== undefined && raw.trim() !== "" && Number.isFinite(Number(raw)) && Number(raw) >= 0) return Number(raw);
+  const set = config.stationIdleSeconds;
+  return typeof set === "number" && Number.isFinite(set) && set >= 0 ? set : DEFAULT_STATION_IDLE_SECONDS;
 }
 
 export function configPath(): string {
@@ -55,6 +68,7 @@ export function readConfig(): Config {
       ...(typeof record["publish"] === "boolean" ? { publish: record["publish"] } : {}),
       ...(typeof record["autoStations"] === "object" && record["autoStations"] !== null ? { autoStations: record["autoStations"] as Record<string, unknown> } : {}),
       ...(typeof record["limits"] === "object" && record["limits"] !== null ? { limits: record["limits"] as Record<string, unknown> } : {}),
+      ...(typeof record["stationIdleSeconds"] === "number" ? { stationIdleSeconds: record["stationIdleSeconds"] } : {}),
       ...(Array.isArray(record["trustedProxies"]) ? { trustedProxies: (record["trustedProxies"] as unknown[]).filter((one): one is string => typeof one === "string") } : {}),
       ...(Array.isArray(record["guideHosts"]) ? { guideHosts: (record["guideHosts"] as unknown[]).filter((one): one is string => typeof one === "string") } : {}),
       ...(typeof record["guideAds"] === "object" && record["guideAds"] !== null ? { guideAds: record["guideAds"] as Config["guideAds"] } : {}),

package/src/playlist-input.ts

@@ -39,7 +39,16 @@ export interface PlaylistInput {
    * `next` answers a file to play (an advert, an ident) or null for no break
    * this time. The break is outside the rotation and the station's history.
    */
-  breaks?: { everySeconds: number | (() => number); next: () => Promise<string | null> };
+  breaks?: {
+    everySeconds: number | (() => number);
+    next: () => Promise<string | null>;
+    /**
+     * Seconds of airtime since the last break when this stream opens, asked
+     * once per open: a station that slept with nobody listening carries its
+     * clock across, so breaks come every so often of time on the air.
+     */
+    sinceBreak?: () => number;
+  };
   /** Told when an entry is passed over because it would not play. */
   onFailure?: (event: { at: number; file: string; reason: string }) => void;
 }
@@ -51,12 +60,26 @@ export interface PlaylistInput {
  */
 export const MAX_FAILURES_IN_A_ROW = 5;
 
+/** An entry that started: where it sits in the stream and in its pass. */
+interface Entry {
+  at: number;
+  file: string;
+  start: number;
+  position: number;
+  list: readonly string[];
+  /** The pass's order and how far into it the next entry is, for resumePoint. */
+  order: readonly number[];
+  step: number;
+  /** Where the break clock stood when it started. */
+  lastBreak: number;
+}
+
 /** 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; file: string; start: number; position: number; list: readonly string[] }[] = [];
+  private entries: Entry[] = [];
   error: Error | null = null;
   complete = false;
   /**
@@ -68,7 +91,7 @@ export class PlaylistInputStream {
   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; list: readonly string[] }> {
+  get history(): ReadonlyArray<Entry> {
     return this.entries;
   }
 
@@ -84,6 +107,22 @@ export class PlaylistInputStream {
       : { at: this.options.at, position: this.options.position, list: this.options.files };
   }
 
+  /**
+   * Where to pick up after this point of the stream, for a station that
+   * sleeps with nobody listening: the file that is on ("" in a break), the
+   * rest of this pass in the order it was going to play, and the seconds
+   * of airtime since the last break.
+   */
+  resumePoint(seconds: number): { file: string; upcoming: string[]; sinceBreak: number } | null {
+    const entry = this.entries.findLast(one => seconds >= one.start) ?? this.entries[0];
+    if (!entry) return null;
+    return {
+      file: entry.at >= 0 ? entry.file : "",
+      upcoming: entry.order.slice(entry.step).map((index) => entry.list[index]).filter((one): one is string => typeof one === "string"),
+      sinceBreak: entry.at < 0 ? 0 : Math.max(0, seconds - entry.lastBreak),
+    };
+  }
+
   /** The decoder for the entry that is on, so skip() can end it early. */
   private stopCurrent: (() => void) | null = null;
   private skipping = false;
@@ -114,7 +153,9 @@ export class PlaylistInputStream {
       let step = Math.min(Math.max(0, o.at), order.length);
       let played = 0;
       let last = "";
-      let lastBreak = 0;
+      // Counted back from 0 by however long it had been, so a clock carried
+      // across a sleep comes due when it would have on the air.
+      let lastBreak = -Math.max(0, o.breaks?.sinceBreak?.() ?? 0);
       // A film cut for a break, to be picked up where it stopped.
       let resume: { at: number; file: string; position: number } | null = null;
       for (;;) {
@@ -179,7 +220,7 @@ export class PlaylistInputStream {
             const room = o.video && !isBreak && o.breaks && every > 0 ? every - (offset - lastBreak) : Infinity;
             const cut = room >= 1 && full - room > 5;
             const duration = cut ? room : full;
-            this.entries.push({ at, file, start: offset, position, list: files });
+            this.entries.push({ at, file, start: offset, position, list: files, order, step, lastBreak });
             const hasVideo = Boolean(codecs.video);
             const extra = o.video && !hasVideo
               ? ["-f", "lavfi", "-i", `color=c=black:s=${width}x${height}:r=30`]

package/src/server.ts

@@ -122,7 +122,7 @@ import { Porkbun, isIPv4, isIPv6, type DnsZone } from "./dns.ts";
 import { NameError, Names } from "./names.ts";
 import { AcmeIssuer, Certs } from "./certs.ts";
 import { claimName, fetchCert, humanizeSource, labelFor, readCertFiles, writeCertFiles } from "./naming.ts";
-import { forbiddenLibrary, readConfig, readLibrary, writeConfig } from "./library.ts";
+import { forbiddenLibrary, readConfig, readLibrary, stationIdleSeconds, writeConfig } from "./library.ts";
 import { createThrottle, presentedCredential, type Throttle } from "@profullstack/throttle";
 import { Durable } from "./durable.ts";
 import { notifyAll, resendEmail, webPush, type Notification } from "./notify.ts";
@@ -5940,6 +5940,12 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         return;
       }
 
+      // A station asleep with nobody listening is woken by whoever asks for
+      // its channel here too, and they are held for its first bytes.
+      if ((action === "hls" || action === undefined) && request.method === "GET" && !channels.has(id) && stationOfChannel(id) && options.stations?.runner.isSleeping(stationOfChannel(id))) {
+        await options.stations.runner.awake(stationOfChannel(id));
+      }
+
       // The same channel as HLS: a playlist of short files, which is what
       // Safari on an iPhone plays live -- it will not take the endless MP4
       // below, and spun on it a few times before giving up. Packaged on
@@ -7455,6 +7461,8 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     onRestart: (id) => stationUsage.restarted(id),
     onFailure: (id) => stationUsage.failed(id),
     artistOf: (file) => trackFor(engine, file)?.artist ?? "",
+    // Nobody listening for this long and a station sleeps until somebody does.
+    idleSeconds: () => stationIdleSeconds(process.env, readConfig()),
     store: stationStore,
     channels,
     pull: async (channelId, name, files, known) =>
@@ -7729,6 +7737,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     });
   }
   stationRunner.restore();
+  stationRunner.watchIdle();
   // Where each film has got to, written down every so often, so a restart
   // picks it up from about there rather than from the start. Only when it
   // has changed: a server carrying nothing but live television writes

package/src/station-routes.ts

@@ -114,14 +114,16 @@ function nowPlayingFile(ctx: StationContext, station: Station): string {
 
 export function publicView(ctx: StationContext, station: Station): PublicStation {
   const state = ctx.runner.observed(station.id);
-  const file = state === "live" || state === "recovering" ? nowPlayingFile(ctx, station) : "";
+  // Asleep, what it will wake on: the first listener hears that next.
+  const asleep = ctx.runner.isSleeping?.(station.id) ?? false;
+  const file = asleep ? ctx.runner.nextUp(station.id) : state === "live" || state === "recovering" ? nowPlayingFile(ctx, station) : "";
   // The tags the player read when it put this file on, else the library's.
   const track = file ? (ctx.channels.tagsOf(channelOf(station.id), file) ?? ctx.trackFor(file)) : null;
   // What the channel is carrying wins over the flag: a station made by hand
   // from films streams video whether or not anyone said so.
   const video = station.video || ctx.channels.kindOf(channelOf(station.id)) === "video";
   // How far into the song (or film) on the air, by the encoder's clock, and how long it is.
-  const position = file ? ctx.channels.info(channelOf(station.id))?.position : undefined;
+  const position = file && !asleep ? ctx.channels.info(channelOf(station.id))?.position : undefined;
   const duration = file && ctx.durationOf ? ctx.durationOf(file) : 0;
   const progress = typeof position === "number" && duration > 0 ? { position: Math.round(Math.min(position, duration) * 10) / 10, duration: Math.round(duration * 10) / 10 } : null;
   return {
@@ -161,11 +163,13 @@ export function guideEntries(ctx: StationContext): Array<PublicStation & { page:
   return [...names].map(([slug, one]) => ({ ...publicView(ctx, one), page: links(ctx, one, base).page, m3u: links(ctx, one, base).m3u, group: guideGroup(one), radio: `${radioBase}/radio/${slug}` }));
 }
 
-export function ownerView(ctx: StationContext, station: Station): OwnerStation & { links: ReturnType<typeof links>; nowPlaying: string } {
+export function ownerView(ctx: StationContext, station: Station): OwnerStation & { links: ReturnType<typeof links>; nowPlaying: string; sleeping: boolean } {
   const { failures, idempotencyKey: _key, ...rest } = station;
   return {
     ...rest,
     state: ctx.runner.observed(station.id),
+    // On the air with nobody listening: no encoder until somebody does.
+    sleeping: ctx.runner.isSleeping?.(station.id) ?? false,
     excluded: Object.entries(failures).filter(([, count]) => count >= 3).map(([file]) => file),
     listeners: ctx.runner.listeners(station.id),
     error: ctx.runner.error(station.id),
@@ -348,18 +352,31 @@ export async function handleStations(
       return true;
     }
     const channelId = channelOf(station.id);
-    if (!ctx.channels.has(channelId)) {
-      ctx.json(response, 503, { error: "the station is not on the air", code: "not_live", state: ctx.runner.observed(station.id) });
+    // Asleep, a HEAD is told what it would get without waking it.
+    if (method === "HEAD" && ctx.runner.isSleeping?.(station.id)) {
+      response.writeHead(200, { ...ctx.headers, "content-type": station.video ? "video/mp4" : "audio/mpeg", "cache-control": "no-store" });
+      response.end();
       return true;
     }
     // Admitted only within the station's and the server's limits, and the
-    // month's allowance; refused with what to do about it.
+    // month's allowance; refused with what to do about it. Before waking it:
+    // a listener turned away is no reason to start the encoder.
     const refused = method === "GET" && ctx.usage && ctx.limits ? ctx.usage.admit(station.id, ctx.limits) : null;
     if (refused) {
       response.writeHead(refused.status, { ...ctx.headers, "content-type": "application/json; charset=utf-8", "retry-after": String(refused.retryAfter) });
       response.end(JSON.stringify({ error: refused.error, code: refused.code, retryAfter: refused.retryAfter }));
       return true;
     }
+    // The first listener wakes a sleeping station, and is held until it
+    // starts sending, so they hear it begin rather than a stream that ends.
+    let closed = false;
+    response.once("close", () => { closed = true; });
+    await ctx.runner.awake?.(station.id, undefined, () => closed);
+    if (closed) return true;
+    if (!ctx.channels.has(channelId)) {
+      ctx.json(response, 503, { error: "the station is not on the air", code: "not_live", state: ctx.runner.observed(station.id) });
+      return true;
+    }
     // Signed in at nixamp.com: no breaks, starting a little behind live so
     // they can be left out without a gap. Radio only (Channel.listenWithoutBreaks).
     const pass = url.searchParams.get(PASS_PARAM) ?? "";