nixamp 0.67.1 → 0.67.4

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/dist/veo-studio.d.ts

@@ -52,6 +52,12 @@ export declare class VeoStudio {
         seconds: number;
         references: Buffer[];
     }): Promise<Buffer>;
+    /** Veo 3.1 Fast on fal.ai: with the portraits as references when there are any, else from the prompt alone. */
+    private viaFal;
+    /** fal.ai takes inputs by URL only (a data: URI is "invalid"): its own storage first. */
+    private falUpload;
+    /** One fal.ai queue job to its video: submitted, waited on (up to 10 minutes), downloaded. */
+    private falJob;
     get canLipsync(): boolean;
     /**
      * A singer's close-up with the mouth redrawn to `audio` (the same seconds of

package/dist/veo-studio.js

@@ -20,6 +20,8 @@ import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 export class VeoBudgetError extends Error {
 }
+/** Google will make no more today (quota) or has no credit left: worth trying fal.ai instead. */
+const GOOGLE_OUT = /quota|prepayment|depleted|RESOURCE_EXHAUSTED|\b429\b/i;
 export class VeoRefused extends Error {
 }
 /** The spend in Postgres, one row a month, reserved atomically. */
@@ -101,13 +103,76 @@ export class VeoStudio {
         if (!(await this.options.ledger.reserve(month, cost, this.cap)))
             throw new VeoBudgetError(`this month's $${this.cap} of Veo is spent`);
         try {
-            return await this.make(input.prompt, seconds, input.references.slice(0, 3));
+            try {
+                return await this.make(input.prompt, seconds, input.references.slice(0, 3));
+            }
+            catch (error) {
+                // Google out of quota for the day, or its prepaid credit spent: the same Veo on fal.ai.
+                if (!this.options.falKey || !(error instanceof VeoRefused) || !GOOGLE_OUT.test(error.message))
+                    throw error;
+                return await this.viaFal(this.options.falKey, input.prompt, seconds, input.references.slice(0, 3));
+            }
         }
         catch (error) {
             await this.options.ledger.refund(month, cost).catch(() => undefined);
             throw error;
         }
     }
