{
+ const config = loadOptionalSMTPConfig(environment);
+ if (!config) throw new Error("SMTP delivery is not configured");
+ const transport = nodemailer.createTransport(emailTransportOptions(config));
+ const id = messageId(message.idempotencyKey, config.host);
+ try {
+ await transport.sendMail({
+ from: config.from,
+ to: config.to,
+ subject: message.subject.slice(0, 200),
+ text: message.text,
+ html: `${htmlEscape(message.text)}`,
+ messageId: id,
+ headers: { "X-Frontier-Idempotency-Key": message.idempotencyKey },
+ });
+ return { messageId: id };
+ } finally {
+ transport.close();
+ }
+}
diff --git a/lib/env-migration.ts b/lib/env-migration.ts
new file mode 100644
index 0000000..4df3b93
--- /dev/null
+++ b/lib/env-migration.ts
@@ -0,0 +1,180 @@
+import {
+ chmodSync,
+ renameSync,
+ rmSync,
+ writeFileSync,
+} from "node:fs";
+import { randomUUID } from "node:crypto";
+import { basename, dirname, join } from "node:path";
+import { parseEnv } from "node:util";
+import { ConfigError } from "./runtime-config.ts";
+import {
+ assertFileUnchanged,
+ readSecureFile,
+ repairFileMode,
+ snapshotFileMode,
+ writeSecureFileExclusive,
+ type SecureFileSnapshot,
+} from "./secure-file.ts";
+
+interface EnvEntry {
+ decoded: string;
+ raw: string;
+}
+
+export interface EnvMigrationOptions {
+ clock?: () => Date;
+}
+
+export interface EnvMigrationResult {
+ backupPath?: string;
+ changed: boolean;
+ migratedKeys: readonly string[];
+ permissionsFixed: boolean;
+}
+
+function entriesFromText(text: string): Map {
+ return new Map(
+ Object.entries(parseEnvText(text)).map(([key, decoded]) => [
+ key,
+ { decoded, raw: JSON.stringify(decoded) },
+ ]),
+ );
+}
+
+export function parseEnvText(text: string): Record {
+ try {
+ return Object.fromEntries(
+ Object.entries(parseEnv(text)).filter((entry): entry is [string, string] => entry[1] !== undefined),
+ );
+ } catch {
+ throw new ConfigError([{ code: "INVALID", key: ".env syntax" }]);
+ }
+}
+
+function deepSeekLegacyAllowed(entries: ReadonlyMap): boolean {
+ if (entries.get("LLM_PROVIDER")?.decoded.toLowerCase() !== "deepseek") return false;
+ const rawURL = entries.get("LLM_BASE_URL")?.decoded;
+ if (!rawURL) return false;
+ try {
+ const url = new URL(rawURL);
+ return url.protocol === "https:" &&
+ (url.hostname === "deepseek.com" || url.hostname.endsWith(".deepseek.com"));
+ } catch {
+ return false;
+ }
+}
+
+function backupName(path: string, instant: Date): string {
+ const timestamp = instant
+ .toISOString()
+ .replace(/\.\d{3}Z$/, "Z")
+ .replaceAll("-", "")
+ .replaceAll(":", "");
+ return join(dirname(path), `${basename(path)}.migrated.${timestamp}.bak`);
+}
+
+function createBackup(path: string, content: string, instant: Date): string {
+ const base = backupName(path, instant).replace(/\.bak$/, "");
+ for (let suffix = 0; suffix < 10_000; suffix += 1) {
+ const candidate = `${base}${suffix ? `.${suffix}` : ""}.bak`;
+ try {
+ writeSecureFileExclusive(candidate, content);
+ return candidate;
+ } catch (error) {
+ if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+ }
+ }
+ throw new ConfigError([{ code: "INVALID", key: ".env backup" }]);
+}
+
+export function migrateEnvFile(
+ path: string,
+ options: EnvMigrationOptions = {},
+): EnvMigrationResult {
+ const snapshot = readSecureFile(path, { key: ".env", required: true }) as SecureFileSnapshot;
+ const original = snapshot.text;
+ const permissionsFixed = snapshotFileMode(snapshot) !== 0o600;
+ const entries = entriesFromText(original);
+ const aliases = [
+ {
+ allowed: deepSeekLegacyAllowed(entries),
+ canonical: "DEEPSEEK_API_KEY",
+ legacy: "LLM_API_KEY",
+ },
+ {
+ allowed: true,
+ canonical: "SERVERCHAN_SENDKEY",
+ legacy: "SERVERCHAN_KEY",
+ },
+ {
+ allowed: true,
+ canonical: "SMTP_PASS",
+ legacy: "SMTP_PASSWORD",
+ },
+ {
+ allowed: true,
+ canonical: "SMTP_SECURE",
+ legacy: "SMTP_USE_SSL",
+ },
+ ] as const;
+ const additions: string[] = [];
+ const migratedKeys: string[] = [];
+
+ for (const alias of aliases) {
+ if (!alias.allowed) continue;
+ const legacy = entries.get(alias.legacy);
+ if (!legacy?.decoded) continue;
+ const migratedValue = alias.canonical === "SMTP_SECURE"
+ ? ({ "0": "false", "1": "true", false: "false", true: "true" } as const)[legacy.decoded.toLowerCase() as "0" | "1" | "false" | "true"]
+ : legacy.decoded;
+ if (migratedValue === undefined) {
+ throw new ConfigError([{ code: "INVALID", key: alias.legacy }]);
+ }
+ const canonical = entries.get(alias.canonical);
+ if (canonical && canonical.decoded !== migratedValue) {
+ throw new ConfigError([
+ { code: "CONFLICT", key: alias.canonical, relatedKey: alias.legacy },
+ ]);
+ }
+ if (canonical) continue;
+ additions.push(`${alias.canonical}=${JSON.stringify(migratedValue)}`);
+ migratedKeys.push(alias.canonical);
+ }
+
+ if (!additions.length) {
+ if (permissionsFixed) repairFileMode(path, snapshot);
+ return Object.freeze({
+ changed: permissionsFixed,
+ migratedKeys: Object.freeze([]),
+ permissionsFixed,
+ });
+ }
+
+ assertFileUnchanged(path, snapshot);
+ const backupPath = createBackup(path, original, (options.clock ?? (() => new Date()))());
+
+ const separator = original.endsWith("\n") ? "" : "\n";
+ const migrated = `${original}${separator}\n# ---- Frontier canonical aliases (migrated; legacy keys retained) ----\n${additions.join("\n")}\n`;
+ const temporaryPath = join(dirname(path), `.${basename(path)}.${randomUUID()}.tmp`);
+ try {
+ writeFileSync(temporaryPath, migrated, { encoding: "utf8", flag: "wx", mode: 0o600 });
+ chmodSync(temporaryPath, 0o600);
+ try {
+ assertFileUnchanged(path, snapshot);
+ } catch (error) {
+ rmSync(backupPath, { force: true });
+ throw error;
+ }
+ renameSync(temporaryPath, path);
+ } finally {
+ rmSync(temporaryPath, { force: true });
+ }
+
+ return Object.freeze({
+ backupPath,
+ changed: true,
+ migratedKeys: Object.freeze([...migratedKeys]),
+ permissionsFixed,
+ });
+}
diff --git a/lib/feedback-token.test.ts b/lib/feedback-token.test.ts
new file mode 100644
index 0000000..a5a2e4a
--- /dev/null
+++ b/lib/feedback-token.test.ts
@@ -0,0 +1,134 @@
+import { describe, expect, test } from "vitest";
+import {
+ feedbackTokenFingerprint,
+ issueFeedbackToken,
+ verifyFeedbackToken,
+} from "./feedback-token.ts";
+import fixture from "../tests/fixtures/feedback-token-v1.json";
+
+const secret = "feedback-secret-with-at-least-thirty-two-bytes";
+const input = {
+ digestDate: "2026-07-13",
+ itemId: "abcdef12-3456-4789-8abc-def012345678",
+ rating: "up" as const,
+};
+
+describe("versioned one-time feedback token codec", () => {
+ test("matches the independently frozen cross-project fixture", () => {
+ expect(
+ issueFeedbackToken(fixture.secret, {
+ digestDate: fixture.digestDate,
+ itemId: fixture.itemId,
+ rating: "up",
+ }),
+ ).toBe(fixture.up);
+ expect(
+ issueFeedbackToken(fixture.secret, {
+ digestDate: fixture.digestDate,
+ itemId: fixture.itemId,
+ rating: "down",
+ }),
+ ).toBe(fixture.down);
+ });
+
+ test.each(["2000-01-01", "2287-01-01"])(
+ "round-trips canonical expiry widths for digest date %s",
+ (digestDate) => {
+ const token = issueFeedbackToken(secret, { ...input, digestDate });
+
+ expect(verifyFeedbackToken(secret, token, 0)).toMatchObject({ digestDate });
+ },
+ );
+
+ test("issues a deterministic canonical token and verifies all signed claims", () => {
+ const token = issueFeedbackToken(secret, input);
+
+ expect(issueFeedbackToken(secret, input)).toBe(token);
+ expect(token).toMatch(
+ /^v1\.2026-07-13\.abcdef12-3456-4789-8abc-def012345678\.up\.\d{10}\.[A-Za-z0-9_-]{43}\.[A-Za-z0-9_-]{43}$/,
+ );
+ expect(
+ verifyFeedbackToken(secret, token, new Date("2026-08-03T15:59:59.000Z")),
+ ).toEqual({
+ digestDate: input.digestDate,
+ expiresAt: Date.parse("2026-08-03T16:00:00.000Z") / 1_000,
+ itemId: input.itemId,
+ nonce: token.split(".")[5],
+ rating: "up",
+ version: "v1",
+ });
+ });
+
+ test("shares one deterministic nonce across the two choices for one digest item", () => {
+ const up = issueFeedbackToken(secret, input).split(".");
+ const down = issueFeedbackToken(secret, { ...input, rating: "down" }).split(".");
+
+ expect(up[5]).toBe(down[5]);
+ expect(up[6]).not.toBe(down[6]);
+ expect(issueFeedbackToken(secret, { ...input, digestDate: "2026-07-14" }).split(".")[5])
+ .not.toBe(up[5]);
+ expect(
+ issueFeedbackToken(secret, {
+ ...input,
+ itemId: "abcdef12-3456-4789-8abc-def012345679",
+ }).split(".")[5],
+ ).not.toBe(up[5]);
+ });
+
+ test("expires exactly at the fixed boundary and rejects invalid clocks", () => {
+ const token = issueFeedbackToken(secret, input);
+
+ expect(verifyFeedbackToken(secret, token, new Date("2026-08-03T15:59:59.999Z"))).toBeDefined();
+ expect(verifyFeedbackToken(secret, token, new Date("2026-08-03T16:00:00.000Z"))).toBeUndefined();
+ expect(verifyFeedbackToken(secret, token, new Date("invalid"))).toBeUndefined();
+ });
+
+ test.each([
+ ["version", 0, "v2"],
+ ["date", 1, "2026-07-14"],
+ ["item", 2, "abcdef12-3456-4789-8abc-def012345679"],
+ ["rating", 3, "down"],
+ ["expiry", 4, "1999999999"],
+ ["nonce", 5, "A".repeat(43)],
+ ["signature", 6, "A".repeat(43)],
+ ])("rejects a token with a mutated %s", (_name, index, replacement) => {
+ const parts = issueFeedbackToken(secret, input).split(".");
+ parts[index] = replacement;
+
+ expect(verifyFeedbackToken(secret, parts.join("."), new Date("2026-07-13T00:00:00Z")))
+ .toBeUndefined();
+ });
+
+ test.each([
+ "",
+ "0123456789abcdef",
+ "v1.too.few.fields",
+ `v1.2026-07-13.${input.itemId}.up.1785772800.${"!".repeat(43)}.${"A".repeat(43)}`,
+ `v1.2026-07-13.${input.itemId}.up.01785772800.${"A".repeat(43)}.${"A".repeat(43)}`,
+ `v1.2026-07-13.${input.itemId.toUpperCase()}.up.1785772800.${"A".repeat(43)}.${"A".repeat(43)}`,
+ ])("rejects malformed or legacy token %s", (token) => {
+ expect(verifyFeedbackToken(secret, token, new Date("2026-07-13T00:00:00Z"))).toBeUndefined();
+ });
+
+ test.each([
+ { ...input, digestDate: "2026-02-30" },
+ { ...input, digestDate: "1969-12-01" },
+ { ...input, itemId: input.itemId.toUpperCase() },
+ { ...input, itemId: "not-a-uuid" },
+ { ...input, rating: "maybe" as "up" },
+ ])("refuses to sign noncanonical claims", (claims) => {
+ expect(() => issueFeedbackToken(secret, claims)).toThrow("Invalid feedback token claims");
+ });
+
+ test("requires a strong secret and produces stable non-token fingerprints", () => {
+ const token = issueFeedbackToken(secret, input);
+
+ expect(() => issueFeedbackToken("too-short", input)).toThrow("Invalid feedback token secret");
+ expect(verifyFeedbackToken("too-short", token, new Date("2026-07-13T00:00:00Z")))
+ .toBeUndefined();
+ expect(feedbackTokenFingerprint(token)).toMatch(/^[a-f0-9]{64}$/);
+ expect(feedbackTokenFingerprint(token)).toBe(feedbackTokenFingerprint(token));
+ expect(feedbackTokenFingerprint(`${token}x`)).not.toBe(feedbackTokenFingerprint(token));
+ expect(feedbackTokenFingerprint(token)).not.toContain(token);
+ });
+});
diff --git a/lib/feedback-token.ts b/lib/feedback-token.ts
new file mode 100644
index 0000000..2e81125
--- /dev/null
+++ b/lib/feedback-token.ts
@@ -0,0 +1,158 @@
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+
+export type FeedbackTokenRating = "up" | "down";
+
+export interface FeedbackTokenInput {
+ readonly digestDate: string;
+ readonly itemId: string;
+ readonly rating: FeedbackTokenRating;
+}
+
+export interface FeedbackTokenClaims extends FeedbackTokenInput {
+ readonly expiresAt: number;
+ readonly nonce: string;
+ readonly version: "v1";
+}
+
+const CANONICAL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const BASE64URL_32_BYTES = /^[A-Za-z0-9_-]{43}$/;
+const TOKEN_DOMAIN = "frontier-paper-dispatch:feedback:v1";
+const NONCE_DOMAIN = "frontier-paper-dispatch:feedback-nonce:v1";
+const TOKEN_VALID_DAYS_AFTER_DIGEST = 21;
+
+function validSecret(secret: unknown): secret is string {
+ return (
+ typeof secret === "string" &&
+ Buffer.byteLength(secret, "utf8") >= 32 &&
+ ![...secret].some((character) => {
+ const code = character.codePointAt(0) ?? 0;
+ return code < 32 || code === 127;
+ })
+ );
+}
+
+function validDateKey(value: unknown): value is string {
+ if (typeof value !== "string") return false;
+ const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+ if (!match || match[1] === "0000") return false;
+ const instant = new Date(Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3])));
+ return instant.toISOString().slice(0, 10) === value;
+}
+
+function validInput(value: FeedbackTokenInput): boolean {
+ return (
+ value !== null &&
+ typeof value === "object" &&
+ validDateKey(value.digestDate) &&
+ CANONICAL_UUID.test(value.itemId) &&
+ (value.rating === "up" || value.rating === "down")
+ );
+}
+
+function expiryForDigest(digestDate: string): number {
+ const [year, month, day] = digestDate.split("-").map(Number);
+ const shanghaiMidnightUTC = Date.UTC(year, month - 1, day) - 8 * 60 * 60 * 1_000;
+ return Math.floor(
+ (shanghaiMidnightUTC + (TOKEN_VALID_DAYS_AFTER_DIGEST + 1) * 24 * 60 * 60 * 1_000) /
+ 1_000,
+ );
+}
+
+export function feedbackTokenExpiresAt(digestDate: string): number {
+ if (!validDateKey(digestDate)) throw new Error("Invalid feedback digest date");
+ const expiresAt = expiryForDigest(digestDate);
+ if (parseCanonicalEpochSeconds(String(expiresAt)) === undefined) {
+ throw new Error("Invalid feedback digest date");
+ }
+ return expiresAt;
+}
+
+function hmac(secret: string, value: string): Buffer {
+ return createHmac("sha256", secret).update(value, "utf8").digest();
+}
+
+function canonicalBase64URL(value: string): Buffer | undefined {
+ if (!BASE64URL_32_BYTES.test(value)) return undefined;
+ const decoded = Buffer.from(value, "base64url");
+ return decoded.length === 32 && decoded.toString("base64url") === value ? decoded : undefined;
+}
+
+function equalBase64URL(value: string, expected: Buffer): boolean {
+ const decoded = canonicalBase64URL(value);
+ const candidate = decoded ?? Buffer.alloc(32);
+ const equal = timingSafeEqual(candidate, expected);
+ return decoded !== undefined && equal;
+}
+
+function nonceFor(secret: string, digestDate: string, itemId: string): Buffer {
+ return hmac(secret, `${NONCE_DOMAIN}\0${digestDate}\0${itemId}`);
+}
+
+function parseCanonicalEpochSeconds(value: string): number | undefined {
+ if (!/^[1-9]\d{0,15}$/.test(value)) return undefined;
+ const parsed = Number(value);
+ return Number.isSafeInteger(parsed) && String(parsed) === value ? parsed : undefined;
+}
+
+export function issueFeedbackToken(secret: string, input: FeedbackTokenInput): string {
+ if (!validSecret(secret)) throw new Error("Invalid feedback token secret");
+ if (!validInput(input)) throw new Error("Invalid feedback token claims");
+ let expiresAt: number;
+ try {
+ expiresAt = feedbackTokenExpiresAt(input.digestDate);
+ } catch {
+ throw new Error("Invalid feedback token claims");
+ }
+ const nonce = nonceFor(secret, input.digestDate, input.itemId).toString("base64url");
+ const payload = [
+ "v1",
+ input.digestDate,
+ input.itemId,
+ input.rating,
+ String(expiresAt),
+ nonce,
+ ].join(".");
+ const signature = hmac(secret, `${TOKEN_DOMAIN}\0${payload}`).toString("base64url");
+ return `${payload}.${signature}`;
+}
+
+export function verifyFeedbackToken(
+ secret: string,
+ token: string,
+ now: Date | number = Date.now(),
+): FeedbackTokenClaims | undefined {
+ if (!validSecret(secret) || typeof token !== "string" || Buffer.byteLength(token) > 256) {
+ return undefined;
+ }
+ const nowMilliseconds = now instanceof Date ? now.valueOf() : now;
+ if (!Number.isFinite(nowMilliseconds)) return undefined;
+ const parts = token.split(".");
+ if (parts.length !== 7) return undefined;
+ const [version, digestDate, itemId, rating, expires, nonce, signature] = parts;
+ const input = { digestDate, itemId, rating } as FeedbackTokenInput;
+ const expiresAt = parseCanonicalEpochSeconds(expires);
+ if (version !== "v1" || !validInput(input) || expiresAt === undefined) {
+ return undefined;
+ }
+ const expectedNonce = nonceFor(secret, digestDate, itemId);
+ const payload = parts.slice(0, 6).join(".");
+ const expectedSignature = hmac(secret, `${TOKEN_DOMAIN}\0${payload}`);
+ const nonceMatches = equalBase64URL(nonce, expectedNonce);
+ const signatureMatches = equalBase64URL(signature, expectedSignature);
+ if (!nonceMatches || !signatureMatches) return undefined;
+ if (expiresAt !== expiryForDigest(digestDate) || nowMilliseconds >= expiresAt * 1_000) {
+ return undefined;
+ }
+ return Object.freeze({
+ digestDate,
+ expiresAt,
+ itemId,
+ nonce,
+ rating: rating as FeedbackTokenRating,
+ version: "v1",
+ });
+}
+
+export function feedbackTokenFingerprint(token: string): string {
+ return createHash("sha256").update(token, "utf8").digest("hex");
+}
diff --git a/lib/http.ts b/lib/http.ts
index 6581d55..77a7e60 100644
--- a/lib/http.ts
+++ b/lib/http.ts
@@ -1,29 +1,638 @@
-const UA = "frontier-papers/0.1 (research digest bot)";
+const USER_AGENT = "frontier-papers/0.1 (research digest bot)";
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_DEADLINE_MS = 90_000;
+const DEFAULT_MAX_ATTEMPTS = 3;
+const DEFAULT_BASE_DELAY_MS = 500;
+const DEFAULT_MAX_DELAY_MS = 30_000;
+const DEFAULT_MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
-interface Opts {
+type FetchImplementation = typeof fetch;
+type HttpRedirectMode = "error" | "follow" | "manual";
+
+export interface RetryEvent {
+ attempt: number;
+ delayMs: number;
+ error: unknown;
+ status?: number;
+}
+
+export interface HttpOptions {
+ baseDelayMs?: number;
+ deadlineMs?: number;
+ fetchImpl?: FetchImplementation;
headers?: Record;
+ maxAttempts?: number;
+ maxDelayMs?: number;
+ maxResponseBytes?: number;
+ now?: () => number;
+ onRetry?: (event: RetryEvent) => void;
+ random?: () => number;
+ redirect?: HttpRedirectMode;
+ signal?: AbortSignal;
+ sleep?: (delayMs: number, signal?: AbortSignal) => Promise;
timeoutMs?: number;
}
-async function req(url: string, accept: string, opts: Opts): Promise {
- const ctrl = new AbortController();
- const t = setTimeout(() => ctrl.abort(), opts.timeoutMs ?? 30_000);
+export interface JSONOptions extends HttpOptions {
+ validate?: (value: unknown) => T;
+}
+
+export interface BoundedJSONResponseOptions {
+ endpoint?: string;
+ maxResponseBytes: number;
+ signal?: AbortSignal;
+ validate: (value: unknown) => T;
+}
+
+interface ResolvedOptions {
+ baseDelayMs: number;
+ deadlineMs: number;
+ fetchImpl: FetchImplementation;
+ headers?: Record;
+ maxAttempts: number;
+ maxDelayMs: number;
+ maxResponseBytes: number;
+ now: () => number;
+ onRetry?: (event: RetryEvent) => void;
+ random: () => number;
+ redirect: HttpRedirectMode;
+ signal?: AbortSignal;
+ sleep: (delayMs: number, signal?: AbortSignal) => Promise;
+ timeoutMs: number;
+}
+
+interface BodyResult {
+ attempts: number;
+ body: string;
+ status: number;
+}
+
+export class HttpRequestError extends Error {
+ readonly attempts: number;
+ readonly endpoint: string;
+ readonly retryable: boolean;
+ readonly status?: number;
+
+ constructor(
+ message: string,
+ options: {
+ attempts: number;
+ endpoint: string;
+ retryable: boolean;
+ status?: number;
+ },
+ ) {
+ super(message);
+ this.name = "HttpRequestError";
+ this.attempts = options.attempts;
+ this.endpoint = options.endpoint;
+ this.retryable = options.retryable;
+ this.status = options.status;
+ }
+}
+
+const defaultSleep = (delayMs: number, signal?: AbortSignal): Promise =>
+ new Promise((resolve, reject) => {
+ if (signal?.aborted) {
+ reject(new DOMException("Request aborted", "AbortError"));
+ return;
+ }
+ const onAbort = () => {
+ clearTimeout(timer);
+ signal?.removeEventListener("abort", onAbort);
+ reject(new DOMException("Request aborted", "AbortError"));
+ };
+ const timer = setTimeout(() => {
+ signal?.removeEventListener("abort", onAbort);
+ resolve();
+ }, delayMs);
+ signal?.addEventListener("abort", onAbort, { once: true });
+ });
+
+function positiveNumber(name: string, value: number): number {
+ if (!Number.isFinite(value) || value <= 0) throw new TypeError(`${name} must be a positive number`);
+ return value;
+}
+
+function resolveOptions(options: HttpOptions): ResolvedOptions {
+ const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+ if (!Number.isInteger(maxAttempts) || maxAttempts < 1 || maxAttempts > 5) {
+ throw new TypeError("maxAttempts must be an integer between 1 and 5");
+ }
+ const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+ if (!Number.isFinite(baseDelayMs) || baseDelayMs < 0) {
+ throw new TypeError("baseDelayMs must be a non-negative number");
+ }
+ return {
+ baseDelayMs,
+ deadlineMs: positiveNumber("deadlineMs", options.deadlineMs ?? DEFAULT_DEADLINE_MS),
+ fetchImpl: options.fetchImpl ?? fetch,
+ headers: options.headers,
+ maxAttempts,
+ maxDelayMs: positiveNumber("maxDelayMs", options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS),
+ maxResponseBytes: positiveNumber(
+ "maxResponseBytes",
+ options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES,
+ ),
+ now: options.now ?? Date.now,
+ onRetry: options.onRetry,
+ random: options.random ?? Math.random,
+ redirect: options.redirect ?? "follow",
+ signal: options.signal,
+ sleep: options.sleep ?? defaultSleep,
+ timeoutMs: positiveNumber("timeoutMs", options.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+ };
+}
+
+function safeEndpoint(rawURL: string): string {
try {
- const res = await fetch(url, {
- headers: { "User-Agent": UA, Accept: accept, ...opts.headers },
- signal: ctrl.signal,
- });
- if (!res.ok) throw new Error(`HTTP ${res.status} — ${url}`);
- return res;
+ const url = new URL(rawURL);
+ return `${url.origin}${url.pathname}`;
+ } catch {
+ return "";
+ }
+}
+
+function requireHTTPURL(rawURL: string): URL {
+ let url: URL;
+ try {
+ url = new URL(rawURL);
+ } catch {
+ throw requestError("", 0, false, "Invalid HTTP URL");
+ }
+ if (url.protocol !== "http:" && url.protocol !== "https:") {
+ throw requestError(`${url.protocol}//`, 0, false, "Invalid HTTP URL protocol");
+ }
+ if (url.username || url.password) {
+ throw requestError(`${url.origin}${url.pathname}`, 0, false, "HTTP URL credentials are not allowed");
+ }
+ return url;
+}
+
+function isRetryableStatus(status: number): boolean {
+ return status === 408 || status === 429 || (status >= 500 && status <= 599);
+}
+
+function retryAfterMs(value: string | null, now: number): number | null {
+ if (!value) return null;
+ const seconds = Number(value);
+ if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1_000;
+ const date = Date.parse(value);
+ return Number.isFinite(date) ? Math.max(0, date - now) : null;
+}
+
+function retryDelay(response: Response | null, attempt: number, options: ResolvedOptions): number {
+ const instructed = retryAfterMs(response?.headers.get("Retry-After") ?? null, options.now());
+ if (instructed !== null) return Math.min(instructed, options.maxDelayMs);
+ const jitter = 0.5 + Math.min(1, Math.max(0, options.random()));
+ return Math.min(options.baseDelayMs * 2 ** (attempt - 1) * jitter, options.maxDelayMs);
+}
+
+function requestError(
+ endpoint: string,
+ attempts: number,
+ retryable: boolean,
+ message: string,
+ status?: number,
+): HttpRequestError {
+ return new HttpRequestError(`${message} (${endpoint})`, {
+ attempts,
+ endpoint,
+ retryable,
+ status,
+ });
+}
+
+function retryBudgetError(error: HttpRequestError, attempts: number): HttpRequestError {
+ return requestError(
+ error.endpoint,
+ attempts,
+ true,
+ `HTTP retry budget exhausted after ${attempts} attempt(s)`,
+ error.status,
+ );
+}
+
+async function waitBeforeRetry(
+ error: HttpRequestError,
+ response: Response | null,
+ attempt: number,
+ startedAt: number,
+ options: ResolvedOptions,
+): Promise {
+ if (options.signal?.aborted) {
+ throw requestError(error.endpoint, attempt, false, "HTTP request aborted by caller");
+ }
+ const delayMs = retryDelay(response, attempt, options);
+ const remainingMs = options.deadlineMs - (options.now() - startedAt);
+ if (remainingMs <= delayMs) {
+ throw requestError(
+ error.endpoint,
+ attempt,
+ true,
+ `HTTP deadline exhausted after ${attempt} attempt(s)`,
+ error.status,
+ );
+ }
+ options.onRetry?.({ attempt, delayMs, error, status: error.status });
+ if (options.signal?.aborted) {
+ throw requestError(error.endpoint, attempt, false, "HTTP request aborted by caller");
+ }
+ if (!options.signal) {
+ try {
+ await options.sleep(delayMs);
+ } catch {
+ throw requestError(error.endpoint, attempt, false, "HTTP retry delay failed");
+ }
+ return;
+ }
+
+ let abortListener: (() => void) | undefined;
+ const aborted = new Promise((_resolve, reject) => {
+ abortListener = () => reject(new DOMException("Request aborted", "AbortError"));
+ options.signal?.addEventListener("abort", abortListener, { once: true });
+ if (options.signal?.aborted) abortListener();
+ });
+ try {
+ await Promise.race([options.sleep(delayMs, options.signal), aborted]);
+ if (options.signal.aborted) {
+ throw new DOMException("Request aborted", "AbortError");
+ }
+ } catch {
+ if (options.signal.aborted) {
+ throw requestError(error.endpoint, attempt, false, "HTTP request aborted by caller");
+ }
+ throw requestError(error.endpoint, attempt, false, "HTTP retry delay failed");
} finally {
- clearTimeout(t);
+ if (abortListener) options.signal.removeEventListener("abort", abortListener);
}
}
-export const httpText = (url: string, opts: Opts = {}) =>
- req(url, "application/xml, text/xml, */*", opts).then((r) => r.text());
+interface AttemptHandle {
+ cleanup: () => void;
+ controller: AbortController;
+ response: Response;
+ timedOut: () => boolean;
+}
+
+function isNetworkFailure(error: unknown): boolean {
+ return error instanceof TypeError || error instanceof DOMException;
+}
-export const httpJSON = (url: string, opts: Opts = {}) =>
- req(url, "application/json", opts).then((r) => r.json() as Promise);
+async function openAttempt(
+ url: string,
+ accept: string,
+ attempt: number,
+ timeoutMs: number,
+ options: ResolvedOptions,
+): Promise {
+ const endpoint = safeEndpoint(url);
+ let headers: Headers;
+ try {
+ headers = new Headers(options.headers);
+ if (!headers.has("User-Agent")) headers.set("User-Agent", USER_AGENT);
+ if (!headers.has("Accept")) headers.set("Accept", accept);
+ } catch {
+ throw requestError(endpoint, attempt, false, "Invalid HTTP request headers");
+ }
+ const controller = new AbortController();
+ let didTimeOut = false;
+ const abortFromCaller = () => controller.abort(options.signal?.reason);
+ if (options.signal?.aborted) {
+ throw requestError(endpoint, attempt, false, "HTTP request aborted by caller");
+ }
+ options.signal?.addEventListener("abort", abortFromCaller, { once: true });
+
+ const timer = setTimeout(() => {
+ didTimeOut = true;
+ controller.abort(new DOMException(`Timed out after ${timeoutMs}ms`, "TimeoutError"));
+ }, timeoutMs);
+ let cleaned = false;
+ const cleanup = () => {
+ if (cleaned) return;
+ cleaned = true;
+ clearTimeout(timer);
+ options.signal?.removeEventListener("abort", abortFromCaller);
+ };
+ try {
+ const response = await options.fetchImpl(url, { headers, redirect: options.redirect, signal: controller.signal });
+ return { cleanup, controller, response, timedOut: () => didTimeOut };
+ } catch (error) {
+ cleanup();
+ const callerAborted = options.signal?.aborted ?? false;
+ const retryable = !callerAborted && (didTimeOut || isNetworkFailure(error));
+ throw requestError(
+ endpoint,
+ attempt,
+ retryable,
+ callerAborted
+ ? "HTTP request aborted by caller"
+ : retryable
+ ? "HTTP network request failed"
+ : "HTTP fetch failed with a non-network error",
+ );
+ }
+}
+
+function contentType(response: Response): string {
+ return (response.headers.get("Content-Type") ?? "").split(";", 1)[0].trim().toLowerCase();
+}
+
+function cancelBody(body: ReadableStream | null, reason: string): void {
+ if (!body) return;
+ try {
+ void body.cancel(reason).catch(() => undefined);
+ } catch {
+ // Best-effort cleanup must never mask the request result.
+ }
+}
+
+function cancelReader(reader: ReadableStreamDefaultReader, reason: unknown): void {
+ try {
+ void reader.cancel(reason).catch(() => undefined);
+ } catch {
+ // Best-effort cleanup must never mask the request result.
+ }
+}
+
+async function validatedBody(
+ response: Response,
+ attempt: number,
+ endpoint: string,
+ options: ResolvedOptions,
+ accepts: (mediaType: string) => boolean,
+ signal: AbortSignal,
+): Promise {
+ const mediaType = contentType(response);
+ if (!accepts(mediaType)) {
+ cancelBody(response.body, "Unexpected Content-Type");
+ throw requestError(
+ endpoint,
+ attempt,
+ false,
+ `Unexpected Content-Type ${mediaType || ""}`,
+ response.status,
+ );
+ }
+
+ const declaredLength = Number(response.headers.get("Content-Length"));
+ if (Number.isFinite(declaredLength) && declaredLength > options.maxResponseBytes) {
+ cancelBody(response.body, "Response exceeded declared byte limit");
+ throw requestError(endpoint, attempt, false, "Response is too large", response.status);
+ }
+
+ if (!response.body) {
+ throw requestError(endpoint, attempt, false, "Response body is empty", response.status);
+ }
+
+ const reader = response.body.getReader();
+ const decoder = new TextDecoder();
+ let body = "";
+ let size = 0;
+ for (;;) {
+ let abortListener: (() => void) | undefined;
+ const aborted = new Promise((_resolve, reject) => {
+ abortListener = () => {
+ reject(signal.reason ?? new DOMException("Request aborted", "AbortError"));
+ queueMicrotask(() => cancelReader(reader, signal.reason));
+ };
+ signal.addEventListener("abort", abortListener, { once: true });
+ if (signal.aborted) abortListener();
+ });
+ let chunk: Awaited>;
+ try {
+ if (signal.aborted) throw signal.reason ?? new DOMException("Request aborted", "AbortError");
+ chunk = await Promise.race([reader.read(), aborted]);
+ if (signal.aborted) throw signal.reason ?? new DOMException("Request aborted", "AbortError");
+ } finally {
+ if (abortListener) signal.removeEventListener("abort", abortListener);
+ }
+ if (chunk.done) break;
+ size += chunk.value.byteLength;
+ if (size > options.maxResponseBytes) {
+ cancelReader(reader, "Response exceeded configured byte limit");
+ throw requestError(endpoint, attempt, false, "Response is too large", response.status);
+ }
+ body += decoder.decode(chunk.value, { stream: true });
+ }
+ body += decoder.decode();
+ if (!body.trim()) {
+ throw requestError(endpoint, attempt, false, "Response body is empty", response.status);
+ }
+ return body;
+}
+
+async function requestBody(
+ url: string,
+ accept: string,
+ accepts: (mediaType: string) => boolean,
+ inputOptions: HttpOptions,
+): Promise {
+ const options = resolveOptions(inputOptions);
+ const parsedURL = requireHTTPURL(url);
+ const endpoint = `${parsedURL.origin}${parsedURL.pathname}`;
+ const startedAt = options.now();
+
+ for (let attempt = 1; attempt <= options.maxAttempts; attempt += 1) {
+ const remainingMs = options.deadlineMs - (options.now() - startedAt);
+ if (remainingMs <= 0) {
+ throw requestError(endpoint, attempt - 1, true, "HTTP deadline exhausted");
+ }
+
+ let handle: AttemptHandle;
+ try {
+ handle = await openAttempt(
+ url,
+ accept,
+ attempt,
+ Math.max(1, Math.min(options.timeoutMs, remainingMs)),
+ options,
+ );
+ } catch (error) {
+ if (!(error instanceof HttpRequestError)) throw error;
+ if (!error.retryable) throw error;
+ if (attempt === options.maxAttempts) throw retryBudgetError(error, attempt);
+ await waitBeforeRetry(error, null, attempt, startedAt, options);
+ continue;
+ }
+
+ const { response } = handle;
+ if (!response.ok) {
+ cancelBody(response.body, `HTTP status ${response.status}`);
+ handle.cleanup();
+ const retryable = isRetryableStatus(response.status);
+ const error = requestError(
+ endpoint,
+ attempt,
+ retryable,
+ `HTTP request failed with status ${response.status}`,
+ response.status,
+ );
+ if (!retryable) throw error;
+ if (attempt === options.maxAttempts) throw retryBudgetError(error, attempt);
+ await waitBeforeRetry(error, response, attempt, startedAt, options);
+ continue;
+ }
+
+ try {
+ const result = {
+ attempts: attempt,
+ body: await validatedBody(
+ response,
+ attempt,
+ endpoint,
+ options,
+ accepts,
+ handle.controller.signal,
+ ),
+ status: response.status,
+ };
+ handle.cleanup();
+ return result;
+ } catch (error) {
+ handle.cleanup();
+ if (error instanceof HttpRequestError) throw error;
+ const callerAborted = options.signal?.aborted ?? false;
+ const retryable = !callerAborted && (handle.timedOut() || isNetworkFailure(error));
+ const bodyError = requestError(
+ endpoint,
+ attempt,
+ retryable,
+ callerAborted
+ ? "HTTP request aborted by caller"
+ : retryable
+ ? "HTTP response body could not be read"
+ : "HTTP response body failed with a non-network error",
+ response.status,
+ );
+ if (!retryable) throw bodyError;
+ if (attempt === options.maxAttempts) throw retryBudgetError(bodyError, attempt);
+ await waitBeforeRetry(bodyError, null, attempt, startedAt, options);
+ }
+ }
+
+ throw requestError(
+ endpoint,
+ options.maxAttempts,
+ true,
+ `HTTP retry budget exhausted after ${options.maxAttempts} attempt(s)`,
+ );
+}
+
+const acceptsJSON = (mediaType: string): boolean =>
+ mediaType === "application/json" || mediaType.endsWith("+json");
+
+const acceptsXML = (mediaType: string): boolean =>
+ mediaType === "application/xml" ||
+ mediaType === "text/xml" ||
+ mediaType === "text/plain" ||
+ mediaType.endsWith("+xml");
+
+const acceptsHTML = (mediaType: string): boolean =>
+ acceptsXML(mediaType) || mediaType === "text/html" || mediaType === "application/xhtml+xml";
+
+export async function httpText(url: string, options: HttpOptions = {}): Promise {
+ const result = await requestBody(
+ url,
+ "application/xml, text/xml, application/rss+xml, application/atom+xml",
+ acceptsXML,
+ options,
+ );
+ return result.body;
+}
+
+export async function httpHTML(url: string, options: HttpOptions = {}): Promise {
+ const result = await requestBody(
+ url,
+ "text/html, application/xhtml+xml, application/xml, text/xml",
+ acceptsHTML,
+ options,
+ );
+ return result.body;
+}
+
+export async function httpJSON(url: string, options: JSONOptions = {}): Promise {
+ const result = await requestBody(url, "application/json", acceptsJSON, options);
+ let value: unknown;
+ try {
+ value = JSON.parse(result.body);
+ } catch {
+ throw requestError(
+ safeEndpoint(url),
+ result.attempts,
+ false,
+ "Response is not valid JSON",
+ result.status,
+ );
+ }
+ if (!options.validate) return value as T;
+ try {
+ return options.validate(value);
+ } catch (error) {
+ const message = error instanceof Error ? error.message : String(error);
+ throw requestError(
+ safeEndpoint(url),
+ result.attempts,
+ false,
+ `Response validation failed: ${message}`,
+ result.status,
+ );
+ }
+}
+
+/** Parse an already-open response without ever buffering beyond the byte cap. */
+export async function readBoundedJSONResponse(
+ response: Response,
+ options: BoundedJSONResponseOptions,
+): Promise {
+ const endpoint = options.endpoint ?? "";
+ if (!/^[-A-Za-z0-9_.:/<>]{1,200}$/.test(endpoint)) {
+ throw new TypeError("endpoint label is invalid");
+ }
+ if (!response.ok) {
+ cancelBody(response.body, `HTTP status ${response.status}`);
+ throw requestError(
+ endpoint,
+ 1,
+ isRetryableStatus(response.status),
+ `HTTP request failed with status ${response.status}`,
+ response.status,
+ );
+ }
+ const resolved = resolveOptions({
+ maxAttempts: 1,
+ maxResponseBytes: options.maxResponseBytes,
+ });
+ const signal = options.signal ?? new AbortController().signal;
+ const body = await validatedBody(
+ response,
+ 1,
+ endpoint,
+ resolved,
+ acceptsJSON,
+ signal,
+ );
+ let value: unknown;
+ try {
+ value = JSON.parse(body);
+ } catch {
+ throw requestError(endpoint, 1, false, "Response is not valid JSON", response.status);
+ }
+ try {
+ return options.validate(value);
+ } catch (error) {
+ const message = error instanceof Error ? error.message : String(error);
+ throw requestError(
+ endpoint,
+ 1,
+ false,
+ `Response validation failed: ${message}`,
+ response.status,
+ );
+ }
+}
-export const clean = (s: unknown): string => String(s ?? "").replace(/\s+/g, " ").trim();
+export const clean = (value: unknown): string =>
+ String(value ?? "")
+ .replace(/\s+/g, " ")
+ .trim();
diff --git a/lib/llm-budget.test.ts b/lib/llm-budget.test.ts
new file mode 100644
index 0000000..bb1e74b
--- /dev/null
+++ b/lib/llm-budget.test.ts
@@ -0,0 +1,242 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { withRuntimeEnvironment } from "./runtime-env.ts";
+import {
+ reserveRootLLMBudget,
+ settleRootLLMBudget,
+ type RootLLMBudgetReservation,
+} from "./llm-budget.ts";
+
+const serviceRoleKey = `sb_secret_${"s".repeat(40)}`;
+const requestId = "10000000-0000-4000-8000-000000000001";
+const reservationId = "20000000-0000-4000-8000-000000000001";
+const fetchMock = vi.fn();
+
+const environment = () => ({
+ SUPABASE_SERVICE_ROLE_KEY: serviceRoleKey,
+ SUPABASE_URL: "https://frontier-paper.supabase.co",
+});
+
+function jsonRPC(body: unknown, init: ResponseInit = {}): Response {
+ return new Response(JSON.stringify(body), {
+ ...init,
+ headers: { "Content-Type": "application/json; charset=utf-8", ...init.headers },
+ });
+}
+
+function reservation(): RootLLMBudgetReservation {
+ return Object.freeze({
+ budgetDate: "2026-07-14",
+ reservationId,
+ reservedTokens: 5_000,
+ subject: "system:ingest" as const,
+ });
+}
+
+beforeEach(() => {
+ vi.stubGlobal("fetch", fetchMock);
+ fetchMock.mockReset();
+});
+
+afterEach(() => {
+ vi.useRealTimers();
+ vi.unstubAllGlobals();
+});
+
+describe("root hard LLM budget client", () => {
+ test.each([
+ ["root_rank", "system:ingest"],
+ ["root_summary", "system:ingest"],
+ ["root_refine", "system:refine"],
+ ] as const)("maps %s to its sealed system subject", async (policy, subject) => {
+ fetchMock.mockResolvedValueOnce(
+ jsonRPC([
+ {
+ budget_date: "2026-07-14",
+ outcome: "reserved",
+ reservation_id: reservationId,
+ reserved_tokens: 5_000,
+ retry_after_seconds: null,
+ },
+ ]),
+ );
+
+ const result = await withRuntimeEnvironment(environment(), () =>
+ reserveRootLLMBudget(policy, requestId, 5_000),
+ );
+
+ expect(result).toEqual({
+ allowed: true,
+ budgetDate: "2026-07-14",
+ reservationId,
+ reservedTokens: 5_000,
+ subject,
+ });
+ expect(fetchMock).toHaveBeenCalledTimes(1);
+ const [url, init] = fetchMock.mock.calls[0];
+ expect(url).toBe(
+ "https://frontier-paper.supabase.co/rest/v1/rpc/reserve_llm_budget",
+ );
+ expect(init).toMatchObject({
+ cache: "no-store",
+ credentials: "omit",
+ method: "POST",
+ redirect: "error",
+ referrerPolicy: "no-referrer",
+ });
+ const headers = new Headers(init?.headers);
+ expect(headers.get("apikey")).toBe(serviceRoleKey);
+ expect(headers.get("authorization")).toBe(`Bearer ${serviceRoleKey}`);
+ expect(JSON.parse(String(init?.body))).toEqual({
+ p_policy: policy,
+ p_request_id: requestId,
+ p_reserved_tokens: 5_000,
+ p_subject: subject,
+ });
+ });
+
+ test("returns the bounded database delay when the daily budget is exhausted", async () => {
+ fetchMock.mockResolvedValueOnce(
+ jsonRPC([
+ {
+ budget_date: "2026-07-14",
+ outcome: "budget_exhausted",
+ reservation_id: null,
+ reserved_tokens: null,
+ retry_after_seconds: 3_600,
+ },
+ ]),
+ );
+
+ await expect(
+ withRuntimeEnvironment(environment(), () =>
+ reserveRootLLMBudget("root_rank", requestId, 5_000),
+ ),
+ ).resolves.toEqual({ allowed: false, retryAfter: 3_600 });
+ });
+
+ test("settles known usage against the reservation's sealed subject", async () => {
+ fetchMock.mockResolvedValueOnce(
+ jsonRPC([{ budget_date: "2026-07-14", charged_tokens: 1_234, outcome: "settled" }]),
+ );
+
+ await expect(
+ withRuntimeEnvironment(environment(), () =>
+ settleRootLLMBudget(reservation(), 1_234),
+ ),
+ ).resolves.toEqual({ chargedTokens: 1_234 });
+ expect(JSON.parse(String(fetchMock.mock.calls[0][1]?.body))).toEqual({
+ p_actual_tokens: 1_234,
+ p_reservation_id: reservationId,
+ p_subject: "system:ingest",
+ });
+ });
+
+ test("charges the full reservation when provider usage is unknown", async () => {
+ fetchMock.mockResolvedValueOnce(
+ jsonRPC([{ budget_date: "2026-07-14", charged_tokens: 5_000, outcome: "settled" }]),
+ );
+
+ await expect(
+ withRuntimeEnvironment(environment(), () => settleRootLLMBudget(reservation(), null)),
+ ).resolves.toEqual({ chargedTokens: 5_000 });
+ });
+
+ test.each([
+ ["wrong row count", []],
+ ["unknown outcome", [{ budget_date: "2026-07-14", outcome: "maybe", reservation_id: null, reserved_tokens: null, retry_after_seconds: null }]],
+ ["mismatched amount", [{ budget_date: "2026-07-14", outcome: "reserved", reservation_id: reservationId, reserved_tokens: 4_999, retry_after_seconds: null }]],
+ ["extra field", [{ budget_date: "2026-07-14", outcome: "reserved", reservation_id: reservationId, reserved_tokens: 5_000, retry_after_seconds: null, private: true }]],
+ ])("fails closed for a malformed reservation response: %s", async (_name, body) => {
+ fetchMock.mockResolvedValueOnce(jsonRPC(body));
+
+ await expect(
+ withRuntimeEnvironment(environment(), () =>
+ reserveRootLLMBudget("root_rank", requestId, 5_000),
+ ),
+ ).rejects.toThrow("LLM_BUDGET_UNAVAILABLE");
+ });
+
+ test("maps provider details to one safe error", async () => {
+ fetchMock.mockResolvedValueOnce(
+ jsonRPC({ private: "database detail https://secret.example" }, { status: 500 }),
+ );
+
+ let error: unknown;
+ try {
+ await withRuntimeEnvironment(environment(), () =>
+ reserveRootLLMBudget("root_rank", requestId, 5_000),
+ );
+ } catch (caught) {
+ error = caught;
+ }
+ expect(String(error)).toBe("Error: LLM_BUDGET_UNAVAILABLE");
+ expect(String(error)).not.toMatch(/private|database|secret\.example/i);
+ });
+
+ test("aborts a hanging RPC at a fixed deadline without retrying", async () => {
+ vi.useFakeTimers();
+ let signal: AbortSignal | undefined;
+ fetchMock.mockImplementationOnce((_url, init) => {
+ signal = init?.signal ?? undefined;
+ return new Promise((_resolve, reject) => {
+ signal?.addEventListener("abort", () => reject(new Error("private abort")));
+ });
+ });
+
+ const pending = withRuntimeEnvironment(environment(), () =>
+ reserveRootLLMBudget("root_rank", requestId, 5_000),
+ );
+ await vi.advanceTimersByTimeAsync(10_000);
+
+ await expect(pending).rejects.toThrow("LLM_BUDGET_UNAVAILABLE");
+ expect(signal?.aborted).toBe(true);
+ expect(fetchMock).toHaveBeenCalledTimes(1);
+ });
+
+ test("deadline also cancels a response body that hangs after headers", async () => {
+ vi.useFakeTimers();
+ let cancelled = false;
+ fetchMock.mockResolvedValueOnce(
+ new Response(
+ new ReadableStream({
+ cancel() {
+ cancelled = true;
+ },
+ pull() {
+ return new Promise(() => {});
+ },
+ }),
+ { headers: { "Content-Type": "application/json" } },
+ ),
+ );
+
+ const pending = withRuntimeEnvironment(environment(), () =>
+ reserveRootLLMBudget("root_rank", requestId, 5_000),
+ );
+ const observed = Promise.race([
+ pending.then(
+ () => "resolved",
+ (error: unknown) => String(error),
+ ),
+ new Promise((resolve) => setTimeout(() => resolve("still-pending"), 6_000)),
+ ]);
+ await vi.advanceTimersByTimeAsync(10_000);
+
+ await expect(observed).resolves.toBe("Error: LLM_BUDGET_UNAVAILABLE");
+ expect(cancelled).toBe(true);
+ });
+
+ test.each([
+ ["bad policy", "web_chat", requestId, 5_000],
+ ["non-v4 request", "root_rank", "00000000-0000-1000-8000-000000000001", 5_000],
+ ["zero tokens", "root_rank", requestId, 0],
+ ["too many tokens", "root_rank", requestId, 65_537],
+ ])("rejects %s before network I/O", async (_name, policy, id, tokens) => {
+ await expect(
+ withRuntimeEnvironment(environment(), () =>
+ reserveRootLLMBudget(policy as "root_rank", id, tokens),
+ ),
+ ).rejects.toThrow("LLM_BUDGET_UNAVAILABLE");
+ expect(fetchMock).not.toHaveBeenCalled();
+ });
+});
diff --git a/lib/llm-budget.ts b/lib/llm-budget.ts
new file mode 100644
index 0000000..b508947
--- /dev/null
+++ b/lib/llm-budget.ts
@@ -0,0 +1,316 @@
+import { loadSupabaseConfig } from "./runtime-config.ts";
+import { currentRuntimeEnvironment } from "./runtime-env.ts";
+
+const RPC_DEADLINE_MS = 5_000;
+const MAX_RPC_RESPONSE_BYTES = 8_192;
+const MAX_LLM_TOKENS = 65_536;
+const MAX_DAILY_RETRY_SECONDS = 86_400;
+
+const DATABASE_UUID_V4 =
+ /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+export type RootLLMPolicy = "root_rank" | "root_summary" | "root_refine";
+export type RootLLMSubject = "system:ingest" | "system:refine";
+
+export interface RootLLMBudgetReservation {
+ readonly budgetDate: string;
+ readonly reservationId: string;
+ readonly reservedTokens: number;
+ readonly subject: RootLLMSubject;
+}
+
+export type RootLLMBudgetResult =
+ | Readonly<({ allowed: true } & RootLLMBudgetReservation)>
+ | Readonly<{ allowed: false; retryAfter: number }>;
+
+function unavailable(): never {
+ throw new Error("LLM_BUDGET_UNAVAILABLE");
+}
+
+function safely(operation: () => Promise): Promise {
+ const result = (async () => {
+ try {
+ return await operation();
+ } catch {
+ return unavailable();
+ }
+ })();
+ // A deadline may reject before orchestration reaches its await. Observing the
+ // promise here prevents a transient unhandled-rejection report without
+ // changing the rejection returned to the caller.
+ void result.catch(() => {});
+ return result;
+}
+
+function record(value: unknown): Record | undefined {
+ return value !== null && typeof value === "object" && !Array.isArray(value)
+ ? (value as Record)
+ : undefined;
+}
+
+function oneRow(value: unknown): Record {
+ if (!Array.isArray(value) || value.length !== 1) return unavailable();
+ return record(value[0]) ?? unavailable();
+}
+
+function exactKeys(value: Record, expected: readonly string[]): boolean {
+ const keys = Object.keys(value);
+ return keys.length === expected.length && expected.every((key) => Object.hasOwn(value, key));
+}
+
+function validDateKey(value: unknown): value is string {
+ if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value) || value.startsWith("0000-")) {
+ return false;
+ }
+ const instant = new Date(`${value}T00:00:00.000Z`);
+ return Number.isFinite(instant.valueOf()) && instant.toISOString().slice(0, 10) === value;
+}
+
+function validPositiveInteger(value: unknown, maximum: number): value is number {
+ return Number.isInteger(value) && (value as number) >= 1 && (value as number) <= maximum;
+}
+
+function subjectFor(policy: RootLLMPolicy): RootLLMSubject {
+ return policy === "root_refine" ? "system:refine" : "system:ingest";
+}
+
+function validPolicy(value: unknown): value is RootLLMPolicy {
+ return value === "root_rank" || value === "root_summary" || value === "root_refine";
+}
+
+function cancelResponse(response: Response): void {
+ try {
+ void response.body?.cancel().catch(() => {});
+ } catch {
+ // Cancellation is best-effort; validation still fails closed.
+ }
+}
+
+function cancelReader(reader: ReadableStreamDefaultReader): void {
+ try {
+ void reader.cancel().catch(() => {});
+ } catch {
+ // Cancellation is best-effort; validation still fails closed.
+ }
+}
+
+function readChunk(
+ reader: ReadableStreamDefaultReader,
+ signal: AbortSignal,
+): ReturnType {
+ return new Promise((resolve, reject) => {
+ const aborted = () => {
+ cancelReader(reader);
+ reject(new Error("LLM_BUDGET_ABORTED"));
+ };
+ if (signal.aborted) {
+ aborted();
+ return;
+ }
+ signal.addEventListener("abort", aborted, { once: true });
+ try {
+ void reader.read().then(
+ (result) => {
+ signal.removeEventListener("abort", aborted);
+ resolve(result);
+ },
+ (error: unknown) => {
+ signal.removeEventListener("abort", aborted);
+ reject(error);
+ },
+ );
+ } catch (error) {
+ signal.removeEventListener("abort", aborted);
+ reject(error);
+ }
+ });
+}
+
+function jsonContentType(value: string | null): boolean {
+ return value !== null && /^application\/json(?:\s*;\s*charset=utf-8)?$/i.test(value.trim());
+}
+
+async function boundedJSON(response: Response, signal: AbortSignal): Promise {
+ if (!response.ok || !jsonContentType(response.headers.get("content-type"))) {
+ cancelResponse(response);
+ throw new Error("INVALID_LLM_BUDGET_RESPONSE");
+ }
+
+ const declaredLength = response.headers.get("content-length");
+ if (
+ declaredLength !== null &&
+ (!/^\d{1,10}$/.test(declaredLength) || Number(declaredLength) > MAX_RPC_RESPONSE_BYTES)
+ ) {
+ cancelResponse(response);
+ throw new Error("INVALID_LLM_BUDGET_RESPONSE");
+ }
+
+ const body = response.body;
+ if (!body) throw new Error("INVALID_LLM_BUDGET_RESPONSE");
+ const reader = body.getReader();
+ const chunks: Uint8Array[] = [];
+ let size = 0;
+ try {
+ for (;;) {
+ const { done, value } = await readChunk(reader, signal);
+ if (done) break;
+ size += value.byteLength;
+ if (size > MAX_RPC_RESPONSE_BYTES) {
+ cancelReader(reader);
+ throw new Error("INVALID_LLM_BUDGET_RESPONSE");
+ }
+ chunks.push(value);
+ }
+ } catch (error) {
+ cancelReader(reader);
+ throw error;
+ } finally {
+ try {
+ reader.releaseLock();
+ } catch {
+ // A hostile stream may retain its lock; the response is still rejected.
+ }
+ }
+
+ const bytes = new Uint8Array(size);
+ let offset = 0;
+ for (const chunk of chunks) {
+ bytes.set(chunk, offset);
+ offset += chunk.byteLength;
+ }
+ return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)) as unknown;
+}
+
+async function rpc(
+ name: "reserve_llm_budget" | "settle_llm_budget",
+ payload: Readonly>,
+): Promise {
+ const config = loadSupabaseConfig(currentRuntimeEnvironment());
+ const controller = new AbortController();
+ const timeout = setTimeout(() => controller.abort(), RPC_DEADLINE_MS);
+ try {
+ const response = await globalThis.fetch(`${config.url}/rest/v1/rpc/${name}`, {
+ body: JSON.stringify(payload),
+ cache: "no-store",
+ credentials: "omit",
+ headers: {
+ Accept: "application/json",
+ apikey: config.serviceRoleKey,
+ Authorization: `Bearer ${config.serviceRoleKey}`,
+ "Content-Type": "application/json",
+ },
+ method: "POST",
+ redirect: "error",
+ referrerPolicy: "no-referrer",
+ signal: controller.signal,
+ });
+ return await boundedJSON(response, controller.signal);
+ } finally {
+ clearTimeout(timeout);
+ }
+}
+
+export function reserveRootLLMBudget(
+ policy: RootLLMPolicy,
+ requestId: string,
+ reservedTokens: number,
+): Promise {
+ return safely(async () => {
+ if (
+ !validPolicy(policy) ||
+ typeof requestId !== "string" ||
+ !DATABASE_UUID_V4.test(requestId) ||
+ !validPositiveInteger(reservedTokens, MAX_LLM_TOKENS)
+ ) {
+ return unavailable();
+ }
+ const subject = subjectFor(policy);
+ const row = oneRow(
+ await rpc("reserve_llm_budget", {
+ p_policy: policy,
+ p_request_id: requestId,
+ p_reserved_tokens: reservedTokens,
+ p_subject: subject,
+ }),
+ );
+ if (
+ !exactKeys(row, [
+ "budget_date",
+ "outcome",
+ "reservation_id",
+ "reserved_tokens",
+ "retry_after_seconds",
+ ]) ||
+ !validDateKey(row.budget_date)
+ ) {
+ return unavailable();
+ }
+
+ if (row.outcome === "reserved" || row.outcome === "existing") {
+ if (
+ typeof row.reservation_id !== "string" ||
+ !DATABASE_UUID_V4.test(row.reservation_id) ||
+ row.reserved_tokens !== reservedTokens ||
+ row.retry_after_seconds !== null
+ ) {
+ return unavailable();
+ }
+ return Object.freeze({
+ allowed: true,
+ budgetDate: row.budget_date,
+ reservationId: row.reservation_id,
+ reservedTokens,
+ subject,
+ });
+ }
+
+ if (
+ row.outcome !== "budget_exhausted" ||
+ row.reservation_id !== null ||
+ row.reserved_tokens !== null ||
+ !validPositiveInteger(row.retry_after_seconds, MAX_DAILY_RETRY_SECONDS)
+ ) {
+ return unavailable();
+ }
+ return Object.freeze({ allowed: false, retryAfter: row.retry_after_seconds });
+ });
+}
+
+export function settleRootLLMBudget(
+ reservation: RootLLMBudgetReservation,
+ actualTokens: number | null,
+): Promise> {
+ return safely(async () => {
+ const value = record(reservation);
+ if (
+ value === undefined ||
+ !validDateKey(value.budgetDate) ||
+ typeof value.reservationId !== "string" ||
+ !DATABASE_UUID_V4.test(value.reservationId) ||
+ !validPositiveInteger(value.reservedTokens, MAX_LLM_TOKENS) ||
+ (value.subject !== "system:ingest" && value.subject !== "system:refine") ||
+ (actualTokens !== null &&
+ !validPositiveInteger(actualTokens, value.reservedTokens as number))
+ ) {
+ return unavailable();
+ }
+
+ const row = oneRow(
+ await rpc("settle_llm_budget", {
+ p_actual_tokens: actualTokens,
+ p_reservation_id: value.reservationId,
+ p_subject: value.subject,
+ }),
+ );
+ const expectedCharge = actualTokens ?? (value.reservedTokens as number);
+ if (
+ !exactKeys(row, ["budget_date", "charged_tokens", "outcome"]) ||
+ (row.outcome !== "settled" && row.outcome !== "existing") ||
+ row.budget_date !== value.budgetDate ||
+ row.charged_tokens !== expectedCharge
+ ) {
+ return unavailable();
+ }
+ return Object.freeze({ chargedTokens: expectedCharge });
+ });
+}
diff --git a/lib/llm.test.ts b/lib/llm.test.ts
new file mode 100644
index 0000000..0527a97
--- /dev/null
+++ b/lib/llm.test.ts
@@ -0,0 +1,318 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { z } from "zod";
+import { withRuntimeEnvironment } from "./runtime-env.ts";
+
+const mocks = vi.hoisted(() => ({
+ clientOptions: [] as unknown[],
+ create: vi.fn(),
+ reserve: vi.fn(),
+ settle: vi.fn(),
+}));
+
+vi.mock("openai", () => ({
+ default: class MockOpenAI {
+ readonly chat = { completions: { create: mocks.create } };
+
+ constructor(options: unknown) {
+ mocks.clientOptions.push(options);
+ }
+ },
+}));
+
+vi.mock("./llm-budget.ts", () => ({
+ reserveRootLLMBudget: mocks.reserve,
+ settleRootLLMBudget: mocks.settle,
+}));
+
+import { complete, completeJSON, LLMOperationError, MODELS } from "./llm.ts";
+
+const reservation = Object.freeze({
+ allowed: true as const,
+ budgetDate: "2026-07-14",
+ reservationId: "20000000-0000-4000-8000-000000000001",
+ reservedTokens: 8_000,
+ subject: "system:ingest" as const,
+});
+
+function run(operation: () => Promise): Promise {
+ return withRuntimeEnvironment(
+ { DEEPSEEK_API_KEY: `sk-${crypto.randomUUID().replaceAll("-", "")}` },
+ operation,
+ );
+}
+
+function response(content: string, totalTokens: number | null = 321) {
+ return {
+ choices: [{ message: { content } }],
+ ...(totalTokens === null ? {} : { usage: { total_tokens: totalTokens } }),
+ };
+}
+
+beforeEach(() => {
+ mocks.clientOptions.length = 0;
+ mocks.create.mockReset().mockResolvedValue(response("answer"));
+ mocks.reserve.mockReset().mockResolvedValue(reservation);
+ mocks.settle.mockReset().mockResolvedValue({ chargedTokens: 321 });
+});
+
+describe("budgeted root LLM dispatch", () => {
+ test("rejects structured output that parses but fails its semantic schema", async () => {
+ mocks.create
+ .mockResolvedValueOnce(response('{"ok":"yes"}', 100))
+ .mockResolvedValueOnce(response('{"ok":2}', 101))
+ .mockResolvedValueOnce(response('{"ok":1}', 102));
+ mocks.reserve
+ .mockResolvedValueOnce({ ...reservation, reservationId: "20000000-0000-4000-8000-000000000001" })
+ .mockResolvedValueOnce({ ...reservation, reservationId: "20000000-0000-4000-8000-000000000002" })
+ .mockResolvedValueOnce({ ...reservation, reservationId: "20000000-0000-4000-8000-000000000003" });
+
+ await expect(
+ run(() =>
+ completeJSON({
+ model: MODELS.rank,
+ policy: "root_rank",
+ system: "return json",
+ user: "user",
+ schema: z.object({ ok: z.boolean() }),
+ }),
+ ),
+ ).rejects.toMatchObject({ code: "LLM_PROVIDER_INVALID" });
+ expect(mocks.create).toHaveBeenCalledTimes(3);
+ expect(mocks.settle).toHaveBeenCalledTimes(3);
+ });
+
+ test("reserves before one no-hidden-retry provider attempt and settles before returning", async () => {
+ const events: string[] = [];
+ mocks.reserve.mockImplementationOnce(async () => {
+ events.push("reserve");
+ return reservation;
+ });
+ mocks.create.mockImplementationOnce(async () => {
+ events.push("provider");
+ return response("answer", 321);
+ });
+ mocks.settle.mockImplementationOnce(async () => {
+ events.push("settle");
+ return { chargedTokens: 321 };
+ });
+
+ await expect(
+ run(() =>
+ complete({
+ model: MODELS.rank,
+ policy: "root_rank",
+ system: "system",
+ user: "user",
+ maxTokens: 2_000,
+ }),
+ ),
+ ).resolves.toBe("answer");
+
+ expect(events).toEqual(["reserve", "provider", "settle"]);
+ expect(mocks.reserve).toHaveBeenCalledTimes(1);
+ const [policy, requestId, reservedTokens] = mocks.reserve.mock.calls[0];
+ expect(policy).toBe("root_rank");
+ expect(requestId).toMatch(
+ /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,
+ );
+ expect(reservedTokens).toEqual(expect.any(Number));
+ expect(reservedTokens).toBeGreaterThanOrEqual(2_000 + Buffer.byteLength("systemuser"));
+ expect(reservedTokens).toBeLessThanOrEqual(65_536);
+ expect(mocks.create).toHaveBeenCalledTimes(1);
+ expect(mocks.settle).toHaveBeenCalledWith(
+ expect.objectContaining({ reservationId: reservation.reservationId }),
+ 321,
+ );
+ expect(mocks.clientOptions[0]).toMatchObject({ maxRetries: 0 });
+ expect(mocks.clientOptions[0]).toHaveProperty("timeout");
+ });
+
+ test("passes a caller abort signal to the provider and does not reserve after abort", async () => {
+ const controller = new AbortController();
+ controller.abort();
+ await expect(
+ run(() =>
+ complete({
+ model: MODELS.rank,
+ policy: "root_rank",
+ system: "system",
+ user: "user",
+ signal: controller.signal,
+ }),
+ ),
+ ).rejects.toMatchObject({ code: "LLM_PROVIDER_REQUEST_FAILED" });
+ expect(mocks.reserve).not.toHaveBeenCalled();
+ expect(mocks.create).not.toHaveBeenCalled();
+ });
+
+ test("does not reach the provider when the database budget is exhausted", async () => {
+ mocks.reserve.mockResolvedValueOnce({ allowed: false, retryAfter: 3_600 });
+
+ await expect(
+ run(() =>
+ complete({
+ model: MODELS.rank,
+ policy: "root_rank",
+ system: "system",
+ user: "user",
+ }),
+ ),
+ ).rejects.toMatchObject({ code: "LLM_BUDGET_EXHAUSTED", retryAfter: 3_600 });
+ expect(mocks.create).not.toHaveBeenCalled();
+ expect(mocks.settle).not.toHaveBeenCalled();
+ });
+
+ test("validates provider configuration before consuming a budget reservation", async () => {
+ await expect(
+ withRuntimeEnvironment({}, () =>
+ complete({
+ model: MODELS.rank,
+ policy: "root_rank",
+ system: "system",
+ user: "user",
+ }),
+ ),
+ ).rejects.toThrow("DEEPSEEK_API_KEY");
+ expect(mocks.reserve).not.toHaveBeenCalled();
+ expect(mocks.create).not.toHaveBeenCalled();
+ });
+
+ test("full-charges a failed provider attempt and exposes no provider detail", async () => {
+ mocks.create.mockRejectedValueOnce(
+ new Error("secret upstream https://api.deepseek.com?token=private"),
+ );
+ mocks.settle.mockResolvedValueOnce({ chargedTokens: reservation.reservedTokens });
+
+ let error: unknown;
+ try {
+ await run(() =>
+ complete({
+ model: MODELS.rank,
+ policy: "root_rank",
+ system: "system",
+ user: "user",
+ }),
+ );
+ } catch (caught) {
+ error = caught;
+ }
+ expect(error).toBeInstanceOf(LLMOperationError);
+ expect(String(error)).toBe("LLMOperationError: LLM provider request failed");
+ expect(String(error)).not.toMatch(/deepseek|private|secret upstream/i);
+ expect(mocks.settle).toHaveBeenCalledWith(
+ expect.objectContaining({ reservationId: reservation.reservationId }),
+ null,
+ );
+ });
+
+ test("full-charges unknown usage without silently skipping settlement", async () => {
+ mocks.create.mockResolvedValueOnce(response("answer", null));
+ mocks.settle.mockResolvedValueOnce({ chargedTokens: reservation.reservedTokens });
+
+ await expect(
+ run(() =>
+ complete({
+ model: MODELS.summarize,
+ policy: "root_summary",
+ system: "system",
+ user: "user",
+ }),
+ ),
+ ).resolves.toBe("answer");
+ expect(mocks.settle).toHaveBeenCalledWith(expect.any(Object), null);
+ });
+
+ test("full-charges a malformed provider envelope without stranding the reservation", async () => {
+ mocks.create.mockResolvedValueOnce({ choices: null });
+ mocks.settle.mockResolvedValueOnce({ chargedTokens: reservation.reservedTokens });
+
+ await expect(
+ run(() =>
+ complete({
+ model: MODELS.rank,
+ policy: "root_rank",
+ system: "system",
+ user: "user",
+ }),
+ ),
+ ).rejects.toMatchObject({ code: "LLM_PROVIDER_INVALID" });
+ expect(mocks.settle).toHaveBeenCalledWith(expect.any(Object), null);
+ });
+
+ test("rejects impossible provider usage after full-charge", async () => {
+ mocks.create.mockResolvedValueOnce(response("answer", reservation.reservedTokens + 1));
+ mocks.settle.mockResolvedValueOnce({ chargedTokens: reservation.reservedTokens });
+
+ await expect(
+ run(() =>
+ complete({
+ model: MODELS.rank,
+ policy: "root_rank",
+ system: "system",
+ user: "user",
+ }),
+ ),
+ ).rejects.toMatchObject({ code: "LLM_PROVIDER_INVALID" });
+ expect(mocks.settle).toHaveBeenCalledWith(expect.any(Object), null);
+ });
+
+ test("does not use a provider result when budget settlement fails", async () => {
+ mocks.settle.mockRejectedValueOnce(new Error("private database detail"));
+
+ await expect(
+ run(() =>
+ complete({
+ model: MODELS.rank,
+ policy: "root_rank",
+ system: "system",
+ user: "user",
+ }),
+ ),
+ ).rejects.toMatchObject({ code: "LLM_BUDGET_UNAVAILABLE" });
+ });
+
+ test("rejects an oversized dispatch before reserving or calling the provider", async () => {
+ await expect(
+ run(() =>
+ complete({
+ model: MODELS.rank,
+ policy: "root_rank",
+ system: "system",
+ user: "x".repeat(70_000),
+ }),
+ ),
+ ).rejects.toMatchObject({ code: "LLM_INPUT_TOO_LARGE" });
+ expect(mocks.reserve).not.toHaveBeenCalled();
+ expect(mocks.create).not.toHaveBeenCalled();
+ });
+
+ test("budgets and settles every explicit invalid-JSON retry", async () => {
+ mocks.create
+ .mockResolvedValueOnce(response("not json", 100))
+ .mockResolvedValueOnce(response("still not json", 101))
+ .mockResolvedValueOnce(response('{"ok":true}', 102));
+ mocks.reserve
+ .mockResolvedValueOnce({ ...reservation, reservationId: "20000000-0000-4000-8000-000000000001" })
+ .mockResolvedValueOnce({ ...reservation, reservationId: "20000000-0000-4000-8000-000000000002" })
+ .mockResolvedValueOnce({ ...reservation, reservationId: "20000000-0000-4000-8000-000000000003" });
+ mocks.settle
+ .mockResolvedValueOnce({ chargedTokens: 100 })
+ .mockResolvedValueOnce({ chargedTokens: 101 })
+ .mockResolvedValueOnce({ chargedTokens: 102 });
+
+ await expect(
+ run(() =>
+ completeJSON<{ ok: boolean }>({
+ model: MODELS.rank,
+ policy: "root_rank",
+ system: "return json",
+ user: "user",
+ }),
+ ),
+ ).resolves.toEqual({ ok: true });
+ expect(mocks.reserve).toHaveBeenCalledTimes(3);
+ expect(mocks.create).toHaveBeenCalledTimes(3);
+ expect(mocks.settle).toHaveBeenCalledTimes(3);
+ expect(mocks.settle.mock.calls.map((call) => call[1])).toEqual([100, 101, 102]);
+ });
+});
diff --git a/lib/llm.ts b/lib/llm.ts
index a0fcc4b..5ba66da 100644
--- a/lib/llm.ts
+++ b/lib/llm.ts
@@ -1,5 +1,14 @@
// LLM 封装 —— DeepSeek（OpenAI 兼容协议）。动态/惰性 import，使 `--dry` 路径无需配置密钥。
+import { randomUUID } from "node:crypto";
import OpenAI from "openai";
+import { z } from "zod";
+import {
+ reserveRootLLMBudget,
+ settleRootLLMBudget,
+ type RootLLMPolicy,
+} from "./llm-budget.ts";
+import { loadDeepSeekConfig } from "./runtime-config.ts";
+import { currentRuntimeEnvironment } from "./runtime-env.ts";
// deepseek-chat = DeepSeek-V3（通用）；如需更强推理可换 deepseek-reasoner（更慢/不支持 json 模式）。
export const MODELS = {
@@ -7,56 +16,214 @@ export const MODELS = {
summarize: "deepseek-chat",
} as const;
-let client: OpenAI | null = null;
+const clients = new WeakMap();
+const MAX_DISPATCH_TOKENS = 65_536;
+const DEFAULT_MAX_TOKENS = 4_096;
+const PROVIDER_TIMEOUT_MS = 45_000;
+const STRUCTURED_OUTPUT_DEADLINE_MS = 120_000;
+
+export type LLMOperationErrorCode =
+ | "LLM_BUDGET_EXHAUSTED"
+ | "LLM_BUDGET_UNAVAILABLE"
+ | "LLM_INPUT_TOO_LARGE"
+ | "LLM_PROVIDER_INVALID"
+ | "LLM_PROVIDER_REQUEST_FAILED";
+
+export class LLMOperationError extends Error {
+ readonly code: LLMOperationErrorCode;
+ readonly retryAfter?: number;
+
+ constructor(code: LLMOperationErrorCode, message: string, retryAfter?: number) {
+ super(message);
+ this.name = "LLMOperationError";
+ this.code = code;
+ if (retryAfter !== undefined) this.retryAfter = retryAfter;
+ }
+}
function getClient(): OpenAI {
- if (client) return client;
- const key = process.env.DEEPSEEK_API_KEY;
- if (!key) throw new Error("缺少 DEEPSEEK_API_KEY（见 .env.example）");
- client = new OpenAI({ apiKey: key, baseURL: "https://api.deepseek.com" });
+ const environment = currentRuntimeEnvironment();
+ const existing = clients.get(environment);
+ if (existing) return existing;
+ const config = loadDeepSeekConfig(environment);
+ // SDK retries are disabled because every physical provider attempt needs its
+ // own database reservation. JSON retries below are explicit and budgeted.
+ const client = new OpenAI({
+ apiKey: config.apiKey,
+ baseURL: config.baseURL,
+ maxRetries: 0,
+ timeout: PROVIDER_TIMEOUT_MS,
+ });
+ clients.set(environment, client);
return client;
}
+function reservationUpperBound(system: string, user: string, maxTokens: number): number {
+ if (!Number.isInteger(maxTokens) || maxTokens < 1 || maxTokens > MAX_DISPATCH_TOKENS) {
+ throw new LLMOperationError("LLM_INPUT_TOO_LARGE", "LLM dispatch is too large");
+ }
+ // UTF-8 bytes are a conservative upper bound for input tokens. The fixed
+ // allowance covers message framing and provider-side tokenization overhead.
+ const estimate =
+ Buffer.byteLength(system, "utf8") +
+ Buffer.byteLength(user, "utf8") +
+ maxTokens +
+ 4_096 +
+ 256;
+ if (!Number.isSafeInteger(estimate) || estimate > MAX_DISPATCH_TOKENS) {
+ throw new LLMOperationError("LLM_INPUT_TOO_LARGE", "LLM dispatch is too large");
+ }
+ return estimate;
+}
+
+async function settleOrFail(
+ reservation: Parameters[0],
+ actualTokens: number | null,
+): Promise {
+ try {
+ await settleRootLLMBudget(reservation, actualTokens);
+ } catch {
+ throw new LLMOperationError(
+ "LLM_BUDGET_UNAVAILABLE",
+ "LLM budget settlement unavailable",
+ );
+ }
+}
+
/** 文本补全。 */
export async function complete(opts: {
model: string;
+ policy: RootLLMPolicy;
system: string;
user: string;
maxTokens?: number;
json?: boolean;
+ signal?: AbortSignal;
}): Promise {
- const res = await getClient().chat.completions.create({
- model: opts.model,
- max_tokens: opts.maxTokens ?? 4096,
- messages: [
- { role: "system", content: opts.system },
- { role: "user", content: opts.user },
- ],
- // DeepSeek JSON 模式：要求 prompt 内含 "json" 字样（本项目 prompt 已满足）。
- ...(opts.json ? { response_format: { type: "json_object" as const } } : {}),
- });
- return res.choices[0]?.message?.content ?? "";
+ const maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
+ const reservedTokens = reservationUpperBound(opts.system, opts.user, maxTokens);
+ if (opts.signal?.aborted) {
+ throw new LLMOperationError("LLM_PROVIDER_REQUEST_FAILED", "LLM provider request failed");
+ }
+ // Validate and construct the non-I/O provider client before charging the
+ // daily ledger. A local configuration error must not strand a reservation.
+ const client = getClient();
+ let reservation;
+ try {
+ const result = await reserveRootLLMBudget(opts.policy, randomUUID(), reservedTokens);
+ if (!result.allowed) {
+ throw new LLMOperationError(
+ "LLM_BUDGET_EXHAUSTED",
+ "LLM daily budget exhausted",
+ result.retryAfter,
+ );
+ }
+ reservation = result;
+ } catch (error) {
+ if (error instanceof LLMOperationError) throw error;
+ throw new LLMOperationError(
+ "LLM_BUDGET_UNAVAILABLE",
+ "LLM budget reservation unavailable",
+ );
+ }
+
+ let response;
+ try {
+ response = await client.chat.completions.create(
+ {
+ model: opts.model,
+ max_tokens: maxTokens,
+ messages: [
+ { role: "system", content: opts.system },
+ { role: "user", content: opts.user },
+ ],
+ // DeepSeek JSON 模式：要求 prompt 内含 "json" 字样（本项目 prompt 已满足）。
+ ...(opts.json ? { response_format: { type: "json_object" as const } } : {}),
+ },
+ opts.signal ? { signal: opts.signal } : undefined,
+ );
+ } catch {
+ await settleOrFail(reservation, null);
+ throw new LLMOperationError(
+ "LLM_PROVIDER_REQUEST_FAILED",
+ "LLM provider request failed",
+ );
+ }
+
+ const firstChoice =
+ response !== null &&
+ typeof response === "object" &&
+ Array.isArray(response.choices)
+ ? response.choices[0]
+ : undefined;
+ const content =
+ firstChoice !== null && typeof firstChoice === "object"
+ ? firstChoice.message?.content
+ : undefined;
+ if (typeof content !== "string") {
+ await settleOrFail(reservation, null);
+ throw new LLMOperationError("LLM_PROVIDER_INVALID", "LLM provider response is invalid");
+ }
+
+ const usage = response.usage?.total_tokens;
+ if (usage === undefined) {
+ await settleOrFail(reservation, null);
+ } else if (
+ !Number.isInteger(usage) ||
+ usage < 1 ||
+ usage > reservation.reservedTokens
+ ) {
+ await settleOrFail(reservation, null);
+ throw new LLMOperationError("LLM_PROVIDER_INVALID", "LLM provider response is invalid");
+ } else {
+ await settleOrFail(reservation, usage);
+ }
+ return content;
}
/** 期望 JSON 对象输出：用 JSON 模式，解析后返回。 */
export async function completeJSON(opts: {
model: string;
+ policy: RootLLMPolicy;
system: string;
user: string;
maxTokens?: number;
+ schema?: z.ZodType;
+ deadlineMs?: number;
+ signal?: AbortSignal;
}): Promise {
+ const deadlineMs = opts.deadlineMs ?? STRUCTURED_OUTPUT_DEADLINE_MS;
+ if (!Number.isInteger(deadlineMs) || deadlineMs < 1 || deadlineMs > 300_000) {
+ throw new LLMOperationError("LLM_INPUT_TOO_LARGE", "LLM structured output deadline is invalid");
+ }
+ const controller = new AbortController();
+ const abort = () => controller.abort();
+ if (opts.signal?.aborted) abort();
+ else opts.signal?.addEventListener("abort", abort, { once: true });
+ const timeout = setTimeout(abort, deadlineMs);
// DeepSeek 偶尔返回非 JSON / 截断 → 重试至多 3 次，避免单次抖动让整条夜跑失败。
- let last = "";
- for (let attempt = 0; attempt < 3; attempt++) {
- const text = await complete({ ...opts, json: true });
- last = text;
- const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/);
- const raw = fenced ? fenced[1] : text.slice(text.search(/[[{]/));
- try {
- return JSON.parse(raw) as T;
- } catch {
- /* 重试 */
+ try {
+ for (let attempt = 0; attempt < 3; attempt++) {
+ if (controller.signal.aborted) {
+ throw new LLMOperationError("LLM_PROVIDER_REQUEST_FAILED", "LLM provider request failed");
+ }
+ const text = await complete({ ...opts, json: true, signal: controller.signal });
+ const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+ const firstJson = text.search(/(?:\[|\{)/);
+ const raw = fenced?.[1] ?? (firstJson >= 0 ? text.slice(firstJson) : "");
+ try {
+ const parsed: unknown = JSON.parse(raw);
+ return opts.schema ? opts.schema.parse(parsed) : (parsed as T);
+ } catch {
+ /* 重试 */
+ }
}
+ throw new LLMOperationError(
+ "LLM_PROVIDER_INVALID",
+ "LLM provider returned invalid structured output",
+ );
+ } finally {
+ clearTimeout(timeout);
+ opts.signal?.removeEventListener("abort", abort);
}
- throw new Error(`DeepSeek 未返回可解析 JSON（重试 3 次后）：\n${last.slice(0, 500)}`);
}
diff --git a/lib/normalize.test.ts b/lib/normalize.test.ts
index ac106a0..c092fd8 100644
--- a/lib/normalize.test.ts
+++ b/lib/normalize.test.ts
@@ -1,6 +1,5 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { dedupKey, normalizeTitle, titleHash, dedupe } from "./normalize.ts";
+import { expect, test } from "vitest";
+import { canonicalWorkKey, dedupKey, normalizeTitle, normalizeWorkUrl, titleHash, dedupe } from "./normalize.ts";
import type { NormalizedItem } from "./types.ts";
const mk = (over: Partial): NormalizedItem => ({
@@ -16,20 +15,17 @@ const mk = (over: Partial): NormalizedItem => ({
});
test("dedupKey combines source + externalId", () => {
- assert.equal(dedupKey({ source: "arxiv", externalId: "2406.1" }), "arxiv:2406.1");
+ expect(dedupKey({ source: "arxiv", externalId: "2406.1" })).toBe("arxiv:2406.1");
});
test("normalizeTitle ignores case, punctuation, whitespace", () => {
- assert.equal(normalizeTitle("Attention Is All You Need!"), "attention is all you need");
- assert.equal(
- normalizeTitle(" Attention, is\nall you need "),
- "attention is all you need",
- );
+ expect(normalizeTitle("Attention Is All You Need!")).toBe("attention is all you need");
+ expect(normalizeTitle(" Attention, is\nall you need ")).toBe("attention is all you need");
});
test("titleHash equal for punctuation/case variants, different for different titles", () => {
- assert.equal(titleHash("Attention Is All You Need"), titleHash("attention is all you need!"));
- assert.notEqual(titleHash("Paper A"), titleHash("Paper B"));
+ expect(titleHash("Attention Is All You Need")).toBe(titleHash("attention is all you need!"));
+ expect(titleHash("Paper A")).not.toBe(titleHash("Paper B"));
});
test("dedupe merges same paper across sources and unions signals", () => {
@@ -39,12 +35,160 @@ test("dedupe merges same paper across sources and unions signals", () => {
mk({ source: "github", externalId: "999", title: "Unrelated Repo", signals: { stars: 5 } }),
];
const out = dedupe(items);
- assert.equal(out.length, 2, "two distinct papers remain");
+ expect(out, "two distinct papers remain").toHaveLength(2);
const merged = out.find((i) => titleHash(i.title) === titleHash("Cool LLM Paper"))!;
- assert.equal(merged.abstract, "long abstract here", "keeps the richer abstract");
- assert.equal(merged.signals.upvotes, 99, "carries HF upvotes onto the merged row");
+ expect(merged.abstract, "keeps the richer abstract").toBe("long abstract here");
+ expect(merged.signals.upvotes, "carries HF upvotes onto the merged row").toBe(99);
});
test("dedupe drops empty-title items", () => {
- assert.equal(dedupe([mk({ title: " " })]).length, 0);
+ expect(dedupe([mk({ title: " " })])).toHaveLength(0);
+});
+
+test("canonical work identity prefers arXiv/DOI IDs and strips tracking URLs", () => {
+ expect(canonicalWorkKey(mk({ source: "huggingface", externalId: "2406.12345v2" }))).toBe("arxiv:2406.12345");
+ expect(canonicalWorkKey(mk({ source: "blog", externalId: "entry", url: "https://doi.org/10.1234/ABC?utm_source=x" }))).toBe("doi:10.1234/abc");
+ expect(canonicalWorkKey(mk({ source: "blog", externalId: "entry", url: "https://openreview.net/forum?id=AbC" }))).toBe("openreview:AbC");
+ expect(canonicalWorkKey(mk({ source: "blog", externalId: "entry", url: "https://aclanthology.org/2024.acl-long.1/" }))).toBe("acl:2024.acl-long.1");
+ expect(normalizeWorkUrl("http://Example.COM/paper/?utm_campaign=test#section")).toBe("https://example.com/paper");
+});
+
+test("canonical URL identities preserve encoded bytes and normalize the default HTTPS port", () => {
+ expect(canonicalWorkKey(mk({
+ source: "blog",
+ externalId: "entry",
+ url: "https://openreview.net/forum?id=Ab%2FC",
+ }))).toBe("openreview:Ab%2FC");
+ expect(canonicalWorkKey(mk({
+ source: "blog",
+ externalId: "entry",
+ url: "https://openreview.net:443/forum?id=AbC",
+ }))).toBe("openreview:AbC");
+ expect(canonicalWorkKey(mk({
+ source: "blog",
+ externalId: "entry",
+ url: "https://doi.org/10.1234/AB%2FC",
+ }))).toBe("doi:10.1234/ab%2fc");
+});
+
+test("canonical identity only removes arXiv versions and never throws on malformed URL escapes", () => {
+ expect(canonicalWorkKey(mk({ source: "blog", externalId: "releasev2", url: "https://example.com/release-v2" }))).toBe("blog:releasev2");
+ expect(() => canonicalWorkKey(mk({
+ source: "openreview",
+ externalId: "bad%id",
+ url: "https://openreview.net/forum?id=bad%id",
+ }))).not.toThrow();
+});
+
+test("canonical identity trusts provider hosts instead of lookalike hostnames or coincidental IDs", () => {
+ expect(canonicalWorkKey(mk({
+ source: "blog",
+ externalId: "2406.12345v2",
+ url: "https://example.com/posts/2406.12345v2",
+ }))).toBe("blog:2406.12345v2");
+ expect(canonicalWorkKey(mk({
+ source: "blog",
+ externalId: "entry",
+ url: "https://evilopenreview.net/forum?id=AbC",
+ }))).toBe("blog:entry");
+ expect(canonicalWorkKey(mk({
+ source: "blog",
+ externalId: "entry",
+ url: "https://notaclanthology.org/2024.acl-long.1/",
+ }))).toBe("blog:entry");
+ expect(canonicalWorkKey(mk({
+ source: "blog",
+ externalId: "2406.12345v2",
+ url: "https://arxiv.org/abs/2406.12345v2",
+ }))).toBe("blog:2406.12345v2");
+});
+
+test("opaque source IDs remain stable when publisher metadata changes", () => {
+ const first = canonicalWorkKey(mk({
+ source: "blog",
+ externalId: "https://example.com/posts/stable-guid",
+ title: "Original title",
+ authors: ["Alice"],
+ }));
+ const revised = canonicalWorkKey(mk({
+ source: "blog",
+ externalId: "https://example.com/posts/stable-guid",
+ title: "Publisher revised the title",
+ authors: ["Bob"],
+ }));
+ expect(first).toMatch(/^blog:id:[a-f0-9]{64}$/);
+ expect(revised).toBe(first);
+});
+
+test("source-local IDs preserve case instead of collapsing case-sensitive identities", () => {
+ expect(canonicalWorkKey(mk({ source: "github", externalId: "Owner/Repo" })))
+ .not.toBe(canonicalWorkKey(mk({ source: "github", externalId: "owner/repo" })));
+});
+
+test("canonical source normalization matches the database contract", () => {
+ expect(canonicalWorkKey(mk({ source: " Blog " as NormalizedItem["source"], externalId: "stable-id" })))
+ .toBe("blog:stable-id");
+ expect(canonicalWorkKey(mk({ source: "Blog Source" as NormalizedItem["source"], externalId: "stable-id" })))
+ .toMatch(/^source:id:[a-f0-9]{64}$/);
+});
+
+test("dedupe retains source observations when providers expose the same work", () => {
+ const [merged] = dedupe([
+ mk({ source: "arxiv", externalId: "2406.12345", url: "https://arxiv.org/abs/2406.12345", title: "Same Work" }),
+ mk({ source: "huggingface", externalId: "2406.12345", url: "https://huggingface.co/papers/2406.12345", title: "Same Work" }),
+ ]);
+ expect(merged.provenance).toEqual([
+ { source: "arxiv", externalId: "2406.12345", url: "https://arxiv.org/abs/2406.12345", signals: {} },
+ { source: "huggingface", externalId: "2406.12345", url: "https://huggingface.co/papers/2406.12345", signals: {} },
+ ]);
+});
+
+test("dedupe keeps the latest same-source observation and identity despite URL drift", () => {
+ const [merged] = dedupe([
+ mk({
+ source: "blog",
+ externalId: "stable-entry",
+ url: "https://example.com/stable-entry",
+ title: "Stable entry",
+ provenance: [{
+ source: "blog",
+ externalId: "stable-entry",
+ url: "https://example.com/stable-entry",
+ signals: { views: 1 },
+ }],
+ }),
+ mk({
+ source: "blog",
+ externalId: "stable-entry",
+ url: "https://doi.org/10.1234/stable-entry",
+ title: "Stable entry DOI",
+ provenance: [{
+ source: "blog",
+ externalId: "stable-entry",
+ url: "https://doi.org/10.1234/stable-entry",
+ signals: { views: 2 },
+ }],
+ }),
+ ]);
+ expect(dedupe([
+ mk({ source: "blog", externalId: "stable-entry", url: "https://example.com/stable-entry" }),
+ mk({ source: "blog", externalId: "stable-entry", url: "https://doi.org/10.1234/stable-entry" }),
+ ])).toHaveLength(1);
+ expect(merged.provenance).toEqual([{
+ source: "blog",
+ externalId: "stable-entry",
+ url: "https://doi.org/10.1234/stable-entry",
+ signals: { views: 2 },
+ }]);
+});
+
+test("dedupe drops one oversized source identity before it can abort a bulk upsert", () => {
+ const valid = mk({ source: "blog", externalId: "valid", url: "https://example.com/valid", title: "Valid" });
+ const oversized = mk({
+ source: "blog",
+ externalId: "x".repeat(513),
+ url: "https://example.com/oversized",
+ title: "Oversized",
+ });
+ expect(dedupe([oversized, valid])).toEqual([expect.objectContaining({ externalId: "valid" })]);
});
diff --git a/lib/normalize.ts b/lib/normalize.ts
index 0c87f77..90d13c2 100644
--- a/lib/normalize.ts
+++ b/lib/normalize.ts
@@ -1,5 +1,5 @@
import crypto from "node:crypto";
-import type { NormalizedItem } from "./types.ts";
+import type { NormalizedItem, SourceObservation } from "./types.ts";
export const toArray = (x: T | T[] | null | undefined): T[] =>
Array.isArray(x) ? x : x == null ? [] : [x];
@@ -21,26 +21,153 @@ export function normalizeTitle(t: string): string {
export const titleHash = (title: string): string =>
crypto.createHash("sha1").update(normalizeTitle(title)).digest("hex").slice(0, 12);
+/** Normalize a public work URL without throwing away the work identity. */
+export function normalizeWorkUrl(value: string): string {
+ try {
+ const url = new URL(value.trim());
+ if (!/^https?:$/.test(url.protocol)) return "";
+ url.protocol = "https:";
+ url.hostname = url.hostname.toLowerCase();
+ url.hash = "";
+ for (const key of [...url.searchParams.keys()]) {
+ if (/^(utm_|fbclid$|gclid$|ref$|source$)/i.test(key)) url.searchParams.delete(key);
+ }
+ url.pathname = url.pathname.replace(/\/+$/, "") || "/";
+ return url.toString();
+ } catch {
+ return "";
+ }
+}
+
+export function sourceIdentityHash(source: string, externalId: string): string {
+ return crypto
+ .createHash("sha256")
+ .update(`${source.trim().toLowerCase()}\u001f${externalId.trim()}`)
+ .digest("hex");
+}
+
+/** Cross-provider identity: stable public IDs first, stable source identity last. */
+export function canonicalWorkKey(item: Pick): string {
+ const source = item.source.trim().toLowerCase();
+ const externalId = item.externalId.trim();
+ const lowerExternalId = externalId.toLowerCase();
+ const arxivId = lowerExternalId.replace(/v\d+$/, "");
+ const url = normalizeWorkUrl(item.url);
+ let parsedURL: URL | undefined;
+ try {
+ parsedURL = url ? new URL(url) : undefined;
+ } catch {
+ parsedURL = undefined;
+ }
+ const hostname = parsedURL?.hostname.replace(/^www\./, "") ?? "";
+ const trustedArxivIdentity = source === "arxiv" || source === "huggingface";
+ if (trustedArxivIdentity && /^(?:\d{4}\.\d{1,5}|[a-z][a-z0-9.-]*\/\d{7})$/.test(arxivId)) {
+ return `arxiv:${arxivId}`;
+ }
+ // URLSearchParams.get() decodes percent-encoded bytes. Keep the encoded form
+ // so the browser/runtime and PostgreSQL derive the same durable identity.
+ const openReview = hostname === "openreview.net"
+ ? url.match(/[?&]id=([^&#]+)/i)?.[1]
+ : undefined;
+ if (openReview) return `openreview:${openReview}`;
+ const acl = hostname === "aclanthology.org" ? parsedURL?.pathname.split("/").filter(Boolean)[0] : undefined;
+ if (acl) return `acl:${acl.toLowerCase()}`;
+ const doi = hostname === "doi.org" ? parsedURL?.pathname.replace(/^\//, "").match(/^(10\.\d{4,9}\/.+)$/i)?.[1] : undefined;
+ if (doi) return `doi:${doi.toLowerCase()}`;
+ if (/^[a-z0-9._-]+$/.test(source) && Buffer.byteLength(source, "utf8") <= 64
+ && Buffer.byteLength(externalId, "utf8") >= 3
+ && Buffer.byteLength(externalId, "utf8") <= 256
+ && /^[a-z0-9._/-]+$/i.test(externalId)) {
+ return `${source}:${externalId}`;
+ }
+ const prefix = /^[a-z0-9._-]+$/.test(source) && Buffer.byteLength(source, "utf8") <= 64
+ ? source
+ : "source";
+ return `${prefix}:id:${sourceIdentityHash(source, externalId)}`;
+}
+
+/** Match the database provenance limits before one malformed source can abort a batch. */
+export function hasBoundedSourceIdentity(
+ item: Pick,
+): boolean {
+ const sourceBytes = Buffer.byteLength(item.source.trim(), "utf8");
+ const externalIdBytes = Buffer.byteLength(item.externalId.trim(), "utf8");
+ return item.source === item.source.trim().toLowerCase()
+ && /^[a-z0-9._-]+$/.test(item.source)
+ && sourceBytes >= 1
+ && sourceBytes <= 64
+ && externalIdBytes >= 1
+ && externalIdBytes <= 512;
+}
+
function merge(a: NormalizedItem, b: NormalizedItem): NormalizedItem {
// 保留摘要更长的一条为主，合并双方 signals（保留各自数值信号如 upvotes/stars）。
const primary = (b.abstract?.length ?? 0) > (a.abstract?.length ?? 0) ? b : a;
const other = primary === a ? b : a;
+ const observations = [...(a.provenance ?? []), ...(b.provenance ?? [])];
+ const latestObservations = new Map();
+ for (const observation of observations) {
+ latestObservations.set(sourceIdentityHash(observation.source, observation.externalId), observation);
+ }
return {
...primary,
abstract: primary.abstract || other.abstract,
content: primary.content || other.content,
signals: { ...other.signals, ...primary.signals, mergedFrom: `${a.source}+${b.source}` },
+ provenance: [...latestObservations.values()],
};
}
/** 跨源 + 源内去重：标题相同视为同一篇，合并信号。 */
-export function dedupe(items: NormalizedItem[]): NormalizedItem[] {
- const byTitle = new Map();
+export function dedupe(
+ items: NormalizedItem[],
+ onDiscard?: (item: NormalizedItem, reason: "empty_title" | "invalid_source_identity") => void,
+): NormalizedItem[] {
+ type Group = { item: NormalizedItem };
+ const byCanonical = new Map();
+ const bySourceIdentity = new Map();
+ const groups = new Set();
for (const it of items) {
- if (!it.title?.trim()) continue;
- const key = titleHash(it.title);
- const prev = byTitle.get(key);
- byTitle.set(key, prev ? merge(prev, it) : it);
+ if (!it.title?.trim()) {
+ onDiscard?.(it, "empty_title");
+ continue;
+ }
+ if (!hasBoundedSourceIdentity(it)) {
+ onDiscard?.(it, "invalid_source_identity");
+ continue;
+ }
+ const key = canonicalWorkKey(it);
+ const identity = sourceIdentityHash(it.source, it.externalId);
+ const observed: SourceObservation = {
+ source: it.source,
+ externalId: it.externalId,
+ url: normalizeWorkUrl(it.url) || it.url,
+ signals: it.signals,
+ };
+ const item = it.provenance?.length ? it : { ...it, provenance: [observed] };
+ const canonicalGroup = byCanonical.get(key);
+ const identityGroup = bySourceIdentity.get(identity);
+ let group = canonicalGroup ?? identityGroup;
+ if (!group) {
+ group = { item };
+ groups.add(group);
+ } else {
+ group.item = merge(group.item, item);
+ }
+
+ if (canonicalGroup && identityGroup && canonicalGroup !== identityGroup) {
+ canonicalGroup.item = merge(canonicalGroup.item, identityGroup.item);
+ groups.delete(identityGroup);
+ for (const [candidateKey, candidateGroup] of byCanonical) {
+ if (candidateGroup === identityGroup) byCanonical.set(candidateKey, canonicalGroup);
+ }
+ for (const [candidateIdentity, candidateGroup] of bySourceIdentity) {
+ if (candidateGroup === identityGroup) bySourceIdentity.set(candidateIdentity, canonicalGroup);
+ }
+ group = canonicalGroup;
+ }
+ byCanonical.set(key, group);
+ bySourceIdentity.set(identity, group);
}
- return [...byTitle.values()];
+ return [...groups].map((group) => group.item);
}
diff --git a/lib/outbox.test.ts b/lib/outbox.test.ts
new file mode 100644
index 0000000..8393266
--- /dev/null
+++ b/lib/outbox.test.ts
@@ -0,0 +1,135 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { withRuntimeEnvironment } from "./runtime-env.ts";
+
+const mocks = vi.hoisted(() => ({ rpc: vi.fn() }));
+vi.mock("./supabase.ts", () => ({ getClient: vi.fn(async () => ({ rpc: mocks.rpc })) }));
+
+import {
+ claimDeliveries,
+ claimDigestDeliveries,
+ enqueueDigestDeliveries,
+ finishDelivery,
+ requeueFailedDigestDeliveries,
+ retryAt,
+} from "./outbox.ts";
+
+const base = {
+ SERVERCHAN_SENDKEY: `SCT${"c".repeat(40)}`,
+ SUPABASE_SERVICE_ROLE_KEY: `sb_secret_${"s".repeat(40)}`,
+ SUPABASE_URL: "https://frontier.example.com",
+};
+
+beforeEach(() => {
+ mocks.rpc.mockReset().mockImplementation(async (name: string) => {
+ if (name === "claim_delivery" || name === "claim_digest_delivery") {
+ return { data: [], error: null };
+ }
+ if (name === "requeue_failed_deliveries") return { data: [], error: null };
+ return { data: [{ delivery_id: "00000000-0000-4000-8000-000000000001", delivery_status: "pending", inserted: true }], error: null };
+ });
+});
+
+describe("delivery outbox client", () => {
+ test("enqueues only configured providers", async () => {
+ await withRuntimeEnvironment(base, () => enqueueDigestDeliveries("Digest 2026-07-14", "# digest"));
+ expect(mocks.rpc).toHaveBeenCalledTimes(1);
+ expect(mocks.rpc).toHaveBeenCalledWith("enqueue_delivery", expect.objectContaining({
+ p_channel: "wechat",
+ p_provider_id: "serverchan",
+ p_digest_date: "2026-07-14",
+ }));
+ });
+
+ test("binds pipeline delivery enqueue to the active run owner", async () => {
+ const runId = "00000000-0000-4000-8000-000000000009";
+ await withRuntimeEnvironment(base, () =>
+ enqueueDigestDeliveries("Digest 2026-07-14", "# digest", base, runId),
+ );
+ expect(mocks.rpc).toHaveBeenCalledWith("enqueue_pipeline_delivery", expect.objectContaining({
+ p_digest_date: "2026-07-14",
+ p_run_id: runId,
+ }));
+ });
+
+ test("enqueues SMTP and ServerChan with the same bounded payload", async () => {
+ const env = {
+ ...base,
+ SMTP_HOST: "smtp.example.com",
+ SMTP_PORT: "465",
+ SMTP_SECURE: "true",
+ SMTP_USER: "mailer@example.com",
+ SMTP_PASS: "secret",
+ EMAIL_FROM: "mailer@example.com",
+ EMAIL_TO: "hgjly1206@163.com",
+ };
+ await withRuntimeEnvironment(env, () => enqueueDigestDeliveries("Digest 2026-07-14", "# digest"));
+ expect(mocks.rpc).toHaveBeenCalledTimes(2);
+ expect(mocks.rpc.mock.calls.map(([, payload]) => payload.p_channel).sort()).toEqual(["email", "wechat"]);
+ });
+
+ test("maps claims and validates worker identity", async () => {
+ mocks.rpc.mockImplementationOnce(async () => ({
+ data: [{
+ delivery_id: "00000000-0000-4000-8000-000000000001",
+ digest_date: "2026-07-14",
+ channel: "email",
+ provider_id: "smtp",
+ idempotency_key: "digest:2026-07-14:email",
+ payload: { title: "Digest", markdown: "# digest" },
+ attempts: 2,
+ lease_until: "2026-07-14T00:05:00Z",
+ }],
+ error: null,
+ }));
+ await expect(claimDeliveries("00000000-0000-4000-8000-000000000002")).resolves.toMatchObject([
+ { channel: "email", attempts: 2, payload: { title: "Digest" } },
+ ]);
+ await expect(claimDeliveries("not-a-uuid")).rejects.toThrow(/worker id/i);
+ });
+
+ test("requeues and claims only the requested digest and configured channels", async () => {
+ mocks.rpc
+ .mockResolvedValueOnce({
+ data: [{
+ attempts: 2,
+ channel: "wechat",
+ delivery_id: "00000000-0000-4000-8000-000000000001",
+ delivery_status: "pending",
+ requeue_count: 1,
+ }],
+ error: null,
+ })
+ .mockResolvedValueOnce({ data: [], error: null });
+ const workerId = "00000000-0000-4000-8000-000000000002";
+
+ await expect(requeueFailedDigestDeliveries("2026-07-14", base)).resolves.toBe(1);
+ await expect(claimDigestDeliveries("2026-07-14", workerId)).resolves.toEqual([]);
+
+ expect(mocks.rpc).toHaveBeenNthCalledWith(1, "requeue_failed_deliveries", {
+ p_channels: ["wechat"],
+ p_digest_date: "2026-07-14",
+ p_now: expect.any(String),
+ });
+ expect(mocks.rpc).toHaveBeenNthCalledWith(2, "claim_digest_delivery", {
+ p_digest_date: "2026-07-14",
+ p_limit: 10,
+ p_lease_seconds: 300,
+ p_now: expect.any(String),
+ p_worker_id: workerId,
+ });
+ });
+
+ test("finishes a leased delivery and bounds retry delay", async () => {
+ mocks.rpc.mockResolvedValueOnce({
+ data: [{ delivery_id: "00000000-0000-4000-8000-000000000001", delivery_status: "pending", attempts: 1 }],
+ error: null,
+ });
+ await expect(finishDelivery(
+ "00000000-0000-4000-8000-000000000001",
+ "00000000-0000-4000-8000-000000000002",
+ "retry",
+ { error: "temporary", nextAttemptAt: new Date("2026-07-14T00:01:00Z") },
+ )).resolves.toBe("pending");
+ expect(retryAt(100, 0).getTime()).toBe(6 * 60 * 60_000);
+ });
+});
diff --git a/lib/outbox.ts b/lib/outbox.ts
new file mode 100644
index 0000000..bfefe86
--- /dev/null
+++ b/lib/outbox.ts
@@ -0,0 +1,217 @@
+import { randomUUID } from "node:crypto";
+import { getClient } from "./supabase.ts";
+import { databaseData, isDatabaseUuid, assertDatabaseIntegrity } from "./db-result.ts";
+import { loadOptionalSMTPConfig } from "./runtime-config.ts";
+import { currentRuntimeEnvironment, type RuntimeEnvironment } from "./runtime-env.ts";
+
+export type DeliveryChannel = "email" | "wechat";
+
+export interface ClaimedDelivery {
+ readonly deliveryId: string;
+ readonly digestDate: string;
+ readonly channel: DeliveryChannel;
+ readonly providerId: "smtp" | "serverchan";
+ readonly idempotencyKey: string;
+ readonly payload: { title: string; markdown: string };
+ readonly attempts: number;
+}
+
+function row(value: unknown): Record {
+ assertDatabaseIntegrity("delivery.outbox", value !== null && typeof value === "object" && !Array.isArray(value));
+ return value as Record;
+}
+
+function oneRow(value: unknown): Record {
+ assertDatabaseIntegrity("delivery.outbox", Array.isArray(value) && value.length === 1);
+ return row(value[0]);
+}
+
+export function deliveryDateFromTitle(title: string): string {
+ const date = title.match(/\b(\d{4}-\d{2}-\d{2})\b/)?.[1];
+ if (!date) throw new Error("Delivery title must include an ISO digest date");
+ return date;
+}
+
+function validDigestDate(value: string): boolean {
+ if (!/^\d{4}-\d{2}-\d{2}$/.test(value) || value.startsWith("0000-")) return false;
+ const instant = new Date(`${value}T00:00:00.000Z`);
+ return Number.isFinite(instant.getTime()) && instant.toISOString().slice(0, 10) === value;
+}
+
+function configuredChannels(environment: RuntimeEnvironment): readonly DeliveryChannel[] {
+ return Object.freeze([
+ "wechat" as const,
+ ...(loadOptionalSMTPConfig(environment) ? ["email" as const] : []),
+ ]);
+}
+
+function payload(title: string, markdown: string): Record {
+ if (!title.trim() || Buffer.byteLength(title, "utf8") > 200 || !markdown.trim() || Buffer.byteLength(markdown, "utf8") > 1_048_576) {
+ throw new Error("Delivery payload is invalid");
+ }
+ return { title, markdown };
+}
+
+export async function enqueueDigestDeliveries(
+ title: string,
+ markdown: string,
+ environment: RuntimeEnvironment = currentRuntimeEnvironment(),
+ pipelineRunId?: string,
+): Promise {
+ if (pipelineRunId !== undefined && !isDatabaseUuid(pipelineRunId)) {
+ throw new Error("Pipeline run id is invalid");
+ }
+ const digestDate = deliveryDateFromTitle(title);
+ const message = payload(title, markdown);
+ const channels = configuredChannels(environment).map((channel) => [
+ channel,
+ channel === "email" ? "smtp" as const : "serverchan" as const,
+ ] as const);
+ const db = await getClient();
+ for (const [channel, providerId] of channels) {
+ const data = databaseData(
+ `delivery.enqueue.${channel}`,
+ await db.rpc(pipelineRunId ? "enqueue_pipeline_delivery" : "enqueue_delivery", {
+ p_channel: channel,
+ p_digest_date: digestDate,
+ p_idempotency_key: `digest:${digestDate}:${channel}`,
+ p_payload: message,
+ p_provider_id: providerId,
+ ...(pipelineRunId ? { p_run_id: pipelineRunId } : {}),
+ }),
+ );
+ const record = oneRow(data);
+ assertDatabaseIntegrity(
+ `delivery.enqueue.${channel}`,
+ isDatabaseUuid(record.delivery_id) &&
+ (record.delivery_status === "pending" || record.delivery_status === "in_flight" || record.delivery_status === "succeeded" || record.delivery_status === "failed") &&
+ typeof record.inserted === "boolean",
+ );
+ }
+}
+
+function parseClaimedDeliveries(operation: string, data: unknown): ClaimedDelivery[] {
+ assertDatabaseIntegrity(operation, Array.isArray(data));
+ return data.map((value) => {
+ const record = row(value);
+ const rawPayload = row(record.payload);
+ assertDatabaseIntegrity(
+ operation,
+ isDatabaseUuid(record.delivery_id) &&
+ /^\d{4}-\d{2}-\d{2}$/.test(String(record.digest_date)) &&
+ (record.channel === "email" || record.channel === "wechat") &&
+ (record.provider_id === "smtp" || record.provider_id === "serverchan") &&
+ typeof record.idempotency_key === "string" &&
+ typeof rawPayload.title === "string" &&
+ typeof rawPayload.markdown === "string" &&
+ typeof record.attempts === "number" &&
+ Number.isInteger(record.attempts) &&
+ record.attempts >= 1,
+ );
+ return {
+ deliveryId: record.delivery_id as string,
+ digestDate: record.digest_date as string,
+ channel: record.channel as DeliveryChannel,
+ providerId: record.provider_id as "smtp" | "serverchan",
+ idempotencyKey: record.idempotency_key as string,
+ payload: { title: rawPayload.title as string, markdown: rawPayload.markdown as string },
+ attempts: record.attempts as number,
+ };
+ });
+}
+
+export async function claimDeliveries(workerId: string = randomUUID()): Promise {
+ if (!isDatabaseUuid(workerId)) throw new Error("Delivery worker id is invalid");
+ const db = await getClient();
+ const data = databaseData(
+ "delivery.claim",
+ await db.rpc("claim_delivery", {
+ p_limit: 10,
+ p_lease_seconds: 300,
+ p_now: new Date().toISOString(),
+ p_worker_id: workerId,
+ }),
+ );
+ return parseClaimedDeliveries("delivery.claim", data);
+}
+
+export async function claimDigestDeliveries(
+ digestDate: string,
+ workerId: string = randomUUID(),
+): Promise {
+ if (!validDigestDate(digestDate) || !isDatabaseUuid(workerId)) {
+ throw new Error("Digest delivery identity is invalid");
+ }
+ const db = await getClient();
+ const data = databaseData(
+ "delivery.claimDigest",
+ await db.rpc("claim_digest_delivery", {
+ p_digest_date: digestDate,
+ p_limit: 10,
+ p_lease_seconds: 300,
+ p_now: new Date().toISOString(),
+ p_worker_id: workerId,
+ }),
+ );
+ return parseClaimedDeliveries("delivery.claimDigest", data);
+}
+
+export async function requeueFailedDigestDeliveries(
+ digestDate: string,
+ environment: RuntimeEnvironment = currentRuntimeEnvironment(),
+): Promise {
+ if (!validDigestDate(digestDate)) throw new Error("Digest delivery date is invalid");
+ const db = await getClient();
+ const data = databaseData(
+ "delivery.requeueFailed",
+ await db.rpc("requeue_failed_deliveries", {
+ p_channels: configuredChannels(environment),
+ p_digest_date: digestDate,
+ p_now: new Date().toISOString(),
+ }),
+ );
+ assertDatabaseIntegrity("delivery.requeueFailed", Array.isArray(data));
+ for (const value of data) {
+ const record = row(value);
+ assertDatabaseIntegrity(
+ "delivery.requeueFailed",
+ isDatabaseUuid(record.delivery_id) &&
+ (record.channel === "email" || record.channel === "wechat") &&
+ record.delivery_status === "pending" &&
+ Number.isInteger(record.attempts) &&
+ Number.isInteger(record.requeue_count) &&
+ (record.requeue_count as number) >= 1,
+ );
+ }
+ return data.length;
+}
+
+export async function finishDelivery(
+ deliveryId: string,
+ workerId: string,
+ outcome: "success" | "retry" | "permanent",
+ options: { providerMessageId?: string; error?: string; nextAttemptAt?: Date } = {},
+): Promise<"succeeded" | "pending" | "failed"> {
+ if (!isDatabaseUuid(deliveryId) || !isDatabaseUuid(workerId)) throw new Error("Delivery identity is invalid");
+ const db = await getClient();
+ const data = databaseData(
+ "delivery.finish",
+ await db.rpc("finish_delivery", {
+ p_delivery_id: deliveryId,
+ p_error: options.error?.slice(0, 2_048) ?? null,
+ p_next_attempt_at: options.nextAttemptAt?.toISOString() ?? null,
+ p_outcome: outcome,
+ p_provider_message_id: options.providerMessageId?.slice(0, 200) ?? null,
+ p_worker_id: workerId,
+ }),
+ );
+ const record = oneRow(data);
+ const expected = outcome === "success" ? "succeeded" : outcome === "retry" ? "pending" : "failed";
+ assertDatabaseIntegrity("delivery.finish", record.delivery_id === deliveryId && record.delivery_status === expected && Number.isInteger(record.attempts));
+ return expected;
+}
+
+export function retryAt(attempts: number, now = Date.now()): Date {
+ const delay = Math.min(6 * 60 * 60_000, 30_000 * 2 ** Math.max(0, Math.min(10, attempts - 1)));
+ return new Date(now + delay);
+}
diff --git a/lib/pipeline-run.test.ts b/lib/pipeline-run.test.ts
new file mode 100644
index 0000000..3fdd97b
--- /dev/null
+++ b/lib/pipeline-run.test.ts
@@ -0,0 +1,111 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({ rpc: vi.fn() }));
+vi.mock("./supabase.ts", () => ({
+ getClient: vi.fn(async () => ({ rpc: mocks.rpc })),
+}));
+
+import {
+ finishPipelineRun,
+ heartbeatPipelineRun,
+ recordSourceRun,
+ startPipelineRun,
+} from "./pipeline-run.ts";
+
+const runId = "77777777-7777-4777-8777-777777777777";
+
+beforeEach(() => {
+ mocks.rpc.mockReset().mockResolvedValue({ data: null, error: null });
+});
+
+describe("pipeline run client", () => {
+ test("starts a run and validates the database acknowledgement", async () => {
+ mocks.rpc.mockResolvedValueOnce({
+ data: [{ acquired: true, active_run_id: runId, run_status: "running" }],
+ error: null,
+ });
+
+ await expect(startPipelineRun("2026-07-15", runId)).resolves.toEqual({
+ acquired: true,
+ activeRunId: runId,
+ status: "running",
+ });
+ expect(mocks.rpc).toHaveBeenCalledWith("start_pipeline_run", {
+ p_run_date: "2026-07-15",
+ p_run_id: runId,
+ });
+ });
+
+ test("rejects an unknown run status from the database", async () => {
+ mocks.rpc.mockResolvedValueOnce({
+ data: [{ acquired: true, active_run_id: runId, run_status: "unknown" }],
+ error: null,
+ });
+
+ await expect(startPipelineRun("2026-07-15", runId)).rejects.toThrow(
+ "pipeline.start: invalid response",
+ );
+ });
+
+ test("heartbeats the exact date and fencing token", async () => {
+ await expect(heartbeatPipelineRun("2026-07-15", runId)).resolves.toBeUndefined();
+ expect(mocks.rpc).toHaveBeenCalledWith("heartbeat_pipeline_run", {
+ p_run_date: "2026-07-15",
+ p_run_id: runId,
+ });
+
+ await expect(heartbeatPipelineRun("not-a-date", runId)).rejects.toThrow(
+ "Invalid pipeline run identity",
+ );
+ expect(mocks.rpc).toHaveBeenCalledTimes(1);
+ });
+
+ test("records bounded source health", async () => {
+ const input = {
+ runId,
+ source: "arxiv",
+ status: "succeeded" as const,
+ itemCount: 4,
+ startedAt: "2026-07-15T14:00:00.000Z",
+ finishedAt: "2026-07-15T14:00:01.000Z",
+ };
+ await expect(recordSourceRun(input)).resolves.toBeUndefined();
+ expect(mocks.rpc).toHaveBeenCalledWith("record_source_run", {
+ p_error_message: null,
+ p_finished_at: input.finishedAt,
+ p_item_count: 4,
+ p_run_id: runId,
+ p_source: "arxiv",
+ p_started_at: input.startedAt,
+ p_status: "succeeded",
+ });
+
+ await expect(recordSourceRun({ ...input, itemCount: -1 })).rejects.toThrow(
+ "Invalid source run",
+ );
+ });
+
+ test("finishes only a valid bounded run outcome", async () => {
+ await expect(finishPipelineRun({
+ runId,
+ status: "degraded",
+ candidateCount: 10,
+ sourceCount: 6,
+ errorMessage: "one source failed",
+ })).resolves.toBeUndefined();
+ expect(mocks.rpc).toHaveBeenCalledWith("finish_pipeline_run", {
+ p_candidate_count: 10,
+ p_error_message: "one source failed",
+ p_run_id: runId,
+ p_source_count: 6,
+ p_status: "degraded",
+ });
+
+ await expect(finishPipelineRun({
+ runId,
+ status: "succeeded",
+ candidateCount: 1.5,
+ sourceCount: 6,
+ })).rejects.toThrow("Invalid pipeline completion");
+ });
+});
diff --git a/lib/pipeline-run.ts b/lib/pipeline-run.ts
new file mode 100644
index 0000000..718b595
--- /dev/null
+++ b/lib/pipeline-run.ts
@@ -0,0 +1,112 @@
+import { databaseData, isDatabaseUuid } from "./db-result.ts";
+import { getClient } from "./supabase.ts";
+
+export type PipelineStatus = "succeeded" | "degraded" | "failed" | "skipped";
+export type PipelineRunState = "running" | PipelineStatus;
+export type SourceRunStatus = "succeeded" | "failed" | "empty";
+
+function record(operation: string, value: unknown): Record {
+ if (!value || typeof value !== "object" || Array.isArray(value)) {
+ throw new Error(`${operation}: invalid response`);
+ }
+ return value as Record;
+}
+
+export async function startPipelineRun(runDate: string, runId: string): Promise<{
+ acquired: boolean;
+ activeRunId: string;
+ status: PipelineRunState;
+}> {
+ if (!/^\d{4}-\d{2}-\d{2}$/.test(runDate) || !isDatabaseUuid(runId)) {
+ throw new Error("Invalid pipeline run identity");
+ }
+ const result = await getClient().then((db) =>
+ db.rpc("start_pipeline_run", { p_run_date: runDate, p_run_id: runId }),
+ );
+ const data = databaseData("pipeline.start", result);
+ const row = Array.isArray(data) ? data[0] : data;
+ const value = record("pipeline.start", row);
+ if (
+ typeof value.acquired !== "boolean" ||
+ typeof value.active_run_id !== "string" ||
+ !isDatabaseUuid(value.active_run_id) ||
+ typeof value.run_status !== "string" ||
+ !["running", "succeeded", "degraded", "failed", "skipped"].includes(value.run_status)
+ ) {
+ throw new Error("pipeline.start: invalid response");
+ }
+ return {
+ acquired: value.acquired,
+ activeRunId: value.active_run_id,
+ status: value.run_status as PipelineRunState,
+ };
+}
+
+export async function heartbeatPipelineRun(runDate: string, runId: string): Promise {
+ if (!/^\d{4}-\d{2}-\d{2}$/.test(runDate) || !isDatabaseUuid(runId)) {
+ throw new Error("Invalid pipeline run identity");
+ }
+ const result = await getClient().then((db) =>
+ db.rpc("heartbeat_pipeline_run", { p_run_date: runDate, p_run_id: runId }),
+ );
+ databaseData("pipeline.heartbeat", result);
+}
+
+export async function recordSourceRun(input: {
+ runId: string;
+ source: string;
+ status: SourceRunStatus;
+ itemCount: number;
+ errorMessage?: string | null;
+ startedAt: string;
+ finishedAt: string;
+}): Promise {
+ if (
+ !isDatabaseUuid(input.runId) ||
+ !input.source ||
+ !Number.isInteger(input.itemCount) ||
+ input.itemCount < 0 ||
+ !["succeeded", "failed", "empty"].includes(input.status)
+ ) {
+ throw new Error("Invalid source run");
+ }
+ const result = await getClient().then((db) =>
+ db.rpc("record_source_run", {
+ p_run_id: input.runId,
+ p_source: input.source,
+ p_status: input.status,
+ p_item_count: input.itemCount,
+ p_error_message: input.errorMessage ?? null,
+ p_started_at: input.startedAt,
+ p_finished_at: input.finishedAt,
+ }),
+ );
+ databaseData("pipeline.source", result);
+}
+
+export async function finishPipelineRun(input: {
+ runId: string;
+ status: PipelineStatus;
+ candidateCount: number;
+ sourceCount: number;
+ errorMessage?: string | null;
+}): Promise {
+ if (
+ !isDatabaseUuid(input.runId) ||
+ !["succeeded", "degraded", "failed", "skipped"].includes(input.status) ||
+ !Number.isInteger(input.candidateCount) ||
+ !Number.isInteger(input.sourceCount)
+ ) {
+ throw new Error("Invalid pipeline completion");
+ }
+ const result = await getClient().then((db) =>
+ db.rpc("finish_pipeline_run", {
+ p_run_id: input.runId,
+ p_status: input.status,
+ p_candidate_count: input.candidateCount,
+ p_source_count: input.sourceCount,
+ p_error_message: input.errorMessage ?? null,
+ }),
+ );
+ databaseData("pipeline.finish", result);
+}
diff --git a/lib/preflight.ts b/lib/preflight.ts
new file mode 100644
index 0000000..04646cf
--- /dev/null
+++ b/lib/preflight.ts
@@ -0,0 +1,102 @@
+import { resolve } from "node:path";
+import { parseEnvText } from "./env-migration.ts";
+import {
+ ConfigError,
+ loadRootConfig,
+ type ConfigIssue,
+ type ConfigTarget,
+} from "./runtime-config.ts";
+import { loadWebRuntimeConfig, resolveAccessMode } from "../web/lib/runtime-config.ts";
+import { readSecureFile } from "./secure-file.ts";
+
+export type PreflightTarget = ConfigTarget | "web:development" | "web:production";
+
+export interface PreflightOptions {
+ rootEnvPath?: string;
+ target: PreflightTarget;
+ webEnvPath?: string;
+}
+
+export interface PreflightReport {
+ checkedFiles: readonly string[];
+ deprecations: readonly string[];
+ status: "ok";
+ target: PreflightTarget;
+}
+
+function readSecureEnv(
+ path: string,
+ required: boolean,
+ key: ".env" | "web/.env.local",
+): Record | undefined {
+ const snapshot = readSecureFile(path, { expectedMode: 0o600, key, required });
+ return snapshot ? parseEnvText(snapshot.text) : undefined;
+}
+
+export function assertEnvFileSecurity(path: string, required = true): void {
+ readSecureEnv(path, required, ".env");
+}
+
+function mismatch(
+ issues: ConfigIssue[],
+ key: string,
+ rootValue: string | undefined,
+ webValue: string | undefined,
+): void {
+ if (!rootValue || !webValue || rootValue !== webValue) {
+ issues.push({ code: "CONFLICT", key, relatedKey: `web:${key}` });
+ }
+}
+
+export function runPreflight(options: PreflightOptions): PreflightReport {
+ const rootEnvPath = options.rootEnvPath ?? resolve(".env");
+ const webEnvPath = options.webEnvPath ?? resolve("web/.env.local");
+ const checkedFiles: string[] = [];
+ const deprecations: string[] = [];
+
+ if (options.target === "web:production") {
+ const webEnv = readSecureEnv(webEnvPath, true, "web/.env.local") as Record;
+ checkedFiles.push(webEnvPath);
+ loadWebRuntimeConfig("production", { ...webEnv, NODE_ENV: "production" });
+ } else if (options.target === "web:development") {
+ const webEnv = readSecureEnv(webEnvPath, true, "web/.env.local") as Record;
+ checkedFiles.push(webEnvPath);
+ resolveAccessMode({ ...webEnv, NODE_ENV: "development" }, "localhost");
+ loadWebRuntimeConfig("auth", webEnv);
+ loadWebRuntimeConfig("data", webEnv);
+ loadWebRuntimeConfig("feedback", webEnv);
+ loadWebRuntimeConfig("llm", webEnv);
+ loadWebRuntimeConfig("quota", webEnv);
+ } else if (options.target === "all") {
+ const rootEnv = readSecureEnv(rootEnvPath, true, ".env") as Record;
+ const webEnv = readSecureEnv(webEnvPath, true, "web/.env.local") as Record;
+ checkedFiles.push(rootEnvPath, webEnvPath);
+ const root = loadRootConfig("all", rootEnv);
+ const web = loadWebRuntimeConfig("production", { ...webEnv, NODE_ENV: "production" });
+ deprecations.push(...root.deprecations);
+ const issues: ConfigIssue[] = [];
+ mismatch(issues, "SUPABASE_URL", root.supabase?.url, web.supabase?.url);
+ mismatch(
+ issues,
+ "SUPABASE_SERVICE_ROLE_KEY",
+ root.supabase?.serviceRoleKey,
+ web.supabase?.serviceRoleKey,
+ );
+ mismatch(issues, "DEEPSEEK_API_KEY", root.deepseek?.apiKey, web.deepseek?.apiKey);
+ mismatch(issues, "WEB_BASE_URL", root.feedback?.webBaseURL, web.feedback?.webBaseURL);
+ mismatch(issues, "FEEDBACK_SECRET", root.feedback?.secret, web.feedback?.secret);
+ if (issues.length) throw new ConfigError(issues);
+ } else {
+ const env = readSecureEnv(rootEnvPath, options.target !== "dry", ".env") ?? {};
+ if (Object.keys(env).length) checkedFiles.push(rootEnvPath);
+ const root = loadRootConfig(options.target, env);
+ deprecations.push(...root.deprecations);
+ }
+
+ return Object.freeze({
+ checkedFiles: Object.freeze([...checkedFiles]),
+ deprecations: Object.freeze([...deprecations]),
+ status: "ok" as const,
+ target: options.target,
+ });
+}
diff --git a/lib/ranking-metrics.ts b/lib/ranking-metrics.ts
new file mode 100644
index 0000000..8524615
--- /dev/null
+++ b/lib/ranking-metrics.ts
@@ -0,0 +1,14 @@
+export function precisionAtK(relevant: readonly boolean[], k: number): number {
+ const limit = Math.max(0, Math.min(k, relevant.length));
+ if (!limit) return 0;
+ return relevant.slice(0, limit).filter(Boolean).length / limit;
+}
+
+export function ndcgAtK(relevance: readonly number[], k: number): number {
+ const limit = Math.max(0, Math.min(k, relevance.length));
+ if (!limit) return 0;
+ const dcg = relevance.slice(0, limit).reduce((sum, value, index) => sum + (2 ** Math.max(0, value) - 1) / Math.log2(index + 2), 0);
+ const ideal = [...relevance].sort((a, b) => b - a).slice(0, limit)
+ .reduce((sum, value, index) => sum + (2 ** Math.max(0, value) - 1) / Math.log2(index + 2), 0);
+ return ideal ? dcg / ideal : 0;
+}
diff --git a/lib/runtime-config.ts b/lib/runtime-config.ts
new file mode 100644
index 0000000..58428c6
--- /dev/null
+++ b/lib/runtime-config.ts
@@ -0,0 +1,486 @@
+export type ConfigTarget =
+ | "all"
+ | "dry"
+ | "deliver"
+ | "ingest"
+ | "ingest:send"
+ | "push:last"
+ | "refine";
+
+type Environment = Readonly>;
+
+export interface ConfigIssue {
+ code: "CONFLICT" | "FORBIDDEN_PUBLIC_SECRET" | "INVALID" | "MISSING";
+ key: string;
+ relatedKey?: string;
+}
+
+export class ConfigError extends Error {
+ readonly code = "INVALID_RUNTIME_CONFIG";
+ readonly issues: readonly ConfigIssue[];
+
+ constructor(issues: readonly ConfigIssue[]) {
+ const safeIssues = issues.map((issue) => Object.freeze({ ...issue }));
+ const summary = safeIssues
+ .map((issue) =>
+ `${issue.code}:${issue.key}${issue.relatedKey ? `:${issue.relatedKey}` : ""}`,
+ )
+ .join(", ");
+ super(`Runtime configuration is invalid (${summary})`);
+ this.name = "ConfigError";
+ this.issues = Object.freeze(safeIssues);
+ }
+}
+
+export interface RootRuntimeConfig {
+ readonly deepseek?: Readonly<{ apiKey: string; baseURL: "https://api.deepseek.com" }>;
+ readonly deprecations: readonly string[];
+ readonly smtp?: Readonly;
+ readonly alert?: Readonly;
+ readonly feedback?: Readonly<{ secret: string; webBaseURL: string }>;
+ readonly githubToken?: string;
+ readonly openAlexApiKey?: string;
+ readonly serverChan?: Readonly<{ sendKey: string }>;
+ readonly supabase?: Readonly<{ serviceRoleKey: string; url: string }>;
+ readonly target: ConfigTarget;
+}
+
+export type DeepSeekConfig = NonNullable;
+export type FeedbackConfig = NonNullable;
+export type ServerChanConfig = NonNullable;
+export type SupabaseConfig = NonNullable;
+
+export interface SMTPConfig {
+ readonly host: string;
+ readonly port: number;
+ readonly secure: boolean;
+ readonly user: string;
+ readonly pass: string;
+ readonly from: string;
+ readonly to: string;
+}
+
+export interface AlertConfig {
+ readonly webhookURL: string;
+ readonly token?: string;
+}
+
+const FORBIDDEN_PUBLIC_KEYS = [
+ "NEXT_PUBLIC_SUPABASE_SERVICE_ROLE_KEY",
+ "NEXT_PUBLIC_DEEPSEEK_API_KEY",
+ "NEXT_PUBLIC_FEEDBACK_SECRET",
+ "NEXT_PUBLIC_APP_PASSWORD",
+ "NEXT_PUBLIC_GITHUB_TOKEN",
+ "NEXT_PUBLIC_OPENALEX_API_KEY",
+ "NEXT_PUBLIC_SERVERCHAN_SENDKEY",
+ "NEXT_PUBLIC_SERVERCHAN_KEY",
+ "NEXT_PUBLIC_LLM_API_KEY",
+ "NEXT_PUBLIC_SMTP_PASS",
+ "NEXT_PUBLIC_EMAIL_TO",
+] as const;
+
+const PUBLIC_ENV_PREFIXES = [
+ "NEXT_PUBLIC_",
+ "VITE_",
+ "PUBLIC_",
+ "NUXT_PUBLIC_",
+ "REACT_APP_",
+ "EXPO_PUBLIC_",
+] as const;
+
+function isPublicAlertKey(key: string): boolean {
+ return PUBLIC_ENV_PREFIXES.some((prefix) => key.startsWith(`${prefix}ALERT_`));
+}
+
+const TARGET_REQUIREMENTS: Record<
+ ConfigTarget,
+ readonly ("deepseek" | "feedback" | "serverChan" | "supabase")[]
+> = {
+ all: ["deepseek", "supabase", "serverChan", "feedback"],
+ dry: [],
+ deliver: ["supabase", "serverChan"],
+ ingest: ["deepseek", "supabase", "feedback"],
+ "ingest:send": ["deepseek", "supabase", "serverChan", "feedback"],
+ "push:last": ["supabase", "serverChan", "feedback"],
+ refine: ["deepseek", "supabase"],
+};
+
+function valueOf(env: Environment, key: string): string | undefined {
+ const value = env[key]?.trim();
+ return value ? value : undefined;
+}
+
+function obviousPlaceholder(value: string): boolean {
+ const normalized = value.toLowerCase();
+ return (
+ value.includes("...") ||
+ value.includes("<") ||
+ normalized.includes("replace-with-") ||
+ normalized.includes("replace-me") ||
+ /^(?:x{4,}|example|changeme)$/.test(normalized)
+ );
+}
+
+const hasControlCharacter = (value: string): boolean =>
+ [...value].some((character) => {
+ const code = character.codePointAt(0) ?? 0;
+ return code <= 31 || code === 127;
+ });
+const validHeaderToken = (value: string): boolean => /^[\x21-\x7e]+$/.test(value);
+
+function validDeepSeekLegacy(env: Environment): boolean {
+ if (valueOf(env, "LLM_PROVIDER")?.toLowerCase() !== "deepseek") return false;
+ const rawURL = valueOf(env, "LLM_BASE_URL");
+ if (!rawURL) return false;
+ try {
+ const url = new URL(rawURL);
+ return url.protocol === "https:" &&
+ (url.hostname === "deepseek.com" || url.hostname.endsWith(".deepseek.com"));
+ } catch {
+ return false;
+ }
+}
+
+function resolveAlias(
+ env: Environment,
+ canonicalKey: string,
+ legacyKey: string,
+ legacyAllowed: boolean,
+ issues: ConfigIssue[],
+ deprecations: string[],
+): string | undefined {
+ const canonical = valueOf(env, canonicalKey);
+ const legacy = legacyAllowed ? valueOf(env, legacyKey) : undefined;
+ if (canonical && legacy && canonical !== legacy) {
+ issues.push({
+ code: "CONFLICT",
+ key: canonicalKey,
+ relatedKey: legacyKey,
+ });
+ return undefined;
+ }
+ if (canonical) {
+ if (legacy) deprecations.push(`${legacyKey}->${canonicalKey}`);
+ return canonical;
+ }
+ if (legacy) {
+ deprecations.push(`${legacyKey}->${canonicalKey}`);
+ return legacy;
+ }
+ return undefined;
+}
+
+function isLoopback(hostname: string): boolean {
+ return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+
+function validBaseURL(rawURL: string): boolean {
+ try {
+ if (hasControlCharacter(rawURL)) return false;
+ const url = new URL(rawURL);
+ if (url.username || url.password || url.hash || url.search) return false;
+ if (url.pathname !== "/" && url.pathname !== "") return false;
+ const placeholderHostname = url.hostname
+ .split(".")
+ .some((label) => /^x{4,}$/i.test(label) || /^(?:your-app|your-project|replace-me)$/i.test(label));
+ if (placeholderHostname || obviousPlaceholder(rawURL)) return false;
+ return url.protocol === "https:" || (url.protocol === "http:" && isLoopback(url.hostname));
+ } catch {
+ return false;
+ }
+}
+
+function invalidServiceRoleKey(value: string): boolean {
+ if (
+ value.length < 24 ||
+ !validHeaderToken(value) ||
+ obviousPlaceholder(value) ||
+ /^sb_publishable_/i.test(value)
+ ) {
+ return true;
+ }
+ const segments = value.split(".");
+ if (segments.length !== 3) return false;
+ try {
+ const payload = JSON.parse(Buffer.from(segments[1], "base64url").toString("utf8")) as {
+ role?: unknown;
+ };
+ return typeof payload.role === "string" && payload.role !== "service_role";
+ } catch {
+ return false;
+ }
+}
+
+function requireCapability(
+ required: ReadonlySet,
+ capability: string,
+ values: readonly [string, string | undefined][],
+ issues: ConfigIssue[],
+): void {
+ if (!required.has(capability)) return;
+ for (const [key, value] of values) {
+ if (!value) issues.push({ code: "MISSING", key });
+ }
+}
+
+export function loadRootConfig(
+ target: ConfigTarget,
+ env: Environment = process.env,
+): RootRuntimeConfig {
+ if (!Object.hasOwn(TARGET_REQUIREMENTS, target)) {
+ throw new ConfigError([{ code: "INVALID", key: "target" }]);
+ }
+ const issues: ConfigIssue[] = [];
+ const deprecations: string[] = [];
+
+ for (const key of FORBIDDEN_PUBLIC_KEYS) {
+ if (valueOf(env, key)) issues.push({ code: "FORBIDDEN_PUBLIC_SECRET", key });
+ }
+ for (const key of Object.keys(env)) {
+ if (isPublicAlertKey(key) && valueOf(env, key)) {
+ issues.push({ code: "FORBIDDEN_PUBLIC_SECRET", key });
+ }
+ }
+
+ const deepseekKey = resolveAlias(
+ env,
+ "DEEPSEEK_API_KEY",
+ "LLM_API_KEY",
+ validDeepSeekLegacy(env),
+ issues,
+ deprecations,
+ );
+ const serverChanKey = resolveAlias(
+ env,
+ "SERVERCHAN_SENDKEY",
+ "SERVERCHAN_KEY",
+ true,
+ issues,
+ deprecations,
+ );
+ const supabaseURL = valueOf(env, "SUPABASE_URL");
+ const serviceRoleKey = valueOf(env, "SUPABASE_SERVICE_ROLE_KEY");
+ const webBaseURL = valueOf(env, "WEB_BASE_URL");
+ const feedbackSecret = valueOf(env, "FEEDBACK_SECRET");
+ const githubToken = valueOf(env, "GITHUB_TOKEN");
+ const openAlexApiKey = valueOf(env, "OPENALEX_API_KEY");
+ const alertWebhookURL = valueOf(env, "ALERT_WEBHOOK_URL");
+ const alertWebhookToken = valueOf(env, "ALERT_WEBHOOK_TOKEN");
+ const smtpValues = {
+ host: valueOf(env, "SMTP_HOST"),
+ port: valueOf(env, "SMTP_PORT"),
+ secure: valueOf(env, "SMTP_SECURE"),
+ user: valueOf(env, "SMTP_USER"),
+ pass: valueOf(env, "SMTP_PASS"),
+ from: valueOf(env, "EMAIL_FROM"),
+ to: valueOf(env, "EMAIL_TO"),
+ };
+ const smtpConfigured = Object.values(smtpValues).some((value) => value !== undefined);
+ if (alertWebhookToken && !alertWebhookURL) issues.push({ code: "MISSING", key: "ALERT_WEBHOOK_URL" });
+ if (alertWebhookURL) {
+ try {
+ const url = new URL(alertWebhookURL);
+ if (url.protocol !== "https:" || url.username || url.password || url.hash || alertWebhookURL.length > 2048) {
+ issues.push({ code: "INVALID", key: "ALERT_WEBHOOK_URL" });
+ }
+ } catch {
+ issues.push({ code: "INVALID", key: "ALERT_WEBHOOK_URL" });
+ }
+ }
+ if (alertWebhookToken && (!validHeaderToken(alertWebhookToken) || alertWebhookToken.length > 512)) {
+ issues.push({ code: "INVALID", key: "ALERT_WEBHOOK_TOKEN" });
+ }
+
+ const required = new Set(TARGET_REQUIREMENTS[target]);
+ requireCapability(required, "deepseek", [["DEEPSEEK_API_KEY", deepseekKey]], issues);
+ requireCapability(
+ required,
+ "supabase",
+ [
+ ["SUPABASE_URL", supabaseURL],
+ ["SUPABASE_SERVICE_ROLE_KEY", serviceRoleKey],
+ ],
+ issues,
+ );
+ requireCapability(
+ required,
+ "serverChan",
+ [["SERVERCHAN_SENDKEY", serverChanKey]],
+ issues,
+ );
+ requireCapability(
+ required,
+ "feedback",
+ [
+ ["WEB_BASE_URL", webBaseURL],
+ ["FEEDBACK_SECRET", feedbackSecret],
+ ],
+ issues,
+ );
+
+ if (
+ deepseekKey &&
+ (deepseekKey.length < 16 || !validHeaderToken(deepseekKey) || obviousPlaceholder(deepseekKey))
+ ) {
+ issues.push({ code: "INVALID", key: "DEEPSEEK_API_KEY" });
+ }
+ if (supabaseURL && !validBaseURL(supabaseURL)) {
+ issues.push({ code: "INVALID", key: "SUPABASE_URL" });
+ }
+ if (serviceRoleKey && invalidServiceRoleKey(serviceRoleKey)) {
+ issues.push({ code: "INVALID", key: "SUPABASE_SERVICE_ROLE_KEY" });
+ }
+ if (supabaseURL && !serviceRoleKey) {
+ issues.push({ code: "MISSING", key: "SUPABASE_SERVICE_ROLE_KEY" });
+ }
+ if (serviceRoleKey && !supabaseURL) issues.push({ code: "MISSING", key: "SUPABASE_URL" });
+ if (
+ serverChanKey &&
+ !/^SCT[A-Za-z0-9_-]{10,}$/.test(serverChanKey) &&
+ !/^sctp\d+t[A-Za-z0-9_-]{10,}$/.test(serverChanKey)
+ ) {
+ issues.push({ code: "INVALID", key: "SERVERCHAN_SENDKEY" });
+ }
+ if (
+ githubToken &&
+ (githubToken.length < 20 || !validHeaderToken(githubToken) || obviousPlaceholder(githubToken))
+ ) {
+ issues.push({ code: "INVALID", key: "GITHUB_TOKEN" });
+ }
+ if (
+ openAlexApiKey &&
+ (openAlexApiKey.length < 8 ||
+ openAlexApiKey.length > 512 ||
+ !validHeaderToken(openAlexApiKey) ||
+ obviousPlaceholder(openAlexApiKey))
+ ) {
+ issues.push({ code: "INVALID", key: "OPENALEX_API_KEY" });
+ }
+
+ if (webBaseURL && !feedbackSecret) issues.push({ code: "MISSING", key: "FEEDBACK_SECRET" });
+ if (feedbackSecret && !webBaseURL) issues.push({ code: "MISSING", key: "WEB_BASE_URL" });
+ if (webBaseURL && !validBaseURL(webBaseURL)) {
+ issues.push({ code: "INVALID", key: "WEB_BASE_URL" });
+ }
+ if (
+ feedbackSecret &&
+ (Buffer.byteLength(feedbackSecret, "utf8") < 32 ||
+ hasControlCharacter(feedbackSecret) ||
+ obviousPlaceholder(feedbackSecret))
+ ) {
+ issues.push({ code: "INVALID", key: "FEEDBACK_SECRET" });
+ }
+
+ if (smtpConfigured) {
+ for (const [key, value] of Object.entries(smtpValues)) {
+ if (!value) issues.push({ code: "MISSING", key: key === "from" || key === "to" ? `EMAIL_${key.toUpperCase()}` : `SMTP_${key.toUpperCase()}` });
+ }
+ const port = Number(smtpValues.port);
+ if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+ issues.push({ code: "INVALID", key: "SMTP_PORT" });
+ }
+ if (smtpValues.secure !== "true" && smtpValues.secure !== "false") {
+ issues.push({ code: "INVALID", key: "SMTP_SECURE" });
+ }
+ for (const [key, value] of Object.entries(smtpValues)) {
+ if (value && hasControlCharacter(value)) {
+ issues.push({ code: "INVALID", key: key === "from" || key === "to" ? `EMAIL_${key.toUpperCase()}` : `SMTP_${key.toUpperCase()}` });
+ }
+ }
+ if (smtpValues.host && !/^[A-Za-z0-9.-]+$/.test(smtpValues.host)) {
+ issues.push({ code: "INVALID", key: "SMTP_HOST" });
+ }
+ for (const key of ["from", "to"] as const) {
+ const value = smtpValues[key];
+ if (value && (!value.includes("@") || value.length > 320)) {
+ issues.push({ code: "INVALID", key: key === "from" ? "EMAIL_FROM" : "EMAIL_TO" });
+ }
+ }
+ }
+
+ if (issues.length) throw new ConfigError(issues);
+
+ const config: RootRuntimeConfig = {
+ target,
+ deprecations: Object.freeze([...deprecations]),
+ ...(deepseekKey
+ ? { deepseek: Object.freeze({ apiKey: deepseekKey, baseURL: "https://api.deepseek.com" as const }) }
+ : {}),
+ ...(supabaseURL && serviceRoleKey
+ ? { supabase: Object.freeze({ serviceRoleKey, url: supabaseURL.replace(/\/$/, "") }) }
+ : {}),
+ ...(serverChanKey ? { serverChan: Object.freeze({ sendKey: serverChanKey }) } : {}),
+ ...(webBaseURL && feedbackSecret
+ ? { feedback: Object.freeze({ secret: feedbackSecret, webBaseURL: webBaseURL.replace(/\/$/, "") }) }
+ : {}),
+ ...(smtpConfigured
+ ? {
+ smtp: Object.freeze({
+ host: smtpValues.host as string,
+ port: Number(smtpValues.port),
+ secure: smtpValues.secure === "true",
+ user: smtpValues.user as string,
+ pass: smtpValues.pass as string,
+ from: smtpValues.from as string,
+ to: smtpValues.to as string,
+ }),
+ }
+ : {}),
+ ...(githubToken ? { githubToken } : {}),
+ ...(openAlexApiKey ? { openAlexApiKey } : {}),
+ ...(alertWebhookURL
+ ? { alert: Object.freeze({ webhookURL: alertWebhookURL, ...(alertWebhookToken ? { token: alertWebhookToken } : {}) }) }
+ : {}),
+ };
+ return Object.freeze(config);
+}
+
+export function loadDeepSeekConfig(env: Environment = process.env): DeepSeekConfig {
+ const config = loadRootConfig("dry", env);
+ if (!config.deepseek) throw new ConfigError([{ code: "MISSING", key: "DEEPSEEK_API_KEY" }]);
+ return config.deepseek;
+}
+
+export function loadSupabaseConfig(env: Environment = process.env): SupabaseConfig {
+ const config = loadRootConfig("dry", env);
+ if (!config.supabase) {
+ throw new ConfigError([
+ { code: "MISSING", key: "SUPABASE_URL" },
+ { code: "MISSING", key: "SUPABASE_SERVICE_ROLE_KEY" },
+ ]);
+ }
+ return config.supabase;
+}
+
+export function loadServerChanConfig(env: Environment = process.env): ServerChanConfig {
+ const config = loadRootConfig("dry", env);
+ if (!config.serverChan) {
+ throw new ConfigError([{ code: "MISSING", key: "SERVERCHAN_SENDKEY" }]);
+ }
+ return config.serverChan;
+}
+
+export function loadFeedbackConfig(env: Environment = process.env): FeedbackConfig {
+ const config = loadRootConfig("dry", env);
+ if (!config.feedback) {
+ throw new ConfigError([
+ { code: "MISSING", key: "WEB_BASE_URL" },
+ { code: "MISSING", key: "FEEDBACK_SECRET" },
+ ]);
+ }
+ return config.feedback;
+}
+
+export function loadOptionalFeedbackConfig(
+ env: Environment = process.env,
+): FeedbackConfig | undefined {
+ return loadRootConfig("dry", env).feedback;
+}
+
+export function loadOptionalSMTPConfig(env: Environment = process.env): SMTPConfig | undefined {
+ return loadRootConfig("dry", env).smtp;
+}
+
+export function loadOptionalAlertConfig(env: Environment = process.env): AlertConfig | undefined {
+ return loadRootConfig("dry", env).alert;
+}
diff --git a/lib/runtime-env.ts b/lib/runtime-env.ts
new file mode 100644
index 0000000..9097780
--- /dev/null
+++ b/lib/runtime-env.ts
@@ -0,0 +1,49 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { resolve } from "node:path";
+import { parseEnvText } from "./env-migration.ts";
+import { readSecureFile } from "./secure-file.ts";
+import { ConfigError } from "./runtime-config.ts";
+
+export type RuntimeEnvironment = Readonly>;
+
+const environmentStorage = new AsyncLocalStorage();
+
+function immutableEnvironment(env: RuntimeEnvironment): RuntimeEnvironment {
+ return Object.freeze({ ...env });
+}
+
+export function currentRuntimeEnvironment(): RuntimeEnvironment {
+ return environmentStorage.getStore() ?? process.env;
+}
+
+export function withRuntimeEnvironment(
+ env: RuntimeEnvironment,
+ operation: () => T,
+): T {
+ return environmentStorage.run(immutableEnvironment(env), operation);
+}
+
+export function loadRuntimeEnvironment(
+ options: {
+ baseEnv?: RuntimeEnvironment;
+ path?: string;
+ required?: boolean;
+ } = {},
+): RuntimeEnvironment {
+ const snapshot = readSecureFile(resolve(options.path ?? ".env"), {
+ expectedMode: 0o600,
+ key: ".env",
+ required: options.required ?? true,
+ });
+ const fileEnvironment = snapshot ? parseEnvText(snapshot.text) : {};
+ const baseEnvironment = options.baseEnv ?? process.env;
+ const conflicts = Object.entries(fileEnvironment)
+ .filter(([key, value]) => baseEnvironment[key] !== undefined && baseEnvironment[key] !== value)
+ .map(([key]) => ({
+ code: "CONFLICT" as const,
+ key,
+ relatedKey: "inherited environment",
+ }));
+ if (conflicts.length) throw new ConfigError(conflicts);
+ return immutableEnvironment({ ...baseEnvironment, ...fileEnvironment });
+}
diff --git a/lib/safe-error.ts b/lib/safe-error.ts
new file mode 100644
index 0000000..9fba018
--- /dev/null
+++ b/lib/safe-error.ts
@@ -0,0 +1,48 @@
+import { currentRuntimeEnvironment } from "./runtime-env.ts";
+
+const MAX_ERROR_LENGTH = 1_024;
+const SENSITIVE_NAME =
+ /(?:api.?key|auth|cookie|credential|password|secret|sendkey|token|(?:^|_)key$)/i;
+
+type Environment = Readonly>;
+
+function stripURLDetails(message: string): string {
+ return message.replace(/https?:\/\/[^\s"'<>]+/gi, (candidate) => {
+ try {
+ const url = new URL(candidate);
+ return `${url.origin}${url.pathname}`;
+ } catch {
+ return "[REDACTED_URL]";
+ }
+ });
+}
+
+function configuredSecrets(env: Environment): string[] {
+ const secrets = Object.entries(env)
+ .filter(([key, value]) => SENSITIVE_NAME.test(key) && Boolean(value && value.length >= 4))
+ .flatMap(([, value]) => {
+ const secret = value as string;
+ const encoded = encodeURIComponent(secret);
+ return encoded === secret ? [secret] : [secret, encoded];
+ });
+ return [...new Set(secrets)].sort((left, right) => right.length - left.length);
+}
+
+export function safeErrorMessage(
+ error: unknown,
+ env: Environment = currentRuntimeEnvironment(),
+): string {
+ if (!(error instanceof Error)) return "Operation failed with a non-Error rejection";
+ let message = error.message || "Operation failed";
+ for (const secret of configuredSecrets(env)) {
+ message = message.replaceAll(secret, "[REDACTED]");
+ }
+ message = message
+ .replace(/\bBearer\s+[^\s,;]+/gi, "Bearer [REDACTED]")
+ .replace(
+ /\b(?:sk-|sb_secret_|sb_publishable_|SCT|sctp\d+t)[A-Za-z0-9_-]{8,}\b/g,
+ "[REDACTED]",
+ );
+ message = stripURLDetails(message);
+ return message.slice(0, MAX_ERROR_LENGTH);
+}
diff --git a/lib/secure-file.ts b/lib/secure-file.ts
new file mode 100644
index 0000000..dc1f2da
--- /dev/null
+++ b/lib/secure-file.ts
@@ -0,0 +1,145 @@
+import {
+ chmodSync,
+ closeSync,
+ constants,
+ fchmodSync,
+ fstatSync,
+ lstatSync,
+ openSync,
+ readFileSync,
+ writeFileSync,
+ type BigIntStats,
+} from "node:fs";
+import { ConfigError } from "./runtime-config.ts";
+
+interface FileFingerprint {
+ ctimeNs: bigint;
+ dev: bigint;
+ ino: bigint;
+ mode: bigint;
+ mtimeNs: bigint;
+ size: bigint;
+}
+
+export interface SecureFileSnapshot {
+ readonly fingerprint: FileFingerprint;
+ readonly text: string;
+}
+
+interface SecureFileOptions {
+ expectedMode?: number;
+ key?: string;
+ required?: boolean;
+}
+
+function fingerprint(stat: BigIntStats): FileFingerprint {
+ return {
+ ctimeNs: stat.ctimeNs,
+ dev: stat.dev,
+ ino: stat.ino,
+ mode: stat.mode,
+ mtimeNs: stat.mtimeNs,
+ size: stat.size,
+ };
+}
+
+function sameFingerprint(left: FileFingerprint, right: FileFingerprint): boolean {
+ return Object.keys(left).every(
+ (key) => left[key as keyof FileFingerprint] === right[key as keyof FileFingerprint],
+ );
+}
+
+function validateStat(stat: BigIntStats, key: string, expectedMode?: number): void {
+ if (!stat.isFile()) throw new ConfigError([{ code: "INVALID", key }]);
+ if (typeof process.getuid === "function" && stat.uid !== BigInt(process.getuid())) {
+ throw new ConfigError([{ code: "INVALID", key: `${key} owner` }]);
+ }
+ if (expectedMode !== undefined && Number(stat.mode & 0o777n) !== expectedMode) {
+ throw new ConfigError([{ code: "INVALID", key: `${key} mode` }]);
+ }
+}
+
+export function readSecureFile(
+ path: string,
+ options: SecureFileOptions = {},
+): SecureFileSnapshot | undefined {
+ const key = options.key ?? ".env";
+ let descriptor: number;
+ try {
+ descriptor = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+ } catch (error) {
+ if (!options.required && (error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+ throw new ConfigError([
+ { code: (error as NodeJS.ErrnoException).code === "ENOENT" ? "MISSING" : "INVALID", key },
+ ]);
+ }
+ try {
+ const before = fstatSync(descriptor, { bigint: true });
+ validateStat(before, key, options.expectedMode);
+ const text = readFileSync(descriptor, "utf8");
+ const after = fstatSync(descriptor, { bigint: true });
+ if (!sameFingerprint(fingerprint(before), fingerprint(after))) {
+ throw new ConfigError([{ code: "CONFLICT", key, relatedKey: "changed-during-read" }]);
+ }
+ return Object.freeze({ fingerprint: Object.freeze(fingerprint(after)), text });
+ } finally {
+ closeSync(descriptor);
+ }
+}
+
+export function assertFileUnchanged(
+ path: string,
+ snapshot: SecureFileSnapshot,
+ key = ".env",
+): void {
+ let current: BigIntStats;
+ try {
+ current = lstatSync(path, { bigint: true });
+ } catch {
+ throw new ConfigError([{ code: "CONFLICT", key, relatedKey: "changed-after-read" }]);
+ }
+ if (current.isSymbolicLink() || !sameFingerprint(snapshot.fingerprint, fingerprint(current))) {
+ throw new ConfigError([{ code: "CONFLICT", key, relatedKey: "changed-after-read" }]);
+ }
+}
+
+export function snapshotFileMode(snapshot: SecureFileSnapshot): number {
+ return Number(snapshot.fingerprint.mode & 0o777n);
+}
+
+export function repairFileMode(
+ path: string,
+ snapshot: SecureFileSnapshot,
+ mode = 0o600,
+ key = ".env",
+): void {
+ let descriptor: number;
+ try {
+ descriptor = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+ } catch {
+ throw new ConfigError([{ code: "CONFLICT", key, relatedKey: "changed-after-read" }]);
+ }
+ try {
+ const before = fstatSync(descriptor, { bigint: true });
+ if (!sameFingerprint(snapshot.fingerprint, fingerprint(before))) {
+ throw new ConfigError([{ code: "CONFLICT", key, relatedKey: "changed-after-read" }]);
+ }
+ fchmodSync(descriptor, mode);
+ } finally {
+ closeSync(descriptor);
+ }
+ const after = lstatSync(path, { bigint: true });
+ if (
+ after.isSymbolicLink() ||
+ after.dev !== snapshot.fingerprint.dev ||
+ after.ino !== snapshot.fingerprint.ino ||
+ Number(after.mode & 0o777n) !== mode
+ ) {
+ throw new ConfigError([{ code: "CONFLICT", key, relatedKey: "changed-after-read" }]);
+ }
+}
+
+export function writeSecureFileExclusive(path: string, text: string): void {
+ writeFileSync(path, text, { encoding: "utf8", flag: "wx", mode: 0o600 });
+ chmodSync(path, 0o600);
+}
diff --git a/lib/sign.ts b/lib/sign.ts
index ca58278..30b2639 100644
--- a/lib/sign.ts
+++ b/lib/sign.ts
@@ -1,15 +1,10 @@
-import { createHmac } from "node:crypto";
+import { loadFeedbackConfig } from "./runtime-config.ts";
+import { currentRuntimeEnvironment } from "./runtime-env.ts";
+import {
+ issueFeedbackToken as issueWithSecret,
+ type FeedbackTokenInput,
+} from "./feedback-token.ts";
-// 一键反馈链接的签名（防伪造、免登录）。ingest 端签发、web 端校验，逻辑两边各放一份。
-export function signFeedback(itemId: string, rating: string): string {
- return createHmac("sha256", process.env.FEEDBACK_SECRET ?? "")
- .update(`${itemId}:${rating}`)
- .digest("hex")
- .slice(0, 16);
-}
-
-export function verifyFeedback(itemId: string, rating: string, token: string): boolean {
- if (!process.env.FEEDBACK_SECRET) return false;
- const expected = signFeedback(itemId, rating);
- return token.length === expected.length && token === expected;
+export function issueFeedbackToken(input: FeedbackTokenInput): string {
+ return issueWithSecret(loadFeedbackConfig(currentRuntimeEnvironment()).secret, input);
}
diff --git a/lib/source-freshness.ts b/lib/source-freshness.ts
new file mode 100644
index 0000000..42ac3a9
--- /dev/null
+++ b/lib/source-freshness.ts
@@ -0,0 +1,37 @@
+import { LOOKBACK_DAYS } from "../config/sources.ts";
+import type { NormalizedItem } from "./types.ts";
+
+const MAX_CLOCK_SKEW_MS = 5 * 60_000;
+
+export type FreshnessRejection = "missing" | "invalid" | "stale" | "future";
+
+export function sourceFreshness(
+ publishedAt: string,
+ now: Date,
+ lookbackDays = LOOKBACK_DAYS,
+): { fresh: true; instant: Date } | { fresh: false; reason: FreshnessRejection } {
+ if (!publishedAt.trim()) return { fresh: false, reason: "missing" };
+ const timestamp = Date.parse(publishedAt);
+ if (!Number.isFinite(timestamp)) return { fresh: false, reason: "invalid" };
+ const instant = new Date(timestamp);
+ const nowMs = now.getTime();
+ if (!Number.isFinite(nowMs)) throw new TypeError("Invalid source freshness clock");
+ if (timestamp > nowMs + MAX_CLOCK_SKEW_MS) return { fresh: false, reason: "future" };
+ if (timestamp < nowMs - lookbackDays * 86_400_000) return { fresh: false, reason: "stale" };
+ return { fresh: true, instant };
+}
+
+export function filterFreshItems(
+ items: readonly NormalizedItem[],
+ now: Date,
+ onReject?: (item: NormalizedItem, reason: FreshnessRejection) => void,
+): NormalizedItem[] {
+ return items.flatMap((item) => {
+ const result = sourceFreshness(item.publishedAt, now);
+ if (!result.fresh) {
+ onReject?.(item, result.reason);
+ return [];
+ }
+ return [{ ...item, publishedAt: result.instant.toISOString() }];
+ });
+}
diff --git a/lib/state-backup.ts b/lib/state-backup.ts
new file mode 100644
index 0000000..7c3f0a7
--- /dev/null
+++ b/lib/state-backup.ts
@@ -0,0 +1,350 @@
+import { createHash, randomUUID } from "node:crypto";
+import {
+ chmodSync,
+ linkSync,
+ lstatSync,
+ mkdirSync,
+ renameSync,
+ rmSync,
+ type Stats,
+} from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import {
+ assertFileUnchanged,
+ readSecureFile,
+ snapshotFileMode,
+ writeSecureFileExclusive,
+ type SecureFileSnapshot,
+} from "./secure-file.ts";
+
+const BACKUP_FORMAT = "frontier-paper-dispatch/state-backup";
+const BACKUP_VERSION = 1;
+const MAX_FILE_BYTES = 512 * 1024;
+const MAX_BUNDLE_BYTES = 2 * 1024 * 1024;
+export const STATE_BACKUP_FILES = Object.freeze([
+ "config/profile.md",
+ "config/sources.ts",
+] as const);
+
+type BackupPath = (typeof STATE_BACKUP_FILES)[number];
+
+interface BackupFile {
+ readonly bytes: number;
+ readonly content: string;
+ readonly path: BackupPath;
+ readonly sha256: string;
+}
+
+interface BackupBundle {
+ readonly createdAt: string;
+ readonly files: readonly BackupFile[];
+ readonly format: typeof BACKUP_FORMAT;
+ readonly version: typeof BACKUP_VERSION;
+}
+
+export interface StateBackupReport {
+ readonly destination: string;
+ readonly files: readonly BackupPath[];
+}
+
+export interface StateRestoreReport {
+ readonly applied: boolean;
+ readonly files: readonly {
+ readonly action: "create" | "overwrite";
+ readonly path: BackupPath;
+ }[];
+}
+
+function isOwnedByCurrentUser(stat: Stats): boolean {
+ return typeof process.getuid !== "function" || stat.uid === process.getuid();
+}
+
+function requireDirectory(path: string, label: string, privateDirectory = false): void {
+ let stat: Stats;
+ try {
+ stat = lstatSync(path);
+ } catch {
+ throw new Error(`${label} directory is missing`);
+ }
+ if (stat.isSymbolicLink()) throw new Error(`${label} directory must not be a symlink`);
+ if (!stat.isDirectory() || !isOwnedByCurrentUser(stat)) {
+ throw new Error(`${label} directory is invalid`);
+ }
+ if (privateDirectory && (stat.mode & 0o077) !== 0) {
+ throw new Error(`${label} directory permissions must be 700 or stricter`);
+ }
+}
+
+function sha256(content: string): string {
+ return createHash("sha256").update(content, "utf8").digest("hex");
+}
+
+function safeClock(clock: () => Date): string {
+ const instant = clock();
+ if (!(instant instanceof Date) || !Number.isFinite(instant.getTime())) {
+ throw new TypeError("Backup clock returned an invalid date");
+ }
+ return instant.toISOString();
+}
+
+function defaultDestination(root: string, createdAt: string): string {
+ const backupDirectory = join(root, ".backups");
+ try {
+ mkdirSync(backupDirectory, { mode: 0o700 });
+ } catch (error) {
+ if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+ }
+ requireDirectory(backupDirectory, "backup", true);
+ const timestamp = createdAt.replaceAll(":", "-");
+ return join(backupDirectory, `state-${timestamp}.json`);
+}
+
+function serializeBundle(bundle: BackupBundle): string {
+ return `${JSON.stringify(bundle, null, 2)}\n`;
+}
+
+export function createStateBackup(options: Readonly<{
+ clock?: () => Date;
+ destination?: string;
+ root?: string;
+}> = {}): StateBackupReport {
+ const root = resolve(options.root ?? ".");
+ requireDirectory(root, "repository");
+ requireDirectory(join(root, "config"), "config");
+ const createdAt = safeClock(options.clock ?? (() => new Date()));
+ const files = STATE_BACKUP_FILES.map((path) => {
+ const snapshot = readSecureFile(join(root, path), { key: path, required: true });
+ const content = snapshot!.text;
+ const bytes = Buffer.byteLength(content, "utf8");
+ if (bytes < 1 || bytes > MAX_FILE_BYTES) {
+ throw new Error(`${path} exceeds the backup size boundary`);
+ }
+ return Object.freeze({ bytes, content, path, sha256: sha256(content) });
+ });
+ const bundle: BackupBundle = Object.freeze({
+ createdAt,
+ files: Object.freeze(files),
+ format: BACKUP_FORMAT,
+ version: BACKUP_VERSION,
+ });
+ const rendered = serializeBundle(bundle);
+ if (Buffer.byteLength(rendered, "utf8") > MAX_BUNDLE_BYTES) {
+ throw new Error("State backup exceeds the bundle size boundary");
+ }
+ const destination = resolve(options.destination ?? defaultDestination(root, createdAt));
+ requireDirectory(dirname(destination), "backup destination");
+ writeSecureFileExclusive(destination, rendered);
+ return Object.freeze({
+ destination,
+ files: Object.freeze([...STATE_BACKUP_FILES]),
+ });
+}
+
+function objectValue(value: unknown, label: string): Record {
+ if (value === null || typeof value !== "object" || Array.isArray(value)) {
+ throw new Error(`Backup integrity check failed: invalid ${label}`);
+ }
+ return value as Record;
+}
+
+function parseBundle(text: string): BackupBundle {
+ if (Buffer.byteLength(text, "utf8") > MAX_BUNDLE_BYTES) {
+ throw new Error("Backup integrity check failed: bundle is too large");
+ }
+ let decoded: unknown;
+ try {
+ decoded = JSON.parse(text);
+ } catch {
+ throw new Error("Backup integrity check failed: invalid JSON");
+ }
+ const raw = objectValue(decoded, "envelope");
+ if (
+ raw.format !== BACKUP_FORMAT ||
+ raw.version !== BACKUP_VERSION ||
+ typeof raw.createdAt !== "string" ||
+ !Array.isArray(raw.files) ||
+ raw.files.length !== STATE_BACKUP_FILES.length
+ ) {
+ throw new Error("Backup integrity check failed: unsupported envelope");
+ }
+ try {
+ if (new Date(raw.createdAt).toISOString() !== raw.createdAt) throw new Error();
+ } catch {
+ throw new Error("Backup integrity check failed: invalid timestamp");
+ }
+
+ const allowed = new Set(STATE_BACKUP_FILES);
+ const seen = new Set();
+ const entries = raw.files.map((value) => {
+ const file = objectValue(value, "file");
+ if (typeof file.path !== "string" || !allowed.has(file.path) || seen.has(file.path)) {
+ throw new Error("Backup path is outside the restore allowlist");
+ }
+ seen.add(file.path);
+ if (
+ typeof file.content !== "string" ||
+ !Number.isInteger(file.bytes) ||
+ (file.bytes as number) < 1 ||
+ (file.bytes as number) > MAX_FILE_BYTES ||
+ typeof file.sha256 !== "string" ||
+ !/^[a-f0-9]{64}$/.test(file.sha256) ||
+ Buffer.byteLength(file.content, "utf8") !== file.bytes ||
+ sha256(file.content) !== file.sha256
+ ) {
+ throw new Error("Backup integrity check failed: file digest mismatch");
+ }
+ return Object.freeze({
+ bytes: file.bytes as number,
+ content: file.content,
+ path: file.path as BackupPath,
+ sha256: file.sha256,
+ });
+ });
+ if (STATE_BACKUP_FILES.some((path) => !seen.has(path))) {
+ throw new Error("Backup path is outside the restore allowlist");
+ }
+ entries.sort(
+ (left, right) => STATE_BACKUP_FILES.indexOf(left.path) - STATE_BACKUP_FILES.indexOf(right.path),
+ );
+ return Object.freeze({
+ createdAt: raw.createdAt,
+ files: Object.freeze(entries),
+ format: BACKUP_FORMAT,
+ version: BACKUP_VERSION,
+ });
+}
+
+function existingTarget(path: string): Stats | undefined {
+ try {
+ return lstatSync(path);
+ } catch (error) {
+ if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+ throw error;
+ }
+}
+
+export function restoreStateBackup(options: Readonly<{
+ apply?: boolean;
+ backupPath: string;
+ force?: boolean;
+ root?: string;
+}>): StateRestoreReport {
+ if (options.force && !options.apply) {
+ throw new Error("--force requires --apply");
+ }
+ const root = resolve(options.root ?? ".");
+ requireDirectory(root, "repository");
+ const configDirectory = join(root, "config");
+ requireDirectory(configDirectory, "config");
+ const backup = readSecureFile(resolve(options.backupPath), {
+ expectedMode: 0o600,
+ key: "state backup",
+ required: true,
+ });
+ const bundle = parseBundle(backup!.text);
+ const plan = bundle.files.map((file) => {
+ const target = join(root, file.path);
+ const stat = existingTarget(target);
+ if (stat?.isSymbolicLink()) throw new Error(`Restore target is a symlink: ${file.path}`);
+ if (stat && (!stat.isFile() || !isOwnedByCurrentUser(stat))) {
+ throw new Error(`Restore target is invalid: ${file.path}`);
+ }
+ return Object.freeze({
+ action: stat ? "overwrite" as const : "create" as const,
+ content: file.content,
+ path: file.path,
+ target,
+ });
+ });
+ const reportFiles = Object.freeze(plan.map(({ action, path }) => Object.freeze({ action, path })));
+ if (!options.apply) return Object.freeze({ applied: false, files: reportFiles });
+ if (!options.force && plan.some(({ action }) => action === "overwrite")) {
+ throw new Error("Restore would overwrite an existing file; review dry-run and pass --force");
+ }
+
+ type StagedRestore = (typeof plan)[number] & {
+ temporaryPath: string;
+ rollback?: {
+ path: string;
+ snapshot: SecureFileSnapshot;
+ };
+ };
+ const staged: StagedRestore[] = [];
+ try {
+ for (const entry of plan) {
+ const temporaryPath = join(
+ dirname(entry.target),
+ `.${basename(entry.target)}.${randomUUID()}.restore`,
+ );
+ let rollback: StagedRestore["rollback"];
+ let rollbackPath: string | undefined;
+ try {
+ writeSecureFileExclusive(temporaryPath, entry.content);
+ if (entry.action === "overwrite") {
+ const snapshot = readSecureFile(entry.target, { key: entry.path, required: true });
+ rollbackPath = join(
+ dirname(entry.target),
+ `.${basename(entry.target)}.${randomUUID()}.rollback`,
+ );
+ writeSecureFileExclusive(rollbackPath, snapshot!.text);
+ chmodSync(rollbackPath, snapshotFileMode(snapshot!));
+ rollback = Object.freeze({ path: rollbackPath, snapshot: snapshot! });
+ }
+ } catch (error) {
+ rmSync(temporaryPath, { force: true });
+ if (rollbackPath) rmSync(rollbackPath, { force: true });
+ throw error;
+ }
+ staged.push({ ...entry, temporaryPath, ...(rollback ? { rollback } : {}) });
+ }
+ } catch (error) {
+ for (const entry of staged) {
+ rmSync(entry.temporaryPath, { force: true });
+ if (entry.rollback) rmSync(entry.rollback.path, { force: true });
+ }
+ throw error;
+ }
+ const committed: typeof staged = [];
+ let preserveRollback = false;
+ try {
+ requireDirectory(configDirectory, "config");
+ for (const entry of staged) {
+ if (entry.action === "create") {
+ linkSync(entry.temporaryPath, entry.target);
+ committed.push(entry);
+ rmSync(entry.temporaryPath);
+ } else {
+ if (!entry.rollback) throw new Error(`Restore rollback is missing: ${entry.path}`);
+ assertFileUnchanged(entry.target, entry.rollback.snapshot, entry.path);
+ renameSync(entry.temporaryPath, entry.target);
+ committed.push(entry);
+ }
+ }
+ } catch (error) {
+ let rollbackIncomplete = false;
+ for (const entry of committed.toReversed()) {
+ try {
+ if (entry.action === "create") {
+ rmSync(entry.target, { force: true });
+ } else if (entry.rollback) {
+ renameSync(entry.rollback.path, entry.target);
+ }
+ } catch {
+ rollbackIncomplete = true;
+ }
+ }
+ if (rollbackIncomplete) {
+ preserveRollback = true;
+ throw new Error("Restore failed and rollback is incomplete; preserve .rollback files", {
+ cause: error,
+ });
+ }
+ throw error;
+ } finally {
+ for (const entry of staged) {
+ rmSync(entry.temporaryPath, { force: true });
+ if (!preserveRollback && entry.rollback) rmSync(entry.rollback.path, { force: true });
+ }
+ }
+ return Object.freeze({ applied: true, files: reportFiles });
+}
diff --git a/lib/summary-cache.test.ts b/lib/summary-cache.test.ts
new file mode 100644
index 0000000..9bd0765
--- /dev/null
+++ b/lib/summary-cache.test.ts
@@ -0,0 +1,53 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({ rpc: vi.fn() }));
+vi.mock("./supabase.ts", () => ({ getClient: vi.fn(async () => ({ rpc: mocks.rpc })) }));
+
+import { getSummaryVersion, storeSummaryVersion } from "./summary-cache.ts";
+
+const key = {
+ itemId: "00000000-0000-4000-8000-000000000001",
+ contentHash: "a".repeat(64),
+ profileHash: "b".repeat(64),
+ promptVersion: "summary-v1",
+};
+
+beforeEach(() => {
+ mocks.rpc.mockReset();
+});
+
+describe("summary cache RPC client", () => {
+ test("returns a validated cached version and sends exact hash keys", async () => {
+ mocks.rpc.mockResolvedValueOnce({
+ data: [{ one_liner: "One", summary_md: "Summary", impact_md: "Impact", model: "deepseek" }],
+ error: null,
+ });
+ await expect(getSummaryVersion(key.itemId, key.contentHash, key.profileHash, key.promptVersion)).resolves.toEqual({
+ oneLiner: "One",
+ summaryMd: "Summary",
+ impactMd: "Impact",
+ model: "deepseek",
+ });
+ expect(mocks.rpc).toHaveBeenCalledWith("get_summary_version", expect.objectContaining({
+ p_item_id: key.itemId,
+ p_content_hash: key.contentHash,
+ p_profile_hash: key.profileHash,
+ p_prompt_version: key.promptVersion,
+ }));
+ });
+
+ test("stores output through the server-only RPC and validates malformed rows", async () => {
+ mocks.rpc.mockResolvedValueOnce({ data: [{ stored: true }], error: null });
+ await expect(storeSummaryVersion(key.itemId, key.contentHash, key.profileHash, key.promptVersion, {
+ oneLiner: "One",
+ summaryMd: "Summary",
+ impactMd: "Impact",
+ model: "deepseek",
+ })).resolves.toBeUndefined();
+ expect(mocks.rpc).toHaveBeenCalledWith("store_summary_version", expect.objectContaining({
+ p_model: "deepseek",
+ p_summary_md: "Summary",
+ }));
+ await expect(getSummaryVersion(key.itemId, "bad", key.profileHash, key.promptVersion)).rejects.toMatchObject({ code: "DB_INTEGRITY_FAILED" });
+ });
+});
diff --git a/lib/summary-cache.ts b/lib/summary-cache.ts
new file mode 100644
index 0000000..3bc680b
--- /dev/null
+++ b/lib/summary-cache.ts
@@ -0,0 +1,92 @@
+import { getClient } from "./supabase.ts";
+import { assertDatabaseIntegrity, databaseData, isDatabaseUuid } from "./db-result.ts";
+
+export interface SummaryCacheValue {
+ readonly oneLiner: string;
+ readonly summaryMd: string;
+ readonly impactMd: string;
+ readonly model: string;
+}
+
+const HASH = /^[0-9a-f]{64}$/;
+
+function validateKey(itemId: string, contentHash: string, profileHash: string, promptVersion: string): void {
+ assertDatabaseIntegrity(
+ "summary-cache.key",
+ isDatabaseUuid(itemId) && HASH.test(contentHash) && HASH.test(profileHash) && /^[\x20-\x7e]{1,64}$/.test(promptVersion),
+ );
+}
+
+function value(record: Record): SummaryCacheValue {
+ assertDatabaseIntegrity(
+ "summary-cache.value",
+ typeof record.one_liner === "string" &&
+ record.one_liner.length > 0 &&
+ Buffer.byteLength(record.one_liner, "utf8") <= 240 &&
+ typeof record.summary_md === "string" &&
+ record.summary_md.length > 0 &&
+ Buffer.byteLength(record.summary_md, "utf8") <= 16_384 &&
+ typeof record.impact_md === "string" &&
+ record.impact_md.length > 0 &&
+ Buffer.byteLength(record.impact_md, "utf8") <= 16_384 &&
+ typeof record.model === "string" &&
+ record.model.length > 0 &&
+ Buffer.byteLength(record.model, "utf8") <= 100,
+ );
+ return {
+ oneLiner: record.one_liner as string,
+ summaryMd: record.summary_md as string,
+ impactMd: record.impact_md as string,
+ model: record.model as string,
+ };
+}
+
+export async function getSummaryVersion(
+ itemId: string,
+ contentHash: string,
+ profileHash: string,
+ promptVersion: string,
+): Promise {
+ validateKey(itemId, contentHash, profileHash, promptVersion);
+ const db = await getClient();
+ const data = databaseData(
+ "summary-cache.get",
+ await db.rpc("get_summary_version", {
+ p_content_hash: contentHash,
+ p_item_id: itemId,
+ p_profile_hash: profileHash,
+ p_prompt_version: promptVersion,
+ }),
+ );
+ assertDatabaseIntegrity("summary-cache.get", Array.isArray(data) && data.length <= 1);
+ if (data.length === 0) return undefined;
+ return value(data[0] as Record);
+}
+
+export async function storeSummaryVersion(
+ itemId: string,
+ contentHash: string,
+ profileHash: string,
+ promptVersion: string,
+ summary: SummaryCacheValue,
+): Promise {
+ validateKey(itemId, contentHash, profileHash, promptVersion);
+ const db = await getClient();
+ const data = databaseData(
+ "summary-cache.store",
+ await db.rpc("store_summary_version", {
+ p_content_hash: contentHash,
+ p_impact_md: summary.impactMd,
+ p_item_id: itemId,
+ p_model: summary.model,
+ p_one_liner: summary.oneLiner,
+ p_profile_hash: profileHash,
+ p_prompt_version: promptVersion,
+ p_summary_md: summary.summaryMd,
+ }),
+ );
+ assertDatabaseIntegrity(
+ "summary-cache.store",
+ Array.isArray(data) && data.length === 1 && typeof (data[0] as Record).stored === "boolean",
+ );
+}
diff --git a/lib/supabase.ts b/lib/supabase.ts
index 67e2872..3d5a178 100644
--- a/lib/supabase.ts
+++ b/lib/supabase.ts
@@ -1,64 +1,172 @@
// Supabase 封装。动态 import，`--dry` 路径不触达数据库。
import type { SupabaseClient } from "@supabase/supabase-js";
import type { NormalizedItem, SummarizedItem } from "./types.ts";
+import { assertDatabaseIntegrity, databaseData, isDatabaseUuid } from "./db-result.ts";
+import { loadSupabaseConfig } from "./runtime-config.ts";
+import { currentRuntimeEnvironment } from "./runtime-env.ts";
+import {
+ canonicalWorkKey,
+ hasBoundedSourceIdentity,
+ normalizeWorkUrl,
+ sourceIdentityHash,
+} from "./normalize.ts";
-let client: SupabaseClient | null = null;
+const clients = new WeakMap();
export async function getClient(): Promise {
- if (client) return client;
- const url = process.env.SUPABASE_URL;
- const key = process.env.SUPABASE_SERVICE_ROLE_KEY;
- if (!url || !key) throw new Error("缺少 SUPABASE_URL / SUPABASE_SERVICE_ROLE_KEY（见 .env.example）");
+ const environment = currentRuntimeEnvironment();
+ const existing = clients.get(environment);
+ if (existing) return existing;
+ const config = loadSupabaseConfig(environment);
const { createClient } = await import("@supabase/supabase-js");
- client = createClient(url, key, { auth: { persistSession: false } });
+ const client = createClient(config.url, config.serviceRoleKey, { auth: { persistSession: false } });
+ clients.set(environment, client);
return client;
}
-const row = (i: NormalizedItem) => ({
- source: i.source,
- external_id: i.externalId,
- url: i.url,
- title: i.title,
- authors: i.authors,
- abstract: i.abstract,
- content: i.content ?? null,
- published_at: i.publishedAt,
- signals: i.signals,
- raw_json: i.raw ?? null,
+const row = (item: NormalizedItem) => ({
+ canonical_key: canonicalWorkKey(item),
+ source: item.source,
+ external_id: item.externalId,
+ url: item.url,
+ title: item.title,
+ authors: item.authors,
+ abstract: item.abstract,
+ content: item.content ?? null,
+ published_at: item.publishedAt,
+ signals: item.signals,
+ provenance: item.provenance?.length
+ ? item.provenance
+ : [{
+ source: item.source,
+ externalId: item.externalId,
+ url: normalizeWorkUrl(item.url) || item.url,
+ signals: item.signals,
+ }],
+ raw_json: item.raw ?? null,
});
-/** 落库去重：按 (source, external_id) upsert，已存在则不重复（替代 seen.json）。返回带 DB id 的映射。 */
-export async function upsertItems(items: NormalizedItem[]): Promise> {
- const db = await getClient();
- const { data, error } = await db
- .from("items")
- .upsert(items.map(row), { onConflict: "source,external_id" })
- .select("id, source, external_id");
- if (error) throw error;
- const map = new Map();
- for (const r of data ?? []) map.set(`${r.source}:${r.external_id}`, r.id as string);
- return map;
+function mappedItemIds(
+ operation: string,
+ items: readonly NormalizedItem[],
+ idByKey: ReadonlyMap,
+): string[] {
+ const keys = new Set();
+ const ids = new Set();
+ const mapped: string[] = [];
+ for (const item of items) {
+ const key = `${item.source}:${item.externalId}`;
+ const id = idByKey.get(key);
+ assertDatabaseIntegrity(
+ operation,
+ !keys.has(key) && isDatabaseUuid(id) && !ids.has(id),
+ );
+ keys.add(key);
+ ids.add(id);
+ mapped.push(id);
+ }
+ return mapped;
}
-export async function saveSummaries(
- items: SummarizedItem[],
- idByKey: Map,
-): Promise {
+function recordValue(operation: string, value: unknown): Record {
+ assertDatabaseIntegrity(
+ operation,
+ value !== null && typeof value === "object" && !Array.isArray(value),
+ );
+ return value as Record;
+}
+
+function relatedRecord(operation: string, value: unknown): Record {
+ if (Array.isArray(value)) {
+ assertDatabaseIntegrity(operation, value.length === 1);
+ }
+ const related = Array.isArray(value) ? value[0] : value;
+ return recordValue(operation, related);
+}
+
+function relatedTitle(operation: string, value: unknown): string {
+ const title = relatedRecord(operation, value).title;
+ assertDatabaseIntegrity(operation, typeof title === "string");
+ return title;
+}
+
+export interface PipelineItemOwner {
+ runDate: string;
+ runId: string;
+}
+
+/** Persist one row per canonical work and map every incoming source identity to that row. */
+export async function upsertItems(
+ items: NormalizedItem[],
+ pipelineOwner?: PipelineItemOwner,
+): Promise> {
+ if (!items.length) return new Map();
+ const expected = new Set(items.map((item) => `${item.source}:${item.externalId}`));
+ const canonicalKeys = new Set(items.map(canonicalWorkKey));
+ const sourceIdentities = new Set(items.map((item) => sourceIdentityHash(item.source, item.externalId)));
+ assertDatabaseIntegrity(
+ "items.upsert",
+ expected.size === items.length &&
+ canonicalKeys.size === items.length &&
+ sourceIdentities.size === items.length &&
+ items.every(hasBoundedSourceIdentity) &&
+ (pipelineOwner === undefined || (
+ /^\d{4}-\d{2}-\d{2}$/.test(pipelineOwner.runDate) &&
+ isDatabaseUuid(pipelineOwner.runId)
+ )),
+ );
const db = await getClient();
- const rows = items.map((i) => ({
- item_id: idByKey.get(`${i.source}:${i.externalId}`),
- summary_md: i.summaryMd,
- impact_md: i.impactMd,
- one_liner: i.oneLiner,
- score: i.score,
- rank: i.rank,
- model: "deepseek",
- }));
- // 同日/重跑时替换这些 item 的旧摘要，避免每篇堆叠多条。
- const ids = rows.map((r) => r.item_id).filter(Boolean) as string[];
- if (ids.length) await db.from("summaries").delete().in("item_id", ids);
- const { error } = await db.from("summaries").insert(rows);
- if (error) throw error;
+ const rows = items.map(row);
+ let result;
+ for (let attempt = 1; attempt <= 2; attempt += 1) {
+ result = pipelineOwner
+ ? await db.rpc("upsert_pipeline_items", {
+ p_items: rows,
+ p_run_date: pipelineOwner.runDate,
+ p_run_id: pipelineOwner.runId,
+ })
+ : await db
+ .from("items")
+ .upsert(rows, { onConflict: "canonical_key" })
+ .select("id, canonical_key, source, external_id");
+ const errorCode = result.error && typeof result.error === "object" && "code" in result.error
+ ? String(result.error.code)
+ : "";
+ if (!result.error || attempt === 2 || (errorCode !== "23505" && errorCode !== "40001")) break;
+ }
+ assertDatabaseIntegrity("items.upsert", result !== undefined);
+ const data = databaseData("items.upsert", result);
+ assertDatabaseIntegrity("items.upsert", Array.isArray(data));
+ const map = new Map();
+ const returnedIds = new Set();
+ for (const record of data) {
+ const canonicalKey = record?.canonical_key;
+ const id = record?.id;
+ const returnedSourceKey = typeof record?.source === "string" && typeof record?.external_id === "string"
+ ? `${record.source}:${record.external_id}`
+ : undefined;
+ const incoming = returnedSourceKey && expected.has(returnedSourceKey)
+ ? items.find((item) => `${item.source}:${item.externalId}` === returnedSourceKey)
+ : items.find((item) => canonicalWorkKey(item) === canonicalKey);
+ assertDatabaseIntegrity(
+ "items.upsert",
+ typeof canonicalKey === "string" &&
+ canonicalKey.length >= 3 &&
+ canonicalKey.length <= 512 &&
+ isDatabaseUuid(id) &&
+ !returnedIds.has(id),
+ );
+ assertDatabaseIntegrity("items.upsert", incoming !== undefined);
+ const sourceKey = `${incoming.source}:${incoming.externalId}`;
+ assertDatabaseIntegrity("items.upsert", expected.has(sourceKey) && !map.has(sourceKey));
+ map.set(sourceKey, id);
+ returnedIds.add(id);
+ }
+ assertDatabaseIntegrity(
+ "items.upsert",
+ map.size === expected.size && [...expected].every((key) => map.has(key)),
+ );
+ return map;
}
/** 取用户的行为信号：带正文的批注（高亮引文/便签想法）+ 提问，用于画像精炼。 */
@@ -67,23 +175,49 @@ export async function fetchSignals(): Promise<{
chats: { content: string; title: string }[];
}> {
const db = await getClient();
- const { data: a } = await db
- .from("annotations")
- .select("type, body, items(title)")
- .not("body", "is", null)
- .order("created_at", { ascending: false })
- .limit(200);
- const { data: c } = await db
- .from("chats")
- .select("content, items(title)")
- .eq("role", "user")
- .order("created_at", { ascending: false })
- .limit(200);
- const title = (x: any): string =>
- Array.isArray(x?.items) ? x.items[0]?.title ?? "" : x?.items?.title ?? "";
+ const a = databaseData(
+ "annotations.fetchSignals",
+ await db
+ .from("annotations")
+ .select("type, body, items(title)")
+ .not("body", "is", null)
+ .order("created_at", { ascending: false })
+ .limit(200),
+ );
+ assertDatabaseIntegrity("annotations.fetchSignals", Array.isArray(a));
+ const annotations = a.map((value) => {
+ const record = recordValue("annotations.fetchSignals", value);
+ assertDatabaseIntegrity(
+ "annotations.fetchSignals",
+ typeof record.type === "string" && typeof record.body === "string",
+ );
+ return {
+ type: record.type,
+ body: record.body,
+ title: relatedTitle("annotations.fetchSignals", record.items),
+ };
+ });
+ const c = databaseData(
+ "chats.fetchSignals",
+ await db
+ .from("chats")
+ .select("content, items(title)")
+ .eq("role", "user")
+ .order("created_at", { ascending: false })
+ .limit(200),
+ );
+ assertDatabaseIntegrity("chats.fetchSignals", Array.isArray(c));
+ const chats = c.map((value) => {
+ const record = recordValue("chats.fetchSignals", value);
+ assertDatabaseIntegrity("chats.fetchSignals", typeof record.content === "string");
+ return {
+ content: record.content,
+ title: relatedTitle("chats.fetchSignals", record.items),
+ };
+ });
return {
- annotations: (a ?? []).map((x: any) => ({ type: x.type, body: x.body, title: title(x) })),
- chats: (c ?? []).map((x: any) => ({ content: x.content, title: title(x) })),
+ annotations,
+ chats,
};
}
@@ -93,25 +227,86 @@ export async function fetchFeedback(
): Promise<{ rating: string; note: string | null; title: string; source: string; category: string }[]> {
const db = await getClient();
const since = new Date(Date.now() - days * 86_400_000).toISOString();
- const { data } = await db
- .from("feedback")
- .select("rating, note, created_at, items(title, source, signals)")
- .gte("created_at", since)
- .order("created_at", { ascending: false })
- .limit(200);
- const item = (x: any) => (Array.isArray(x?.items) ? x.items[0] : x?.items) ?? {};
- return (data ?? []).map((x: any) => {
- const it = item(x);
+ const data = databaseData(
+ "feedback.fetchRecent",
+ await db
+ .from("feedback")
+ .select("rating, note, created_at, items(title, source, signals)")
+ .gte("created_at", since)
+ .order("created_at", { ascending: false })
+ .limit(200),
+ );
+ assertDatabaseIntegrity("feedback.fetchRecent", Array.isArray(data));
+ return data.map((value) => {
+ const record = recordValue("feedback.fetchRecent", value);
+ assertDatabaseIntegrity(
+ "feedback.fetchRecent",
+ (record.rating === "up" || record.rating === "down") &&
+ (record.note === null || typeof record.note === "string"),
+ );
+ const item = relatedRecord("feedback.fetchRecent", record.items);
+ assertDatabaseIntegrity(
+ "feedback.fetchRecent",
+ typeof item.title === "string" &&
+ typeof item.source === "string" &&
+ item.signals !== null &&
+ typeof item.signals === "object" &&
+ !Array.isArray(item.signals),
+ );
+ const category = (item.signals as Record).category;
+ assertDatabaseIntegrity(
+ "feedback.fetchRecent",
+ category === undefined || typeof category === "string" || typeof category === "number",
+ );
return {
- rating: x.rating,
- note: x.note,
- title: it.title ?? "",
- source: it.source ?? "",
- category: String(it.signals?.category ?? ""),
+ rating: record.rating,
+ note: record.note,
+ title: item.title,
+ source: item.source,
+ category: category === undefined ? "" : String(category),
};
});
}
+/** Remove items already shown in recent Top5 digests without changing identity. */
+export async function filterRecentlyDelivered(
+ items: readonly NormalizedItem[],
+ days = 14,
+ now = new Date(),
+): Promise {
+ if (!items.length) return [];
+ if (!Number.isInteger(days) || days < 1 || days > 90) throw new Error("Invalid novelty lookback");
+ const from = new Date(now.getTime() - days * 86_400_000);
+ const db = await getClient();
+ const delivered = databaseData(
+ "novelty.successfulDeliveries",
+ await db.rpc("successful_delivery_canonical_keys", {
+ p_since: from.toISOString(),
+ p_until: now.toISOString(),
+ }),
+ );
+ assertDatabaseIntegrity("novelty.successfulDeliveries", Array.isArray(delivered));
+ const keys = new Set();
+ const identities = new Set();
+ for (const value of delivered) {
+ const record = recordValue("novelty.successfulDeliveries", value);
+ assertDatabaseIntegrity(
+ "novelty.successfulDeliveries",
+ typeof record.canonical_key === "string" &&
+ record.canonical_key.length >= 3 &&
+ record.canonical_key.length <= 512 &&
+ typeof record.identity_hash === "string" &&
+ /^[a-f0-9]{64}$/.test(record.identity_hash),
+ );
+ keys.add(record.canonical_key);
+ identities.add(record.identity_hash);
+ }
+ return items.filter((item) =>
+ !keys.has(canonicalWorkKey(item)) &&
+ !identities.has(sourceIdentityHash(item.source, item.externalId)),
+ );
+}
+
/** 把反馈数组拼成给 LLM 的简短摘要（喜欢/不喜欢两列）。 */
export function feedbackSummary(
fb: { rating: string; note: string | null; title: string; source: string; category: string }[],
@@ -131,14 +326,59 @@ export async function saveDigest(
top5: SummarizedItem[],
idByKey: Map,
renderedMd: string,
+ pipelineRunId?: string,
): Promise {
+ const validInteger = (value: unknown): value is number =>
+ typeof value === "number" &&
+ Number.isInteger(value) &&
+ value >= -2_147_483_648 &&
+ value <= 2_147_483_647;
+ assertDatabaseIntegrity(
+ "digests.save",
+ top5.length >= 1 &&
+ top5.length <= 5 &&
+ typeof renderedMd === "string" &&
+ Buffer.byteLength(renderedMd, "utf8") >= 1 &&
+ Buffer.byteLength(renderedMd, "utf8") <= 1_048_576 &&
+ top5.every(
+ (item, index) =>
+ typeof item.oneLiner === "string" &&
+ typeof item.summaryMd === "string" &&
+ typeof item.impactMd === "string" &&
+ validInteger(item.score) &&
+ item.score >= 0 &&
+ item.score <= 100 &&
+ validInteger(item.rank) &&
+ item.rank === index + 1,
+ ) &&
+ (pipelineRunId === undefined || isDatabaseUuid(pipelineRunId)),
+ );
+ const ids = mappedItemIds("digests.save", top5, idByKey);
const db = await getClient();
- const ids = top5.map((i) => idByKey.get(`${i.source}:${i.externalId}`)).filter(Boolean);
- const { error } = await db
- .from("digests")
- .upsert(
- { digest_date: digestDate, top5_item_ids: ids, rendered_md: renderedMd, emailed_at: new Date().toISOString() },
- { onConflict: "digest_date" },
- );
- if (error) throw error;
+ const saved = databaseData(
+ "digests.save",
+ await db.rpc(pipelineRunId ? "store_pipeline_digest_bundle" : "store_digest_bundle", {
+ p_digest_date: digestDate,
+ p_impact_mds: top5.map((item) => item.impactMd),
+ p_item_ids: ids,
+ p_one_liners: top5.map((item) => item.oneLiner),
+ p_ranks: top5.map((item) => item.rank),
+ p_rendered_md: renderedMd,
+ p_scores: top5.map((item) => item.score),
+ p_summary_mds: top5.map((item) => item.summaryMd),
+ ...(pipelineRunId ? { p_run_id: pipelineRunId } : {}),
+ }),
+ );
+ assertDatabaseIntegrity("digests.save", Array.isArray(saved) && saved.length === 1);
+ const record = recordValue("digests.save", saved[0]);
+ assertDatabaseIntegrity(
+ "digests.save",
+ (record.outcome === "inserted" || record.outcome === "existing") &&
+ record.persisted_digest_date === digestDate &&
+ record.persisted_rendered_md === renderedMd &&
+ record.persisted_summary_count === ids.length &&
+ Array.isArray(record.persisted_top5_item_ids) &&
+ record.persisted_top5_item_ids.length === ids.length &&
+ record.persisted_top5_item_ids.every((id, index) => id === ids[index]),
+ );
}
diff --git a/lib/time.ts b/lib/time.ts
new file mode 100644
index 0000000..3a9d523
--- /dev/null
+++ b/lib/time.ts
@@ -0,0 +1,41 @@
+export const SHANGHAI_TIME_ZONE = "Asia/Shanghai" as const;
+
+const shanghaiDateFormatter = new Intl.DateTimeFormat("en-CA-u-ca-gregory-nu-latn", {
+ day: "2-digit",
+ month: "2-digit",
+ timeZone: SHANGHAI_TIME_ZONE,
+ year: "numeric",
+});
+
+function requireValidDate(date: Date): void {
+ if (!(date instanceof Date) || !Number.isFinite(date.getTime())) {
+ throw new TypeError("Invalid date returned by clock");
+ }
+}
+
+export function shanghaiDateKey(date: Date = new Date()): string {
+ requireValidDate(date);
+ const parts = Object.fromEntries(
+ shanghaiDateFormatter
+ .formatToParts(date)
+ .filter(({ type }) => type === "year" || type === "month" || type === "day")
+ .map(({ type, value }) => [type, value]),
+ );
+ return `${parts.year}-${parts.month}-${parts.day}`;
+}
+
+export interface ShanghaiRunTime {
+ readonly date: string;
+ readonly startedAt: string;
+ readonly timeZone: typeof SHANGHAI_TIME_ZONE;
+}
+
+export function lockShanghaiRunTime(clock: () => Date = () => new Date()): ShanghaiRunTime {
+ const instant = clock();
+ requireValidDate(instant);
+ return Object.freeze({
+ date: shanghaiDateKey(instant),
+ startedAt: instant.toISOString(),
+ timeZone: SHANGHAI_TIME_ZONE,
+ });
+}
diff --git a/lib/types.ts b/lib/types.ts
index df5a4ed..9a866a0 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -1,4 +1,11 @@
-export type SourceId = "arxiv" | "huggingface" | "github" | "blog" | "x" | "facebook";
+export type SourceId = "arxiv" | "huggingface" | "github" | "blog" | "acl" | "openreview" | "openalex";
+
+export interface SourceObservation {
+ source: SourceId;
+ externalId: string;
+ url: string;
+ signals: Record;
+}
/** 各 fetcher 归一化后的统一形态。 */
export interface NormalizedItem {
@@ -11,6 +18,7 @@ export interface NormalizedItem {
content?: string; // 更长正文（如有）
publishedAt: string; // ISO 8601
signals: Record; // 排名信号：upvotes / stars / category / sourceWeight ...
+ provenance?: readonly SourceObservation[];
raw?: unknown;
}
@@ -19,6 +27,9 @@ export interface RankedItem extends NormalizedItem {
score: number; // 0–100
rank: number; // 1 = 最高
rationale: string;
+ /** True when the deterministic safety fallback was used for this item. */
+ degraded?: boolean;
+ degradedReason?: "llm_rank_failed" | "llm_summary_failed";
}
/** 总结后追加概要与影响。 */
diff --git a/package-lock.json b/package-lock.json
index 1ee513c..772fcfb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -10,12 +10,135 @@
"dependencies": {
"@supabase/supabase-js": "^2.108.2",
"fast-xml-parser": "^5.9.3",
- "openai": "^6.45.0"
+ "nodemailer": "^9.0.3",
+ "openai": "^6.45.0",
+ "zod": "^4.4.3"
},
"devDependencies": {
+ "@eslint/js": "^10.0.1",
"@types/node": "^26.0.1",
+ "@types/nodemailer": "^7.0.12",
+ "@vitest/coverage-v8": "^4.1.10",
+ "eslint": "^10.6.0",
+ "fast-check": "^4.9.0",
+ "msw": "^2.15.0",
+ "supabase": "2.109.1",
"tsx": "^4.22.4",
- "typescript": "^6.0.3"
+ "typescript": "^6.0.3",
+ "typescript-eslint": "^8.63.0",
+ "vitest": "^4.1.10"
+ },
+ "engines": {
+ "node": ">=20.19.0 <26"
+ }
+ },
+ "node_modules/@babel/helper-string-parser": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+ "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-validator-identifier": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+ "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/parser": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz",
+ "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/types": "^7.29.7"
+ },
+ "bin": {
+ "parser": "bin/babel-parser.js"
+ },
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/@babel/types": {
+ "version": "7.29.7",
+ "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz",
+ "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-string-parser": "^7.29.7",
+ "@babel/helper-validator-identifier": "^7.29.7"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@bcoe/v8-coverage": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz",
+ "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@ecies/ciphers": {
+ "version": "0.2.6",
+ "resolved": "https://registry.npmjs.org/@ecies/ciphers/-/ciphers-0.2.6.tgz",
+ "integrity": "sha512-patgsRPKGkhhoBjETV4XxD0En4ui5fbX0hzayqI3M8tvNMGUoUvmyYAIWwlxBc1KX5cturfqByYdj5bYGRpN9g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "bun": ">=1",
+ "deno": ">=2.7.10",
+ "node": ">=16"
+ },
+ "peerDependencies": {
+ "@noble/ciphers": "^1.0.0"
+ }
+ },
+ "node_modules/@emnapi/core": {
+ "version": "1.11.1",
+ "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.11.1.tgz",
+ "integrity": "sha512-RSvbQmHzdKzNsLYa/wHrbc3KN4sYLKAdPZxqiM2HATqv/SBk2/ENSHpvXGaLOMcsAyz0poEGqkmmKYG3OWiJEQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "@emnapi/wasi-threads": "1.2.2",
+ "tslib": "^2.4.0"
+ }
+ },
+ "node_modules/@emnapi/runtime": {
+ "version": "1.11.1",
+ "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.1.tgz",
+ "integrity": "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "tslib": "^2.4.0"
+ }
+ },
+ "node_modules/@emnapi/wasi-threads": {
+ "version": "1.2.2",
+ "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.2.tgz",
+ "integrity": "sha512-c95qOXkHdydNKhscBTebqEC1CVAZpyqOfVfBzQ1qgzyl3gfeldUjIggDbIZgDKsHLgnsM+igH7TJ/eAasaVuMA==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "tslib": "^2.4.0"
}
},
"node_modules/@esbuild/aix-ppc64": {
@@ -460,241 +583,2783 @@
"node": ">=18"
}
},
- "node_modules/@nodable/entities": {
- "version": "2.2.0",
- "resolved": "https://registry.npmjs.org/@nodable/entities/-/entities-2.2.0.tgz",
- "integrity": "sha512-9uGyhaQavEUMC8AIddIjau4NsnsXhou+j5sBAGojCM1oxmQpVKTWR/9JxABD6UAv12vpIms55fPZKFQEhG6uBg==",
- "funding": [
- {
- "type": "github",
- "url": "https://github.com/sponsors/nodable"
- }
- ],
- "license": "MIT"
- },
- "node_modules/@supabase/auth-js": {
- "version": "2.108.2",
- "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.108.2.tgz",
- "integrity": "sha512-tNaQmBgodDZwgB40mRwVbxFy8IDYwjdpcZ0BYrWiwlULCSQoJj4QoG4zgJT7QRPXcqipefNOzvO/qAu4dF98ag==",
+ "node_modules/@eslint-community/eslint-utils": {
+ "version": "4.9.1",
+ "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
+ "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
+ "dev": true,
"license": "MIT",
"dependencies": {
- "tslib": "2.8.1"
+ "eslint-visitor-keys": "^3.4.3"
},
"engines": {
- "node": ">=20.0.0"
+ "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ },
+ "peerDependencies": {
+ "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
}
},
- "node_modules/@supabase/functions-js": {
- "version": "2.108.2",
- "resolved": "https://registry.npmjs.org/@supabase/functions-js/-/functions-js-2.108.2.tgz",
- "integrity": "sha512-RNUX8EiBy3iLwAX19jtRzLyePnl11/fHcgwDHLnpKcDSXt/5qBnh3LUwAtIjT21Q66QsmNUR2esrHziLCpNubw==",
+ "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+ "version": "3.4.3",
+ "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+ "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/@eslint-community/regexpp": {
+ "version": "4.12.2",
+ "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
+ "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
+ "dev": true,
"license": "MIT",
+ "engines": {
+ "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+ }
+ },
+ "node_modules/@eslint/config-array": {
+ "version": "0.23.5",
+ "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.23.5.tgz",
+ "integrity": "sha512-Y3kKLvC1dvTOT+oGlqNQ1XLqK6D1HU2YXPc52NmAlJZbMMWDzGYXMiPRJ8TYD39muD/OTjlZmNJ4ib7dvSrMBA==",
+ "dev": true,
+ "license": "Apache-2.0",
"dependencies": {
- "tslib": "2.8.1"
+ "@eslint/object-schema": "^3.0.5",
+ "debug": "^4.3.1",
+ "minimatch": "^10.2.4"
},
"engines": {
- "node": ">=20.0.0"
+ "node": "^20.19.0 || ^22.13.0 || >=24"
}
},
- "node_modules/@supabase/phoenix": {
- "version": "0.4.4",
- "resolved": "https://registry.npmjs.org/@supabase/phoenix/-/phoenix-0.4.4.tgz",
- "integrity": "sha512-Gt0pqoXuIqX/8dvG0OKp/wMCobXNH3klNbUPBNyOfN0YA1IswrM3HyWFMOPk1Jy+BRaIyDPcFx4jLBwHNmlyfQ==",
- "license": "MIT"
- },
- "node_modules/@supabase/postgrest-js": {
- "version": "2.108.2",
- "resolved": "https://registry.npmjs.org/@supabase/postgrest-js/-/postgrest-js-2.108.2.tgz",
- "integrity": "sha512-GQ28/Y8hk3CFmkb3kXH1h/AQx6JIYSQfO0CJMRVBcEKZoNy6C45cXAZ4fcJvRC5Id0cs6xnkUV0+c0rIocigsw==",
- "license": "MIT",
+ "node_modules/@eslint/config-helpers": {
+ "version": "0.6.0",
+ "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.6.0.tgz",
+ "integrity": "sha512-ii6Bw9jJ2zi2cWA2Z+9/QZ/+3DX6kwaV5Q986D/CdP3Lap3w/pgQZ373FV7byY/i7L4IRH/G43I5dz1ClsCbpA==",
+ "dev": true,
+ "license": "Apache-2.0",
"dependencies": {
- "tslib": "2.8.1"
+ "@eslint/core": "^1.2.1"
},
"engines": {
- "node": ">=20.0.0"
+ "node": "^20.19.0 || ^22.13.0 || >=24"
}
},
- "node_modules/@supabase/realtime-js": {
- "version": "2.108.2",
- "resolved": "https://registry.npmjs.org/@supabase/realtime-js/-/realtime-js-2.108.2.tgz",
- "integrity": "sha512-aAGxCSUemZvQIibnCdvNvgaKib28I4rfrNjKbQ9cG1uBLwUsI7hVpGXgEbypCCDhLjQlDTAiJlu7rgljYUT73g==",
- "license": "MIT",
+ "node_modules/@eslint/core": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/@eslint/core/-/core-1.2.1.tgz",
+ "integrity": "sha512-MwcE1P+AZ4C6DWlpin/OmOA54mmIZ/+xZuJiQd4SyB29oAJjN30UW9wkKNptW2ctp4cEsvhlLY/CsQ1uoHDloQ==",
+ "dev": true,
+ "license": "Apache-2.0",
"dependencies": {
- "@supabase/phoenix": "^0.4.2",
- "tslib": "2.8.1"
+ "@types/json-schema": "^7.0.15"
},
"engines": {
- "node": ">=20.0.0"
+ "node": "^20.19.0 || ^22.13.0 || >=24"
}
},
- "node_modules/@supabase/storage-js": {
- "version": "2.108.2",
- "resolved": "https://registry.npmjs.org/@supabase/storage-js/-/storage-js-2.108.2.tgz",
- "integrity": "sha512-TVZPQxXGxY2+A6yTtm77zUHsh70lBhYUEaJL8RQC+BghcX/ygiMG/rmXrNVBce30/WAeNPa8FiG8HbqlGeV05g==",
+ "node_modules/@eslint/js": {
+ "version": "10.0.1",
+ "resolved": "https://registry.npmjs.org/@eslint/js/-/js-10.0.1.tgz",
+ "integrity": "sha512-zeR9k5pd4gxjZ0abRoIaxdc7I3nDktoXZk2qOv9gCNWx3mVwEn32VRhyLaRsDiJjTs0xq/T8mfPtyuXu7GWBcA==",
+ "dev": true,
"license": "MIT",
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ },
+ "funding": {
+ "url": "https://eslint.org/donate"
+ },
+ "peerDependencies": {
+ "eslint": "^10.0.0"
+ },
+ "peerDependenciesMeta": {
+ "eslint": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@eslint/object-schema": {
+ "version": "3.0.5",
+ "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-3.0.5.tgz",
+ "integrity": "sha512-vqTaUEgxzm+YDSdElad6PiRoX4t8VGDjCtt05zn4nU810UIx/uNEV7/lZJ6KwFThKZOzOxzXy48da+No7HZaMw==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ }
+ },
+ "node_modules/@eslint/plugin-kit": {
+ "version": "0.7.2",
+ "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.7.2.tgz",
+ "integrity": "sha512-+CNAzxglkrpNf/kKywqQfk74QjtceuOE7Qm+AF8miRvPF/wmmK5+OJOgVh3AVTT3RP2mH3+FOaxlE5v72owk0A==",
+ "dev": true,
+ "license": "Apache-2.0",
"dependencies": {
- "iceberg-js": "^0.8.1",
- "tslib": "2.8.1"
+ "@eslint/core": "^1.2.1",
+ "levn": "^0.4.1"
},
"engines": {
- "node": ">=20.0.0"
+ "node": "^20.19.0 || ^22.13.0 || >=24"
}
},
- "node_modules/@supabase/supabase-js": {
- "version": "2.108.2",
- "resolved": "https://registry.npmjs.org/@supabase/supabase-js/-/supabase-js-2.108.2.tgz",
- "integrity": "sha512-hFhnPveb5JQg4a0QYicM0swT253YHMdfeRAl2BKHOlI5VAzuHxUGSr8RbwNLYNPauWOgQMS1H8sz8bvYlgwUfQ==",
- "license": "MIT",
+ "node_modules/@humanfs/core": {
+ "version": "0.19.2",
+ "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz",
+ "integrity": "sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==",
+ "dev": true,
+ "license": "Apache-2.0",
"dependencies": {
- "@supabase/auth-js": "2.108.2",
- "@supabase/functions-js": "2.108.2",
- "@supabase/postgrest-js": "2.108.2",
- "@supabase/realtime-js": "2.108.2",
- "@supabase/storage-js": "2.108.2"
+ "@humanfs/types": "^0.15.0"
},
"engines": {
- "node": ">=20.0.0"
+ "node": ">=18.18.0"
}
},
- "node_modules/@types/node": {
- "version": "26.0.1",
- "resolved": "https://registry.npmjs.org/@types/node/-/node-26.0.1.tgz",
- "integrity": "sha512-fc3KiUoBt6kie0N9bIW3E47vZsuaMf0PM2AaUpLCLT0s/LvX1nxAim6Fc049cNxODPpGm6qRAuUOB86SkRuPQw==",
+ "node_modules/@humanfs/node": {
+ "version": "0.16.8",
+ "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.8.tgz",
+ "integrity": "sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==",
"dev": true,
- "license": "MIT",
+ "license": "Apache-2.0",
"dependencies": {
- "undici-types": "~8.3.0"
+ "@humanfs/core": "^0.19.2",
+ "@humanfs/types": "^0.15.0",
+ "@humanwhocodes/retry": "^0.4.0"
+ },
+ "engines": {
+ "node": ">=18.18.0"
}
},
- "node_modules/anynum": {
- "version": "1.0.1",
- "resolved": "https://registry.npmjs.org/anynum/-/anynum-1.0.1.tgz",
- "integrity": "sha512-N6//FLET/tXYNM/F6ABca1oH6fWB+KlTt909Le28WMDBk8oaT4vY17DCrwg2MvmuqUKt3Ni4N5dGJ/EoBgcO6A==",
- "funding": [
- {
- "type": "github",
- "url": "https://github.com/sponsors/NaturalIntelligence"
- }
- ],
- "license": "MIT"
+ "node_modules/@humanfs/types": {
+ "version": "0.15.0",
+ "resolved": "https://registry.npmjs.org/@humanfs/types/-/types-0.15.0.tgz",
+ "integrity": "sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=18.18.0"
+ }
},
- "node_modules/esbuild": {
- "version": "0.28.1",
- "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz",
- "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==",
+ "node_modules/@humanwhocodes/module-importer": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+ "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
"dev": true,
- "hasInstallScript": true,
- "license": "MIT",
- "bin": {
- "esbuild": "bin/esbuild"
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=12.22"
},
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/nzakas"
+ }
+ },
+ "node_modules/@humanwhocodes/retry": {
+ "version": "0.4.3",
+ "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
+ "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
+ "dev": true,
+ "license": "Apache-2.0",
"engines": {
- "node": ">=18"
+ "node": ">=18.18"
},
- "optionalDependencies": {
- "@esbuild/aix-ppc64": "0.28.1",
- "@esbuild/android-arm": "0.28.1",
- "@esbuild/android-arm64": "0.28.1",
- "@esbuild/android-x64": "0.28.1",
- "@esbuild/darwin-arm64": "0.28.1",
- "@esbuild/darwin-x64": "0.28.1",
- "@esbuild/freebsd-arm64": "0.28.1",
- "@esbuild/freebsd-x64": "0.28.1",
- "@esbuild/linux-arm": "0.28.1",
- "@esbuild/linux-arm64": "0.28.1",
- "@esbuild/linux-ia32": "0.28.1",
- "@esbuild/linux-loong64": "0.28.1",
- "@esbuild/linux-mips64el": "0.28.1",
- "@esbuild/linux-ppc64": "0.28.1",
- "@esbuild/linux-riscv64": "0.28.1",
- "@esbuild/linux-s390x": "0.28.1",
- "@esbuild/linux-x64": "0.28.1",
- "@esbuild/netbsd-arm64": "0.28.1",
- "@esbuild/netbsd-x64": "0.28.1",
- "@esbuild/openbsd-arm64": "0.28.1",
- "@esbuild/openbsd-x64": "0.28.1",
- "@esbuild/openharmony-arm64": "0.28.1",
- "@esbuild/sunos-x64": "0.28.1",
- "@esbuild/win32-arm64": "0.28.1",
- "@esbuild/win32-ia32": "0.28.1",
- "@esbuild/win32-x64": "0.28.1"
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/nzakas"
}
},
- "node_modules/fast-xml-builder": {
- "version": "1.2.0",
- "resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.2.0.tgz",
- "integrity": "sha512-00aAWieqff+ZJhsXA4g1g7M8k+7AYoMUUHF+/zFb5U6Uv/P0Vl4QZo84/IcufzYalLuEj9928bXN9PbbFzMF0Q==",
- "funding": [
- {
- "type": "github",
- "url": "https://github.com/sponsors/NaturalIntelligence"
- }
- ],
+ "node_modules/@inquirer/ansi": {
+ "version": "2.0.7",
+ "resolved": "https://registry.npmjs.org/@inquirer/ansi/-/ansi-2.0.7.tgz",
+ "integrity": "sha512-3eTuUO1vH2cZm2ZKHeQxnOqlTi9EfZDGgIe3BL3I4u+rJHocr9Fz86M4fjYABPvFnQG/gGK551HqDiIcETwU6Q==",
+ "dev": true,
"license": "MIT",
- "dependencies": {
- "path-expression-matcher": "^1.5.0",
- "xml-naming": "^0.1.0"
+ "engines": {
+ "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
}
},
- "node_modules/fast-xml-parser": {
- "version": "5.9.3",
- "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.9.3.tgz",
- "integrity": "sha512-brCNCeScma/kqa54J4PIDriSSSLssRkuYaUCpvHJulGc3HGI/xxKUCTDcYkAdqJsyb//ydpbxecjC3hB9+tb/g==",
- "funding": [
- {
- "type": "github",
- "url": "https://github.com/sponsors/NaturalIntelligence"
- }
- ],
+ "node_modules/@inquirer/confirm": {
+ "version": "6.1.1",
+ "resolved": "https://registry.npmjs.org/@inquirer/confirm/-/confirm-6.1.1.tgz",
+ "integrity": "sha512-eb8DBZcz/2qHWQda4rk2JiQk5h9QV/cVHi1yjt0f69WFZMRFn0sJTye3EAP8icut8UDMjQPsaH5KbcOogefrFQ==",
+ "dev": true,
"license": "MIT",
"dependencies": {
- "@nodable/entities": "^2.2.0",
+ "@inquirer/core": "^11.2.1",
+ "@inquirer/type": "^4.0.7"
+ },
+ "engines": {
+ "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+ },
+ "peerDependencies": {
+ "@types/node": ">=18"
+ },
+ "peerDependenciesMeta": {
+ "@types/node": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@inquirer/core": {
+ "version": "11.2.1",
+ "resolved": "https://registry.npmjs.org/@inquirer/core/-/core-11.2.1.tgz",
+ "integrity": "sha512-Qd6GJT1yVyrZZCfN8W2qKF5ApmqryXRhRKCuip8h01x2w/esJQ2XIYc6f9abMIHgKQdBfFTSOdbHRLAhuM09UA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@inquirer/ansi": "^2.0.7",
+ "@inquirer/figures": "^2.0.7",
+ "@inquirer/type": "^4.0.7",
+ "cli-width": "^4.1.0",
+ "fast-wrap-ansi": "^0.2.0",
+ "mute-stream": "^3.0.0",
+ "signal-exit": "^4.1.0"
+ },
+ "engines": {
+ "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+ },
+ "peerDependencies": {
+ "@types/node": ">=18"
+ },
+ "peerDependenciesMeta": {
+ "@types/node": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@inquirer/figures": {
+ "version": "2.0.7",
+ "resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-2.0.7.tgz",
+ "integrity": "sha512-aJ8TBPOGB6f/2qziPfElISTCEd5XOYTFckA2SGjhNmiKzfK/u4ot3v0DUzGVdUnKjN10EqnnEPck36BkyfLnJw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+ }
+ },
+ "node_modules/@inquirer/type": {
+ "version": "4.0.7",
+ "resolved": "https://registry.npmjs.org/@inquirer/type/-/type-4.0.7.tgz",
+ "integrity": "sha512-t28inv14nMQ1PhKpsJPY+kEs/c00qzeCOS2gTNRyTjG5d6qsVA2fItxW4hkvGZ5lvanGLdtCzVIx5dwdRpN1+g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+ },
+ "peerDependencies": {
+ "@types/node": ">=18"
+ },
+ "peerDependenciesMeta": {
+ "@types/node": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@jridgewell/resolve-uri": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+ "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/@jridgewell/sourcemap-codec": {
+ "version": "1.5.5",
+ "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+ "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@jridgewell/trace-mapping": {
+ "version": "0.3.31",
+ "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+ "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/resolve-uri": "^3.1.0",
+ "@jridgewell/sourcemap-codec": "^1.4.14"
+ }
+ },
+ "node_modules/@mswjs/interceptors": {
+ "version": "0.41.9",
+ "resolved": "https://registry.npmjs.org/@mswjs/interceptors/-/interceptors-0.41.9.tgz",
+ "integrity": "sha512-VVPPgHyQ6ShqnrmDWuxjmUIsO9gWyOZFmuOfLd9LfBGQJwZfy0gvv9pbHSJuoFNIYC7ZDX9aoFwowjcdSC4E8w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@open-draft/deferred-promise": "^2.2.0",
+ "@open-draft/logger": "^0.3.0",
+ "@open-draft/until": "^2.0.0",
+ "is-node-process": "^1.2.0",
+ "outvariant": "^1.4.3",
+ "strict-event-emitter": "^0.5.1"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@mswjs/interceptors/node_modules/@open-draft/deferred-promise": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/@open-draft/deferred-promise/-/deferred-promise-2.2.0.tgz",
+ "integrity": "sha512-CecwLWx3rhxVQF6V4bAgPS5t+So2sTbPgAzafKkVizyi7tlwpcFpdFqq+wqF2OwNBmqFuu6tOyouTuxgpMfzmA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@napi-rs/wasm-runtime": {
+ "version": "1.1.6",
+ "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.6.tgz",
+ "integrity": "sha512-ZLv/JdUfkvOy9eCnnBaGfiO+XimbjebAeO+MRQqD/B+FR1tnRN0tpKSJHRbE8sFfS6aqsXZ67TQjfwfsxULVbg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "@tybys/wasm-util": "^0.10.3"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/Brooooooklyn"
+ },
+ "peerDependencies": {
+ "@emnapi/core": "^1.7.1",
+ "@emnapi/runtime": "^1.7.1"
+ }
+ },
+ "node_modules/@noble/ciphers": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/@noble/ciphers/-/ciphers-1.3.0.tgz",
+ "integrity": "sha512-2I0gnIVPtfnMw9ee9h1dJG7tp81+8Ob3OJb3Mv37rx5L40/b0i7djjCVvGOVqc9AEIQyvyu1i6ypKdFw8R8gQw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^14.21.3 || >=16"
+ },
+ "funding": {
+ "url": "https://paulmillr.com/funding/"
+ }
+ },
+ "node_modules/@noble/curves": {
+ "version": "1.9.7",
+ "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.9.7.tgz",
+ "integrity": "sha512-gbKGcRUYIjA3/zCCNaWDciTMFI0dCkvou3TL8Zmy5Nc7sJ47a0jtOeZoTaMxkuqRo9cRhjOdZJXegxYE5FN/xw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@noble/hashes": "1.8.0"
+ },
+ "engines": {
+ "node": "^14.21.3 || >=16"
+ },
+ "funding": {
+ "url": "https://paulmillr.com/funding/"
+ }
+ },
+ "node_modules/@noble/hashes": {
+ "version": "1.8.0",
+ "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz",
+ "integrity": "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^14.21.3 || >=16"
+ },
+ "funding": {
+ "url": "https://paulmillr.com/funding/"
+ }
+ },
+ "node_modules/@nodable/entities": {
+ "version": "2.2.0",
+ "resolved": "https://registry.npmjs.org/@nodable/entities/-/entities-2.2.0.tgz",
+ "integrity": "sha512-9uGyhaQavEUMC8AIddIjau4NsnsXhou+j5sBAGojCM1oxmQpVKTWR/9JxABD6UAv12vpIms55fPZKFQEhG6uBg==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/nodable"
+ }
+ ],
+ "license": "MIT"
+ },
+ "node_modules/@open-draft/deferred-promise": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/@open-draft/deferred-promise/-/deferred-promise-3.0.0.tgz",
+ "integrity": "sha512-XW375UK8/9SqUVNVa6M0yEy8+iTi4QN5VZ7aZuRFQmy76LRwI9wy5F4YIBU6T+eTe2/DNDo8tqu8RHlwLHM6RA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@open-draft/logger": {
+ "version": "0.3.0",
+ "resolved": "https://registry.npmjs.org/@open-draft/logger/-/logger-0.3.0.tgz",
+ "integrity": "sha512-X2g45fzhxH238HKO4xbSr7+wBS8Fvw6ixhTDuvLd5mqh6bJJCFAPwU9mPDxbcrRtfxv4u5IHCEH77BmxvXmmxQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "is-node-process": "^1.2.0",
+ "outvariant": "^1.4.0"
+ }
+ },
+ "node_modules/@open-draft/until": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/@open-draft/until/-/until-2.1.0.tgz",
+ "integrity": "sha512-U69T3ItWHvLwGg5eJ0n3I62nWuE6ilHlmz7zM0npLBRvPRd7e6NYmg54vvRtP5mZG7kZqZCFVdsTWo7BPtBujg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@oxc-project/types": {
+ "version": "0.139.0",
+ "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.139.0.tgz",
+ "integrity": "sha512-r9gHphtCs+1M7J0pw6Sn/hh/Wpa/iQrOOkrNAlVLF/gHq+/CJmHIWKKUUhdWjcD6CIa8idarspCsASiXCXvFUw==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/Boshen"
+ }
+ },
+ "node_modules/@rolldown/binding-android-arm64": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.1.5.tgz",
+ "integrity": "sha512-lZg8fqIv2v7FF237bwMgzGZEJvGL79/s5knJ/i6FmsGF4XXlzccZ4jb+TrFIxtSSxFtIpdsgrPZeMk1I9AFcyQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-darwin-arm64": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.1.5.tgz",
+ "integrity": "sha512-51Bnx9pNiMRKSUNtBfySkNJ9vMU9Hh3I1ozDd6gyPPYzaXCfnptUcEZxXGYFn+ul2dtcMUiqGR1Yai2K10uoTw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-darwin-x64": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.1.5.tgz",
+ "integrity": "sha512-Tm+gbfC0aHu1tBA/JvKQh32S0K6YgCHkiAF4/W6xX0K0RmNuc94VeK419dJoE65R5aRxmo+noZQSWrAMF6yb6g==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-freebsd-x64": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.1.5.tgz",
+ "integrity": "sha512-JMzDKCCXq93YccG5gz3hvOs1oXRKAf0XYpfOS88e+wZrC8Iugj6j68867vrYZkvpDDpKn/KoKORThmchMpF6TA==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-arm-gnueabihf": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.1.5.tgz",
+ "integrity": "sha512-uML21j2K5TfPGutKxub+M+nLjZIrWjXQ5Grx4lCe/nimTj9B4L63zHpjXLl4y0L3mcm2htEQIb06oCG/szerNw==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-arm64-gnu": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.1.5.tgz",
+ "integrity": "sha512-navSiuTMogvnQoZoM/v+l3ZWo50/NTwSHSzheABx/RCnmUPaKwq9qSo4Br2OYRs21+Fz8uFqITZM3H4opOB0/Q==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-arm64-musl": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.1.5.tgz",
+ "integrity": "sha512-lAryqH7IteztmCXQXk0etKj4wBQ7Gx5S6LjKhsgp9zb8I5bsuvU/2llH1hDQcjsFeqIsovMVN339/8pUDDBXxA==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-ppc64-gnu": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.1.5.tgz",
+ "integrity": "sha512-fsK/sNBnxzBlL4O1JNrZakVQxPspqpED5dLtNsZS9oOKmtSpdNIzxH2kkol5HYTWJN47sE20ztMJPxfZ89qGOg==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-s390x-gnu": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.1.5.tgz",
+ "integrity": "sha512-gLYb4BIadlfTOYT5gO503n8zQjXflgzpD0FcyKh0Mzx3rqCZKnHoJWV9xe1KXUJ5lx2JfcSHr/mhzS0PC/McAA==",
+ "cpu": [
+ "s390x"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-x64-gnu": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.1.5.tgz",
+ "integrity": "sha512-FjcpEKUyJygHgs1o50VYNvkt5+7Le/VEdYt0AkRpkL33MnyQfwr8l5mXwMmfmTbyMPr5vJLC+8/Gd9gXnwU1QQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-linux-x64-musl": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.1.5.tgz",
+ "integrity": "sha512-Me+PfPI2TMeOQk0gYWfLQZtTktrmzbr8cDboqX83XKc7UrgAi55gF+2dUkWdxd19n55Essp2yeca+O9N5rBxHg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-openharmony-arm64": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.1.5.tgz",
+ "integrity": "sha512-yc5WrLzXks6zCQfn9Oxr8pORKyl/pF+QjHmW/Qx3qu0oyrrNC+y2JLTU1E2rcWYAmzlnqngWXHQjy51VzW70Vw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openharmony"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-wasm32-wasi": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.1.5.tgz",
+ "integrity": "sha512-VbQGPX2b4r48TAMIM2cjgluIM1HYutm4pcTEJsle7iEP7sB1dFqtPLBVbdLAZCxy1txCcPxf4QFf4v8uvltPqA==",
+ "cpu": [
+ "wasm32"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "@emnapi/core": "1.11.1",
+ "@emnapi/runtime": "1.11.1",
+ "@napi-rs/wasm-runtime": "^1.1.6"
+ },
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-win32-arm64-msvc": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.1.5.tgz",
+ "integrity": "sha512-gHv82k63z4qpV5+Q1y/12KrK0ltWBukVDI8nZcbT7Tt/ZlOIVwppazneq0F93oDxTo3IgAMEDIoQh3E2n6mVsw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/binding-win32-x64-msvc": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.1.5.tgz",
+ "integrity": "sha512-tTZuDBPw85tEN5PQi1pnEBzDy0Z49HtScLAbD5t6hyeU92A95pRWaSMw1GZZi/RwgSgUIl0xrSlXIT/9QzvYSA==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ }
+ },
+ "node_modules/@rolldown/pluginutils": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz",
+ "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@standard-schema/spec": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+ "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@supabase/auth-js": {
+ "version": "2.108.2",
+ "resolved": "https://registry.npmjs.org/@supabase/auth-js/-/auth-js-2.108.2.tgz",
+ "integrity": "sha512-tNaQmBgodDZwgB40mRwVbxFy8IDYwjdpcZ0BYrWiwlULCSQoJj4QoG4zgJT7QRPXcqipefNOzvO/qAu4dF98ag==",
+ "license": "MIT",
+ "dependencies": {
+ "tslib": "2.8.1"
+ },
+ "engines": {
+ "node": ">=20.0.0"
+ }
+ },
+ "node_modules/@supabase/cli-darwin-arm64": {
+ "version": "2.109.1",
+ "resolved": "https://registry.npmjs.org/@supabase/cli-darwin-arm64/-/cli-darwin-arm64-2.109.1.tgz",
+ "integrity": "sha512-tkn8tfunyqIL7RE+7DVjg6Ql2cJLPkGgh9cPafp2LbXI0qDgds0TaS+UOTHQEjci8JQXXe2wS00+122ko2QI8A==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ]
+ },
+ "node_modules/@supabase/cli-darwin-x64": {
+ "version": "2.109.1",
+ "resolved": "https://registry.npmjs.org/@supabase/cli-darwin-x64/-/cli-darwin-x64-2.109.1.tgz",
+ "integrity": "sha512-0Q5ZAoWhOyIv4ZzQOU8QbjjdB2JmznnDNyJ3VrIeuLMWoifVfUWaLZhHBNYzr4xXoxBpKrggomuAT8BaEhY3lg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ]
+ },
+ "node_modules/@supabase/cli-linux-arm64": {
+ "version": "2.109.1",
+ "resolved": "https://registry.npmjs.org/@supabase/cli-linux-arm64/-/cli-linux-arm64-2.109.1.tgz",
+ "integrity": "sha512-MS1djJjq5laD99+jYJUoARfSZhzRX9aXmo5piZ1yl2JXb9IXTuhiTD5olkFKQcgNckRcAZqMf4fucQGTYC767A==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@supabase/cli-linux-arm64-musl": {
+ "version": "2.109.1",
+ "resolved": "https://registry.npmjs.org/@supabase/cli-linux-arm64-musl/-/cli-linux-arm64-musl-2.109.1.tgz",
+ "integrity": "sha512-cXNOsSU7MS+jmslGQATTD4DfWBEIHiFi7LaBWyBxHmR7tzIiZXimUXgN26ZiQjfAxU+RZq52C3k0qhi7vmqXQw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@supabase/cli-linux-x64": {
+ "version": "2.109.1",
+ "resolved": "https://registry.npmjs.org/@supabase/cli-linux-x64/-/cli-linux-x64-2.109.1.tgz",
+ "integrity": "sha512-svFmamF/vIq4/oinwY50jDi869itC9/GWrPaGtsHFkK4NUBcQtl1T37WWIivGsXwbBKNC4FjZD3dGqjL7bfW1g==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@supabase/cli-linux-x64-musl": {
+ "version": "2.109.1",
+ "resolved": "https://registry.npmjs.org/@supabase/cli-linux-x64-musl/-/cli-linux-x64-musl-2.109.1.tgz",
+ "integrity": "sha512-zeD9MrZpEKJrjkSPcYp4nZeGJ9FQt0i/kiRij4ZprPP6R5l+SLi6Pk20ln+Vj/GZuWTVxX7IHJ11pgViaReAWw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@supabase/cli-windows-arm64": {
+ "version": "2.109.1",
+ "resolved": "https://registry.npmjs.org/@supabase/cli-windows-arm64/-/cli-windows-arm64-2.109.1.tgz",
+ "integrity": "sha512-NeKzgWAOpglnLwMTggTp5t44fbkfxACLkQNlCRx0q332HMM3WqsKQUsHv1MHc6ZbEc5bcMwaYjqPNI/aOWnP5g==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ]
+ },
+ "node_modules/@supabase/cli-windows-x64": {
+ "version": "2.109.1",
+ "resolved": "https://registry.npmjs.org/@supabase/cli-windows-x64/-/cli-windows-x64-2.109.1.tgz",
+ "integrity": "sha512-L9/pDLM+4IR8646aT69ZDVcnJeg1lZZsB26ZgI775S3f8jOHP41+1UH9Oq1g9CvKiAQviuaLgtwkuvi0I/cc/A==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ]
+ },
+ "node_modules/@supabase/functions-js": {
+ "version": "2.108.2",
+ "resolved": "https://registry.npmjs.org/@supabase/functions-js/-/functions-js-2.108.2.tgz",
+ "integrity": "sha512-RNUX8EiBy3iLwAX19jtRzLyePnl11/fHcgwDHLnpKcDSXt/5qBnh3LUwAtIjT21Q66QsmNUR2esrHziLCpNubw==",
+ "license": "MIT",
+ "dependencies": {
+ "tslib": "2.8.1"
+ },
+ "engines": {
+ "node": ">=20.0.0"
+ }
+ },
+ "node_modules/@supabase/phoenix": {
+ "version": "0.4.4",
+ "resolved": "https://registry.npmjs.org/@supabase/phoenix/-/phoenix-0.4.4.tgz",
+ "integrity": "sha512-Gt0pqoXuIqX/8dvG0OKp/wMCobXNH3klNbUPBNyOfN0YA1IswrM3HyWFMOPk1Jy+BRaIyDPcFx4jLBwHNmlyfQ==",
+ "license": "MIT"
+ },
+ "node_modules/@supabase/postgrest-js": {
+ "version": "2.108.2",
+ "resolved": "https://registry.npmjs.org/@supabase/postgrest-js/-/postgrest-js-2.108.2.tgz",
+ "integrity": "sha512-GQ28/Y8hk3CFmkb3kXH1h/AQx6JIYSQfO0CJMRVBcEKZoNy6C45cXAZ4fcJvRC5Id0cs6xnkUV0+c0rIocigsw==",
+ "license": "MIT",
+ "dependencies": {
+ "tslib": "2.8.1"
+ },
+ "engines": {
+ "node": ">=20.0.0"
+ }
+ },
+ "node_modules/@supabase/realtime-js": {
+ "version": "2.108.2",
+ "resolved": "https://registry.npmjs.org/@supabase/realtime-js/-/realtime-js-2.108.2.tgz",
+ "integrity": "sha512-aAGxCSUemZvQIibnCdvNvgaKib28I4rfrNjKbQ9cG1uBLwUsI7hVpGXgEbypCCDhLjQlDTAiJlu7rgljYUT73g==",
+ "license": "MIT",
+ "dependencies": {
+ "@supabase/phoenix": "^0.4.2",
+ "tslib": "2.8.1"
+ },
+ "engines": {
+ "node": ">=20.0.0"
+ }
+ },
+ "node_modules/@supabase/storage-js": {
+ "version": "2.108.2",
+ "resolved": "https://registry.npmjs.org/@supabase/storage-js/-/storage-js-2.108.2.tgz",
+ "integrity": "sha512-TVZPQxXGxY2+A6yTtm77zUHsh70lBhYUEaJL8RQC+BghcX/ygiMG/rmXrNVBce30/WAeNPa8FiG8HbqlGeV05g==",
+ "license": "MIT",
+ "dependencies": {
+ "iceberg-js": "^0.8.1",
+ "tslib": "2.8.1"
+ },
+ "engines": {
+ "node": ">=20.0.0"
+ }
+ },
+ "node_modules/@supabase/supabase-js": {
+ "version": "2.108.2",
+ "resolved": "https://registry.npmjs.org/@supabase/supabase-js/-/supabase-js-2.108.2.tgz",
+ "integrity": "sha512-hFhnPveb5JQg4a0QYicM0swT253YHMdfeRAl2BKHOlI5VAzuHxUGSr8RbwNLYNPauWOgQMS1H8sz8bvYlgwUfQ==",
+ "license": "MIT",
+ "dependencies": {
+ "@supabase/auth-js": "2.108.2",
+ "@supabase/functions-js": "2.108.2",
+ "@supabase/postgrest-js": "2.108.2",
+ "@supabase/realtime-js": "2.108.2",
+ "@supabase/storage-js": "2.108.2"
+ },
+ "engines": {
+ "node": ">=20.0.0"
+ }
+ },
+ "node_modules/@tybys/wasm-util": {
+ "version": "0.10.3",
+ "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.3.tgz",
+ "integrity": "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "tslib": "^2.4.0"
+ }
+ },
+ "node_modules/@types/chai": {
+ "version": "5.2.3",
+ "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+ "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/deep-eql": "*",
+ "assertion-error": "^2.0.1"
+ }
+ },
+ "node_modules/@types/deep-eql": {
+ "version": "4.0.2",
+ "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+ "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/esrecurse": {
+ "version": "4.3.1",
+ "resolved": "https://registry.npmjs.org/@types/esrecurse/-/esrecurse-4.3.1.tgz",
+ "integrity": "sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/estree": {
+ "version": "1.0.9",
+ "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+ "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/json-schema": {
+ "version": "7.0.15",
+ "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+ "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/node": {
+ "version": "26.0.1",
+ "resolved": "https://registry.npmjs.org/@types/node/-/node-26.0.1.tgz",
+ "integrity": "sha512-fc3KiUoBt6kie0N9bIW3E47vZsuaMf0PM2AaUpLCLT0s/LvX1nxAim6Fc049cNxODPpGm6qRAuUOB86SkRuPQw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "undici-types": "~8.3.0"
+ }
+ },
+ "node_modules/@types/nodemailer": {
+ "version": "7.0.12",
+ "resolved": "https://registry.npmjs.org/@types/nodemailer/-/nodemailer-7.0.12.tgz",
+ "integrity": "sha512-80vKwiIsVSyFA1rRovH59jNPLBOuc6dRZIHEu40gXTkBkZnQv8vog1xSGEb9j5q/tdMAs5ivvDR2pLTU0hGHXA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/set-cookie-parser": {
+ "version": "2.4.10",
+ "resolved": "https://registry.npmjs.org/@types/set-cookie-parser/-/set-cookie-parser-2.4.10.tgz",
+ "integrity": "sha512-GGmQVGpQWUe5qglJozEjZV/5dyxbOOZ0LHe/lqyWssB88Y4svNfst0uqBVscdDeIKl5Jy5+aPSvy7mI9tYRguw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/statuses": {
+ "version": "2.0.6",
+ "resolved": "https://registry.npmjs.org/@types/statuses/-/statuses-2.0.6.tgz",
+ "integrity": "sha512-xMAgYwceFhRA2zY+XbEA7mxYbA093wdiW8Vu6gZPGWy9cmOyU9XesH1tNcEWsKFd5Vzrqx5T3D38PWx1FIIXkA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@typescript-eslint/eslint-plugin": {
+ "version": "8.63.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.63.0.tgz",
+ "integrity": "sha512-rvwSgqT+DHpWdzfSzPatRLm02a0GlESt++9iy3hLCDY4BgkaLcl8LBi9Yh7XGFBpwcBE/K3024QuXWTpbz4FfQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@eslint-community/regexpp": "^4.12.2",
+ "@typescript-eslint/scope-manager": "8.63.0",
+ "@typescript-eslint/type-utils": "8.63.0",
+ "@typescript-eslint/utils": "8.63.0",
+ "@typescript-eslint/visitor-keys": "8.63.0",
+ "ignore": "^7.0.5",
+ "natural-compare": "^1.4.0",
+ "ts-api-utils": "^2.5.0"
+ },
+ "engines": {
+ "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependencies": {
+ "@typescript-eslint/parser": "^8.63.0",
+ "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+ "typescript": ">=4.8.4 <6.1.0"
+ }
+ },
+ "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
+ "version": "7.0.5",
+ "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
+ "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 4"
+ }
+ },
+ "node_modules/@typescript-eslint/parser": {
+ "version": "8.63.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.63.0.tgz",
+ "integrity": "sha512-gwh4gvvlaVDKKxyfxMG+Gnu1u9X0OQBwyGLkbwB65dIzBKnxeRiJlNFqlI3zwVhNXJIs6qV7mlFCn/BIajlVig==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@typescript-eslint/scope-manager": "8.63.0",
+ "@typescript-eslint/types": "8.63.0",
+ "@typescript-eslint/typescript-estree": "8.63.0",
+ "@typescript-eslint/visitor-keys": "8.63.0",
+ "debug": "^4.4.3"
+ },
+ "engines": {
+ "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependencies": {
+ "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+ "typescript": ">=4.8.4 <6.1.0"
+ }
+ },
+ "node_modules/@typescript-eslint/project-service": {
+ "version": "8.63.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.63.0.tgz",
+ "integrity": "sha512-e5dh0/UI0ok53AlZ5wRkXCB32z/f2jUZqPR/ygAw5WYaSw8j9EoJWlS7wQjr/dmOaqWjnPIn2m+HhVPCMWGZVQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@typescript-eslint/tsconfig-utils": "^8.63.0",
+ "@typescript-eslint/types": "^8.63.0",
+ "debug": "^4.4.3"
+ },
+ "engines": {
+ "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependencies": {
+ "typescript": ">=4.8.4 <6.1.0"
+ }
+ },
+ "node_modules/@typescript-eslint/scope-manager": {
+ "version": "8.63.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.63.0.tgz",
+ "integrity": "sha512-uUyfMWCnDSN8bCpcrY8nGP2BLkQ9Xn0GsipcONcpIDWhwhO4ZSyHvyS14U3X75mzxWxL3I2UZIrenTzdzcJO8A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@typescript-eslint/types": "8.63.0",
+ "@typescript-eslint/visitor-keys": "8.63.0"
+ },
+ "engines": {
+ "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ }
+ },
+ "node_modules/@typescript-eslint/tsconfig-utils": {
+ "version": "8.63.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.63.0.tgz",
+ "integrity": "sha512-sUAbkulqBAsncKnbRP3+7CtQFRKicexnj7ZwNC6ddCR7EmrXvjvdCYMJbUIqMd6lwoEriZjwLo08aS5tSjVMHg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependencies": {
+ "typescript": ">=4.8.4 <6.1.0"
+ }
+ },
+ "node_modules/@typescript-eslint/type-utils": {
+ "version": "8.63.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.63.0.tgz",
+ "integrity": "sha512-Nzzh/OGxVCOjObjaj1CQF2RUasyYy2Jfuh+zZ3PjLzG2fYRriAiZLib9UKtO+CpQAS3YHiAS+ckZDclwqI1TPA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@typescript-eslint/types": "8.63.0",
+ "@typescript-eslint/typescript-estree": "8.63.0",
+ "@typescript-eslint/utils": "8.63.0",
+ "debug": "^4.4.3",
+ "ts-api-utils": "^2.5.0"
+ },
+ "engines": {
+ "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependencies": {
+ "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+ "typescript": ">=4.8.4 <6.1.0"
+ }
+ },
+ "node_modules/@typescript-eslint/types": {
+ "version": "8.63.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.63.0.tgz",
+ "integrity": "sha512-xyLtl9DUBBFrcJS4x2pIqGLH68/tC2uOa4Z7pUteW09D3bXnnXUom4dyPikzWgB7llmIc1zoeI3aoUdC4rPK/Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ }
+ },
+ "node_modules/@typescript-eslint/typescript-estree": {
+ "version": "8.63.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.63.0.tgz",
+ "integrity": "sha512-ygBkU+B7ex5UI/gKhaqexWev79uISfIv7XQCRNYO/jmD8rGLPyWLAb3KMRT6nd8Gt9bmUBi9+iX6tBdYfOY81Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@typescript-eslint/project-service": "8.63.0",
+ "@typescript-eslint/tsconfig-utils": "8.63.0",
+ "@typescript-eslint/types": "8.63.0",
+ "@typescript-eslint/visitor-keys": "8.63.0",
+ "debug": "^4.4.3",
+ "minimatch": "^10.2.2",
+ "semver": "^7.7.3",
+ "tinyglobby": "^0.2.15",
+ "ts-api-utils": "^2.5.0"
+ },
+ "engines": {
+ "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependencies": {
+ "typescript": ">=4.8.4 <6.1.0"
+ }
+ },
+ "node_modules/@typescript-eslint/utils": {
+ "version": "8.63.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.63.0.tgz",
+ "integrity": "sha512-fUKaeAvrTuQg/Tgt3nliAUSZHJM6DlCcfyEmxCvlX8kieWSStBX+5O5Fnidtc3i2JrH+9c/GL4RY2iasd/GPTA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@eslint-community/eslint-utils": "^4.9.1",
+ "@typescript-eslint/scope-manager": "8.63.0",
+ "@typescript-eslint/types": "8.63.0",
+ "@typescript-eslint/typescript-estree": "8.63.0"
+ },
+ "engines": {
+ "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependencies": {
+ "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+ "typescript": ">=4.8.4 <6.1.0"
+ }
+ },
+ "node_modules/@typescript-eslint/visitor-keys": {
+ "version": "8.63.0",
+ "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.63.0.tgz",
+ "integrity": "sha512-UexrHGnGTpbuQHct2ExOc2ZcFbGUS9FOesCxxqdBGcpI1BxYu/LZ6U8Aq6/72XtF/qRBk9nhuGHFJIXXMhPMdw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@typescript-eslint/types": "8.63.0",
+ "eslint-visitor-keys": "^5.0.0"
+ },
+ "engines": {
+ "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ }
+ },
+ "node_modules/@vitest/coverage-v8": {
+ "version": "4.1.10",
+ "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-4.1.10.tgz",
+ "integrity": "sha512-IM49HmthevbgAO4anp1hwtoT9wYe59w0LR00gr+eagHE+ZJ5lK4sLPeO0ubgoJcwLk6dehU3R24N+FbEEKDc8g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@bcoe/v8-coverage": "^1.0.2",
+ "@vitest/utils": "4.1.10",
+ "ast-v8-to-istanbul": "^1.0.0",
+ "istanbul-lib-coverage": "^3.2.2",
+ "istanbul-lib-report": "^3.0.1",
+ "istanbul-reports": "^3.2.0",
+ "magicast": "^0.5.2",
+ "obug": "^2.1.1",
+ "std-env": "^4.0.0-rc.1",
+ "tinyrainbow": "^3.1.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ },
+ "peerDependencies": {
+ "@vitest/browser": "4.1.10",
+ "vitest": "4.1.10"
+ },
+ "peerDependenciesMeta": {
+ "@vitest/browser": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@vitest/expect": {
+ "version": "4.1.10",
+ "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.10.tgz",
+ "integrity": "sha512-YsCn+qAk1GWjQOWFEsEcL2gNQ0zmVmQu3T03qP6UyjhtmdtwtbuI+DASn/7iQB3HGTXkdBwGddzxPlmiql5vlA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@standard-schema/spec": "^1.1.0",
+ "@types/chai": "^5.2.2",
+ "@vitest/spy": "4.1.10",
+ "@vitest/utils": "4.1.10",
+ "chai": "^6.2.2",
+ "tinyrainbow": "^3.1.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ }
+ },
+ "node_modules/@vitest/mocker": {
+ "version": "4.1.10",
+ "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.10.tgz",
+ "integrity": "sha512-v0xaezt+DKEmKfaxg133ldzADrwLGd7Ze1MfQQTYfvs8OqZIwbxyxaYURivwV7sWy5fqn3rH5uOrSp07bp44Ow==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@vitest/spy": "4.1.10",
+ "estree-walker": "^3.0.3",
+ "magic-string": "^0.30.21"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ },
+ "peerDependencies": {
+ "msw": "^2.4.9",
+ "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+ },
+ "peerDependenciesMeta": {
+ "msw": {
+ "optional": true
+ },
+ "vite": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@vitest/pretty-format": {
+ "version": "4.1.10",
+ "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.10.tgz",
+ "integrity": "sha512-W1HsjSH4MXQ9YfmmhLAoIYf1HRfekQCGngeIgcei6MP5QQGWUe0gkopdZQaVCFO+JDJMrAJGwa5pRpNpvy4P8Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "tinyrainbow": "^3.1.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ }
+ },
+ "node_modules/@vitest/runner": {
+ "version": "4.1.10",
+ "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.10.tgz",
+ "integrity": "sha512-IKI6kpIH+LmpROplyLwBBaCfMgOZOMsygVa6BARD6ahA04VRuJSa6OaVG7kRvSEMD870Vd91rSSw0eegtWyLGg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@vitest/utils": "4.1.10",
+ "pathe": "^2.0.3"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ }
+ },
+ "node_modules/@vitest/snapshot": {
+ "version": "4.1.10",
+ "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.10.tgz",
+ "integrity": "sha512-xRkfOT1qpTAi/Ti4Y1LtfRc3kEuqxGw59eN2jN9pRWMtS/XDevekhcFSqvQqjUNGksfjMJu3Y+oJ+4Ypn2OaJw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@vitest/pretty-format": "4.1.10",
+ "@vitest/utils": "4.1.10",
+ "magic-string": "^0.30.21",
+ "pathe": "^2.0.3"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ }
+ },
+ "node_modules/@vitest/spy": {
+ "version": "4.1.10",
+ "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.10.tgz",
+ "integrity": "sha512-PLf/Ugvoq5wO/b4rwYCR1h2PSIdXz7wnkQFMiUpLdtM7l6pqVFcQIBEHyT1+l+cj7mNwAfZHzqXqDyjvOuwbDw==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ }
+ },
+ "node_modules/@vitest/utils": {
+ "version": "4.1.10",
+ "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.10.tgz",
+ "integrity": "sha512-fy9am/HWxbaGt/Sawrp90vt6Y6jQwf1RX77cz3uwoJwJVMli/e1IEwRPnMNJ7vKfPTwo0diXifkpPvwH9v7nGA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@vitest/pretty-format": "4.1.10",
+ "convert-source-map": "^2.0.0",
+ "tinyrainbow": "^3.1.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ }
+ },
+ "node_modules/acorn": {
+ "version": "8.17.0",
+ "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.17.0.tgz",
+ "integrity": "sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "acorn": "bin/acorn"
+ },
+ "engines": {
+ "node": ">=0.4.0"
+ }
+ },
+ "node_modules/acorn-jsx": {
+ "version": "5.3.2",
+ "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+ "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+ "dev": true,
+ "license": "MIT",
+ "peerDependencies": {
+ "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+ }
+ },
+ "node_modules/ajv": {
+ "version": "6.15.0",
+ "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz",
+ "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fast-deep-equal": "^3.1.1",
+ "fast-json-stable-stringify": "^2.0.0",
+ "json-schema-traverse": "^0.4.1",
+ "uri-js": "^4.2.2"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/epoberezkin"
+ }
+ },
+ "node_modules/ansi-regex": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+ "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/ansi-styles": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+ "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "color-convert": "^2.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+ }
+ },
+ "node_modules/anynum": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/anynum/-/anynum-1.0.1.tgz",
+ "integrity": "sha512-N6//FLET/tXYNM/F6ABca1oH6fWB+KlTt909Le28WMDBk8oaT4vY17DCrwg2MvmuqUKt3Ni4N5dGJ/EoBgcO6A==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/NaturalIntelligence"
+ }
+ ],
+ "license": "MIT"
+ },
+ "node_modules/assertion-error": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+ "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/ast-v8-to-istanbul": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/ast-v8-to-istanbul/-/ast-v8-to-istanbul-1.0.4.tgz",
+ "integrity": "sha512-0bC0/4bTSrnwdhU3IsZDwEdojvuPrSg59OYZfKsLRtJZ0u8VBx9DebfqqG8bRdCC0I7vjgxmPi41P0lpkhJHtA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/trace-mapping": "^0.3.31",
+ "estree-walker": "^3.0.3",
+ "js-tokens": "^10.0.0"
+ }
+ },
+ "node_modules/balanced-match": {
+ "version": "4.0.4",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+ "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "18 || 20 || >=22"
+ }
+ },
+ "node_modules/brace-expansion": {
+ "version": "5.0.7",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.7.tgz",
+ "integrity": "sha512-7oFy703dxfY3/NLxC1fh2SUCQ0H9rmAY+5EpDVfXjUTTs+HEwR2nYaqLv+GWcTsumwxPfiz6CzCNkwXwBUwqCA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^4.0.2"
+ },
+ "engines": {
+ "node": "18 || 20 || >=22"
+ }
+ },
+ "node_modules/chai": {
+ "version": "6.2.2",
+ "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+ "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/cli-width": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-4.1.0.tgz",
+ "integrity": "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">= 12"
+ }
+ },
+ "node_modules/cliui": {
+ "version": "8.0.1",
+ "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+ "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "string-width": "^4.2.0",
+ "strip-ansi": "^6.0.1",
+ "wrap-ansi": "^7.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/color-convert": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+ "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "color-name": "~1.1.4"
+ },
+ "engines": {
+ "node": ">=7.0.0"
+ }
+ },
+ "node_modules/color-name": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+ "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/convert-source-map": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+ "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/cookie": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.1.1.tgz",
+ "integrity": "sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/express"
+ }
+ },
+ "node_modules/cross-spawn": {
+ "version": "7.0.6",
+ "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+ "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "path-key": "^3.1.0",
+ "shebang-command": "^2.0.0",
+ "which": "^2.0.1"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/debug": {
+ "version": "4.4.3",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+ "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ms": "^2.1.3"
+ },
+ "engines": {
+ "node": ">=6.0"
+ },
+ "peerDependenciesMeta": {
+ "supports-color": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/deep-is": {
+ "version": "0.1.4",
+ "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+ "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/detect-libc": {
+ "version": "2.1.2",
+ "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+ "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/eciesjs": {
+ "version": "0.5.0",
+ "resolved": "https://registry.npmjs.org/eciesjs/-/eciesjs-0.5.0.tgz",
+ "integrity": "sha512-s0J9SEVYAEPg7J63GFMApLYzPH9VNIQIyC6s15JpnqVc0TqcKWdbgFlnAweEBRyMmko2dcs2sfC83Hj4J43tuA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@ecies/ciphers": "^0.2.6",
+ "@noble/ciphers": "^1.3.0",
+ "@noble/curves": "^1.9.7",
+ "@noble/hashes": "^1.8.0"
+ },
+ "engines": {
+ "bun": ">=1",
+ "deno": ">=2.7.10",
+ "node": ">=16"
+ }
+ },
+ "node_modules/emoji-regex": {
+ "version": "8.0.0",
+ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+ "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/es-module-lexer": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.0.tgz",
+ "integrity": "sha512-KLdwQm2NvGLDkQDCGvmiQrhkd0JbMzXthwQAUgWjQuQdBLFa3eiBP5arXZyA+f8x+x7OXgud6bq2rxjGtHV2tw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/esbuild": {
+ "version": "0.28.1",
+ "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz",
+ "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "bin": {
+ "esbuild": "bin/esbuild"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "optionalDependencies": {
+ "@esbuild/aix-ppc64": "0.28.1",
+ "@esbuild/android-arm": "0.28.1",
+ "@esbuild/android-arm64": "0.28.1",
+ "@esbuild/android-x64": "0.28.1",
+ "@esbuild/darwin-arm64": "0.28.1",
+ "@esbuild/darwin-x64": "0.28.1",
+ "@esbuild/freebsd-arm64": "0.28.1",
+ "@esbuild/freebsd-x64": "0.28.1",
+ "@esbuild/linux-arm": "0.28.1",
+ "@esbuild/linux-arm64": "0.28.1",
+ "@esbuild/linux-ia32": "0.28.1",
+ "@esbuild/linux-loong64": "0.28.1",
+ "@esbuild/linux-mips64el": "0.28.1",
+ "@esbuild/linux-ppc64": "0.28.1",
+ "@esbuild/linux-riscv64": "0.28.1",
+ "@esbuild/linux-s390x": "0.28.1",
+ "@esbuild/linux-x64": "0.28.1",
+ "@esbuild/netbsd-arm64": "0.28.1",
+ "@esbuild/netbsd-x64": "0.28.1",
+ "@esbuild/openbsd-arm64": "0.28.1",
+ "@esbuild/openbsd-x64": "0.28.1",
+ "@esbuild/openharmony-arm64": "0.28.1",
+ "@esbuild/sunos-x64": "0.28.1",
+ "@esbuild/win32-arm64": "0.28.1",
+ "@esbuild/win32-ia32": "0.28.1",
+ "@esbuild/win32-x64": "0.28.1"
+ }
+ },
+ "node_modules/escalade": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+ "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/escape-string-regexp": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+ "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/eslint": {
+ "version": "10.6.0",
+ "resolved": "https://registry.npmjs.org/eslint/-/eslint-10.6.0.tgz",
+ "integrity": "sha512-6lVbcqSodALYo+4ELD0heG6lFiFxnLMuLkiMi2qV8LMp54N8tE8FT1GMH+ev4Ti00nFjNze2+Su6DsV5OQW3Dg==",
+ "dev": true,
+ "license": "MIT",
+ "workspaces": [
+ "packages/*"
+ ],
+ "dependencies": {
+ "@eslint-community/eslint-utils": "^4.8.0",
+ "@eslint-community/regexpp": "^4.12.2",
+ "@eslint/config-array": "^0.23.5",
+ "@eslint/config-helpers": "^0.6.0",
+ "@eslint/core": "^1.2.1",
+ "@eslint/plugin-kit": "^0.7.2",
+ "@humanfs/node": "^0.16.6",
+ "@humanwhocodes/module-importer": "^1.0.1",
+ "@humanwhocodes/retry": "^0.4.2",
+ "@types/estree": "^1.0.6",
+ "ajv": "^6.14.0",
+ "cross-spawn": "^7.0.6",
+ "debug": "^4.3.2",
+ "escape-string-regexp": "^4.0.0",
+ "eslint-scope": "^9.1.2",
+ "eslint-visitor-keys": "^5.0.1",
+ "espree": "^11.2.0",
+ "esquery": "^1.7.0",
+ "esutils": "^2.0.2",
+ "fast-deep-equal": "^3.1.3",
+ "file-entry-cache": "^8.0.0",
+ "find-up": "^5.0.0",
+ "glob-parent": "^6.0.2",
+ "ignore": "^5.2.0",
+ "imurmurhash": "^0.1.4",
+ "is-glob": "^4.0.0",
+ "json-stable-stringify-without-jsonify": "^1.0.1",
+ "minimatch": "^10.2.4",
+ "natural-compare": "^1.4.0",
+ "optionator": "^0.9.3"
+ },
+ "bin": {
+ "eslint": "bin/eslint.js"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ },
+ "funding": {
+ "url": "https://eslint.org/donate"
+ },
+ "peerDependencies": {
+ "jiti": "*"
+ },
+ "peerDependenciesMeta": {
+ "jiti": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/eslint-scope": {
+ "version": "9.1.2",
+ "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-9.1.2.tgz",
+ "integrity": "sha512-xS90H51cKw0jltxmvmHy2Iai1LIqrfbw57b79w/J7MfvDfkIkFZ+kj6zC3BjtUwh150HsSSdxXZcsuv72miDFQ==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "@types/esrecurse": "^4.3.1",
+ "@types/estree": "^1.0.8",
+ "esrecurse": "^4.3.0",
+ "estraverse": "^5.2.0"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/eslint-visitor-keys": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz",
+ "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/espree": {
+ "version": "11.2.0",
+ "resolved": "https://registry.npmjs.org/espree/-/espree-11.2.0.tgz",
+ "integrity": "sha512-7p3DrVEIopW1B1avAGLuCSh1jubc01H2JHc8B4qqGblmg5gI9yumBgACjWo4JlIc04ufug4xJ3SQI8HkS/Rgzw==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "acorn": "^8.16.0",
+ "acorn-jsx": "^5.3.2",
+ "eslint-visitor-keys": "^5.0.1"
+ },
+ "engines": {
+ "node": "^20.19.0 || ^22.13.0 || >=24"
+ },
+ "funding": {
+ "url": "https://opencollective.com/eslint"
+ }
+ },
+ "node_modules/esquery": {
+ "version": "1.7.0",
+ "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz",
+ "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "estraverse": "^5.1.0"
+ },
+ "engines": {
+ "node": ">=0.10"
+ }
+ },
+ "node_modules/esrecurse": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+ "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "estraverse": "^5.2.0"
+ },
+ "engines": {
+ "node": ">=4.0"
+ }
+ },
+ "node_modules/estraverse": {
+ "version": "5.3.0",
+ "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+ "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=4.0"
+ }
+ },
+ "node_modules/estree-walker": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+ "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/estree": "^1.0.0"
+ }
+ },
+ "node_modules/esutils": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+ "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/expect-type": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz",
+ "integrity": "sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=12.0.0"
+ }
+ },
+ "node_modules/fast-check": {
+ "version": "4.9.0",
+ "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-4.9.0.tgz",
+ "integrity": "sha512-7ms6T7SybUev/PQITciI0yLM2pOSFy5zpG8Ty7tQofcVaQUvrMXp6CBwqF6fThLCLOrfBtuHAtwq6Yu4XPCllg==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://github.com/sponsors/dubzzz"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/fast-check"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "pure-rand": "^8.0.0"
+ },
+ "engines": {
+ "node": ">=12.17.0"
+ }
+ },
+ "node_modules/fast-deep-equal": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+ "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fast-json-stable-stringify": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+ "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fast-levenshtein": {
+ "version": "2.0.6",
+ "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+ "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fast-string-truncated-width": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/fast-string-truncated-width/-/fast-string-truncated-width-3.0.3.tgz",
+ "integrity": "sha512-0jjjIEL6+0jag3l2XWWizO64/aZVtpiGE3t0Zgqxv0DPuxiMjvB3M24fCyhZUO4KomJQPj3LTSUnDP3GpdwC0g==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fast-string-width": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/fast-string-width/-/fast-string-width-3.0.2.tgz",
+ "integrity": "sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fast-string-truncated-width": "^3.0.2"
+ }
+ },
+ "node_modules/fast-wrap-ansi": {
+ "version": "0.2.2",
+ "resolved": "https://registry.npmjs.org/fast-wrap-ansi/-/fast-wrap-ansi-0.2.2.tgz",
+ "integrity": "sha512-7F2Fl+TjRSenLqlU3UjSH0iyqopqoZIu7eZVpEirP2g1GtWa2G/ecEmBdgz31+Mxr+ELclgg6sokpSFIQiZ02Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fast-string-width": "^3.0.2"
+ }
+ },
+ "node_modules/fast-xml-builder": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.2.0.tgz",
+ "integrity": "sha512-00aAWieqff+ZJhsXA4g1g7M8k+7AYoMUUHF+/zFb5U6Uv/P0Vl4QZo84/IcufzYalLuEj9928bXN9PbbFzMF0Q==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/NaturalIntelligence"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "path-expression-matcher": "^1.5.0",
+ "xml-naming": "^0.1.0"
+ }
+ },
+ "node_modules/fast-xml-parser": {
+ "version": "5.9.3",
+ "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.9.3.tgz",
+ "integrity": "sha512-brCNCeScma/kqa54J4PIDriSSSLssRkuYaUCpvHJulGc3HGI/xxKUCTDcYkAdqJsyb//ydpbxecjC3hB9+tb/g==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/NaturalIntelligence"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "@nodable/entities": "^2.2.0",
"fast-xml-builder": "^1.2.0",
"is-unsafe": "^1.0.1",
"path-expression-matcher": "^1.5.0",
"strnum": "^2.4.1",
"xml-naming": "^0.1.0"
},
- "bin": {
- "fxparser": "src/cli/cli.js"
+ "bin": {
+ "fxparser": "src/cli/cli.js"
+ }
+ },
+ "node_modules/fdir": {
+ "version": "6.5.0",
+ "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+ "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "peerDependencies": {
+ "picomatch": "^3 || ^4"
+ },
+ "peerDependenciesMeta": {
+ "picomatch": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/file-entry-cache": {
+ "version": "8.0.0",
+ "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
+ "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "flat-cache": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=16.0.0"
+ }
+ },
+ "node_modules/find-up": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+ "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "locate-path": "^6.0.0",
+ "path-exists": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/flat-cache": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
+ "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "flatted": "^3.2.9",
+ "keyv": "^4.5.4"
+ },
+ "engines": {
+ "node": ">=16"
+ }
+ },
+ "node_modules/flatted": {
+ "version": "3.4.2",
+ "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz",
+ "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/fsevents": {
+ "version": "2.3.3",
+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+ "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+ }
+ },
+ "node_modules/get-caller-file": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+ "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": "6.* || 8.* || >= 10.*"
+ }
+ },
+ "node_modules/glob-parent": {
+ "version": "6.0.2",
+ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+ "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "is-glob": "^4.0.3"
+ },
+ "engines": {
+ "node": ">=10.13.0"
+ }
+ },
+ "node_modules/graphql": {
+ "version": "16.14.2",
+ "resolved": "https://registry.npmjs.org/graphql/-/graphql-16.14.2.tgz",
+ "integrity": "sha512-Chq1s4CY7jmh8gO2qvLIJyfCDIN+EHLFW/9iShnp1z8FjBQMoodWP1kDC36VAMXXIvAjj4ARa7ntfAV2BrjsbA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0"
+ }
+ },
+ "node_modules/has-flag": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+ "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/headers-polyfill": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/headers-polyfill/-/headers-polyfill-5.0.1.tgz",
+ "integrity": "sha512-1TJ6Fih/b8h5TIcv+1+Hw0PDQWJTKDKzFZzcKOiW1wJza3XoAQlkCuXLbymPYB8+ZQyw8mHvdw560e8zVFIWyA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/set-cookie-parser": "^2.4.10",
+ "set-cookie-parser": "^3.0.1"
+ }
+ },
+ "node_modules/html-escaper": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
+ "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/iceberg-js": {
+ "version": "0.8.1",
+ "resolved": "https://registry.npmjs.org/iceberg-js/-/iceberg-js-0.8.1.tgz",
+ "integrity": "sha512-1dhVQZXhcHje7798IVM+xoo/1ZdVfzOMIc8/rgVSijRK38EDqOJoGula9N/8ZI5RD8QTxNQtK/Gozpr+qUqRRA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=20.0.0"
+ }
+ },
+ "node_modules/ignore": {
+ "version": "5.3.2",
+ "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+ "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 4"
+ }
+ },
+ "node_modules/imurmurhash": {
+ "version": "0.1.4",
+ "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+ "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.8.19"
+ }
+ },
+ "node_modules/is-extglob": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+ "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/is-fullwidth-code-point": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+ "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/is-glob": {
+ "version": "4.0.3",
+ "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+ "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "is-extglob": "^2.1.1"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/is-node-process": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/is-node-process/-/is-node-process-1.2.0.tgz",
+ "integrity": "sha512-Vg4o6/fqPxIjtxgUH5QLJhwZ7gW5diGCVlXpuUfELC62CuxM1iHcRe51f2W1FDy04Ai4KJkagKjx3XaqyfRKXw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/is-unsafe": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/is-unsafe/-/is-unsafe-1.0.1.tgz",
+ "integrity": "sha512-CLK2+VdgERgD96EYm5lUQssZYlRg2tkZnbsxZoacmSiRxiFJ4Nk4SzjCl+Ur+v3kXIY9dTIdb3IH22y1mZ56LA==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/NaturalIntelligence"
+ }
+ ],
+ "license": "MIT"
+ },
+ "node_modules/isexe": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+ "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/istanbul-lib-coverage": {
+ "version": "3.2.2",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
+ "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/istanbul-lib-report": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
+ "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "istanbul-lib-coverage": "^3.0.0",
+ "make-dir": "^4.0.0",
+ "supports-color": "^7.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/istanbul-reports": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
+ "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "html-escaper": "^2.0.0",
+ "istanbul-lib-report": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/jose": {
+ "version": "6.2.3",
+ "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.3.tgz",
+ "integrity": "sha512-YYVDInQKFJfR/xa3ojUTl8c2KoTwiL1R5Wg9YCydwH0x0B9grbzlg5HC7mMjCtUJjbQ/YnGEZIhI5tCgfTb4Hw==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/panva"
+ }
+ },
+ "node_modules/js-tokens": {
+ "version": "10.0.0",
+ "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-10.0.0.tgz",
+ "integrity": "sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json-buffer": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+ "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json-schema-traverse": {
+ "version": "0.4.1",
+ "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+ "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json-stable-stringify-without-jsonify": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+ "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/keyv": {
+ "version": "4.5.4",
+ "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+ "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "json-buffer": "3.0.1"
+ }
+ },
+ "node_modules/levn": {
+ "version": "0.4.1",
+ "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+ "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "prelude-ls": "^1.2.1",
+ "type-check": "~0.4.0"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/lightningcss": {
+ "version": "1.32.0",
+ "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
+ "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
+ "dev": true,
+ "license": "MPL-2.0",
+ "dependencies": {
+ "detect-libc": "^2.0.3"
+ },
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ },
+ "optionalDependencies": {
+ "lightningcss-android-arm64": "1.32.0",
+ "lightningcss-darwin-arm64": "1.32.0",
+ "lightningcss-darwin-x64": "1.32.0",
+ "lightningcss-freebsd-x64": "1.32.0",
+ "lightningcss-linux-arm-gnueabihf": "1.32.0",
+ "lightningcss-linux-arm64-gnu": "1.32.0",
+ "lightningcss-linux-arm64-musl": "1.32.0",
+ "lightningcss-linux-x64-gnu": "1.32.0",
+ "lightningcss-linux-x64-musl": "1.32.0",
+ "lightningcss-win32-arm64-msvc": "1.32.0",
+ "lightningcss-win32-x64-msvc": "1.32.0"
+ }
+ },
+ "node_modules/lightningcss-android-arm64": {
+ "version": "1.32.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.32.0.tgz",
+ "integrity": "sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-darwin-arm64": {
+ "version": "1.32.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.32.0.tgz",
+ "integrity": "sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-darwin-x64": {
+ "version": "1.32.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.32.0.tgz",
+ "integrity": "sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-freebsd-x64": {
+ "version": "1.32.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.32.0.tgz",
+ "integrity": "sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-arm-gnueabihf": {
+ "version": "1.32.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.32.0.tgz",
+ "integrity": "sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-arm64-gnu": {
+ "version": "1.32.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.32.0.tgz",
+ "integrity": "sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-arm64-musl": {
+ "version": "1.32.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.32.0.tgz",
+ "integrity": "sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-x64-gnu": {
+ "version": "1.32.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz",
+ "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-linux-x64-musl": {
+ "version": "1.32.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz",
+ "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-win32-arm64-msvc": {
+ "version": "1.32.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.32.0.tgz",
+ "integrity": "sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
+ }
+ },
+ "node_modules/lightningcss-win32-x64-msvc": {
+ "version": "1.32.0",
+ "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.32.0.tgz",
+ "integrity": "sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MPL-2.0",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">= 12.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/parcel"
}
},
- "node_modules/fsevents": {
- "version": "2.3.3",
- "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
- "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+ "node_modules/locate-path": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+ "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
"dev": true,
- "hasInstallScript": true,
"license": "MIT",
- "optional": true,
- "os": [
- "darwin"
- ],
+ "dependencies": {
+ "p-locate": "^5.0.0"
+ },
"engines": {
- "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
}
},
- "node_modules/iceberg-js": {
- "version": "0.8.1",
- "resolved": "https://registry.npmjs.org/iceberg-js/-/iceberg-js-0.8.1.tgz",
- "integrity": "sha512-1dhVQZXhcHje7798IVM+xoo/1ZdVfzOMIc8/rgVSijRK38EDqOJoGula9N/8ZI5RD8QTxNQtK/Gozpr+qUqRRA==",
+ "node_modules/magic-string": {
+ "version": "0.30.21",
+ "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+ "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/sourcemap-codec": "^1.5.5"
+ }
+ },
+ "node_modules/magicast": {
+ "version": "0.5.3",
+ "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.5.3.tgz",
+ "integrity": "sha512-pVKE4UdSQ7DvHzivsCIFx2BJn1mHG6KsyrFcaxFx6tONdneEuThrDx0Cj3AMg58KyN4pzYT+LHOotxDQDjNvkw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/parser": "^7.29.3",
+ "@babel/types": "^7.29.0",
+ "source-map-js": "^1.2.1"
+ }
+ },
+ "node_modules/make-dir": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz",
+ "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==",
+ "dev": true,
"license": "MIT",
+ "dependencies": {
+ "semver": "^7.5.3"
+ },
"engines": {
- "node": ">=20.0.0"
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
}
},
- "node_modules/is-unsafe": {
- "version": "1.0.1",
- "resolved": "https://registry.npmjs.org/is-unsafe/-/is-unsafe-1.0.1.tgz",
- "integrity": "sha512-CLK2+VdgERgD96EYm5lUQssZYlRg2tkZnbsxZoacmSiRxiFJ4Nk4SzjCl+Ur+v3kXIY9dTIdb3IH22y1mZ56LA==",
+ "node_modules/minimatch": {
+ "version": "10.2.5",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
+ "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "dependencies": {
+ "brace-expansion": "^5.0.5"
+ },
+ "engines": {
+ "node": "18 || 20 || >=22"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/ms": {
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+ "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/msw": {
+ "version": "2.15.0",
+ "resolved": "https://registry.npmjs.org/msw/-/msw-2.15.0.tgz",
+ "integrity": "sha512-2wQAmKkQKxRuXvYJxVhPGG0wZNBQyD06oJvxqw90XqLvptdqxdlHrFUfEteKkpaNORX3Xzc+HtEl/q0nfmN2wQ==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "dependencies": {
+ "@inquirer/confirm": "^6.0.11",
+ "@mswjs/interceptors": "^0.41.3",
+ "@open-draft/deferred-promise": "^3.0.0",
+ "@types/statuses": "^2.0.6",
+ "cookie": "^1.1.1",
+ "graphql": "^16.13.2",
+ "headers-polyfill": "^5.0.1",
+ "is-node-process": "^1.2.0",
+ "outvariant": "^1.4.3",
+ "path-to-regexp": "^6.3.0",
+ "picocolors": "^1.1.1",
+ "rettime": "^0.11.11",
+ "statuses": "^2.0.2",
+ "strict-event-emitter": "^0.5.1",
+ "tough-cookie": "^6.0.1",
+ "type-fest": "^5.5.0",
+ "until-async": "^3.0.2",
+ "yargs": "^17.7.2"
+ },
+ "bin": {
+ "msw": "cli/index.js"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/mswjs"
+ },
+ "peerDependencies": {
+ "typescript": ">= 4.8.x"
+ },
+ "peerDependenciesMeta": {
+ "typescript": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/mute-stream": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-3.0.0.tgz",
+ "integrity": "sha512-dkEJPVvun4FryqBmZ5KhDo0K9iDXAwn08tMLDinNdRBNPcYEDiWYysLcc6k3mjTMlbP9KyylvRpd4wFtwrT9rw==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": "^20.17.0 || >=22.9.0"
+ }
+ },
+ "node_modules/nanoid": {
+ "version": "3.3.15",
+ "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.15.tgz",
+ "integrity": "sha512-y7Wygv/7mEOvxTuEQDB8StXdMRBWf1kR/tlhAzBRUFkB2jfcLOAxO/SHmOO2zgz1pVgK29/kyupn059/bCHdjA==",
+ "dev": true,
"funding": [
{
"type": "github",
- "url": "https://github.com/sponsors/NaturalIntelligence"
+ "url": "https://github.com/sponsors/ai"
}
],
+ "license": "MIT",
+ "bin": {
+ "nanoid": "bin/nanoid.cjs"
+ },
+ "engines": {
+ "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+ }
+ },
+ "node_modules/natural-compare": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+ "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+ "dev": true,
"license": "MIT"
},
+ "node_modules/nodemailer": {
+ "version": "9.0.3",
+ "resolved": "https://registry.npmjs.org/nodemailer/-/nodemailer-9.0.3.tgz",
+ "integrity": "sha512-n+YP+NKwR5zRWa60k3GiQ6Q3B4KXCoAw40dAKeCtYn020iNN74aWK2liXIC3ZEATeGql7we3tE3t8QwhY0eskw==",
+ "license": "MIT-0",
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/obug": {
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.3.tgz",
+ "integrity": "sha512-9miFgM2OFba7hB+pRgvtV84pYTBaoTHohvmIgiRt6dRIzbwEOIaNaP+dIlGs2fNFoB0SeISs0Jz5WFVRid6Xyg==",
+ "dev": true,
+ "funding": [
+ "https://github.com/sponsors/sxzz",
+ "https://opencollective.com/debug"
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=12.20.0"
+ }
+ },
"node_modules/openai": {
"version": "6.45.0",
"resolved": "https://registry.npmjs.org/openai/-/openai-6.45.0.tgz",
@@ -725,19 +3390,379 @@
}
}
},
- "node_modules/path-expression-matcher": {
- "version": "1.6.1",
- "resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.6.1.tgz",
- "integrity": "sha512-h7bxdzhHk8Knyc4Tj+jMaa7fEEoUJy7p1qtbVgkYg1Uhpe5Np5VuGXCRZnkZvU+Q42M1vStt0ifa3ueykRJPmQ==",
- "funding": [
- {
- "type": "github",
- "url": "https://github.com/sponsors/NaturalIntelligence"
- }
- ],
+ "node_modules/optionator": {
+ "version": "0.9.4",
+ "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+ "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "deep-is": "^0.1.3",
+ "fast-levenshtein": "^2.0.6",
+ "levn": "^0.4.1",
+ "prelude-ls": "^1.2.1",
+ "type-check": "^0.4.0",
+ "word-wrap": "^1.2.5"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/outvariant": {
+ "version": "1.4.3",
+ "resolved": "https://registry.npmjs.org/outvariant/-/outvariant-1.4.3.tgz",
+ "integrity": "sha512-+Sl2UErvtsoajRDKCE5/dBz4DIvHXQQnAxtQTF04OJxY0+DyZXSo5P5Bb7XYWOh81syohlYL24hbDwxedPUJCA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/p-limit": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+ "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "yocto-queue": "^0.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/p-locate": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+ "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "p-limit": "^3.0.2"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/path-exists": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+ "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/path-expression-matcher": {
+ "version": "1.6.1",
+ "resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.6.1.tgz",
+ "integrity": "sha512-h7bxdzhHk8Knyc4Tj+jMaa7fEEoUJy7p1qtbVgkYg1Uhpe5Np5VuGXCRZnkZvU+Q42M1vStt0ifa3ueykRJPmQ==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/NaturalIntelligence"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=14.0.0"
+ }
+ },
+ "node_modules/path-key": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+ "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/path-to-regexp": {
+ "version": "6.3.0",
+ "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.3.0.tgz",
+ "integrity": "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/pathe": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+ "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/picocolors": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+ "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/picomatch": {
+ "version": "4.0.5",
+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
+ "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/jonschlinkert"
+ }
+ },
+ "node_modules/postcss": {
+ "version": "8.5.16",
+ "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.16.tgz",
+ "integrity": "sha512-vuwillviilfKZsg0VGj5R/YwwcHx4SLsIOI/7K6mQkWx+l5cUHTjj5g0AasTBcyXsbfTgrwsUNmVUb5xVwyPwg==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/postcss/"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/funding/github/npm/postcss"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "nanoid": "^3.3.12",
+ "picocolors": "^1.1.1",
+ "source-map-js": "^1.2.1"
+ },
+ "engines": {
+ "node": "^10 || ^12 || >=14"
+ }
+ },
+ "node_modules/prelude-ls": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+ "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/punycode": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+ "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/pure-rand": {
+ "version": "8.4.1",
+ "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-8.4.1.tgz",
+ "integrity": "sha512-c58R2+SPFcSIPXoU834QN/KPDDOSd8sXcSrqf6e83Me6Rrp1EYkxukkjXMVrKvKaADs1SOyNkWdfvLf6zY8qLQ==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://github.com/sponsors/dubzzz"
+ },
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/fast-check"
+ }
+ ],
+ "license": "MIT"
+ },
+ "node_modules/require-directory": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+ "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/rettime": {
+ "version": "0.11.11",
+ "resolved": "https://registry.npmjs.org/rettime/-/rettime-0.11.11.tgz",
+ "integrity": "sha512-ILJRqVWBCTlg9r42fFgwVZx1gnFAcQF8mRoMkbgQfIrjEDf9nbBFDFx00oloOa+Q869FUtaYDXZvEfnecQSCoQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/rolldown": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.1.5.tgz",
+ "integrity": "sha512-t9z29cJjXf/vxQ8dyhCSpt6H6aSwHTk8cT5I3iy6SMXuFpk5mB6PL6XfC8PCwrPTx93udwKUm9HRteAlTGBLiA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@oxc-project/types": "=0.139.0",
+ "@rolldown/pluginutils": "^1.0.0"
+ },
+ "bin": {
+ "rolldown": "bin/cli.mjs"
+ },
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ },
+ "optionalDependencies": {
+ "@rolldown/binding-android-arm64": "1.1.5",
+ "@rolldown/binding-darwin-arm64": "1.1.5",
+ "@rolldown/binding-darwin-x64": "1.1.5",
+ "@rolldown/binding-freebsd-x64": "1.1.5",
+ "@rolldown/binding-linux-arm-gnueabihf": "1.1.5",
+ "@rolldown/binding-linux-arm64-gnu": "1.1.5",
+ "@rolldown/binding-linux-arm64-musl": "1.1.5",
+ "@rolldown/binding-linux-ppc64-gnu": "1.1.5",
+ "@rolldown/binding-linux-s390x-gnu": "1.1.5",
+ "@rolldown/binding-linux-x64-gnu": "1.1.5",
+ "@rolldown/binding-linux-x64-musl": "1.1.5",
+ "@rolldown/binding-openharmony-arm64": "1.1.5",
+ "@rolldown/binding-wasm32-wasi": "1.1.5",
+ "@rolldown/binding-win32-arm64-msvc": "1.1.5",
+ "@rolldown/binding-win32-x64-msvc": "1.1.5"
+ }
+ },
+ "node_modules/semver": {
+ "version": "7.8.5",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+ "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/set-cookie-parser": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-3.1.2.tgz",
+ "integrity": "sha512-5/r/lTwbJ3zQ+qwdUFZYeRNqda7P5HD8zQKqlSjdGt1/S0cjLAphHusj4Y58ahDtWn/g32xrIS58/ikOvwl0Lw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/shebang-command": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+ "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "shebang-regex": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/shebang-regex": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+ "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/siginfo": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+ "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/signal-exit": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+ "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=14"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/source-map-js": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+ "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/stackback": {
+ "version": "0.0.2",
+ "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+ "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/statuses": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+ "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/std-env": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.2.0.tgz",
+ "integrity": "sha512-oCUKSupKTHX53EyjDtuZQ64pjLJ6yYCtpmEw0goYxtjG9KpbRe8KAsl2tBUGU9DyMcJ0RwJ8GqJAFzMXcXW1Rw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/strict-event-emitter": {
+ "version": "0.5.1",
+ "resolved": "https://registry.npmjs.org/strict-event-emitter/-/strict-event-emitter-0.5.1.tgz",
+ "integrity": "sha512-vMgjE/GGEPEFnhFub6pa4FmJBRBVOLpIII2hvCZ8Kzb7K0hlHo7mQv6xYrBvCL2LtAIBwFUK8wvuJgTVSQ5MFQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/string-width": {
+ "version": "4.2.3",
+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+ "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "emoji-regex": "^8.0.0",
+ "is-fullwidth-code-point": "^3.0.0",
+ "strip-ansi": "^6.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/strip-ansi": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+ "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+ "dev": true,
"license": "MIT",
+ "dependencies": {
+ "ansi-regex": "^5.0.1"
+ },
"engines": {
- "node": ">=14.0.0"
+ "node": ">=8"
}
},
"node_modules/strnum": {
@@ -755,6 +3780,146 @@
"anynum": "^1.0.1"
}
},
+ "node_modules/supabase": {
+ "version": "2.109.1",
+ "resolved": "https://registry.npmjs.org/supabase/-/supabase-2.109.1.tgz",
+ "integrity": "sha512-N2yP2MHTxOxXBWhfn3poudpJn4pkPosAUo7J/46FTou/l7wOwFi9tox8NSN6HljWkfM0zhwPRimNNGC9XBMoxQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "eciesjs": "^0.5.0",
+ "jose": "^6.2.3"
+ },
+ "bin": {
+ "supabase": "dist/supabase.js"
+ },
+ "optionalDependencies": {
+ "@supabase/cli-darwin-arm64": "2.109.1",
+ "@supabase/cli-darwin-x64": "2.109.1",
+ "@supabase/cli-linux-arm64": "2.109.1",
+ "@supabase/cli-linux-arm64-musl": "2.109.1",
+ "@supabase/cli-linux-x64": "2.109.1",
+ "@supabase/cli-linux-x64-musl": "2.109.1",
+ "@supabase/cli-windows-arm64": "2.109.1",
+ "@supabase/cli-windows-x64": "2.109.1"
+ }
+ },
+ "node_modules/supports-color": {
+ "version": "7.2.0",
+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+ "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "has-flag": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/tagged-tag": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/tagged-tag/-/tagged-tag-1.0.0.tgz",
+ "integrity": "sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=20"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/tinybench": {
+ "version": "2.9.0",
+ "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+ "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/tinyexec": {
+ "version": "1.2.4",
+ "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.2.4.tgz",
+ "integrity": "sha512-SHf/r48b7vOrjve9PxJo3MN5v5yuyjHvdUcrQffT3WXMUfnGmHDVbC4k3sHJaJTgZCwpUplIaAo5ANtMyp3YHg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/tinyglobby": {
+ "version": "0.2.17",
+ "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+ "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fdir": "^6.5.0",
+ "picomatch": "^4.0.4"
+ },
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/SuperchupuDev"
+ }
+ },
+ "node_modules/tinyrainbow": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.0.tgz",
+ "integrity": "sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=14.0.0"
+ }
+ },
+ "node_modules/tldts": {
+ "version": "7.4.8",
+ "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.8.tgz",
+ "integrity": "sha512-htwgN/8KRB3z3vnC0BOETVh2m499g5GmyTK9Wq5JBLX3FNz6tSBveAd+fQhzy9hkjif8vy2jwDMR1sGhLtZl2A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "tldts-core": "^7.4.8"
+ },
+ "bin": {
+ "tldts": "bin/cli.js"
+ }
+ },
+ "node_modules/tldts-core": {
+ "version": "7.4.8",
+ "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.8.tgz",
+ "integrity": "sha512-c1P7u0EhACHj7lPy4MJm8iTFEU8+nB0LCtddH0fhP7noaVoXAqafMtOOeX+ulpuPBqnrRgRhw494RICT3mbhnw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/tough-cookie": {
+ "version": "6.0.2",
+ "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.2.tgz",
+ "integrity": "sha512-exgYmnmL/sJpR3upZfXG5PoatXQii55xAiXGXzY+sROLZ/Y+SLcp9PgJNI9Vz37HpQ74WvDcLT8eqm+kV3FzrA==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "tldts": "^7.0.5"
+ },
+ "engines": {
+ "node": ">=16"
+ }
+ },
+ "node_modules/ts-api-utils": {
+ "version": "2.5.0",
+ "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.5.0.tgz",
+ "integrity": "sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18.12"
+ },
+ "peerDependencies": {
+ "typescript": ">=4.8.4"
+ }
+ },
"node_modules/tslib": {
"version": "2.8.1",
"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
@@ -780,6 +3945,35 @@
"fsevents": "~2.3.3"
}
},
+ "node_modules/type-check": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+ "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "prelude-ls": "^1.2.1"
+ },
+ "engines": {
+ "node": ">= 0.8.0"
+ }
+ },
+ "node_modules/type-fest": {
+ "version": "5.8.0",
+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.8.0.tgz",
+ "integrity": "sha512-YGYEVz3Fm5iy/AybuA0oyNFq7H4CgQNfRp/qfe8nurE1kuCeNm3/vfm9X4Mtl+qLyaKJUh5xrFZwogr41SMjYA==",
+ "dev": true,
+ "license": "(MIT OR CC0-1.0)",
+ "dependencies": {
+ "tagged-tag": "^1.0.0"
+ },
+ "engines": {
+ "node": ">=20"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
"node_modules/typescript": {
"version": "6.0.3",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
@@ -794,6 +3988,30 @@
"node": ">=14.17"
}
},
+ "node_modules/typescript-eslint": {
+ "version": "8.63.0",
+ "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.63.0.tgz",
+ "integrity": "sha512-xgwXyzG4sK9ALkBxbyGkTMMOS+imnW65iPhxCQMK83KhxyoDNW7l+IDqEf9vMdoUidHpOoS967RCq4eMiTexwQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@typescript-eslint/eslint-plugin": "8.63.0",
+ "@typescript-eslint/parser": "8.63.0",
+ "@typescript-eslint/typescript-estree": "8.63.0",
+ "@typescript-eslint/utils": "8.63.0"
+ },
+ "engines": {
+ "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/typescript-eslint"
+ },
+ "peerDependencies": {
+ "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+ "typescript": ">=4.8.4 <6.1.0"
+ }
+ },
"node_modules/undici-types": {
"version": "8.3.0",
"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.3.0.tgz",
@@ -801,6 +4019,255 @@
"dev": true,
"license": "MIT"
},
+ "node_modules/until-async": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/until-async/-/until-async-3.0.2.tgz",
+ "integrity": "sha512-IiSk4HlzAMqTUseHHe3VhIGyuFmN90zMTpD3Z3y8jeQbzLIq500MVM7Jq2vUAnTKAFPJrqwkzr6PoTcPhGcOiw==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/kettanaito"
+ }
+ },
+ "node_modules/uri-js": {
+ "version": "4.4.1",
+ "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+ "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "punycode": "^2.1.0"
+ }
+ },
+ "node_modules/vite": {
+ "version": "8.1.4",
+ "resolved": "https://registry.npmjs.org/vite/-/vite-8.1.4.tgz",
+ "integrity": "sha512-bTT9PsdWO+MQMNG9ZXIP/qM9wGh37DFxTV/sPq9cFpHr3w4jkgef032PkAL9jAqhk3Nz8NQw3O8n6/xFkqO4QQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "lightningcss": "^1.32.0",
+ "picomatch": "^4.0.5",
+ "postcss": "^8.5.16",
+ "rolldown": "~1.1.4",
+ "tinyglobby": "^0.2.17"
+ },
+ "bin": {
+ "vite": "bin/vite.js"
+ },
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ },
+ "funding": {
+ "url": "https://github.com/vitejs/vite?sponsor=1"
+ },
+ "optionalDependencies": {
+ "fsevents": "~2.3.3"
+ },
+ "peerDependencies": {
+ "@types/node": "^20.19.0 || >=22.12.0",
+ "@vitejs/devtools": "^0.3.0",
+ "esbuild": "^0.27.0 || ^0.28.0",
+ "jiti": ">=1.21.0",
+ "less": "^4.0.0",
+ "sass": "^1.70.0",
+ "sass-embedded": "^1.70.0",
+ "stylus": ">=0.54.8",
+ "sugarss": "^5.0.0",
+ "terser": "^5.16.0",
+ "tsx": "^4.8.1",
+ "yaml": "^2.4.2"
+ },
+ "peerDependenciesMeta": {
+ "@types/node": {
+ "optional": true
+ },
+ "@vitejs/devtools": {
+ "optional": true
+ },
+ "esbuild": {
+ "optional": true
+ },
+ "jiti": {
+ "optional": true
+ },
+ "less": {
+ "optional": true
+ },
+ "sass": {
+ "optional": true
+ },
+ "sass-embedded": {
+ "optional": true
+ },
+ "stylus": {
+ "optional": true
+ },
+ "sugarss": {
+ "optional": true
+ },
+ "terser": {
+ "optional": true
+ },
+ "tsx": {
+ "optional": true
+ },
+ "yaml": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/vitest": {
+ "version": "4.1.10",
+ "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.10.tgz",
+ "integrity": "sha512-R9jUTe5S4Qb0HCd4TNqpC7oGcrMssMRGXLW80ubjWsW9VH5GF8y1Y0SFLY9AbqSk6nt0PnOx4H4WNJYZ13GUPw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@vitest/expect": "4.1.10",
+ "@vitest/mocker": "4.1.10",
+ "@vitest/pretty-format": "4.1.10",
+ "@vitest/runner": "4.1.10",
+ "@vitest/snapshot": "4.1.10",
+ "@vitest/spy": "4.1.10",
+ "@vitest/utils": "4.1.10",
+ "es-module-lexer": "^2.0.0",
+ "expect-type": "^1.3.0",
+ "magic-string": "^0.30.21",
+ "obug": "^2.1.1",
+ "pathe": "^2.0.3",
+ "picomatch": "^4.0.3",
+ "std-env": "^4.0.0-rc.1",
+ "tinybench": "^2.9.0",
+ "tinyexec": "^1.0.2",
+ "tinyglobby": "^0.2.15",
+ "tinyrainbow": "^3.1.0",
+ "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
+ "why-is-node-running": "^2.3.0"
+ },
+ "bin": {
+ "vitest": "vitest.mjs"
+ },
+ "engines": {
+ "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
+ },
+ "funding": {
+ "url": "https://opencollective.com/vitest"
+ },
+ "peerDependencies": {
+ "@edge-runtime/vm": "*",
+ "@opentelemetry/api": "^1.9.0",
+ "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+ "@vitest/browser-playwright": "4.1.10",
+ "@vitest/browser-preview": "4.1.10",
+ "@vitest/browser-webdriverio": "4.1.10",
+ "@vitest/coverage-istanbul": "4.1.10",
+ "@vitest/coverage-v8": "4.1.10",
+ "@vitest/ui": "4.1.10",
+ "happy-dom": "*",
+ "jsdom": "*",
+ "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@edge-runtime/vm": {
+ "optional": true
+ },
+ "@opentelemetry/api": {
+ "optional": true
+ },
+ "@types/node": {
+ "optional": true
+ },
+ "@vitest/browser-playwright": {
+ "optional": true
+ },
+ "@vitest/browser-preview": {
+ "optional": true
+ },
+ "@vitest/browser-webdriverio": {
+ "optional": true
+ },
+ "@vitest/coverage-istanbul": {
+ "optional": true
+ },
+ "@vitest/coverage-v8": {
+ "optional": true
+ },
+ "@vitest/ui": {
+ "optional": true
+ },
+ "happy-dom": {
+ "optional": true
+ },
+ "jsdom": {
+ "optional": true
+ },
+ "vite": {
+ "optional": false
+ }
+ }
+ },
+ "node_modules/which": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+ "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "isexe": "^2.0.0"
+ },
+ "bin": {
+ "node-which": "bin/node-which"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/why-is-node-running": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+ "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "siginfo": "^2.0.0",
+ "stackback": "0.0.2"
+ },
+ "bin": {
+ "why-is-node-running": "cli.js"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/word-wrap": {
+ "version": "1.2.5",
+ "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+ "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/wrap-ansi": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+ "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-styles": "^4.0.0",
+ "string-width": "^4.1.0",
+ "strip-ansi": "^6.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+ }
+ },
"node_modules/xml-naming": {
"version": "0.1.0",
"resolved": "https://registry.npmjs.org/xml-naming/-/xml-naming-0.1.0.tgz",
@@ -815,6 +4282,67 @@
"engines": {
"node": ">=16.0.0"
}
+ },
+ "node_modules/y18n": {
+ "version": "5.0.8",
+ "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+ "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/yargs": {
+ "version": "17.7.3",
+ "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.3.tgz",
+ "integrity": "sha512-GZtjxm/J/4TSxuL3FNYjCmLktBTnIw/rVmKSIyKeYAZpmJB2ig9VauCC5xsa82GNKVKDAqpOn3KVzNt0zmrU0g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "cliui": "^8.0.1",
+ "escalade": "^3.1.1",
+ "get-caller-file": "^2.0.5",
+ "require-directory": "^2.1.1",
+ "string-width": "^4.2.3",
+ "y18n": "^5.0.5",
+ "yargs-parser": "^21.1.1"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/yargs-parser": {
+ "version": "21.1.1",
+ "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+ "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/yocto-queue": {
+ "version": "0.1.0",
+ "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+ "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/zod": {
+ "version": "4.4.3",
+ "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
+ "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/colinhacks"
+ }
}
}
}
diff --git a/package.json b/package.json
index ea39f80..39c4e0e 100644
--- a/package.json
+++ b/package.json
@@ -2,26 +2,61 @@
"name": "frontier-papers",
"version": "0.1.0",
"private": true,
+ "engines": {
+ "node": ">=20.19.0 <26"
+ },
"type": "module",
- "description": "前沿论文情报台 — 多源采集 → Claude 排名/总结 → 每晚邮件 Top5",
+ "description": "前沿论文情报台 — 多源采集、DeepSeek 个性化 Top 5、Supabase 归档与微信推送",
"scripts": {
"ingest:dry": "tsx scripts/ingest.ts --dry",
- "ingest": "node --env-file=.env --import tsx scripts/ingest.ts",
- "ingest:send": "node --env-file=.env --import tsx scripts/ingest.ts --send",
- "push:last": "node --env-file=.env --import tsx scripts/send-last.ts",
- "refine": "node --env-file=.env --import tsx scripts/refine-profile.ts",
- "refine:apply": "node --env-file=.env --import tsx scripts/refine-profile.ts --apply",
- "test": "node --import tsx --test lib/*.test.ts",
- "typecheck": "tsc --noEmit"
+ "ingest": "node --import tsx scripts/ingest.ts",
+ "ingest:send": "node --import tsx scripts/ingest.ts --send",
+ "push:last": "node --import tsx scripts/send-last.ts",
+ "delivery:work": "node --import tsx scripts/delivery-worker.ts",
+ "refine": "node --import tsx scripts/refine-profile.ts",
+ "refine:apply": "node --import tsx scripts/refine-profile.ts --apply",
+ "config:migrate": "node --import tsx scripts/migrate-env.ts",
+ "preflight": "node --import tsx scripts/preflight.ts",
+ "doctor": "node --import tsx scripts/doctor.ts",
+ "state:backup": "node --import tsx scripts/state-backup.ts backup",
+ "state:restore": "node --import tsx scripts/state-backup.ts restore",
+ "cloud:materialize": "node --import tsx scripts/materialize-cloud-runtime.ts",
+ "db:start": "supabase start -x studio,imgproxy,edge-runtime,logflare,vector,realtime,storage-api,mailpit,postgres-meta,supavisor",
+ "db:stop": "supabase stop --no-backup",
+ "db:reset": "supabase db reset --local",
+ "db:lint": "supabase db lint --local --schema public --level warning --fail-on error",
+ "db:test": "bash scripts/test-db.sh",
+ "test:idor": "bash scripts/test-idor.sh",
+ "lint": "eslint . --max-warnings=0",
+ "test": "vitest run",
+ "test:unit": "vitest run lib tests/unit",
+ "test:contract": "vitest run tests/contracts",
+ "test:integration": "vitest run tests/integration --maxWorkers=1",
+ "test:watch": "vitest",
+ "test:coverage": "vitest run --coverage",
+ "typecheck": "tsc --noEmit",
+ "verify": "npm run lint && npm run typecheck && npm run test:coverage && npm --prefix web run verify",
+ "verify:full": "npm run verify && npm --prefix web run test:e2e"
},
"dependencies": {
"@supabase/supabase-js": "^2.108.2",
"fast-xml-parser": "^5.9.3",
- "openai": "^6.45.0"
+ "nodemailer": "^9.0.3",
+ "openai": "^6.45.0",
+ "zod": "^4.4.3"
},
"devDependencies": {
+ "@eslint/js": "^10.0.1",
"@types/node": "^26.0.1",
+ "@types/nodemailer": "^7.0.12",
+ "@vitest/coverage-v8": "^4.1.10",
+ "eslint": "^10.6.0",
+ "fast-check": "^4.9.0",
+ "msw": "^2.15.0",
+ "supabase": "2.109.1",
"tsx": "^4.22.4",
- "typescript": "^6.0.3"
+ "typescript": "^6.0.3",
+ "typescript-eslint": "^8.63.0",
+ "vitest": "^4.1.10"
}
}
diff --git a/scripts/delivery-worker.ts b/scripts/delivery-worker.ts
new file mode 100644
index 0000000..f8812fb
--- /dev/null
+++ b/scripts/delivery-worker.ts
@@ -0,0 +1,74 @@
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadRootConfig } from "../lib/runtime-config.ts";
+import { safeErrorMessage } from "../lib/safe-error.ts";
+import { sendFailureAlert, type AlertEvent } from "../lib/alert.ts";
+import {
+ currentRuntimeEnvironment,
+ loadRuntimeEnvironment,
+ withRuntimeEnvironment,
+ type RuntimeEnvironment,
+} from "../lib/runtime-env.ts";
+import {
+ processPendingDeliveries,
+ type DeliveryAttemptReport,
+} from "./digest.ts";
+import {
+ checkDeliveryDeadline,
+ type DeliveryHealthReport,
+} from "../lib/delivery-health.ts";
+
+type HealthCheck = (environment: RuntimeEnvironment) => Promise;
+type WorkerRunner = (environment: RuntimeEnvironment) => Promise;
+type AlertSender = (
+ event: AlertEvent,
+ environment: RuntimeEnvironment,
+) => Promise;
+type EnvironmentLoader = (baseEnvironment: RuntimeEnvironment) => RuntimeEnvironment;
+
+export async function runDeliveryWorker(
+ injectedEnv?: RuntimeEnvironment,
+ processPending: () => Promise = processPendingDeliveries,
+ checkHealth: HealthCheck = (environment) => checkDeliveryDeadline({ environment }),
+): Promise {
+ const environment = injectedEnv ?? loadRuntimeEnvironment();
+ return withRuntimeEnvironment(environment, async () => {
+ loadRootConfig("deliver", currentRuntimeEnvironment());
+ const report = await processPending();
+ const health = await checkHealth(environment);
+ console.log(
+ `delivery worker: attempted=${report.attempted} succeeded=${report.succeeded.length} retried=${report.retried.length}`,
+ );
+ console.log(
+ `delivery health: date=${health.date} status=${health.status} missing=${health.missing.join(",") || "none"}`,
+ );
+ return report;
+ });
+}
+
+export async function runDeliveryWorkerEntry(
+ baseEnvironment: RuntimeEnvironment = process.env,
+ worker: WorkerRunner = runDeliveryWorker,
+ sendAlert: AlertSender = sendFailureAlert,
+ loadEnvironment: EnvironmentLoader = (base) => loadRuntimeEnvironment({ baseEnv: base }),
+): Promise {
+ let environment: RuntimeEnvironment | undefined;
+ try {
+ environment = loadEnvironment(baseEnvironment);
+ await worker(environment);
+ } catch (error) {
+ const scopedEnvironment = environment ?? baseEnvironment;
+ const detail = safeErrorMessage(error, scopedEnvironment);
+ console.error(`delivery worker failed: ${detail}`);
+ await sendAlert({
+ detail,
+ event: "delivery_worker_failed",
+ severity: "critical",
+ }, scopedEnvironment);
+ process.exitCode = 1;
+ }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+ void runDeliveryWorkerEntry();
+}
diff --git a/scripts/digest.ts b/scripts/digest.ts
index 58657d5..0bf9cbe 100644
--- a/scripts/digest.ts
+++ b/scripts/digest.ts
@@ -1,21 +1,114 @@
+import { createHash } from "node:crypto";
+import { randomUUID } from "node:crypto";
import type { SummarizedItem } from "../lib/types.ts";
-import { signFeedback } from "../lib/sign.ts";
+import { classifyEmailFailure, sendEmail } from "../lib/email.ts";
+import {
+ claimDigestDeliveries,
+ claimDeliveries,
+ deliveryDateFromTitle,
+ enqueueDigestDeliveries,
+ finishDelivery,
+ requeueFailedDigestDeliveries,
+ retryAt,
+} from "../lib/outbox.ts";
+import {
+ loadFeedbackConfig,
+ loadServerChanConfig,
+ type FeedbackConfig,
+} from "../lib/runtime-config.ts";
+import { issueFeedbackToken, verifyFeedbackToken } from "../lib/feedback-token.ts";
+import { currentRuntimeEnvironment } from "../lib/runtime-env.ts";
+import { sendFailureAlert } from "../lib/alert.ts";
+import { HttpRequestError, readBoundedJSONResponse } from "../lib/http.ts";
const SHOW_SIGNALS = ["upvotes", "stars", "category", "publisher"];
+const CANONICAL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-/** 每篇的 👍/👎 一键反馈链接（需 WEB_BASE_URL + FEEDBACK_SECRET）。 */
-function feedbackLinks(itemId: string | undefined): string {
- const base = process.env.WEB_BASE_URL;
- if (!base || !itemId || !process.env.FEEDBACK_SECRET) return "";
- const link = (r: "up" | "down") => `${base}/api/feedback?i=${itemId}&r=${r}&t=${signFeedback(itemId, r)}`;
- return `👍 [有用](${link("up")}) ・ 👎 [不相关](${link("down")})`;
+function invalidStoredDigest(): never {
+ throw new Error("Stored digest feedback links have expired or are invalid");
+}
+
+/** Rejects stale, legacy, rotated, partial, or remapped stored feedback links. */
+export function assertDigestFeedbackLinks(
+ date: string,
+ itemIds: readonly string[],
+ markdown: string,
+ feedback: FeedbackConfig,
+ now: Date | number = Date.now(),
+): void {
+ const expectedOrigin = new URL(feedback.webBaseURL).origin;
+ if (
+ !/^\d{4}-\d{2}-\d{2}$/.test(date) ||
+ itemIds.length < 1 ||
+ itemIds.length > 5 ||
+ new Set(itemIds).size !== itemIds.length ||
+ itemIds.some((itemId) => !CANONICAL_UUID.test(itemId)) ||
+ markdown.includes("/api/feedback")
+ ) {
+ invalidStoredDigest();
+ }
+ const links = [
+ ...markdown.matchAll(/\[(👍 有用|👎 不相关)\]\(([^)\r\n]+)\)/g),
+ ];
+ const expectedCount = itemIds.length * 2;
+ if (
+ links.length !== expectedCount ||
+ (markdown.match(/[?&]token=/g)?.length ?? 0) !== expectedCount
+ ) {
+ invalidStoredDigest();
+ }
+
+ const expected = itemIds.flatMap((itemId) => [`${itemId}:up`, `${itemId}:down`]);
+ const actual: string[] = [];
+ for (const [, label, destination] of links) {
+ let url: URL;
+ try {
+ url = new URL(destination);
+ } catch {
+ invalidStoredDigest();
+ }
+ const parameters = [...url.searchParams];
+ if (
+ url.origin !== expectedOrigin ||
+ url.pathname !== "/feedback" ||
+ url.hash ||
+ url.username ||
+ url.password ||
+ parameters.length !== 1 ||
+ parameters[0][0] !== "token"
+ ) {
+ invalidStoredDigest();
+ }
+ const claims = verifyFeedbackToken(feedback.secret, parameters[0][1], now);
+ const rating = label === "👍 有用" ? "up" : "down";
+ if (!claims || claims.digestDate !== date || claims.rating !== rating) {
+ invalidStoredDigest();
+ }
+ actual.push(`${claims.itemId}:${claims.rating}`);
+ }
+ if (actual.some((value, index) => value !== expected[index])) invalidStoredDigest();
}
/** 渲染每日简报 markdown（也是写进 digests.rendered_md 的内容）。 */
-export function renderDigest(date: string, items: SummarizedItem[], idByKey?: Map): string {
- const head = `# 前沿论文情报台 · ${date}\n\n> 今日 Top ${items.length}（按对你的价值排序）。读完顺手点每篇下的 👍/👎，明天更准。\n\n---\n\n`;
+export function renderDigest(
+ date: string,
+ items: SummarizedItem[],
+ idByKey: Map,
+): string {
+ const feedback = loadFeedbackConfig(currentRuntimeEnvironment());
+ const head = `# 前沿论文情报台 · ${date}\n\n> 今日 Top ${items.length}（按对你的价值排序）。登录 Web 情报台后可记录反馈，明天更准。\n\n---\n\n`;
const body = items
.map((it) => {
+ const itemId = idByKey.get(`${it.source}:${it.externalId}`);
+ if (!itemId) throw new Error("Missing digest item mapping");
+ const feedbackURL = (rating: "up" | "down") => {
+ const url = new URL("/feedback", feedback.webBaseURL);
+ url.searchParams.set(
+ "token",
+ issueFeedbackToken(feedback.secret, { digestDate: date, itemId, rating }),
+ );
+ return url.toString();
+ };
const sig = Object.entries(it.signals)
.filter(([k]) => SHOW_SIGNALS.includes(k))
.map(([k, v]) => `${k}:${v}`)
@@ -26,6 +119,7 @@ export function renderDigest(date: string, items: SummarizedItem[], idByKey?: Ma
`- 来源：${it.source}${sig ? ` · ${sig}` : ""} · 评分 ${it.score}`,
`- 链接：${it.url}`,
`- 作者：${it.authors.slice(0, 6).join(", ") || "—"}`,
+ `- 反馈：[👍 有用](${feedbackURL("up")}) · [👎 不相关](${feedbackURL("down")})（登录后确认）`,
``,
`**一句话看点** ${it.oneLiner}`,
``,
@@ -37,9 +131,9 @@ export function renderDigest(date: string, items: SummarizedItem[], idByKey?: Ma
``,
it.impactMd,
``,
+ ...(it.degraded ? [`> ⚠️ 本条为降级结果（${it.degradedReason === "llm_rank_failed" ? "排名服务暂不可用" : "摘要服务暂不可用"}），请以原文为准。`, ``] : []),
`> 入选理由：${it.rationale}`,
``,
- feedbackLinks(idByKey?.get(`${it.source}:${it.externalId}`)),
`---`,
].join("\n");
})
@@ -49,20 +143,164 @@ export function renderDigest(date: string, items: SummarizedItem[], idByKey?: Ma
/** 推送到微信（Server酱 / ServerChan）。markdown 直接作为 desp，无需 SDK。
* 自动适配两种 SendKey：老版 Turbo（SCT...）走 ftqq，Server酱³（sctpt...）走 ft07。 */
-export async function pushDigest(title: string, md: string): Promise {
- const key = process.env.SERVERCHAN_SENDKEY;
- if (!key) throw new Error("缺少 SERVERCHAN_SENDKEY（见 .env.example）");
+function validateServerChanResponse(value: unknown): { code: 0 } {
+ if (
+ value === null ||
+ typeof value !== "object" ||
+ Array.isArray(value) ||
+ (value as { code?: unknown }).code !== 0
+ ) {
+ throw new Error("ServerChan response does not contain an explicit success code");
+ }
+ return { code: 0 };
+}
+
+async function sendServerChan(title: string, md: string): Promise {
+ const key = loadServerChanConfig(currentRuntimeEnvironment()).sendKey;
const uid = key.match(/^sctp(\d+)t/)?.[1];
const url = uid
? `https://${uid}.push.ft07.com/send/${key}.send`
: `https://sctapi.ftqq.com/${key}.send`;
- const res = await fetch(url, {
- method: "POST",
- headers: { "Content-Type": "application/x-www-form-urlencoded" },
- body: new URLSearchParams({ title: title.slice(0, 32), desp: md }),
+ const controller = new AbortController();
+ const timeout = setTimeout(() => controller.abort(), 30_000);
+ try {
+ const res = await fetch(url, {
+ method: "POST",
+ headers: { "Content-Type": "application/x-www-form-urlencoded" },
+ body: new URLSearchParams({ title: title.slice(0, 32), desp: md }),
+ signal: controller.signal,
+ });
+ await readBoundedJSONResponse(res, {
+ endpoint: "serverchan",
+ maxResponseBytes: 64 * 1024,
+ signal: controller.signal,
+ validate: validateServerChanResponse,
+ });
+ } finally {
+ clearTimeout(timeout);
+ }
+}
+
+function retryableServerChanFailure(error: unknown): boolean {
+ if (error instanceof HttpRequestError) return error.retryable;
+ const message = error instanceof Error ? error.message : String(error);
+ return /HTTP (408|429|5\d\d)|aborted|timed out|network|fetch/i.test(message);
+}
+
+export interface DeliveryAttemptReport {
+ readonly attempted: number;
+ readonly permanentFailures: readonly string[];
+ readonly retried: readonly string[];
+ readonly succeeded: readonly string[];
+}
+
+export interface DeliveryReplayReport extends DeliveryAttemptReport {
+ readonly requeued: number;
+}
+
+/** Process one leased attempt per claimable channel without re-enqueuing a digest. */
+async function processClaimedDeliveries(
+ deliveries: Awaited>,
+ workerId: string,
+): Promise {
+ const permanentFailures: string[] = [];
+ const retried: string[] = [];
+ const succeeded: string[] = [];
+ for (const delivery of deliveries) {
+ try {
+ let providerMessageId: string | undefined;
+ if (delivery.channel === "email") {
+ const result = await sendEmail({
+ subject: delivery.payload.title,
+ text: delivery.payload.markdown,
+ idempotencyKey: delivery.idempotencyKey,
+ });
+ if (!result || typeof result.messageId !== "string" || !result.messageId) {
+ throw new Error("SMTP provider returned no delivery receipt");
+ }
+ providerMessageId = result.messageId;
+ } else {
+ await sendServerChan(delivery.payload.title, delivery.payload.markdown);
+ }
+ await finishDelivery(delivery.deliveryId, workerId, "success", { providerMessageId });
+ succeeded.push(delivery.channel);
+ } catch (error) {
+ const retryable = delivery.channel === "email"
+ ? classifyEmailFailure(error) === "retryable"
+ : retryableServerChanFailure(error);
+ const safeReason = delivery.channel === "email" ? "SMTP delivery failed" : "ServerChan delivery failed";
+ const outcome = retryable && delivery.attempts < 5 ? "retry" : "permanent";
+ await finishDelivery(
+ delivery.deliveryId,
+ workerId,
+ outcome,
+ outcome === "retry"
+ ? { error: safeReason, nextAttemptAt: retryAt(delivery.attempts) }
+ : { error: safeReason },
+ );
+ (outcome === "retry" ? retried : permanentFailures).push(delivery.channel);
+ }
+ }
+ if (permanentFailures.length) {
+ const channels = [...new Set(permanentFailures)].join(", ");
+ const correlationId = `delivery:${createHash("sha256")
+ .update(deliveries.map((delivery) => delivery.idempotencyKey).sort().join("\0"))
+ .digest("hex")}`;
+ await sendFailureAlert({
+ event: "delivery_failed",
+ severity: "critical",
+ detail: `channels=${channels}`,
+ correlationId,
+ });
+ throw new Error(`Delivery failed for: ${channels}`);
+ }
+ return Object.freeze({
+ attempted: deliveries.length,
+ permanentFailures: Object.freeze([...permanentFailures]),
+ retried: Object.freeze([...retried]),
+ succeeded: Object.freeze([...succeeded]),
});
- const json = (await res.json().catch(() => ({}))) as { code?: number; message?: string };
- if (!res.ok || (json.code !== undefined && json.code !== 0)) {
- throw new Error(`Server酱 推送失败：HTTP ${res.status} ${JSON.stringify(json)}`);
+}
+
+export async function processPendingDeliveries(
+ workerId = randomUUID(),
+): Promise {
+ return processClaimedDeliveries(await claimDeliveries(workerId), workerId);
+}
+
+/** Manual recovery path: never claims an unrelated digest's pending delivery. */
+export async function processDigestDeliveries(
+ digestDate: string,
+ workerId = randomUUID(),
+): Promise {
+ return processClaimedDeliveries(
+ await claimDigestDeliveries(digestDate, workerId),
+ workerId,
+ );
+}
+
+/** Enqueue a digest, then make one immediate leased delivery attempt. */
+export async function pushDigest(
+ title: string,
+ md: string,
+ pipelineRunId?: string,
+): Promise {
+ if (pipelineRunId) {
+ await enqueueDigestDeliveries(title, md, currentRuntimeEnvironment(), pipelineRunId);
+ } else {
+ await enqueueDigestDeliveries(title, md);
}
+ return processDigestDeliveries(deliveryDateFromTitle(title));
+}
+
+/** Explicit manual recovery: revive failed rows for configured channels only. */
+export async function replayDigest(
+ title: string,
+ md: string,
+): Promise {
+ const digestDate = deliveryDateFromTitle(title);
+ await enqueueDigestDeliveries(title, md);
+ const requeued = await requeueFailedDigestDeliveries(digestDate);
+ const report = await processDigestDeliveries(digestDate);
+ return Object.freeze({ ...report, requeued });
}
diff --git a/scripts/doctor.ts b/scripts/doctor.ts
new file mode 100644
index 0000000..35337a7
--- /dev/null
+++ b/scripts/doctor.ts
@@ -0,0 +1,121 @@
+import { readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { parseEnvText } from "../lib/env-migration.ts";
+import { runPreflight } from "../lib/preflight.ts";
+import { loadRootConfig } from "../lib/runtime-config.ts";
+
+export interface DoctorCheck {
+ name: string;
+ ok: boolean;
+ detail: string;
+ required: boolean;
+}
+
+export function supportedNodeVersion(version = process.versions.node): boolean {
+ const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+ if (!match) return false;
+ const major = Number(match[1]);
+ const minor = Number(match[2]);
+ return (major > 20 && major < 26) || (major === 20 && minor >= 19);
+}
+
+export function isShanghaiTimeZone(value: string): boolean {
+ try {
+ return new Intl.DateTimeFormat("en-US", { timeZone: value })
+ .resolvedOptions().timeZone === "Asia/Shanghai";
+ } catch {
+ return false;
+ }
+}
+
+async function checkFileMode(path: string): Promise {
+ try {
+ const mode = (await stat(path)).mode & 0o777;
+ return { name: `${path} mode`, ok: (mode & 0o077) === 0, detail: `mode ${mode.toString(8).padStart(3, "0")}`, required: true };
+ } catch {
+ return { name: `${path} mode`, ok: false, detail: "missing", required: true };
+ }
+}
+
+export function isTCCProtectedPath(path: string, home = homedir()): boolean {
+ const candidate = resolve(path);
+ return ["Desktop", "Documents", "Downloads"].some((directory) => {
+ const protectedRoot = resolve(home, directory);
+ return candidate === protectedRoot || candidate.startsWith(`${protectedRoot}/`);
+ });
+}
+
+export async function runDoctor(
+ root = resolve("."),
+ options: Readonly<{ home?: string; timeZone?: string }> = {},
+): Promise {
+ const checks: DoctorCheck[] = [];
+ checks.push({ name: "repository", ok: root.endsWith("frontier-paper-dispatch"), detail: root, required: true });
+ checks.push({
+ name: "macOS protected path",
+ ok: !isTCCProtectedPath(root, options.home),
+ detail: isTCCProtectedPath(root, options.home) ? "move the repository outside Desktop/Documents/Downloads" : "safe location",
+ required: true,
+ });
+ checks.push({ name: "node", ok: supportedNodeVersion(), detail: process.versions.node, required: true });
+ const timeZone = options.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+ checks.push({
+ name: "system time zone",
+ ok: isShanghaiTimeZone(timeZone),
+ detail: isShanghaiTimeZone(timeZone) ? timeZone : `${timeZone}; set macOS time zone to Asia/Shanghai`,
+ required: true,
+ });
+ for (const file of ["package-lock.json", "web/package-lock.json", ".env"]) {
+ try {
+ await stat(join(root, file));
+ checks.push({ name: `${file} exists`, ok: true, detail: "present", required: true });
+ } catch {
+ checks.push({ name: `${file} exists`, ok: false, detail: file === ".env" ? "configure before scheduling" : "missing", required: true });
+ }
+ }
+ const envPath = join(root, ".env");
+ if (checks.some((check) => check.name === ".env exists" && check.ok)) checks.push(await checkFileMode(envPath));
+ for (const plist of [
+ "launchd/com.frontierpapers.deliver.plist",
+ "launchd/com.frontierpapers.ingest.plist",
+ "launchd/com.frontierpapers.refine.plist",
+ ]) {
+ try {
+ const content = await readFile(join(root, plist), "utf8");
+ checks.push({ name: `${plist} template`, ok: content.includes("__PROJECT_DIR__") && content.includes("__NODE_PATH__"), detail: "placeholders present", required: true });
+ } catch {
+ checks.push({ name: `${plist} template`, ok: false, detail: "missing", required: true });
+ }
+ }
+ try {
+ runPreflight({ rootEnvPath: envPath, target: "ingest:send" });
+ checks.push({ name: "ingest:send preflight", ok: true, detail: "configuration valid", required: true });
+ } catch (error) {
+ checks.push({
+ name: "ingest:send preflight",
+ ok: false,
+ detail: error instanceof Error ? error.message : "configuration invalid",
+ required: true,
+ });
+ }
+ try {
+ const environment = parseEnvText(await readFile(envPath, "utf8"));
+ const alert = loadRootConfig("dry", environment).alert;
+ checks.push({
+ name: "independent alert",
+ ok: alert !== undefined,
+ detail: alert ? "configured" : "ALERT_WEBHOOK_URL is missing",
+ required: true,
+ });
+ } catch {
+ checks.push({ name: "independent alert", ok: false, detail: "configuration invalid", required: true });
+ }
+ return checks;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+ const checks = await runDoctor();
+ for (const check of checks) console.log(`${check.ok ? "ok" : "FAIL"} ${check.name}: ${check.detail}`);
+ if (checks.some((check) => check.required && !check.ok)) process.exitCode = 1;
+}
diff --git a/scripts/fetchers/acl.ts b/scripts/fetchers/acl.ts
new file mode 100644
index 0000000..1c0d37a
--- /dev/null
+++ b/scripts/fetchers/acl.ts
@@ -0,0 +1,159 @@
+import { XMLParser, XMLValidator } from "fast-xml-parser";
+import { ACL_SELECTED_VENUES, PER_SOURCE_LIMIT, SOURCE_WEIGHTS } from "../../config/sources.ts";
+import { clean, httpText } from "../../lib/http.ts";
+import { toArray } from "../../lib/normalize.ts";
+import type { NormalizedItem } from "../../lib/types.ts";
+
+export const ACL_ANTHOLOGY_FEED_URL = "https://aclanthology.org/papers/index.xml";
+
+interface AclFeedItem {
+ title?: unknown;
+ link?: unknown;
+ guid?: unknown;
+ pubDate?: unknown;
+ description?: unknown;
+}
+
+export interface AclAnthologyFeed {
+ items: AclFeedItem[];
+}
+
+const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: "@_" });
+const selectedVenues = new Set(ACL_SELECTED_VENUES);
+
+function isRecord(value: unknown): value is Record {
+ return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function text(value: unknown): string {
+ if (typeof value === "object" && value !== null) {
+ return clean((value as Record)["#text"] ?? "");
+ }
+ return clean(value);
+}
+
+export function parseAclAnthologyFeed(xml: string): AclAnthologyFeed {
+ if (XMLValidator.validate(xml) !== true) throw new Error("ACL Anthology feed has invalid XML");
+ let document: unknown;
+ try {
+ document = parser.parse(xml);
+ } catch {
+ throw new Error("ACL Anthology feed XML could not be parsed");
+ }
+ const rss = isRecord(document) ? document.rss : undefined;
+ const channel = isRecord(rss) ? rss.channel : undefined;
+ if (!isRecord(channel) || !Object.hasOwn(channel, "item")) {
+ throw new Error("ACL Anthology feed does not match the RSS schema");
+ }
+ const entries = toArray(channel.item);
+ if (entries.length === 0) throw new Error("ACL Anthology RSS contains no paper entries");
+ if (!entries.every((entry) =>
+ isRecord(entry) &&
+ Object.hasOwn(entry, "title") &&
+ Object.hasOwn(entry, "link") &&
+ Object.hasOwn(entry, "guid") &&
+ Object.hasOwn(entry, "pubDate") &&
+ Object.hasOwn(entry, "description")
+ )) {
+ throw new Error("ACL Anthology entry does not match the paper schema");
+ }
+ const items = entries as AclFeedItem[];
+ return { items };
+}
+
+function paperIdentity(item: AclFeedItem): { id: string; url: string; venue: string } | undefined {
+ const id = text(item.guid);
+ const match = id.match(/^(\d{4})\.([a-z][a-z0-9]*)(?:[-.])[a-z0-9][a-z0-9.-]*$/i);
+ if (!match || id.length > 128) return undefined;
+ const venue = match[2].toLowerCase();
+ if (!selectedVenues.has(venue)) return undefined;
+
+ let url: URL;
+ try {
+ url = new URL(text(item.link));
+ } catch {
+ return undefined;
+ }
+ if (
+ url.protocol !== "https:" ||
+ url.hostname !== "aclanthology.org" ||
+ url.username ||
+ url.password ||
+ (url.port && url.port !== "443") ||
+ url.search ||
+ url.hash ||
+ url.pathname !== `/${id}/`
+ ) {
+ return undefined;
+ }
+ return { id, url: `https://aclanthology.org/${id}/`, venue };
+}
+
+function authors(description: string): string[] {
+ const authorText = description.split(/\s+in\s+(?=Proceedings|Transactions|Computational Linguistics)/i, 1)[0];
+ if (!authorText || authorText === description) return [];
+ return authorText
+ .replace(/\s+and\s+/gi, ", ")
+ .split(/,\s*/)
+ .map(clean)
+ .filter(Boolean)
+ .slice(0, 50);
+}
+
+function fairVenueLimit(items: readonly NormalizedItem[], limit: number): NormalizedItem[] {
+ const buckets = new Map(
+ ACL_SELECTED_VENUES.map((venue) => [venue, [] as NormalizedItem[]]),
+ );
+ for (const item of items) buckets.get(String(item.signals.venue))?.push(item);
+ const result: NormalizedItem[] = [];
+ while (result.length < limit) {
+ let added = false;
+ for (const venue of ACL_SELECTED_VENUES) {
+ const next = buckets.get(venue)?.shift();
+ if (!next) continue;
+ result.push(next);
+ added = true;
+ if (result.length === limit) break;
+ }
+ if (!added) break;
+ }
+ return result;
+}
+
+export function mapAclAnthologyFeed(feed: AclAnthologyFeed): NormalizedItem[] {
+ const seen = new Set();
+ const mapped = feed.items.flatMap((entry) => {
+ const identity = paperIdentity(entry);
+ const title = text(entry.title);
+ const description = text(entry.description).slice(0, 2_048);
+ const timestamp = Date.parse(text(entry.pubDate));
+ if (!identity || !title || !Number.isFinite(timestamp) || seen.has(identity.id)) return [];
+ seen.add(identity.id);
+ return [{
+ source: "acl",
+ externalId: identity.id,
+ url: identity.url,
+ title: title.slice(0, 1_024),
+ authors: authors(description),
+ abstract: description,
+ publishedAt: new Date(timestamp).toISOString(),
+ signals: {
+ sourceWeight: SOURCE_WEIGHTS.acl,
+ venue: identity.venue,
+ publisher: "ACL Anthology",
+ },
+ } satisfies NormalizedItem];
+ });
+ return fairVenueLimit(mapped, PER_SOURCE_LIMIT.acl);
+}
+
+export async function fetchACLAnthology(): Promise {
+ const xml = await httpText(ACL_ANTHOLOGY_FEED_URL, {
+ deadlineMs: 20_000,
+ maxAttempts: 2,
+ maxResponseBytes: 2 * 1024 * 1024,
+ redirect: "error",
+ timeoutMs: 10_000,
+ });
+ return mapAclAnthologyFeed(parseAclAnthologyFeed(xml));
+}
diff --git a/scripts/fetchers/arxiv.ts b/scripts/fetchers/arxiv.ts
index 5db55bd..f8954fc 100644
--- a/scripts/fetchers/arxiv.ts
+++ b/scripts/fetchers/arxiv.ts
@@ -1,53 +1,461 @@
-import { XMLParser } from "fast-xml-parser";
+import { XMLParser, XMLValidator } from "fast-xml-parser";
import { httpText, clean } from "../../lib/http.ts";
import { toArray } from "../../lib/normalize.ts";
import { ARXIV_CATEGORIES, PER_SOURCE_LIMIT, SOURCE_WEIGHTS } from "../../config/sources.ts";
import type { NormalizedItem } from "../../lib/types.ts";
-// 用 arxiv 的 RSS 主机（rss.arxiv.org，当日新投稿）—— 比 export API 更稳更轻。
+// arXiv 官方 RSS 支持用 `+` 合并分类；每轮只请求一次，避免多分类并发打到提供方。
const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: "@_" });
+const combinedFeedUrl = `https://rss.arxiv.org/rss/${ARXIV_CATEGORIES.join("+")}`;
+const categoryByLowercase = new Map(
+ ARXIV_CATEGORIES.map((category) => [category.toLowerCase(), category]),
+);
+const arxivIdPattern = String.raw`(?:\d{4}\.\d{4,5}|[a-z][a-z0-9.-]*\/\d{7})`;
+const exactArxivId = new RegExp(
+ String.raw`^(?:oai:arxiv\.org:|arxiv:)?(${arxivIdPattern})(?:v(\d+))?$`,
+ "i",
+);
+const arxivPath = new RegExp(
+ String.raw`^\/(?:abs|pdf)\/(${arxivIdPattern})(?:v(\d+))?(?:\.pdf)?\/?$`,
+ "i",
+);
-function parseFeed(cat: string, xml: string): NormalizedItem[] {
- const items = toArray(parser.parse(xml)?.rss?.channel?.item);
- return items
- .map((it) => {
- const link = String(it.link ?? "");
- const externalId = link.match(/abs\/(.+?)(?:v\d+)?$/)?.[1] ?? link;
- const abstract = clean(it.description).replace(
- /^arXiv:\S+\s+Announce Type:\s+\S+\s+Abstract:\s*/i,
- "",
- );
- const announce = clean(it["arxiv:announce_type"]); // new | cross | replace
- return {
- source: "arxiv" as const,
- externalId,
- url: link,
- title: clean(it.title),
- authors: clean(it["dc:creator"]).split(/,\s*/).filter(Boolean),
- abstract,
- publishedAt: String(it.pubDate ?? ""),
- signals: { sourceWeight: SOURCE_WEIGHTS.arxiv, category: cat, announce },
- _announce: announce,
- };
- })
- // 只要全新/交叉投稿，跳过 replace（旧文更新）。
- .filter((i) => i.title && i._announce !== "replace")
- .map(({ _announce, ...i }) => i);
+interface ArxivIdentity {
+ externalId: string;
+ version?: number;
}
-export async function fetchArxiv(): Promise {
- const settled = await Promise.allSettled(
- ARXIV_CATEGORIES.map(async (cat) =>
- parseFeed(cat, await httpText(`https://rss.arxiv.org/rss/${cat}`, { timeoutMs: 25_000 })),
- ),
+interface CategorizedItem {
+ categories: string[];
+ item: NormalizedItem;
+}
+
+function isRecord(value: unknown): value is Record {
+ return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function text(value: unknown): string {
+ if (value === null || value === undefined) return "";
+ if (typeof value === "object") {
+ const record = value as Record;
+ return clean(record["#text"] ?? record.name ?? "");
+ }
+ return clean(value);
+}
+
+function normalizeExternalId(value: string): string {
+ return value.includes("/") ? value.toLowerCase() : value;
+}
+
+function identityCandidate(candidate: unknown): ArxivIdentity | undefined {
+ let value = text(candidate);
+ if (!value) return undefined;
+ try {
+ value = decodeURIComponent(value);
+ } catch {
+ // A malformed candidate is checked in its original form and normally rejected.
+ }
+
+ const exact = value.match(exactArxivId);
+ if (exact) {
+ return {
+ externalId: normalizeExternalId(exact[1]),
+ version: exact[2] ? Number(exact[2]) : undefined,
+ };
+ }
+
+ let url: URL;
+ try {
+ url = new URL(value);
+ } catch {
+ return undefined;
+ }
+ if (
+ (url.protocol !== "https:" && url.protocol !== "http:") ||
+ (url.hostname !== "arxiv.org" && !url.hostname.endsWith(".arxiv.org"))
+ ) {
+ return undefined;
+ }
+
+ let pathname = url.pathname;
+ try {
+ pathname = decodeURIComponent(pathname);
+ } catch {
+ return undefined;
+ }
+ const path = pathname.match(arxivPath);
+ if (!path) return undefined;
+ return {
+ externalId: normalizeExternalId(path[1]),
+ version: path[2] ? Number(path[2]) : undefined,
+ };
+}
+
+function canonicalArxivIdentity(...candidates: unknown[]): ArxivIdentity | undefined {
+ const matches = candidates
+ .map(identityCandidate)
+ .filter((identity): identity is ArxivIdentity => identity !== undefined);
+ if (matches.length === 0) return undefined;
+
+ const externalId = matches[0].externalId;
+ if (matches.some((identity) => identity.externalId !== externalId)) return undefined;
+ const versions = matches
+ .map(({ version }) => version)
+ .filter((version): version is number => version !== undefined);
+ return {
+ externalId,
+ version: versions.length > 0 ? Math.max(...versions) : undefined,
+ };
+}
+
+function isCalendarDate(year: number, month: number, day: number): boolean {
+ const leapYear = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+ const daysByMonth = [31, leapYear ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+ return month >= 1 && month <= 12 && day >= 1 && day <= daysByMonth[month - 1];
+}
+
+function isoDate(value: unknown): string | undefined {
+ const raw = text(value);
+ const iso = raw.match(
+ /^(\d{4})-(\d{2})-(\d{2})T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:(?:0\d|1[0-3]):[0-5]\d|14:00))$/,
);
- const all = settled.flatMap((r, i) => {
- if (r.status === "fulfilled") return r.value;
- console.warn(`[arxiv] 跳过 ${ARXIV_CATEGORIES[i]}：${(r.reason as Error)?.message ?? r.reason}`);
- return [];
+ const rfc = raw.match(
+ /^(?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s*)?(\d{1,2})\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{4})\s+(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d\s+(?:UT|GMT|[ECMP][SD]T|[+-](?:(?:0\d|1[0-3])[0-5]\d|1400))$/i,
+ );
+ let year: number;
+ let month: number;
+ let day: number;
+
+ if (iso) {
+ year = Number(iso[1]);
+ month = Number(iso[2]);
+ day = Number(iso[3]);
+ } else if (rfc) {
+ const monthIndex = [
+ "jan",
+ "feb",
+ "mar",
+ "apr",
+ "may",
+ "jun",
+ "jul",
+ "aug",
+ "sep",
+ "oct",
+ "nov",
+ "dec",
+ ].indexOf(rfc[2].toLowerCase());
+ if (monthIndex < 0) return undefined;
+ year = Number(rfc[3]);
+ month = monthIndex + 1;
+ day = Number(rfc[1]);
+ } else {
+ return undefined;
+ }
+
+ if (!isCalendarDate(year, month, day)) return undefined;
+ const timestamp = Date.parse(raw);
+ return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : undefined;
+}
+
+function categories(value: unknown): string[] {
+ return toArray(value)
+ .map((category) =>
+ typeof category === "object" && category !== null
+ ? text(category["@_term"] ?? category)
+ : text(category),
+ )
+ .filter(Boolean);
+}
+
+function configuredCategories(primary: unknown, listed: unknown): string[] {
+ const configured: string[] = [];
+ const seen = new Set();
+ for (const candidate of [text(primary), ...categories(listed)]) {
+ const category = categoryByLowercase.get(candidate.toLowerCase());
+ if (!category || seen.has(category)) continue;
+ seen.add(category);
+ configured.push(category);
+ }
+ return configured;
+}
+
+function announceType(explicit: unknown, description: string): string {
+ return text(explicit) || description.match(/Announce Type:\s*([^\s]+)/i)?.[1] || "";
+}
+
+function rssAuthors(value: unknown): string[] {
+ return text(value).split(/,\s*/).filter(Boolean);
+}
+
+function atomField(record: any, name: string): unknown {
+ return record?.[name] ?? record?.[`atom:${name}`];
+}
+
+function hasAtomField(record: Record, name: string): boolean {
+ return Object.hasOwn(record, name) || Object.hasOwn(record, `atom:${name}`);
+}
+
+function matchesRssItemSchema(value: unknown): boolean {
+ return (
+ isRecord(value) &&
+ Object.hasOwn(value, "title") &&
+ (Object.hasOwn(value, "link") || Object.hasOwn(value, "guid")) &&
+ Object.hasOwn(value, "pubDate") &&
+ Object.hasOwn(value, "category")
+ );
+}
+
+function matchesAtomEntrySchema(value: unknown): boolean {
+ return (
+ isRecord(value) &&
+ hasAtomField(value, "title") &&
+ (hasAtomField(value, "link") || hasAtomField(value, "id")) &&
+ hasAtomField(value, "published") &&
+ (hasAtomField(value, "category") || Object.hasOwn(value, "arxiv:primary_category"))
+ );
+}
+
+function atomAuthors(value: unknown): string[] {
+ return toArray(value)
+ .map((author) => text(atomField(author, "name") ?? author))
+ .filter(Boolean);
+}
+
+function atomLink(entry: any): string {
+ const links = toArray(atomField(entry, "link"));
+ const alternate = links.find((link) => text(link?.["@_rel"]).toLowerCase() === "alternate");
+ return text(alternate?.["@_href"] ?? links[0]?.["@_href"] ?? atomField(entry, "id"));
+}
+
+function normalizeEntry(input: {
+ title: unknown;
+ description: unknown;
+ announce: unknown;
+ publishedAt: unknown;
+ link: unknown;
+ id: unknown;
+ guid?: unknown;
+ primaryCategory?: unknown;
+ listedCategories: unknown;
+ authors: string[];
+}): CategorizedItem | undefined {
+ const title = text(input.title);
+ const rawDescription = text(input.description);
+ const announce = announceType(input.announce, rawDescription);
+ const publishedAt = isoDate(input.publishedAt);
+ const identity = canonicalArxivIdentity(input.link, input.id, input.guid);
+ const configured = configuredCategories(input.primaryCategory, input.listedCategories);
+ const isReplacement = announce.toLowerCase().startsWith("replace");
+ const isUnlabelledRevision = !announce && (identity?.version ?? 1) > 1;
+
+ if (
+ !title ||
+ !publishedAt ||
+ !identity ||
+ configured.length === 0 ||
+ isReplacement ||
+ isUnlabelledRevision
+ ) {
+ return undefined;
+ }
+
+ const abstract = rawDescription.replace(
+ /^arXiv:\S+\s+Announce Type:\s+\S+\s+Abstract:\s*/i,
+ "",
+ );
+ return {
+ categories: configured,
+ item: {
+ source: "arxiv",
+ externalId: identity.externalId,
+ url: `https://arxiv.org/abs/${identity.externalId}`,
+ title,
+ authors: input.authors,
+ abstract,
+ publishedAt,
+ signals: { sourceWeight: SOURCE_WEIGHTS.arxiv, announce },
+ },
+ };
+}
+
+function parseFeed(xml: string): CategorizedItem[] {
+ if (XMLValidator.validate(xml) !== true) {
+ throw new Error("arXiv feed XML is invalid");
+ }
+
+ let parsed: Record;
+ try {
+ const value = parser.parse(xml);
+ if (!isRecord(value)) throw new Error("parsed XML is not an object");
+ parsed = value;
+ } catch {
+ throw new Error("arXiv feed XML could not be parsed");
+ }
+
+ if (Object.hasOwn(parsed, "rss")) {
+ const rss = parsed.rss;
+ if (!isRecord(rss) || !Object.hasOwn(rss, "channel")) {
+ throw new Error("arXiv feed does not match the RSS schema");
+ }
+ const channel = rss.channel;
+ if (channel !== "" && !isRecord(channel)) {
+ throw new Error("arXiv feed does not match the RSS schema");
+ }
+ if (channel === "") return [];
+ const rssItems = toArray(channel.item);
+ if (rssItems.length > 0 && !rssItems.every(matchesRssItemSchema)) {
+ throw new Error("arXiv feed does not match the RSS item schema");
+ }
+ return rssItems
+ .map((item) =>
+ normalizeEntry({
+ title: item.title,
+ description: item.description,
+ announce: item["arxiv:announce_type"],
+ publishedAt: item.pubDate,
+ link: item.link,
+ id: item.guid,
+ guid: item.guid,
+ listedCategories: item.category,
+ authors: rssAuthors(item["dc:creator"]),
+ }),
+ )
+ .filter((item): item is CategorizedItem => item !== undefined);
+ }
+
+ const hasDefaultAtomRoot = Object.hasOwn(parsed, "feed");
+ const hasPrefixedAtomRoot = Object.hasOwn(parsed, "atom:feed");
+ if (hasDefaultAtomRoot || hasPrefixedAtomRoot) {
+ const feed = parsed[hasDefaultAtomRoot ? "feed" : "atom:feed"];
+ if (feed !== "" && !isRecord(feed)) {
+ throw new Error("arXiv feed does not match the Atom schema");
+ }
+ if (feed === "") return [];
+ const atomEntries = toArray(atomField(feed, "entry"));
+ if (atomEntries.length > 0 && !atomEntries.every(matchesAtomEntrySchema)) {
+ throw new Error("arXiv feed does not match the Atom entry schema");
+ }
+ return atomEntries
+ .map((entry) =>
+ normalizeEntry({
+ title: atomField(entry, "title"),
+ description: atomField(entry, "summary"),
+ announce: entry["arxiv:announce_type"],
+ publishedAt: atomField(entry, "published"),
+ link: atomLink(entry),
+ id: atomField(entry, "id"),
+ primaryCategory: entry["arxiv:primary_category"]?.["@_term"],
+ listedCategories: atomField(entry, "category"),
+ authors: atomAuthors(atomField(entry, "author")),
+ }),
+ )
+ .filter((item): item is CategorizedItem => item !== undefined);
+ }
+
+ throw new Error("arXiv feed has an unsupported RSS/Atom root");
+}
+
+function fairLimit(items: CategorizedItem[], limit: number): NormalizedItem[] {
+ const uniqueById = new Map();
+ for (const candidate of items) {
+ const existing = uniqueById.get(candidate.item.externalId);
+ if (!existing) {
+ uniqueById.set(candidate.item.externalId, {
+ categories: [...candidate.categories],
+ item: candidate.item,
+ });
+ continue;
+ }
+ for (const category of candidate.categories) {
+ if (!existing.categories.includes(category)) existing.categories.push(category);
+ }
+ }
+
+ const unique = [...uniqueById.values()];
+ const buckets = new Map(ARXIV_CATEGORIES.map((category) => [category, [] as CategorizedItem[]]));
+ for (const candidate of unique) {
+ for (const category of candidate.categories) buckets.get(category)?.push(candidate);
+ }
+ for (const bucket of buckets.values()) {
+ // Preserve scarce cross-listed entries for categories that have no single-category alternatives.
+ bucket.sort((left, right) => left.categories.length - right.categories.length);
+ }
+
+ const configuredOrder = new Map(ARXIV_CATEGORIES.map((category, index) => [category, index]));
+ const categoryPriority = (category: string): [number, number, number] => {
+ let preference = Number.POSITIVE_INFINITY;
+ let feedPosition = Number.POSITIVE_INFINITY;
+ unique.forEach((candidate, index) => {
+ const candidatePreference = candidate.categories.indexOf(category);
+ if (
+ candidatePreference >= 0 &&
+ (candidatePreference < preference ||
+ (candidatePreference === preference && index < feedPosition))
+ ) {
+ preference = candidatePreference;
+ feedPosition = index;
+ }
+ });
+ return [preference, feedPosition, configuredOrder.get(category) ?? Number.POSITIVE_INFINITY];
+ };
+ const allocationOrder = [...ARXIV_CATEGORIES].sort((left, right) => {
+ const leftPriority = categoryPriority(left);
+ const rightPriority = categoryPriority(right);
+ return (
+ leftPriority[0] - rightPriority[0] ||
+ leftPriority[1] - rightPriority[1] ||
+ leftPriority[2] - rightPriority[2]
+ );
});
+
+ const assignments = new Map();
+ const augment = (
+ category: string,
+ visitedItems: Set,
+ visitedCategories: Set,
+ ): boolean => {
+ if (visitedCategories.has(category)) return false;
+ visitedCategories.add(category);
+
+ for (const candidate of buckets.get(category) ?? []) {
+ const externalId = candidate.item.externalId;
+ const assignedCategory = assignments.get(externalId);
+ if (assignedCategory === category || visitedItems.has(externalId)) continue;
+ visitedItems.add(externalId);
+
+ if (
+ assignedCategory === undefined ||
+ augment(assignedCategory, visitedItems, visitedCategories)
+ ) {
+ assignments.set(externalId, category);
+ return true;
+ }
+ }
+ return false;
+ };
+
+ let progressed = true;
+ while (assignments.size < limit && progressed) {
+ progressed = false;
+ for (const category of allocationOrder) {
+ if (augment(category, new Set(), new Set())) progressed = true;
+ if (assignments.size === limit) break;
+ }
+ }
+
+ return unique.flatMap((candidate) => {
+ const category = assignments.get(candidate.item.externalId);
+ return category
+ ? [{ ...candidate.item, signals: { ...candidate.item.signals, category } }]
+ : [];
+ });
+}
+
+export async function fetchArxiv(): Promise {
+ const all = parseFeed(await httpText(combinedFeedUrl, { timeoutMs: 25_000 }));
if (all.length === 0) {
console.log("[arxiv] feed 无新投稿（arxiv 周末 skipDays，工作日恢复；HF daily papers 已覆盖高分 arxiv 论文）");
}
- return all.slice(0, PER_SOURCE_LIMIT.arxiv);
+ return fairLimit(all, PER_SOURCE_LIMIT.arxiv);
}
diff --git a/scripts/fetchers/blogs.ts b/scripts/fetchers/blogs.ts
index 496a679..c7d69be 100644
--- a/scripts/fetchers/blogs.ts
+++ b/scripts/fetchers/blogs.ts
@@ -1,27 +1,132 @@
-import { XMLParser } from "fast-xml-parser";
-import { httpText, clean } from "../../lib/http.ts";
-import { toArray } from "../../lib/normalize.ts";
-import { BLOG_FEEDS, PER_SOURCE_LIMIT, SOURCE_WEIGHTS } from "../../config/sources.ts";
+import { XMLParser, XMLValidator } from "fast-xml-parser";
+import { httpHTML, httpText, clean } from "../../lib/http.ts";
+import { normalizeWorkUrl, toArray } from "../../lib/normalize.ts";
+import { safeErrorMessage } from "../../lib/safe-error.ts";
+import { BLOG_FEEDS, PER_SOURCE_LIMIT, SOURCE_WEIGHTS, type BlogSource } from "../../config/sources.ts";
import type { NormalizedItem } from "../../lib/types.ts";
const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: "@_" });
+export const BLOG_FEED_REQUEST_BOUNDS = Object.freeze({
+ deadlineMs: 35_000,
+ maxAttempts: 2,
+ maxResponseBytes: 1024 * 1024,
+ redirect: "error" as const,
+ timeoutMs: 15_000,
+});
+
const text = (v: any): string => clean(typeof v === "object" && v ? v["#text"] ?? "" : v);
-async function fetchFeed(publisher: string, url: string): Promise {
- let doc: any;
+export function stripHtml(value: string): string {
+ return clean(value
+ .replace(/]*>[\s\S]*?<\/script>/gi, " ")
+ .replace(/]*>[\s\S]*?<\/style>/gi, " ")
+ .replace(/<[^>]+>/g, " ")
+ .replace(/ /gi, " ")
+ .replace(/&/gi, "&")
+ .replace(/</gi, "<")
+ .replace(/>/gi, ">"));
+}
+
+export function extractPageContent(html: string): { title: string; description: string; body: string } {
+ const title = stripHtml(html.match(/]*>([\s\S]*?)<\/title>/i)?.[1] ?? "");
+ const description = stripHtml(
+ html.match(/]*name=["']description["'][^>]*content=["']([^"']*)["']/i)?.[1] ?? "",
+ );
+ const article = html.match(/<(?:article|main)\b[^>]*>([\s\S]*?)<\/(?:article|main)>/i)?.[1] ?? html;
+ return { title: title.slice(0, 512), description: description.slice(0, 2_048), body: stripHtml(article).slice(0, 4_096) };
+}
+
+export function isTrustedBlogPageURL(value: string, allowedHosts: readonly string[]): boolean {
+ try {
+ const url = new URL(value);
+ if (url.protocol !== "https:" || url.username || url.password || (url.port && url.port !== "443")) return false;
+ const hostname = url.hostname.toLowerCase().replace(/^www\./, "");
+ return allowedHosts.some((allowed) => {
+ const normalized = allowed.toLowerCase().replace(/^www\./, "");
+ return hostname === normalized || hostname.endsWith(`.${normalized}`);
+ });
+ } catch {
+ return false;
+ }
+}
+
+export function isAllowedBlogPageURL(
+ value: string,
+ source: Pick,
+): boolean {
+ if (!isTrustedBlogPageURL(value, source.pageHosts)) return false;
+ const prefixes = source.allowedPathPrefixes ?? ["/"];
try {
- doc = parser.parse(await httpText(url));
+ const pathname = new URL(value).pathname;
+ return prefixes.some((prefix) => prefix.startsWith("/") && pathname.startsWith(prefix));
} catch {
- console.warn(`[blogs] 跳过 ${publisher}（抓取/解析失败）`);
- return [];
+ return false;
}
+}
+
+interface SitemapOptions {
+ allowedPathPrefixes?: readonly string[];
+ pageHosts: readonly string[];
+ publisher: string;
+}
+
+export function mapSitemapItems(document: any, source: SitemapOptions): NormalizedItem[] {
+ return toArray(document?.urlset?.url)
+ .flatMap((entry) => {
+ const url = clean(entry?.loc);
+ const publishedAt = clean(entry?.lastmod);
+ if (!isAllowedBlogPageURL(url, source) || !Number.isFinite(Date.parse(publishedAt))) return [];
+ const parsed = new URL(url);
+ const slug = parsed.pathname.split("/").filter(Boolean).at(-1) ?? parsed.hostname;
+ let title = slug;
+ try { title = decodeURIComponent(slug); } catch { /* keep the bounded URL slug */ }
+ return [{
+ source: "blog",
+ externalId: url,
+ url,
+ title: clean(title.replace(/[-_]+/g, " ")).slice(0, 512),
+ authors: [],
+ abstract: "",
+ publishedAt,
+ signals: { sourceWeight: SOURCE_WEIGHTS.blog, publisher: source.publisher },
+ } satisfies NormalizedItem];
+ })
+ .sort((a, b) => Date.parse(b.publishedAt) - Date.parse(a.publishedAt) || a.url.localeCompare(b.url))
+ .slice(0, PER_SOURCE_LIMIT.blog);
+}
+
+export function parseBlogSourceDocument(xml: string, source: BlogSource): any {
+ if (XMLValidator.validate(xml) !== true) {
+ throw new Error(`${source.publisher} source returned invalid XML`);
+ }
+ let document: any;
+ try {
+ document = parser.parse(xml);
+ } catch {
+ throw new Error(`${source.publisher} source XML could not be parsed`);
+ }
+ const matchesSchema = source.kind === "sitemap"
+ ? document?.urlset && typeof document.urlset === "object"
+ : (document?.rss?.channel && typeof document.rss.channel === "object") ||
+ (document?.feed && typeof document.feed === "object") ||
+ (document?.["atom:feed"] && typeof document["atom:feed"] === "object");
+ if (!matchesSchema) throw new Error(`${source.publisher} source does not match the ${source.kind} schema`);
+ return document;
+}
+
+async function fetchFeed(source: BlogSource): Promise {
+ const xml = await httpText(source.url, {
+ ...BLOG_FEED_REQUEST_BOUNDS,
+ });
+ const doc = parseBlogSourceDocument(xml, source);
+ if (source.kind === "sitemap") return enrichItems(mapSitemapItems(doc, source), source, 4);
const rss = toArray(doc?.rss?.channel?.item);
- const atom = toArray(doc?.feed?.entry);
+ const atom = toArray((doc?.feed ?? doc?.["atom:feed"])?.entry);
const isAtom = rss.length === 0 && atom.length > 0;
const entries = (rss.length ? rss : atom).slice(0, PER_SOURCE_LIMIT.blog);
- return entries
+ const mapped = entries
.map((it) => {
const link = isAtom
? toArray(it.link).find((l) => l?.["@_rel"] !== "self")?.["@_href"] ??
@@ -32,18 +137,65 @@ async function fetchFeed(publisher: string, url: string): Promise i.title);
+ .filter((item) => item.title && isAllowedBlogPageURL(item.url, source));
+ return enrichItems(mapped, source, 2);
+}
+
+export function combineBlogSourceResults(
+ sources: readonly BlogSource[],
+ results: readonly PromiseSettledResult[],
+ logger: Pick = console,
+): NormalizedItem[] {
+ const successful: NormalizedItem[][] = [];
+ const failures: unknown[] = [];
+ results.forEach((result, index) => {
+ if (result.status === "fulfilled") {
+ successful.push(result.value);
+ return;
+ }
+ failures.push(result.reason);
+ logger.warn(
+ `[blogs] ${sources[index]?.publisher ?? "unknown publisher"} 失败：${safeErrorMessage(result.reason)}`,
+ );
+ });
+ if (successful.length === 0) {
+ throw new AggregateError(failures, "all configured blog sources failed");
+ }
+ return successful.flat();
+}
+
+async function enrichItems(items: NormalizedItem[], source: BlogSource, limit: number): Promise {
+ return Promise.all(items.map(async (item, index) => {
+ if (index >= limit || item.abstract.length >= 240 || !isAllowedBlogPageURL(item.url, source)) return item;
+ try {
+ const page = extractPageContent(await httpHTML(item.url, {
+ maxAttempts: 1,
+ maxResponseBytes: 256 * 1024,
+ timeoutMs: 8_000,
+ deadlineMs: 10_000,
+ redirect: "error",
+ }));
+ return {
+ ...item,
+ title: item.title || page.title,
+ abstract: page.description || page.body || item.abstract,
+ content: page.body || undefined,
+ };
+ } catch {
+ return item;
+ }
+ }));
}
export async function fetchBlogs(): Promise {
- const settled = await Promise.allSettled(BLOG_FEEDS.map((f) => fetchFeed(f.publisher, f.url)));
- return settled.flatMap((r) => (r.status === "fulfilled" ? r.value : []));
+ const settled = await Promise.allSettled(BLOG_FEEDS.map(fetchFeed));
+ return combineBlogSourceResults(BLOG_FEEDS, settled);
}
diff --git a/scripts/fetchers/github.ts b/scripts/fetchers/github.ts
index 92b124b..d01f807 100644
--- a/scripts/fetchers/github.ts
+++ b/scripts/fetchers/github.ts
@@ -2,51 +2,167 @@ import { httpJSON, clean } from "../../lib/http.ts";
import { toArray } from "../../lib/normalize.ts";
import { GITHUB_TOPICS, LOOKBACK_DAYS, PER_SOURCE_LIMIT, SOURCE_WEIGHTS } from "../../config/sources.ts";
import type { NormalizedItem } from "../../lib/types.ts";
+import { loadRootConfig } from "../../lib/runtime-config.ts";
+import { currentRuntimeEnvironment } from "../../lib/runtime-env.ts";
+
+interface GitHubSearchResponse {
+ items: any[];
+}
+
+export function validateGitHubSearch(value: unknown): GitHubSearchResponse {
+ if (!value || typeof value !== "object" || !Array.isArray((value as { items?: unknown }).items)) {
+ throw new Error("GitHub search response must contain an items array");
+ }
+ const items = (value as { items: unknown[] }).items;
+ for (const item of items) {
+ if (!item || typeof item !== "object") {
+ throw new Error("GitHub search response contains an invalid repository");
+ }
+ const repository = item as Record;
+ const hasId =
+ (typeof repository.id === "number" && Number.isFinite(repository.id)) ||
+ (typeof repository.id === "string" && repository.id.trim().length > 0);
+ if (
+ !hasId ||
+ typeof repository.full_name !== "string" ||
+ !repository.full_name.trim() ||
+ typeof repository.html_url !== "string" ||
+ !repository.html_url.trim()
+ ) {
+ throw new Error("GitHub search response contains an incomplete repository");
+ }
+ }
+ return value as GitHubSearchResponse;
+}
+
+interface GitHubRelease { published_at?: unknown; tag_name?: unknown; html_url?: unknown }
+
+function validateGitHubRelease(value: unknown): GitHubRelease {
+ if (!value || typeof value !== "object") throw new Error("GitHub release response is invalid");
+ return value as GitHubRelease;
+}
// GitHub search 不接受 qualifier 之间用裸 OR（会 422）—— 因此每个 topic 单独查再合并。
-async function searchTopic(topic: string, since: string, perPage: number): Promise {
- const q = `topic:${topic} pushed:>=${since}`;
+type GitHubSearchMode = "new" | "active";
+
+async function searchTopic(topic: string, since: string, perPage: number, mode: GitHubSearchMode): Promise {
+ const q = `topic:${topic} ${mode === "new" ? "created" : "pushed"}:>=${since}`;
const url =
`https://api.github.com/search/repositories?q=${encodeURIComponent(q)}` +
- `&sort=stars&order=desc&per_page=${perPage}`;
+ `&sort=${mode === "new" ? "stars" : "updated"}&order=desc&per_page=${perPage}`;
const headers: Record = { Accept: "application/vnd.github+json" };
- if (process.env.GITHUB_TOKEN) headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
- const data = await httpJSON<{ items?: any[] }>(url, { headers });
- return toArray(data?.items);
+ const githubToken = loadRootConfig("dry", currentRuntimeEnvironment()).githubToken;
+ if (githubToken) headers.Authorization = `Bearer ${githubToken}`;
+ const data = await httpJSON(url, { headers, validate: validateGitHubSearch });
+ return toArray(data.items);
}
-export async function fetchGitHub(): Promise {
- const since = new Date(Date.now() - LOOKBACK_DAYS * 86_400_000).toISOString().slice(0, 10);
- const perPage = Math.ceil(PER_SOURCE_LIMIT.github / GITHUB_TOPICS.length) + 2;
+export function githubVelocity(repo: { stargazers_count?: unknown; created_at?: unknown; pushed_at?: unknown }, now = Date.now()): number {
+ const stars = Number(repo.stargazers_count ?? 0);
+ const created = Date.parse(String(repo.created_at ?? ""));
+ const ageDays = Number.isFinite(created) ? Math.max(1, (now - created) / 86_400_000) : 3650;
+ return Number.isFinite(stars) && stars >= 0 ? stars / ageDays : 0;
+}
- const settled = await Promise.allSettled(GITHUB_TOPICS.map((t) => searchTopic(t, since, perPage)));
- const byId = new Map();
- settled.forEach((r, i) => {
- if (r.status !== "fulfilled") {
- console.warn(`[github] 跳过 topic:${GITHUB_TOPICS[i]}：${(r.reason as Error)?.message ?? r.reason}`);
+export function orderGitHubCandidates(items: readonly NormalizedItem[]): NormalizedItem[] {
+ return [...items].sort((a, b) =>
+ Number(b.signals.starVelocity) - Number(a.signals.starVelocity) ||
+ Number(b.signals.stars) - Number(a.signals.stars) ||
+ a.externalId.localeCompare(b.externalId),
+ );
+}
+
+export function applyGitHubRelease(item: NormalizedItem, release: GitHubRelease, now = Date.now()): void {
+ const publishedAt = clean(release.published_at);
+ const releaseTime = Date.parse(publishedAt);
+ if (!Number.isFinite(releaseTime) || releaseTime > now + 5 * 60_000) return;
+ const activityTime = Date.parse(item.publishedAt);
+ if (!Number.isFinite(activityTime) || releaseTime > activityTime) item.publishedAt = publishedAt;
+ item.signals = {
+ ...item.signals,
+ release: clean(release.tag_name),
+ releasePublishedAt: publishedAt,
+ releaseUrl: clean(release.html_url),
+ };
+}
+
+export function combineGitHubSearchResults(
+ results: readonly PromiseSettledResult[],
+ topics: readonly string[],
+ logger: Pick = console,
+): any[] {
+ if (!topics.length || results.length !== topics.length * 2) {
+ throw new Error("GitHub search result contract mismatch");
+ }
+ const repositories: any[] = [];
+ const failures: unknown[] = [];
+ results.forEach((result, index) => {
+ if (result.status === "fulfilled") {
+ repositories.push(...result.value);
return;
}
- for (const repo of r.value) {
- const id = String(repo.id);
- if (byId.has(id)) continue;
- byId.set(id, {
- source: "github",
- externalId: id,
- url: String(repo.html_url ?? ""),
- title: clean(repo.full_name),
- authors: [clean(repo.owner?.login)].filter(Boolean),
- abstract: clean(repo.description),
- publishedAt: String(repo.pushed_at ?? repo.created_at ?? ""),
- signals: {
- sourceWeight: SOURCE_WEIGHTS.github,
- stars: Number(repo.stargazers_count ?? 0),
- language: clean(repo.language),
- },
- });
- }
+ failures.push(result.reason);
+ logger.warn(
+ `[github] 跳过 topic:${topics[Math.floor(index / 2)]}：${(result.reason as Error)?.message ?? result.reason}`,
+ );
});
+ if (failures.length === results.length) {
+ throw new AggregateError(failures, "all GitHub repository searches failed");
+ }
+ return repositories;
+}
- return [...byId.values()]
- .sort((a, b) => Number(b.signals.stars) - Number(a.signals.stars))
- .slice(0, PER_SOURCE_LIMIT.github);
+export async function fetchGitHub(): Promise {
+ const now = Date.now();
+ const since = new Date(now - LOOKBACK_DAYS * 86_400_000).toISOString().slice(0, 10);
+ const perPage = Math.ceil(PER_SOURCE_LIMIT.github / GITHUB_TOPICS.length) + 2;
+
+ const settled = await Promise.allSettled(
+ GITHUB_TOPICS.flatMap((topic) => [
+ searchTopic(topic, since, Math.ceil(perPage / 2), "new"),
+ searchTopic(topic, since, Math.ceil(perPage / 2), "active"),
+ ]),
+ );
+ const byId = new Map();
+ for (const repo of combineGitHubSearchResults(settled, GITHUB_TOPICS)) {
+ const id = String(repo.id);
+ if (byId.has(id)) continue;
+ byId.set(id, {
+ source: "github",
+ externalId: id,
+ url: String(repo.html_url ?? ""),
+ title: clean(repo.full_name),
+ authors: [clean(repo.owner?.login)].filter(Boolean),
+ abstract: clean(repo.description),
+ publishedAt: String(repo.pushed_at ?? repo.created_at ?? ""),
+ signals: {
+ sourceWeight: SOURCE_WEIGHTS.github,
+ stars: Number(repo.stargazers_count ?? 0),
+ starVelocity: githubVelocity(repo, now),
+ isNew: Date.parse(String(repo.created_at ?? "")) >= now - LOOKBACK_DAYS * 86_400_000 ? 1 : 0,
+ pushedAt: String(repo.pushed_at ?? ""),
+ language: clean(repo.language),
+ },
+ });
+ }
+
+ const candidates = orderGitHubCandidates([...byId.values()]);
+ const githubToken = loadRootConfig("dry", currentRuntimeEnvironment()).githubToken;
+ const releases = await Promise.allSettled(candidates.slice(0, 10).map(async (item) => {
+ const repo = item.url.match(/github\.com\/([^/]+\/[^/?#]+)/i)?.[1];
+ if (!repo) return undefined;
+ const release = await httpJSON(`https://api.github.com/repos/${repo}/releases/latest`, {
+ headers: { Accept: "application/vnd.github+json", ...(githubToken ? { Authorization: `Bearer ${githubToken}` } : {}) },
+ validate: validateGitHubRelease,
+ maxAttempts: 1,
+ timeoutMs: 8_000,
+ deadlineMs: 10_000,
+ });
+ return { item, release };
+ }));
+ releases.forEach((result) => {
+ if (result.status !== "fulfilled" || !result.value) return;
+ applyGitHubRelease(result.value.item, result.value.release, now);
+ });
+ return orderGitHubCandidates(candidates).slice(0, PER_SOURCE_LIMIT.github);
}
diff --git a/scripts/fetchers/huggingface.ts b/scripts/fetchers/huggingface.ts
index 2eafa2a..e6554ae 100644
--- a/scripts/fetchers/huggingface.ts
+++ b/scripts/fetchers/huggingface.ts
@@ -4,8 +4,35 @@ import { PER_SOURCE_LIMIT, SOURCE_WEIGHTS } from "../../config/sources.ts";
import type { NormalizedItem } from "../../lib/types.ts";
// HF daily papers 是已被社区筛过的当日 arxiv 论文，带 upvotes —— 绝佳排名信号。
+export function validateHuggingFaceDailyPapers(value: unknown): any[] {
+ if (!Array.isArray(value)) throw new Error("Hugging Face daily papers response must be an array");
+ for (const entry of value) {
+ if (!entry || typeof entry !== "object") {
+ throw new Error("Hugging Face daily papers response contains an invalid entry");
+ }
+ const record = entry as Record;
+ const paperValue = Object.hasOwn(record, "paper") ? record.paper : record;
+ if (!paperValue || typeof paperValue !== "object") {
+ throw new Error("Hugging Face daily papers response contains an invalid paper");
+ }
+ const paper = paperValue as Record;
+ const id = paper.id ?? record.id;
+ const title = paper.title ?? record.title;
+ if (
+ !((typeof id === "string" && id.trim()) || (typeof id === "number" && Number.isFinite(id))) ||
+ typeof title !== "string" ||
+ !title.trim()
+ ) {
+ throw new Error("Hugging Face daily papers response contains an incomplete paper");
+ }
+ }
+ return value;
+}
+
export async function fetchHuggingFace(): Promise {
- const data = await httpJSON("https://huggingface.co/api/daily_papers");
+ const data = await httpJSON("https://huggingface.co/api/daily_papers", {
+ validate: validateHuggingFaceDailyPapers,
+ });
return toArray(data)
.slice(0, PER_SOURCE_LIMIT.huggingface)
.map((el) => {
diff --git a/scripts/fetchers/openalex.ts b/scripts/fetchers/openalex.ts
new file mode 100644
index 0000000..cc13128
--- /dev/null
+++ b/scripts/fetchers/openalex.ts
@@ -0,0 +1,163 @@
+import { httpJSON, clean } from "../../lib/http.ts";
+import { LOOKBACK_DAYS, PER_SOURCE_LIMIT, SOURCE_WEIGHTS } from "../../config/sources.ts";
+import type { NormalizedItem } from "../../lib/types.ts";
+import { shanghaiDateKey } from "../../lib/time.ts";
+import { loadRootConfig } from "../../lib/runtime-config.ts";
+import { currentRuntimeEnvironment } from "../../lib/runtime-env.ts";
+
+interface OpenAlexWork { id?: unknown; doi?: unknown; title?: unknown; publication_date?: unknown; authorships?: unknown; cited_by_count?: unknown; primary_location?: { landing_page_url?: unknown } | null; primary_topic?: { display_name?: unknown; field?: { id?: unknown } } | null; abstract_inverted_index?: Record | null; }
+interface OpenAlexResponse { results: OpenAlexWork[]; }
+
+export function validateOpenAlex(value: unknown): OpenAlexResponse {
+ if (!value || typeof value !== "object" || !Array.isArray((value as { results?: unknown }).results)) {
+ throw new Error("OpenAlex response must contain results");
+ }
+ for (const work of (value as { results: unknown[] }).results) {
+ if (!work || typeof work !== "object" || Array.isArray(work)) {
+ throw new Error("OpenAlex response contains an invalid work");
+ }
+ }
+ return value as OpenAlexResponse;
+}
+
+export function openAlexWorksURL(now = new Date(), apiKey?: string): string {
+ const nowMs = now.getTime();
+ if (!Number.isFinite(nowMs)) throw new TypeError("Invalid OpenAlex clock");
+ const from = shanghaiDateKey(new Date(nowMs - LOOKBACK_DAYS * 86_400_000));
+ const to = shanghaiDateKey(now);
+ const url = new URL("https://api.openalex.org/works");
+ url.searchParams.set("filter", `from_publication_date:${from},to_publication_date:${to},primary_topic.subfield.id:1702`);
+ url.searchParams.set("sort", "publication_date:desc");
+ url.searchParams.set("per_page", String(PER_SOURCE_LIMIT.openalex));
+ if (apiKey) url.searchParams.set("api_key", apiKey);
+ url.searchParams.set(
+ "select",
+ "id,doi,title,publication_date,authorships,cited_by_count,primary_location,primary_topic,abstract_inverted_index",
+ );
+ return url.toString();
+}
+
+function abstract(work: OpenAlexWork): string {
+ const index = work.abstract_inverted_index;
+ if (!index) return "";
+ return Object.entries(index)
+ .flatMap(([word, positions]) => Array.isArray(positions)
+ ? positions
+ .filter((position) => Number.isInteger(position) && position >= 0)
+ .map((position) => [position, clean(word).slice(0, 256)] as const)
+ : [])
+ .sort((a, b) => a[0] - b[0])
+ .map(([, word]) => word)
+ .join(" ")
+ .slice(0, 16_384);
+}
+
+function canonicalOpenAlexURL(value: unknown): string {
+ let url: URL;
+ try {
+ url = new URL(clean(value));
+ } catch {
+ return "";
+ }
+ const match = url.pathname.match(/^\/W(\d+)$/i);
+ if (
+ !match ||
+ url.protocol !== "https:" ||
+ url.hostname !== "openalex.org" ||
+ url.username ||
+ url.password ||
+ (url.port && url.port !== "443") ||
+ url.search ||
+ url.hash
+ ) return "";
+ return `https://openalex.org/W${match[1]}`;
+}
+
+function canonicalDoiURL(value: unknown): string {
+ let url: URL;
+ try {
+ url = new URL(clean(value));
+ } catch {
+ return "";
+ }
+ const doi = url.pathname.slice(1);
+ if (
+ url.protocol !== "https:" ||
+ url.hostname !== "doi.org" ||
+ url.username ||
+ url.password ||
+ (url.port && url.port !== "443") ||
+ url.search ||
+ url.hash ||
+ doi.length > 512 ||
+ !/^10\.\d{4,9}\/.+$/i.test(doi)
+ ) return "";
+ return `https://doi.org/${doi}`;
+}
+
+function safeLandingPageURL(value: unknown): string {
+ let url: URL;
+ try {
+ url = new URL(clean(value));
+ } catch {
+ return "";
+ }
+ if (
+ url.protocol !== "https:" ||
+ url.username ||
+ url.password ||
+ (url.port && url.port !== "443") ||
+ url.toString().length > 2_048
+ ) return "";
+ url.hash = "";
+ return url.toString();
+}
+
+export function mapOpenAlexWorks(response: OpenAlexResponse, now = new Date()): NormalizedItem[] {
+ const from = shanghaiDateKey(new Date(now.getTime() - LOOKBACK_DAYS * 86_400_000));
+ const to = shanghaiDateKey(now);
+ return response.results.flatMap((work) => {
+ const doiURL = canonicalDoiURL(work.doi);
+ const openAlexURL = canonicalOpenAlexURL(work.id);
+ const id = doiURL || openAlexURL;
+ const title = clean(work.title).slice(0, 1_024);
+ const publishedAt = clean(work.publication_date);
+ if (!id || !title || !/^\d{4}-\d{2}-\d{2}$/.test(publishedAt) || publishedAt < from || publishedAt > to) return [];
+ const authors = Array.isArray(work.authorships)
+ ? work.authorships
+ .flatMap((entry) => typeof entry === "object" && entry && "author" in entry && typeof entry.author === "object" && entry.author && "display_name" in entry.author ? [clean((entry.author as { display_name?: unknown }).display_name).slice(0, 256)] : [])
+ .filter(Boolean)
+ .slice(0, 50)
+ : [];
+ const rawCitations = Number(work.cited_by_count ?? 0);
+ return [{
+ source: "openalex",
+ externalId: id,
+ url: doiURL || safeLandingPageURL(work.primary_location?.landing_page_url) || openAlexURL,
+ title,
+ authors,
+ abstract: abstract(work),
+ publishedAt: `${publishedAt}T00:00:00.000Z`,
+ signals: {
+ sourceWeight: SOURCE_WEIGHTS.openalex,
+ citations: Number.isFinite(rawCitations) && rawCitations >= 0 ? rawCitations : 0,
+ category: clean(work.primary_topic?.display_name).slice(0, 256),
+ },
+ } satisfies NormalizedItem];
+ }).slice(0, PER_SOURCE_LIMIT.openalex);
+}
+
+export async function fetchOpenAlex(): Promise {
+ const now = new Date();
+ const apiKey = loadRootConfig("dry", currentRuntimeEnvironment()).openAlexApiKey;
+ const response = await httpJSON(openAlexWorksURL(now, apiKey), {
+ validate: validateOpenAlex,
+ headers: { "User-Agent": "frontier-paper-dispatch/0.1 (+https://github.com/Looperswag/frontier-paper-dispatch)" },
+ deadlineMs: 20_000,
+ maxAttempts: 2,
+ maxResponseBytes: 4 * 1024 * 1024,
+ redirect: "error",
+ timeoutMs: 10_000,
+ });
+ return mapOpenAlexWorks(response, now);
+}
diff --git a/scripts/fetchers/openreview.ts b/scripts/fetchers/openreview.ts
new file mode 100644
index 0000000..d46be62
--- /dev/null
+++ b/scripts/fetchers/openreview.ts
@@ -0,0 +1,12 @@
+import type { NormalizedItem } from "../../lib/types.ts";
+
+export const OPENREVIEW_DISABLED_REASON =
+ "OpenReview source disabled: authenticated, venue-scoped submission access and a documented quota are required";
+
+/**
+ * Fail closed if this adapter is called accidentally. Anonymous `/notes` access currently
+ * returns a bot challenge and an all-notes query cannot distinguish submissions safely.
+ */
+export async function fetchOpenReview(): Promise {
+ throw new Error(OPENREVIEW_DISABLED_REASON);
+}
diff --git a/scripts/fetchers/x.ts b/scripts/fetchers/x.ts
deleted file mode 100644
index 6825ac3..0000000
--- a/scripts/fetchers/x.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import type { NormalizedItem } from "../../lib/types.ts";
-
-// X / Twitter 源（best-effort）。
-//
-// 现状：agent-reach 已装，但 twitter 后端未启用（无 active backend）。启用步骤：
-// 1. pipx install twitter-cli （或 uv tool install twitter-cli）
-// 2. 用 `agent-reach setup` / `agent-reach configure` 登录授权
-// 3. 在本函数里 shell out 调 `twitter-cli`（命令/输出格式以其 --help 为准）解析为 NormalizedItem
-//
-// 注意：agent-reach 本身是安装/编排器（命令仅 setup/install/configure/doctor/format…），
-// 没有 `agent-reach twitter search` 子命令；真正抓取走底层的 twitter-cli。
-// 未启用前静默返回空，不阻塞 arxiv/HF/github/blog 四个高质量源。
-export async function fetchX(): Promise {
- return [];
-}
diff --git a/scripts/ingest-runner.ts b/scripts/ingest-runner.ts
new file mode 100644
index 0000000..2cd23da
--- /dev/null
+++ b/scripts/ingest-runner.ts
@@ -0,0 +1,367 @@
+import { randomUUID } from "node:crypto";
+import { lockShanghaiRunTime } from "../lib/time.ts";
+import { sendFailureAlert } from "../lib/alert.ts";
+import { filterFreshItems } from "../lib/source-freshness.ts";
+import type { NormalizedItem, RankedItem, SummarizedItem } from "../lib/types.ts";
+import { safeErrorMessage } from "../lib/safe-error.ts";
+import type { PipelineRunState, PipelineStatus, SourceRunStatus } from "../lib/pipeline-run.ts";
+import { hasBoundedSourceIdentity } from "../lib/normalize.ts";
+import type { DeliveryAttemptReport } from "./digest.ts";
+
+export class IncompleteCandidatePoolError extends Error {
+ constructor(candidateCount: number, minimum: number) {
+ super(`Fresh candidate pool is incomplete (${candidateCount}/${minimum})`);
+ this.name = "IncompleteCandidatePoolError";
+ }
+}
+
+export interface FeedbackRecord {
+ category: string;
+ note: string | null;
+ rating: string;
+ source: string;
+ title: string;
+}
+
+export interface IngestDependencies {
+ clock: () => Date;
+ /** Wall-clock observations for source latency; separate from a catch-up run's logical date. */
+ observedClock?: () => Date;
+ dedupe: (items: NormalizedItem[]) => NormalizedItem[];
+ feedbackSummary: (feedback: FeedbackRecord[]) => string;
+ fetchFeedback: () => Promise;
+ fetchers: readonly (readonly [name: string, fetch: () => Promise])[];
+ logger: Pick;
+ pushDigest: (
+ title: string,
+ markdown: string,
+ pipelineRunId?: string,
+ ) => Promise;
+ rankTop: (items: NormalizedItem[], count: number, feedback: string) => Promise;
+ renderDigest: (
+ date: string,
+ items: SummarizedItem[],
+ idByKey: Map,
+ ) => string;
+ saveDigest: (
+ date: string,
+ items: SummarizedItem[],
+ idByKey: Map,
+ markdown: string,
+ pipelineRunId?: string,
+ ) => Promise;
+ summarizeAll: (
+ items: RankedItem[],
+ idByKey?: ReadonlyMap,
+ ) => Promise;
+ upsertItems: (
+ items: NormalizedItem[],
+ pipelineOwner?: { runDate: string; runId: string },
+ ) => Promise