feedkeeper 0.0.0-stage → 0.23.0

package/server/dist/pushOutbox.js

@@ -0,0 +1,164 @@
+import { AsyncResource } from "node:async_hooks";
+import { db } from "./db/index.js";
+import { hasUserCapability } from "./auth/capabilities.js";
+import { newItemsPushPayload, sendPushTarget } from "./push.js";
+import { parseRetryAfter } from "./feeds/fetcher.js";
+// Initialized during startup, so background work never retains an HTTP capability cache.
+const context = new AsyncResource("FeedKeeperPushOutbox");
+/** Call inside the article/job-completion transaction. No network or recipient-sized array. */
+export function enqueueNewItemNotifications(feedId, newItems) {
+    if (!newItems)
+        return;
+    const ceiling = db.prepare("SELECT MAX(id) id FROM subscriptions WHERE feed_id = ? AND notify = 1").get(feedId).id;
+    if (ceiling === null)
+        return;
+    const maxItem = db.prepare("SELECT MAX(id) id FROM items WHERE feed_id = ?").get(feedId).id;
+    db.prepare(`INSERT INTO push_outbox(feed_id,max_item_id,item_count,subscription_ceiling,available_at,created_at)
+    VALUES (?,?,?,?,?,?)`).run(feedId, maxItem, Math.min(newItems, 10), ceiling, Date.now(), Date.now());
+}
+/** Exactly one worker per process. SQLite holds fanout and progress, not suspended tasks.
+ * A delivery accepted immediately before a crash can repeat (at-least-once); stable notification
+ * tags replace it in the browser. Unstarted recipients survive shutdown and feed deadlines.
+ */
+export class PushOutbox {
+    stopped = false;
+    scheduled = false;
+    active;
+    timer;
+    counters = { delivered: 0, errors: 0, retries: 0, dropped: 0 };
+    start() {
+        if (this.stopped || this.timer)
+            return;
+        context.runInAsyncScope(() => {
+            this.timer = setInterval(() => this.kick(), 1000);
+            this.timer.unref();
+        });
+        this.kick();
+    }
+    kick() {
+        if (this.stopped || this.scheduled || this.active)
+            return;
+        this.scheduled = true;
+        context.runInAsyncScope(() => setImmediate(() => {
+            this.scheduled = false;
+            if (this.stopped)
+                return;
+            this.active = this.step().catch(() => {
+                // A failed progress write must not immediately repeat a delivery forever.
+                this.stopped = true;
+                if (this.timer)
+                    clearInterval(this.timer);
+                console.error(JSON.stringify({ event: "push_outbox_error", code: "storage_or_eligibility_failure" }));
+            }).finally(() => { this.active = undefined; });
+            void this.active.then(() => {
+                if (!this.stopped && this.nextEvent())
+                    this.kick();
+            }).catch(() => {
+                this.stopped = true;
+                if (this.timer)
+                    clearInterval(this.timer);
+                console.error(JSON.stringify({ event: "push_outbox_error", code: "queue_storage_failure" }));
+            });
+        }));
+    }
+    advanceSubscription(event, subscriptionId) {
+        db.prepare(`UPDATE push_outbox SET subscription_cursor = ?, current_subscription = 0,
+      device_cursor = 0, device_ceiling = 0, target_device = 0, attempts = 0, available_at = ? WHERE id = ?`)
+            .run(subscriptionId, Date.now(), event.id);
+    }
+    nextEvent() {
+        return db.prepare(`SELECT p.* FROM push_outbox p WHERE available_at <= ?
+      AND NOT EXISTS (SELECT 1 FROM push_outbox earlier WHERE earlier.feed_id = p.feed_id AND earlier.id < p.id)
+      ORDER BY available_at, id LIMIT 1`).get(Date.now());
+    }
+    async step() {
+        const event = this.nextEvent();
+        if (!event)
+            return;
+        const subscription = db.prepare(`
+      SELECT id,user_id,NULLIF(TRIM(label),'') label FROM subscriptions
+      WHERE feed_id = ? AND id > ? AND id <= ? AND notify = 1 ORDER BY id LIMIT 1`)
+            .get(event.feed_id, event.subscription_cursor, event.subscription_ceiling);
+        if (!subscription) {
+            db.prepare("DELETE FROM push_outbox WHERE id = ?").run(event.id);
+            return;
+        }
+        // Revocation/unsubscribe/opt-out while waiting always takes effect before another delivery.
+        if (!hasUserCapability(subscription.user_id, "sync")) {
+            this.advanceSubscription(event, subscription.id);
+            return;
+        }
+        if (subscription.id !== event.current_subscription) {
+            event.device_cursor = 0;
+            event.attempts = 0;
+            event.device_ceiling = db.prepare("SELECT COALESCE(MAX(id),0) id FROM push_devices WHERE user_id = ?").get(subscription.user_id).id;
+            db.prepare(`UPDATE push_outbox SET current_subscription = ?, device_cursor = 0, device_ceiling = ?, target_device = 0, attempts = 0 WHERE id = ?`)
+                .run(subscription.id, event.device_ceiling, event.id);
+        }
+        const device = db.prepare(`
+      SELECT id,endpoint,p256dh,auth FROM push_devices WHERE user_id = ? AND id > ? AND id <= ? ORDER BY id LIMIT 1`)
+            .get(subscription.user_id, event.device_cursor, event.device_ceiling);
+        if (!device) {
+            this.advanceSubscription(event, subscription.id);
+            return;
+        }
+        // A removed/reassigned retry target must not consume the next device's retry budget.
+        if (device.id !== event.target_device) {
+            event.attempts = 0;
+            db.prepare("UPDATE push_outbox SET target_device = ?, attempts = 0 WHERE id = ?").run(device.id, event.id);
+        }
+        const feed = db.prepare("SELECT id,title,url FROM feeds WHERE id = ?").get(event.feed_id);
+        if (!feed)
+            return; // Feed deletion cascades the event.
+        const latest = db.prepare(`
+      SELECT id,title,content_snippet FROM items WHERE feed_id = ? AND id <= ? ORDER BY id DESC LIMIT ?`)
+            .all(event.feed_id, event.max_item_id, event.item_count);
+        const payload = newItemsPushPayload(feed, subscription.user_id, subscription.label, latest);
+        if (!payload) {
+            this.advanceSubscription(event, subscription.id);
+            return;
+        }
+        try {
+            await sendPushTarget({ endpoint: device.endpoint, keys: { p256dh: device.p256dh, auth: device.auth } }, payload);
+            this.counters.delivered++;
+        }
+        catch (error) {
+            this.counters.errors++;
+            const status = error.statusCode;
+            if (status === 404 || status === 410) {
+                // Do not remove a device if its ownership changed during I/O.
+                db.prepare("DELETE FROM push_devices WHERE id = ? AND user_id = ?").run(device.id, subscription.user_id);
+            }
+            else if ((status === undefined || [408, 425, 429, 500, 502, 503, 504].includes(status)) && event.attempts < 2) {
+                const headers = error.headers;
+                const retryAt = [429, 503].includes(status ?? 0) ? parseRetryAfter(headers?.["retry-after"] ?? null) ?? 0 : 0;
+                const delay = Math.ceil(1000 * 2 ** event.attempts * (0.5 + Math.random() * 0.5));
+                db.prepare("UPDATE push_outbox SET attempts = attempts + 1, available_at = ? WHERE id = ?")
+                    .run(Math.max(Date.now() + delay, retryAt), event.id);
+                this.counters.retries++;
+                return;
+            }
+            else
+                this.counters.dropped++;
+        }
+        // Advance only after an attempted delivery. Round-robin events between device attempts.
+        db.prepare("UPDATE push_outbox SET device_cursor = ?, target_device = 0, attempts = 0, available_at = ? WHERE id = ?")
+            .run(device.id, Date.now(), event.id);
+    }
+    metrics() {
+        const row = db.prepare("SELECT COUNT(*) pending, COALESCE(MAX(? - created_at),0) oldestMs FROM push_outbox").get(Date.now());
+        return { ...row, running: this.active ? 1 : 0, ...this.counters };
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearInterval(this.timer);
+        // Finish at most the one device already in flight (absolute network deadline: 10 seconds).
+        await this.active;
+    }
+}
+let outbox;
+export function startPushOutbox() { outbox ??= new PushOutbox(); outbox.start(); outbox.kick(); }
+export function pushOutboxMetrics() { return outbox?.metrics() ?? { pending: 0, running: 0 }; }
+export async function stopPushOutbox() { await outbox?.stop(); }
+//# sourceMappingURL=pushOutbox.js.map

