@orthacms/i18n-server 0.0.0-reserve.0

package/dist/lib/domain/value-objects/locale-set.d.ts

@@ -0,0 +1,41 @@
+import { Locale, type LocaleInput } from './locale';
+/**
+ * The configured set of {@link Locale}s — the value object that owns the
+ * **collection invariants** no single locale can guard: a non-empty set,
+ * unique slugs, and **exactly one default**. Because construction guarantees a
+ * default member, {@link default} never returns undefined, and {@link remove}
+ * refuses to drop the default. Preserves config (display) order.
+ */
+export declare class LocaleSet {
+    private readonly locales;
+    private readonly bySlug;
+    private readonly _default;
+    private constructor();
+    /**
+     * Builds a {@link LocaleSet} from already-validated {@link Locale}s,
+     * enforcing the collection invariants ({@link InvalidLocaleSetError} on a
+     * violation).
+     */
+    static create(locales: readonly Locale[]): LocaleSet;
+    /**
+     * Builds a {@link LocaleSet} from the plugin's raw config defs — validating
+     * each locale's format ({@link Locale.create}) then the collection. The one
+     * entry point the plugin factory uses, so every locale rule lives here.
+     */
+    static fromDefs(defs: readonly LocaleInput[]): LocaleSet;
+    /** All configured locales, in config (display) order. */
+    all(): Locale[];
+    /** One locale by slug, or undefined. */
+    get(slug: string): Locale | undefined;
+    /** Whether `slug` names a configured locale. */
+    has(slug: string): boolean;
+    /** The default locale (exactly one exists). */
+    default(): Locale;
+    /**
+     * The set with `slug` removed — guarding that only a **member** can be
+     * removed and that the **default is never removed** (either throws
+     * {@link InvalidLocaleSetError}).
+     */
+    remove(slug: string): LocaleSet;
+}
+//# sourceMappingURL=locale-set.d.ts.map

package/dist/lib/domain/value-objects/locale-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-set.d.ts","sourceRoot":"","sources":["../../../../src/lib/domain/value-objects/locale-set.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,UAAU,CAAC;AAEpD;;;;;;GAMG;AACH,qBAAa,SAAS;IAIE,OAAO,CAAC,QAAQ,CAAC,OAAO;IAH5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC,OAAO;IAUP;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS;IAwBpD;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,GAAG,SAAS;IAIxD,yDAAyD;IACzD,GAAG,IAAI,MAAM,EAAE;IAIf,wCAAwC;IACxC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIrC,gDAAgD;IAChD,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,+CAA+C;IAC/C,OAAO,IAAI,MAAM;IAIjB;;;;OAIG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS;CAgBlC"}

