@orthacms/i18n-server 0.0.0-reserve.0

package/dist/lib/content/services/locale-group.service.d.ts

@@ -0,0 +1,87 @@
+import { type Database } from '@orthacms/database';
+import type { AnyContentType, EntryStatus } from '@orthacms/content-server';
+import type { LocaleDir } from '../../i18n.constants';
+import { LocaleRegistryService } from '../../locales/services/locale-registry.service';
+/** One locale's slot in a translation group — the row, or null if missing. */
+export interface EntryLocaleItem {
+    /**
+     * The configured locale slug — a BCP-47 language tag, usable verbatim as
+     * the HTML `lang` of this translation's editor surface and preview.
+     */
+    locale: string;
+    /**
+     * This locale's text direction, so the editor can set `dir` alongside
+     * `lang` without a second call to `GET /api/i18n/locales`.
+     */
+    dir: LocaleDir;
+    /** Whether it's the configured default locale. */
+    isDefault: boolean;
+    /** The group's row in this locale, or null when not yet translated. */
+    entry: {
+        id: string;
+        /** Publish state — publishable types only. */
+        status?: EntryStatus;
+        /**
+         * ISO timestamp of when this locale last went live, or `null` if never
+         * — publishable types only. Paired with `status` it separates a
+         * never-published draft from one carrying unpublished edits over live
+         * content, which is the difference the locale switcher renders.
+         */
+        publishedAt?: string | null;
+        /** ISO last-updated timestamp. */
+        updatedAt: string;
+    } | null;
+}
+/** The `GET /api/i18n/content/:typeName/:id/locales` response envelope. */
+export interface EntryLocalesView {
+    /** The entry's translation-group id. */
+    localeGroupId: string;
+    /** One item per **configured** locale, in config order. */
+    items: EntryLocaleItem[];
+}
+/** One group member in a batch summary. */
+export interface LocaleSummaryItem {
+    locale: string;
+    entryId: string;
+    /** Publish state — publishable types only. */
+    status?: EntryStatus;
+    /** When this locale last went live, or `null` — publishable types only. */
+    publishedAt?: string | null;
+}
+/** The `POST /api/i18n/content/:typeName/locale-summary` response envelope. */
+export interface LocaleSummaryView {
+    /** Per requested group id: its live members (config-ordered). */
+    groups: Record<string, LocaleSummaryItem[]>;
+}
+/**
+ * Reads over translation groups: the per-entry locale panel (which locales
+ * exist, with status) and the records table's batched per-page summary.
+ * Read-only — writes live in {@link TranslationService}.
+ */
+export declare class LocaleGroupService {
+    private readonly db;
+    private readonly locales;
+    constructor(db: Database, locales: LocaleRegistryService);
+    /**
+     * The locale panel for one entry: every configured locale with its
+     * sibling row (id, status, updatedAt) or null. 404 when the entry is
+     * missing (or soft-deleted) in this workspace.
+     */
+    entryLocales(type: AnyContentType, id: string, workspaceId: string): Promise<EntryLocalesView>;
+    /**
+     * Batched group summary for the records table's Locales column: for each
+     * requested group id, its live members **in a configured locale**, with
+     * per-row status — one query for the whole page.
+     *
+     * The response's keys are exactly the request's: every requested id is
+     * seeded to `[]` up front and the rows are workspace-scoped, so a group id
+     * from another workspace and one that names nothing at all come back
+     * identical. A caller learns nothing it did not already supply.
+     */
+    summaries(type: AnyContentType, groupIds: string[], workspaceId: string): Promise<LocaleSummaryView>;
+    /** A row's `published_at` as an ISO string, or null when it never went live. */
+    private publishedAt;
+    /** A predicate AND workspace scope AND (paranoid) the not-deleted guard. */
+    private liveWhere;
+}
+//# sourceMappingURL=locale-group.service.d.ts.map