package/server/dist/security-recover-cli.js

@@ -0,0 +1,29 @@
+import { runMigrations, db } from "./db/index.js";
+import { findUserByEmail } from "./auth/users.js";
+import { revokeSecuritySessions, securityAccount } from "./auth/security.js";
+const args = process.argv.slice(2);
+const emailIndex = args.indexOf("--email");
+const email = emailIndex >= 0 ? args[emailIndex + 1] : undefined;
+if (!email || !args.includes("--confirm")) {
+    console.error("Usage: npm run security:recover -- --email reader@example.com --confirm\nDisables the authenticator and recovery codes for this account and revokes all sessions, tokens and pending sign-ins. Password and passkeys stay unchanged. Requires local database access.");
+    process.exitCode = 1;
+}
+else {
+    runMigrations();
+    const user = findUserByEmail(email);
+    if (!user) {
+        console.error("Account not found.");
+        process.exitCode = 1;
+    }
+    else {
+        db.transaction(() => {
+            securityAccount(user.id);
+            db.prepare("UPDATE account_security SET totp_secret = NULL, totp_last_step = -1 WHERE user_id = ?").run(user.id);
+            db.prepare("DELETE FROM recovery_codes WHERE user_id = ?").run(user.id);
+            revokeSecuritySessions(user.id);
+        })();
+        console.log("Authenticator removed. The account must sign in again. Set up a new authenticator and save new recovery codes.");
+    }
+}
+db.close();
+//# sourceMappingURL=security-recover-cli.js.map

