nixamp 0.27.0 → 0.27.2

package/src/server.ts

@@ -37,6 +37,8 @@ import {
 } from "./channels.ts";
 import { RtmpListeners } from "./rtmp-in.ts";
 import { Accounts, clearedCookie, sessionCookie, tokenFrom } from "./accounts.ts";
+import { RESET_INVALID, RESET_MESSAGE, resendPasswordReset, type ResetMail } from "./password-reset.ts";
+import { passwordResetPage } from "./password-reset-page.ts";
 import { anonymousHandle, Handles } from "./handles.ts";
 import { OpenDirs } from "./opendirs.ts";
 import { Servers } from "./servers.ts";
@@ -1717,6 +1719,8 @@ export interface HandlerOptions {
   publishUrls?: () => { id: string; url: string }[];
   /** Accounts, on the instance that keeps them. Only nixamp.com passes this. */
   accounts?: Accounts;
+  /** Transactional password recovery mail, separate from follow notifications. */
+  resetMail?: ResetMail;
   /** Providers to sign in with, and the terminals waiting to be connected. */
   signIn?: SignIn;
   /** The servers each account runs, on the instance that keeps accounts. */
@@ -1852,6 +1856,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
     const webSite = options.webSites?.get((request.headers.host ?? "").toLowerCase());
     const web = webSite?.web ?? options.web;
     const eventSite = webSite?.site ?? options.invites?.site;
+    const accountSite = eventSite ?? options.site ?? "https://nixamp.com";
     const key = options.key ?? null;
     const behindProxy = options.behindProxy ?? false;
     const listenKey = options.listenKey ?? null;
@@ -2460,6 +2465,20 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       return;
     }
 
+    if (path === "/reset-password" && options.accounts?.passwordResets) {
+      if (request.method !== "GET" && request.method !== "HEAD") {
+        json(response, 405, { error: "GET only" }); return;
+      }
+      const nonce = randomBytes(18).toString("base64");
+      response.writeHead(200, {
+        "content-type": "text/html; charset=utf-8", "cache-control": "no-store",
+        "referrer-policy": "no-referrer", "x-robots-tag": "noindex, nofollow",
+        "content-security-policy": `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'unsafe-inline'; connect-src 'self'; base-uri 'none'; frame-ancestors 'none'; form-action 'self'`,
+      });
+      response.end(request.method === "HEAD" ? undefined : passwordResetPage(accountSite, nonce));
+      return;
+    }
+
     // --- accounts ---------------------------------------------------------
     //
     // Before the share-key check, because signing in is how somebody without a
@@ -2469,6 +2488,46 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       const accounts = options.accounts;
       const secure = options.secureCookies ?? false;
 