package/dist/lib/content/services/locale-group.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-group.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/content/services/locale-group.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAKvF,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC5B;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,GAAG,EAAE,SAAS,CAAC;IACf,kDAAkD;IAClD,SAAS,EAAE,OAAO,CAAC;IACnB,uEAAuE;IACvE,KAAK,EAAE;QACH,EAAE,EAAE,MAAM,CAAC;QACX,8CAA8C;QAC9C,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB;;;;;WAKG;QACH,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC5B,kCAAkC;QAClC,SAAS,EAAE,MAAM,CAAC;KACrB,GAAG,IAAI,CAAC;CACZ;AAED,2EAA2E;AAC3E,MAAM,WAAW,gBAAgB;IAC7B,wCAAwC;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,KAAK,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED,2CAA2C;AAC3C,MAAM,WAAW,iBAAiB;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,+EAA+E;AAC/E,MAAM,WAAW,iBAAiB;IAC9B,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;CAC/C;AAED;;;;GAIG;AACH,qBACa,kBAAkB;IAEL,OAAO,CAAC,QAAQ,CAAC,EAAE;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADW,EAAE,EAAE,QAAQ,EAC9B,OAAO,EAAE,qBAAqB;IAGnD;;;;OAIG;IACG,YAAY,CACd,IAAI,EAAE,cAAc,EACpB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,gBAAgB,CAAC;IAyD5B;;;;;;;;;OASG;IACG,SAAS,CACX,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,MAAM,EAAE,EAClB,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,iBAAiB,CAAC;IAoD7B,gFAAgF;IAChF,OAAO,CAAC,WAAW;IAKnB,4EAA4E;IAC5E,OAAO,CAAC,SAAS;CAYpB"}