package/dist/lib/domain/value-objects/locale-set.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleSet = void 0;
+const errors_1 = require("../errors");
+const locale_1 = require("./locale");
+/**
+ * The configured set of {@link Locale}s — the value object that owns the
+ * **collection invariants** no single locale can guard: a non-empty set,
+ * unique slugs, and **exactly one default**. Because construction guarantees a
+ * default member, {@link default} never returns undefined, and {@link remove}
+ * refuses to drop the default. Preserves config (display) order.
+ */
+class LocaleSet {
+    locales;
+    bySlug;
+    _default;
+    constructor(locales) {
+        this.locales = locales;
+        this.bySlug = new Map(locales.map((locale) => [locale.slug, locale]));
+        // `create` guarantees exactly one; the guard is for type flow.
+        const fallback = locales.find((locale) => locale.isDefault);
+        if (!fallback) {
+            throw new errors_1.InvalidLocaleSetError('A locale set has no default.');
+        }
+        this._default = fallback;
+    }
+    /**
+     * Builds a {@link LocaleSet} from already-validated {@link Locale}s,
+     * enforcing the collection invariants ({@link InvalidLocaleSetError} on a
+     * violation).
+     */
+    static create(locales) {
+        if (locales.length === 0) {
+            throw new errors_1.InvalidLocaleSetError('A locale set requires at least one locale.');
+        }
+        const seen = new Set();
+        for (const locale of locales) {
+            if (seen.has(locale.slug)) {
+                throw new errors_1.InvalidLocaleSetError(`Duplicate locale slug "${locale.slug}".`);
+            }
+            seen.add(locale.slug);
+        }
+        const defaults = locales.filter((locale) => locale.isDefault);
+        if (defaults.length !== 1) {
+            throw new errors_1.InvalidLocaleSetError(`Exactly one locale must set isDefault (got ${defaults.length}).`);
+        }
+        return new LocaleSet(locales);
+    }
+    /**
+     * Builds a {@link LocaleSet} from the plugin's raw config defs — validating
+     * each locale's format ({@link Locale.create}) then the collection. The one
+     * entry point the plugin factory uses, so every locale rule lives here.
+     */
+    static fromDefs(defs) {
+        return LocaleSet.create(defs.map((def) => locale_1.Locale.create(def)));
+    }
+    /** All configured locales, in config (display) order. */
+    all() {
+        return [...this.locales];
+    }
+    /** One locale by slug, or undefined. */
+    get(slug) {
+        return this.bySlug.get(slug);
+    }
+    /** Whether `slug` names a configured locale. */
+    has(slug) {
+        return this.bySlug.has(slug);
+    }
+    /** The default locale (exactly one exists). */
+    default() {
+        return this._default;
+    }
+    /**
+     * The set with `slug` removed — guarding that only a **member** can be
+     * removed and that the **default is never removed** (either throws
+     * {@link InvalidLocaleSetError}).
+     */
+    remove(slug) {
+        const target = this.bySlug.get(slug);
+        if (!target) {
+            throw new errors_1.InvalidLocaleSetError(`Locale "${slug}" is not a member.`);
+        }
+        if (target.isDefault) {
+            throw new errors_1.InvalidLocaleSetError(`Cannot remove the default locale "${slug}".`);
+        }
+        return LocaleSet.create(this.locales.filter((locale) => locale.slug !== slug));
+    }
+}
+exports.LocaleSet = LocaleSet;

package/dist/lib/domain/value-objects/locale.d.ts

@@ -0,0 +1,55 @@
+import { type LocaleDir } from '../../i18n.constants';
+/** The primitive shape a {@link Locale} is built from (the plugin's config). */
+export interface LocaleInput {
+    /** Machine slug stored on entry rows (e.g. `en`, `de`, `pt-br`). */
+    slug: string;
+    /** Human display name (e.g. "English"). */
+    name: string;
+    /** Whether this is the default locale. */
+    isDefault?: boolean;
+    /**
+     * Text direction of content written in this locale. Optional in config —
+     * omitted, it is **inferred from the slug** (`ar`, `he`, `fa`, … → `rtl`),
+     * so a host adding an RTL language gets the right answer without saying so.
+     * Declare it to override the inference (a transliterated variant, say).
+     */
+    dir?: LocaleDir;
+}
+/**
+ * A single configured locale — the value object that owns the **slug format
+ * rule** (the lowercase BCP-47-ish shape that used to live inline on the
+ * plugin factory) and a non-blank display name. Constructing one guarantees a
+ * well-formed locale, so every other i18n path can handle a `Locale` instead
+ * of a raw string it must re-validate.
+ */
+export declare class Locale {
+    private readonly _slug;
+    private readonly _name;
+    private readonly _isDefault;
+    private readonly _dir;
+    private constructor();
+    /**
+     * Builds a {@link Locale}, rejecting a malformed slug, a blank name, or a
+     * `dir` that is neither `ltr` nor `rtl` with {@link InvalidLocaleError}
+     * (the plugin factory surfaces it at construction, request paths as HTTP
+     * 400). An omitted `dir` is inferred from the slug rather than assumed
+     * `ltr`, so configuring an RTL language is one line and not a silent
+     * accessibility failure.
+     */
+    static create(input: LocaleInput): Locale;
+    /** The validated locale slug. */
+    get slug(): string;
+    /** The display name. */
+    get name(): string;
+    /** Whether this is the default locale. */
+    get isDefault(): boolean;
+    /**
+     * Text direction of content in this locale — always resolved (declared or
+     * inferred), never undefined, so a consumer can set `dir` unconditionally
+     * instead of guessing.
+     */
+    get dir(): LocaleDir;
+    /** Structural equality on the slug. */
+    equals(other: Locale): boolean;
+}
+//# sourceMappingURL=locale.d.ts.map

