nixamp 0.56.0 → 0.57.1

package/dist/channels.d.ts

@@ -247,6 +247,16 @@ export declare class Channel {
      * failure, so it does not count as a redial.
      */
     skip(): boolean;
+    /** How far listeners have got into this dial of a list, by the encoder's progress. */
+    private heard;
+    /** Where a list would pick up after what listeners hear now (PlaylistInputStream.resumePoint). */
+    resumePoint(): {
+        file: string;
+        upcoming: string[];
+        sinceBreak: number;
+    } | null;
+    /** Whether listeners would get sound (and, for a picture, its opening) if they joined now. */
+    get flowing(): boolean;
     /** An entry's tags, as read when it was put on. */
     tagsOf(file: string): {
         title: string;
@@ -539,6 +549,16 @@ export declare class Channels {
         artist: string;
         album: string;
     } | undefined;
+    /** Where a channel playing a list would pick up after what is on now; null when it is not one. */
+    resumePoint(id: string): {
+        file: string;
+        upcoming: string[];
+        sinceBreak: number;
+    } | null;
+    /** Whether a channel is up and has started sending. */
+    flowing(id: string): boolean;
+    /** Who is attached to one channel: listeners, relays, packagers. */
+    listenersOf(id: string): number;
     /** The next entry, now, on a channel playing a list of files. */
     skip(id: string): boolean;
     stop(id: string): boolean;

package/dist/channels.js

@@ -169,6 +169,16 @@ export class Channel {
             this.info.redials = redials;
         return done;
     }
+    /** How far listeners have got into this dial of a list, by the encoder's progress. */
+    heard = 0;
+    /** Where a list would pick up after what listeners hear now (PlaylistInputStream.resumePoint). */
+    resumePoint() {
+        return this.playlistInput?.resumePoint(this.heard) ?? null;
+    }
+    /** Whether listeners would get sound (and, for a picture, its opening) if they joined now. */
+    get flowing() {
+        return this.info.bytes > 0 && (!this.fragments || this.fragments.ready);
+    }
     /** An entry's tags, as read when it was put on. */
     tagsOf(file) {
         return this.playlistInput?.tags.get(file);
@@ -334,6 +344,7 @@ export class Channel {
                 ...resume.rotation,
             }) : null;
             this.playlistInput = playlistInput;
+            this.heard = 0;
             const through = this.outroOn ? null : playlistInput
                 ? { format: "mpegts", open: async (signal) => playlistInput.open(signal) }
                 : this.options.through?.(this.info, from, input, audio) ?? null;
@@ -413,6 +424,7 @@ export class Channel {
                     if (match) {
                         const seconds = Number(match[1]) / 1e6;
                         if (playlistInput) {
+                            this.heard = seconds;
                             const place = playlistInput.place(seconds);
                             // A break (-1) belongs to no list; a track's index belongs to its own.
                             if (place.at >= 0 && this.info.playlist !== place.list)
@@ -1283,6 +1295,18 @@ export class Channels {
     tagsOf(id, file) {
         return this.open.get(id)?.tagsOf(file);
     }
+    /** Where a channel playing a list would pick up after what is on now; null when it is not one. */
+    resumePoint(id) {
+        return this.open.get(id)?.resumePoint() ?? null;
+    }
+    /** Whether a channel is up and has started sending. */
+    flowing(id) {
+        return this.open.get(id)?.flowing ?? false;
+    }
+    /** Who is attached to one channel: listeners, relays, packagers. */
+    listenersOf(id) {
+        return this.open.get(id)?.listeners.size ?? 0;
+    }
     /** The next entry, now, on a channel playing a list of files. */
     skip(id) {
         return this.open.get(id)?.skip() ?? false;

package/dist/label-profiles.js

@@ -98,7 +98,7 @@ export function bandMarkdown(band) {
 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.",
+    "precisely enough that an illustrator could draw the same person every time. Start every look with their gender and age (\"woman, 24, ...\"), then 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(" ");
@@ -143,7 +143,7 @@ export function castLine(members) {
 }
 /** The portrait prompt for a member: the same person every time it is used as a reference. */
 export function portraitPrompt(member, band) {
-    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.`;
+    return `Photographic portrait of ${member.name}: ${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, members, band, draw) {

package/dist/library.d.ts

@@ -21,7 +21,13 @@ 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 declare 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 declare function stationIdleSeconds(env: Record<string, string | undefined>, config: Config): number;
 export declare function configPath(): string;
 export declare function readConfig(): Config;
 export declare function writeConfig(patch: Partial<Config>): void;

package/dist/library.js

@@ -19,6 +19,16 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { stateDir } from "./daemon.js";
+/** 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, config) {
+    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() {
     return join(stateDir(), "config.json");
 }
@@ -33,6 +43,7 @@ export function readConfig() {
             ...(typeof record["publish"] === "boolean" ? { publish: record["publish"] } : {}),
             ...(typeof record["autoStations"] === "object" && record["autoStations"] !== null ? { autoStations: record["autoStations"] } : {}),
             ...(typeof record["limits"] === "object" && record["limits"] !== null ? { limits: record["limits"] } : {}),
+            ...(typeof record["stationIdleSeconds"] === "number" ? { stationIdleSeconds: record["stationIdleSeconds"] } : {}),
             ...(Array.isArray(record["trustedProxies"]) ? { trustedProxies: record["trustedProxies"].filter((one) => typeof one === "string") } : {}),
             ...(Array.isArray(record["guideHosts"]) ? { guideHosts: record["guideHosts"].filter((one) => typeof one === "string") } : {}),
             ...(typeof record["guideAds"] === "object" && record["guideAds"] !== null ? { guideAds: record["guideAds"] } : {}),

package/dist/oauth.d.ts

@@ -13,22 +13,41 @@ export interface Provider {
     scope: string;
     /** Turn the provider's access token into an address it stands behind. */
     identify(accessToken: string, send: typeof fetch): Promise<Identity | null>;
+    /** OAuth 2.1: the round trip carries a PKCE S256 challenge and the exchange its verifier. */
+    pkce?: boolean;
 }
 /** Who the provider says this is. `subject` is stable when an address is not. */
 export interface Identity {
     provider: string;
     subject: string;
     email: string;
+    /**
+     * Whether the provider verified the address. Absent means yes (GitHub and
+     * Google are only asked for verified ones). An unverified one never links
+     * to an existing account and is never the new account's address.
+     */
+    verified?: boolean;
 }
+/**
+ * CoinPay (coinpayportal.com), the house identity: OAuth 2.1, authorization
+ * code with PKCE S256 and a client secret. CoinPay does not verify the
+ * address it reports, so a CoinPay identity is matched by its `sub` only.
+ */
+export declare function coinpayProvider(clientId: string, clientSecret: string, base?: string): Provider;
+/** A PKCE pair: the verifier kept here, the S256 challenge sent with the browser. */
+export declare function pkcePair(): {
+    verifier: string;
+    challenge: string;
+};
 export declare function githubProvider(clientId: string, clientSecret: string): Provider;
 export declare function googleProvider(clientId: string, clientSecret: string): Provider;
 /** Whichever providers this deployment has been given both halves of. */
 export declare function providersFrom(env: Record<string, string | undefined>): Provider[];
 export declare function redirectUri(site: string, provider: Provider): string;
 /** Where to send the browser. `state` is the only thing standing between this and CSRF. */
-export declare function authorizeUrl(provider: Provider, site: string, state: string): string;
+export declare function authorizeUrl(provider: Provider, site: string, state: string, challenge?: string): string;
 /** Swap the code for an access token. Empty string means the provider refused. */
-export declare function exchangeCode(provider: Provider, code: string, site: string, send?: typeof fetch): Promise<string>;
+export declare function exchangeCode(provider: Provider, code: string, site: string, send?: typeof fetch, verifier?: string): Promise<string>;
 /** The slice of the auth module's storage adapter that identities need. */
 export interface Users {
     getUserByEmail(email: string): Promise<{
@@ -60,6 +79,8 @@ export declare class Identities {
     constructor(db: Queryable, users: Users);
     private ensure;
     resolve(identity: Identity): Promise<Account | null>;
+    /** The account linked to this subject, or a new one whose address is `<provider>-<subject>@<provider>.invalid`. */
+    private resolveUnverified;
 }
 /**
  * What a round trip to a provider is for.
@@ -74,7 +95,19 @@ export interface Pending {
     /** Set when this round trip is approving a terminal rather than a browser. */
     userCode: string;
     createdAt: number;
+    /** The PKCE verifier, for a provider that takes one. */
+    verifier?: string;
+    /** Where the browser goes once signed in (a path here, or an allowed site); "/" by default. */
+    redirect?: string;
 }
+/** The sites a sign-in may return to: NIXAMP_SIGNIN_RETURN_HOSTS, else the ones that send people here. */
+export declare function signInReturnHosts(env?: Record<string, string | undefined>): string[];
+/**
+ * Where a sign-in may send the browser afterwards: a path on this site, or a
+ * page on one of the sites that send people here to sign in (live.streaming).
+ * Anything else is "/", so a sign-in link cannot be made to bounce elsewhere.
+ */
+export declare function safeRedirect(value: unknown, allowedHosts?: string[]): string;
 /** A state is only ever open for the length of one sign-in. */
 export declare const STATE_TTL_MS = 600000;
 export declare class SignIn {
@@ -91,7 +124,7 @@ export declare class SignIn {
     }[];
     provider(id: unknown): Provider | null;
     /** Start a round trip, and answer the URL the browser should go to. */
-    begin(provider: Provider, userCode?: string): string;
+    begin(provider: Provider, userCode?: string, redirect?: string): string;
     /** Redeem a state exactly once, so a replayed callback finds nothing. */
     claim(state: unknown): Pending | null;
     private sweep;

package/dist/oauth.js

@@ -16,7 +16,37 @@
  * address, and both are asked. Without that check, anyone who can add an
  * unverified address at a provider could claim somebody else's nixamp account.
  */
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
+/**
+ * CoinPay (coinpayportal.com), the house identity: OAuth 2.1, authorization
+ * code with PKCE S256 and a client secret. CoinPay does not verify the
+ * address it reports, so a CoinPay identity is matched by its `sub` only.
+ */
+export function coinpayProvider(clientId, clientSecret, base = "https://coinpayportal.com") {
+    return {
+        id: "coinpay",
+        name: "CoinPay",
+        clientId,
+        clientSecret,
+        authorizeUrl: `${base}/api/oauth/authorize`,
+        tokenUrl: `${base}/api/oauth/token`,
+        scope: "openid profile email",
+        pkce: true,
+        async identify(accessToken, send) {
+            const who = await readJson(await send(`${base}/api/oauth/userinfo`, { headers: { authorization: `Bearer ${accessToken}`, ...AGENT } }));
+            const subject = typeof who["sub"] === "string" ? who["sub"] : "";
+            if (!subject)
+                return null;
+            const email = typeof who["email"] === "string" ? who["email"].toLowerCase() : "";
+            return { provider: "coinpay", subject, email, verified: who["email_verified"] === true };
+        },
+    };
+}
+/** A PKCE pair: the verifier kept here, the S256 challenge sent with the browser. */
+export function pkcePair() {
+    const verifier = randomBytes(32).toString("base64url");
+    return { verifier, challenge: createHash("sha256").update(verifier).digest("base64url") };
+}
 const AGENT = { "user-agent": "nixamp" };
 async function readJson(answer) {
     if (!answer.ok)
@@ -86,23 +116,30 @@ export function providersFrom(env) {
     if (env["GOOGLE_CLIENT_ID"] && env["GOOGLE_CLIENT_SECRET"]) {
         found.push(googleProvider(env["GOOGLE_CLIENT_ID"], env["GOOGLE_CLIENT_SECRET"]));
     }
+    if (env["COINPAY_OAUTH_CLIENT_ID"] && env["COINPAY_OAUTH_CLIENT_SECRET"]) {
+        found.push(coinpayProvider(env["COINPAY_OAUTH_CLIENT_ID"], env["COINPAY_OAUTH_CLIENT_SECRET"], env["COINPAY_OAUTH_BASE"] || undefined));
+    }
     return found;
 }
 export function redirectUri(site, provider) {
     return `${site.replace(/\/+$/, "")}/api/v1/${provider.id}/oauth/callback`;
 }
 /** Where to send the browser. `state` is the only thing standing between this and CSRF. */
-export function authorizeUrl(provider, site, state) {
+export function authorizeUrl(provider, site, state, challenge = "") {
     const url = new URL(provider.authorizeUrl);
     url.searchParams.set("client_id", provider.clientId);
     url.searchParams.set("redirect_uri", redirectUri(site, provider));
     url.searchParams.set("response_type", "code");
     url.searchParams.set("scope", provider.scope);
     url.searchParams.set("state", state);
+    if (challenge) {
+        url.searchParams.set("code_challenge", challenge);
+        url.searchParams.set("code_challenge_method", "S256");
+    }
     return url.toString();
 }
 /** Swap the code for an access token. Empty string means the provider refused. */
-export async function exchangeCode(provider, code, site, send = fetch) {
+export async function exchangeCode(provider, code, site, send = fetch, verifier = "") {
     const answer = await send(provider.tokenUrl, {
         method: "POST",
         headers: {
@@ -118,6 +155,7 @@ export async function exchangeCode(provider, code, site, send = fetch) {
             code,
             redirect_uri: redirectUri(site, provider),
             grant_type: "authorization_code",
+            ...(verifier ? { code_verifier: verifier } : {}),
         }).toString(),
     });
     const body = await readJson(answer);
@@ -156,7 +194,15 @@ export class Identities {
         await this.ready;
     }
     async resolve(identity) {
-        if (!identity.subject || !identity.email)
+        if (!identity.subject)
+            return null;
+        // An address the provider did not verify (CoinPay's) is a hint, not a
+        // claim: the account is found by subject alone, and a new one gets an
+        // address nobody can own, so purchases kept by email are never reached
+        // through it.
+        if (identity.verified === false)
+            return this.resolveUnverified(identity);
+        if (!identity.email)
             return null;
         await this.ensure();
         // Already linked. The subject is what is matched, not the address: people
@@ -200,6 +246,59 @@ export class Identities {
        ON CONFLICT (provider, subject) DO UPDATE SET email = EXCLUDED.email`, [identity.provider, identity.subject, account.id, identity.email]);
         return account;
     }
+    /** The account linked to this subject, or a new one whose address is `<provider>-<subject>@<provider>.invalid`. */
+    async resolveUnverified(identity) {
+        await this.ensure();
+        const { rows } = await this.db.query(`SELECT user_id, email FROM ${TABLE} WHERE provider = $1 AND subject = $2`, [identity.provider, identity.subject]);
+        const linked = rows[0];
+        const placeholder = `${identity.provider}-${identity.subject.replace(/[^A-Za-z0-9._-]/g, "").slice(0, 60)}@${identity.provider}.invalid`;
+        if (linked) {
+            const id = String(linked["user_id"] ?? "");
+            return id ? { id, email: String(linked["email"] ?? "") || placeholder } : null;
+        }
+        const existing = await this.users.getUserByEmail(placeholder);
+        const account = existing?.id
+            ? { id: existing.id, email: existing.email ?? placeholder }
+            : await (async () => {
+                const made = await this.users.createUser({
+                    email: placeholder,
+                    password: null,
+                    emailVerified: false,
+                    profile: { signedUpWith: identity.provider, ...(identity.email ? { providerEmail: identity.email } : {}) },
+                });
+                return { id: String(made.id ?? ""), email: made.email ?? placeholder };
+            })();
+        if (!account.id)
+            return null;
+        await this.db.query(`INSERT INTO ${TABLE} (provider, subject, user_id, email) VALUES ($1, $2, $3, $4)
+       ON CONFLICT (provider, subject) DO NOTHING`, [identity.provider, identity.subject, account.id, placeholder]);
+        return account;
+    }
+}
+/** The sites a sign-in may return to: NIXAMP_SIGNIN_RETURN_HOSTS, else the ones that send people here. */
+export function signInReturnHosts(env = process.env) {
+    const set = (env["NIXAMP_SIGNIN_RETURN_HOSTS"] ?? "").split(",").map((one) => one.trim().toLowerCase()).filter(Boolean);
+    return set.length ? set : ["live.streaming", "live.streaming.pit.world", "bittorrented.com", "backtoschool.help"];
+}
+/**
+ * Where a sign-in may send the browser afterwards: a path on this site, or a
+ * page on one of the sites that send people here to sign in (live.streaming).
+ * Anything else is "/", so a sign-in link cannot be made to bounce elsewhere.
+ */
+export function safeRedirect(value, allowedHosts = []) {
+    if (typeof value !== "string" || value === "")
+        return "/";
+    if (value.startsWith("/") && !value.startsWith("//") && !value.startsWith("/\\"))
+        return value.slice(0, 500);
+    try {
+        const url = new URL(value);
+        if (url.protocol === "https:" && allowedHosts.includes(url.hostname))
+            return url.href.slice(0, 500);
+    }
+    catch {
+        // not a URL
+    }
+    return "/";
 }
 /** A state is only ever open for the length of one sign-in. */
 export const STATE_TTL_MS = 600_000;
@@ -223,11 +322,12 @@ export class SignIn {
         return this.providers.find((candidate) => candidate.id === id) ?? null;
     }
     /** Start a round trip, and answer the URL the browser should go to. */
-    begin(provider, userCode = "") {
+    begin(provider, userCode = "", redirect = "/") {
         this.sweep();
         const state = randomBytes(24).toString("base64url");
-        this.states.set(state, { provider: provider.id, userCode, createdAt: this.now() });
-        return authorizeUrl(provider, this.site, state);
+        const pair = provider.pkce ? pkcePair() : null;
+        this.states.set(state, { provider: provider.id, userCode, createdAt: this.now(), redirect, ...(pair ? { verifier: pair.verifier } : {}) });
+        return authorizeUrl(provider, this.site, state, pair?.challenge ?? "");
     }
     /** Redeem a state exactly once, so a replayed callback finds nothing. */
     claim(state) {

package/dist/playlist-input.d.ts

@@ -37,6 +37,12 @@ export interface PlaylistInput {
     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: {
@@ -51,6 +57,19 @@ export interface PlaylistInput {
  * not a loop.
  */
 export declare 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
@@ -72,13 +91,7 @@ export declare class PlaylistInputStream {
     }>;
     constructor(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>;
     /**
      * What is on at this point of the stream. `at` indexes `list`, the list as
      * it was when that entry started: a station re-reads its list at every
@@ -90,6 +103,17 @@ export declare class PlaylistInputStream {
         position: number;
         list: readonly string[];
     };
+    /**
+     * 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;
     /** The decoder for the entry that is on, so skip() can end it early. */
     private stopCurrent;
     private skipping;
@@ -97,3 +121,4 @@ export declare class PlaylistInputStream {
     skip(): boolean;
     open(signal: AbortSignal): AsyncGenerator<Buffer>;
 }
+export {};

package/dist/playlist-input.js

@@ -40,6 +40,22 @@ export class PlaylistInputStream {
         return entry ? { at: entry.at, position: Math.max(0, seconds - entry.start + entry.position), list: entry.list }
             : { 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) {
+        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) => 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. */
     stopCurrent = null;
     skipping = false;
@@ -69,7 +85,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 = null;
             for (;;) {
@@ -146,7 +164,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/dist/server.js

@@ -40,7 +40,7 @@ import { NixampLinks, nixampExchange } from "./nixamp-link.js";
 import { handleNixampLinkApi, nixampLinkPath } from "./nixamp-link-api.js";
 import { DeviceGrants } from "./device.js";
 import { BAD_KEY_LIMIT, callerOf, Guard, SIGN_IN_LIMIT } from "./guard.js";
-import { deviceDonePage, devicePage, exchangeCode, providersFrom, signInFailedPage, SignIn, } from "./oauth.js";
+import { deviceDonePage, devicePage, exchangeCode, providersFrom, safeRedirect, signInReturnHosts, signInFailedPage, SignIn, } from "./oauth.js";
 import { AuthorizationServer, BACKTOSCHOOL_CLIENT, SCOPE_NAMES, clientsFrom } from "./oauth-server.js";
 import { handleOAuthApi, oauthApiPath } from "./oauth-api.js";
 import { WatchParties } from "./watch-party.js";
@@ -98,7 +98,7 @@ import { Porkbun, isIPv4, isIPv6 } from "./dns.js";
 import { NameError, Names } from "./names.js";
 import { AcmeIssuer, Certs } from "./certs.js";
 import { claimName, fetchCert, humanizeSource, labelFor, readCertFiles, writeCertFiles } from "./naming.js";
-import { forbiddenLibrary, readConfig, readLibrary, writeConfig } from "./library.js";
+import { forbiddenLibrary, readConfig, readLibrary, stationIdleSeconds, writeConfig } from "./library.js";
 import { createThrottle, presentedCredential } from "@profullstack/throttle";
 import { Durable } from "./durable.js";
 import { notifyAll, resendEmail, webPush } from "./notify.js";
@@ -4509,7 +4509,9 @@ export function createHandler(engine, options) {
                 // A terminal can link straight here with the code it is showing, which
                 // is one hop shorter than the page for somebody who followed the link.
                 const grant = signIn.device.find(url.searchParams.get("device") ?? "");
-                response.writeHead(302, { location: signIn.begin(provider, grant?.userCode ?? "") });
+                // Back where the visit was going: a page here, or a site that sends people here to sign in.
+                const redirect = safeRedirect(url.searchParams.get("redirect"), signInReturnHosts());
+                response.writeHead(302, { location: signIn.begin(provider, grant?.userCode ?? "", redirect) });
                 response.end();
                 return;
             }
@@ -4525,10 +4527,10 @@ export function createHandler(engine, options) {
                 html(response, 400, signInFailedPage(url.searchParams.get("error") ?? "The provider sent no code."));
                 return;
             }
-            const access = await exchangeCode(provider, code, signIn.site).catch(() => "");
+            const access = await exchangeCode(provider, code, signIn.site, fetch, pending.verifier ?? "").catch(() => "");
             const identity = access ? await provider.identify(access, fetch).catch(() => null) : null;
             if (identity === null) {
-                html(response, 401, signInFailedPage(`${provider.name} did not confirm a verified email address.`));
+                html(response, 401, signInFailedPage(provider.pkce ? `${provider.name} did not finish the sign-in. Try it again.` : `${provider.name} did not confirm a verified email address.`));
                 return;
             }
             const result = await accounts.signInWith(identity);
@@ -4548,7 +4550,7 @@ export function createHandler(engine, options) {
             }
             response.writeHead(302, {
                 "set-cookie": sessionCookie(result.token, secure),
-                location: "/",
+                location: pending.redirect || "/",
             });
             response.end();
             return;
@@ -5501,6 +5503,11 @@ export function createHandler(engine, options) {
                 response.end(request.method === "HEAD" ? undefined : bytes);
                 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
@@ -6956,6 +6963,8 @@ export async function serve(argv, version = "0.1.0") {
         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) => Boolean(await pullChannel(channels, tools.ffprobe, channelId, name, files[0], [], "", {
@@ -7245,6 +7254,7 @@ export async function serve(argv, version = "0.1.0") {
         });
     }
     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/dist/station-routes.d.ts

@@ -112,6 +112,7 @@ export declare function guideEntries(ctx: StationContext): Array<PublicStation &
 export declare function ownerView(ctx: StationContext, station: Station): OwnerStation & {
     links: ReturnType<typeof links>;
     nowPlaying: string;
+    sleeping: boolean;
 };
 /** Answers anything under /api/v1/stations; false when the path is not one. */
 export declare function handleStations(request: IncomingMessage, response: ServerResponse, path: string, url: URL, ctx: StationContext): Promise<boolean>;