+    /** Veo 3.1 Fast on fal.ai: with the portraits as references when there are any, else from the prompt alone. */
+    async viaFal(key, prompt, seconds, references) {
+        const settings = { prompt: prompt.slice(0, 1800), duration: `${seconds}s`, aspect_ratio: "16:9", resolution: "1080p", generate_audio: false };
+        if (references.length) {
+            const image_urls = await Promise.all(references.map((bytes, i) => this.falUpload(key, bytes, "image/jpeg", `ref-${i}.jpg`)));
+            try {
+                return await this.falJob(key, "fal-ai/veo3.1/fast/reference-to-video", { ...settings, image_urls }, "the fal.ai Veo shot");
+            }
+            catch (error) {
+                // A reference shot it will not make is tried once from the words alone.
+                if (!(error instanceof VeoRefused))
+                    throw error;
+            }
+        }
+        return await this.falJob(key, "fal-ai/veo3.1/fast", settings, "the fal.ai Veo shot");
+    }
+    /** fal.ai takes inputs by URL only (a data: URI is "invalid"): its own storage first. */
+    async falUpload(key, bytes, type, name) {
+        const send = this.options.fetcher ?? fetch;
+        const init = await send("https://rest.alpha.fal.ai/storage/upload/initiate?storage_type=fal-cdn-v3", { method: "POST", headers: { authorization: `Key ${key}`, "content-type": "application/json" }, body: JSON.stringify({ content_type: type, file_name: name }), signal: AbortSignal.timeout(30_000) });
+        const slot = await init.json().catch(() => ({}));
+        if (!slot.upload_url || !slot.file_url)
+            throw new VeoRefused(`fal.ai storage refused the upload (HTTP ${init.status})`);
+        const put = await send(slot.upload_url, { method: "PUT", headers: { "content-type": type }, body: new Uint8Array(bytes), signal: AbortSignal.timeout(120_000) });
+        if (!put.ok)
+            throw new VeoRefused(`fal.ai storage refused the upload (HTTP ${put.status})`);
+        return slot.file_url;
+    }
+    /** One fal.ai queue job to its video: submitted, waited on (up to 10 minutes), downloaded. */
+    async falJob(key, model, body, what) {
+        const send = this.options.fetcher ?? fetch;
+        const auth = { authorization: `Key ${key}`, "content-type": "application/json" };
+        const started = await send(`https://queue.fal.run/${model}`, { method: "POST", headers: auth, body: JSON.stringify(body), signal: AbortSignal.timeout(60_000) });
+        const job = await started.json().catch(() => ({}));
+        if (!started.ok || !job.status_url || !job.response_url)
+            throw new VeoRefused(`fal.ai refused ${what}: HTTP ${started.status}`);
+        const sleep = this.options.sleep ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+        for (let tries = 0; tries < 120; tries++) {
+            await sleep(5_000);
+            const state = await (await send(job.status_url, { headers: auth, signal: AbortSignal.timeout(30_000) })).json().catch(() => ({}));
+            if (state.status !== "COMPLETED")
+                continue;
+            const answer = await send(job.response_url, { headers: auth, signal: AbortSignal.timeout(30_000) });
+            const result = await answer.json().catch(() => ({}));
+            const why = typeof result.detail === "string" ? result.detail : result.detail?.[0]?.msg;
+            if (!answer.ok || !result.video?.url)
+                throw new VeoRefused(`${what} failed: ${why ?? `HTTP ${answer.status}`}`);
+            const out = await send(result.video.url, { signal: AbortSignal.timeout(120_000) });
+            const bytes = Buffer.from(await out.arrayBuffer());
+            if (!out.ok || bytes.length < 10_000)
+                throw new VeoRefused(`${what} did not download (HTTP ${out.status})`);
+            return bytes;
+        }
+        throw new VeoRefused(`${what} took too long (10 minutes)`);
+    }
     get canLipsync() { return Boolean(this.options.falKey); }
     /**
      * A singer's close-up with the mouth redrawn to `audio` (the same seconds of
@@ -131,41 +196,8 @@ export class VeoStudio {
         }
     }
     async sync(key, video, audio) {
-        const send = this.options.fetcher ?? fetch;
-        const auth = { authorization: `Key ${key}`, "content-type": "application/json" };
-        // fal.ai takes inputs by URL only (a data: URI is "invalid"): its own storage first.
-        const upload = async (bytes, type, name) => {
-            const init = await send("https://rest.alpha.fal.ai/storage/upload/initiate?storage_type=fal-cdn-v3", { method: "POST", headers: auth, body: JSON.stringify({ content_type: type, file_name: name }), signal: AbortSignal.timeout(30_000) });
-            const slot = await init.json().catch(() => ({}));
-            if (!slot.upload_url || !slot.file_url)
-                throw new VeoRefused(`fal.ai storage refused the upload (HTTP ${init.status})`);
-            const put = await send(slot.upload_url, { method: "PUT", headers: { "content-type": type }, body: new Uint8Array(bytes), signal: AbortSignal.timeout(120_000) });
-            if (!put.ok)
-                throw new VeoRefused(`fal.ai storage refused the upload (HTTP ${put.status})`);
-            return slot.file_url;
-        };
-        const [videoUrl, audioUrl] = await Promise.all([upload(video, "video/mp4", "shot.mp4"), upload(audio, "audio/mpeg", "vocal.mp3")]);
-        const started = await send("https://queue.fal.run/fal-ai/sync-lipsync/v2", { method: "POST", headers: auth, body: JSON.stringify({ video_url: videoUrl, audio_url: audioUrl }), signal: AbortSignal.timeout(60_000) });
-        const job = await started.json().catch(() => ({}));
-        if (!started.ok || !job.status_url || !job.response_url)
-            throw new VeoRefused(`fal.ai refused the lip sync: HTTP ${started.status}`);
-        const sleep = this.options.sleep ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
-        for (let tries = 0; tries < 120; tries++) {
-            await sleep(5_000);
-            const state = await (await send(job.status_url, { headers: auth, signal: AbortSignal.timeout(30_000) })).json().catch(() => ({}));
-            if (state.status !== "COMPLETED")
-                continue;
-            const answer = await send(job.response_url, { headers: auth, signal: AbortSignal.timeout(30_000) });
-            const result = await answer.json().catch(() => ({}));
-            if (!answer.ok || !result.video?.url)
-                throw new VeoRefused(`the lip sync failed: ${result.detail?.[0]?.msg ?? `HTTP ${answer.status}`}`);
-            const out = await send(result.video.url, { signal: AbortSignal.timeout(120_000) });
-            const bytes = Buffer.from(await out.arrayBuffer());
-            if (!out.ok || bytes.length < 10_000)
-                throw new VeoRefused(`the lip-synced clip did not download (HTTP ${out.status})`);
-            return bytes;
-        }
-        throw new VeoRefused("the lip sync took too long (10 minutes)");
+        const [videoUrl, audioUrl] = await Promise.all([this.falUpload(key, video, "video/mp4", "shot.mp4"), this.falUpload(key, audio, "audio/mpeg", "vocal.mp3")]);
+        return await this.falJob(key, "fal-ai/sync-lipsync/v2", { video_url: videoUrl, audio_url: audioUrl }, "the lip sync");
     }
     async make(prompt, seconds, references) {
         const send = this.options.fetcher ?? fetch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.67.1",
+  "version": "0.67.4",
   "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",