package/dist/lib/content/services/locale-group.service.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleGroupService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const drizzle_orm_1 = require("drizzle-orm");
+const database_1 = require("@orthacms/database");
+const locale_registry_service_1 = require("../../locales/services/locale-registry.service");
+/**
+ * Reads over translation groups: the per-entry locale panel (which locales
+ * exist, with status) and the records table's batched per-page summary.
+ * Read-only — writes live in {@link TranslationService}.
+ */
+let LocaleGroupService = class LocaleGroupService {
+    db;
+    locales;
+    constructor(db, locales) {
+        this.db = db;
+        this.locales = locales;
+    }
+    /**
+     * The locale panel for one entry: every configured locale with its
+     * sibling row (id, status, updatedAt) or null. 404 when the entry is
+     * missing (or soft-deleted) in this workspace.
+     */
+    async entryLocales(type, id, workspaceId) {
+        const table = type.table;
+        const [row] = (await this.db
+            .select()
+            .from(type.table)
+            .where(this.liveWhere(type, (0, drizzle_orm_1.eq)(table['id'], id), workspaceId))
+            .limit(1));
+        if (!row) {
+            throw new common_1.NotFoundException(`No entry "${id}" on content type "${type.name}".`);
+        }
+        const groupId = row['localeGroupId'];
+        const siblings = (await this.db
+            .select()
+            .from(type.table)
+            .where(this.liveWhere(type, (0, drizzle_orm_1.eq)(table['localeGroupId'], groupId), workspaceId)));
+        const byLocale = new Map(siblings.map((sibling) => [sibling['locale'], sibling]));
+        return {
+            localeGroupId: groupId,
+            items: this.locales.all().map((locale) => {
+                const sibling = byLocale.get(locale.slug);
+                return {
+                    locale: locale.slug,
+                    // Always resolved by the registry; the fallback is for
+                    // type flow only.
+                    dir: locale.dir ?? 'ltr',
+                    isDefault: locale.isDefault ?? false,
+                    entry: sibling
+                        ? {
+                            id: sibling['id'],
+                            ...(type.publishable
+                                ? {
+                                    status: sibling['status'],
+                                    publishedAt: this.publishedAt(sibling)
+                                }
+                                : {}),
+                            updatedAt: sibling['updatedAt'].toISOString()
+                        }
+                        : null
+                };
+            })
+        };
+    }
+    /**
+     * Batched group summary for the records table's Locales column: for each
+     * requested group id, its live members **in a configured locale**, with
+     * per-row status — one query for the whole page.
+     *
+     * The response's keys are exactly the request's: every requested id is
+     * seeded to `[]` up front and the rows are workspace-scoped, so a group id
+     * from another workspace and one that names nothing at all come back
+     * identical. A caller learns nothing it did not already supply.
+     */
+    async summaries(type, groupIds, workspaceId) {
+        const groups = {};
+        for (const groupId of groupIds)
+            groups[groupId] = [];
+        if (!groupIds.length)
+            return { groups };
+        const table = type.table;
+        const rows = (await this.db
+            .select()
+            .from(type.table)
+            .where(this.liveWhere(type, (0, drizzle_orm_1.inArray)(table['localeGroupId'], groupIds), workspaceId)));
+        // Config order within each group, so badge order is stable. The map
+        // doubles as the **configured-set filter**: a row in a slug the host no
+        // longer declares is not a translation the UI can offer, and reporting
+        // it here made this endpoint the one place an orphaned locale stayed
+        // visible — the locale panel iterates the configured set, coverage
+        // filters it out, and `?locale=` 400s it, so the records table's badges
+        // contradicted every other view of the same record.
+        const order = new Map(this.locales.all().map((locale, index) => [locale.slug, index]));
+        for (const row of rows) {
+            const groupId = row['localeGroupId'];
+            if (!order.has(row['locale']))
+                continue;
+            groups[groupId]?.push({
+                locale: row['locale'],
+                entryId: row['id'],
+                ...(type.publishable
+                    ? {
+                        status: row['status'],
+                        publishedAt: this.publishedAt(row)
+                    }
+                    : {})
+            });
+        }
+        for (const members of Object.values(groups)) {
+            // Every surviving member is configured, so the lookup always hits.
+            members.sort((a, b) => order.get(a.locale) -
+                order.get(b.locale));
+        }
+        return { groups };
+    }
+    /** A row's `published_at` as an ISO string, or null when it never went live. */
+    publishedAt(row) {
+        const value = row['publishedAt'];
+        return value ? value.toISOString() : null;
+    }
+    /** A predicate AND workspace scope AND (paranoid) the not-deleted guard. */
+    liveWhere(type, predicate, workspaceId) {
+        const table = type.table;
+        return (0, drizzle_orm_1.and)(predicate, (0, drizzle_orm_1.eq)(table['workspaceId'], workspaceId), ...(type.paranoid ? [(0, drizzle_orm_1.isNull)(table['deletedAt'])] : []));
+    }
+};
+exports.LocaleGroupService = LocaleGroupService;
+exports.LocaleGroupService = LocaleGroupService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, database_1.InjectDatabase)()),
+    tslib_1.__metadata("design:paramtypes", [Object, locale_registry_service_1.LocaleRegistryService])
+], LocaleGroupService);

package/dist/lib/copilot/i18n-tool.provider.d.ts