package/server/dist/server.js

@@ -0,0 +1,108 @@
+import { dirname, join, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import express from "express";
+import helmet from "helmet";
+import cors from "cors";
+import cookieSession from "cookie-session";
+import rateLimit from "express-rate-limit";
+import { config } from "./config.js";
+import { clientAddressFromHeader } from "./clientAddress.js";
+import { runMigrations } from "./db/index.js";
+import { apiRouter } from "./api/index.js";
+import { mcpRouter } from "./mcp/http.js";
+import { oauthAuthorizeRouter, oauthPublicRouter } from "./oauth/routes.js";
+import { startFullTextScheduler } from "./feeds/fullTextQueue.js";
+import { installPollingShutdown, startPollingScheduler } from "./feeds/poller.js";
+import { startCleanupScheduler } from "./feeds/cleanup.js";
+import { repairEncodedText } from "./feeds/repository.js";
+import { pruneArchive, scheduleMissingArchives } from "./feeds/archive.js";
+import { startEditionScheduler } from "./native/editions.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const WEB_DIST = join(__dirname, "../../web/dist");
+runMigrations();
+const repairedItems = repairEncodedText();
+if (repairedItems > 0)
+    console.log(`[db] decoded HTML entities in ${repairedItems} stored items`);
+pruneArchive();
+const pendingArchives = scheduleMissingArchives();
+if (pendingArchives > 0)
+    console.log(`[archive] archiving ${pendingArchives} saved articles in the background`);
+startPollingScheduler();
+startFullTextScheduler();
+startCleanupScheduler();
+startEditionScheduler();
+const app = express();
+// Express validates the addresses here, so a mistyped TRUST_PROXY list stops the server at startup.
+if (config.trustProxy !== false) {
+    app.set("trust proxy", config.trustProxy);
+}
+if (config.clientIpHeader && !Array.isArray(config.trustProxy)) {
+    console.warn("[config] CLIENT_IP_HEADER is ignored: it needs TRUST_PROXY to list the trusted proxies");
+}
+// Before every rate limiter, so limits count the CDN's client rather than its edge.
+app.use(clientAddressFromHeader(config.clientIpHeader, config.trustProxy));
+app.use(helmet({
+    contentSecurityPolicy: {
+        directives: {
+            ...helmet.contentSecurityPolicy.getDefaultDirectives(),
+            "script-src": ["'self'"],
+            "img-src": ["'self'", "data:", "https:", "http:"],
+        },
+    },
+}));
+// Send X-Robots-Tag to ensure all HTTP endpoints disallow indexing even outside HTML
+app.use((_req, res, next) => {
+    res.setHeader("X-Robots-Tag", "noindex, nofollow");
+    next();
+});
+// Connector backends and browser tools call these without our cookies, so they sit before the same-origin CORS rule.
+app.use(oauthPublicRouter);
+app.use(cors({
+    origin: config.publicUrl,
+    credentials: true,
+}));
+app.use(express.json({ limit: "1mb" }));
+app.use(express.text({ type: ["application/xml", "text/xml", "text/plain"], limit: "5mb" }));
+app.use(cookieSession({
+    name: "feedkeeper.sid",
+    secret: config.sessionSecret,
+    maxAge: 30 * 24 * 60 * 60 * 1000,
+    httpOnly: true,
+    sameSite: "lax",
+    secure: config.publicUrl.startsWith("https://"),
+}));
+// Generic API rate limit as defense in depth on top of the stricter
+// per-route limiter on /api/auth/login.
+app.use("/api", rateLimit({
+    windowMs: 60 * 1000,
+    limit: 120,
+    standardHeaders: true,
+    legacyHeaders: false,
+    // Lists load many article images and feed icons at once; those routes have their own, higher limit.
+    skip: (req) => /^\/(v1\/)?(items\/\d+\/image|feeds\/\d+\/icon|subscriptions\/\d+\/icon|archive\/images\/\d+)$/.test(req.path),
+}));
+app.use("/api", apiRouter);
+app.use(oauthAuthorizeRouter);
+app.use("/mcp", mcpRouter);
+if (existsSync(WEB_DIST)) {
+    app.use(express.static(WEB_DIST, {
+        setHeaders(res, filePath) {
+            // Hashed build files never change; the service worker must always be re-checked.
+            if (filePath.includes(`${sep}assets${sep}`))
+                res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+            if (filePath.endsWith(`${sep}sw.js`))
+                res.setHeader("Cache-Control", "no-cache");
+        },
+    }));
+    app.get(/(.*)/, (req, res, next) => {
+        if (req.path.startsWith("/api") || req.path.startsWith("/mcp") || req.path.startsWith("/oauth") || req.path.startsWith("/.well-known"))
+            return next();
+        res.sendFile(join(WEB_DIST, "index.html"));
+    });
+}
+const server = app.listen(config.port, () => {
+    console.log(`[feedkeeper] listening on port ${config.port}`);
+});
+installPollingShutdown(server);
+//# sourceMappingURL=server.js.map

package/server/dist/setup-cli.js

@@ -0,0 +1,97 @@
+import { stdin, stdout } from "node:process";
+import { runMigrations, hasAnyUser } from "./db/index.js";
+import { createUser } from "./auth/users.js";
+// Alternative to the in-browser onboarding screen: creates the first admin
+// user from the terminal, e.g. right after deploying on a fresh server.
+//
+// A single persistent stdin listener maintains the current line and echoes
+// it (masked for the password prompt), one character at a time. This avoids
+// the classic bug of mixing readline.question() with ad-hoc raw-mode reads,
+// where switching prompts mid-stream can drop already-buffered input.
+const isTty = stdin.isTTY === true;
+let line = "";
+let masked = false;
+const pendingLines = [];
+let lineReady = null;
+if (isTty)
+    stdin.setRawMode?.(true);
+stdin.resume();
+stdin.setEncoding("utf8");
+stdin.on("data", (chunk) => {
+    for (const char of chunk) {
+        if (char === "") {
+            stdout.write("\n");
+            process.exit(1);
+        }
+        if (char === "\n" || char === "\r") {
+            const value = line;
+            line = "";
+            stdout.write("\n");
+            if (lineReady) {
+                const resolve = lineReady;
+                lineReady = null;
+                resolve(value);
+            }
+            else {
+                // Answer arrived before the next prompt started asking for it
+                // (e.g. buffered/piped input) — queue it instead of dropping it.
+                pendingLines.push(value);
+            }
+            continue;
+        }
+        if (char === "" || char === "\b") {
+            if (line.length > 0) {
+                line = line.slice(0, -1);
+                stdout.write("\b \b");
+            }
+            continue;
+        }
+        line += char;
+        if (masked)
+            stdout.write("*");
+        else if (!isTty)
+            stdout.write(char); // piped input isn't echoed by the terminal itself
+    }
+});
+function readLine(question, opts = {}) {
+    stdout.write(question);
+    masked = Boolean(opts.mask);
+    const queued = pendingLines.shift();
+    if (queued !== undefined) {
+        stdout.write(`${queued}\n`);
+        return Promise.resolve(queued.trim());
+    }
+    return new Promise((resolve) => {
+        lineReady = (value) => resolve(value.trim());
+    });
+}
+async function main() {
+    runMigrations();
+    if (hasAnyUser()) {
+        console.log("An admin user already exists. Use the web UI to manage additional accounts.");
+        process.exit(0);
+    }
+    console.log("FeedKeeper setup — create the first admin account.\n");
+    const email = await readLine("Admin email: ");
+    const displayName = await readLine("Display name: ");
+    let password = "";
+    while (password.length < 10) {
+        password = await readLine("Password (min. 10 characters): ", { mask: true });
+        if (password.length < 10)
+            console.log("Password too short, try again.");
+    }
+    const user = createUser({ email, password, displayName, role: "admin" });
+    console.log(`\nAdmin account "${user.email}" created. You can now log in at your FeedKeeper URL.`);
+    process.exit(0);
+}
+main()
+    .catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+})
+    .finally(() => {
+    if (isTty)
+        stdin.setRawMode?.(false);
+    stdin.pause();
+});
+//# sourceMappingURL=setup-cli.js.map

