meowpress 0.3.0-alpha.4 → 0.3.0-alpha.6

package/dist/src/cli.js

@@ -3,21 +3,38 @@ import { stat } from "node:fs/promises";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { buildSite, meowSite } from "./build.js";
+import { loadSection } from "./content.js";
+import { loadLocaleCatalogs } from "./locales.js";
 import { hasBuiltSite, validateOutputDirectory } from "./output.js";
 import { serveSite } from "./preview.js";
+import { formatReport, stampTranslation, translationReport, } from "./translations.js";
 const USAGE = [
-    "Usage: meowpress [--config <file>]",
+    "Usage: meowpress [--config <file>] [--root <dir>]",
     "       meowpress build [root] [--config <file>]",
     "       meowpress preview [root] [--config <file>] [--port <port>]",
+    "       meowpress locales [--json] [--root <dir>] [--config <file>]",
+    "       meowpress locales stamp <file> [--root <dir>] [--config <file>]",
 ].join("\n");
 const CONFIG_FILES = ["meowpress.config.ts", "site.config.ts"];
 function parseArgs(args) {
-    const command = args[0] === "preview" ? "preview" : "build";
-    const hasCommand = args[0] === command;
+    const first = args[0];
+    const hasCommand = first === "build" || first === "preview" || first === "locales";
+    let mode = hasCommand ? first : "build";
+    let index = hasCommand ? 1 : 0;
+    let file;
+    if (mode === "locales" && args[index] === "stamp") {
+        const value = args[++index];
+        if (!value || value.startsWith("-"))
+            throw new Error("Missing file for locales stamp");
+        file = value;
+        mode = "stamp";
+        index++;
+    }
     let root;
     let config;
     let port;
-    for (let index = hasCommand ? 1 : 0; index < args.length; index++) {
+    let json = false;
+    for (; index < args.length; index++) {
         const arg = args[index];
         if (arg === "--config" && config === undefined) {
             const value = args[++index];
@@ -25,20 +42,37 @@ function parseArgs(args) {
                 throw new Error("Missing file for --config");
             config = value;
         }
-        else if (arg === "--port" && command === "preview" && port === undefined) {
+        else if (arg === "--root" && root === undefined) {
+            const value = args[++index];
+            if (!value || value.startsWith("-"))
+                throw new Error("Missing directory for --root");
+            root = value;
+        }
+        else if (arg === "--port" && mode === "preview" && port === undefined) {
             const value = args[++index];
             port = Number(value);
             if (!Number.isInteger(port) || port < 1 || port > 65535)
                 throw new Error("Port must be an integer between 1 and 65535");
         }
-        else if (hasCommand && !arg.startsWith("-") && root === undefined) {
+        else if (arg === "--json" && mode === "locales" && !json) {
+            json = true;
+        }
+        else if ((mode === "build" || mode === "preview") &&
+            !arg.startsWith("-") &&
+            root === undefined) {
             root = arg;
         }
         else {
             throw new Error(`Unexpected argument: ${arg}\n${USAGE}`);
         }
     }
-    return { command, root: resolve(root ?? "."), config, port };
+    return { mode, root: resolve(root ?? "."), config, port, json, file };
+}
+/** The locale configuration the content loader needs, or undefined on a single-locale site. */
+function contentLocales(config) {
+    return config.locales
+        ? { source: config.locales.source, targets: config.locales.targets.map((target) => target.tag) }
+        : undefined;
 }
 async function loadConfig(config) {
     for (const candidate of config === undefined ? CONFIG_FILES : [config]) {
@@ -62,6 +96,60 @@ async function loadConfig(config) {
     }
     return {};
 }
+/** Load the content and catalogs a work-list command needs, without building the site. */
+async function loadTranslationInput(config) {
+    const locales = config.locales;
+    if (!locales)
+        throw new Error("This site configures no locales. Add `locales` to meowpress.config.ts, then run meowpress locales again.");
+    const options = {
+        components: config.mdxComponents,
+        timeZone: config.site.timeZone,
+        locales: contentLocales(config),
+    };
+    const [posts, thoughts, catalogs] = await Promise.all([
+        loadSection(config.content, "post", options),
+        loadSection(config.content, "thought", options),
+        loadLocaleCatalogs(locales, config.localesDirectory),
+    ]);
+    const report = translationReport({
+        locales,
+        catalogs,
+        site: config.site,
+        notFound: config.notFound,
+        posts,
+        thoughts,
+    });
+    return { posts, thoughts, report };
+}
+async function runLocales(options) {
+    const config = meowSite(await loadConfig(options.config));
+    if (options.mode === "stamp") {
+        const locales = config.locales;
+        if (!locales)
+            throw new Error("This site configures no locales. Add `locales` to meowpress.config.ts before stamping a translation.");
+        const stampOptions = {
+            components: config.mdxComponents,
+            timeZone: config.site.timeZone,
+            locales: contentLocales(config),
+        };
+        const [posts, thoughts] = await Promise.all([
+            loadSection(config.content, "post", stampOptions),
+            loadSection(config.content, "thought", stampOptions),
+        ]);
+        const file = resolve(options.file);
+        const stamped = await stampTranslation(file, [...posts, ...thoughts]);
+        console.log(`Stamped ${stamped.file} with ${stamped.hash}.`);
+        return;
+    }
+    const { report } = await loadTranslationInput(config);
+    if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    const text = formatReport(report);
+    if (text)
+        console.log(text);
+}
 export async function runSiteCli(args = Bun.argv.slice(2)) {
     if (args.includes("--help") || args.includes("-h")) {
         console.log(USAGE);
@@ -71,14 +159,20 @@ export async function runSiteCli(args = Bun.argv.slice(2)) {
     if (options.root !== process.cwd()) {
         if (!(await stat(options.root).catch(() => undefined))?.isDirectory())
             throw new Error(`Project root is not a directory: ${options.root}`);
-        // Trusted config can call meowSite while loading, so it and its imports need the selected cwd.
-        const child = Bun.spawn([
-            process.execPath,
-            import.meta.path,
-            options.command,
+        const childArgs = [
+            options.mode === "stamp" ? "locales" : options.mode,
+            ...(options.mode === "stamp" ? ["stamp", options.file] : []),
+            ...(options.json ? ["--json"] : []),
             ...(options.config ? ["--config", options.config] : []),
             ...(options.port ? ["--port", String(options.port)] : []),
-        ], { cwd: options.root, stdin: "inherit", stdout: "inherit", stderr: "inherit" });
+        ];
+        // Trusted config can call meowSite while loading, so it and its imports need the selected cwd.
+        const child = Bun.spawn([process.execPath, import.meta.path, ...childArgs], {
+            cwd: options.root,
+            stdin: "inherit",
+            stdout: "inherit",
+            stderr: "inherit",
+        });
         const interrupt = () => child.kill("SIGINT");
         const terminate = () => child.kill("SIGTERM");
         process.once("SIGINT", interrupt);
@@ -92,8 +186,12 @@ export async function runSiteCli(args = Bun.argv.slice(2)) {
         }
         return;
     }
+    if (options.mode === "locales" || options.mode === "stamp") {
+        await runLocales(options);
+        return;
+    }
     const config = await loadConfig(options.config);
-    if (options.command === "preview") {
+    if (options.mode === "preview") {
         const resolved = meowSite(config);
         await validateOutputDirectory(resolved);
         if (!(await hasBuiltSite(resolved.outputDirectory))) {

package/dist/src/content.d.ts

@@ -1,6 +1,18 @@
 import { type Child, type Props } from "meowjsx/runtime";
 export type ContentKind = "post" | "thought";
 export type Frontmatter = Record<string, unknown>;
+/** Whether a translation still matches the original it records. */
+export type TranslationState = "current" | "stale";
+/**
+ * The locales a content tree may carry, so a file-name suffix is read only when it names a
+ * configured locale: `notes.v2.md` keeps its slug, `notes.fr.md` is a French translation.
+ */
+export interface ContentLocales {
+    /** The language of an unsuffixed file, and the one whose file in a set is the original. */
+    source: string;
+    /** Other canonical tags, written as a lower-case file-name suffix. */
+    targets?: readonly string[];
+}
 /** A content root containing `posts/`, `thoughts/`, and optional asset folders. */
 export interface ContentSource {
     directory: string;
@@ -22,6 +34,10 @@ export interface LoadSectionOptions {
     duplicate?: DuplicateContentPolicy;
     /** Extra components available to MDX content pages. */
     components?: Record<string, MdxComponent>;
+    /** IANA time zone for day keys and time labels. Defaults to "Asia/Shanghai". */
+    timeZone?: string;
+    /** Locales a file-name suffix may name. Without it every item is written in English. */
+    locales?: ContentLocales;
 }
 /** A component an MDX content page may use by name. */
 export type MdxComponent = (props: Props) => Child;
@@ -40,6 +56,28 @@ export interface ContentItem {
     tags: string[];
     readingMinutes: number;
     characterCount: number;
+    /** Canonical tag of the language the item is written in. */
+    locale: string;
+    /**
+     * The slug the file name would have without locale suffixes, set only when a suffix was read.
+     * `notes.fr.md` reports `notes.fr` here and resolves to `notes`.
+     */
+    previousSlug?: string;
+    /** On an original: the translations that share its slug, sorted by language. */
+    translations: ContentItem[];
+    /** On a translation: whether it still matches the original it records. */
+    translationState?: TranslationState;
+    /** On a translation: the original it was translated from. */
+    original?: ContentItem;
+    /** On a translation: the source hash recorded in its frontmatter, when it has one. */
+    translatedFrom?: string;
+}
+/** The `translation` frontmatter block of a translation. */
+export interface TranslationRecord {
+    /** The provenance hash of the original when this file was translated. */
+    source?: string;
+    /** A person marked the translation as reviewed; unset means it was not. */
+    reviewed?: boolean;
 }
 export interface ParsedDocument {
     metadata: Frontmatter;
@@ -55,8 +93,31 @@ export interface CollectContentAssetsOptions {
     directory?: string;
     duplicate?: DuplicateContentPolicy;
 }
+/**
+ * The provenance hash of an original: the first 12 hex characters of SHA-256 over its resolved
+ * title, a newline, and its body with line endings normalised to LF.
+ */
+export declare function translationHash(item: {
+    title: string;
+    body: string;
+}): string;
+/** The `translation` frontmatter block, when it has the expected shape. */
+export declare function translationRecord(metadata: Frontmatter): TranslationRecord;
 export declare function normalizeContentSources(input: ContentSourceInput | readonly ContentSourceInput[], baseDirectory?: string): ContentSource[];
 export declare function loadSection(sources: ContentSourceInput | readonly ContentSourceInput[], kind: ContentKind, options?: LoadSectionOptions): Promise<ContentItem[]>;
+/**
+ * Every item written in one locale: the originals in that language and the translations of
+ * originals written in another one. These are the pages a locale's tree publishes.
+ */
+export declare function localizedItems(originals: readonly ContentItem[], locale: string): ContentItem[];
+/**
+ * The entries a locale's tree lists: its own pages, and the original of anything not translated
+ * into it — marked with the original's language and linked to where it is published.
+ */
+export declare function treeItems(originals: readonly ContentItem[], locale: string, options: {
+    source: string;
+    untranslated: "link" | "omit";
+}): ContentItem[];
 export declare function withoutLeadingHeading(html: string): string;
 export declare function collectAssetFiles(directory: string): Promise<string[]>;
 export declare function collectContentAssets(sources: ContentSourceInput | readonly ContentSourceInput[], options?: CollectContentAssetsOptions): Promise<ContentAsset[]>;

package/dist/src/content.js

@@ -1,11 +1,23 @@
 import { compile, run } from "@mdx-js/mdx";
 import remarkGfm from "remark-gfm";
+import { createHash } from "node:crypto";
 import { lstat, readdir, readFile, stat } from "node:fs/promises";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { Fragment, h } from "meowjsx/runtime";
 import { renderToHtml } from "meowjsx/web";
+import { DEFAULT_TIME_ZONE } from "./identity.js";
 const CONTENT_EXTENSIONS = new Set([".md", ".mdx"]);
+/** Frontmatter keys a date may be written under, in precedence order. */
+const DATE_KEYS = [
+    "published_at",
+    "publishedAt",
+    "date",
+    "created_at",
+    "createdAt",
+    "updated_at",
+    "updatedAt",
+];
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -39,7 +51,7 @@ function parseDate(value) {
     const date = new Date(text);
     return Number.isNaN(date.getTime()) ? undefined : date;
 }
-function makeDateKey(value, date) {
+function makeDateKey(value, date, timeZone) {
     const text = asText(value);
     const explicitDate = text?.match(/^\d{4}-\d{2}-\d{2}/)?.[0];
     if (explicitDate) {
@@ -50,8 +62,9 @@ function makeDateKey(value, date) {
     }
     if (!date)
         return "undated";
+    // The "en-US" formatter only produces the numeric parts that are read back below.
     const parts = new Intl.DateTimeFormat("en-US", {
-        timeZone: "Asia/Shanghai",
+        timeZone,
         year: "numeric",
         month: "2-digit",
         day: "2-digit",
@@ -61,15 +74,16 @@ function makeDateKey(value, date) {
     const day = parts.find((part) => part.type === "day").value;
     return `${year.padStart(4, "0")}-${month}-${day}`;
 }
-function makeTimeLabel(value, date) {
+function makeTimeLabel(value, date, timeZone) {
     const text = asText(value);
     if (text) {
         return text.match(/(?:T|\s)(\d{2}:\d{2})/)?.[1] ?? "";
     }
     if (!date)
         return "";
+    // "zh-CN" with hour12 false is only the way to print a 24-hour HH:mm; it is not a display locale.
     return new Intl.DateTimeFormat("zh-CN", {
-        timeZone: "Asia/Shanghai",
+        timeZone,
         hour: "2-digit",
         minute: "2-digit",
         hour12: false,
@@ -174,6 +188,99 @@ function makeSlug(sourcePath, sectionDirectory) {
         .split(sep)
         .join("/");
 }
+/** Canonical tag by lower-cased file-name suffix, for the locales a content tree may carry. */
+function localeSuffixes(locales) {
+    const suffixes = new Map();
+    if (!locales)
+        return suffixes;
+    for (const tag of [locales.source, ...(locales.targets ?? [])]) {
+        suffixes.set(tag.toLowerCase(), tag);
+    }
+    return suffixes;
+}
+/**
+ * Split a configured locale off the last segment of a slug. The suffix is read only when it
+ * names a configured locale, so `notes.v2.md` keeps its slug and `notes.fr.md` is French.
+ */
+function splitLocaleSuffix(slug, suffixes) {
+    const slash = slug.lastIndexOf("/");
+    const name = slug.slice(slash + 1);
+    const dot = name.lastIndexOf(".");
+    if (dot <= 0)
+        return { slug };
+    const locale = suffixes.get(name.slice(dot + 1).toLowerCase());
+    if (locale === undefined)
+        return { slug };
+    return { slug: `${slug.slice(0, slash + 1)}${name.slice(0, dot)}`, locale };
+}
+/**
+ * The provenance hash of an original: the first 12 hex characters of SHA-256 over its resolved
+ * title, a newline, and its body with line endings normalised to LF.
+ */
+export function translationHash(item) {
+    return createHash("sha256")
+        .update(`${item.title}\n${item.body.replaceAll("\r\n", "\n")}`)
+        .digest("hex")
+        .slice(0, 12);
+}
+/** The `translation` frontmatter block, when it has the expected shape. */
+export function translationRecord(metadata) {
+    const value = metadata.translation;
+    if (!isRecord(value))
+        return {};
+    return {
+        source: typeof value.source === "string" ? value.source : undefined,
+        reviewed: value.reviewed === true,
+    };
+}
+/** A translation inherits the date, tags and category of its original unless it sets them. */
+function inheritFromOriginal(item, original) {
+    if (metadataValue(item.metadata, DATE_KEYS) === undefined) {
+        item.date = original.date;
+        item.dateKey = original.dateKey;
+        item.timeLabel = original.timeLabel;
+    }
+    if (metadataValue(item.metadata, ["tags"]) === undefined)
+        item.tags = [...original.tags];
+    if (item.metadata.category === undefined && original.metadata.category !== undefined) {
+        item.metadata.category = original.metadata.category;
+    }
+}
+/**
+ * Group items that share a slug into translation sets. With a source-locale member it is the
+ * original and the others record provenance against it; without one every member is an original
+ * in its own language and none is stale.
+ */
+function pairTranslations(items, source) {
+    const sets = new Map();
+    for (const item of items) {
+        const key = `${item.kind}\u0000${item.slug}`;
+        const members = sets.get(key) ?? [];
+        members.push(item);
+        sets.set(key, members);
+    }
+    const originals = [];
+    for (const members of sets.values()) {
+        members.sort((left, right) => left.locale.localeCompare(right.locale));
+        const original = members.find((member) => member.locale === source);
+        if (!original) {
+            originals.push(...members);
+            continue;
+        }
+        original.translations = members.filter((member) => member !== original);
+        for (const translation of original.translations) {
+            translation.original = original;
+            translation.translatedFrom = translationRecord(translation.metadata).source;
+            translation.translationState =
+                translation.translatedFrom === translationHash(original) ? "current" : "stale";
+            inheritFromOriginal(translation, original);
+        }
+        originals.push(original);
+    }
+    return originals.sort((left, right) => {
+        return (right.date?.getTime() ?? 0) - (left.date?.getTime() ?? 0);
+    });
+}
 function normalizeSlugPrefix(prefix) {
     const normalized = (prefix ?? "")
         .replaceAll("\\", "/")
@@ -259,22 +366,26 @@ async function loadSectionFromSource(source, kind, options) {
     if (assetRoots.has(sectionDirectory))
         return [];
     const sourceFiles = await collectFiles(sectionDirectory, assetRoots, mapping !== undefined);
+    const timeZone = options.timeZone ?? DEFAULT_TIME_ZONE;
+    const sourceLocale = options.locales?.source ?? "en";
+    const suffixes = localeSuffixes(options.locales);
     const items = [];
+    const seen = new Map();
     for (const sourcePath of sourceFiles) {
         if (isDraft(sourcePath, sectionDirectory, kind))
             continue;
         const sourceText = await readFile(sourcePath, "utf8");
         const document = parseFrontmatter(sourceText);
-        const slug = withSlugPrefix(source.slugPrefix, makeSlug(sourcePath, sectionDirectory));
-        const dateValue = metadataValue(document.metadata, [
-            "published_at",
-            "publishedAt",
-            "date",
-            "created_at",
-            "createdAt",
-            "updated_at",
-            "updatedAt",
-        ]);
+        const fileSlug = withSlugPrefix(source.slugPrefix, makeSlug(sourcePath, sectionDirectory));
+        const { slug, locale: suffixLocale } = splitLocaleSuffix(fileSlug, suffixes);
+        const locale = suffixLocale ?? sourceLocale;
+        const key = `${locale}\u0000${slug}`;
+        const clash = seen.get(key);
+        if (clash !== undefined) {
+            throw new Error(`Duplicate ${kind} "${slug}" for locale "${locale}": ${clash} and ${sourcePath}`);
+        }
+        seen.set(key, sourcePath);
+        const dateValue = metadataValue(document.metadata, DATE_KEYS);
         const date = parseDate(dateValue) ?? (await stat(sourcePath)).mtime;
         const bodyWithoutLeadingHeading = document.body.replace(/^\s*#\s+.+?(?:\r?\n|$)+/, "");
         const plainText = stripMarkdown(bodyWithoutLeadingHeading);
@@ -290,11 +401,14 @@ async function loadSectionFromSource(source, kind, options) {
             html,
             metadata: document.metadata,
             date,
-            dateKey: makeDateKey(dateValue, date),
-            timeLabel: makeTimeLabel(dateValue, date),
+            dateKey: makeDateKey(dateValue, date, timeZone),
+            timeLabel: makeTimeLabel(dateValue, date, timeZone),
             tags: getTags(document.metadata),
             readingMinutes: getReadingMinutes(plainText),
             characterCount: plainText.length,
+            locale,
+            ...(suffixLocale === undefined ? {} : { previousSlug: fileSlug }),
+            translations: [],
         });
     }
     return items;
@@ -305,17 +419,44 @@ export async function loadSection(sources, kind, options = {}) {
     for (const source of normalizeContentSources(sources)) {
         const items = await loadSectionFromSource(source, kind, options);
         for (const item of items) {
-            if (merged.has(item.slug)) {
+            // Pairing happens after the overlay, so a translation and its original are different keys.
+            const key = `${item.locale}\u0000${item.slug}`;
+            if (merged.has(key)) {
                 if (duplicatePolicy === "error")
                     throw duplicateContentError(kind, item.slug);
                 continue;
             }
-            merged.set(item.slug, item);
+            merged.set(key, item);
         }
     }
-    return [...merged.values()].sort((left, right) => {
-        return (right.date?.getTime() ?? 0) - (left.date?.getTime() ?? 0);
-    });
+    return pairTranslations([...merged.values()], options.locales?.source ?? "en");
+}
+/**
+ * Every item written in one locale: the originals in that language and the translations of
+ * originals written in another one. These are the pages a locale's tree publishes.
+ */
+export function localizedItems(originals, locale) {
+    return originals
+        .flatMap((original) => [original, ...original.translations])
+        .filter((item) => item.locale === locale)
+        .sort((left, right) => (right.date?.getTime() ?? 0) - (left.date?.getTime() ?? 0));
+}
+/**
+ * The entries a locale's tree lists: its own pages, and the original of anything not translated
+ * into it — marked with the original's language and linked to where it is published.
+ */
+export function treeItems(originals, locale, options) {
+    const items = [];
+    for (const original of originals) {
+        const translation = original.translations.find((item) => item.locale === locale);
+        if (original.locale === locale)
+            items.push(original);
+        else if (translation)
+            items.push(translation);
+        else if (options.untranslated === "link")
+            items.push(original);
+    }
+    return items.sort((left, right) => (right.date?.getTime() ?? 0) - (left.date?.getTime() ?? 0));
 }
 export function withoutLeadingHeading(html) {
     return html.replace(/^\s*<h1>.*?<\/h1>\s*/s, "");

package/dist/src/identity.d.ts

@@ -40,5 +40,17 @@ export interface SiteIdentity {
         about?: string;
     };
     about?: SiteAbout;
+    /**
+     * Public origin of the site, without a path: `https://example.com`. It is validated and stored
+     * without a trailing slash; later releases use it for absolute alternate and canonical links.
+     */
+    url?: string;
+    /**
+     * IANA time zone that turns a date with a time into a day key and an `HH:mm` label. Defaults to
+     * `Asia/Shanghai`, the value earlier releases hard-coded, so existing day keys do not move.
+     */
+    timeZone?: string;
 }
+/** The time zone date keys and time labels use when a site sets none. */
+export declare const DEFAULT_TIME_ZONE = "Asia/Shanghai";
 export declare const DEFAULT_SITE: SiteIdentity;

package/dist/src/identity.js

@@ -1,3 +1,5 @@
+/** The time zone date keys and time labels use when a site sets none. */
+export const DEFAULT_TIME_ZONE = "Asia/Shanghai";
 export const DEFAULT_SITE = {
     name: "Meowpress site",
     id: "meowpress",

package/dist/src/index.d.ts

@@ -1,5 +1,8 @@
-export { collectContentAssets, collectAssetFiles, isDraftAsset, loadSection, normalizeContentSources, type ContentItem, type ContentAsset, type ContentKind, type ContentSource, type ContentSourceInput, type DuplicateContentPolicy, type LoadSectionOptions, } from "./content.js";
-export { buildSite, meowSite, type ResolvedSiteConfig, type SiteConfig } from "./build.js";
+export { collectContentAssets, collectAssetFiles, isDraftAsset, loadSection, localizedItems, normalizeContentSources, translationHash, treeItems, type ContentItem, type ContentAsset, type ContentKind, type ContentLocales, type ContentSource, type ContentSourceInput, type DuplicateContentPolicy, type LoadSectionOptions, type TranslationRecord, type TranslationState, } from "./content.js";
+export { buildSite, meowSite, type ResolvedLocaleTarget, type ResolvedLocales, type ResolvedSiteConfig, type SiteConfig, type SiteLocales, } from "./build.js";
+export { contentUrl, createPageLocale, localePath, type LocaleEntry, type PageLocale, } from "./locale.js";
+export { themeMessages } from "./messages.js";
+export { contentRoute, formatReport, siteCopyMessages, stampTranslation, translationReport, type ContentWorkItem, type LocaleWork, type ManifestPage, type ManifestSitePage, type TranslationReport, } from "./translations.js";
 export { aboutPage, agentMarkdown, homePage, listPage, llmText, postPage, skillPage, skillsIndexPage, thoughtPage, } from "./site.js";
 export { DEFAULT_SITE, type SiteAbout, type SiteIdentity, type SiteProfileLink } from "./identity.js";
 export { blogFonts, blogTheme } from "./theme.js";

package/dist/src/index.js

@@ -1,5 +1,8 @@
-export { collectContentAssets, collectAssetFiles, isDraftAsset, loadSection, normalizeContentSources, } from "./content.js";
-export { buildSite, meowSite } from "./build.js";
+export { collectContentAssets, collectAssetFiles, isDraftAsset, loadSection, localizedItems, normalizeContentSources, translationHash, treeItems, } from "./content.js";
+export { buildSite, meowSite, } from "./build.js";
+export { contentUrl, createPageLocale, localePath, } from "./locale.js";
+export { themeMessages } from "./messages.js";
+export { contentRoute, formatReport, siteCopyMessages, stampTranslation, translationReport, } from "./translations.js";
 export { aboutPage, agentMarkdown, homePage, listPage, llmText, postPage, skillPage, skillsIndexPage, thoughtPage, } from "./site.js";
 export { DEFAULT_SITE } from "./identity.js";
 export { blogFonts, blogTheme } from "./theme.js";

package/dist/src/locale.d.ts

@@ -0,0 +1,71 @@
+import type { Child } from "meowjsx";
+import { type Catalog, type CreateI18nOptions, type I18n, type MessageDescriptor, type MessageParams, type MissingMessage, type RichPart } from "meowjsx/i18n";
+/**
+ * An instance for the built-in theme: the same as `createI18n`, except that `t` and `t.rich`
+ * refuse any source that is not declared in `themeMessages`. The theme and any component it
+ * renders through `I18nProvider` therefore cannot carry a sentence the work list does not know.
+ * `lookup` is not checked: it translates site-owned copy that no table can list.
+ */
+export declare function createThemeI18n(options: CreateI18nOptions): I18n;
+/** A locale the site publishes, as a page sees it for the language switch and alternate links. */
+export interface LocaleEntry {
+    /** Canonical tag, written to `lang` and `hreflang`. */
+    tag: string;
+    /** URL segment, "" for the source tree. */
+    segment: string;
+    /** The language's own name, shown by the language switch. */
+    label: string;
+    isSource: boolean;
+}
+/**
+ * What a page needs to know about the locale it is rendered for. Page functions receive it
+ * explicitly because they are plain functions: the ambient `t` works only in component bodies.
+ */
+export interface PageLocale {
+    /** Canonical tag, written to `<html lang>`. */
+    readonly tag: string;
+    readonly direction: "ltr" | "rtl";
+    /** URL segment of a target locale (the lower-cased tag), or "" for the source locale. */
+    readonly segment: string;
+    /** The language site-owned copy and content are written in. */
+    readonly source: string;
+    /** The tree that keeps the unprefixed routes. */
+    readonly isSource: boolean;
+    /** Every locale the site publishes, the source first; one entry on a single-locale site. */
+    readonly entries: readonly LocaleEntry[];
+    /** Whether an unreviewed translation says so on the page. */
+    readonly disclosure: boolean;
+    /** Theme sentences. Its source language is always English. */
+    readonly i18n: I18n;
+    /** Site-owned copy (name, description, About, 404) in this locale, written in `source`. */
+    copy(text: string): string;
+}
+export interface PageLocaleOptions {
+    tag: string;
+    source: string;
+    segment: string;
+    catalogs: Readonly<Record<string, Catalog>>;
+    timeZone?: string;
+    onMissing?: (miss: MissingMessage) => void;
+    entries?: readonly LocaleEntry[];
+    disclosure?: boolean;
+}
+export declare function createPageLocale(options: PageLocaleOptions): PageLocale;
+/** The locale every page function uses when the caller passes none. */
+export declare function defaultPageLocale(): PageLocale;
+/** The URL of an internal route for a locale. Every internal link of the theme goes through
+ * it. A route that exists only in the source tree (skills) keeps its source URL. */
+export declare function localePath(locale: PageLocale, path: string): string;
+/**
+ * The URL of a content item, in the tree of the language it is written in. An original in the
+ * source locale keeps the unprefixed route; anything else lives under its locale's segment.
+ */
+export declare function contentUrl(locale: PageLocale, item: {
+    kind: string;
+    slug: string;
+    locale: string;
+}): string;
+/** The text of a message that carries named tags, with the parts supplied by the page. */
+export declare function richMessage(locale: PageLocale, message: MessageDescriptor, parts: {
+    readonly [name: string]: RichPart;
+}, params?: MessageParams): Child;