package/dist/lib/domain/value-objects/locale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale.d.ts","sourceRoot":"","sources":["../../../../src/lib/domain/value-objects/locale.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,KAAK,SAAS,EACjB,MAAM,sBAAsB,CAAC;AAG9B,gFAAgF;AAChF,MAAM,WAAW,WAAW;IACxB,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,GAAG,CAAC,EAAE,SAAS,CAAC;CACnB;AAED;;;;;;GAMG;AACH,qBAAa,MAAM;IAEX,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,IAAI;IAJzB,OAAO;IAOP;;;;;;;OAOG;IACH,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM;IA4BzC,iCAAiC;IACjC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,wBAAwB;IACxB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,0CAA0C;IAC1C,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED;;;;OAIG;IACH,IAAI,GAAG,IAAI,SAAS,CAEnB;IAED,uCAAuC;IACvC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAGjC"}

package/dist/lib/domain/value-objects/locale.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Locale = void 0;
+const i18n_constants_1 = require("../../i18n.constants");
+const errors_1 = require("../errors");
+/**
+ * A single configured locale — the value object that owns the **slug format
+ * rule** (the lowercase BCP-47-ish shape that used to live inline on the
+ * plugin factory) and a non-blank display name. Constructing one guarantees a
+ * well-formed locale, so every other i18n path can handle a `Locale` instead
+ * of a raw string it must re-validate.
+ */
+class Locale {
+    _slug;
+    _name;
+    _isDefault;
+    _dir;
+    constructor(_slug, _name, _isDefault, _dir) {
+        this._slug = _slug;
+        this._name = _name;
+        this._isDefault = _isDefault;
+        this._dir = _dir;
+    }
+    /**
+     * Builds a {@link Locale}, rejecting a malformed slug, a blank name, or a
+     * `dir` that is neither `ltr` nor `rtl` with {@link InvalidLocaleError}
+     * (the plugin factory surfaces it at construction, request paths as HTTP
+     * 400). An omitted `dir` is inferred from the slug rather than assumed
+     * `ltr`, so configuring an RTL language is one line and not a silent
+     * accessibility failure.
+     */
+    static create(input) {
+        const { slug, name, isDefault, dir } = input;
+        if (!i18n_constants_1.LOCALE_SLUG_RE.test(slug) ||
+            slug.length > i18n_constants_1.LOCALE_SLUG_MAX_LENGTH) {
+            throw new errors_1.InvalidLocaleError(`Locale slug "${slug}" is invalid — lowercase 2-3 letter ` +
+                `primary tag with optional "-" subtags (e.g. "en", "pt-br").`);
+        }
+        if (!name.trim()) {
+            throw new errors_1.InvalidLocaleError(`Locale "${slug}" has an empty name.`);
+        }
+        if (dir !== undefined && !i18n_constants_1.LOCALE_DIR.includes(dir)) {
+            throw new errors_1.InvalidLocaleError(`Locale "${slug}" has an invalid dir "${dir}" — ` +
+                `expected ${i18n_constants_1.LOCALE_DIR.map((d) => `"${d}"`).join(' or ')}.`);
+        }
+        return new Locale(slug, name, isDefault ?? false, dir ?? (0, i18n_constants_1.inferLocaleDir)(slug));
+    }
+    /** The validated locale slug. */
+    get slug() {
+        return this._slug;
+    }
+    /** The display name. */
+    get name() {
+        return this._name;
+    }
+    /** Whether this is the default locale. */
+    get isDefault() {
+        return this._isDefault;
+    }
+    /**
+     * Text direction of content in this locale — always resolved (declared or
+     * inferred), never undefined, so a consumer can set `dir` unconditionally
+     * instead of guessing.
+     */
+    get dir() {
+        return this._dir;
+    }
+    /** Structural equality on the slug. */
+    equals(other) {
+        return this._slug === other._slug;
+    }
+}
+exports.Locale = Locale;