+      if (path === "/api/v1/auth/password-reset/request" || path === "/api/v1/auth/password-reset/confirm") {
+        if (request.method !== "POST") { json(response, 405, { error: "POST only" }); return; }
+        const confirming = path.endsWith("/confirm");
+        if (!accounts.passwordResets || (!confirming && !options.resetMail)) {
+          json(response, 503, { error: "Password reset email is temporarily unavailable. Please try again later." }); return;
+        }
+        const who = callerOf(request.headers, request.socket.remoteAddress, behindProxy);
+        const limit = guard.check(`password-reset:${confirming ? "confirm" : "request"}:${who}`, { allowed: confirming ? 15 : 10, windowMs: 15 * 60_000 });
+        if (!limit.ok) {
+          response.setHeader("retry-after", String(limit.retryAfter));
+          json(response, 429, { error: "Too many attempts. Please try again in 15 minutes." }); return;
+        }
+        try {
+          const input: unknown = JSON.parse(await readBody(request, 4096));
+          if (!input || typeof input !== "object" || Array.isArray(input)) {
+            json(response, 400, { error: "Provide a JSON object." }); return;
+          }
+          const body = input as Record<string, unknown>;
+          if (confirming) {
+            const error = await accounts.passwordResets.confirm(body["token"], body["password"]);
+            if (error) { json(response, error === RESET_INVALID ? 400 : 422, { error }); return; }
+            response.setHeader("set-cookie", clearedCookie());
+            json(response, 200, { message: "Your password has been changed. Sign in with your new password." });
+          } else {
+            const email = typeof body["email"] === "string" ? body["email"].trim().toLowerCase() : "";
+            if (email.length > 320 || !/^[^@\s]+@[^@\s.]+\.[^@\s]+$/.test(email)) {
+              json(response, 422, { error: "Enter a valid email address." }); return;
+            }
+            // Count every address, including nonexistent ones, identically.
+            const address = guard.check(`password-reset:email:${email}`, { allowed: 3, windowMs: 15 * 60_000 });
+            if (address.ok) await accounts.passwordResets.request(email, accountSite, options.resetMail!);
+            json(response, 200, { message: RESET_MESSAGE });
+          }
+        } catch (error) {
+          const malformed = error instanceof SyntaxError || (error as Error).message === "body too large";
+          json(response, malformed ? 400 : 503, { error: malformed ? "Provide a valid JSON request." : "Password reset is temporarily unavailable. Please try again." });
+        }
+        return;
+      }
+
       if (path === "/api/v1/auth/me") {
         const who = await accounts.whoIs(tokenFrom(request.headers));
         if (who === null) {
@@ -2909,8 +2968,16 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         if (path === "/api/v1/translation-passes" && request.method === "GET") {
           json(response, 200, await service.access(who?.id)); return;
         }
-        if (!who) throw new SpeechError("Sign in to buy translated audio.", 401);
+        if (!who) throw new SpeechError("Sign in to use translated audio.", 401);
         if (!guard.check(`translation-pass-account:${who.id}`, { allowed: 30, windowMs: 60_000 }).ok) throw new SpeechError("Too many purchase requests.", 429);
+        if (path === "/api/v1/translation-passes/session" && request.method === "POST") {
+          if (!request.headers["content-type"]?.startsWith("application/json")) throw new SpeechError("Send a panel session as JSON.", 415);
+          let body: { resource?: unknown };
+          try { body = JSON.parse(await readBody(request, 1024)); } catch { throw new SpeechError("Choose a panel session.", 400); }
+          if (typeof body?.resource !== "string") throw new SpeechError("Choose a panel session.", 400);
+          await service.begin(who.id, body.resource);
+          json(response, 200, await service.access(who.id)); return;
+        }
         if (path === "/api/v1/translation-passes/checkout" && request.method === "POST") {
           if (!request.headers["content-type"]?.startsWith("application/json")) throw new SpeechError("Send a purchase as JSON.", 415);
           if (!guard.check(`translation-checkout-ip:${caller}`, { allowed: 10, windowMs: 3600_000 }).ok) throw new SpeechError("Too many new checkouts. Resume your pending purchase.", 429);
@@ -2959,7 +3026,9 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           } else if (path.endsWith("/speakers") && request.method === "POST") {
             if (!request.headers["content-type"]?.startsWith("audio/wav")) { json(response, 415, { error: "send a mono 16 kHz WAV" }); return; }
             const bytes = await readBytes(request, 484_000);
-            json(response, 200, await service.hear(bytes, who.id, controller.signal));
+            const resource = request.headers["x-nixamp-translation-session"];
+            if (resource !== undefined && (typeof resource !== "string" || !/^[\w-]{1,80}$/.test(resource))) throw new SpeechError("Choose a panel session.", 400);
+            json(response, 200, await service.hear(bytes, who.id, controller.signal, undefined, resource));
           } else if (path.endsWith("/grant") && request.method === "POST") {
             if (!request.headers["content-type"]?.startsWith("application/json")) { json(response, 415, { error: "send JSON" }); return; }
             let body: { channel?: unknown };
@@ -6595,6 +6664,12 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     ...(translations ? { translations } : {}),
     ...(records ? { records } : {}),
     site: nixampSite,
+    ...(accounts && process.env["RESEND_API_KEY"] ? {
+      resetMail: resendPasswordReset({
+        apiKey: process.env["RESEND_API_KEY"],
+        from: process.env["NIXAMP_MAIL_FROM"] ?? "nixamp <notifications@nixamp.com>",
+      }),
+    } : {}),
     // Other people's OpenProfiles, read for the voice a line is spoken in,
     // and the voices to speak in: ElevenLabs when the Telnyx account holds
     // the key for it (an integration secret named "elevenlabs"), Kokoro

package/src/shared-translation.ts

@@ -71,18 +71,24 @@ export class SharedTranslations {
     if (!this.options.voice.available()) throw new SpeechError("Translated audio is unavailable.", 503);
     const source = sharedSource(raw);
     if (!LIVE_VOICE_LANGUAGES.has(language)) throw new SpeechError("Choose a supported audio language.", 400);
-    await this.options.billing?.require(by);
-    const connections = [...this.feeds.values()].reduce((total, feed) => total + [...feed.members].filter(member => member.by === by).length, 0);
-    if (connections >= 2) throw new SpeechError("Translated audio is already open in two players for this account.", 429);
     const id = `dub-${createHash("sha256").update(`${source}|${language}`).digest("hex").slice(0, 40)}`;
+    const capacity = (): void => {
+      const connections = [...this.feeds.values()].reduce((total, feed) => total + [...feed.members].filter(member => member.by === by).length, 0);
+      if (connections >= 2) throw new SpeechError("Translated audio is already open in two players for this account.", 429);
+      const feed = this.feeds.get(id);
+      if (!feed && this.feeds.size >= 4) throw new SpeechError("Live translation is busy. Try again shortly.", 429);
+      if (feed && feed.members.size >= 1000) throw new SpeechError("This translated stream is full. Try again shortly.", 429);
+    };
+    capacity();
+    if (this.options.billing?.begin) await this.options.billing.begin(by, id);
+    else await this.options.billing?.require(by, id);
+    capacity(); // Other joins can finish during the account/database check.
     let feed = this.feeds.get(id);
     if (!feed) {
-      if (this.feeds.size >= 4) throw new SpeechError("Live translation is busy. Try again shortly.", 429);
       feed = this.make(id, source, language); this.feeds.set(id, feed);
       const current = feed;
       current.heartbeat = setInterval(() => void this.checkMembers(current), 10_000); current.heartbeat.unref?.();
     }
-    if (feed.members.size >= 1000) throw new SpeechError("This translated stream is full. Try again shortly.", 429);
     const member = { by, send, close }; feed.members.add(member);
     this.broadcast(feed, { type: "status", listeners: feed.members.size });
     if (feed.members.size === 1 && !feed.input) void this.start(feed);
@@ -99,14 +105,14 @@ export class SharedTranslations {
   }
   private async checkMembers(feed: Feed): Promise<void> {
     const accounts = [...new Set([...feed.members].map(member => member.by))];
-    let funded = new Set(accounts), message = "Your translation balance is used up or expired. Buy another pass to continue.";
+    let funded = new Set(accounts), message = "This free session ended and audio credit is used up. Start a remaining free session or buy a pass.";
     try {
-      if (this.options.billing?.eligible) funded = new Set(await this.options.billing.eligible(accounts));
+      if (this.options.billing?.eligible) funded = new Set(await this.options.billing.eligible(accounts, feed.id));
       else if (this.options.billing) {
-        const results = await Promise.allSettled(accounts.map(by => this.options.billing!.require(by)));
+        const results = await Promise.allSettled(accounts.map(by => this.options.billing!.require(by, feed.id)));
         funded = new Set(accounts.filter((_by, index) => results[index]?.status === "fulfilled"));
       }
-    } catch { funded.clear(); message = "Your translation balance could not be checked. Try again shortly."; }
+    } catch { funded.clear(); message = "Your translation access could not be checked. Try again shortly."; }
     for (const member of [...feed.members]) if (accounts.includes(member.by) && !funded.has(member.by)) {
       try { member.send({ type: "error", error: message }); } catch { /* disconnected */ }
       finally { this.leave(feed, member); member.close(); }
@@ -123,8 +129,8 @@ export class SharedTranslations {
   }
   private make(id: string, source: URL, language: string): Feed {
     const feed = { id, source, language, members: new Set<Member>(), controller: new AbortController(), reservations: new Map<string, string[]>(), queue: [], speaking: false, previous: Buffer.alloc(0), pending: Buffer.alloc(0), until: Date.now() } as unknown as Feed;
-    // Every active account pays the same published access rate. API work is
-    // done once; additional listeners do not trigger recognition or synthesis.
+    // Each account uses free access first, then the same published credit rate.
+    // Additional listeners do not trigger recognition or synthesis.
     feed.meter = {
       require: async () => { if (!feed.members.size) throw new SpeechError("No listeners.", 410); },
       reserve: async (_by: string, kind: TranslationUsage, units: number) => {
@@ -133,9 +139,9 @@ export class SharedTranslations {
         const accepted = new Set<string>();
         const billing = this.options.billing;
         if (billing?.reserveMany) {
-          for (const charged of await billing.reserveMany(accounts, kind, units)) { ids.push(charged.id); accepted.add(charged.by); }
+          for (const charged of await billing.reserveMany(accounts, kind, units, feed.id)) { ids.push(charged.id); accepted.add(charged.by); }
         } else {
-          const results = await Promise.allSettled(accounts.map(async account => ({ by: account, id: await billing?.reserve(account, kind, units) })));
+          const results = await Promise.allSettled(accounts.map(async account => ({ by: account, id: await billing?.reserve(account, kind, units, feed.id) })));
           let failure: unknown;
           for (const result of results) {
             if (result.status === "fulfilled") { accepted.add(result.value.by); if (result.value.id) ids.push(result.value.id); }
@@ -144,7 +150,7 @@ export class SharedTranslations {
           if (failure) { await Promise.all(ids.map(id => billing!.refund(id))); throw failure; }
         }
         for (const member of [...feed.members]) if (accounts.includes(member.by) && !accepted.has(member.by)) {
-          try { member.send({ type: "error", error: "Your translation balance is used up or expired. Buy another pass to continue." }); }
+          try { member.send({ type: "error", error: "This free session ended and audio credit is used up. Start a remaining free session or buy a pass." }); }
           catch { /* disconnected */ } finally { this.leave(feed, member); member.close(); }
         }
         if (!feed.members.size) { await Promise.all(ids.map(id => this.options.billing!.refund(id))); throw new SpeechError("No funded listeners.", 402); }

package/src/tokens.ts

@@ -152,6 +152,9 @@ export class Tokens {
     await this.ready;
   }
 
+  /** Recovery revokes this table in the same transaction as the password update. */
+  async initialize(): Promise<void> { await this.ensure(); }
+
   async issue(options: IssueOptions): Promise<IssuedToken> {
     await this.ensure();
     const { id, secret, token } = mintToken();

package/src/translation-passes.ts

@@ -3,6 +3,7 @@
 import { randomUUID } from "node:crypto";
 import type { Queryable } from "./follows.ts";
 import { SpeechError } from "./speech.ts";
+import { UpgradeAllowances, type UpgradeAllowance } from "./upgrade-allowance.ts";
 
 export const TRANSLATION_MULTIPLIER = 5;
 export const TRANSLATION_PLANS = [
@@ -13,10 +14,11 @@ export const TRANSLATION_PLANS = [
 export type TranslationPlan = typeof TRANSLATION_PLANS[number];
 export type TranslationUsage = "transcription" | "voice";
 export interface TranslationMeter {
-  require(by: string): Promise<void>;
-  eligible?(accounts: string[]): Promise<string[]>;
-  reserve(by: string, kind: TranslationUsage, units: number): Promise<string>;
-  reserveMany?(accounts: string[], kind: TranslationUsage, units: number): Promise<{ by: string; id: string }[]>;
+  begin?(by: string, resource: string): Promise<void>;
+  require(by: string, resource?: string): Promise<void>;
+  eligible?(accounts: string[], resource?: string): Promise<string[]>;
+  reserve(by: string, kind: TranslationUsage, units: number, resource?: string): Promise<string>;
+  reserveMany?(accounts: string[], kind: TranslationUsage, units: number, resource?: string): Promise<{ by: string; id: string }[]>;
   commitMany?(ids: string[]): Promise<void>;
   refundMany?(ids: string[]): Promise<void>;
   commit(id: string): Promise<void>;
@@ -26,6 +28,7 @@ export interface TranslationAccess {
   required: boolean; available: boolean; balanceMicros: number; expires: string | null;
   plans: readonly TranslationPlan[]; coins: string[]; orders: { id: string; url: string; plan: string }[];
   rates: { transcriptionHour: number; voiceThousand: number; multiplier: number };
+  free: UpgradeAllowance;
 }
 const COINS = ["USDC_POL", "USDC_SOL", "SOL", "POL", "BTC", "ETH", "USDC_ETH", "BCH", "DOGE"];
 const ID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
@@ -57,11 +60,14 @@ export class TranslationPasses implements TranslationMeter {
   private merchantUntil = 0;
   private readonly fetcher: typeof fetch;
   private readonly now: () => number;
+  readonly free: UpgradeAllowances;
   constructor(private readonly options: { db: Queryable; key: string; site: string; fetcher?: typeof fetch; now?: () => number }) {
     this.fetcher = options.fetcher ?? fetch; this.now = options.now ?? Date.now;
+    this.free = new UpgradeAllowances(options.db, this.now);
   }
   private async ensure(): Promise<void> {
     this.schema ??= (async () => {
+      await this.free.ensure();
       await this.options.db.query(`CREATE TABLE IF NOT EXISTS translation_wallets (
         by_account TEXT PRIMARY KEY, balance_micros BIGINT NOT NULL CHECK (balance_micros >= 0), expires_at TIMESTAMPTZ NOT NULL)`);
       await this.options.db.query(`CREATE TABLE IF NOT EXISTS translation_orders (
@@ -105,41 +111,45 @@ export class TranslationPasses implements TranslationMeter {
     const row = by ? (await this.options.db.query("SELECT balance_micros, expires_at FROM translation_wallets WHERE by_account = $1 AND expires_at > $2", [by, new Date(this.now())])).rows[0] : null;
     const orders = by ? (await this.options.db.query("SELECT id, payment_id, plan FROM translation_orders WHERE by_account = $1 AND status = 'pending' AND payment_id IS NOT NULL ORDER BY created_at DESC LIMIT 5", [by])).rows.map(order => ({ id: String(order["id"]), plan: String(order["plan"]), url: `https://coinpayportal.com/pay/${order["payment_id"]}` })) : [];
     return { required: true, available: config.coins.length > 0, balanceMicros: Number(row?.["balance_micros"] ?? 0),
-      expires: row ? new Date(String(row["expires_at"])).toISOString() : null, plans: TRANSLATION_PLANS, coins: config.coins, orders,
+      expires: row ? new Date(String(row["expires_at"])).toISOString() : null, plans: TRANSLATION_PLANS, coins: config.coins, orders, free: await this.free.access(by),
       rates: { transcriptionHour: 0.22, voiceThousand: 0.05, multiplier: TRANSLATION_MULTIPLIER } };
   }
-  async require(by: string): Promise<void> {
+  async begin(by: string, resource: string): Promise<void> {
     await this.ensure();
+    if (await this.free.begin(by, "translation", resource)) return;
+    await this.require(by, resource);
+  }
+  async require(by: string, resource = ""): Promise<void> {
+    await this.ensure();
+    if ((await this.free.active([by], "translation", resource, true)).length) return;
     const found = await this.options.db.query("SELECT by_account FROM translation_wallets WHERE by_account = $1 AND expires_at > $2 AND balance_micros > 0", [by, new Date(this.now())]);
-    if (!found.rows.length) throw new SpeechError("Buy a translation pass to enable translated audio.", 402);
+    if (!found.rows.length) throw new SpeechError("Buy a pass or start a remaining free session: this session has no free time or audio credit.", 402);
   }
-  async eligible(accounts: string[]): Promise<string[]> {
+  async eligible(accounts: string[], resource = ""): Promise<string[]> {
     await this.ensure();
     const result = await this.options.db.query("SELECT by_account FROM translation_wallets WHERE by_account = ANY($1::text[]) AND expires_at > $2 AND balance_micros > 0", [accounts, new Date(this.now())]);
-    return result.rows.map(row => String(row["by_account"]));
+    return [...new Set([...result.rows.map(row => String(row["by_account"])), ...await this.free.active(accounts, "translation", resource, true)])];
   }
-  async reserve(by: string, kind: TranslationUsage, units: number): Promise<string> {
-    await this.ensure();
-    const { cost, charge } = translationCost(kind, units), id = randomUUID();
-    const result = await this.options.db.query(`WITH debit AS (
-      UPDATE translation_wallets SET balance_micros = balance_micros - $2
-      WHERE by_account = $1 AND expires_at > $3 AND balance_micros >= $2 RETURNING by_account)
-      INSERT INTO translation_usage (id, by_account, kind, units, cost_micros, charge_micros, created_at)
-      SELECT $4, by_account, $5, $6, $7, $2, $3 FROM debit RETURNING id`,
-    [by, charge, new Date(this.now()), id, kind, units, cost]);
-    if (!result.rows.length) throw new SpeechError("Your translation balance is used up or expired. Buy another pass to continue.", 402);
-    return id;
+  async reserve(by: string, kind: TranslationUsage, units: number, resource = ""): Promise<string> {
+    const result = await this.reserveMany([by], kind, units, resource);
+    if (!result.length) throw new SpeechError("This free session ended and audio credit is used up. Start a remaining free session or buy a pass.", 402);
+    return result[0]!.id;
   }
   /** Batch a shared stream's access charges in one database round trip. */
-  async reserveMany(accounts: string[], kind: TranslationUsage, units: number): Promise<{ by: string; id: string }[]> {
+  async reserveMany(accounts: string[], kind: TranslationUsage, units: number, resource = ""): Promise<{ by: string; id: string }[]> {
     await this.ensure();
     const { cost, charge } = translationCost(kind, units);
-    const result = await this.options.db.query(`WITH debit AS (
+    const now = this.now(), key = resource ? this.free.key("translation", resource) : "";
+    const result = await this.options.db.query(`WITH free AS (
+      SELECT DISTINCT by_account FROM upgrade_daily_uses WHERE by_account = ANY($1::text[])
+        AND (sessions->>$7)::bigint > $8), debit AS (
       UPDATE translation_wallets SET balance_micros = balance_micros - $2
-      WHERE by_account = ANY($1::text[]) AND expires_at > $3 AND balance_micros >= $2 RETURNING by_account)
+      WHERE by_account = ANY($1::text[]) AND expires_at > $3 AND balance_micros >= $2
+        AND by_account NOT IN (SELECT by_account FROM free) RETURNING by_account), admitted AS (
+      SELECT by_account, 0::bigint AS charge FROM free UNION ALL SELECT by_account, $2::bigint FROM debit)
       INSERT INTO translation_usage (id, by_account, kind, units, cost_micros, charge_micros, created_at)
-      SELECT gen_random_uuid()::text, by_account, $4, $5, $6, $2, $3 FROM debit RETURNING id, by_account`,
-    [[...new Set(accounts)], charge, new Date(this.now()), kind, units, cost]);
+      SELECT gen_random_uuid()::text, by_account, $4, $5, $6, charge, $3 FROM admitted RETURNING id, by_account`,
+    [[...new Set(accounts)], charge, new Date(now), kind, units, cost, key, now]);
     return result.rows.map(row => ({ by: String(row["by_account"]), id: String(row["id"]) }));
   }
   async commit(id: string): Promise<void> {

package/src/types/auth-system.d.ts

@@ -8,6 +8,16 @@
  * than smoothed over.
  */
 declare module "@profullstack/auth-system" {
+  export function createPasswordUtils(options?: {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumbers?: boolean;
+    requireSpecialChars?: boolean;
+  }): {
+    hashPassword(password: string): Promise<string>;
+    validatePassword(password: string): { valid: boolean; message: string };
+  };
   export interface AuthUser {
     id: string;
     email: string;

package/src/upgrade-allowance.ts

@@ -0,0 +1,69 @@
+/** Daily free access shared by Nixamp's paid panels and upgrades.
+ * Claim only on explicit use, never from balance polling or provider chunks. */
+import { createHash } from "node:crypto";
+import type { Queryable } from "./follows.ts";
+import { SpeechError } from "./speech.ts";
+
+export const FREE_UPGRADE_SESSIONS = 5;
+export const FREE_UPGRADE_RECONNECT_SECONDS = 90;
+const DAY = 86_400_000;
+export interface UpgradeAllowance {
+  limit: number; remaining: number; reconnectSeconds: number; resets: string;
+  activeUntil: string | null;
+}
+
+export class UpgradeAllowances {
+  private schema: Promise<void> | null = null;
+  constructor(private readonly db: Queryable, private readonly now: () => number = Date.now) {}
+  async ensure(): Promise<void> {
+    this.schema ??= this.db.query(`CREATE TABLE IF NOT EXISTS upgrade_daily_uses (
+      by_account TEXT NOT NULL, day BIGINT NOT NULL,
+      uses INTEGER NOT NULL CHECK (uses BETWEEN 1 AND 5),
+      sessions JSONB NOT NULL, PRIMARY KEY (by_account, day))`).then(() => undefined)
+      .catch(error => { this.schema = null; throw error; });
+    await this.schema;
+  }
+  key(product: string, resource: string): string {
+    if (!/^[a-z][a-z0-9-]{0,63}$/.test(product) || !/^[\w-]{1,80}$/.test(resource)) throw new SpeechError("Choose a panel session.", 400);
+    return createHash("sha256").update(`${product}|${resource}`).digest("hex");
+  }
+  async access(by?: string): Promise<UpgradeAllowance> {
+    await this.ensure();
+    const now = this.now(), day = Math.floor(now / DAY);
+    const rows = by ? (await this.db.query("SELECT uses, day, sessions FROM upgrade_daily_uses WHERE by_account = $1", [by])).rows : [];
+    const today = rows.find(row => Number(row["day"]) === day);
+    const active = Math.max(0, ...rows.flatMap(row => Object.values(row["sessions"] as Record<string, number>).map(Number)));
+    return { limit: FREE_UPGRADE_SESSIONS, remaining: Math.max(0, FREE_UPGRADE_SESSIONS - Number(today?.["uses"] ?? 0)),
+      reconnectSeconds: FREE_UPGRADE_RECONNECT_SECONDS, resets: new Date((day + 1) * DAY).toISOString(), activeUntil: active > now ? new Date(active).toISOString() : null };
+  }
+
+  /** One atomic row serializes concurrent starts across tabs, products and replicas.
+   * Active use renews a short lease. Reconnecting reuses it; idle leases expire. */
+  async begin(by: string, product: string, resource: string): Promise<boolean> {
+    if (!by) throw new SpeechError("Sign in to use your free sessions.", 401);
+    const key = this.key(product, resource);
+    if ((await this.active([by], product, resource, true)).length) return true;
+    await this.ensure();
+    const now = this.now(), day = Math.floor(now / DAY), until = now + FREE_UPGRADE_RECONNECT_SECONDS * 1000;
+    const result = await this.db.query(`INSERT INTO upgrade_daily_uses AS daily (by_account, day, uses, sessions)
+      VALUES ($1, $2, 1, jsonb_build_object($3::text, $5::bigint))
+      ON CONFLICT (by_account, day) DO UPDATE SET
+        uses = CASE WHEN COALESCE((daily.sessions->>$3)::bigint, 0) > $4 THEN daily.uses ELSE daily.uses + 1 END,
+        sessions = daily.sessions || EXCLUDED.sessions
+      WHERE COALESCE((daily.sessions->>$3)::bigint, 0) > $4 OR daily.uses < $6
+      RETURNING uses`, [by, day, key, now, until, FREE_UPGRADE_SESSIONS]);
+    return result.rows.length > 0;
+  }
+  async active(accounts: string[], product: string, resource: string, renew = false): Promise<string[]> {
+    if (!resource || !accounts.length) return [];
+    const key = this.key(product, resource);
+    await this.ensure();
+    const now = this.now();
+    const result = renew
+      ? await this.db.query(`UPDATE upgrade_daily_uses SET sessions = sessions || jsonb_build_object($2::text, $4::bigint)
+          WHERE by_account = ANY($1::text[]) AND (sessions->>$2)::bigint > $3 RETURNING by_account`, [accounts, key, now, now + FREE_UPGRADE_RECONNECT_SECONDS * 1000])
+      : await this.db.query(`SELECT by_account FROM upgrade_daily_uses
+          WHERE by_account = ANY($1::text[]) AND (sessions->>$2)::bigint > $3`, [accounts, key, now]);
+    return result.rows.map(row => String(row["by_account"]));
+  }
+}

package/web/dist/assets/{hls-3VKVEQE3-P3sj2d3a.js → hls-3VKVEQE3-CAL4qBEq.js}

@@ -1 +1 @@
-import{t as e}from"./index-Do9VYiU8.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};
+import{t as e}from"./index-CLeEWlms.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};