nixamp 0.49.0 → 0.50.1

package/dist/music-store.js

@@ -0,0 +1,289 @@
+/**
+ * The music store on nixamp.com: the AI label's songs as files, bought with
+ * crypto through CoinPay.
+ *
+ * Listening is free on the live stations (with their breaks). What is sold is
+ * the files: a song for 10 cents, an album for $1, everything by an artist
+ * for $2, as a zip made on the fly by the server that holds them (MP3s with
+ * the cover and the words inside, each song's .lyrics.txt, cover.jpg and
+ * album.json). A buyer gives an email; once CoinPay says paid (its webhook,
+ * or asked when the buyer comes back), the email gets a link to the purchase,
+ * and the account with that email sees every purchase under My music on
+ * nixamp.com/radio, to play or download again.
+ *
+ * nixamp.com never holds the music. It signs a grant -- what was bought, from
+ * which server, until when -- and the server asks nixamp.com whether a grant
+ * is good before it plays or zips anything (/api/v1/store/grant).
+ */
+import { createHmac, randomUUID, timingSafeEqual } from "node:crypto";
+import { SupportError } 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;
+const KEY = /^[a-f0-9]{10}$/;
+const ALBUM = /^[a-f0-9]{8}$/;
+/** A grant is good for a day; pages mint a fresh one each time. */
+const GRANT_MS = 24 * 3600_000;
+/** A server's public address as given: https, no path, no trailing slash. */
+export function serverBase(value) {
+    if (typeof value !== "string")
+        return "";
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "https:" || url.username || url.password)
+            return "";
+        return url.origin;
+    }
+    catch {
+        return "";
+    }
+}
+function sign(secret, text) {
+    return createHmac("sha256", secret).update(text).digest("base64url");
+}
+/** `g1.<exp>.<kind>.<artist>.<album|->.<n>.<server, base64url>.<sig>` */
+export function makeGrant(secret, scope, exp) {
+    const body = ["g1", String(exp), scope.kind, scope.artist, scope.album || "-", String(scope.n), Buffer.from(scope.server).toString("base64url")].join(".");
+    return `${body}.${sign(secret, body)}`;
+}
+export function readGrant(secret, grant, now = Date.now()) {
+    const parts = grant.split(".");
+    if (parts.length !== 8 || parts[0] !== "g1")
+        return null;
+    const body = parts.slice(0, 7).join(".");
+    const expected = Buffer.from(sign(secret, body));
+    const given = Buffer.from(parts[7]);
+    if (expected.length !== given.length || !timingSafeEqual(expected, given))
+        return null;
+    const exp = Number(parts[1]);
+    if (!Number.isFinite(exp) || exp < now)
+        return null;
+    const kind = parts[2];
+    if (!(kind in PRICES))
+        return null;
+    return { kind, artist: parts[3], album: parts[4] === "-" ? "" : parts[4], n: Number(parts[5]), server: Buffer.from(parts[6], "base64url").toString("utf8"), exp };
+}
+/** Whether a grant for `scope` covers this file of the catalogue. */
+export function covers(scope, artist, album, n) {
+    if (scope.artist !== artist)
+        return false;
+    if (scope.kind === "artist")
+        return true;
+    if (scope.album !== album)
+        return false;
+    if (scope.kind === "album")
+        return true;
+    return n === undefined ? false : scope.n === n;
+}
+/**
+ * On a server that holds the music: whether nixamp.com signed this grant,
+ * asked at /api/v1/store/grant and remembered (a good one until it expires,
+ * a refused one for 5 minutes). nixamp.com itself checks with its secret.
+ */
+export class GrantVerifier {
+    options;
+    known = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async check(grant) {
+        const now = this.options.now?.() ?? Date.now();
+        if (!/^g1\.[A-Za-z0-9._-]{20,600}$/.test(grant))
+            return null;
+        if (this.options.secret)
+            return readGrant(this.options.secret, grant, now);
+        const hit = this.known.get(grant);
+        if (hit && hit.until > now)
+            return hit.scope;
+        try {
+            const response = await (this.options.fetcher ?? fetch)(`${this.options.site}/api/v1/store/grant?g=${encodeURIComponent(grant)}`, { signal: AbortSignal.timeout(5_000) });
+            if (response.status >= 500)
+                return null;
+            const body = await response.json();
+            const scope = body.ok && body.scope ? body.scope : null;
+            if (this.known.size > 5000)
+                this.known.clear();
+            this.known.set(grant, { scope, until: scope ? scope.exp : now + 5 * 60_000 });
+            return scope;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function row(one) {
+    return {
+        id: String(one["id"]), token: String(one["token"]), email: String(one["email"]), userId: String(one["user_id"] ?? ""),
+        server: String(one["server"]), kind: String(one["kind"]), artist: String(one["artist"]), album: String(one["album"] ?? ""), n: Number(one["n"] ?? 0),
+        title: String(one["title"]), artistName: String(one["artist_name"]), amountCents: Number(one["amount_cents"]), coin: String(one["coin"]),
+        paymentId: String(one["payment_id"] ?? ""), status: one["status"] === "paid" ? "paid" : "pending",
+        createdAt: new Date(String(one["created_at"])).getTime(), paidAt: one["paid_at"] ? new Date(String(one["paid_at"])).getTime() : 0,
+    };
+}
+export class MusicStore {
+    options;
+    schema = null;
+    constructor(options) {
+        this.options = options;
+    }
+    now() {
+        return this.options.now?.() ?? Date.now();
+    }
+    ready() {
+        this.schema ??= (async () => {
+            await this.options.db.query(`CREATE TABLE IF NOT EXISTS music_purchases (
+        id TEXT PRIMARY KEY, token TEXT NOT NULL, email TEXT NOT NULL, user_id TEXT NOT NULL DEFAULT '',
+        server TEXT NOT NULL, kind TEXT NOT NULL, artist TEXT NOT NULL, album TEXT NOT NULL DEFAULT '', n INTEGER NOT NULL DEFAULT 0,
+        title TEXT NOT NULL, artist_name TEXT NOT NULL, amount_cents INTEGER NOT NULL, coin TEXT NOT NULL,
+        payment_id TEXT, status TEXT NOT NULL DEFAULT 'pending', created_at TIMESTAMPTZ NOT NULL, paid_at TIMESTAMPTZ)`);
+            await this.options.db.query("CREATE INDEX IF NOT EXISTS music_purchases_email ON music_purchases (lower(email))");
+            await this.options.db.query("CREATE INDEX IF NOT EXISTS music_purchases_user ON music_purchases (user_id)");
+            await this.options.db.query("CREATE INDEX IF NOT EXISTS music_purchases_payment ON music_purchases (payment_id)");
+        })().catch((error) => { this.schema = null; throw error; });
+        return this.schema;
+    }
+    /** A server's catalogue, as it publishes it at /api/v1/label. */
+    async catalogue(server) {
+        const response = await (this.options.fetcher ?? fetch)(`${server}/api/v1/label`, { signal: AbortSignal.timeout(10_000), headers: { accept: "application/json" } });
+        if (!response.ok)
+            throw new SupportError("That server's catalogue could not be read. Try again.", 502, "catalogue");
+        return await response.json();
+    }
+    /** What is for sale at this address, with its name and price; refused when there is no such thing. */
+    async describe(input) {
+        const server = serverBase(input["server"]);
+        // A server in the directory or the guide's peers, or one named under nixamp.com (whose names
+        // and certificates nixamp.com issues): the directory empties on every restart of nixamp.com.
+        const named = server ? new URL(server).hostname.endsWith(".nixamp.com") : false;
+        if (!server || !(named || this.options.servers().includes(server)))
+            throw new SupportError("That server does not sell music here.", 404, "not_found");
+        const kind = String(input["kind"] ?? "");
+        if (!(kind in PRICES))
+            throw new SupportError("Buy a song, an album or an artist.", 400, "invalid_kind");
+        const artistKey = String(input["artist"] ?? "");
+        const albumKey = kind === "artist" ? "" : String(input["album"] ?? "");
+        const n = kind === "song" ? Number(input["n"]) : 0;
+        if (!KEY.test(artistKey) || (kind !== "artist" && !ALBUM.test(albumKey)) || (kind === "song" && !(Number.isInteger(n) && n > 0)))
+            throw new SupportError("No such music.", 404, "not_found");
+        const view = await this.catalogue(server);
+        const artist = view.genres.flatMap((one) => one.artists).find((one) => one.key === artistKey);
+        const album = artist?.albums.find((one) => one.key === albumKey);
+        const song = album?.songs.find((one) => one.n === n);
+        if (!artist || (kind !== "artist" && !album) || (kind === "song" && !song))
+            throw new SupportError("No such music.", 404, "not_found");
+        const title = kind === "artist" ? `Everything by ${artist.name}` : kind === "album" ? `${album.title} (${album.year})` : `${song.title}`;
+        const songs = kind === "artist" ? artist.albums.reduce((sum, one) => sum + one.songs.length, 0) : kind === "album" ? album.songs.length : 1;
+        return { server, kind, artist: artistKey, album: albumKey, n, title, artistName: artist.name, amountCents: PRICES[kind], songs };
+    }
+    /** A purchase waiting for its payment, and where to pay. Signed in, it is the account's too. */
+    async checkout(input, account) {
+        const email = (typeof input["email"] === "string" && input["email"].trim() ? input["email"] : account?.email ?? "").trim().toLowerCase();
+        if (!EMAIL.test(email))
+            throw new SupportError("Give the email your music should go to.", 400, "invalid_email");
+        const item = await this.describe(input);
+        await this.ready();
+        const id = randomUUID();
+        const token = randomUUID().replace(/-/g, "");
+        const checkout = await this.options.support.pay({
+            amountUsd: item.amountCents / 100,
+            coin: input["coin"],
+            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())]);
+        return { url: checkout.url, id, token };
+    }
+    /** The purchase's own page, which is also the receipt link. */
+    link(id, token) {
+        return `${this.options.site}/purchases/${id}?t=${token}`;
+    }
+    /** A purchase by its link; a pending one asks CoinPay whether it has been paid since. */
+    async get(id, token) {
+        await this.ready();
+        const found = (await this.options.db.query("SELECT * FROM music_purchases WHERE id = $1 AND token = $2", [id, token])).rows[0];
+        if (!found)
+            return null;
+        const purchase = row(found);
+        if (purchase.status === "pending" && purchase.paymentId && (await this.options.support.isPaid(purchase.paymentId)) === true)
+            return (await this.paid(purchase.id)) ?? purchase;
+        return purchase;
+    }
+    /** CoinPay's webhook: a payment of ours that is now paid. False when it is not a music purchase. */
+    async settle(paymentId) {
+        await this.ready();
+        const found = (await this.options.db.query("SELECT id, status FROM music_purchases WHERE payment_id = $1", [paymentId])).rows[0];
+        if (!found)
+            return { settled: false };
+        if (found["status"] === "paid")
+            return { settled: true, purchase: String(found["id"]) };
+        if ((await this.options.support.isPaid(paymentId)) !== true)
+            return { settled: false, purchase: String(found["id"]) };
+        await this.paid(String(found["id"]));
+        return { settled: true, purchase: String(found["id"]) };
+    }
+    /** Whether CoinPay's webhook is about one of ours. */
+    async owns(paymentId) {
+        await this.ready();
+        return (await this.options.db.query("SELECT 1 FROM music_purchases WHERE payment_id = $1", [paymentId])).rows.length > 0;
+    }
+    /** Marks it paid once (the first to get there sends the receipt). */
+    async paid(id) {
+        const updated = (await this.options.db.query("UPDATE music_purchases SET status = 'paid', paid_at = $2 WHERE id = $1 AND status = 'pending' RETURNING *", [id, new Date(this.now())])).rows[0];
+        if (!updated) {
+            const again = (await this.options.db.query("SELECT * FROM music_purchases WHERE id = $1", [id])).rows[0];
+            return again ? row(again) : null;
+        }
+        const purchase = row(updated);
+        await this.mail(purchase.email, `Your music: ${purchase.title}`, [
+            `Thank you. "${purchase.title}" by ${purchase.artistName} is yours: MP3s with the cover art and the lyrics, in one zip.`,
+            `Download it, now or any time: ${this.link(purchase.id, purchase.token)}`,
+            `Sign in to nixamp.com with ${purchase.email} and everything you have bought is under My music on ${this.options.site}/radio#music, to play or download again.`,
+        ]);
+        return purchase;
+    }
+    /** Every paid purchase of this account: made signed in, or to its email. */
+    async forAccount(account) {
+        await this.ready();
+        const rows = await this.options.db.query("SELECT * FROM music_purchases WHERE status = 'paid' AND (user_id = $1 OR lower(email) = lower($2)) ORDER BY paid_at DESC LIMIT 500", [account.id, account.email]);
+        return rows.rows.map(row);
+    }
+    grant(purchase) {
+        return makeGrant(this.options.secret, purchase, this.now() + GRANT_MS);
+    }
+    check(grant) {
+        return readGrant(this.options.secret, grant, this.now());
+    }
+    /** Where the zip of a purchase is made: on the server that holds the music. */
+    zipUrl(purchase) {
+        return `${purchase.server}/api/v1/label/zip?grant=${encodeURIComponent(this.grant(purchase))}`;
+    }
+    /** What anybody with the purchase's link (or the account) is shown. */
+    view(purchase) {
+        return {
+            id: purchase.id, kind: purchase.kind, title: purchase.title, artistName: purchase.artistName, server: purchase.server,
+            artist: purchase.artist, album: purchase.album, n: purchase.n, amountUsd: purchase.amountCents / 100, coin: purchase.coin,
+            status: purchase.status, createdAt: purchase.createdAt, paidAt: purchase.paidAt,
+            ...(purchase.status === "paid" ? { grant: this.grant(purchase), zip: this.zipUrl(purchase), link: this.link(purchase.id, purchase.token) } : {}),
+        };
+    }
+    async mail(to, subject, lines) {
+        if (!this.options.mail) {
+            this.options.log?.(`  store: no RESEND_API_KEY, so "${subject}" to ${to} was not sent`);
+            return;
+        }
+        try {
+            await (this.options.fetcher ?? fetch)("https://api.resend.com/emails", {
+                method: "POST",
+                signal: AbortSignal.timeout(15_000),
+                headers: { authorization: `Bearer ${this.options.mail.apiKey}`, "content-type": "application/json" },
+                body: JSON.stringify({ from: this.options.mail.from, to: [to], subject, text: `${lines.join("\n\n")}\n\nnixamp.com` }),
+            });
+        }
+        catch (error) {
+            this.options.log?.(`  store: mail to ${to} failed: ${error.message}`);
+        }
+    }
+}

package/dist/server.d.ts

@@ -25,6 +25,7 @@ import { LibraryIndex, type Probed } from "./library-index.ts";
 import { ListenerStore } from "./library-user.ts";
 import { Importer } from "./handoff.ts";
 import { AiLabel } from "./ai-label.ts";
+import { MusicStore } from "./music-store.ts";
 import { AiRadio } from "./ai-radio.ts";
 import { ListenerShares } from "./listener-shares.ts";
 import { Support, SupportSubscriptions } from "./support.ts";
@@ -830,6 +831,8 @@ export interface HandlerOptions {
     supportSubscriptions?: SupportSubscriptions;
     /** Signing secret of nixamp's CoinPay business, for /api/v1/webhooks/coinpay. */
     coinpayWebhookSecret?: string;
+    /** The AI label's songs for sale, nixamp.com only (music-store.ts). */
+    musicStore?: MusicStore;
     sharedTranslations?: SharedTranslations;
     /** Translation: texts in another language, by a model here. The same optional library. */
     translator?: Translator;

package/dist/server.js

@@ -62,7 +62,9 @@ import { Importer } from "./handoff.js";
 import { handleHandoffs } from "./handoff-routes.js";
 import { handleAiRoutes, isPublicSharePath } from "./ai-routes.js";
 import { AiLabel } from "./ai-label.js";
-import { handleLabelRoutes, isPublicLabelPath } from "./label-routes.js";
+import { buyLink, handleLabelRoutes, isPublicLabelPath } from "./label-routes.js";
+import { GrantVerifier, MusicStore } from "./music-store.js";
+import { handleStoreRoutes, isStorePath } from "./store-routes.js";
 import { AiRadio } from "./ai-radio.js";
 import { ListenerShares } from "./listener-shares.js";
 import { HolderStore, TagReader, factsFor } from "./track-facts.js";
@@ -1491,6 +1493,9 @@ export function createHandler(engine, options) {
         site: process.env["NIXAMP_SITE"] || "https://nixamp.com",
         ...(listenPassKey ? { secret: listenPassKey } : {}),
     });
+    // The music store lives on nixamp.com; a server holding the label's music asks it about grants.
+    const storeSite = (process.env["NIXAMP_SITE"] || "https://nixamp.com").replace(/\/+$/, "");
+    const storeGrants = new GrantVerifier({ site: storeSite });
     return async function handle(request, response) {
         const url = new URL(request.url ?? "/", "http://localhost");
         const path = url.pathname;
@@ -2057,6 +2062,19 @@ export function createHandler(engine, options) {
                 json(response, 400, { error: "invalid JSON" });
                 return;
             }
+            if (options.musicStore) {
+                try {
+                    if (await options.musicStore.owns(event.paymentId)) {
+                        json(response, 200, await options.musicStore.settle(event.paymentId));
+                        return;
+                    }
+                }
+                catch (error) {
+                    console.error(`nixamp: CoinPay webhook for ${event.paymentId} (music) could not settle: ${error instanceof Error ? error.message : String(error)}`);
+                    json(response, 500, { error: "could not settle; retry" });
+                    return;
+                }
+            }
             if (!options.translationPasses) {
                 json(response, 200, { settled: false, reason: "billing is off here" });
                 return;
@@ -2181,6 +2199,8 @@ export function createHandler(engine, options) {
             !isPublicSharePath(path) &&
             // The AI label's catalogue, its songs and their words.
             !(isPublicLabelPath(path) && Boolean(options.stations?.label)) &&
+            // The music store: its pages, checkout, receipts and grants (nixamp.com).
+            !(isStorePath(path) && Boolean(options.musicStore)) &&
             // What is on, as MCP, for anybody.
             path !== "/mcp/public" &&
             // Supporting a copyright holder is for anybody listening.
@@ -2528,9 +2548,24 @@ export function createHandler(engine, options) {
             });
             return;
         }
+        if (options.musicStore && options.support && isStorePath(path)) {
+            const support = options.support;
+            const accounts = options.accounts;
+            if (await handleStoreRoutes(request, response, path, url, {
+                store: options.musicStore,
+                coins: async () => (await support.coins()).coins,
+                account: async () => (accounts ? await accounts.whoIs(tokenFrom(request.headers)) : null),
+                json,
+                readBody,
+            }))
+                return;
+        }
         if (options.stations?.label && (isPublicLabelPath(path) || path === "/api/v1/stations/label" || path.startsWith("/api/v1/stations/label/"))) {
             const control = isPublicLabelPath(path) ? { allowed: false } : await controlOf();
-            if (await handleLabelRoutes(request, response, path, { label: options.stations.label, canControl: control.allowed, json, readBody }))
+            if (await handleLabelRoutes(request, response, path, {
+                label: options.stations.label, canControl: control.allowed, json, readBody,
+                grants: storeGrants, site: storeSite, publicBase: options.stations.publicBase?.() ?? "",
+            }))
                 return;
         }
         if (options.stations && (isPublicSharePath(path) || path.startsWith("/api/v1/stations/ai") || path.startsWith("/api/v1/stations/shares") || path.startsWith("/api/v1/stations/holders"))) {
@@ -6880,16 +6915,27 @@ export async function serve(argv, version = "0.1.0") {
         }
         const art = picture ? `/api/v1/stations/${station.id}/art?t=${encodeURIComponent(station.listenToken)}&f=${sha("sha1").update(file + stamp).digest("hex").slice(0, 12)}` : "";
         const words = await lyricsFinder.find(file).catch(() => null);
-        return factsFor({
-            art,
-            ...(words ? { lyrics: `/api/v1/stations/${station.id}/lyrics?t=${encodeURIComponent(station.listenToken)}&f=${sha("sha1").update(file + stamp).digest("hex").slice(0, 12)}` } : {}),
-            station, file,
-            tags: await tagReader.read(file),
-            known: trackFor(engine, file),
-            holders: holderStore.list(),
-            share: share ? { basis: share.rights.basis, note: share.rights.note, by: share.by } : null,
-            aiTrack: composed ? { made: composed.made } : null,
-        });
+        // A label song is for sale on nixamp.com: the song, its album, everything by the artist.
+        const song = aiLabel.songAt(file);
+        const here = stations.publicBase?.() ?? "";
+        const shop = (process.env["NIXAMP_SITE"] || "https://nixamp.com").replace(/\/+$/, "");
+        const store = song && /^https:\/\//.test(here) ? {
+            song: buyLink(shop, here, "song", song.artist, song.album, song.n),
+            album: buyLink(shop, here, "album", song.artist, song.album),
+            artist: buyLink(shop, here, "artist", song.artist),
+            artistName: song.artistName,
+            albumTitle: song.albumTitle,
+        } : null;
+        return { ...factsFor({
+                art,
+                ...(words ? { lyrics: `/api/v1/stations/${station.id}/lyrics?t=${encodeURIComponent(station.listenToken)}&f=${sha("sha1").update(file + stamp).digest("hex").slice(0, 12)}` } : {}),
+                station, file,
+                tags: await tagReader.read(file),
+                known: trackFor(engine, file),
+                holders: holderStore.list(),
+                share: share ? { basis: share.rights.basis, note: share.rights.note, by: share.by } : null,
+                aiTrack: composed ? { made: composed.made } : null,
+            }), store };
     };
     // Channels as HLS, on demand, for Safari on a phone: one ffmpeg copying a
     // channel's fragments into short files while somebody is asking for them.
@@ -7029,6 +7075,20 @@ export async function serve(argv, version = "0.1.0") {
         log: (line) => console.log(line),
     }) : undefined;
     supportMonthly?.startSchedule();
+    // The AI label's songs for sale: purchases kept here, the music zipped by the server that holds it.
+    const jwtSecret = process.env["NIXAMP_JWT_SECRET"] ?? "";
+    const musicStore = supportPayments && supportPayments.enabled && pool && jwtSecret ? new MusicStore({
+        db: pool,
+        support: supportPayments,
+        mail: process.env["RESEND_API_KEY"] ? { apiKey: process.env["RESEND_API_KEY"], from: process.env["NIXAMP_MAIL_FROM"] ?? "nixamp <notifications@nixamp.com>" } : null,
+        site: nixampSite,
+        secret: sha("sha256").update(`music-grant:${jwtSecret}`).digest("hex"),
+        servers: () => {
+            const listed = directory ? directory.list().map((one) => peerBase(one.url)).filter(Boolean) : [];
+            return [...new Set([...guidePeers(), ...listed])];
+        },
+        log: (line) => console.log(line),
+    }) : undefined;
     if (translationPasses)
         void translationPasses.access().catch(() => console.error("nixamp: translation checkout could not warm; it will retry on demand"));
     const liveVoice = accounts && process.env["NIXAMP_DUBBING"] !== "off" ? new LiveVoice({
@@ -7579,6 +7639,7 @@ export async function serve(argv, version = "0.1.0") {
         ...(translationPasses ? { translationPasses } : {}),
         ...(supportPayments ? { support: supportPayments } : {}),
         ...(supportMonthly ? { supportSubscriptions: supportMonthly } : {}),
+        ...(musicStore ? { musicStore } : {}),
         ...(process.env["COINPAY_WEBHOOK_SECRET"] ? { coinpayWebhookSecret: process.env["COINPAY_WEBHOOK_SECRET"] } : {}),
         ...(sharedTranslations ? { sharedTranslations } : {}),
         ...(translator ? { translator } : {}),

package/dist/store-routes.d.ts

@@ -0,0 +1,16 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type MusicStore } from "./music-store.ts";
+export declare function isStorePath(path: string): boolean;
+export interface StoreRoutesContext {
+    store: MusicStore;
+    coins: () => Promise<string[]>;
+    /** The signed-in account, or null. */
+    account: () => Promise<{
+        id: string;
+        email: string;
+    } | null>;
+    json: (response: ServerResponse, status: number, body: unknown) => void;
+    readBody: (request: IncomingMessage) => Promise<string>;
+}
+export declare const STORE_CSP: string;
+export declare function handleStoreRoutes(request: IncomingMessage, response: ServerResponse, path: string, url: URL, ctx: StoreRoutesContext): Promise<boolean>;