nixamp 0.67.0 → 0.67.3

package/dist/support.js

@@ -8,7 +8,9 @@
  * holders nixamp.com collects for -- today Profullstack's own music (the
  * band Þrøngva, AI radio) -- named in NIXAMP_SUPPORT_HOLDERS ("id=Name,...").
  *
- * One payment, in crypto, on CoinPay's hosted checkout. CoinPay offers no
+ * One payment on CoinPay's hosted checkout session: the payer picks any coin
+ * nixamp's business takes, or PayPal, and the sale is filed under nixamp.com
+ * with the payer's account id (their email when signed out) and email. CoinPay offers no
  * crypto subscription a business key can start (its plan/subscribe API is
  * Stripe's, which we do not use), so "monthly" is not offered rather than
  * pretended.
@@ -24,6 +26,33 @@ export function supportHoldersFrom(env = process.env) {
 export const AMOUNTS = [3, 5, 10, 25, 50];
 const MIN_USD = 1;
 const MAX_USD = 1000;
+const SESSION = /^cs_[A-Za-z0-9]{16,64}$/;
+const COINPAY = "https://coinpayportal.com";
+/** A CoinPay hosted checkout session id (cs_...), as stored where a payment id used to be. */
+export function isSessionRef(ref) {
+    return SESSION.test(ref);
+}
+/** Where a payer finishes a stored payment: its hosted session, or an older one-coin invoice. */
+export function payUrl(ref) {
+    return isSessionRef(ref) ? `${COINPAY}/checkout/${ref}` : `${COINPAY}/pay/${encodeURIComponent(ref)}`;
+}
+/** The site hostname every nixamp sale is filed under at CoinPay. */
+export function propertyOf(site) {
+    try {
+        return new URL(site).hostname.replace(/^www\./, "").toLowerCase() || "nixamp.com";
+    }
+    catch {
+        return "nixamp.com";
+    }
+}
+/** The coin a stored payment names: "ANY" for a hosted session, where the payer picks (or PayPal). */
+export function coinOf(value) {
+    return typeof value === "string" && /^[A-Za-z0-9_]{2,20}$/.test(value.trim()) ? value.trim().toUpperCase() : "ANY";
+}
+/** "in USDC_POL" for an older one-coin payment; nothing for a session. */
+export function paidIn(coin) {
+    return coin && coin !== "ANY" ? ` in ${coin}` : "";
+}
 export class SupportError extends Error {
     status;
     code;
@@ -81,33 +110,66 @@ export class Support {
         }
         return this.merchant;
     }
-    /** Any CoinPay checkout on nixamp's business (a purchase in the store): no holder, no floor but a cent. */
-    async pay(input) {
-        const { business, coins } = await this.coins();
-        const coin = typeof input.coin === "string" ? input.coin.toUpperCase() : "";
-        if (!coins.includes(coin))
-            throw new SupportError(`Pay with one of: ${coins.join(", ")}.`, 400, "invalid_coin");
-        const created = await this.provider("/api/payments/create", {
+    /** The POST /api/checkout/sessions body: what CoinPay files the sale under. */
+    sessionBody(input) {
+        return {
+            amount: Math.max(0.01, Math.round(input.amountUsd * 100) / 100),
+            currency: "USD",
+            description: input.description.slice(0, 200),
+            customer_email: input.email,
+            account_id: input.accountId,
+            property: propertyOf(this.options.site),
+            metadata: { app: "nixamp", ...input.metadata },
+            success_url: input.redirect,
+            cancel_url: input.cancel ?? input.redirect,
+            expires_in_minutes: 60,
+        };
+    }
+    /** Open a CoinPay hosted checkout session; its id stands where a payment id used to. */
+    async session(input) {
+        const email = typeof input.email === "string" ? input.email.trim().toLowerCase() : "";
+        if (!EMAIL.test(email))
+            throw new SupportError("Give an email for the receipt.", 400, "invalid_email");
+        const accountId = (typeof input.accountId === "string" && input.accountId.trim()) || email;
+        const created = await this.provider("/api/checkout/sessions", {
             method: "POST",
-            headers: { "idempotency-key": `nixamp-${input.order}` },
-            body: JSON.stringify({
-                business_id: business,
-                amount_usd: Math.max(0.01, Math.round(input.amountUsd * 100) / 100),
-                currency: coin.toLowerCase(),
-                payment_method: "crypto",
-                description: input.description.slice(0, 200),
-                metadata: { app: "nixamp", ...input.metadata },
-                redirect_url: input.redirect,
-            }),
+            body: JSON.stringify(this.sessionBody({ ...input, email, accountId })),
         });
-        const payment = created["payment"];
-        const id = typeof payment?.id === "string" ? payment.id : "";
-        if (!/^[A-Za-z0-9_-]{6,80}$/.test(id))
+        const id = typeof created["id"] === "string" ? created["id"] : "";
+        if (!SESSION.test(id))
             throw new SupportError("The checkout did not start; nothing was charged. Try again.", 502, "provider");
-        return { url: `https://coinpayportal.com/pay/${id}`, paymentId: id };
+        return { url: payUrl(id), paymentId: id };
     }
-    /** Whether CoinPay counts this payment as paid; null when it did not answer. */
+    /**
+     * 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.
+     */
+    async pay(input) {
+        return this.session({ ...input, metadata: { order: input.order, ...input.metadata } });
+    }
+    /**
+     * 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.
+     */
     async isPaid(paymentId) {
+        if (isSessionRef(paymentId)) {
+            try {
+                const response = await (this.options.fetcher ?? fetch)(`${COINPAY}/api/checkout/sessions/${encodeURIComponent(paymentId)}`, {
+                    signal: AbortSignal.timeout(15_000),
+                    headers: { authorization: `Bearer ${this.options.key}` },
+                });
+                if (!response.ok)
+                    return null;
+                const body = (await response.json());
+                if (body.session?.id !== paymentId)
+                    return null;
+                return body.session.status === "paid";
+            }
+            catch {
+                return null;
+            }
+        }
         try {
             const response = await (this.options.fetcher ?? fetch)(`https://coinpayportal.com/api/payments/${encodeURIComponent(paymentId)}`, {
                 signal: AbortSignal.timeout(15_000),
@@ -122,6 +184,34 @@ export class Support {
             return 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.
+     */
+    async sessionState(ref) {
+        if (!isSessionRef(ref)) {
+            const paid = await this.isPaid(ref);
+            return paid === null ? null : { status: paid ? "paid" : "gone", expiresAt: 0 };
+        }
+        try {
+            const response = await (this.options.fetcher ?? fetch)(`${COINPAY}/api/checkout/sessions/${encodeURIComponent(ref)}`, {
+                signal: AbortSignal.timeout(15_000),
+                headers: { authorization: `Bearer ${this.options.key}` },
+            });
+            if (!response.ok)
+                return null;
+            const body = (await response.json());
+            if (body.session?.id !== ref)
+                return null;
+            const expiresAt = Date.parse(String(body.session.expires_at ?? "")) || 0;
+            return { status: String(body.session.status ?? ""), expiresAt };
+        }
+        catch {
+            return null;
+        }
+    }
     /** A CoinPay checkout for this much, to this holder; the address to send the payer to. */
     async checkout(input) {
         const holder = typeof input.holder === "string" ? this.holder(input.holder) : undefined;
@@ -130,30 +220,17 @@ export class Support {
         const amount = Number(input.amountUsd);
         if (!Number.isFinite(amount) || amount < MIN_USD || amount > MAX_USD)
             throw new SupportError(`Choose an amount from $${MIN_USD} to $${MAX_USD}.`, 400, "invalid_amount");
-        const { business, coins } = await this.coins();
-        const coin = typeof input.coin === "string" ? input.coin.toUpperCase() : "";
-        if (!coins.includes(coin))
-            throw new SupportError(`Pay with one of: ${coins.join(", ")}.`, 400, "invalid_coin");
         const clean = (value) => (typeof value === "string" ? value.replace(/[\u0000-\u001f]/g, " ").slice(0, 120) : "");
         const order = randomUUID();
-        const created = await this.provider("/api/payments/create", {
-            method: "POST",
-            headers: { "idempotency-key": `nixamp-support-${order}` },
-            body: JSON.stringify({
-                business_id: business,
-                amount_usd: Math.round(amount * 100) / 100,
-                currency: coin.toLowerCase(),
-                payment_method: "crypto",
-                description: `Support ${holder.name} on nixamp`,
-                metadata: { app: "nixamp", product: "support", holder: holder.id, order, station: clean(input.station), track: clean(input.track), ...(input.metadata ?? {}) },
-                redirect_url: `${this.options.site}/support/${holder.id}?thanks=1`,
-            }),
+        return this.session({
+            amountUsd: amount,
+            description: `Support ${holder.name} on nixamp`,
+            metadata: { product: "support", holder: holder.id, order, station: clean(input.station), track: clean(input.track), ...(input.metadata ?? {}) },
+            redirect: `${this.options.site}/support/${holder.id}?thanks=1`,
+            cancel: `${this.options.site}/support/${holder.id}`,
+            email: input.email,
+            accountId: input.accountId ?? null,
         });
-        const payment = created["payment"];
-        const id = typeof payment?.id === "string" ? payment.id : "";
-        if (!/^[A-Za-z0-9_-]{6,80}$/.test(id))
-            throw new SupportError("The checkout did not start; nothing was charged. Try again.", 502, "provider");
-        return { url: `https://coinpayportal.com/pay/${id}`, paymentId: id };
     }
 }
 const STYLE = `
@@ -190,16 +267,14 @@ const SCRIPT = `
   }
   const monthly = () => document.querySelector("input[name=often]:checked").value === "monthly";
   for (const r of document.querySelectorAll("input[name=often]")) r.addEventListener("change", () => {
-    $("#email-box").hidden = !monthly();
+    $("#email-label").textContent = monthly() ? "Email, for the receipt and each month's payment link (and the cancel link)" : "Email, for the receipt";
     $("#go").textContent = monthly() ? "Pay the first month" : "Continue to payment";
   });
   if (params.get("thanks")) { $("#status").className = "thanks"; $("#status").textContent = "Thank you. Your payment is on its way."; }
   try {
     const info = await (await fetch("/api/v1/support/" + encodeURIComponent(holder), { cache: "no-store" })).json();
     if (info.name) { $("#who").textContent = info.name; document.title = "Support " + info.name + " · nixamp"; }
-    const coins = info.coins || [];
-    $("#coin").replaceChildren(...coins.map((c) => { const o = document.createElement("option"); o.value = c; o.textContent = c.replace(/_/g, " "); return o; }));
-    if (!coins.length) { $("#go").disabled = true; $("#status").textContent = info.error || "Payments are not available right now."; }
+    if (info.error) { $("#go").disabled = true; $("#status").textContent = info.error; }
   } catch { $("#status").textContent = "Payments are not available right now."; }
   $("#form").addEventListener("submit", async (event) => {
     event.preventDefault();
@@ -209,8 +284,8 @@ const SCRIPT = `
     $("#status").textContent = "Starting the checkout…";
     try {
       const r = await fetch("/api/v1/support/" + encodeURIComponent(holder), { method: "POST", headers: { "content-type": "application/json" },
-        body: JSON.stringify({ amountUsd: usd, coin: $("#coin").value, station: params.get("station") || "", track: params.get("track") || "",
-          ...(monthly() ? { monthly: true, email: $("#email").value } : {}) }) });
+        body: JSON.stringify({ amountUsd: usd, email: $("#email").value, station: params.get("station") || "", track: params.get("track") || "",
+          ...(monthly() ? { monthly: true } : {}) }) });
       const body = await r.json();
       if (r.ok && body.url) { location.href = body.url; return; }
       $("#status").textContent = body.error || "That did not work.";
@@ -233,22 +308,18 @@ export const SUPPORT_PAGE = `<!doctype html>
 <main>
   <div class="card">
     <h1>Support <span id="who">the artist</span></h1>
-    <p>Pay the copyright holder of the music you are listening to, directly, in crypto through CoinPay. Once, or every month.</p>
+    <p>Pay the copyright holder of the music you are listening to, directly, through CoinPay: any coin, or PayPal. Once, or every month.</p>
     <form id="form">
       <div class="often"><label><input type="radio" name="often" value="once" checked> One time</label><label><input type="radio" name="often" value="monthly"> Monthly</label></div>
       <div class="amounts">${AMOUNTS.map((usd, at) => `<button type="button" data-usd="${usd}" aria-pressed="${at === 1}">$${usd}</button>`).join("")}</div>
       <label for="other">Or another amount (US$)</label>
       <input id="other" type="number" min="1" max="1000" step="1" inputmode="numeric">
-      <div id="email-box" hidden>
-        <label for="email">Email, for each month's payment link (and the cancel link)</label>
-        <input id="email" type="email" autocomplete="email" maxlength="254">
-      </div>
-      <label for="coin">Pay with</label>
-      <select id="coin"></select>
+      <label id="email-label" for="email">Email, for the receipt</label>
+      <input id="email" type="email" autocomplete="email" maxlength="254" required>
       <button id="go" class="go" type="submit">Continue to payment</button>
       <div id="status" role="status" aria-live="polite"></div>
     </form>
-    <small>Payments go through <a href="https://coinpayportal.com">CoinPay</a> to nixamp.com, which pays the holder. Monthly: each month we email a new payment link; nothing is taken until you pay it, and every email has a one-click cancel.</small>
+    <small>Payments go through <a href="https://coinpayportal.com">CoinPay</a> to nixamp.com, which pays the holder. You pick the coin, or PayPal, on CoinPay's page. Monthly: each month we email a new payment link; nothing is taken until you pay it, and every email has a one-click cancel.</small>
   </div>
 </main>
 <script>${SCRIPT}</script>
@@ -276,9 +347,10 @@ export function nextMonth(at) {
  * 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 class SupportSubscriptions {
     options;
@@ -298,6 +370,9 @@ export class SupportSubscriptions {
         cycles INTEGER NOT NULL DEFAULT 0, last_payment_id TEXT, next_due TIMESTAMPTZ NOT NULL,
         station TEXT NOT NULL DEFAULT '', created_at TIMESTAMPTZ NOT NULL, canceled_at TIMESTAMPTZ)`);
             await this.options.db.query("CREATE INDEX IF NOT EXISTS support_subscriptions_due ON support_subscriptions (status, next_due)");
+            // Every checkout opened for the current month, space separated: a payer
+            // may open several from the pay link, and any one of them paid counts.
+            await this.options.db.query("ALTER TABLE support_subscriptions ADD COLUMN IF NOT EXISTS cycle_payment_ids TEXT NOT NULL DEFAULT ''");
         })().catch((error) => { this.schema = null; throw error; });
         return this.schema;
     }
@@ -315,14 +390,17 @@ export class SupportSubscriptions {
             throw new SupportError("That email already has ten monthly supports.", 409, "too_many");
         const id = randomUUID();
         const token = randomUUID().replace(/-/g, "");
-        const checkout = await this.options.support.checkout({ ...input, holder: holder.id, metadata: { subscription: id, cycle: 1 } });
+        const checkout = await this.options.support.checkout({ ...input, email, holder: holder.id, metadata: { subscription: id, cycle: 1 } });
+        // The payer picks the coin (or PayPal) on CoinPay; an older page may still name one.
+        const coin = (typeof input.coin === "string" && input.coin.trim() ? input.coin : "ANY").toUpperCase();
+        const paidWith = coin === "ANY" ? "" : ` in ${coin}`;
         const now = this.now();
-        await this.options.db.query(`INSERT INTO support_subscriptions (id, token, holder, email, amount_cents, coin, cycles, last_payment_id, next_due, station, created_at)
-      VALUES ($1,$2,$3,$4,$5,$6,1,$7,$8,$9,$10)`, [id, token, holder.id, email, Math.round(Number(input.amountUsd) * 100), String(input.coin).toUpperCase(), checkout.paymentId, new Date(nextMonth(now)), typeof input.station === "string" ? input.station.slice(0, 20) : "", new Date(now)]);
+        await this.options.db.query(`INSERT INTO support_subscriptions (id, token, holder, email, amount_cents, coin, cycles, last_payment_id, next_due, station, created_at, cycle_payment_ids)
+      VALUES ($1,$2,$3,$4,$5,$6,1,$7,$8,$9,$10,$7)`, [id, token, holder.id, email, Math.round(Number(input.amountUsd) * 100), coin, checkout.paymentId, new Date(nextMonth(now)), typeof input.station === "string" ? input.station.slice(0, 20) : "", new Date(now)]);
         await this.mail(email, `Your monthly support for ${holder.name}`, [
-            `Thank you for supporting ${holder.name} on nixamp, $${Number(input.amountUsd).toFixed(2)} a month in ${String(input.coin).toUpperCase()}.`,
-            `This month: ${checkout.url}`,
-            `Each month we email you a new payment link like this one. Nothing is taken without you paying it.`,
+            `Thank you for supporting ${holder.name} on nixamp, $${Number(input.amountUsd).toFixed(2)} a month${paidWith}.`,
+            `Pay this month: ${this.payLink(id, token)}`,
+            `That link works all month: each time you open it, it starts a fresh checkout (or shows that this month is paid). Each month we email you the same link. Nothing is taken without you paying it.`,
             `Stop at any time: ${this.cancelLink(id, token)}`,
         ]);
         return { url: checkout.url, id };
@@ -330,6 +408,81 @@ export class SupportSubscriptions {
     cancelLink(id, token) {
         return `${this.options.site}/support/cancel?s=${encodeURIComponent(id)}&t=${encodeURIComponent(token)}`;
     }
+    /**
+     * 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, token) {
+        return `${this.options.site}/support/pay/${encodeURIComponent(id)}/${encodeURIComponent(token)}`;
+    }
+    /** The checkouts opened for the subscription's current month, newest last. */
+    static cycleIds(row) {
+        const listed = String(row["cycle_payment_ids"] ?? "").split(/\s+/).filter(Boolean);
+        const last = String(row["last_payment_id"] ?? "");
+        if (last && !listed.includes(last))
+            listed.push(last);
+        return listed;
+    }
+    /** Whether any of this month's checkouts is paid; null when CoinPay could not say and none is known paid. */
+    async cyclePaid(row) {
+        let unknown = false;
+        for (const ref of SupportSubscriptions.cycleIds(row)) {
+            const paid = await this.paid(ref);
+            if (paid === true)
+                return true;
+            if (paid === null)
+                unknown = true;
+        }
+        return unknown ? null : false;
+    }
+    /**
+     * 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.
+     */
+    async open(id, token) {
+        if (!/^[0-9a-f-]{36}$/.test(id) || !/^[0-9a-f]{32}$/.test(token))
+            throw new SupportError("That payment link is not one of ours.", 404, "not_found");
+        await this.ready();
+        const found = await this.options.db.query("SELECT * FROM support_subscriptions WHERE id = $1 AND token = $2", [id, token]);
+        const row = found.rows[0];
+        if (!row)
+            throw new SupportError("That payment link is not one of ours.", 404, "not_found");
+        const holderId = String(row["holder"]);
+        const status = String(row["status"]);
+        if (status === "canceled" || status === "lapsed")
+            return { state: status, holder: holderId };
+        const holder = this.options.support.holder(holderId);
+        if (!holder)
+            throw new SupportError("Nobody by that name is supported here any more.", 404, "not_found");
+        const ids = SupportSubscriptions.cycleIds(row);
+        const newest = ids.at(-1);
+        let unknown = false;
+        for (const ref of ids) {
+            const state = await this.options.support.sessionState(ref);
+            if (state === null) {
+                unknown = true;
+                continue;
+            }
+            if (state.status === "paid")
+                return { state: "paid", holder: holderId };
+            if (ref === newest && state.status === "open" && state.expiresAt - this.now() >= 15 * 60_000)
+                return { state: "redirect", url: payUrl(ref) };
+        }
+        // A checkout CoinPay could not report on may be paid: do not stack new ones on it.
+        if (unknown)
+            throw new SupportError("The payment service did not answer; nothing was charged. Try the link again in a minute.", 502, "provider");
+        if (ids.length >= 20)
+            throw new SupportError("This month's link has opened too many checkouts; reply to the email and we will sort it out.", 429, "too_many");
+        const checkout = await this.options.support.checkout({ holder: holder.id, amountUsd: Number(row["amount_cents"]) / 100, email: String(row["email"]),
+            station: String(row["station"] ?? ""), metadata: { subscription: id, cycle: Number(row["cycles"]) } });
+        // Appended under the row's own month, so a renewal racing this click is not overwritten.
+        await this.options.db.query(`UPDATE support_subscriptions SET last_payment_id = $3,
+      cycle_payment_ids = trim(both ' ' from cycle_payment_ids || ' ' || $3) WHERE id = $1 AND cycles = $2`, [id, Number(row["cycles"]), checkout.paymentId]);
+        return { state: "redirect", url: checkout.url };
+    }
     async cancel(id, token) {
         await this.ready();
         const found = await this.options.db.query("UPDATE support_subscriptions SET status = 'canceled', canceled_at = $3 WHERE id = $1 AND token = $2 AND status <> 'canceled' RETURNING holder", [id, token, new Date(this.now())]);
@@ -343,19 +496,8 @@ export class SupportSubscriptions {
         return { canceled: true, holder: String(row["holder"]) };
     }
     async paid(paymentId) {
-        try {
-            const response = await (this.options.fetcher ?? fetch)(`https://coinpayportal.com/api/payments/${encodeURIComponent(paymentId)}`, {
-                signal: AbortSignal.timeout(15_000),
-                headers: { authorization: `Bearer ${this.options.support.key}` },
-            });
-            if (!response.ok)
-                return null;
-            const body = (await response.json());
-            return PAID.has(String(body.payment?.status ?? ""));
-        }
-        catch {
-            return null;
-        }
+        // A session (cs_...) or an older one-coin payment, asked the same way checkouts are.
+        return this.options.support.isPaid(paymentId);
     }
     /** Every subscription now due: a new month's payment and its link, or lapsed when last month went unpaid. */
     async renew() {
@@ -365,8 +507,7 @@ export class SupportSubscriptions {
         let lapsed = 0;
         for (const row of due.rows) {
             const id = String(row["id"]);
-            const last = String(row["last_payment_id"] ?? "");
-            const paid = last ? await this.paid(last) : false;
+            const paid = await this.cyclePaid(row);
             if (paid === null)
                 continue; // CoinPay did not answer: ask again next time.
             const holder = this.options.support.holder(String(row["holder"]));
@@ -382,18 +523,13 @@ export class SupportSubscriptions {
             }
             const amountUsd = Number(row["amount_cents"]) / 100;
             const cycle = Number(row["cycles"]) + 1;
-            let checkout;
-            try {
-                checkout = await this.options.support.checkout({ holder: holder.id, amountUsd, coin: String(row["coin"]), station: String(row["station"] ?? ""), metadata: { subscription: id, cycle } });
-            }
-            catch (error) {
-                this.options.log?.(`  support: renewal ${id} could not start a payment: ${error.message}`);
-                continue;
-            }
-            await this.options.db.query("UPDATE support_subscriptions SET cycles = $2, last_payment_id = $3, next_due = $4 WHERE id = $1", [id, cycle, checkout.paymentId, new Date(nextMonth(new Date(String(row["next_due"])).getTime()))]);
+            // No checkout is opened here: the email carries the stable pay link,
+            // which opens one when the payer follows it, however late in the month.
+            await this.options.db.query("UPDATE support_subscriptions SET cycles = $2, last_payment_id = NULL, cycle_payment_ids = '', next_due = $3 WHERE id = $1 AND cycles = $4", [id, cycle, new Date(nextMonth(new Date(String(row["next_due"])).getTime())), Number(row["cycles"])]);
             await this.mail(String(row["email"]), `This month's support for ${holder.name}`, [
-                `Your monthly support for ${holder.name}: $${amountUsd.toFixed(2)} in ${String(row["coin"])}.`,
-                `Pay this month: ${checkout.url}`,
+                `Your monthly support for ${holder.name}: $${amountUsd.toFixed(2)}, in any coin or PayPal.`,
+                `Pay this month: ${this.payLink(id, String(row["token"]))}`,
+                `The link works all month; each time you open it, it starts a fresh checkout.`,
                 `Stop at any time: ${this.cancelLink(id, String(row["token"]))}`,
             ]);
             renewed += 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.67.0",
+  "version": "0.67.3",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",
@@ -47,7 +47,7 @@
   "dependencies": {
     "@profullstack/auth-system": "^0.8.3",
     "@profullstack/hqtui": "^0.5.0",
-    "@profullstack/live-translate": "^0.1.0",
+    "@profullstack/live-translate": "^0.3.0",
     "@profullstack/notifications": "^0.1.0",
     "@profullstack/synconfig": "^0.1.2",
     "@profullstack/throttle": "^0.3.3",

package/src/ai-label.ts

@@ -59,6 +59,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;
@@ -812,11 +818,23 @@ export function closeUpTimes(seconds: number, lines: Array<{ start: number }>, c
 }
 
 /**
- * The version of a video cut from Veo footage: the band with nobody singing, and the
- * singer only in close-ups lip-synced to the song. Anything older (a slideshow, or 4:
- * footage whose singers were out of sync) is not shown.
+ * The version of a video cut from Veo footage: story scenes and the band playing with
+ * nobody singing, the singer only in close-ups lip-synced to the song. Anything older
+ * is not shown: a slideshow, 4 (singers out of sync) or 5 (all stage, the singer at
+ * the mic in the wide shots).
  */
-export const FILMED = 5;
+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: number): number {
+  const hour = (at: number): number => 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
@@ -992,6 +1010,8 @@ export class AiLabel {
   private alignTried = new Set<string>();
   /** 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 = 0;
   /** Old videos already tried as storyboards since this server started. */
   private upgradeTried = new Set<string>();
   /** When each single was last put in front of the camera: one that came up short is tried again an hour on. */
@@ -1327,7 +1347,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: LabelSong): boolean => 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: typeof songs = [];
     let made = 0;
@@ -1358,7 +1380,9 @@ 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;
@@ -1381,7 +1405,7 @@ export class AiLabel {
    * Fewer than half the shots filmed (a refusal, the budget spent) makes no
    * video at all: footage stretched that thin would be a loop, not a video.
    */
-  private async filmSong(artist: LabelArtist, _album: LabelAlbum, song: LabelSong, scenes: string, out: string, _upgrade = false): Promise<number> {
+  private async filmSong(artist: LabelArtist, _album: LabelAlbum, song: LabelSong, scenes: string, out: string, _upgrade = false): Promise<{ version: number; singer?: "synced" | "unsynced" }> {
     let seconds = song.seconds;
     try {
       const probed = await this.deps.probe(song.file);
@@ -1392,10 +1416,13 @@ export class AiLabel {
     const { band: clips, singer } = await this.filmShots(artist, _album, song, shots, scenes);
     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" as const : "unsynced" as const } : {}) };
   }
 
   /**
@@ -1446,7 +1473,8 @@ export class AiLabel {
 
   /** Whether this song gets filmed Veo shots: an album's single, Veo on, and the month's budget not spent. */
   private wantsVeo(song: Pick<LabelSong, "n">): boolean {
-    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;
   }
 
   /**
@@ -1496,10 +1524,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: [] as Buffer[] })),
       ...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 {
@@ -1525,6 +1554,12 @@ export class AiLabel {
           this.log(`Veo: ${(error as Error).message}; no more videos until next month`);
           break;
         }
+        if (VEO_QUOTA.test((error as 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 as Error).message}`);
       }
     }