package/dist/lib/i18n.constants.d.ts

@@ -0,0 +1,33 @@
+/** Shared constants of the i18n server plugin. */
+/**
+ * Valid locale slugs: lowercase 2–3 letter primary tag, optional `-`-joined
+ * alphanumeric subtags (`en`, `de`, `pt-br`, `zh-hans`).
+ */
+export declare const LOCALE_SLUG_RE: RegExp;
+/** Longest accepted locale slug (mirrors BCP-47's practical bound). */
+export declare const LOCALE_SLUG_MAX_LENGTH = 35;
+/** DI token for the validated {@link I18nPluginConfig}. */
+export declare const I18N_CONFIG: unique symbol;
+/** Cap on `groupIds` per locale-summary batch request. */
+export declare const LOCALE_SUMMARY_MAX_GROUPS = 100;
+/** The `localeFallback` value that widens a list to the default locale. */
+export declare const LOCALE_FALLBACK_DEFAULT = "default";
+/**
+ * The two text directions a locale can declare — the values of the HTML `dir`
+ * attribute a consumer sets on the editor surface, the preview, and the
+ * published page (WCAG 1.3.2 Meaningful Sequence, 3.1.2 Language of Parts).
+ */
+export declare const LOCALE_DIR: readonly ["ltr", "rtl"];
+/** A configured locale's text direction. */
+export type LocaleDir = (typeof LOCALE_DIR)[number];
+/**
+ * The text direction implied by a locale slug, used when the host's config
+ * declares none — so adding `{ slug: 'ar', name: 'العربية' }` yields an RTL
+ * locale without the host having to know it, while an explicit `dir` always
+ * wins.
+ *
+ * An explicit script subtag decides first (`az-arab` → `rtl`, `sr-latn` →
+ * `ltr`); otherwise the primary language subtag does; otherwise `ltr`.
+ */
+export declare function inferLocaleDir(slug: string): LocaleDir;
+//# sourceMappingURL=i18n.constants.d.ts.map

package/dist/lib/i18n.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.constants.d.ts","sourceRoot":"","sources":["../../src/lib/i18n.constants.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAElD;;;GAGG;AACH,eAAO,MAAM,cAAc,QAA8B,CAAC;AAE1D,uEAAuE;AACvE,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC,2DAA2D;AAC3D,eAAO,MAAM,WAAW,eAAwB,CAAC;AAEjD,0DAA0D;AAC1D,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,2EAA2E;AAC3E,eAAO,MAAM,uBAAuB,YAAY,CAAC;AAEjD;;;;GAIG;AACH,eAAO,MAAM,UAAU,yBAA0B,CAAC;AAElD,4CAA4C;AAC5C,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAmDpD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAOtD"}

package/dist/lib/i18n.constants.js

