@jant/core 0.3.46 → 0.3.48

package/dist/github-sync-bL1hnx3Q.js

@@ -0,0 +1,428 @@
+import { c as parseMarkdownDocument, r as parseFrontMatter, t as createExportService } from "./export-ZBlfKSKm.js";
+import { r as getInstallationToken } from "./github-app-D0GvNnqp.js";
+import { r as parseRepoSlug, t as createGitHubClient } from "./github-api-Bh0PH3zr.js";
+//#region src/lib/markdown-to-tiptap.ts
+/**
+* Markdown → TipTap JSON Conversion
+*
+* Converts Markdown strings to TipTap JSON documents using the official
+* Tiptap MarkdownManager and the same extension schema used elsewhere in Jant.
+*/
+/**
+* Converts a Markdown string to a TipTap JSON document string.
+*
+* @param markdown - Markdown source text
+* @returns Stringified TipTap JSON document
+*
+* @example
+* ```ts
+* const json = markdownToTiptapJson("Hello **world**");
+* // '{"type":"doc","content":[{"type":"paragraph","content":[...]}]}'
+* ```
+*/ function markdownToTiptapJson(markdown) {
+	return JSON.stringify(parseMarkdownDocument(markdown));
+}
+//#endregion
+//#region src/services/github-sync.ts
+/**
+* GitHub Sync Service
+*
+* Handles bidirectional content synchronization between Jant and a GitHub repo.
+* Posts are serialized as Hugo-format Markdown bundles (reusing the export
+* format): each post is a branch bundle at `content/{slug}/_index.md` with
+* reply leaves at `content/{root-slug}/{reply-slug}/index.md`.
+*
+* Push (Jant → GitHub):
+*   - Always full sync: regenerate Jant-managed files in a single atomic commit
+*   - Uses base_tree so untracked files in the repo (READMEs, CI, etc.) are preserved
+*   - Debounced: multiple rapid changes collapse into one sync
+*
+* Pull (GitHub → Jant):
+*   - Webhook-triggered: match modified files to existing posts by slug and update
+*   - Unknown files are skipped; new posts cannot be created from GitHub
+*   - File deletions are intentionally ignored to avoid catastrophic data loss
+*     (e.g. user deletes the repo → site wiped). Deletes must go through Jant's UI.
+*
+* Anti-loop: all commits from Jant include `[jant-sync]` in the message.
+* Incoming webhooks with this marker are skipped.
+*/
+/** Marker included in commit messages to prevent webhook loops. */ var SYNC_COMMIT_MARKER = "[jant-sync]";
+/**
+* Path of the ownership marker file written at the repo root.
+*
+* Presence of this file (with a matching `site_id`) identifies the repo
+* as actively managed by a Jant site. Used to distinguish three states
+* during connect: empty repo, Jant-owned repo, foreign repo with existing
+* content. Also serves as the initialization file for empty repos so we
+* don't need a separate throwaway placeholder.
+*/ var JANT_SYNC_MARKER_PATH = ".jant-sync";
+/**
+* Hard list of paths Jant fully owns and always overwrites on push.
+* Anything outside this set is user territory and preserved via base_tree.
+* Files inside this set that Jant no longer generates are deleted on the
+* next push (see `computeManagedDeletions`).
+*
+* - `content/**` — posts, collections, sections (rendered by Hugo)
+* - `data/jant.toml` — nav, branding, collections directory (the rest of
+*   `data/` is user territory so Hugo's `data/menu.toml` convention, etc.,
+*   can be used freely)
+* - `themes/jant/**` — the packaged Jant theme (layouts + static assets)
+* - `hugo.toml` — site config, including `theme = "jant"`
+* - `.gitignore`, `README.md` — scaffolded once, then kept in sync
+* - `.jant-sync` — ownership marker; written by this service, not by export
+*
+* The list is also stored in the marker itself (`managed_globs`) so future
+* schema bumps can diff the old and new sets to decide what needs cleanup.
+*/ var JANT_MANAGED_GLOBS = [
+	"content/**",
+	"data/jant.toml",
+	"themes/jant/**",
+	"hugo.toml",
+	".gitignore",
+	"README.md",
+	".jant-sync"
+];
+/**
+* Match a repo-relative path against a single glob from
+* `JANT_MANAGED_GLOBS`. Only two forms are supported because those are
+* the only two shapes the constant uses:
+*
+* - Exact path (`"hugo.toml"`, `"data/jant.toml"`)
+* - Directory prefix + `/**` (`"content/**"`, `"themes/jant/**"`)
+*
+* Exported for testing.
+*/ function pathMatchesManagedGlob(path, glob) {
+	if (glob.endsWith("/**")) {
+		const prefix = glob.slice(0, -3);
+		return path === prefix || path.startsWith(prefix + "/");
+	}
+	return path === glob;
+}
+/**
+* True when `path` falls inside one of Jant's managed globs.
+*
+* Exported for testing.
+*/ function isManagedPath(path) {
+	return JANT_MANAGED_GLOBS.some((g) => pathMatchesManagedGlob(path, g));
+}
+/**
+* Compute the tree items that should null-out files on the remote HEAD
+* which Jant claims ownership of (matches `JANT_MANAGED_GLOBS`) but is
+* not writing in the current push (not in `writtenPaths`).
+*
+* Returns a list of `{ sha: null }` tree entries suitable for appending
+* to the payload of `createTree`. Exported for testing.
+*/ function computeManagedDeletions(headTreeItems, writtenPaths) {
+	const items = [];
+	for (const item of headTreeItems) {
+		if (item.type !== "blob") continue;
+		if (!isManagedPath(item.path)) continue;
+		if (writtenPaths.has(item.path)) continue;
+		items.push({
+			path: item.path,
+			mode: "100644",
+			type: "blob",
+			sha: null
+		});
+	}
+	return items;
+}
+function parseMarker(text) {
+	try {
+		const parsed = JSON.parse(text);
+		if (typeof parsed.site_id === "string" && typeof parsed.site_host === "string" && typeof parsed.created_at === "number" && typeof parsed.schema_version === "number") return parsed;
+	} catch {}
+	return null;
+}
+function decodeMarkerContent(file) {
+	if (file.encoding === "base64") try {
+		const cleaned = file.content.replace(/\s+/g, "");
+		const binary = atob(cleaned);
+		const bytes = Uint8Array.from(binary, (ch) => ch.charCodeAt(0));
+		return new TextDecoder("utf-8").decode(bytes);
+	} catch {
+		return "";
+	}
+	return file.content;
+}
+function formatMarker(marker) {
+	return `${JSON.stringify(marker, null, 2)}\n`;
+}
+function safeHost(siteUrl) {
+	try {
+		return new URL(siteUrl).host;
+	} catch {
+		return "";
+	}
+}
+/**
+* Classify a repository to decide how to proceed with a sync connection.
+*
+* - `empty`: repo has no commits on the default branch (or repo is brand new).
+* - `owned`: `.jant-sync` marker present with matching `site_id`.
+* - `owned-by-other-site`: `.jant-sync` present but `site_id` differs —
+*   another Jant site already backs up here, blocking the connect.
+* - `foreign`: non-empty repo without a marker — requires explicit
+*   user confirmation before connect.
+*/ async function classifyRepoForSync(client, owner, repo, siteId) {
+	const defaultBranch = (await client.getRepo(owner, repo)).default_branch;
+	try {
+		await client.getRef(owner, repo, `heads/${defaultBranch}`);
+	} catch {
+		return { kind: "empty" };
+	}
+	const markerFile = await client.getFileContent(owner, repo, JANT_SYNC_MARKER_PATH);
+	if (!markerFile) return {
+		kind: "foreign",
+		defaultBranch
+	};
+	const marker = parseMarker(decodeMarkerContent(markerFile));
+	if (!marker) return {
+		kind: "foreign",
+		defaultBranch
+	};
+	if (marker.site_id === siteId) return {
+		kind: "owned",
+		marker
+	};
+	return {
+		kind: "owned-by-other-site",
+		marker
+	};
+}
+function createGitHubSyncService(services, siteId, siteConfig, deps = {}) {
+	/**
+	* Build the ownership marker for this push. Preserves `created_at`
+	* from an existing marker (when readable) so the timestamp reflects
+	* when this repo was first bound to this site, not the latest push.
+	*/ function buildMarker(existingContent, now) {
+		const existing = existingContent ? parseMarker(existingContent) : null;
+		const preservedCreatedAt = existing && existing.site_id === siteId ? existing.created_at : now;
+		return {
+			schema_version: 3,
+			site_id: siteId,
+			site_host: safeHost(siteConfig.siteUrl),
+			created_at: preservedCreatedAt,
+			managed_globs: [...JANT_MANAGED_GLOBS]
+		};
+	}
+	async function loadConfig() {
+		const [repo, enabled, authModeRaw] = await Promise.all([
+			services.settings.get("GITHUB_SYNC_REPO"),
+			services.settings.get("GITHUB_SYNC_ENABLED"),
+			services.settings.get("GITHUB_SYNC_AUTH_MODE")
+		]);
+		if (!repo || enabled !== "true") return null;
+		const authMode = authModeRaw === "app" ? "app" : "pat";
+		const [token, installationId, webhookId, webhookSecret, lastPushSha] = await Promise.all([
+			services.settings.get("GITHUB_SYNC_TOKEN"),
+			services.settings.get("GITHUB_SYNC_APP_INSTALLATION_ID"),
+			services.settings.get("GITHUB_SYNC_WEBHOOK_ID"),
+			services.settings.get("GITHUB_SYNC_WEBHOOK_SECRET"),
+			services.settings.get("GITHUB_SYNC_LAST_PUSH_SHA")
+		]);
+		if (authMode === "pat" && !token) return null;
+		if (authMode === "app" && !installationId) return null;
+		return {
+			authMode,
+			token: token ?? void 0,
+			installationId: installationId ?? void 0,
+			repo,
+			enabled: true,
+			webhookId: webhookId ?? void 0,
+			webhookSecret: webhookSecret ?? void 0,
+			lastPushSha: lastPushSha ?? void 0
+		};
+	}
+	function createClient(config) {
+		const parsed = parseRepoSlug(config.repo);
+		if (!parsed) throw new Error(`Invalid repo slug: ${config.repo}`);
+		let client;
+		if (config.authMode === "app") {
+			if (!deps.githubApp) throw new Error("GitHub App is not configured on this deployment. Set GITHUB_APP_ID, GITHUB_APP_PRIVATE_KEY, and GITHUB_APP_SLUG to use App auth.");
+			if (!config.installationId) throw new Error("GitHub App installation id is missing.");
+			const app = deps.githubApp;
+			const installationId = config.installationId;
+			client = createGitHubClient(() => getInstallationToken(app, installationId));
+		} else {
+			if (!config.token) throw new Error("GitHub sync PAT is missing.");
+			client = createGitHubClient(config.token);
+		}
+		return {
+			client,
+			owner: parsed.owner,
+			repo: parsed.repo
+		};
+	}
+	/**
+	* Get the HEAD SHA, initializing an empty repo if needed.
+	* GitHub's Git Trees API requires at least one commit to exist.
+	*/ async function getOrInitHead(client, owner, repo, defaultBranch, seedMarker) {
+		try {
+			return { sha: (await client.getRef(owner, repo, `heads/${defaultBranch}`)).sha };
+		} catch {
+			await client.createOrUpdateFile(owner, repo, JANT_SYNC_MARKER_PATH, {
+				content: formatMarker(seedMarker),
+				message: `Initialize Jant sync ${SYNC_COMMIT_MARKER}`
+			});
+			return { sha: (await client.getRef(owner, repo, `heads/${defaultBranch}`)).sha };
+		}
+	}
+	return {
+		getConfig: loadConfig,
+		async pushFullSync() {
+			const config = await loadConfig();
+			if (!config) throw new Error("GitHub Sync is not configured");
+			const { client, owner, repo } = createClient(config);
+			const exportFiles = await createExportService(services, siteConfig, deps).generateHugoFiles();
+			const defaultBranch = (await client.getRepo(owner, repo)).default_branch;
+			const now = Math.floor(Date.now() / 1e3);
+			const existingMarkerBeforeInit = await client.getFileContent(owner, repo, JANT_SYNC_MARKER_PATH).catch(() => null);
+			const marker = buildMarker(existingMarkerBeforeInit ? decodeMarkerContent(existingMarkerBeforeInit) : null, now);
+			const { sha: headSha } = await getOrInitHead(client, owner, repo, defaultBranch, marker);
+			const treeItems = [{
+				path: JANT_SYNC_MARKER_PATH,
+				mode: "100644",
+				type: "blob",
+				content: formatMarker(marker)
+			}];
+			for (const file of exportFiles) if (typeof file.content === "string") treeItems.push({
+				path: file.path,
+				mode: "100644",
+				type: "blob",
+				content: file.content
+			});
+			else {
+				const blob = await client.createBlob(owner, repo, uint8ArrayToBase64(file.content), "base64");
+				treeItems.push({
+					path: file.path,
+					mode: "100644",
+					type: "blob",
+					sha: blob.sha
+				});
+			}
+			const headCommit = await client.getCommit(owner, repo, headSha);
+			const headTree = await client.getTree(owner, repo, headCommit.treeSha, { recursive: true });
+			if (headTree.truncated) throw new Error("GitHub tree exceeds API limits (>100k entries or >7MB); incremental deletion cannot run safely against this repo.");
+			const writtenPaths = new Set(treeItems.map((item) => item.path));
+			treeItems.push(...computeManagedDeletions(headTree.tree, writtenPaths));
+			const tree = await client.createTree(owner, repo, treeItems, headCommit.treeSha);
+			const commit = await client.createCommit(owner, repo, {
+				message: `Sync site ${SYNC_COMMIT_MARKER}`,
+				tree: tree.sha,
+				parents: [headSha]
+			});
+			await client.updateRef(owner, repo, `heads/${defaultBranch}`, commit.sha);
+			await services.settings.set("GITHUB_SYNC_LAST_PUSH_SHA", commit.sha);
+			await services.settings.set("GITHUB_SYNC_LAST_PUSH_AT", String(Math.floor(Date.now() / 1e3)));
+			return { commitSha: commit.sha };
+		},
+		async handleWebhookPush(payload) {
+			if (payload.commits.some((c) => c.message.includes("[jant-sync]")) && payload.commits.length === 1) return;
+			const modified = /* @__PURE__ */ new Set();
+			for (const commit of payload.commits) {
+				if (commit.message.includes("[jant-sync]")) continue;
+				for (const file of [...commit.modified, ...commit.added]) if (classifyBundlePath(file)) modified.add(file);
+			}
+			if (modified.size === 0) return;
+			const config = await loadConfig();
+			if (!config) return;
+			const { client, owner, repo } = createClient(config);
+			for (const filePath of modified) {
+				const classification = classifyBundlePath(filePath);
+				if (!classification) continue;
+				const fileContent = await client.getFileContent(owner, repo, filePath, payload.after);
+				if (!fileContent) continue;
+				const { frontMatter, body } = await parseFrontMatter(decodeBase64Content(fileContent.content));
+				const slug = typeof frontMatter.slug === "string" && frontMatter.slug.trim() ? frontMatter.slug.trim() : classification.slug;
+				if (!slug) continue;
+				const pathRecord = await services.paths.getByPath(slug);
+				if (!pathRecord?.postId) continue;
+				const existingPost = await services.posts.getById(pathRecord.postId);
+				if (!existingPost) continue;
+				if (classification.kind === "reply") {
+					const rootPath = await services.paths.getByPath(classification.rootSlug);
+					if (!rootPath?.postId) continue;
+					if (existingPost.threadId !== rootPath.postId) continue;
+				}
+				const trimmedBody = body.trim();
+				const tiptapBody = trimmedBody ? markdownToTiptapJson(trimmedBody) : null;
+				const updateData = {};
+				if (tiptapBody !== null) updateData.body = tiptapBody;
+				if (frontMatter.title !== void 0) updateData.title = frontMatter.title;
+				if (frontMatter.link_url !== void 0) updateData.url = frontMatter.link_url;
+				if (frontMatter.source_name !== void 0) updateData.sourceName = frontMatter.source_name;
+				if (frontMatter.source_url !== void 0) updateData.sourceUrl = frontMatter.source_url;
+				if (frontMatter.quote_text !== void 0) updateData.quoteText = frontMatter.quote_text;
+				if (frontMatter.rating !== void 0) updateData.rating = frontMatter.rating;
+				if (Object.keys(updateData).length > 0) await services.posts.update(existingPost.id, updateData);
+			}
+		},
+		async setupWebhook(callbackUrl) {
+			const config = await loadConfig();
+			if (!config) throw new Error("GitHub Sync is not configured");
+			const { client, owner, repo } = createClient(config);
+			const secretBytes = new Uint8Array(32);
+			crypto.getRandomValues(secretBytes);
+			const secret = Array.from(secretBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+			const webhook = await client.createWebhook(owner, repo, {
+				url: callbackUrl,
+				secret,
+				events: ["push"]
+			});
+			await services.settings.set("GITHUB_SYNC_WEBHOOK_SECRET", secret);
+			await services.settings.set("GITHUB_SYNC_WEBHOOK_ID", String(webhook.id));
+			return { webhookId: webhook.id };
+		},
+		async teardownWebhook() {
+			const config = await loadConfig();
+			if (!config) return;
+			if (config.webhookId) try {
+				const { client, owner, repo } = createClient(config);
+				await client.deleteWebhook(owner, repo, parseInt(config.webhookId));
+			} catch {}
+			await services.settings.set("GITHUB_SYNC_ENABLED", "false");
+			await services.settings.set("GITHUB_SYNC_TOKEN", "");
+			await services.settings.set("GITHUB_SYNC_REPO", "");
+			await services.settings.set("GITHUB_SYNC_WEBHOOK_SECRET", "");
+			await services.settings.set("GITHUB_SYNC_WEBHOOK_ID", "");
+			await services.settings.set("GITHUB_SYNC_LAST_PUSH_SHA", "");
+			await services.settings.set("GITHUB_SYNC_AUTH_MODE", "pat");
+			await services.settings.set("GITHUB_SYNC_APP_INSTALLATION_ID", "");
+		}
+	};
+}
+function decodeBase64Content(content) {
+	const cleaned = content.replace(/\n/g, "");
+	return decodeURIComponent(escape(atob(cleaned)));
+}
+function classifyBundlePath(path) {
+	if (!path.startsWith("content/")) return null;
+	const segments = path.slice(8).split("/");
+	if (segments.length === 2 && segments[1] === "_index.md") {
+		const slug = segments[0];
+		if (!slug) return null;
+		return {
+			kind: "root",
+			slug
+		};
+	}
+	if (segments.length === 3 && segments[2] === "index.md") {
+		const rootSlug = segments[0];
+		const slug = segments[1];
+		if (!rootSlug || !slug) return null;
+		return {
+			kind: "reply",
+			rootSlug,
+			slug
+		};
+	}
+	return null;
+}
+function uint8ArrayToBase64(bytes) {
+	let binary = "";
+	for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+	return btoa(binary);
+}
+//#endregion
+export { computeManagedDeletions as a, pathMatchesManagedGlob as c, classifyRepoForSync as i, markdownToTiptapJson as l, JANT_SYNC_MARKER_PATH as n, createGitHubSyncService as o, SYNC_COMMIT_MARKER as r, isManagedPath as s, JANT_MANAGED_GLOBS as t };

package/dist/index.js

@@ -1,5 +1,6 @@
 import { _ as url_exports } from "./url-umUptr5z.js";
-import { A as SORT_ORDERS, C as toPostViews, D as MAX_PINNED_POSTS, E as MAX_MEDIA_ATTACHMENTS, M as TEXT_ATTACHMENT_CONTENT_FORMATS, O as MEDIA_KINDS, S as toPostView, T as FORMATS, _ as toArchiveGroups, b as toNavItemView, d as defaultFeedRenderer, g as createMediaContext, j as STATUSES, k as NAV_ITEM_TYPES, t as createApp, v as toArchiveGroupsWithMedia, w as toSearchResultView, x as toNavItemViews, y as toMediaView } from "./app-DB-P66E5.js";
-import { E as time_exports, s as markdown_exports } from "./github-sync-CQ1x271f.js";
+import { A as NAV_ITEM_TYPES, C as toPostView, D as MAX_MEDIA_ATTACHMENTS, E as FORMATS, M as STATUSES, N as TEXT_ATTACHMENT_CONTENT_FORMATS, O as MAX_PINNED_POSTS, S as toNavItemViews, T as toSearchResultView, _ as createMediaContext, b as toMediaView, f as defaultFeedRenderer, j as SORT_ORDERS, k as MEDIA_KINDS, t as createApp, v as toArchiveGroups, w as toPostViews, x as toNavItemView, y as toArchiveGroupsWithMedia } from "./app-DdnIoX7y.js";
+import { T as time_exports, a as markdown_exports } from "./export-ZBlfKSKm.js";
 import "./env-CgaH9Mut.js";
+import "./github-sync-bL1hnx3Q.js";
 export { FORMATS, MAX_MEDIA_ATTACHMENTS, MAX_PINNED_POSTS, MEDIA_KINDS, NAV_ITEM_TYPES, SORT_ORDERS, STATUSES, TEXT_ATTACHMENT_CONTENT_FORMATS, createApp, createMediaContext, defaultFeedRenderer, markdown_exports as markdown, time_exports as time, toArchiveGroups, toArchiveGroupsWithMedia, toMediaView, toNavItemView, toNavItemViews, toPostView, toPostViews, toSearchResultView, url_exports as url };

package/dist/node.js

@@ -1,7 +1,8 @@
 import "./url-umUptr5z.js";
-import { F as getPublicAssetBasePath, I as isAssetPath, N as buildThemeStyle, P as BUILTIN_COLOR_THEMES, a as resolveDatabaseDialect, c as BUILTIN_FONT_THEMES, f as pgSchemaBundle, h as schema_exports, i as createSiteService, l as getCjkSerifCssVariables, m as createNodeDatabase, n as createNodeCliRuntime, o as getHostBasedStartupConfigurationIssues, p as sqliteSchemaBundle, r as createNodeRequestRuntime, s as resolveConfig, t as createApp, u as getFontThemeCssVariables } from "./app-DB-P66E5.js";
-import { i as createExportService } from "./github-sync-CQ1x271f.js";
+import { F as BUILTIN_COLOR_THEMES, I as getPublicAssetBasePath, L as isAssetPath, P as buildThemeStyle, a as resolveDatabaseDialect, c as resolveConfig, d as getFontThemeCssVariables, g as schema_exports, h as createNodeDatabase, i as createSiteService, l as BUILTIN_FONT_THEMES, m as sqliteSchemaBundle, n as createNodeCliRuntime, o as getHostBasedStartupConfigurationIssues, p as pgSchemaBundle, r as createNodeRequestRuntime, s as createStorageDriver, t as createApp, u as getCjkSerifCssVariables } from "./app-DdnIoX7y.js";
+import { t as createExportService } from "./export-ZBlfKSKm.js";
 import { b as getSiteResolutionMode, i as getConfiguredSingleSitePathPrefix, l as getEnvString, r as getConfiguredSingleSiteOrigin, x as shouldTrustProxy, y as getPort } from "./env-CgaH9Mut.js";
+import "./github-sync-bL1hnx3Q.js";
 import { drizzle } from "drizzle-orm/better-sqlite3";
 import { serve } from "@hono/node-server";
 import Database from "better-sqlite3";
@@ -473,7 +474,7 @@ async function createNodeRequestHandler(options) {
 async function start(env = process.env, app) {
 	const handler = await createNodeRequestHandler({
 		env,
-		app: async () => app ?? (await import("./app-CM7sb3xO.js")).createApp()
+		app: async () => app ?? (await import("./app-DU7dpJID.js")).createApp()
 	});
 	const hostname = resolveHost(env);
 	const port = resolvePort(env);
@@ -517,4 +518,4 @@ async function start(env = process.env, app) {
 	});
 }
 //#endregion
-export { BUILTIN_COLOR_THEMES, BUILTIN_FONT_THEMES, buildThemeStyle, createApp, createExportService, createNodeBindings, createNodeCliRuntime, createNodeRequestHandler, createNodeRequestRuntime, getCjkSerifCssVariables, getFontThemeCssVariables, migrate, resolveConfig, start };
+export { BUILTIN_COLOR_THEMES, BUILTIN_FONT_THEMES, buildThemeStyle, createApp, createExportService, createNodeBindings, createNodeCliRuntime, createNodeRequestHandler, createNodeRequestRuntime, createStorageDriver, getCjkSerifCssVariables, getFontThemeCssVariables, migrate, resolveConfig, start };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jant/core",
-  "version": "0.3.46",
+  "version": "0.3.48",
   "description": "A modern, open-source microblogging platform built on Cloudflare Workers",
   "type": "module",
   "exports": {
@@ -143,7 +143,8 @@
     "fonts:generate:tc": "node dev/scripts/generate-noto-serif-cjk.mjs tc",
     "i18n:extract": "lingui extract --clean",
     "i18n:compile": "lingui compile --typescript",
-    "i18n:build": "pnpm i18n:extract && pnpm i18n:compile",
+    "i18n:coverage": "node dev/scripts/compute-i18n-coverage.mjs",
+    "i18n:build": "pnpm i18n:extract && pnpm i18n:compile && pnpm i18n:coverage",
     "dev": "pnpm db:migrate:local && vite dev",
     "dev:node": "vite dev --config vite.config.node.ts --mode node --host 0.0.0.0",
     "dev:debug": "node dev/scripts/start-dev-debug.mjs",

package/src/__tests__/helpers/export-fixtures.ts

@@ -31,7 +31,6 @@ export function makePost(over: Partial<Post> = {}): Post {
     previewProvider: null,
     replyToId: null,
     threadId: "post-root",
-    deletedAt: null,
     publishedAt: 1773014400,
     lastActivityAt: 1773014400,
     createdAt: 1773014400,

package/src/client/components/__tests__/jant-settings-avatar.test.ts

@@ -40,6 +40,8 @@ const labels: SettingsLabels = {
   aboutBlogHelp: "Displayed above your blog posts.",
   siteLanguage: "Site Language",
   siteLanguageHelp: "Language used for the site UI.",
+  siteLanguageSearchPlaceholder: "Search…",
+  siteLanguageNoMatches: "No matches.",
   cjkFont: "CJK Font",
   cjkFontHelp:
     "Load a serif font optimized for Chinese, Japanese, or Korean content.",

package/src/client/components/__tests__/jant-settings-general.test.ts

@@ -83,6 +83,8 @@ const labels: SettingsLabels = {
   aboutBlogHelp: "Displayed above your blog posts.",
   siteLanguage: "Site Language",
   siteLanguageHelp: "Language used for the site UI.",
+  siteLanguageSearchPlaceholder: "Search…",
+  siteLanguageNoMatches: "No matches.",
   cjkFont: "CJK Font",
   cjkFontHelp:
     "Load a serif font optimized for Chinese, Japanese, or Korean content.",
@@ -220,6 +222,74 @@ describe("JantSettingsGeneral", () => {
     expect(options?.[0]?.value).toBe("UTC");
   });
 
+  it("opens the locale combobox and filters options as the user searches", async () => {
+    const el = await createElement();
+
+    const trigger = requireElement(
+      el.querySelector<HTMLButtonElement>(
+        'button[aria-haspopup="listbox"][aria-labelledby="site-language-label"]',
+      ),
+      "expected locale picker trigger",
+    );
+    expect(trigger.getAttribute("aria-expanded")).toBe("false");
+
+    trigger.click();
+    await el.updateComplete;
+
+    expect(trigger.getAttribute("aria-expanded")).toBe("true");
+
+    const options = el.querySelectorAll<HTMLButtonElement>('[role="option"]');
+    expect(options.length).toBeGreaterThanOrEqual(20);
+    // Each option carries the universal "translated" coverage suffix.
+    for (const option of options) {
+      expect(option.textContent).toMatch(/% translated/);
+    }
+
+    const search = requireElement(
+      el.querySelector<HTMLInputElement>("[data-locale-search]"),
+      "expected search input",
+    );
+    search.value = "fin";
+    search.dispatchEvent(new Event("input", { bubbles: true }));
+    await el.updateComplete;
+
+    const filtered = el.querySelectorAll<HTMLButtonElement>('[role="option"]');
+    expect(filtered.length).toBe(1);
+    expect(filtered[0]?.textContent).toMatch(/Suomi|Finnish/);
+  });
+
+  it("selects a non-catalog locale and reports 0% translated coverage on it", async () => {
+    const el = await createElement();
+    const trigger = requireElement(
+      el.querySelector<HTMLButtonElement>(
+        'button[aria-labelledby="site-language-label"]',
+      ),
+      "expected trigger",
+    );
+    trigger.click();
+    await el.updateComplete;
+
+    const search = requireElement(
+      el.querySelector<HTMLInputElement>("[data-locale-search]"),
+      "expected search input",
+    );
+    search.value = "fi";
+    search.dispatchEvent(new Event("input", { bubbles: true }));
+    await el.updateComplete;
+
+    const finnishOption = Array.from(
+      el.querySelectorAll<HTMLButtonElement>('[role="option"]'),
+    ).find((opt) => /Suomi|Finnish/.test(opt.textContent ?? ""));
+    finnishOption?.click();
+    await el.updateComplete;
+
+    // Picker closes after selection.
+    expect(trigger.getAttribute("aria-expanded")).toBe("false");
+    // Trigger reflects the new tag and shows 0% coverage.
+    expect(trigger.textContent).toMatch(/fi/);
+    expect(trigger.textContent).toMatch(/0% translated/);
+  });
+
   it("renders CJK font options", async () => {
     const el = await createElement();
     const cjkSelect = requireElement(