@@ -0,0 +1,53 @@
+import { type OnModuleInit } from '@nestjs/common';
+import { WorkspaceGrantsQuery, type ContentTypeRegistry } from '@orthacms/content-server';
+import { ToolRegistry } from '@orthacms/tools-server';
+import type { ToolDefinition, ToolProvider } from '@orthacms/tools-server';
+import { LocaleRegistryService } from '../locales/services/locale-registry.service';
+import { LocaleGroupService } from '../content/services/locale-group.service';
+/**
+ * The i18n plugin's read tools — `i18n_locales_list` and
+ * `i18n_translations_get`.
+ *
+ * **The two land on different surfaces, which is worth reading before adding a
+ * third here.** `i18n_locales_list` is offered to MCP as well as the copilot:
+ * it returns deployment configuration, identical for every caller, with no
+ * publish state to leak. `i18n_translations_get` stays copilot-only because
+ * `LocaleGroupService.entryLocales` scopes to workspace and soft-delete but
+ * **not** publish state, so it reports a draft sibling and its status — which
+ * an MCP `read` token must not see (the endpoint's own `content_translations`
+ * is published-only). Same folder, same plugin, opposite answers; the deciding
+ * question is always what the tool would show a token holding `content:read`.
+ *
+ * **`listLocales` is what makes `admin_content_search`'s `locale` usable.**
+ * The configured locale slugs are deployment config, not content, so nothing
+ * else tells the model they exist: without this it either omits `locale` and
+ * silently searches the default, or guesses a slug and gets a tool error. One
+ * cheap call replaces both failure modes.
+ *
+ * `getTranslations` answers the question a localized CMS is actually asked —
+ * "which languages is this in, and which is missing?" — from the same
+ * `LocaleGroupService` the admin's locale panel reads, so the answer can't
+ * drift from what the editor shows.
+ */
+export declare class I18nCopilotToolProvider implements ToolProvider, OnModuleInit {
+    private readonly locales;
+    private readonly groups;
+    private readonly registry;
+    private readonly grants;
+    private readonly toolRegistry?;
+    constructor(locales: LocaleRegistryService, groups: LocaleGroupService, registry: ContentTypeRegistry, grants: WorkspaceGrantsQuery, toolRegistry?: ToolRegistry | undefined);
+    /**
+     * Register with the shared tool registry once the DI graph is built —
+     * the same catalogue the MCP endpoint serves, narrowed to the `copilot`
+     * surface by each tool's `surfaces`. `@Optional()` because a deployment
+     * may run neither consumer, in which case these simply go unregistered.
+     */
+    onModuleInit(): void;
+    /** The two locale tools, in the order the model sees them. */
+    tools(): readonly ToolDefinition[];
+    /** `i18n_locales_list` — the deployment's configured locales. */
+    private listLocales;
+    /** `i18n_translations_get` — which locales an entry exists in. */
+    private getTranslations;
+}
+//# sourceMappingURL=i18n-tool.provider.d.ts.map

package/dist/lib/copilot/i18n-tool.provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n-tool.provider.d.ts","sourceRoot":"","sources":["../../../src/lib/copilot/i18n-tool.provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEzE,OAAO,EAEH,oBAAoB,EACpB,KAAK,mBAAmB,EAC3B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AACpF,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBACa,uBAAwB,YAAW,YAAY,EAAE,YAAY;IAElE,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAEvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACX,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;gBALzB,OAAO,EAAE,qBAAqB,EAC9B,MAAM,EAAE,kBAAkB,EAE1B,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,oBAAoB,EAChB,YAAY,CAAC,EAAE,YAAY,YAAA;IAG5D;;;;;OAKG;IACH,YAAY,IAAI,IAAI;IAIpB,8DAA8D;IAC9D,KAAK,IAAI,SAAS,cAAc,EAAE;IAIlC,iEAAiE;IACjE,OAAO,CAAC,WAAW;IAiCnB,kEAAkE;IAClE,OAAO,CAAC,eAAe;CA8D1B"}