@@ -0,0 +1,89 @@
+"use strict";
+/** Shared constants of the i18n server plugin. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCALE_DIR = exports.LOCALE_FALLBACK_DEFAULT = exports.LOCALE_SUMMARY_MAX_GROUPS = exports.I18N_CONFIG = exports.LOCALE_SLUG_MAX_LENGTH = exports.LOCALE_SLUG_RE = void 0;
+exports.inferLocaleDir = inferLocaleDir;
+/**
+ * Valid locale slugs: lowercase 2–3 letter primary tag, optional `-`-joined
+ * alphanumeric subtags (`en`, `de`, `pt-br`, `zh-hans`).
+ */
+exports.LOCALE_SLUG_RE = /^[a-z]{2,3}(-[a-z0-9]+)*$/;
+/** Longest accepted locale slug (mirrors BCP-47's practical bound). */
+exports.LOCALE_SLUG_MAX_LENGTH = 35;
+/** DI token for the validated {@link I18nPluginConfig}. */
+exports.I18N_CONFIG = Symbol('I18N_CONFIG');
+/** Cap on `groupIds` per locale-summary batch request. */
+exports.LOCALE_SUMMARY_MAX_GROUPS = 100;
+/** The `localeFallback` value that widens a list to the default locale. */
+exports.LOCALE_FALLBACK_DEFAULT = 'default';
+/**
+ * The two text directions a locale can declare — the values of the HTML `dir`
+ * attribute a consumer sets on the editor surface, the preview, and the
+ * published page (WCAG 1.3.2 Meaningful Sequence, 3.1.2 Language of Parts).
+ */
+exports.LOCALE_DIR = ['ltr', 'rtl'];
+/**
+ * Script subtags that decide direction outright, whichever language carries
+ * them — `sr-latn` is LTR and `az-arab` is RTL regardless of what the language
+ * alone would imply. Checked before {@link RTL_LANGUAGE_SUBTAGS}, since an
+ * explicit script is the more specific statement.
+ */
+const RTL_SCRIPT_SUBTAGS = new Set([
+    'adlm',
+    'arab',
+    'aran',
+    'hebr',
+    'nkoo',
+    'rohg',
+    'syrc',
+    'thaa',
+    'yezi'
+]);
+/** Script subtags that force LTR even on a language written RTL elsewhere. */
+const LTR_SCRIPT_SUBTAGS = new Set([
+    'cyrl',
+    'latn',
+    'hans',
+    'hant'
+]);
+/**
+ * Primary language subtags written right-to-left. Deliberately a short,
+ * conservative list of the languages a CMS is realistically configured with,
+ * not a mirror of CLDR: it only supplies the **default** for a locale that
+ * declares no `dir`, and a host with an exotic script says so explicitly.
+ */
+const RTL_LANGUAGE_SUBTAGS = new Set([
+    'ar', // Arabic
+    'arc', // Aramaic
+    'ckb', // Central Kurdish
+    'dv', // Divehi
+    'fa', // Persian
+    'he', // Hebrew
+    'ks', // Kashmiri
+    'ku', // Kurdish
+    'nqo', // N'Ko
+    'ps', // Pashto
+    'sd', // Sindhi
+    'ug', // Uyghur
+    'ur', // Urdu
+    'yi' // Yiddish
+]);
+/**
+ * The text direction implied by a locale slug, used when the host's config
+ * declares none — so adding `{ slug: 'ar', name: 'العربية' }` yields an RTL
+ * locale without the host having to know it, while an explicit `dir` always
+ * wins.
+ *
+ * An explicit script subtag decides first (`az-arab` → `rtl`, `sr-latn` →
+ * `ltr`); otherwise the primary language subtag does; otherwise `ltr`.
+ */
+function inferLocaleDir(slug) {
+    const parts = slug.toLowerCase().split('-');
+    for (const part of parts.slice(1)) {
+        if (RTL_SCRIPT_SUBTAGS.has(part))
+            return 'rtl';
+        if (LTR_SCRIPT_SUBTAGS.has(part))
+            return 'ltr';
+    }
+    return RTL_LANGUAGE_SUBTAGS.has(parts[0]) ? 'rtl' : 'ltr';
+}

package/dist/lib/i18n.module.d.ts

@@ -0,0 +1,14 @@
+import { DynamicModule } from '@nestjs/common';
+import type { I18nPluginConfig } from './types/locale';
+/**
+ * NestJS module of the i18n plugin. Registered **global** so its binding of
+ * content-server's `CONTENT_ENTRY_EXTENSION` port resolves inside the
+ * (equally global) content module without an explicit import — the same
+ * inversion as content binding identity's `CONTENT_CATALOG`, roles swapped:
+ * content declares the port, this plugin provides the implementation.
+ */
+export declare class I18nModule {
+    /** Creates the global dynamic module around a validated config. */
+    static forRoot(config: I18nPluginConfig): DynamicModule;
+}
+//# sourceMappingURL=i18n.module.d.ts.map

package/dist/lib/i18n.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.module.d.ts","sourceRoot":"","sources":["../../src/lib/i18n.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAU,MAAM,gBAAgB,CAAC;AAIvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAiBvD;;;;;;GAMG;AACH,qBACa,UAAU;IACnB,mEAAmE;IACnE,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,gBAAgB,GAAG,aAAa;CAmD1D"}

