@_linked/translation 0.2.2

package/lib/esm/shapes/TranslationProvider.js

@@ -0,0 +1,1376 @@
+import { ShapeProvider } from '@_linked/server-utils/utils/ShapeProvider';
+import { TranslationKey } from './TranslationKey.js';
+import { TranslationKeyVersion } from './TranslationKeyVersion.js';
+import { TranslationRelease } from './TranslationRelease.js';
+import { TranslationUnit } from './TranslationUnit.js';
+import { TranslationRevision } from './TranslationRevision.js';
+import { GlossaryTerm } from './GlossaryTerm.js';
+import { classifyKeyVersion, createMonotonicVersionId, deriveBackfillKeyVersion, deriveTranslationKeyVersionContract, } from '../key-version.js';
+import { canAuthorTranslation, } from '../authorization.js';
+const iri = (value) => typeof value === 'string'
+    ? value
+    : value === null || value === void 0 ? void 0 : value.id;
+const isoDate = (value) => value instanceof Date ? value.toISOString() : value || undefined;
+function toKeyVersionRecord(row) {
+    var _a, _b;
+    const id = (_a = iri(row.id)) !== null && _a !== void 0 ? _a : iri(row);
+    if (!id || !row.versionId)
+        return null;
+    return {
+        id,
+        versionId: row.versionId,
+        sourceLanguage: row.sourceLanguage || 'en',
+        sourceText: (_b = row.sourceText) !== null && _b !== void 0 ? _b : '',
+        format: row.format === 'icu' ? 'icu' : 'simple',
+        argumentSignature: row.argumentSignature || '[]',
+        contractHash: row.contractHash || '',
+        sourceHash: row.sourceHash || '',
+        supersedes: iri(row.supersedes),
+        createdAt: isoDate(row.createdAt) || undefined,
+        createdBy: iri(row.createdBy),
+    };
+}
+/**
+ * Shared TM/carry-forward classifier (Plan 018 §5.5). Exact source matches may
+ * cross logical keys; changed-source carry-forward candidates never do.
+ */
+export function classifyTranslationMemoryMatches(input) {
+    var _a, _b, _c, _d, _e;
+    const matches = [];
+    for (const row of (_a = input.rows) !== null && _a !== void 0 ? _a : []) {
+        const version = typeof row.ofKeyVersion === 'object' ? row.ofKeyVersion : undefined;
+        const unitId = iri(row.id);
+        const keyVersionId = iri(row.ofKeyVersion);
+        const candidateKey = (_b = row.ofKey) === null || _b === void 0 ? void 0 : _b.key;
+        if (!unitId ||
+            !keyVersionId ||
+            keyVersionId === input.currentVersion.id ||
+            !candidateKey ||
+            row.language !== input.language ||
+            row.state !== 'reviewed' ||
+            !((_c = row.text) === null || _c === void 0 ? void 0 : _c.trim()) ||
+            !(version === null || version === void 0 ? void 0 : version.contractHash) ||
+            version.contractHash !== input.currentVersion.contractHash) {
+            continue;
+        }
+        const exact = version.sourceHash === input.currentVersion.sourceHash;
+        if (!exact && candidateKey !== input.key)
+            continue;
+        matches.push({
+            unitId,
+            key: candidateKey,
+            language: input.language,
+            text: row.text,
+            keyVersionId,
+            sourceText: (_d = version.sourceText) !== null && _d !== void 0 ? _d : '',
+            sourceHash: (_e = version.sourceHash) !== null && _e !== void 0 ? _e : '',
+            contractHash: version.contractHash,
+            kind: exact ? 'exact' : 'carry-forward',
+            updatedAt: isoDate(row.updatedAt) || undefined,
+        });
+    }
+    return matches.sort((left, right) => {
+        var _a, _b;
+        return (left.kind === right.kind ? 0 : left.kind === 'exact' ? -1 : 1) ||
+            ((_a = right.updatedAt) !== null && _a !== void 0 ? _a : '').localeCompare((_b = left.updatedAt) !== null && _b !== void 0 ? _b : '') ||
+            left.key.localeCompare(right.key);
+    });
+}
+/** Build the reviewed-unit index shown in the explicit TM browser. */
+export function toTranslationMemoryRecords(rows = []) {
+    return rows
+        .flatMap((row) => {
+        var _a, _b, _c;
+        const version = typeof row.ofKeyVersion === 'object' ? row.ofKeyVersion : undefined;
+        const unitId = iri(row.id);
+        const keyVersionId = iri(row.ofKeyVersion);
+        const key = (_a = row.ofKey) === null || _a === void 0 ? void 0 : _a.key;
+        if (!unitId ||
+            !keyVersionId ||
+            !key ||
+            !row.language ||
+            row.state !== 'reviewed' ||
+            !((_b = row.text) === null || _b === void 0 ? void 0 : _b.trim()) ||
+            !(version === null || version === void 0 ? void 0 : version.sourceHash) ||
+            !version.contractHash) {
+            return [];
+        }
+        return [
+            {
+                unitId,
+                key,
+                language: row.language,
+                text: row.text,
+                keyVersionId,
+                sourceText: (_c = version.sourceText) !== null && _c !== void 0 ? _c : '',
+                sourceHash: version.sourceHash,
+                contractHash: version.contractHash,
+                updatedAt: isoDate(row.updatedAt) || undefined,
+            },
+        ];
+    })
+        .sort((left, right) => {
+        var _a, _b;
+        return ((_a = right.updatedAt) !== null && _a !== void 0 ? _a : '').localeCompare((_b = left.updatedAt) !== null && _b !== void 0 ? _b : '') ||
+            left.language.localeCompare(right.language) ||
+            left.key.localeCompare(right.key);
+    });
+}
+/**
+ * Find current untranslated cells that can be filled without MT cost.
+ * Source AND argument-contract hashes must match; the current version can
+ * never source itself.
+ */
+export function findExactMemoryPretranslations(input) {
+    var _a;
+    const byContract = new Map();
+    for (const record of input.memory) {
+        if (record.language !== input.language)
+            continue;
+        const signature = `${record.sourceHash}\u0000${record.contractHash}`;
+        const candidates = (_a = byContract.get(signature)) !== null && _a !== void 0 ? _a : [];
+        candidates.push(record);
+        byContract.set(signature, candidates);
+    }
+    for (const candidates of byContract.values()) {
+        candidates.sort((left, right) => {
+            var _a, _b;
+            return ((_a = right.updatedAt) !== null && _a !== void 0 ? _a : '').localeCompare((_b = left.updatedAt) !== null && _b !== void 0 ? _b : '') ||
+                left.key.localeCompare(right.key);
+        });
+    }
+    return input.entries.flatMap((entry) => {
+        var _a;
+        const current = entry.currentVersion;
+        const unit = entry.units[input.language];
+        if (!(current === null || current === void 0 ? void 0 : current.sourceHash) ||
+            !current.contractHash ||
+            (unit === null || unit === void 0 ? void 0 : unit.text.trim())) {
+            return [];
+        }
+        const signature = `${current.sourceHash}\u0000${current.contractHash}`;
+        const match = (_a = byContract
+            .get(signature)) === null || _a === void 0 ? void 0 : _a.find((candidate) => candidate.keyVersionId !== current.id);
+        return match
+            ? [
+                {
+                    key: entry.key,
+                    language: input.language,
+                    unitId: match.unitId,
+                    sourceKey: match.key,
+                    text: match.text,
+                },
+            ]
+            : [];
+    });
+}
+const TRANSLATION_STATES = new Set([
+    'untranslated',
+    'machine',
+    'reviewed',
+    'stale',
+]);
+function normalizeState(value) {
+    return TRANSLATION_STATES.has(value)
+        ? value
+        : 'untranslated';
+}
+/**
+ * Convert LINKED query rows into a deterministic, serialization-safe editor
+ * contract. Exported for package-unit testing; it performs no I/O.
+ */
+export function groupTranslationEntries(keyRows = [], unitRows = [], versionRows = []) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const entries = new Map();
+    const currentVersionByKey = new Map();
+    for (const row of keyRows !== null && keyRows !== void 0 ? keyRows : []) {
+        if (!(row === null || row === void 0 ? void 0 : row.key))
+            continue;
+        const currentVersionId = iri(row.currentVersion);
+        if (currentVersionId)
+            currentVersionByKey.set(row.key, currentVersionId);
+        entries.set(row.key, {
+            key: row.key,
+            namespace: (_a = row.namespace) !== null && _a !== void 0 ? _a : '',
+            sourceText: (_b = row.sourceText) !== null && _b !== void 0 ? _b : '',
+            description: row.description || undefined,
+            kind: row.kind === 'content' ? 'content' : 'ui',
+            format: row.format === 'icu' ? 'icu' : 'simple',
+            ofShape: iri(row.ofShape),
+            ofProperty: iri(row.ofProperty),
+            fromPackage: row.fromPackage || undefined,
+            overridden: row.overridden === true || row.overridden === 'true'
+                ? true
+                : undefined,
+            versions: [],
+            units: {},
+        });
+    }
+    for (const row of versionRows !== null && versionRows !== void 0 ? versionRows : []) {
+        const key = (_c = row === null || row === void 0 ? void 0 : row.ofKey) === null || _c === void 0 ? void 0 : _c.key;
+        const entry = key ? entries.get(key) : undefined;
+        const version = toKeyVersionRecord(row);
+        if (!entry || !version)
+            continue;
+        entry.versions.push(version);
+        if (currentVersionByKey.get(key) === version.id) {
+            entry.currentVersion = version;
+        }
+    }
+    for (const entry of entries.values()) {
+        (_d = entry.versions) === null || _d === void 0 ? void 0 : _d.sort((left, right) => {
+            var _a, _b;
+            return ((_a = right.createdAt) !== null && _a !== void 0 ? _a : '').localeCompare((_b = left.createdAt) !== null && _b !== void 0 ? _b : '') ||
+                right.versionId.localeCompare(left.versionId);
+        });
+        if (!((_e = entry.versions) === null || _e === void 0 ? void 0 : _e.length))
+            delete entry.versions;
+    }
+    const unitCandidates = new Map();
+    for (const row of unitRows !== null && unitRows !== void 0 ? unitRows : []) {
+        const key = (_f = row === null || row === void 0 ? void 0 : row.ofKey) === null || _f === void 0 ? void 0 : _f.key;
+        const language = row === null || row === void 0 ? void 0 : row.language;
+        const entry = key ? entries.get(key) : undefined;
+        if (!entry || !language)
+            continue;
+        const keyVersionId = iri(row.ofKeyVersion);
+        const score = keyVersionId && keyVersionId === ((_g = entry.currentVersion) === null || _g === void 0 ? void 0 : _g.id)
+            ? 2
+            : keyVersionId
+                ? 1
+                : 0;
+        const candidateKey = `${key}\u0000${language}`;
+        if (((_j = (_h = unitCandidates.get(candidateKey)) === null || _h === void 0 ? void 0 : _h.score) !== null && _j !== void 0 ? _j : -1) >= score)
+            continue;
+        unitCandidates.set(candidateKey, {
+            score,
+            record: {
+                language,
+                text: (_k = row.text) !== null && _k !== void 0 ? _k : '',
+                state: entry.currentVersion && score < 2
+                    ? 'stale'
+                    : normalizeState(row.state),
+                origin: row.origin || undefined,
+                updatedAt: isoDate(row.updatedAt) || undefined,
+                keyVersionId,
+            },
+        });
+    }
+    for (const [candidateKey, { record }] of unitCandidates) {
+        const [key, language] = candidateKey.split('\u0000');
+        const entry = entries.get(key);
+        if (entry)
+            entry.units[language] = record;
+    }
+    return [...entries.values()].sort((a, b) => a.key.localeCompare(b.key));
+}
+/** App-scoped key read shared by the RPC provider and managed key-sync flows. */
+export async function listTranslationKeys(data) {
+    const appId = requireText(data.appId, 'appId');
+    return TranslationKey.select((k) => [
+        k.namespace,
+        k.key,
+        k.sourceText,
+        k.description,
+        k.kind,
+        k.ofNode,
+        k.ofField,
+        k.ofShape,
+        k.ofProperty,
+        k.fromPackage,
+        k.overridden,
+        k.format,
+        k.currentVersion,
+    ]).where((k) => k.ofApplication.equals({ id: appId }));
+}
+/**
+ * App-scoped keys + grouped language units as plain records — the read behind
+ * the editor RPC AND the publish/compile flow (Plan 016 P2.3). No auth of its
+ * own (the RPC wrapper gates); callers on the server run it in request context.
+ */
+export async function listTranslationEntries(data) {
+    const appId = requireText(data.appId, 'appId');
+    const [keys, units, versions] = await Promise.all([
+        TranslationKey.select((k) => [
+            k.namespace,
+            k.key,
+            k.sourceText,
+            k.description,
+            k.kind,
+            k.format,
+            k.ofShape,
+            k.ofProperty,
+            k.fromPackage,
+            k.overridden,
+            k.currentVersion,
+        ]).where((k) => k.ofApplication.equals({ id: appId })),
+        TranslationUnit.select((u) => [
+            u.language,
+            u.text,
+            u.state,
+            u.origin,
+            u.updatedAt,
+            u.ofKeyVersion,
+            u.ofKey.select((k) => [k.key]),
+        ]).where((u) => u.ofKey.ofApplication.equals({ id: appId })),
+        TranslationKeyVersion.select((v) => [
+            v.versionId,
+            v.sourceLanguage,
+            v.sourceText,
+            v.format,
+            v.argumentSignature,
+            v.contractHash,
+            v.sourceHash,
+            v.supersedes,
+            v.createdAt,
+            v.createdBy,
+            v.ofKey.select((k) => [k.key]),
+        ]).where((v) => v.ofApplication.equals({ id: appId })),
+    ]);
+    return groupTranslationEntries(keys, units, versions);
+}
+export async function listTranslationKeyVersions(data) {
+    const appId = requireText(data.appId, 'appId');
+    const keyId = data.key
+        ? keyIri(appId, requireText(data.key, 'key'))
+        : undefined;
+    const query = TranslationKeyVersion.select((v) => [
+        v.versionId,
+        v.sourceLanguage,
+        v.sourceText,
+        v.format,
+        v.argumentSignature,
+        v.contractHash,
+        v.sourceHash,
+        v.supersedes,
+        v.createdAt,
+        v.createdBy,
+    ]).where((v) => keyId
+        ? v.ofApplication
+            .equals({ id: appId })
+            .and(v.ofKey.equals({ id: keyId }))
+        : v.ofApplication.equals({ id: appId }));
+    const rows = await query;
+    return (rows !== null && rows !== void 0 ? rows : [])
+        .map((row) => toKeyVersionRecord(row))
+        .filter((record) => record !== null)
+        .sort((left, right) => {
+        var _a, _b;
+        return ((_a = right.createdAt) !== null && _a !== void 0 ? _a : '').localeCompare((_b = left.createdAt) !== null && _b !== void 0 ? _b : '') ||
+            right.versionId.localeCompare(left.versionId);
+    });
+}
+function toReleaseRecord(row) {
+    var _a, _b;
+    const id = (_a = iri(row === null || row === void 0 ? void 0 : row.id)) !== null && _a !== void 0 ? _a : iri(row);
+    const appId = iri(row === null || row === void 0 ? void 0 : row.ofApplication);
+    const branchId = iri(row === null || row === void 0 ? void 0 : row.branch);
+    if (!id || !appId || !branchId || !(row === null || row === void 0 ? void 0 : row.releaseId))
+        return null;
+    return {
+        id,
+        releaseId: row.releaseId,
+        appId,
+        branchId,
+        buildId: row.buildId || undefined,
+        channel: row.channel === 'production' ? 'production' : 'preview',
+        status: ['published', 'superseded', 'retired'].includes(row.status)
+            ? row.status
+            : 'draft',
+        contractSetHash: row.contractSetHash || '',
+        manifestHash: row.manifestHash || '',
+        hotfixSequence: Number((_b = row.hotfixSequence) !== null && _b !== void 0 ? _b : 0),
+        qualitySummary: row.qualitySummary || undefined,
+        createdAt: isoDate(row.createdAt) || '',
+        publishedAt: isoDate(row.publishedAt) || undefined,
+        supportedUntil: isoDate(row.supportedUntil) || undefined,
+        supersedes: iri(row.supersedes),
+    };
+}
+export async function listTranslationReleases(data) {
+    const appId = requireText(data.appId, 'appId');
+    const rows = await TranslationRelease.select((release) => [
+        release.releaseId,
+        release.ofApplication,
+        release.branch,
+        release.buildId,
+        release.channel,
+        release.status,
+        release.contractSetHash,
+        release.manifestHash,
+        release.hotfixSequence,
+        release.qualitySummary,
+        release.createdAt,
+        release.publishedAt,
+        release.supportedUntil,
+        release.supersedes,
+    ]).where((release) => release.ofApplication.equals({ id: appId }));
+    return (rows !== null && rows !== void 0 ? rows : [])
+        .map(toReleaseRecord)
+        .filter((record) => record !== null)
+        .sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+}
+export async function createTranslationRelease(data) {
+    const appId = requireText(data.appId, 'appId');
+    const releaseId = requireText(data.releaseId, 'releaseId');
+    const branchId = requireText(data.branchId, 'branchId');
+    if (!['preview', 'production'].includes(data.channel)) {
+        throw new Error('channel must be preview or production.');
+    }
+    if (!['draft', 'published', 'superseded', 'retired'].includes(data.status)) {
+        throw new Error('Invalid translation release status.');
+    }
+    const id = `${appId.replace(/\/$/, '')}/translation/release/${encodeURIComponent(releaseId)}`;
+    const existing = await TranslationRelease.select((release) => [
+        release.releaseId,
+    ])
+        .where((release) => release.equals({ id }))
+        .one()
+        .catch(() => null);
+    if (existing) {
+        throw new Error(`Translation release "${releaseId}" already exists.`);
+    }
+    const createdAt = data.createdAt || new Date().toISOString();
+    await TranslationRelease.create({
+        __id: id,
+        ofApplication: { id: appId },
+        branch: { id: branchId },
+        releaseId,
+        buildId: data.buildId,
+        channel: data.channel,
+        status: data.status,
+        contractSetHash: requireText(data.contractSetHash, 'contractSetHash'),
+        manifestHash: requireText(data.manifestHash, 'manifestHash'),
+        hotfixSequence: data.hotfixSequence,
+        qualitySummary: data.qualitySummary,
+        createdAt: new Date(createdAt),
+        publishedAt: data.publishedAt ? new Date(data.publishedAt) : undefined,
+        supportedUntil: data.supportedUntil ? new Date(data.supportedUntil) : undefined,
+        supersedes: data.supersedes ? { id: data.supersedes } : undefined,
+    });
+    return { ...data, id, createdAt };
+}
+export async function advanceTranslationReleaseHotfix(data) {
+    const id = requireText(data.id, 'id');
+    const current = await TranslationRelease.select((release) => [
+        release.releaseId,
+        release.ofApplication,
+        release.branch,
+        release.buildId,
+        release.channel,
+        release.status,
+        release.contractSetHash,
+        release.manifestHash,
+        release.hotfixSequence,
+        release.qualitySummary,
+        release.createdAt,
+        release.publishedAt,
+        release.supportedUntil,
+        release.supersedes,
+    ])
+        .where((release) => release.equals({ id }))
+        .one()
+        .catch(() => null);
+    const record = current ? toReleaseRecord(current) : null;
+    if (!record)
+        throw new Error(`Translation release "${id}" was not found.`);
+    if (record.hotfixSequence !== data.expectedSequence) {
+        throw new Error(`Translation release advanced from sequence ${data.expectedSequence} to ${record.hotfixSequence}.`);
+    }
+    await TranslationRelease.update({
+        hotfixSequence: data.hotfixSequence,
+        manifestHash: requireText(data.manifestHash, 'manifestHash'),
+    }).for({ id });
+    return {
+        ...record,
+        hotfixSequence: data.hotfixSequence,
+        manifestHash: data.manifestHash,
+    };
+}
+function requireText(value, label) {
+    const clean = value === null || value === void 0 ? void 0 : value.trim();
+    if (!clean)
+        throw new Error(`${label} is required.`);
+    return clean;
+}
+function keyIri(appId, key) {
+    return `${appId.replace(/\/$/, '')}/translation/key/${encodeURIComponent(key)}`;
+}
+function versionIri(keyId, versionId) {
+    return `${keyId.replace(/\/$/, '')}/version/${versionId}`;
+}
+function unitIri(keyVersionId, language) {
+    return `${keyVersionId.replace(/\/$/, '')}/unit/${encodeURIComponent(language)}`;
+}
+/** Unique append-only revision IRI under the version-scoped cell it revises. */
+function revisionIri(keyVersionId, language) {
+    const suffix = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+    return `${unitIri(keyVersionId, language)}/rev/${suffix}`;
+}
+async function readKeyVersion(id) {
+    const row = await TranslationKeyVersion.select((v) => [
+        v.versionId,
+        v.sourceLanguage,
+        v.sourceText,
+        v.format,
+        v.argumentSignature,
+        v.contractHash,
+        v.sourceHash,
+        v.supersedes,
+        v.createdAt,
+        v.createdBy,
+    ])
+        .where((v) => v.equals({ id }))
+        .one()
+        .catch(() => null);
+    return row ? toKeyVersionRecord(row) : null;
+}
+async function createTranslationKeyVersion(input) {
+    const derived = input.backfill
+        ? await deriveBackfillKeyVersion(input)
+        : {
+            ...(await deriveTranslationKeyVersionContract(input)),
+            versionId: createMonotonicVersionId(),
+        };
+    const id = versionIri(input.keyId, derived.versionId);
+    const createdAt = new Date().toISOString();
+    await TranslationKeyVersion.create({
+        __id: id,
+        ofApplication: { id: input.appId },
+        ofKey: { id: input.keyId },
+        versionId: derived.versionId,
+        sourceLanguage: derived.sourceLanguage,
+        sourceText: derived.sourceText,
+        format: derived.format,
+        argumentSignature: derived.argumentSignature,
+        contractHash: derived.contractHash,
+        sourceHash: derived.sourceHash,
+        supersedes: input.supersedes ? { id: input.supersedes } : undefined,
+        createdAt: new Date(createdAt),
+        createdBy: input.createdBy ? { id: input.createdBy } : undefined,
+    });
+    return {
+        id,
+        ...derived,
+        supersedes: input.supersedes,
+        createdAt,
+        createdBy: input.createdBy,
+    };
+}
+async function ensureCurrentKeyVersion(input) {
+    const currentId = iri(input.currentVersion);
+    if (currentId) {
+        const current = await readKeyVersion(currentId);
+        if (current)
+            return current;
+    }
+    const initial = await createTranslationKeyVersion({
+        ...input,
+        backfill: true,
+    });
+    await TranslationKey.update({
+        currentVersion: { id: initial.id },
+    }).for({ id: input.keyId });
+    return initial;
+}
+const REVISION_STATUSES = new Set([
+    'applied',
+    'proposed',
+    'suggested',
+    'accepted',
+    'rejected',
+    'superseded',
+]);
+async function requireKeyWriteContext(input) {
+    var _a;
+    const keyId = keyIri(input.appId, input.key);
+    const keyRow = await TranslationKey.select((k) => [
+        k.sourceText,
+        k.format,
+        k.currentVersion,
+    ])
+        .where((k) => k.equals({ id: keyId }))
+        .one()
+        .catch(() => null);
+    if (!keyRow) {
+        throw new Error(`Translation key "${input.key}" does not exist for this app.`);
+    }
+    const version = await ensureCurrentKeyVersion({
+        appId: input.appId,
+        keyId,
+        currentVersion: keyRow.currentVersion,
+        sourceLanguage: 'en',
+        sourceText: (_a = keyRow.sourceText) !== null && _a !== void 0 ? _a : '',
+        format: keyRow.format === 'icu' ? 'icu' : 'simple',
+        createdBy: input.createdBy,
+    });
+    return { keyId, version };
+}
+/**
+ * Convert LINKED revision rows into plain RPC-safe records, newest first.
+ * Exported for package-unit testing; performs no I/O.
+ */
+export function toRevisionRecords(rows = []) {
+    const iri = (value) => typeof value === 'string'
+        ? value
+        : value === null || value === void 0 ? void 0 : value.id;
+    return rows
+        .filter((row) => typeof (row === null || row === void 0 ? void 0 : row.text) === 'string')
+        .map((row) => {
+        var _a, _b, _c, _d, _e, _f;
+        return ({
+            id: (_b = (_a = iri(row.id)) !== null && _a !== void 0 ? _a : iri(row)) !== null && _b !== void 0 ? _b : '',
+            key: (_d = (_c = row.ofKey) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : '',
+            language: (_e = row.language) !== null && _e !== void 0 ? _e : '',
+            text: (_f = row.text) !== null && _f !== void 0 ? _f : '',
+            status: REVISION_STATUSES.has(row.status)
+                ? row.status
+                : 'applied',
+            author: iri(row.author),
+            authorKind: row.authorKind === 'machine' ? 'machine' : 'human',
+            mtProvider: row.mtProvider || undefined,
+            basedOnText: typeof row.basedOnText === 'string' ? row.basedOnText : undefined,
+            note: row.note || undefined,
+            createdAt: isoDate(row.createdAt) || undefined,
+            decidedAt: isoDate(row.decidedAt) || undefined,
+            decidedBy: iri(row.decidedBy),
+            keyVersionId: iri(row.ofKeyVersion),
+        });
+    })
+        .sort((a, b) => {
+        var _a, _b;
+        return ((_a = b.createdAt) !== null && _a !== void 0 ? _a : '').localeCompare((_b = a.createdAt) !== null && _b !== void 0 ? _b : '') ||
+            b.id.localeCompare(a.id);
+    });
+}
+export async function getTranslationRevision(data) {
+    var _a;
+    const appId = requireText(data.appId, 'appId');
+    const revisionId = requireText(data.revisionId, 'revisionId');
+    const row = await TranslationRevision.select((revision) => [
+        revision.language,
+        revision.text,
+        revision.status,
+        revision.author,
+        revision.authorKind,
+        revision.mtProvider,
+        revision.basedOnText,
+        revision.note,
+        revision.createdAt,
+        revision.decidedAt,
+        revision.decidedBy,
+        revision.ofKeyVersion,
+        revision.ofKey.select((key) => [key.key]),
+    ])
+        .where((revision) => revision
+        .equals({ id: revisionId })
+        .and(revision.ofApplication.equals({ id: appId })))
+        .one()
+        .catch(() => null);
+    return row ? (_a = toRevisionRecords([row])[0]) !== null && _a !== void 0 ? _a : null : null;
+}
+/** Pending human proposals for the app, optionally narrowed to one language. */
+export async function listTranslationProposals(data) {
+    var _a;
+    const appId = requireText(data.appId, 'appId');
+    const language = (_a = data.language) === null || _a === void 0 ? void 0 : _a.trim();
+    const rows = await TranslationRevision.select((revision) => [
+        revision.language,
+        revision.text,
+        revision.status,
+        revision.author,
+        revision.authorKind,
+        revision.basedOnText,
+        revision.note,
+        revision.createdAt,
+        revision.ofKeyVersion,
+        revision.ofKey.select((key) => [key.key]),
+    ]).where((revision) => {
+        const base = revision.ofApplication
+            .equals({ id: appId })
+            .and(revision.status.equals('proposed'));
+        return language ? base.and(revision.language.equals(language)) : base;
+    });
+    const proposals = toRevisionRecords(rows);
+    const entries = await listTranslationEntries({ appId });
+    const current = new Map(entries.flatMap((entry) => Object.entries(entry.units).map(([unitLanguage, unit]) => [
+        `${entry.key}\u0000${unitLanguage}`,
+        unit.text,
+    ])));
+    return proposals.map((proposal) => {
+        var _a, _b;
+        const currentText = (_a = current.get(`${proposal.key}\u0000${proposal.language}`)) !== null && _a !== void 0 ? _a : '';
+        return {
+            ...proposal,
+            currentText,
+            conflicted: ((_b = proposal.basedOnText) !== null && _b !== void 0 ? _b : '') !== currentText,
+        };
+    });
+}
+export async function decideTranslationProposal(data, reviewer) {
+    var _a, _b, _c, _d, _e, _f;
+    const proposal = await getTranslationRevision({
+        appId: data.appId,
+        revisionId: data.revisionId,
+    });
+    if (!proposal || proposal.status !== 'proposed') {
+        throw new Error('This translation proposal is no longer pending.');
+    }
+    const decisionNote = (_a = data.note) === null || _a === void 0 ? void 0 : _a.trim();
+    if (data.decision === 'reject' && !decisionNote) {
+        throw new Error('A reviewer note is required when rejecting a proposal.');
+    }
+    const now = new Date().toISOString();
+    let unit;
+    if (data.decision === 'accept') {
+        const currentEntries = await listTranslationEntries({ appId: data.appId });
+        const currentText = (_d = (_c = (_b = currentEntries.find(({ key }) => key === proposal.key)) === null || _b === void 0 ? void 0 : _b.units[proposal.language]) === null || _c === void 0 ? void 0 : _c.text) !== null && _d !== void 0 ? _d : '';
+        if (((_e = proposal.basedOnText) !== null && _e !== void 0 ? _e : '') !== currentText) {
+            throw new Error('This proposal conflicts with a newer translation. Review it again before accepting.');
+        }
+        await upsertTranslationUnit({
+            appId: data.appId,
+            key: proposal.key,
+            language: proposal.language,
+            text: proposal.text,
+            state: 'reviewed',
+        }, {
+            author: reviewer,
+            authorKind: 'human',
+            note: data.note || `Accepted proposal ${proposal.id}.`,
+        });
+        unit = {
+            language: proposal.language,
+            text: proposal.text,
+            state: 'reviewed',
+            updatedAt: now,
+        };
+        const competing = await listTranslationProposals({
+            appId: data.appId,
+            language: proposal.language,
+        });
+        await Promise.all(competing
+            .filter(({ id, key }) => id !== proposal.id && key === proposal.key)
+            .map((revision) => TranslationRevision.update({
+            status: 'superseded',
+            note: `Superseded by accepted proposal ${proposal.id}.`,
+            decidedAt: new Date(now),
+            decidedBy: reviewer ? { id: reviewer } : undefined,
+        }).for({ id: revision.id })));
+    }
+    await TranslationRevision.update({
+        status: data.decision === 'accept' ? 'accepted' : 'rejected',
+        note: decisionNote || proposal.note,
+        decidedAt: new Date(now),
+        decidedBy: reviewer ? { id: reviewer } : undefined,
+    }).for({ id: proposal.id });
+    return {
+        revision: {
+            ...proposal,
+            status: data.decision === 'accept' ? 'accepted' : 'rejected',
+            note: decisionNote || proposal.note,
+            decidedAt: now,
+            decidedBy: reviewer,
+            conflicted: false,
+            currentText: (_f = unit === null || unit === void 0 ? void 0 : unit.text) !== null && _f !== void 0 ? _f : proposal.currentText,
+        },
+        unit,
+    };
+}
+/**
+ * Idempotent key write shared by the RPC provider and managed key-sync flows.
+ * Source drift marks every existing language unit stale before returning.
+ */
+export async function upsertTranslationKey(data, authorship = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    const appId = requireText(data.appId, 'appId');
+    const key = requireText(data.key, 'key');
+    requireText(data.sourceText, 'sourceText');
+    const id = keyIri(appId, key);
+    const values = {
+        namespace: (_a = data.namespace) !== null && _a !== void 0 ? _a : key.split('.').slice(0, -1).join('.'),
+        key,
+        sourceText: data.sourceText,
+        description: data.description,
+        kind: (_b = data.kind) !== null && _b !== void 0 ? _b : 'ui',
+        ofApplication: { id: appId },
+        ofNode: data.ofNode ? { id: data.ofNode } : undefined,
+        ofField: data.ofField,
+        ofShape: data.ofShape ? { id: data.ofShape } : undefined,
+        ofProperty: data.ofProperty ? { id: data.ofProperty } : undefined,
+        fromPackage: data.fromPackage,
+        overridden: data.overridden === true ? true : undefined,
+        format: (_c = data.format) !== null && _c !== void 0 ? _c : 'simple',
+    };
+    const existing = await TranslationKey.select((k) => [
+        k.sourceText,
+        k.format,
+        k.ofShape,
+        k.overridden,
+        k.currentVersion,
+    ])
+        .where((k) => k.equals({ id }))
+        .one()
+        .catch(() => null);
+    if (existing) {
+        const sourceChanged = existing.sourceText !== data.sourceText;
+        const wasOverridden = existing.overridden === true;
+        // AD-N override rule: editing the source of a SHAPE-owned key through the
+        // per-app path (this write) marks the app copy `overridden`, so shape-route
+        // propagation won't clobber the app's local wording. An explicit
+        // `data.overridden` (e.g. the installer clearing it) always wins.
+        const isShapeKey = !!existing.ofShape || !!data.ofShape;
+        if (data.overridden === undefined && isShapeKey && sourceChanged) {
+            values.overridden = true;
+            // Snapshot the canonical at FIRST divergence so "clear override" has a
+            // value to revert to even for a single-app project. Later edits keep the
+            // original snapshot (don't re-capture the already-overridden wording).
+            if (!wasOverridden)
+                values.shapeSource = existing.sourceText;
+        }
+        const currentVersion = await ensureCurrentKeyVersion({
+            appId,
+            keyId: id,
+            currentVersion: existing.currentVersion,
+            sourceLanguage: (_d = data.sourceLanguage) !== null && _d !== void 0 ? _d : 'en',
+            sourceText: (_e = existing.sourceText) !== null && _e !== void 0 ? _e : '',
+            format: existing.format === 'icu' ? 'icu' : 'simple',
+            createdBy: authorship.createdBy,
+        });
+        const decision = classifyKeyVersion(currentVersion, {
+            sourceText: data.sourceText,
+            format: (_f = data.format) !== null && _f !== void 0 ? _f : 'simple',
+        });
+        const nextVersion = decision.action === 'create-version'
+            ? await createTranslationKeyVersion({
+                appId,
+                keyId: id,
+                sourceLanguage: (_h = (_g = data.sourceLanguage) !== null && _g !== void 0 ? _g : currentVersion.sourceLanguage) !== null && _h !== void 0 ? _h : 'en',
+                sourceText: data.sourceText,
+                format: (_j = data.format) !== null && _j !== void 0 ? _j : 'simple',
+                supersedes: currentVersion.id,
+                createdBy: authorship.createdBy,
+            })
+            : currentVersion;
+        values.currentVersion = { id: nextVersion.id };
+        await TranslationKey.update(values).for({ id });
+        if (decision.action === 'create-version') {
+            await TranslationUnit.update({ state: 'stale' }).where((u) => u.ofKey.equals({ id }));
+        }
+        return {
+            id,
+            versionId: nextVersion.id,
+            versionCreated: decision.action === 'create-version',
+        };
+    }
+    await TranslationKey.create({ __id: id, ...values });
+    const firstVersion = await createTranslationKeyVersion({
+        appId,
+        keyId: id,
+        sourceLanguage: (_k = data.sourceLanguage) !== null && _k !== void 0 ? _k : 'en',
+        sourceText: data.sourceText,
+        format: (_l = data.format) !== null && _l !== void 0 ? _l : 'simple',
+        createdBy: authorship.createdBy,
+    });
+    await TranslationKey.update({
+        currentVersion: { id: firstVersion.id },
+    }).for({ id });
+    return { id, versionId: firstVersion.id, versionCreated: true };
+}
+/**
+ * Append one revision WITHOUT touching the unit (Plan 017 AD-P) — the write
+ * path for MT SUGGESTIONS (Slice B) and translator PROPOSALS (Slice C): a
+ * pending value a reviewer/editor applies later. `basedOnText` should carry
+ * the unit text visible to the author, for conflict detection at decision time.
+ */
+export async function createTranslationRevision(data) {
+    var _a;
+    const appId = requireText(data.appId, 'appId');
+    const key = requireText(data.key, 'key');
+    const language = requireText(data.language, 'language');
+    const { keyId, version } = await requireKeyWriteContext({
+        appId,
+        key,
+        createdBy: data.author,
+    });
+    const id = revisionIri(version.id, language);
+    await TranslationRevision.create({
+        __id: id,
+        ofApplication: { id: appId },
+        ofKey: { id: keyId },
+        ofKeyVersion: { id: version.id },
+        language,
+        text: data.text,
+        status: data.status,
+        author: data.author ? { id: data.author } : undefined,
+        authorKind: (_a = data.authorKind) !== null && _a !== void 0 ? _a : 'human',
+        mtProvider: data.mtProvider,
+        basedOnText: data.basedOnText,
+        note: data.note,
+        createdAt: new Date(),
+    });
+    return { id };
+}
+/**
+ * Idempotent unit write shared by the RPC provider, import, and (P4) MT flows.
+ * Every write that CHANGES the text also records an append-only
+ * `status:'applied'` `TranslationRevision` (Plan 017 AD-P) carrying the
+ * previous text as `basedOnText` — the audit trail behind the history UI.
+ * Re-saving identical text updates state/provenance without a revision.
+ */
+export async function upsertTranslationUnit(data, authorship = {}) {
+    var _a, _b, _c, _d;
+    const appId = requireText(data.appId, 'appId');
+    const key = requireText(data.key, 'key');
+    const language = requireText(data.language, 'language');
+    const author = (_a = authorship.author) !== null && _a !== void 0 ? _a : data.updatedBy;
+    const { keyId, version } = await requireKeyWriteContext({
+        appId,
+        key,
+        createdBy: author,
+    });
+    const now = new Date().toISOString();
+    const values = {
+        ofApplication: { id: appId },
+        ofKey: { id: keyId },
+        ofKeyVersion: { id: version.id },
+        language,
+        text: data.text,
+        state: (_b = data.state) !== null && _b !== void 0 ? _b : 'reviewed',
+        updatedAt: new Date(now),
+        updatedBy: author ? { id: author } : undefined,
+        origin: authorship.mtProvider === 'tm' ? 'tm' : '',
+    };
+    const existing = await TranslationUnit.select((u) => [u.text])
+        .where((u) => u.language
+        .equals(language)
+        .and(u.ofKeyVersion.equals({ id: version.id })))
+        .one()
+        .catch(() => null);
+    const id = (_c = iri(existing === null || existing === void 0 ? void 0 : existing.id)) !== null && _c !== void 0 ? _c : unitIri(version.id, language);
+    if (existing)
+        await TranslationUnit.update(values).for({ id });
+    else
+        await TranslationUnit.create({ __id: id, ...values });
+    const previousText = existing === null || existing === void 0 ? void 0 : existing.text;
+    if (existing && previousText === data.text)
+        return { id };
+    const revisionId = revisionIri(version.id, language);
+    await TranslationRevision.create({
+        __id: revisionId,
+        ofApplication: { id: appId },
+        ofKey: { id: keyId },
+        ofKeyVersion: { id: version.id },
+        language,
+        text: data.text,
+        status: 'applied',
+        author: author ? { id: author } : undefined,
+        authorKind: (_d = authorship.authorKind) !== null && _d !== void 0 ? _d : 'human',
+        mtProvider: authorship.mtProvider,
+        basedOnText: previousText,
+        note: authorship.note,
+        createdAt: new Date(now),
+    });
+    return { id, revisionId };
+}
+/** One app-scoped lookup powers both exact TM and same-key carry-forward. */
+export async function listTranslationMemoryMatches(data) {
+    const appId = requireText(data.appId, 'appId');
+    const key = requireText(data.key, 'key');
+    const language = requireText(data.language, 'language');
+    const keyId = keyIri(appId, key);
+    const keyRow = await TranslationKey.select((candidate) => [
+        candidate.currentVersion,
+    ])
+        .where((candidate) => candidate.equals({ id: keyId }))
+        .one()
+        .catch(() => null);
+    const currentVersionId = iri(keyRow === null || keyRow === void 0 ? void 0 : keyRow.currentVersion);
+    const currentVersion = currentVersionId
+        ? await readKeyVersion(currentVersionId)
+        : null;
+    if (!currentVersion)
+        return [];
+    const rows = await TranslationUnit.select((unit) => [
+        unit.language,
+        unit.text,
+        unit.state,
+        unit.updatedAt,
+        unit.ofKey.select((candidate) => [candidate.key]),
+        unit.ofKeyVersion.select((version) => [
+            version.sourceText,
+            version.sourceHash,
+            version.contractHash,
+        ]),
+    ]).where((unit) => unit.ofApplication
+        .equals({ id: appId })
+        .and(unit.language.equals(language))
+        .and(unit.state.equals('reviewed')));
+    return classifyTranslationMemoryMatches({
+        key,
+        language,
+        currentVersion,
+        rows: rows,
+    });
+}
+/** App-scoped reviewed-unit index for search, audit, and exact reuse. */
+export async function listTranslationMemory(data) {
+    const appId = requireText(data.appId, 'appId');
+    const rows = await TranslationUnit.select((unit) => [
+        unit.language,
+        unit.text,
+        unit.state,
+        unit.updatedAt,
+        unit.ofKey.select((candidate) => [candidate.key]),
+        unit.ofKeyVersion.select((version) => [
+            version.sourceText,
+            version.sourceHash,
+            version.contractHash,
+        ]),
+    ]).where((unit) => unit.ofApplication
+        .equals({ id: appId })
+        .and(unit.state.equals('reviewed')));
+    return toTranslationMemoryRecords(rows);
+}
+/** Preview or apply every safe exact-match TM candidate for one language. */
+export async function pretranslateFromMemory(data, authorship = {}) {
+    const appId = requireText(data.appId, 'appId');
+    const language = requireText(data.language, 'language');
+    const [entries, memory] = await Promise.all([
+        listTranslationEntries({ appId }),
+        listTranslationMemory({ appId }),
+    ]);
+    const candidates = findExactMemoryPretranslations({
+        entries,
+        memory,
+        language,
+    });
+    if (!data.dryRun) {
+        for (const candidate of candidates) {
+            await upsertTranslationUnit({
+                appId,
+                key: candidate.key,
+                language,
+                text: candidate.text,
+                state: 'machine',
+            }, {
+                author: authorship.author,
+                authorKind: 'machine',
+                mtProvider: 'tm',
+                note: `Exact translation-memory match from ${candidate.sourceKey}.`,
+            });
+        }
+    }
+    return {
+        language,
+        eligible: candidates.length,
+        translated: data.dryRun ? 0 : candidates.length,
+        candidates,
+    };
+}
+/** App-data termbase read shared by Studio, MT, and publish quality gates. */
+export async function listGlossaryTerms(data) {
+    requireText(data.appId, 'appId');
+    const rows = await GlossaryTerm.select((glossary) => [
+        glossary.term,
+        glossary.translation,
+        glossary.language,
+        glossary.description,
+        glossary.termType,
+        glossary.useInstead,
+        glossary.caseSensitive,
+    ]).catch(() => []);
+    return (rows !== null && rows !== void 0 ? rows : [])
+        .filter((row) => row === null || row === void 0 ? void 0 : row.term)
+        .map((row) => {
+        var _a, _b;
+        return ({
+            id: typeof row.id === 'string' ? row.id : ((_b = (_a = row.id) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : ''),
+            term: row.term,
+            termType: row.termType === 'keep' || row.termType === 'forbid' || row.termType === 'require'
+                ? row.termType
+                : 'prefer',
+            translation: row.translation || undefined,
+            useInstead: row.useInstead || undefined,
+            language: row.language || undefined,
+            caseSensitive: row.caseSensitive === true || row.caseSensitive === 'true'
+                ? true
+                : undefined,
+            description: row.description || undefined,
+        });
+    })
+        .sort((left, right) => {
+        var _a, _b;
+        return left.term.localeCompare(right.term) ||
+            ((_a = left.language) !== null && _a !== void 0 ? _a : '').localeCompare((_b = right.language) !== null && _b !== void 0 ? _b : '');
+    });
+}
+/**
+ * Apply a server-validated memory candidate. Exact matches retain `machine`
+ * state and `tm` provenance; changed-source carry-forward is an explicit
+ * reviewer action and becomes reviewed.
+ */
+export async function applyTranslationMemoryMatch(data, authorship = {}) {
+    const unitId = requireText(data.unitId, 'unitId');
+    const match = (await listTranslationMemoryMatches({
+        appId: data.appId,
+        key: data.key,
+        language: data.language,
+    })).find((candidate) => candidate.unitId === unitId);
+    if (!match) {
+        throw new Error('Translation-memory candidate is no longer compatible with this key version.');
+    }
+    const state = match.kind === 'exact' ? 'machine' : 'reviewed';
+    await upsertTranslationUnit({
+        appId: data.appId,
+        key: data.key,
+        language: data.language,
+        text: match.text,
+        state,
+    }, {
+        author: authorship.author,
+        authorKind: match.kind === 'exact' ? 'machine' : 'human',
+        mtProvider: match.kind === 'exact' ? 'tm' : undefined,
+        note: match.kind === 'exact'
+            ? `Exact translation-memory match from ${match.key}.`
+            : `Reviewed carry-forward from ${match.keyVersionId}.`,
+    });
+    return {
+        language: data.language,
+        text: match.text,
+        state,
+        origin: match.kind === 'exact' ? 'tm' : undefined,
+        updatedAt: new Date().toISOString(),
+    };
+}
+/** Server boundary for app-scoped translation keys and language units. */
+export class TranslationProvider extends ShapeProvider {
+    constructor() {
+        super(...arguments);
+        this.shape = TranslationKey;
+    }
+    /**
+     * Authoring gate. Reads `linkedAuth` off the request the LINKED server already
+     * populates — framework-level, so this stays portable (no CN/create-now-js
+     * import, AD-G). Anonymous callers can no longer read or write an app's
+     * translation content via `/call`. Fine-grained "is translation enabled for
+     * this app + is the caller a project member" gating is a Create Now concern and
+     * is enforced additionally at the CN route layer (`isTranslationEnabledForApp`).
+     * `getMessages` intentionally stays public — it is the app's runtime string
+     * fetch, not an authoring surface.
+     */
+    requireAuthor() {
+        var _a, _b;
+        const account = (_b = (_a = this.request) === null || _a === void 0 ? void 0 : _a.linkedAuth) === null || _b === void 0 ? void 0 : _b.userAccount;
+        if (!account) {
+            throw new Error('Authentication required to read or edit translations.');
+        }
+    }
+    async requireAccess(data, action) {
+        this.requireAuthor();
+        const actorWebId = this.authorIri();
+        if (!actorWebId ||
+            !(await canAuthorTranslation({
+                appId: data.appId,
+                actorWebId,
+                action,
+                language: data.language,
+            }))) {
+            throw new Error(`Translation ${action} permission required.`);
+        }
+    }
+    async listKeys(data) {
+        this.requireAuthor();
+        return listTranslationKeys(data);
+    }
+    async listEntries(data) {
+        this.requireAuthor();
+        return listTranslationEntries(data);
+    }
+    async listKeyVersions(data) {
+        this.requireAuthor();
+        return listTranslationKeyVersions(data);
+    }
+    async listMemoryMatches(data) {
+        this.requireAuthor();
+        return listTranslationMemoryMatches(data);
+    }
+    async proposeRevision(data) {
+        var _a, _b, _c;
+        await this.requireAccess(data, 'propose');
+        const currentEntries = await listTranslationEntries({ appId: data.appId });
+        const basedOnText = (_c = (_b = (_a = currentEntries.find(({ key }) => key === data.key)) === null || _a === void 0 ? void 0 : _a.units[data.language]) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : '';
+        return createTranslationRevision({
+            ...data,
+            basedOnText,
+            status: 'proposed',
+            author: this.authorIri(),
+            authorKind: 'human',
+        });
+    }
+    async listProposals(data) {
+        this.requireAuthor();
+        const actorWebId = this.authorIri();
+        if (!actorWebId)
+            throw new Error('Translation read permission required.');
+        const proposals = await listTranslationProposals(data);
+        const allowed = await Promise.all(proposals.map((proposal) => canAuthorTranslation({
+            appId: data.appId,
+            actorWebId,
+            action: 'read',
+            language: proposal.language,
+        })));
+        return proposals.filter((_, index) => allowed[index]);
+    }
+    async decideProposal(data) {
+        const proposal = await getTranslationRevision({
+            appId: data.appId,
+            revisionId: data.revisionId,
+        });
+        if (!proposal) {
+            throw new Error('This translation proposal is no longer pending.');
+        }
+        await this.requireAccess({ appId: data.appId, language: proposal.language }, 'review');
+        return decideTranslationProposal(data, this.authorIri());
+    }
+    async listMemory(data) {
+        this.requireAuthor();
+        return listTranslationMemory(data);
+    }
+    async pretranslateMemory(data) {
+        await this.requireAccess(data, 'run-mt');
+        return pretranslateFromMemory(data, { author: this.authorIri() });
+    }
+    async applyMemoryMatch(data) {
+        await this.requireAccess(data, 'review');
+        return applyTranslationMemoryMatch(data, { author: this.authorIri() });
+    }
+    async listReleases(data) {
+        this.requireAuthor();
+        return listTranslationReleases(data);
+    }
+    async createRelease(data) {
+        this.requireAuthor();
+        return createTranslationRelease(data);
+    }
+    async advanceReleaseHotfix(data) {
+        this.requireAuthor();
+        return advanceTranslationReleaseHotfix(data);
+    }
+    async upsertKey(data) {
+        this.requireAuthor();
+        return upsertTranslationKey(data, { createdBy: this.authorIri() });
+    }
+    /** WebID of the signed-in caller — never trust a client-supplied author. */
+    authorIri() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const auth = (_a = this.request) === null || _a === void 0 ? void 0 : _a.linkedAuth;
+        const webId = (_g = (_e = (_d = (_c = (_b = auth === null || auth === void 0 ? void 0 : auth.userAccount) === null || _b === void 0 ? void 0 : _b.accountOf) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : auth === null || auth === void 0 ? void 0 : auth.webId) !== null && _e !== void 0 ? _e : (_f = auth === null || auth === void 0 ? void 0 : auth.userAccount) === null || _f === void 0 ? void 0 : _f.id) !== null && _g !== void 0 ? _g : auth === null || auth === void 0 ? void 0 : auth.userAccount;
+        return typeof webId === 'string' && webId ? webId : undefined;
+    }
+    async upsertUnit(data) {
+        await this.requireAccess(data, 'review');
+        return upsertTranslationUnit({ ...data, updatedBy: undefined }, { author: this.authorIri(), authorKind: 'human' });
+    }
+    /**
+     * Glossary CRUD (Plan 017 Slice B). App-data is branch-routed per app, so
+     * every GlossaryTerm in context belongs to the calling app; the appId only
+     * anchors the IRIs. Uniqueness = (term, language) — upsert is
+     * delete-then-create on that identity.
+     */
+    async listGlossary(data) {
+        this.requireAuthor();
+        return listGlossaryTerms(data);
+    }
+    async upsertGlossaryTerm(data) {
+        var _a, _b, _c, _d, _e;
+        await this.requireAccess(data, 'manage');
+        const appId = requireText(data.appId, 'appId');
+        const term = requireText(data.term, 'term');
+        const language = ((_a = data.language) === null || _a === void 0 ? void 0 : _a.trim()) || '';
+        const termType = data.termType === 'keep' || data.termType === 'forbid' || data.termType === 'require'
+            ? data.termType
+            : 'prefer';
+        if (termType === 'require' && !((_b = data.translation) === null || _b === void 0 ? void 0 : _b.trim())) {
+            throw new Error('A required glossary term needs a translation.');
+        }
+        const id = `${appId.replace(/\/$/, '')}/translation/glossary/${encodeURIComponent(term)}--${encodeURIComponent(language || 'all')}`;
+        // Delete-then-create: INSERT DATA is add-only, re-saving would duplicate.
+        await GlossaryTerm.delete({ id }).catch(() => { });
+        await GlossaryTerm.create({
+            __id: id,
+            term,
+            termType,
+            translation: termType === 'prefer' || termType === 'require' ? ((_c = data.translation) === null || _c === void 0 ? void 0 : _c.trim()) || undefined : undefined,
+            useInstead: termType === 'forbid' ? ((_d = data.useInstead) === null || _d === void 0 ? void 0 : _d.trim()) || undefined : undefined,
+            language: language || undefined,
+            caseSensitive: data.caseSensitive === true ? true : undefined,
+            description: ((_e = data.description) === null || _e === void 0 ? void 0 : _e.trim()) || undefined,
+        });
+        return { id };
+    }
+    async deleteGlossaryTerm(data) {
+        await this.requireAccess(data, 'manage');
+        const appId = requireText(data.appId, 'appId');
+        const id = requireText(data.id, 'id');
+        // Only glossary nodes under this app's namespace may be deleted here.
+        if (!id.startsWith(`${appId.replace(/\/$/, '')}/translation/glossary/`)) {
+            throw new Error('Not a glossary entry of this app.');
+        }
+        await GlossaryTerm.delete({ id });
+        return { deleted: true };
+    }
+    /** History for one (key, language) cell — newest first (Plan 017 AD-P). */
+    async listRevisions(data) {
+        this.requireAuthor();
+        const appId = requireText(data.appId, 'appId');
+        const key = requireText(data.key, 'key');
+        const language = requireText(data.language, 'language');
+        const keyId = keyIri(appId, key);
+        const rows = await TranslationRevision.select((r) => [
+            r.language,
+            r.text,
+            r.status,
+            r.author,
+            r.authorKind,
+            r.mtProvider,
+            r.basedOnText,
+            r.note,
+            r.createdAt,
+            r.decidedAt,
+            r.decidedBy,
+            r.ofKeyVersion,
+            r.ofKey.select((k) => [k.key]),
+        ]).where((r) => r.language.equals(language).and(r.ofKey.equals({ id: keyId })));
+        return toRevisionRecords(rows);
+    }
+    async getMessages(data) {
+        const appId = requireText(data.appId, 'appId');
+        const language = requireText(data.language, 'language');
+        const rows = await TranslationUnit.select((u) => [
+            u.text,
+            u.ofKeyVersion,
+            u.ofKey.select((k) => [k.key, k.format, k.currentVersion]),
+        ]).where((u) => u.language
+            .equals(language)
+            .and(u.ofKey.ofApplication.equals({ id: appId })));
+        return Object.fromEntries((rows !== null && rows !== void 0 ? rows : [])
+            .filter((row) => {
+            var _a;
+            const currentVersion = iri((_a = row.ofKey) === null || _a === void 0 ? void 0 : _a.currentVersion);
+            const unitVersion = iri(row.ofKeyVersion);
+            return !currentVersion || currentVersion === unitVersion;
+        })
+            .map((row) => {
+            var _a, _b;
+            return [
+                (_a = row.ofKey) === null || _a === void 0 ? void 0 : _a.key,
+                ((_b = row.ofKey) === null || _b === void 0 ? void 0 : _b.format) === 'icu'
+                    ? { message: row.text, format: 'icu' }
+                    : row.text,
+            ];
+        })
+            .filter(([key]) => typeof key === 'string' && key.length > 0));
+    }
+}
+//# sourceMappingURL=TranslationProvider.js.map