nixamp 0.67.1 → 0.67.3

package/dist/ai-label.d.ts

@@ -25,6 +25,12 @@ export interface LabelSong {
     videoTagged?: boolean;
     /** 2 for a storyboard video (scenes that move); absent or 1 for the cover-and-waveform kind, which is made again. */
     videoVersion?: number;
+    /**
+     * The singer in its filmed video: "synced" (close-ups lip-synced), "unsynced" (filmed, but no
+     * sync could be made, so the band plays there). Absent on a filmed video means the singer was
+     * never filmed, and with lip sync on it is filmed again.
+     */
+    singer?: "synced" | "unsynced";
     /** Who wrote the words and who sang them, e.g. "llama-3.3 + elevenlabs/music_v2_5". */
     made: string;
     composedAt: number;
@@ -213,6 +219,10 @@ export declare function closeUpTimes(seconds: number, lines: Array<{
  * the mic in the wide shots).
  */
 export declare const FILMED = 6;
+/** Google's answer when the project's daily Veo requests are used up (HTTP 429). */
+export declare const VEO_QUOTA: RegExp;
+/** The next midnight in California, when Google's daily quotas reset. */
+export declare function nextPacificMidnight(now: number): number;
 /**
  * A single's music video, cut from its filmed shots alone: 4 s cuts, each
  * shot's first half then its second, round and round the shots until the song
@@ -348,6 +358,8 @@ export declare class AiLabel {
     private alignTried;
     /** The month ("YYYY-MM") Veo said its budget was spent; no more shots until the next. */
     private veoSpentIn;
+    /** Until when Google's daily Veo quota is used up (its midnight, Pacific): nothing is asked before. */
+    private veoQuotaUntil;
     /** Old videos already tried as storyboards since this server started. */
     private upgradeTried;
     /** When each single was last put in front of the camera: one that came up short is tried again an hour on. */

package/dist/ai-label.js

@@ -678,6 +678,16 @@ export function closeUpTimes(seconds, lines, count, length = 8) {
  * the mic in the wide shots).
  */
 export const FILMED = 6;
+/** Google's answer when the project's daily Veo requests are used up (HTTP 429). */
+export const VEO_QUOTA = /exceeded your current quota|RESOURCE_EXHAUSTED/i;
+/** The next midnight in California, when Google's daily quotas reset. */
+export function nextPacificMidnight(now) {
+    const hour = (at) => Number(new Intl.DateTimeFormat("en-US", { timeZone: "America/Los_Angeles", hour: "numeric", hourCycle: "h23" }).format(new Date(at)));
+    let at = Math.floor(now / 3_600_000) * 3_600_000 + 3_600_000;
+    for (let i = 0; i < 26 && hour(at) !== 0; i++)
+        at += 3_600_000;
+    return at;
+}
 /**
  * A single's music video, cut from its filmed shots alone: 4 s cuts, each
  * shot's first half then its second, round and round the shots until the song
@@ -814,6 +824,8 @@ export class AiLabel {
     alignTried = new Set();
     /** The month ("YYYY-MM") Veo said its budget was spent; no more shots until the next. */
     veoSpentIn = "";
+    /** Until when Google's daily Veo quota is used up (its midnight, Pacific): nothing is asked before. */
+    veoQuotaUntil = 0;
     /** Old videos already tried as storyboards since this server started. */
     upgradeTried = new Set();
     /** When each single was last put in front of the camera: one that came up short is tried again an hour on. */
@@ -1169,7 +1181,9 @@ export class AiLabel {
             .filter((album) => album.cover || album.coverTried)
             .flatMap((album) => album.songs.filter((song) => song.file && !this.videoFailed.has(song.file)).map((song) => ({ artist, album, song }))));
         // Only a single is filmed, and only with Veo footage: a song with an older (slideshow) video is filmed when its turn comes.
-        const missing = songs.filter(({ song }) => this.wantsVeo(song) && (song.videoVersion ?? 1) < FILMED && this.now() - (this.filmTriedAt.get(song.file) ?? 0) > 60 * 60_000);
+        // A filmed video whose singer was never filmed (a quota or a refusal took the close-ups) is filmed again while it stays up.
+        const singerless = (song) => Boolean(this.deps.lipsync) && this.settings.lipsyncShots > 0 && (song.videoVersion ?? 1) >= FILMED && !song.singer;
+        const missing = songs.filter(({ song }) => this.wantsVeo(song) && ((song.videoVersion ?? 1) < FILMED || singerless(song)) && this.now() - (this.filmTriedAt.get(song.file) ?? 0) > 60 * 60_000);
         const untagged = songs.filter(({ song }) => song.video && !song.videoTagged && (song.videoVersion ?? 1) >= FILMED);
         const old = [];
         let made = 0;
@@ -1205,7 +1219,10 @@ export class AiLabel {
             const partial = join(album.folder, `.${randomBytes(4).toString("hex")}.video.mp4`);
             const scenes = join(album.folder, `.scenes-${song.n}-${randomBytes(3).toString("hex")}`);
             try {
-                song.videoVersion = await this.filmSong(artist, album, song, scenes, partial, upgrade);
+                const filmed = await this.filmSong(artist, album, song, scenes, partial, upgrade);
+                song.videoVersion = filmed.version;
+                if (filmed.singer)
+                    song.singer = filmed.singer;
                 renameSync(partial, out);
                 song.video = out;
                 song.videoTagged = true;
@@ -1243,10 +1260,14 @@ export class AiLabel {
         const wanted = this.settings.veoShots + this.settings.storyShots;
         if (clips.length < Math.max(2, Math.ceil(wanted / 2)))
             throw new Error(`only ${clips.length} of ${wanted} shots filmed so far`);
+        // The singer is the point of the video: with lip sync on, nothing is cut until a close-up is filmed.
+        const singing = Boolean(this.deps.lipsync) && this.settings.lipsyncShots > 0;
+        if (singing && singer.length === 0)
+            throw new Error("the singer's close-ups are not filmed yet");
         const pinned = await this.syncCloseUps(song, singer, seconds, shots);
         await (this.deps.filmedVideo ?? ((input) => renderFilmedVideo(this.deps.ffmpeg, input)))({ audio: song.file, clips, seconds, artist: artist.name, title: song.title, out, ...(pinned.length ? { pinned } : {}) });
         rmSync(shots, { recursive: true, force: true });
-        return FILMED;
+        return { version: FILMED, ...(singing ? { singer: pinned.length ? "synced" : "unsynced" } : {}) };
     }
     /**
      * The singer's close-ups, each placed on a sung line and its mouth redrawn
@@ -1313,7 +1334,8 @@ export class AiLabel {
     }
     /** Whether this song gets filmed Veo shots: an album's single, Veo on, and the month's budget not spent. */
     wantsVeo(song) {
-        return this.settings.veo && song.n === 1 && Boolean(this.deps.veo) && this.veoSpentIn !== new Date(this.now()).toISOString().slice(0, 7);
+        return this.settings.veo && song.n === 1 && Boolean(this.deps.veo) && this.veoSpentIn !== new Date(this.now()).toISOString().slice(0, 7)
+            && this.now() >= this.veoQuotaUntil;
     }
     /**
      * A single's filmed shots: the band, from their portraits (up to three as
@@ -1365,10 +1387,11 @@ export class AiLabel {
         }
         // The singer's close-ups only where they can be lip-synced afterwards. Story scenes go without
         // the portraits: they would pull the whole band into every scene.
+        // The singer first: a day's few Veo requests go to what the video is for, then the story and the band.
         const plan = [
+            ...(this.deps.lipsync ? veoPrompts(artist, song, singers, this.settings.lipsyncShots, "singer").map((prompt, i) => ({ prompt, file: join(keep, `singer-${i}.mp4`), into: singer, refs: singerRefs })) : []),
             ...storyFiles.map((file, i) => ({ prompt: storyPrompts[i] ?? "", file, into: story, refs: [] })),
             ...veoPrompts(artist, song, players, this.settings.veoShots).map((prompt, i) => ({ prompt, file: join(keep, `shot-${i}.mp4`), into: band, refs: playerRefs })),
-            ...(this.deps.lipsync ? veoPrompts(artist, song, singers, this.settings.lipsyncShots, "singer").map((prompt, i) => ({ prompt, file: join(keep, `singer-${i}.mp4`), into: singer, refs: singerRefs })) : []),
         ];
         for (const [i, { prompt, file, into, refs }] of plan.entries()) {
             try {
@@ -1405,6 +1428,12 @@ export class AiLabel {
                     this.log(`Veo: ${error.message}; no more videos until next month`);
                     break;
                 }
+                if (VEO_QUOTA.test(error.message)) {
+                    // Google's daily request quota: every further ask today is refused, so none is made.
+                    this.veoQuotaUntil = nextPacificMidnight(this.now());
+                    this.log(`Veo: Google's daily quota is used up; filming resumes after ${new Date(this.veoQuotaUntil).toISOString()}`);
+                    break;
+                }
                 this.log(`Veo shot ${i + 1} for "${song.title}": ${error.message}`);
             }
         }

package/dist/license-routes.js

@@ -12,7 +12,7 @@
  */
 import { createHash } from "node:crypto";
 import { LICENSE_PRICES, TERMS_VERSION, TIER_NAMES, TIER_USE, licenseTerms } from "./music-license.js";
-import { SupportError } from "./support.js";
+import { SupportError, paidIn, payUrl } from "./support.js";
 const CHECK = /^\/license\/(NXL-[A-Z2-9]{4}-[A-Z2-9]{4})$/;
 const CHECK_JSON = /^\/api\/v1\/licenses\/(NXL-[A-Z2-9]{4}-[A-Z2-9]{4})$/;
 const CERTIFICATE = /^\/licenses\/([0-9a-f-]{36})$/;
@@ -58,14 +58,9 @@ const SCRIPT = `
   if (!form) return;
   const status = $("#status");
   const pay = $("#pay");
-  const label = () => { const one = form.querySelector("input[name=tier]:checked"); pay.textContent = one ? "Pay " + one.dataset.price + " with crypto" : "Pick a licence"; };
+  const label = () => { const one = form.querySelector("input[name=tier]:checked"); pay.textContent = one ? "Pay " + one.dataset.price : "Pick a licence"; };
   form.addEventListener("change", label);
   label();
-  fetch("/api/v1/store/coins").then((r) => r.json()).then((coins) => {
-    const cheap = ["USDC_POL", "USDC_SOL", "SOL", "POL", "LTC", "USDC_BASE", "USDC"];
-    const list = (coins.coins || []).slice().sort((a, b) => (cheap.indexOf(a) + 1 || 99) - (cheap.indexOf(b) + 1 || 99));
-    $("#coin").replaceChildren(...list.map((c) => Object.assign(document.createElement("option"), { value: c, textContent: c })));
-  }).catch(() => { status.textContent = "Payments are not available right now."; });
   form.addEventListener("submit", async (event) => {
     event.preventDefault();
     pay.disabled = true;
@@ -74,7 +69,7 @@ const SCRIPT = `
     try {
       const r = await fetch("/api/v1/licenses/checkout", { method: "POST", headers: { "content-type": "application/json" }, credentials: "same-origin",
         body: JSON.stringify({ ...JSON.parse(document.body.dataset.item), tier: data.get("tier"), licensee: data.get("licensee"), project: data.get("project"),
-          projectUrl: data.get("projectUrl"), email: data.get("email"), coin: data.get("coin"), agree: data.get("agree") === "on" }) });
+          projectUrl: data.get("projectUrl"), email: data.get("email"), agree: data.get("agree") === "on" }) });
       const body = await r.json();
       if (!r.ok) throw new Error(body.error || "The checkout did not start.");
       status.textContent = "Taking you to CoinPay…";
@@ -161,13 +156,11 @@ export async function handleLicenseRoutes(request, response, path, url, ctx) {
 <input id="projectUrl" name="projectUrl" type="url" maxlength="300" placeholder="https://">
 <label class="f" for="email">Email (your certificate goes here)</label>
 <input id="email" name="email" type="email" required autocomplete="email" value="${escape(me?.email ?? "")}">
-<label class="f" for="coin">Pay with</label>
-<select id="coin" name="coin" required></select>
 <label class="agree"><input type="checkbox" name="agree" required> <span>I agree to the <a href="/license/terms" target="_blank" rel="noopener">licence terms</a>, including the credit with a link to the artist's page.</span></label>
 <button id="pay" type="submit">Pay</button>
 </form>
 <p id="status" role="status" aria-live="polite"></p>
-<small>Payments go through <a href="https://coinpayportal.com">CoinPay</a> to nixamp.com. You get a certificate with a licence code that anybody can check at ${escape(ctx.site)}/license/&lt;code&gt;.</small>
+<small>Payments go through <a href="https://coinpayportal.com">CoinPay</a> to nixamp.com: pick any coin, or PayPal, on CoinPay's page. You get a certificate with a licence code that anybody can check at ${escape(ctx.site)}/license/&lt;code&gt;.</small>
 </div>`, { data: JSON.stringify({ kind: quote.kind, ...(quote.kind === "catalog" ? {} : { server: ctx.serverId(quote.server), artist: quote.artist, album: quote.album, n: quote.n }) }) }), method);
             return true;
         }
@@ -193,9 +186,9 @@ export async function handleLicenseRoutes(request, response, path, url, ctx) {
             }
             const body = license.status === "paid"
                 ? certificate(license, ctx, true)
-                : `<div class="card"><h1>${escape(TIER_NAMES[license.tier])} licence ${escape(license.code)}</h1><p class="by">${escape(license.title)} · ${price(license.amountCents)} in ${escape(license.coin)}</p>
+                : `<div class="card"><h1>${escape(TIER_NAMES[license.tier])} licence ${escape(license.code)}</h1><p class="by">${escape(license.title)} · ${price(license.amountCents)}${escape(paidIn(license.coin))}</p>
 <p>Waiting for your payment. Once CoinPay confirms it, your certificate is here and in your email (${escape(license.email)}). This page checks again when you reload it.</p>
-<a class="go" href="https://coinpayportal.com/pay/${escape(license.paymentId)}">Open the payment</a></div>`;
+<a class="go" href="${escape(payUrl(license.paymentId))}">Open the payment</a></div>`;
             html(response, 200, page(`Licence ${license.code}`, body), method);
             return true;
         }

package/dist/music-license.js

@@ -16,7 +16,7 @@
  * under. Paid through nixamp.com's CoinPay business like the store.
  */
 import { randomBytes, randomUUID } from "node:crypto";
-import { SupportError } from "./support.js";
+import { SupportError, coinOf } from "./support.js";
 /** In cents, by tier and what is licensed; a missing pair is not sold. */
 export const LICENSE_PRICES = {
     creator: { song: 500 },
@@ -132,7 +132,8 @@ export class MusicLicenses {
         const code = newCode();
         const checkout = await this.options.support.pay({
             amountUsd: quote.amountCents / 100,
-            coin: input["coin"],
+            email,
+            accountId: account?.id || email,
             order: `license-${id}`,
             description: `${TIER_NAMES[quote.tier]} licence: ${quote.title}${quote.kind === "catalog" ? ", one year" : ` by ${quote.artistName}`} for ${project}`,
             metadata: { product: "music-license", license: id, tier: quote.tier, kind: quote.kind },
@@ -141,7 +142,7 @@ export class MusicLicenses {
         await this.options.db.query(`INSERT INTO music_licenses (id, code, token, email, user_id, licensee, project, project_url, tier, kind, server, artist, album, n,
       title, artist_name, credit_url, amount_cents, coin, payment_id, terms, created_at)
       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22)`, [id, code, token, email, account?.id ?? "", licensee, project, httpsUrl(input["projectUrl"]), quote.tier, quote.kind, quote.server, quote.artist, quote.album, quote.n,
-            quote.title, quote.artistName, quote.creditUrl, quote.amountCents, String(input["coin"]).toUpperCase(), checkout.paymentId, TERMS_VERSION, new Date(this.now())]);
+            quote.title, quote.artistName, quote.creditUrl, quote.amountCents, coinOf(input["coin"]), checkout.paymentId, TERMS_VERSION, new Date(this.now())]);
         return { url: checkout.url, id, token, code };
     }
     /** The licensee's own page: the certificate once paid. */

package/dist/music-store.js

@@ -16,7 +16,7 @@
  * is good before it plays or zips anything (/api/v1/store/grant).
  */
 import { createHmac, randomUUID, timingSafeEqual } from "node:crypto";
-import { SupportError } from "./support.js";
+import { SupportError, coinOf } from "./support.js";
 /** In cents. */
 export const PRICES = { song: 10, album: 100, artist: 200 };
 const EMAIL = /^[^\s@<>"]{1,64}@[^\s@<>"]{1,190}\.[a-z]{2,24}$/i;
@@ -188,14 +188,15 @@ export class MusicStore {
         const token = randomUUID().replace(/-/g, "");
         const checkout = await this.options.support.pay({
             amountUsd: item.amountCents / 100,
-            coin: input["coin"],
+            email,
+            accountId: account?.id || email,
             order: `music-${id}`,
             description: `${item.title} by ${item.artistName} (${item.kind === "song" ? "song" : item.kind === "album" ? "album" : "every album"}, MP3)`,
             metadata: { product: "music", purchase: id, kind: item.kind },
             redirect: this.link(id, token),
         });
         await this.options.db.query(`INSERT INTO music_purchases (id, token, email, user_id, server, kind, artist, album, n, title, artist_name, amount_cents, coin, payment_id, created_at)
-      VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15)`, [id, token, email, account?.id ?? "", item.server, item.kind, item.artist, item.album, item.n, item.title, item.artistName, item.amountCents, String(input["coin"]).toUpperCase(), checkout.paymentId, new Date(this.now())]);
+      VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15)`, [id, token, email, account?.id ?? "", item.server, item.kind, item.artist, item.album, item.n, item.title, item.artistName, item.amountCents, coinOf(input["coin"]), checkout.paymentId, new Date(this.now())]);
         return { url: checkout.url, id, token };
     }
     /** The purchase's own page, which is also the receipt link. */