package/dist/lib/i18n.module.js

@@ -0,0 +1,82 @@
+"use strict";
+var I18nModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const content_server_1 = require("@orthacms/content-server");
+const copilot_server_1 = require("@orthacms/copilot-server");
+const i18n_constants_1 = require("./i18n.constants");
+const locale_registry_service_1 = require("./locales/services/locale-registry.service");
+const orphaned_locale_checker_1 = require("./locales/services/orphaned-locale.checker");
+const list_locales_controller_1 = require("./locales/controllers/list-locales.controller");
+const entry_locale_extension_service_1 = require("./content/services/entry-locale-extension.service");
+const locale_group_service_1 = require("./content/services/locale-group.service");
+const get_entry_locales_controller_1 = require("./content/controllers/get-entry-locales.controller");
+const locale_summary_controller_1 = require("./content/controllers/locale-summary.controller");
+const localization_coverage_query_1 = require("./insights/infrastructure/queries/localization-coverage.query");
+const localization_coverage_controller_1 = require("./insights/http/controllers/localization-coverage.controller");
+const i18n_tool_provider_1 = require("./copilot/i18n-tool.provider");
+const translation_proposal_provider_1 = require("./copilot/translation-proposal.provider");
+const translation_proposal_applier_1 = require("./copilot/translation-proposal.applier");
+/**
+ * NestJS module of the i18n plugin. Registered **global** so its binding of
+ * content-server's `CONTENT_ENTRY_EXTENSION` port resolves inside the
+ * (equally global) content module without an explicit import — the same
+ * inversion as content binding identity's `CONTENT_CATALOG`, roles swapped:
+ * content declares the port, this plugin provides the implementation.
+ */
+let I18nModule = I18nModule_1 = class I18nModule {
+    /** Creates the global dynamic module around a validated config. */
+    static forRoot(config) {
+        return {
+            module: I18nModule_1,
+            global: true,
+            controllers: [
+                list_locales_controller_1.ListLocalesController,
+                // Reads only: the per-entry locale panel and the records
+                // table's batched group summary. Sibling *creation* goes
+                // through `POST /api/content/:type` with a `localeGroupId`
+                // (the extension stamps the group), so this plugin owns no
+                // entry-write route.
+                get_entry_locales_controller_1.GetEntryLocalesController,
+                locale_summary_controller_1.LocaleSummaryController,
+                // The Insights read-model. Mounted under `insights/` with
+                // content's and media's, not this plugin's `i18n/` prefix —
+                // one card, one endpoint, grouped by what they are.
+                localization_coverage_controller_1.LocalizationCoverageController
+            ],
+            providers: [
+                { provide: i18n_constants_1.I18N_CONFIG, useValue: config },
+                locale_registry_service_1.LocaleRegistryService,
+                // Boot-time diff of the configured locale set against what the
+                // data actually holds — the one locale change (a removal) that
+                // otherwise fails silently.
+                orphaned_locale_checker_1.OrphanedLocaleChecker,
+                locale_group_service_1.LocaleGroupService,
+                localization_coverage_query_1.LocalizationCoverageQuery,
+                entry_locale_extension_service_1.EntryLocaleExtensionService,
+                {
+                    provide: content_server_1.CONTENT_ENTRY_EXTENSION,
+                    useExisting: entry_locale_extension_service_1.EntryLocaleExtensionService
+                },
+                // The copilot's locale tools. Both no-op when no copilot
+                // plugin is registered — the registrar injects the registry
+                // optionally.
+                i18n_tool_provider_1.I18nCopilotToolProvider,
+                translation_proposal_provider_1.TranslationProposalToolProvider,
+                // The appliers for the kinds those propose tools produce —
+                // one per kind, next to them on purpose: a missing applier
+                // surfaces only when a change is carried out.
+                translation_proposal_applier_1.TranslationProposalApplier,
+                translation_proposal_applier_1.BulkTranslationProposalApplier,
+                (0, copilot_server_1.copilotAppliersRegistrar)('i18n', translation_proposal_applier_1.TranslationProposalApplier, translation_proposal_applier_1.BulkTranslationProposalApplier)
+            ],
+            exports: [content_server_1.CONTENT_ENTRY_EXTENSION, locale_registry_service_1.LocaleRegistryService]
+        };
+    }
+};
+exports.I18nModule = I18nModule;
+exports.I18nModule = I18nModule = I18nModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], I18nModule);