package/dist/lib/copilot/i18n-tool.provider.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nCopilotToolProvider = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const identity_server_1 = require("@orthacms/identity-server");
+const content_server_1 = require("@orthacms/content-server");
+const tools_server_1 = require("@orthacms/tools-server");
+const locale_registry_service_1 = require("../locales/services/locale-registry.service");
+const locale_group_service_1 = require("../content/services/locale-group.service");
+/**
+ * The i18n plugin's read tools — `i18n_locales_list` and
+ * `i18n_translations_get`.
+ *
+ * **The two land on different surfaces, which is worth reading before adding a
+ * third here.** `i18n_locales_list` is offered to MCP as well as the copilot:
+ * it returns deployment configuration, identical for every caller, with no
+ * publish state to leak. `i18n_translations_get` stays copilot-only because
+ * `LocaleGroupService.entryLocales` scopes to workspace and soft-delete but
+ * **not** publish state, so it reports a draft sibling and its status — which
+ * an MCP `read` token must not see (the endpoint's own `content_translations`
+ * is published-only). Same folder, same plugin, opposite answers; the deciding
+ * question is always what the tool would show a token holding `content:read`.
+ *
+ * **`listLocales` is what makes `admin_content_search`'s `locale` usable.**
+ * The configured locale slugs are deployment config, not content, so nothing
+ * else tells the model they exist: without this it either omits `locale` and
+ * silently searches the default, or guesses a slug and gets a tool error. One
+ * cheap call replaces both failure modes.
+ *
+ * `getTranslations` answers the question a localized CMS is actually asked —
+ * "which languages is this in, and which is missing?" — from the same
+ * `LocaleGroupService` the admin's locale panel reads, so the answer can't
+ * drift from what the editor shows.
+ */
+let I18nCopilotToolProvider = class I18nCopilotToolProvider {
+    locales;
+    groups;
+    registry;
+    grants;
+    toolRegistry;
+    constructor(locales, groups, registry, grants, toolRegistry) {
+        this.locales = locales;
+        this.groups = groups;
+        this.registry = registry;
+        this.grants = grants;
+        this.toolRegistry = toolRegistry;
+    }
+    /**
+     * Register with the shared tool registry once the DI graph is built —
+     * the same catalogue the MCP endpoint serves, narrowed to the `copilot`
+     * surface by each tool's `surfaces`. `@Optional()` because a deployment
+     * may run neither consumer, in which case these simply go unregistered.
+     */
+    onModuleInit() {
+        this.toolRegistry?.register(this);
+    }
+    /** The two locale tools, in the order the model sees them. */
+    tools() {
+        return [this.listLocales(), this.getTranslations()];
+    }
+    /** `i18n_locales_list` — the deployment's configured locales. */
+    listLocales() {
+        return {
+            name: 'i18n_locales_list',
+            title: 'List locales',
+            description: 'List the locales this CMS is configured for, with their slugs and which one ' +
+                'is the default. Call this before passing a `locale` to admin_content_search ' +
+                '— locale slugs are deployment configuration and are not in your system ' +
+                'prompt, so guessing one produces an error and omitting one silently searches ' +
+                'the default language.',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                additionalProperties: false
+            },
+            // Locales are deployment configuration carrying no workspace data,
+            // and the HTTP route needs only a session. `content:read` is the
+            // narrowest key that means "may look at content at all", which is
+            // the only thing this list is useful for.
+            requires: [identity_server_1.PERMISSIONS.CONTENT_READ],
+            readOnly: true,
+            effect: 'read',
+            // No `surfaces` — offered to both. The tension that splits every
+            // other content tool is about *visibility of drafts* and *who a
+            // write is attributed to*, and a locale list has neither: it
+            // returns the same deployment configuration to every caller, holds
+            // no workspace data, and writes nothing. An MCP client needs it for
+            // exactly the reason the copilot does — `?locale=` on the public
+            // reads takes a slug that appears in no schema and no prompt.
+            handler: async () => ({ locales: this.locales.all() })
+        };
+    }
+    /** `i18n_translations_get` — which locales an entry exists in. */
+    getTranslations() {
+        return {
+            name: 'i18n_translations_get',
+            title: 'An entry’s translations',
+            description: 'For one entry of a localized type, list every configured locale and whether ' +
+                'the entry has been translated into it — with each translation’s own entry id ' +
+                'and publish state. Use it to answer “what is missing a German version?” or to ' +
+                'get the id of a sibling translation before reading it.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    typeName: {
+                        type: 'string',
+                        description: 'The content type. It must be localized; a non-localized type is an error.'
+                    },
+                    id: {
+                        type: 'string',
+                        description: 'The id of any one locale’s row, as returned by admin_content_search.'
+                    }
+                },
+                required: ['typeName', 'id'],
+                additionalProperties: false
+            },
+            requires: [identity_server_1.PERMISSIONS.CONTENT_READ],
+            readOnly: true,
+            effect: 'read',
+            surfaces: ['copilot'],
+            handler: async (input, ctx) => {
+                const args = (input ?? {});
+                // The same grant re-check every content tool makes, for the
+                // same reason: `WorkspaceGuard` proved membership, not that
+                // this workspace may reach this type, and the name came from
+                // the model. `resolveI18nType` (the HTTP path) deliberately
+                // does not check grants — its callers are already behind a
+                // workspace-scoped controller reached from the admin's own UI.
+                const type = this.registry.get(args.typeName);
+                const granted = await this.grants.grantedSlugs(ctx.workspaceId);
+                if (!type || !granted.has(type.name)) {
+                    throw new Error(`Unknown content type "${args.typeName}" in this workspace.`);
+                }
+                // "Not localized" is a different fact from "no such type" and
+                // is safe to say: it describes the type the caller already
+                // proved it can reach. Answering `[]` would read as "this has
+                // no other languages" when the truth is "this content is not
+                // translated at all" — the same distinction the public API
+                // draws by 400-ing `?translations=preview` on a plain type.
+                if (!type.i18n) {
+                    throw new Error(`Content type "${type.name}" is not localized, so it has no translations.`);
+                }
+                return this.groups.entryLocales(type, args.id, ctx.workspaceId);
+            }
+        };
+    }
+};
+exports.I18nCopilotToolProvider = I18nCopilotToolProvider;
+exports.I18nCopilotToolProvider = I18nCopilotToolProvider = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(2, (0, content_server_1.InjectContentRegistry)()),
+    tslib_1.__param(4, (0, common_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [locale_registry_service_1.LocaleRegistryService,
+        locale_group_service_1.LocaleGroupService, Function, content_server_1.WorkspaceGrantsQuery,
+        tools_server_1.ToolRegistry])
+], I18nCopilotToolProvider);