package/server/dist/sync/changeLog.js

@@ -0,0 +1,170 @@
+import { contentMetadata } from "../feeds/articleContent.js";
+import { canAccessItem, findItemById } from "../feeds/repository.js";
+import { db } from "../db/index.js";
+import { findItemNote, listFoldersForUser, listMutedKeywords, listSubscriptionsForUser, } from "../feeds/repository.js";
+import { getEditionState } from "../native/editions.js";
+import { getNativePreferences } from "../native/preferences.js";
+const TOMBSTONE_DAYS = 90;
+const MAX_PAGE = 500;
+export function serializeSubscription(subscription) {
+    return {
+        id: subscription.id,
+        url: subscription.url,
+        title: subscription.title,
+        siteUrl: subscription.site_url,
+        label: subscription.label,
+        folderId: subscription.folder_id,
+        position: subscription.position,
+        pollIntervalMinutes: subscription.poll_interval_minutes,
+        fullTextMode: subscription.full_text_mode,
+        notify: Boolean(subscription.notify),
+        badge: Boolean(subscription.badge),
+        isInbox: Boolean(subscription.is_system_inbox),
+        iconHash: subscription.icon_hash ?? null,
+        iconUrl: subscription.icon_hash
+            ? `/api/v1/subscriptions/${subscription.id}/icon?v=${subscription.icon_hash}`
+            : `/api/v1/subscriptions/${subscription.id}/icon`,
+    };
+}
+function itemState(userId, itemId) {
+    const exists = db.prepare("SELECT 1 FROM items WHERE id = ?").get(itemId);
+    if (!exists)
+        return null;
+    const row = db
+        .prepare(`SELECT EXISTS (SELECT 1 FROM item_reads WHERE user_id = ? AND item_id = ?) AS read,
+              (SELECT created_at FROM item_bookmarks WHERE user_id = ? AND item_id = ?) AS saved_at,
+              (SELECT position FROM item_progress WHERE user_id = ? AND item_id = ?) AS progress`)
+        .get(userId, itemId, userId, itemId, userId, itemId);
+    return {
+        read: Boolean(row.read),
+        saved: row.saved_at !== null,
+        savedAt: row.saved_at,
+        progress: row.progress,
+    };
+}
+/**
+ * Add the data a user already had before the log existed. Everything that is in the log
+ * keeps its place; the rest is appended, so a first sync with since=0 delivers the full state.
+ */
+export function ensureChangeLog(userId) {
+    if (db.prepare("SELECT 1 FROM sync_state WHERE user_id = ?").get(userId))
+        return;
+    db.transaction(() => {
+        db.prepare("INSERT OR IGNORE INTO sync_state (user_id) VALUES (?)").run(userId);
+        let seq = db.prepare("SELECT COALESCE(MAX(seq), 0) AS seq FROM changes WHERE user_id = ?").get(userId).seq;
+        const add = db.prepare(`INSERT OR IGNORE INTO changes (user_id, entity, entity_id, op, seq, changed_at) VALUES (?, ?, ?, 'upsert', ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`);
+        const addAll = (entity, ids) => ids.forEach((id) => { if (add.run(userId, entity, id, seq + 1).changes)
+            seq++; });
+        addAll("subscription", listSubscriptionsForUser(userId).map((subscription) => subscription.id));
+        addAll("folder", listFoldersForUser(userId).map((folder) => folder.id));
+        addAll("muted_keyword", listMutedKeywords(userId).map((keyword) => keyword.id));
+        const itemIds = db
+            .prepare(`SELECT item_id FROM item_reads WHERE user_id = ?
+         UNION SELECT item_id FROM item_bookmarks WHERE user_id = ?
+         UNION SELECT item_id FROM item_progress WHERE user_id = ?`)
+            .all(userId, userId, userId)
+            .map((row) => row.item_id);
+        addAll("item_state", itemIds);
+        const noteIds = db
+            .prepare("SELECT item_id FROM item_notes WHERE user_id = ?")
+            .all(userId)
+            .map((row) => row.item_id);
+        addAll("note", noteIds);
+        if (db.prepare("SELECT user_id FROM editions WHERE user_id = ?").get(userId)) {
+            addAll("edition", [1]);
+        }
+        if (getNativePreferences(userId).revision > 0)
+            addAll("native_preferences", [1]);
+    })();
+}
+export class ResyncRequired extends Error {
+    constructor() {
+        super("resync_required");
+    }
+}
+export function currentSeq(userId) {
+    return db.prepare("SELECT COALESCE(MAX(seq), 0) AS seq FROM changes WHERE user_id = ?").get(userId).seq;
+}
+/** Everything that changed after `since`, oldest first, with the current data of each object. */
+export function listChanges(userId, since, limit = 200) {
+    ensureChangeLog(userId);
+    const state = db.prepare("SELECT pruned_through FROM sync_state WHERE user_id = ?").get(userId);
+    // A client that is behind a forgotten deletion cannot know about it and has to start over.
+    if (since > 0 && since < state.pruned_through)
+        throw new ResyncRequired();
+    // A position beyond the end of the log means the server was restored from an older backup.
+    if (since > currentSeq(userId))
+        throw new ResyncRequired();
+    const page = Math.min(Math.max(limit, 1), MAX_PAGE);
+    const rows = db
+        .prepare("SELECT entity, entity_id, op, seq FROM changes WHERE user_id = ? AND seq > ? ORDER BY seq LIMIT ?")
+        .all(userId, since, page + 1);
+    const hasMore = rows.length > page;
+    const slice = rows.slice(0, page);
+    const subscriptions = new Map(listSubscriptionsForUser(userId).map((subscription) => [subscription.id, subscription]));
+    const folders = new Map(listFoldersForUser(userId).map((folder) => [folder.id, folder]));
+    const keywords = new Map(listMutedKeywords(userId).map((keyword) => [keyword.id, keyword]));
+    const changes = slice.map((row) => {
+        const change = { seq: row.seq, entity: row.entity, id: row.entity_id, op: row.op };
+        if (row.entity === "edition") {
+            const state = getEditionState(userId);
+            return state.edition ? { ...change, op: "upsert", data: { ...state.edition } } :
+                { ...change, op: "delete", data: { revision: state.revision, status: state.status } };
+        }
+        if (row.entity === "note" && row.op === "delete") {
+            const version = db.prepare("SELECT revision FROM item_note_revisions WHERE user_id = ? AND item_id = ?").get(userId, row.entity_id);
+            return version ? { ...change, data: { revision: version.revision } } : change;
+        }
+        if (row.op === "delete")
+            return change;
+        let data;
+        if (row.entity === "item_content") {
+            const item = findItemById(row.entity_id);
+            data = item && canAccessItem(userId, row.entity_id) ? contentMetadata(item) : null;
+        }
+        else if (row.entity === "item_state")
+            data = itemState(userId, row.entity_id);
+        else if (row.entity === "subscription") {
+            const subscription = subscriptions.get(row.entity_id);
+            data = subscription && serializeSubscription(subscription);
+        }
+        else if (row.entity === "folder") {
+            const folder = folders.get(row.entity_id);
+            data = folder && { name: folder.name, iconSymbol: folder.icon_symbol ?? null };
+        }
+        else if (row.entity === "muted_keyword") {
+            const keyword = keywords.get(row.entity_id);
+            data = keyword && { keyword: keyword.keyword };
+        }
+        else if (row.entity === "note") {
+            const note = findItemNote(userId, row.entity_id);
+            data = note && {
+                itemId: note.item_id,
+                content: note.content,
+                revision: note.revision,
+                createdAt: note.created_at,
+                updatedAt: note.updated_at,
+            };
+        }
+        else if (row.entity === "native_preferences") {
+            data = { ...getNativePreferences(userId) };
+        }
+        // The object disappeared after it was logged (for example an article removed by retention).
+        return data ? { ...change, data } : { ...change, op: "delete" };
+    });
+    return { changes, nextSeq: slice.length ? slice[slice.length - 1].seq : since, hasMore };
+}
+/** Forget deletions older than the tombstone window and objects that no longer exist. */
+export function pruneChangeLog() {
+    const cutoff = new Date(Date.now() - TOMBSTONE_DAYS * 86_400_000).toISOString();
+    return db.transaction(() => {
+        db.prepare(`UPDATE sync_state SET pruned_through = MAX(pruned_through, COALESCE(
+         (SELECT MAX(seq) FROM changes WHERE changes.user_id = sync_state.user_id AND op = 'delete' AND changed_at < ?), 0))`).run(cutoff);
+        const old = db.prepare("DELETE FROM changes WHERE op = 'delete' AND changed_at < ?").run(cutoff).changes;
+        const gone = db.prepare("DELETE FROM changes WHERE entity IN ('item_state', 'item_content') AND entity_id NOT IN (SELECT id FROM items)").run().changes;
+        const goneNotes = db.prepare("DELETE FROM changes WHERE entity = 'note' AND entity_id NOT IN (SELECT id FROM items)").run().changes;
+        db.prepare("DELETE FROM applied_mutations WHERE applied_at < ?").run(new Date(Date.now() - 30 * 86_400_000).toISOString());
+        return old + gone + goneNotes;
+    })();
+}
+//# sourceMappingURL=changeLog.js.map