package/dist/lib/insights/http/controllers/localization-coverage.controller.d.ts

@@ -0,0 +1,23 @@
+import { LocalizationCoverageQuery } from '../../infrastructure/queries/localization-coverage.query';
+import type { I18nCoverageView } from '../../types/i18n-insights-view';
+/**
+ * `GET /api/insights/i18n/coverage` — how much of the workspace's localized
+ * content exists in each configured locale, and how many records are fully
+ * translated, untranslated, or part-way.
+ *
+ * Mounted under `insights/` beside content's and media's widgets rather than
+ * under this plugin's own `i18n/` prefix: the Insights page's endpoints are
+ * grouped by what they are, and a reader looking for the card's data should
+ * find it next to the other cards'.
+ *
+ * Gated on `content:read` — it counts content, and a reader who may not see
+ * entries must not learn how many there are by counting the gaps. Takes no
+ * `?days=`: an untranslated record is untranslated regardless of when it was
+ * written, so a window could only hide part of the backlog.
+ */
+export declare class LocalizationCoverageController {
+    private readonly coverage;
+    constructor(coverage: LocalizationCoverageQuery);
+    localization(workspaceId: string): Promise<I18nCoverageView>;
+}
+//# sourceMappingURL=localization-coverage.controller.d.ts.map

package/dist/lib/insights/http/controllers/localization-coverage.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localization-coverage.controller.d.ts","sourceRoot":"","sources":["../../../../../src/lib/insights/http/controllers/localization-coverage.controller.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,yBAAyB,EAAE,MAAM,0DAA0D,CAAC;AACrG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAEvE;;;;;;;;;;;;;;GAcG;AACH,qBAGa,8BAA8B;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,yBAAyB;IAGhE,YAAY,CACY,WAAW,EAAE,MAAM,GACxC,OAAO,CAAC,gBAAgB,CAAC;CAG/B"}

