@_linked/translation 0.2.2

package/src/message-format.ts

@@ -0,0 +1,214 @@
+import {
+  isArgumentElement,
+  isDateElement,
+  isNumberElement,
+  isPluralElement,
+  isSelectElement,
+  isTagElement,
+  isTimeElement,
+  parse,
+  type MessageFormatElement,
+} from '@formatjs/icu-messageformat-parser';
+import type { MessageFormat } from './core/messages.js';
+
+export type MessageArgumentKind =
+  | 'argument'
+  | 'number'
+  | 'date'
+  | 'time'
+  | 'select'
+  | 'plural'
+  | 'selectordinal';
+
+export interface MessageArgument {
+  name: string;
+  kinds: MessageArgumentKind[];
+}
+
+export interface MessageAnalysis {
+  valid: boolean;
+  arguments: MessageArgument[];
+  error?: string;
+}
+
+export interface MessageArgumentComparison {
+  valid: boolean;
+  missing: string[];
+  extra: string[];
+  typeMismatches: Array<{
+    name: string;
+    source: MessageArgumentKind[];
+    target: MessageArgumentKind[];
+  }>;
+  sourceError?: string;
+  targetError?: string;
+}
+
+export interface LegacyPluralSuffix {
+  countArgument: string;
+  suffixArgument: string;
+}
+
+/**
+ * FormatSimple remains intentionally looser than ICU identifiers: existing
+ * apps may use positional (`{0}`), dotted (`{user.name}`), hyphenated
+ * (`{item-count}`), or Unicode (`{名前}`) variable names.
+ */
+const SIMPLE_ARGUMENT_RE =
+  /\{\s*([\p{L}\p{N}_][\p{L}\p{N}\p{M}_.-]*)\s*\}/gu;
+
+function argumentKind(element: MessageFormatElement): MessageArgumentKind | null {
+  if (isArgumentElement(element)) return 'argument';
+  if (isNumberElement(element)) return 'number';
+  if (isDateElement(element)) return 'date';
+  if (isTimeElement(element)) return 'time';
+  if (isSelectElement(element)) return 'select';
+  if (isPluralElement(element)) {
+    return element.pluralType === 'ordinal' ? 'selectordinal' : 'plural';
+  }
+  return null;
+}
+
+function collectIcuArguments(
+  elements: MessageFormatElement[],
+  found: Map<string, Set<MessageArgumentKind>>,
+): void {
+  for (const element of elements) {
+    const kind = argumentKind(element);
+    if (kind && 'value' in element) {
+      const kinds = found.get(element.value) ?? new Set<MessageArgumentKind>();
+      kinds.add(kind);
+      found.set(element.value, kinds);
+    }
+    if (isPluralElement(element) || isSelectElement(element)) {
+      for (const option of Object.values(element.options)) {
+        collectIcuArguments(option.value, found);
+      }
+    } else if (isTagElement(element)) {
+      collectIcuArguments(element.children, found);
+    }
+  }
+}
+
+const toArguments = (
+  found: Map<string, Set<MessageArgumentKind>>,
+): MessageArgument[] =>
+  [...found.entries()]
+    .map(([name, kinds]) => ({ name, kinds: [...kinds].sort() }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+
+/** Parse the variables a translator must preserve in a simple or ICU message. */
+export function analyzeMessage(
+  text: string,
+  format: MessageFormat = 'simple',
+): MessageAnalysis {
+  const found = new Map<string, Set<MessageArgumentKind>>();
+  if (format === 'simple') {
+    for (const match of text.matchAll(SIMPLE_ARGUMENT_RE)) {
+      found.set(match[1], new Set(['argument']));
+    }
+    return { valid: true, arguments: toArguments(found) };
+  }
+
+  try {
+    collectIcuArguments(
+      parse(text, { ignoreTag: true, requiresOtherClause: true }),
+      found,
+    );
+    return { valid: true, arguments: toArguments(found) };
+  } catch (cause) {
+    return {
+      valid: false,
+      arguments: [],
+      error: cause instanceof Error ? cause.message : String(cause),
+    };
+  }
+}
+
+/**
+ * Compare runtime arguments without requiring identical word order or plural
+ * categories. Categories legitimately differ by language; variable names and
+ * their ICU roles may not.
+ */
+export function compareMessageArguments(
+  source: string,
+  target: string,
+  format: MessageFormat = 'simple',
+): MessageArgumentComparison {
+  const sourceAnalysis = analyzeMessage(source, format);
+  const targetAnalysis = analyzeMessage(target, format);
+  const sourceByName = new Map(
+    sourceAnalysis.arguments.map((argument) => [argument.name, argument]),
+  );
+  const targetByName = new Map(
+    targetAnalysis.arguments.map((argument) => [argument.name, argument]),
+  );
+  const optionalLegacySuffixes =
+    format === 'simple'
+      ? new Set(
+          detectLegacyPluralSuffixes(source).map(
+            ({ suffixArgument }) => suffixArgument,
+          ),
+        )
+      : new Set<string>();
+  const missing = [...sourceByName.keys()]
+    .filter((name) => !targetByName.has(name) && !optionalLegacySuffixes.has(name))
+    .sort();
+  const extra = [...targetByName.keys()]
+    .filter((name) => !sourceByName.has(name))
+    .sort();
+  const typeMismatches = [...sourceByName.keys()]
+    .filter((name) => targetByName.has(name))
+    .flatMap((name) => {
+      const sourceKinds = sourceByName.get(name)!.kinds;
+      const targetKinds = targetByName.get(name)!.kinds;
+      return sourceKinds.length === targetKinds.length &&
+        sourceKinds.every((kind, index) => kind === targetKinds[index])
+        ? []
+        : [{ name, source: sourceKinds, target: targetKinds }];
+    });
+
+  return {
+    valid:
+      sourceAnalysis.valid &&
+      targetAnalysis.valid &&
+      missing.length === 0 &&
+      extra.length === 0 &&
+      typeMismatches.length === 0,
+    missing,
+    extra,
+    typeMismatches,
+    sourceError: sourceAnalysis.error,
+    targetError: targetAnalysis.error,
+  };
+}
+
+/**
+ * Detect the legacy English suffix idiom (`{n} mission{s}`). `{s}` is not a
+ * plural operator; callers merely pass either "s" or "". Other languages may
+ * omit it, and the key should eventually be rewritten as an ICU plural.
+ */
+export function detectLegacyPluralSuffixes(
+  text: string,
+): LegacyPluralSuffix[] {
+  const countArguments = [
+    ...text.matchAll(
+      /\{\s*([\p{L}\p{N}_][\p{L}\p{N}\p{M}_.-]*)\s*\}/gu,
+    ),
+  ].map((match) => match[1]);
+  if (countArguments.length < 2) return [];
+  const suffixes = [
+    ...text.matchAll(
+      /[\p{L}\p{N}]\{\s*([\p{L}\p{N}_][\p{L}\p{N}\p{M}_.-]*)\s*\}/gu,
+    ),
+  ].map((match) => match[1]);
+  if (suffixes.length === 0) return [];
+  const countArgument = countArguments.find(
+    (name) => !suffixes.includes(name),
+  );
+  if (!countArgument) return [];
+  return [...new Set(suffixes)].map((suffixArgument) => ({
+    countArgument,
+    suffixArgument,
+  }));
+}

package/src/mt.ts

@@ -0,0 +1,248 @@
+/**
+ * Machine-translation provider registry (Plan 014 AD-L / Plan 017 Slice B).
+ * Providers implement one method — translate a batch of UI strings — and
+ * register by key ('claude', 'deepl', …). Resolution is PER TARGET LANGUAGE
+ * with a fallback chain: not every provider covers every language (DeepL has
+ * no Swahili or Urdu), so the preferred provider is used where it supports
+ * the target and the chain falls through otherwise. Pure module: no I/O, no
+ * SDK imports — concrete providers live with the host (Create Now) and are
+ * registered at boot.
+ */
+import {
+  analyzeMessage,
+  compareMessageArguments,
+} from './message-format.js';
+import type { MessageFormat } from './core/messages.js';
+
+export interface MtItem {
+  key: string;
+  sourceText: string;
+  /** Authoring context shown to the translator/model. */
+  description?: string;
+  format?: 'simple' | 'icu';
+}
+
+export interface MtGlossaryEntry {
+  term: string;
+  /** prefer (default) = translate as `translation`; keep = do-not-translate; forbid = never use. */
+  termType?: 'prefer' | 'require' | 'keep' | 'forbid';
+  /** Preferred translation (prefer entries); empty/undefined = keep the term as-is. */
+  translation?: string;
+  /** Replacement wording (forbid entries). */
+  useInstead?: string;
+  /** Target language this applies to; empty = all languages. */
+  language?: string;
+  /** Exact-casing matching (proper nouns / brand styling). */
+  caseSensitive?: boolean;
+  description?: string;
+}
+
+/** Register/tone controls (Plan 017 §7.4b) — NOT sampling temperature. */
+export interface MtStyle {
+  formality?: 'formal' | 'informal';
+  /** Free-text tone guidance, e.g. "friendly, energetic, no bureaucratese". */
+  note?: string;
+}
+
+/** An established translation the provider should stay consistent with. */
+export interface MtReference {
+  sourceText: string;
+  text: string;
+}
+
+export interface MtBatchRequest {
+  sourceLanguage: string;
+  targetLanguage: string;
+  items: MtItem[];
+  glossary: MtGlossaryEntry[];
+  style?: MtStyle;
+  /** Translation-memory context: reviewed units for consistency (Plan 017 §7.4c). */
+  references?: MtReference[];
+}
+
+export interface MtBatchResult {
+  key: string;
+  text: string;
+}
+
+export interface TranslationMtProvider {
+  readonly key: string;
+  /** Absent ⇒ the provider claims every language. */
+  supportsLanguage?(language: string): boolean;
+  translateBatch(request: MtBatchRequest): Promise<MtBatchResult[]>;
+}
+
+const providers = new Map<string, TranslationMtProvider>();
+
+export function registerMtProvider(provider: TranslationMtProvider): void {
+  providers.set(provider.key, provider);
+}
+
+export function getMtProvider(key: string): TranslationMtProvider | undefined {
+  return providers.get(key);
+}
+
+export function listMtProviders(): TranslationMtProvider[] {
+  return [...providers.values()];
+}
+
+/** Test seam. */
+export function clearMtProviders(): void {
+  providers.clear();
+}
+
+/**
+ * Ordered provider chain for one target language: the preferred provider
+ * first when it exists AND supports the language, then every other provider
+ * that supports it, registration order.
+ */
+export function resolveMtProviders(
+  targetLanguage: string,
+  preferred?: string,
+): TranslationMtProvider[] {
+  const supports = (p: TranslationMtProvider) =>
+    !p.supportsLanguage || p.supportsLanguage(targetLanguage);
+  const chain = listMtProviders().filter(supports);
+  if (!preferred) return chain;
+  const first = chain.find((p) => p.key === preferred);
+  if (!first) return chain;
+  return [first, ...chain.filter((p) => p !== first)];
+}
+
+/** Unique `{placeholder}` tokens in a message, sorted for set comparison. */
+export function extractPlaceholders(
+  text: string,
+  format: MessageFormat = 'simple',
+): string[] {
+  return analyzeMessage(text, format).arguments.map(({ name }) => name);
+}
+
+/**
+ * A translation is only usable if it preserves the source's placeholder SET
+ * exactly — a dropped or renamed `{param}` breaks interpolation at runtime.
+ */
+export function placeholdersIntact(
+  source: string,
+  translated: string,
+  format: MessageFormat = 'simple',
+): boolean {
+  return compareMessageArguments(source, translated, format).valid;
+}
+
+/** Glossary entries applying to one target language (global + language-specific). */
+export function glossaryForLanguage(
+  glossary: MtGlossaryEntry[],
+  language: string,
+): MtGlossaryEntry[] {
+  return glossary.filter((g) => !g.language || g.language === language);
+}
+
+export function chunkItems<T>(items: T[], size: number): T[][] {
+  if (size < 1) throw new Error('chunk size must be >= 1');
+  const chunks: T[][] = [];
+  for (let i = 0; i < items.length; i += size) chunks.push(items.slice(i, i + size));
+  return chunks;
+}
+
+/**
+ * Resolve the formality for one language from the encoded config entries
+ * ("formal" = app default; "de:informal" = per-language override; override wins).
+ */
+export function formalityForLanguage(
+  entries: string[],
+  language: string,
+): 'formal' | 'informal' | undefined {
+  let result: 'formal' | 'informal' | undefined;
+  for (const entry of entries ?? []) {
+    const i = entry.indexOf(':');
+    const value = i === -1 ? entry : entry.slice(i + 1);
+    if (value !== 'formal' && value !== 'informal') continue;
+    if (i === -1) {
+      if (!result) result = value;
+    } else if (entry.slice(0, i) === language) {
+      return value;
+    }
+  }
+  return result;
+}
+
+// ── Consistency (Plan 017 §7.4c) ────────────────────────────────────────
+
+/** Minimal entry view the consistency helpers need (client-safe). */
+export interface ConsistencyEntry {
+  key: string;
+  namespace?: string;
+  sourceText: string;
+  format?: 'simple' | 'icu';
+  units: Record<string, { text: string; state: string } | undefined>;
+}
+
+/** Identical English source translated DIFFERENTLY within one language. */
+export interface ConsistencyConflict {
+  sourceText: string;
+  language: string;
+  /** One entry per distinct translation: the text + the keys carrying it. */
+  variants: Array<{ text: string; keys: string[] }>;
+}
+
+/**
+ * Find keys whose IDENTICAL source text has diverging translations in a
+ * language — the core "same words, same translation" consistency check.
+ * Empty/untranslated units are ignored; whitespace-trimmed comparison.
+ */
+export function findInconsistentTranslations(
+  entries: ConsistencyEntry[],
+  language: string,
+): ConsistencyConflict[] {
+  const bySource = new Map<string, Map<string, string[]>>();
+  for (const entry of entries) {
+    const source = entry.sourceText.trim();
+    const text = entry.units[language]?.text?.trim();
+    if (!source || !text) continue;
+    const variants = bySource.get(source) ?? new Map<string, string[]>();
+    variants.set(text, [...(variants.get(text) ?? []), entry.key]);
+    bySource.set(source, variants);
+  }
+  const conflicts: ConsistencyConflict[] = [];
+  for (const [sourceText, variants] of bySource) {
+    if (variants.size < 2) continue;
+    conflicts.push({
+      sourceText,
+      language,
+      variants: [...variants].map(([text, keys]) => ({ text, keys: keys.sort() })),
+    });
+  }
+  return conflicts.sort((a, b) => a.sourceText.localeCompare(b.sourceText));
+}
+
+/**
+ * Pick reviewed units as translation-memory REFERENCES for an MT batch:
+ * same-namespace reviewed translations first (shared vocabulary), then the
+ * shortest reviewed units overall (vocabulary-dense). Deterministic.
+ */
+export function pickReferenceUnits(
+  entries: ConsistencyEntry[],
+  language: string,
+  batchNamespaces: string[],
+  max = 20,
+): MtReference[] {
+  const namespaces = new Set(batchNamespaces);
+  const reviewed = entries
+    .map((entry) => ({
+      namespace: entry.namespace ?? '',
+      sourceText: entry.sourceText.trim(),
+      unit: entry.units[language],
+    }))
+    .filter(
+      (row) =>
+        row.sourceText &&
+        row.unit?.state === 'reviewed' &&
+        row.unit.text.trim(),
+    );
+  const score = (row: (typeof reviewed)[number]) =>
+    (namespaces.has(row.namespace) ? 0 : 100000) + row.sourceText.length;
+  return reviewed
+    .sort((a, b) => score(a) - score(b) || a.sourceText.localeCompare(b.sourceText))
+    .slice(0, max)
+    .map((row) => ({ sourceText: row.sourceText, text: row.unit!.text.trim() }));
+}

package/src/ontologies/translation.ts

@@ -0,0 +1,234 @@
+import { createNameSpace } from '@_linked/core/utils/NameSpace';
+import { linkedOntology } from '../package.js';
+import * as _this from './translation.js';
+
+/** Lazy-load the (currently empty) serialized ontology graph. */
+export var loadData = () => {
+  //@ts-ignore
+  return import('../data/translation.json', { with: { type: 'json' } }).then(
+    (data) => data.default
+  );
+};
+
+/** Vocabulary namespace for the translation package. */
+export var ns = createNameSpace('https://id.linked.cm/translation/vocab#');
+export var _self = ns('');
+
+// ── Classes ─────────────────────────────────────────────────────────────
+export var TranslationKey = ns('TranslationKey');
+export var TranslationKeyVersion = ns('TranslationKeyVersion');
+export var TranslationRelease = ns('TranslationRelease');
+export var TranslationUnit = ns('TranslationUnit');
+export var TranslationRevision = ns('TranslationRevision');
+export var GlossaryTerm = ns('GlossaryTerm');
+export var TranslationInventoryOrigin = ns('TranslationInventoryOrigin');
+
+// Open language resources; BCP-47 is a string identifier, not an enum.
+export var TranslationLanguage = ns('TranslationLanguage');
+export var languageIdentifier = ns('languageIdentifier');
+export var languageCode = ns('languageCode');
+export var nativeName = ns('nativeName');
+export var englishName = ns('englishName');
+export var textDirection = ns('textDirection');
+export var parentLanguage = ns('parentLanguage');
+export var fallbackLanguage = ns('fallbackLanguage');
+export var languageEnabled = ns('languageEnabled');
+export var languageSupported = ns('languageSupported');
+
+// ── TranslationKey properties ───────────────────────────────────────────
+export var namespace = ns('namespace');
+export var key = ns('key');
+export var sourceText = ns('sourceText'); // canonical English (Plan 014 AD-J/R7)
+export var description = ns('description');
+export var kind = ns('kind'); // 'ui' | 'content' (AD-I)
+export var ofApplication = ns('ofApplication'); // owning app IRI (AD-H/R2)
+export var ofNode = ns('ofNode'); // content-translation subject (kind:'content')
+export var ofField = ns('ofField');
+export var ofShape = ns('ofShape'); // semantic SHACL shape context for package keys
+export var ofProperty = ns('ofProperty'); // semantic predicate context for package keys
+export var fromPackage = ns('fromPackage'); // package that supplied a seed catalog
+export var overridden = ns('overridden'); // app diverged this shape key from canonical → excluded from shape propagation (AD-N)
+export var shapeSource = ns('shapeSource'); // canonical source snapshot at override time → the value "clear override" reverts to (AD-N)
+export var format = ns('format'); // 'simple' | 'icu' (AD-J/R8)
+export var currentVersion = ns('currentVersion'); // → TranslationKeyVersion
+
+// ── TranslationKeyVersion properties (Plan 018) ────────────────────────
+export var versionId = ns('versionId');
+export var sourceLanguage = ns('sourceLanguage');
+export var argumentSignature = ns('argumentSignature');
+export var contractHash = ns('contractHash');
+export var sourceHash = ns('sourceHash');
+export var supersedes = ns('supersedes');
+export var createdBy = ns('createdBy');
+
+// ── TranslationRelease properties (Plan 018) ───────────────────────────
+export var branch = ns('branch');
+export var releaseId = ns('releaseId');
+export var buildId = ns('buildId');
+export var channel = ns('channel');
+export var contractSetHash = ns('contractSetHash');
+export var manifestHash = ns('manifestHash');
+export var hotfixSequence = ns('hotfixSequence');
+export var publishedAt = ns('publishedAt');
+export var supportedUntil = ns('supportedUntil');
+export var qualitySummary = ns('qualitySummary');
+
+// ── CapabilityAppConfig properties (stored in Create Now's cn-main) ────
+export var languages = ns('languages'); // active BCP-47 tags, including source
+export var defaultLanguage = ns('defaultLanguage'); // authored/source language
+export var cdnTarget = ns('cdnTarget'); // delivery base URL / bucket prefix — the "repoint" knob (AD-K, P2)
+export var autoPublish = ns('autoPublish'); // boolean — overridable auto-publish-on-edit toggle (P2, default off)
+export var reviewedOnlyLanguage = ns('reviewedOnlyLanguage'); // BCP-47 tags published reviewed-only; absence ⇒ machine-ok (AD-K/R9, P2)
+export var mtDefault = ns('mtDefault'); // default MT provider key (AD-L, unused until P4)
+export var mtFormality = ns('mtFormality'); // multi-value: "formal" (app default) or "de:informal" (per-language) — Plan 017 §7.4b
+export var mtStyleNote = ns('mtStyleNote'); // free-text tone guidance fed to LLM MT providers (Plan 017 §7.4b)
+
+// ── TranslationUnit properties ──────────────────────────────────────────
+export var ofKey = ns('ofKey'); // → TranslationKey
+export var ofKeyVersion = ns('ofKeyVersion'); // → TranslationKeyVersion
+export var language = ns('language'); // BCP-47 tag
+export var text = ns('text');
+export var state = ns('state'); // untranslated | machine | reviewed | stale
+export var updatedAt = ns('updatedAt');
+export var updatedBy = ns('updatedBy');
+export var origin = ns('origin'); // current-value provenance, e.g. `tm`
+
+// ── TranslationRevision properties (Plan 017 AD-P) ─────────────────────
+// One append-only node per authored value: history (`applied`), translator
+// proposals (`proposed`), and MT suggestions (`suggested`) share the shape.
+export var status = ns('status'); // applied | proposed | suggested | accepted | rejected | superseded
+export var author = ns('author'); // WebID or MT provider IRI
+export var authorKind = ns('authorKind'); // 'human' | 'machine'
+export var mtProvider = ns('mtProvider'); // provider key when authorKind=machine
+export var basedOnText = ns('basedOnText'); // unit text at authoring time (conflict detection)
+export var note = ns('note'); // translator/reviewer comment
+export var createdAt = ns('createdAt');
+export var decidedAt = ns('decidedAt'); // when a proposal/suggestion was accepted/rejected
+export var decidedBy = ns('decidedBy'); // WebID of the reviewer
+
+// ── GlossaryTerm properties ─────────────────────────────────────────────
+export var term = ns('term');
+export var glossaryTranslation = ns('glossaryTranslation');
+export var glossaryLanguage = ns('glossaryLanguage');
+export var termType = ns('termType'); // prefer | require | keep | forbid (Plan 017 B2-1 termbase)
+export var useInstead = ns('useInstead'); // replacement for a forbidden term/spelling
+export var caseSensitive = ns('caseSensitive'); // boolean — exact-casing matching (proper nouns)
+
+// ── Branch translation inventory metadata (Plan 017 Phase 8b) ─────────
+// These records are materialized into the active branch metadata dataset,
+// never app data. Confirmed TranslationKey/TranslationUnit records retain
+// their existing app-data placement.
+export var inventoryBranch = ns('inventoryBranch');
+export var inventoryIdentity = ns('inventoryIdentity');
+export var inventoryStatus = ns('inventoryStatus');
+export var inventorySource = ns('inventorySource');
+export var inventorySourceId = ns('inventorySourceId');
+export var inventoryAuthoritative = ns('inventoryAuthoritative');
+export var inventoryFile = ns('inventoryFile');
+export var inventoryLine = ns('inventoryLine');
+export var inventoryOwner = ns('inventoryOwner');
+export var inventoryShape = ns('inventoryShape');
+export var inventoryProperty = ns('inventoryProperty');
+export var inventoryNode = ns('inventoryNode');
+export var inventoryTargetClass = ns('inventoryTargetClass');
+export var inventoryObservedAt = ns('inventoryObservedAt');
+
+/** Grouped export for prefix/name access. */
+export const tr = {
+  TranslationLanguage,
+  languageIdentifier,
+  languageCode,
+  nativeName,
+  englishName,
+  textDirection,
+  parentLanguage,
+  fallbackLanguage,
+  languageEnabled,
+  languageSupported,
+  TranslationKey,
+  TranslationKeyVersion,
+  TranslationRelease,
+  TranslationUnit,
+  TranslationRevision,
+  GlossaryTerm,
+  TranslationInventoryOrigin,
+  namespace,
+  key,
+  sourceText,
+  description,
+  kind,
+  ofApplication,
+  ofNode,
+  ofField,
+  ofShape,
+  ofProperty,
+  fromPackage,
+  overridden,
+  shapeSource,
+  format,
+  currentVersion,
+  versionId,
+  sourceLanguage,
+  argumentSignature,
+  contractHash,
+  sourceHash,
+  supersedes,
+  createdBy,
+  branch,
+  releaseId,
+  buildId,
+  channel,
+  contractSetHash,
+  manifestHash,
+  hotfixSequence,
+  publishedAt,
+  supportedUntil,
+  qualitySummary,
+  languages,
+  defaultLanguage,
+  cdnTarget,
+  autoPublish,
+  reviewedOnlyLanguage,
+  mtDefault,
+  mtFormality,
+  mtStyleNote,
+  ofKey,
+  ofKeyVersion,
+  language,
+  text,
+  state,
+  updatedAt,
+  updatedBy,
+  origin,
+  status,
+  author,
+  authorKind,
+  mtProvider,
+  basedOnText,
+  note,
+  createdAt,
+  decidedAt,
+  decidedBy,
+  term,
+  glossaryTranslation,
+  glossaryLanguage,
+  termType,
+  useInstead,
+  caseSensitive,
+  inventoryBranch,
+  inventoryIdentity,
+  inventoryStatus,
+  inventorySource,
+  inventorySourceId,
+  inventoryAuthoritative,
+  inventoryFile,
+  inventoryLine,
+  inventoryOwner,
+  inventoryShape,
+  inventoryProperty,
+  inventoryNode,
+  inventoryTargetClass,
+  inventoryObservedAt,
+};
+
+linkedOntology(_this, ns, 'translation', loadData, '../data/translation.json');