package/dist/lib/copilot/translation-proposal.applier.d.ts

@@ -0,0 +1,87 @@
+import { type Database } from '@orthacms/database';
+import { EntryWriterService, WorkspaceGrantsQuery, type ContentTypeRegistry } from '@orthacms/content-server';
+import type { ProposalActor, ProposalApplier, ProposalApplyResult, ProposalTarget } from '@orthacms/copilot-domain';
+/**
+ * Applies `i18n.entry.translate` by creating the sibling row through
+ * {@link EntryWriterService.create} — the same call `POST /api/content/:type`
+ * makes, with a `localeGroupId`.
+ *
+ * **There is no "create translation" write path to reuse, and that is the
+ * point**: joining an existing group is what `localeGroupId` on a create
+ * already means, and the bound entry extension stamps and validates it inside
+ * the write transaction. So this applier passes two extra arguments to the
+ * ordinary create rather than reaching for a second mechanism — which is also
+ * what makes a duplicate `(group, locale)` a clean 409 instead of a corrupt
+ * group.
+ *
+ * ## Why it reads the source entry first
+ *
+ * The propose tool accepts **only localized values** — a shared field is one
+ * value across the group, so asking a model to translate it is meaningless. But
+ * a create is a whole row: `coerceValues` stamps every declared field onto the
+ * bag, so a shared field nobody supplied arrives as `null` rather than as
+ * "absent". Two things then go wrong at once, and neither is obvious:
+ *
+ * 1. The new row fails its own required-field validation — `tag.slug` is
+ *    required and shared, and no translation of a tag ever carries it.
+ * 2. Worse, the bound extension treats that `null` as a shared value the save
+ *    *carries* and pushes it onto every sibling in the group. A published
+ *    sibling is re-validated and fails, which rolls the create back — but a
+ *    group whose siblings are all drafts has no such guard, and the shared
+ *    field is silently blanked in every locale.
+ *
+ * So the values the create is given are the **source entry's**, with the
+ * translated ones layered on top: the same thing the admin's own "create
+ * translation" does (it sends the source's values), and the reason that path
+ * has never hit this. The shared values then match the group exactly, the
+ * extension's `IS DISTINCT FROM` predicate finds nothing to sync, and no
+ * sibling is touched at all.
+ *
+ * Read at **apply** time rather than frozen into the proposal: a shared field
+ * can be edited between drafting and applying, and the group's current value is
+ * the one that must not be clobbered.
+ */
+export declare class TranslationProposalApplier implements ProposalApplier {
+    private readonly registry;
+    private readonly writer;
+    private readonly grants;
+    private readonly db;
+    readonly kind: "i18n.entry.translate";
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService, grants: WorkspaceGrantsQuery, db: Database);
+    apply(input: {
+        target: ProposalTarget;
+        patch: Record<string, unknown>;
+    }, actor: ProposalActor): Promise<ProposalApplyResult>;
+}
+/**
+ * Applies `i18n.entry.bulk-translate` — several translations carried out as one
+ * change.
+ *
+ * **Item by item through the same `EntryWriterService.create` the single-entry
+ * applier calls**, each with its own source entry's shared values inherited: a
+ * batch is a way of asking for N translations, not a second way of writing one.
+ * Sequentially rather than concurrently, because every write takes the
+ * workspace's shared content lock and (on a localized type) an advisory lock
+ * over the translation group — a batch translating one record into five
+ * languages contends with itself by construction, so a fan-out would buy
+ * nothing but lock waits.
+ *
+ * **It stops at the first failure and throws**, exactly as the content plugin's
+ * bulk applier does. A proposal is one row with one status, so there is no
+ * per-item verdict to render; carrying on would grow the number of rows written
+ * under a receipt that then reports failure. The error names how many landed,
+ * which is what the model reads back to the user.
+ */
+export declare class BulkTranslationProposalApplier implements ProposalApplier {
+    private readonly registry;
+    private readonly writer;
+    private readonly grants;
+    private readonly db;
+    readonly kind: "i18n.entry.bulk-translate";
+    constructor(registry: ContentTypeRegistry, writer: EntryWriterService, grants: WorkspaceGrantsQuery, db: Database);
+    apply(input: {
+        target: ProposalTarget;
+        patch: Record<string, unknown>;
+    }, actor: ProposalActor): Promise<ProposalApplyResult>;
+}
+//# sourceMappingURL=translation-proposal.applier.d.ts.map