package/dist/lib/insights/http/controllers/localization-coverage.controller.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalizationCoverageController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const identity_server_1 = require("@orthacms/identity-server");
+const workspaces_server_1 = require("@orthacms/workspaces-server");
+const localization_coverage_query_1 = require("../../infrastructure/queries/localization-coverage.query");
+/**
+ * `GET /api/insights/i18n/coverage` — how much of the workspace's localized
+ * content exists in each configured locale, and how many records are fully
+ * translated, untranslated, or part-way.
+ *
+ * Mounted under `insights/` beside content's and media's widgets rather than
+ * under this plugin's own `i18n/` prefix: the Insights page's endpoints are
+ * grouped by what they are, and a reader looking for the card's data should
+ * find it next to the other cards'.
+ *
+ * Gated on `content:read` — it counts content, and a reader who may not see
+ * entries must not learn how many there are by counting the gaps. Takes no
+ * `?days=`: an untranslated record is untranslated regardless of when it was
+ * written, so a window could only hide part of the backlog.
+ */
+let LocalizationCoverageController = class LocalizationCoverageController {
+    coverage;
+    constructor(coverage) {
+        this.coverage = coverage;
+    }
+    localization(workspaceId) {
+        return this.coverage.coverage(workspaceId);
+    }
+};
+exports.LocalizationCoverageController = LocalizationCoverageController;
+tslib_1.__decorate([
+    (0, common_1.Get)('coverage'),
+    tslib_1.__param(0, (0, workspaces_server_1.CurrentWorkspace)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], LocalizationCoverageController.prototype, "localization", null);
+exports.LocalizationCoverageController = LocalizationCoverageController = tslib_1.__decorate([
+    (0, common_1.UseGuards)(identity_server_1.PermissionsGuard, workspaces_server_1.WorkspaceGuard),
+    (0, identity_server_1.RequirePermissions)(identity_server_1.PERMISSIONS.CONTENT_READ),
+    (0, common_1.Controller)('insights/i18n'),
+    tslib_1.__metadata("design:paramtypes", [localization_coverage_query_1.LocalizationCoverageQuery])
+], LocalizationCoverageController);

package/dist/lib/insights/infrastructure/queries/localization-coverage.query.d.ts

@@ -0,0 +1,59 @@
+import { type Database } from '@orthacms/database';
+import type { ContentTypeRegistry } from '@orthacms/content-server';
+import { LocaleRegistryService } from '../../../locales/services/locale-registry.service';
+import type { I18nCoverageView } from '../../types/i18n-insights-view';
+/**
+ * Live read-model for the localization coverage widget.
+ *
+ * **This lives in i18n-server, not content-server, and that is not arbitrary.**
+ * Coverage is a question about a set the content plugin deliberately does not
+ * know: the *configured* locales. content-server owns the `locale` column's
+ * shape and nothing about what a locale means, so it can report which slugs
+ * happen to appear in the data but not which ones are missing — and "missing"
+ * is the entire widget. `LocaleRegistryService` is the source of that set, and
+ * it is here.
+ *
+ * Like content's own insights query this aggregates **on demand**, per type,
+ * with no projection: a localized collection is its own generated
+ * `content_<name>` table, so a workspace-wide answer is inherently a fan-out.
+ */
+export declare class LocalizationCoverageQuery {
+    private readonly db;
+    private readonly registry;
+    private readonly locales;
+    constructor(db: Database, registry: ContentTypeRegistry, locales: LocaleRegistryService);
+    /** Coverage across every localized content type in the workspace. */
+    coverage(workspaceId: string): Promise<I18nCoverageView>;
+    /**
+     * Records holding a row in each locale, for one type.
+     *
+     * `count(distinct locale_group_id)` rather than `count(*)`: the
+     * `(locale_group_id, locale)` unique index makes those equal in a healthy
+     * table, and the distinct keeps the figure honest against a paranoid type
+     * where the index is partial and a trashed row could otherwise be counted
+     * twice.
+     */
+    private perLocale;
+    /**
+     * How many translation groups this type has, how many are complete, and how
+     * many sit in a single language.
+     *
+     * One grouped subquery folded by an outer aggregate — the alternative,
+     * reading one row per group and counting in JS, would pull the workspace's
+     * whole content set over the wire to produce three integers.
+     */
+    private groupSpread;
+    /**
+     * Workspace scope, the soft-delete guard, **and** the configured locale set.
+     *
+     * The locale filter is what makes "complete" mean what it says. A row in a
+     * slug the host has since removed from its config is not coverage of
+     * anything, and left in it would push a group's distinct-locale count past
+     * the configured total — so a record could be over-covered and still not
+     * counted as complete. Filtering here also drops a group made entirely of
+     * such rows, which is the right answer rather than a record with zero
+     * languages.
+     */
+    private configuredScope;
+}
+//# sourceMappingURL=localization-coverage.query.d.ts.map

package/dist/lib/insights/infrastructure/queries/localization-coverage.query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localization-coverage.query.d.ts","sourceRoot":"","sources":["../../../../../src/lib/insights/infrastructure/queries/localization-coverage.query.ts"],"names":[],"mappings":"AAWA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnE,OAAO,KAAK,EAER,mBAAmB,EACtB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,qBAAqB,EAAE,MAAM,mDAAmD,CAAC;AAC1F,OAAO,KAAK,EAER,gBAAgB,EAEnB,MAAM,gCAAgC,CAAC;AAUxC;;;;;;;;;;;;;;GAcG;AACH,qBACa,yBAAyB;IAEZ,OAAO,CAAC,QAAQ,CAAC,EAAE;IACZ,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAFW,EAAE,EAAE,QAAQ,EACL,QAAQ,EAAE,mBAAmB,EACtD,OAAO,EAAE,qBAAqB;IAGnD,qEAAqE;IAC/D,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAwE9D;;;;;;;;OAQG;YACW,SAAS;IAqBvB;;;;;;;OAOG;YACW,WAAW;IAwCzB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,eAAe;CAY1B"}