package/dist/server.js

@@ -2183,15 +2183,20 @@ export function createHandler(engine, options) {
                 json(response, 400, { error: "invalid JSON" });
                 return;
             }
+            // A hosted checkout session's payment names its session; the purchase
+            // row holds the session id (cs_...), an older one the payment id.
+            const refs = [event.sessionId, event.paymentId].filter(Boolean);
             if (options.musicStore) {
                 try {
-                    if (await options.musicStore.owns(event.paymentId)) {
-                        json(response, 200, await options.musicStore.settle(event.paymentId));
-                        return;
-                    }
-                    if (options.musicLicenses && await options.musicLicenses.owns(event.paymentId)) {
-                        json(response, 200, await options.musicLicenses.settle(event.paymentId));
-                        return;
+                    for (const ref of refs) {
+                        if (await options.musicStore.owns(ref)) {
+                            json(response, 200, await options.musicStore.settle(ref));
+                            return;
+                        }
+                        if (options.musicLicenses && await options.musicLicenses.owns(ref)) {
+                            json(response, 200, await options.musicLicenses.settle(ref));
+                            return;
+                        }
                     }
                 }
                 catch (error) {
@@ -2205,7 +2210,7 @@ export function createHandler(engine, options) {
                 return;
             }
             try {
-                json(response, 200, await options.translationPasses.settle(event.paymentId));
+                json(response, 200, await options.translationPasses.settle(event));
             }
             catch (error) {
                 // A 5xx makes CoinPay deliver it again, which is what an unreachable
@@ -2344,7 +2349,7 @@ export function createHandler(engine, options) {
             // llms.txt, the OpenAPI document, the health check and the desktop downloads (nixamp.com).
             !(isDiscoveryPath(path) && Boolean(options.accounts && options.site)) &&
             // Supporting a copyright holder is for anybody listening.
-            !/^\/support\/[a-z0-9-]{1,40}$/.test(path) && path !== "/support/cancel" && !/^\/api\/v1\/support\/[a-z0-9-]{1,40}$/.test(path) &&
+            !/^\/support\/[a-z0-9-]{1,40}$/.test(path) && path !== "/support/cancel" && !/^\/support\/pay\/[0-9a-f-]{36}\/[0-9a-f]{32}$/.test(path) && !/^\/api\/v1\/support\/[a-z0-9-]{1,40}$/.test(path) &&
             // A station's short link, which sends the browser to wherever it plays.
             !/^\/watch\/[a-z0-9]{10}$/.test(path) &&
             // A live room's page: the room's own key travels in ?play=, checked by its server.
@@ -2439,6 +2444,52 @@ export function createHandler(engine, options) {
             response.end(request.method === "HEAD" ? undefined : `<!doctype html><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Support · nixamp</title><body style="margin:0;background:#080c09;color:#e8efe9;font:16px/1.5 system-ui,sans-serif"><main style="max-width:520px;margin:0 auto;padding:48px 16px"><h1 style="font-size:1.4rem">Monthly support</h1><p>${safe}</p><p><a style="color:#3ddc84" href="https://nixamp.com/guide">Back to the stations</a></p></main></body>`);
             return;
         }
+        /*
+         * A monthly support's "pay this month" link, from its emails: a fresh
+         * CoinPay checkout session each time it is followed (one still open is
+         * reused), so a late payer is never sent to an expired session.
+         */
+        const supportPay = /^\/support\/pay\/([0-9a-f-]{36})\/([0-9a-f]{32})$/.exec(path);
+        if (supportPay && options.supportSubscriptions && (request.method === "GET" || request.method === "HEAD")) {
+            const page = (status, words, again) => {
+                const safe = (text) => text.replace(/[&<>"']/g, (one) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[one]);
+                response.writeHead(status, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'", "referrer-policy": "no-referrer", "x-robots-tag": "noindex" });
+                response.end(request.method === "HEAD" ? undefined : `<!doctype html><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Support · nixamp</title><body style="margin:0;background:#080c09;color:#e8efe9;font:16px/1.5 system-ui,sans-serif"><main style="max-width:520px;margin:0 auto;padding:48px 16px"><h1 style="font-size:1.4rem">Monthly support</h1><p>${safe(words)}</p>${again ? `<p><a style="color:#3ddc84" href="${safe(again)}">${safe(again.includes("/support/pay/") ? "Try again" : "Start again")}</a></p>` : ""}<p><a style="color:#3ddc84" href="https://nixamp.com/guide">Back to the stations</a></p></main></body>`);
+            };
+            // A HEAD (a mail scanner checking the link) never opens a checkout.
+            if (request.method === "HEAD") {
+                page(200, "");
+                return;
+            }
+            const verdict = guard.check(`support-pay:${callerOf(request.headers, request.socket.remoteAddress, behindProxy)}`, { allowed: 10, windowMs: 60_000 });
+            if (!verdict.ok) {
+                page(429, "Too many at once; wait a minute and open the link again.");
+                return;
+            }
+            try {
+                const opened = await options.supportSubscriptions.open(supportPay[1], supportPay[2]);
+                if (opened.state === "redirect") {
+                    response.writeHead(303, { location: opened.url, "cache-control": "no-store", "referrer-policy": "no-referrer" });
+                    response.end();
+                    return;
+                }
+                const name = options.support?.holder(opened.holder)?.name ?? opened.holder;
+                const site = options.site ?? "https://nixamp.com";
+                if (opened.state === "paid")
+                    page(200, `This month's support for ${name} is paid. Thank you. Next month's link comes by email.`);
+                else if (opened.state === "canceled")
+                    page(200, `Your monthly support for ${name} was cancelled, so there is nothing to pay.`, `${site}/support/${opened.holder}`);
+                else
+                    page(200, `Your monthly support for ${name} stopped after a month went unpaid. Nothing is owed.`, `${site}/support/${opened.holder}`);
+            }
+            catch (error) {
+                if (error instanceof SupportError)
+                    page(error.status, error.message, error.status >= 500 ? `${url.pathname}` : undefined);
+                else
+                    page(502, "The payment service did not answer; nothing was charged. Try the link again in a minute.", url.pathname);
+            }
+            return;
+        }
         /* Support a copyright holder: the page, the coins, and a CoinPay checkout. */
         const supportPage = /^\/support\/([a-z0-9-]{1,40})$/.exec(path);
         if (supportPage && options.support && (request.method === "GET" || request.method === "HEAD")) {
@@ -2477,13 +2528,20 @@ export function createHandler(engine, options) {
                     catch {
                         body = {};
                     }
+                    // CoinPay files the payment under the payer: a signed-in member by
+                    // account id (their email if the form left it empty), a guest by email.
+                    const me = options.accounts ? await options.accounts.whoIs(tokenFrom(request.headers)).catch(() => null) : null;
+                    const payer = {
+                        email: typeof body["email"] === "string" && body["email"].trim() ? body["email"] : me?.email ?? "",
+                        accountId: me?.id ?? null,
+                    };
                     if (body["monthly"] === true) {
                         if (!options.supportSubscriptions)
                             throw new SupportError("Monthly support is not set up here.", 503, "unavailable");
-                        json(response, 200, await options.supportSubscriptions.start({ ...body, holder: holder.id }));
+                        json(response, 200, await options.supportSubscriptions.start({ ...body, ...payer, holder: holder.id }));
                     }
                     else {
-                        json(response, 200, await support.checkout({ ...body, holder: holder.id }));
+                        json(response, 200, await support.checkout({ ...body, ...payer, holder: holder.id }));
                     }
                     return;
                 }
@@ -3630,9 +3688,12 @@ export function createHandler(engine, options) {
                     catch {
                         throw new SpeechError("Choose a translation pass.", 400);
                     }
-                    if (!body || typeof body !== "object" || typeof body["plan"] !== "string" || typeof body["coin"] !== "string" || typeof body["requestKey"] !== "string")
-                        throw new SpeechError("Choose a translation pass and payment currency.", 400);
-                    json(response, 200, await service.checkout(who.id, body["plan"], body["coin"], body["requestKey"]));
+                    if (!body || typeof body !== "object" || typeof body["plan"] !== "string" || typeof body["requestKey"] !== "string")
+                        throw new SpeechError("Choose a translation pass.", 400);
+                    // A CoinPay hosted session (any coin or PayPal) filed under this
+                    // account and its email; `coin` only comes from an older open page.
+                    const email = who.email || (typeof body["email"] === "string" ? body["email"] : "");
+                    json(response, 200, await service.checkout(who.id, body["plan"], typeof body["coin"] === "string" ? body["coin"] : "", body["requestKey"], { email, accountId: who.id }));
                     return;
                 }
                 const order = path.match(/^\/api\/v1\/translation-passes\/orders\/([^/]+)$/);
@@ -7550,7 +7611,7 @@ export async function serve(argv, version = "0.1.0") {
         ? new TranslationPasses({ db: pool, key: coinpayKeyFrom(), site: nixampSite, admins: [options.owner || ""] }) : undefined;
     // Payments to the copyright holders nixamp.com collects for, on its own CoinPay business.
     const supportPayments = accounts ? new Support({ key: coinpayKeyFrom(), site: nixampSite, holders: supportHoldersFrom() }) : undefined;
-    // Monthly support: each month a new CoinPay payment and its link by email.
+    // Monthly support: each month its stable pay link by email (a fresh CoinPay session per click).
     const supportMonthly = supportPayments && supportPayments.enabled && pool ? new SupportSubscriptions({
         db: pool,
         support: supportPayments,

package/dist/store-routes.js

@@ -12,7 +12,7 @@
 import { createHash } from "node:crypto";
 import { PRICES } from "./music-store.js";
 import { serverId } from "./music-hub.js";
-import { SupportError } from "./support.js";
+import { SupportError, paidIn, payUrl } from "./support.js";
 const PURCHASE = /^\/purchases\/([0-9a-f-]{36})$/;
 const ONE = /^\/api\/v1\/store\/purchases\/([0-9a-f-]{36})$/;
 export function isStorePath(path) {
@@ -45,12 +45,6 @@ const BUY_SCRIPT = `
 (async () => {
   const $ = (s) => document.querySelector(s);
   const status = $("#status");
-  try {
-    const coins = await (await fetch("/api/v1/store/coins")).json();
-    const cheap = ["USDC_POL", "USDC_SOL", "SOL", "POL", "LTC", "USDC_BASE", "USDC"];
-    const list = (coins.coins || []).slice().sort((a, b) => (cheap.indexOf(a) + 1 || 99) - (cheap.indexOf(b) + 1 || 99));
-    $("#coin").replaceChildren(...list.map((c) => Object.assign(document.createElement("option"), { value: c, textContent: c })));
-  } catch { status.textContent = "Payments are not available right now."; }
   $("#buy").addEventListener("submit", async (event) => {
     event.preventDefault();
     const button = $("#pay");
@@ -59,7 +53,7 @@ const BUY_SCRIPT = `
     const form = new FormData(event.currentTarget);
     try {
       const r = await fetch("/api/v1/store/checkout", { method: "POST", headers: { "content-type": "application/json" }, credentials: "same-origin",
-        body: JSON.stringify({ ...JSON.parse(document.body.dataset.item), email: form.get("email"), coin: form.get("coin") }) });
+        body: JSON.stringify({ ...JSON.parse(document.body.dataset.item), email: form.get("email") }) });
       const body = await r.json();
       if (!r.ok) throw new Error(body.error || "The checkout did not start.");
       status.textContent = "Taking you to CoinPay…";
@@ -109,12 +103,10 @@ export async function handleStoreRoutes(request, response, path, url, ctx) {
 <form id="buy">
 <label for="email">Email (your download link goes here)</label>
 <input id="email" name="email" type="email" required autocomplete="email" value="${escape(me?.email ?? "")}">
-<label for="coin">Pay with</label>
-<select id="coin" name="coin" required></select>
-<button id="pay" type="submit">Pay ${price(item.amountCents)} with crypto</button>
+<button id="pay" type="submit">Pay ${price(item.amountCents)}</button>
 </form>
 <p id="status" role="status" aria-live="polite"></p>
-<small>Payments go through <a href="https://coinpayportal.com">CoinPay</a> to nixamp.com. For small amounts pick a coin with low fees (USDC on Polygon or Solana, SOL, LTC). Listening on the live stations is always free.${me ? "" : ` <a href="/?redirect=${encodeURIComponent("/music/me")}#account-panel">Sign in</a> with the same email to keep everything under My music.`}</small>
+<small>Payments go through <a href="https://coinpayportal.com">CoinPay</a> to nixamp.com: pick any coin, or PayPal, on CoinPay's page. For small amounts a coin with low fees (USDC on Polygon or Solana, SOL) or PayPal costs least. Listening on the live stations is always free.${me ? "" : ` <a href="/?redirect=${encodeURIComponent("/music/me")}#account-panel">Sign in</a> with the same email to keep everything under My music.`}</small>
 </div>`, JSON.stringify({ server: serverId(item.server), kind: item.kind, artist: item.artist, album: item.album, n: item.n })), method);
             return true;
         }
@@ -129,9 +121,9 @@ export async function handleStoreRoutes(request, response, path, url, ctx) {
                 ? `<div class="card"><h1>${escape(purchase.title)}</h1><p class="by">${escape(purchase.artistName)} · paid ${price(purchase.amountCents)}</p>
 <a class="go" href="${escape(store.zipUrl(purchase))}" download>Download the zip</a>
 <small>MP3s with the cover art and lyrics, plus each song's .lyrics.txt, cover.jpg and album.json. Keep this page's address (it is in your email too) to download again. Signed in to nixamp.com as ${escape(purchase.email)}, everything you bought is under <a href="/music/me">My music</a>, to play or download.</small></div>`
-                : `<div class="card"><h1>${escape(purchase.title)}</h1><p class="by">${escape(purchase.artistName)} · ${price(purchase.amountCents)} in ${escape(purchase.coin)}</p>
+                : `<div class="card"><h1>${escape(purchase.title)}</h1><p class="by">${escape(purchase.artistName)} · ${price(purchase.amountCents)}${escape(paidIn(purchase.coin))}</p>
 <p>Waiting for your payment. Once CoinPay confirms it, your download is here and in your email (${escape(purchase.email)}). This page checks again when you reload it.</p>
-<a class="go" href="https://coinpayportal.com/pay/${escape(purchase.paymentId)}">Open the payment</a></div>`;
+<a class="go" href="${escape(payUrl(purchase.paymentId))}">Open the payment</a></div>`;
             html(response, 200, page(purchase.title, body), method);
             return true;
         }

package/dist/support.d.ts

@@ -4,6 +4,21 @@ export interface SupportHolder {
 }
 export declare function supportHoldersFrom(env?: Record<string, string | undefined>): SupportHolder[];
 export declare const AMOUNTS: number[];
+/** A CoinPay hosted checkout session id (cs_...), as stored where a payment id used to be. */
+export declare function isSessionRef(ref: string): boolean;
+/** Where a payer finishes a stored payment: its hosted session, or an older one-coin invoice. */
+export declare function payUrl(ref: string): string;
+/** The site hostname every nixamp sale is filed under at CoinPay. */
+export declare function propertyOf(site: string): string;
+/** The coin a stored payment names: "ANY" for a hosted session, where the payer picks (or PayPal). */
+export declare function coinOf(value: unknown): string;
+/** "in USDC_POL" for an older one-coin payment; nothing for a session. */
+export declare function paidIn(coin: string): string;
+/** Who pays: CoinPay needs an email for the receipt; the account id defaults to it (a guest). */
+export interface Payer {
+    email?: unknown;
+    accountId?: string | null;
+}
 export declare class SupportError extends Error {
     readonly status: number;
     readonly code: string;
@@ -30,20 +45,49 @@ export declare class Support {
         business: string;
         coins: string[];
     }>;
-    /** Any CoinPay checkout on nixamp's business (a purchase in the store): no holder, no floor but a cent. */
+    /** The POST /api/checkout/sessions body: what CoinPay files the sale under. */
+    sessionBody(input: {
+        amountUsd: number;
+        description: string;
+        metadata: Record<string, unknown>;
+        redirect: string;
+        cancel?: string;
+        email: string;
+        accountId: string;
+    }): Record<string, unknown>;
+    /** Open a CoinPay hosted checkout session; its id stands where a payment id used to. */
+    private session;
+    /**
+     * Any CoinPay checkout on nixamp's business (a purchase in the store): no
+     * holder, no floor but a cent. A hosted session, so the payer picks any coin
+     * or PayPal there; `coin` is what an older page still sends, and is ignored.
+     */
     pay(input: {
         amountUsd: number;
-        coin: unknown;
+        coin?: unknown;
         description: string;
         metadata: Record<string, unknown>;
         redirect: string;
         order: string;
-    }): Promise<{
+    } & Payer): Promise<{
         url: string;
         paymentId: string;
     }>;
-    /** Whether CoinPay counts this payment as paid; null when it did not answer. */
+    /**
+     * Whether CoinPay counts this payment as paid; null when it did not answer.
+     * A session (cs_...) is asked as a session: paid by any coin or PayPal.
+     */
     isPaid(paymentId: string): Promise<boolean | null>;
+    /**
+     * A hosted session's state: "paid", "open" (with when it expires) or
+     * anything else CoinPay says (expired, canceled); null when it did not
+     * answer. An older one-coin payment is "paid" or "gone": its page cannot be
+     * reopened, so it is never handed out again.
+     */
+    sessionState(ref: string): Promise<{
+        status: string;
+        expiresAt: number;
+    } | null>;
     /** A CoinPay checkout for this much, to this holder; the address to send the payer to. */
     checkout(input: {
         holder?: unknown;
@@ -52,7 +96,7 @@ export declare class Support {
         station?: unknown;
         track?: unknown;
         metadata?: Record<string, unknown>;
-    }): Promise<{
+    } & Payer): Promise<{
         url: string;
         paymentId: string;
     }>;
@@ -71,9 +115,10 @@ export declare function nextMonth(at: number): number;
  * Monthly support, run here rather than by CoinPay: CoinPay's only merchant
  * subscriptions are Stripe's, and its recurring invoices refuse a scoped key.
  * A subscription is an email, an amount, a coin and a holder. Month one is
- * paid at once on CoinPay's checkout; each month after, a new payment is made
- * and its link emailed, with a one-click cancel. A month left unpaid ends it
- * (lapsed) rather than emailing forever.
+ * paid at once on CoinPay's checkout; each month after, the subscription's
+ * stable pay link is emailed (it opens a fresh CoinPay session whenever it is
+ * followed, since a session expires within two hours), with a one-click
+ * cancel. A month left unpaid ends it (lapsed) rather than emailing forever.
  */
 export declare class SupportSubscriptions {
     private readonly options;
@@ -102,11 +147,35 @@ export declare class SupportSubscriptions {
         email?: unknown;
         station?: unknown;
         track?: unknown;
+        accountId?: string | null;
     }): Promise<{
         url: string;
         id: string;
     }>;
     cancelLink(id: string, token: string): string;
+    /**
+     * The subscription's stable "pay this month" link. A CoinPay session lives
+     * at most two hours, so an emailed session link was dead by the time most
+     * people read it; this one opens a fresh session whenever it is followed.
+     * The token is the subscription's own secret (the cancel link's).
+     */
+    payLink(id: string, token: string): string;
+    /** The checkouts opened for the subscription's current month, newest last. */
+    private static cycleIds;
+    /** Whether any of this month's checkouts is paid; null when CoinPay could not say and none is known paid. */
+    private cyclePaid;
+    /**
+     * Following the pay link: this month's checkout to send the payer to.
+     * "paid" when a checkout this month is already paid; "redirect" to a
+     * session still open for at least 15 minutes, else to a new one.
+     */
+    open(id: string, token: string): Promise<{
+        state: "redirect";
+        url: string;
+    } | {
+        state: "paid" | "canceled" | "lapsed";
+        holder: string;
+    }>;
     cancel(id: string, token: string): Promise<{
         canceled: boolean;
         holder: string;