package/dist/lib/copilot/translation-proposal.applier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation-proposal.applier.d.ts","sourceRoot":"","sources":["../../../src/lib/copilot/translation-proposal.applier.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnE,OAAO,EACH,kBAAkB,EAElB,oBAAoB,EAIpB,KAAK,mBAAmB,EAC3B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACR,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,cAAc,EACjB,MAAM,0BAA0B,CAAC;AAMlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBACa,0BAA2B,YAAW,eAAe;IAK1D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACL,OAAO,CAAC,QAAQ,CAAC,EAAE;IAPzC,QAAQ,CAAC,IAAI,yBAAyC;gBAIjC,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,oBAAoB,EACV,EAAE,EAAE,QAAQ;IAG7C,KAAK,CACP,KAAK,EAAE;QAAE,MAAM,EAAE,cAAc,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,EACjE,KAAK,EAAE,aAAa,GACrB,OAAO,CAAC,mBAAmB,CAAC;CAkDlC;AA0DD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBACa,8BAA+B,YAAW,eAAe;IAK9D,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACL,OAAO,CAAC,QAAQ,CAAC,EAAE;IAPzC,QAAQ,CAAC,IAAI,8BAAuC;gBAI/B,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,oBAAoB,EACV,EAAE,EAAE,QAAQ;IAG7C,KAAK,CACP,KAAK,EAAE;QAAE,MAAM,EAAE,cAAc,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,EACjE,KAAK,EAAE,aAAa,GACrB,OAAO,CAAC,mBAAmB,CAAC;CA8FlC"}