@walkinissue/angy 0.2.17 → 0.2.18

package/dist/server.js

@@ -3,10 +3,11 @@ import { json as json4 } from "@sveltejs/kit";
 
 // src/lib/server/commit.ts
 import { json } from "@sveltejs/kit";
+import { basename as basename3 } from "node:path";
 
 // src/lib/server/catalog.ts
 import { constants as fsConstants } from "node:fs";
-import { access, copyFile, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { access, copyFile, readFile as readFile2, rename, rm, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2, extname as extname2, join, basename as basename2 } from "node:path";
 import gettextParser from "gettext-parser";
 import Fuse from "fuse.js";
@@ -102,6 +103,21 @@ function validateLocaleAliasUsage(sourceLocale, targetLocale) {
     throw new Error('[angy] targetLocale cannot be "base". Use an explicit target locale or "working".');
   }
 }
+function validateCatalogPathSemantics(next) {
+  const baseLocale = inferLocaleFromCatalogPath(next.basePoPath);
+  const workingLocale = inferLocaleFromCatalogPath(next.workingPoPath);
+  const expectedWorkingLocale = `${next.targetLocale}-working`;
+  if (baseLocale !== next.targetLocale) {
+    throw new Error(
+      `[angy] basePoPath must point to the ${next.targetLocale}.po catalog. Received "${baseLocale ?? "unknown"}".`
+    );
+  }
+  if (workingLocale !== expectedWorkingLocale) {
+    throw new Error(
+      `[angy] workingPoPath must point to the ${expectedWorkingLocale}.po catalog. Received "${workingLocale ?? "unknown"}".`
+    );
+  }
+}
 function suspendWorkingCatalogWatch(path, delayMs = 800) {
   const normalizedPath = normalizeFsPath(path);
   for (const controller of workingCatalogWatchControllers) {
@@ -124,12 +140,14 @@ function resolveConfiguredLocaleAliases(next) {
   const resolvedSourceLocale = resolveLocaleAlias(rawSourceLocale, next);
   const resolvedTargetLocale = resolveLocaleAlias(rawTargetLocale, next);
   const usesDefaultSystemMessage = next.systemMessage === buildDefaultSystemMessage(rawSourceLocale, rawTargetLocale);
-  return {
+  const resolved = {
     ...next,
     sourceLocale: resolvedSourceLocale,
     targetLocale: resolvedTargetLocale,
     systemMessage: usesDefaultSystemMessage ? buildDefaultSystemMessage(resolvedSourceLocale, resolvedTargetLocale) : next.systemMessage
   };
+  validateCatalogPathSemantics(resolved);
+  return resolved;
 }
 function completeAngyConfig(input) {
   assertNonEmptyString(input.basePoPath, "basePoPath");
@@ -137,8 +155,8 @@ function completeAngyConfig(input) {
   assertNonEmptyString(input.sourceLocale, "sourceLocale");
   assertNonEmptyString(input.targetLocale, "targetLocale");
   validateLocaleAliasUsage(input.sourceLocale, input.targetLocale);
-  if (typeof input.apiKey !== "string") {
-    throw new Error(`[angy] apiKey is required and must be a string. Use an empty string to disable suggestions.`);
+  if (typeof input.apiKey !== "string" && typeof input.apiKey !== "undefined") {
+    throw new Error(`[angy] apiKey must be a string when provided. Use an empty string to disable suggestions.`);
   }
   validateRoutePath(input.routePath);
   validateWatchIgnore(input.watchIgnore);
@@ -149,7 +167,7 @@ function completeAngyConfig(input) {
     sourceLocale: input.sourceLocale,
     targetLocale: input.targetLocale,
     routePath: input.routePath ?? "/api/translations",
-    apiKey: input.apiKey,
+    apiKey: input.apiKey ?? "",
     systemMessage: input.systemMessage ?? buildDefaultSystemMessage(input.sourceLocale, input.targetLocale),
     suggestionModel: input.suggestionModel ?? "gpt-4.1-mini",
     watchIgnore: input.watchIgnore ?? ["**/en-working.po"],
@@ -157,7 +175,7 @@ function completeAngyConfig(input) {
   };
 }
 function defineAngyConfig(config2) {
-  return completeAngyConfig(config2);
+  return resolveConfiguredLocaleAliases(completeAngyConfig(config2));
 }
 async function fileExists(path) {
   try {
@@ -177,13 +195,19 @@ async function loadTsConfigModule(path) {
   const tempPath = `${path}.angy.tmp.mjs`;
   await writeFile(tempPath, transformed.code, "utf8");
   try {
-    return await import(`${pathToFileURL(tempPath).href}?t=${Date.now()}`);
+    return await import(
+      /* @vite-ignore */
+      `${pathToFileURL(tempPath).href}?t=${Date.now()}`
+    );
   } finally {
     await unlink(tempPath).catch(() => void 0);
   }
 }
 async function loadJsConfigModule(path) {
-  return import(pathToFileURL(path).href);
+  return import(
+    /* @vite-ignore */
+    pathToFileURL(path).href
+  );
 }
 async function loadAngyConfigFromRoot(root) {
   if (loadedConfigRoot === root) {
@@ -207,6 +231,14 @@ async function loadAngyConfigFromRoot(root) {
 
 // src/lib/server/catalog.ts
 var runtimeTranslations = /* @__PURE__ */ new Map();
+var CatalogIntegrityError = class extends Error {
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.name = "CatalogIntegrityError";
+    this.issues = issues;
+  }
+};
 function catalogEntryKey(msgid, msgctxt) {
   return `${msgctxt ?? ""}::${msgid}`;
 }
@@ -280,20 +312,9 @@ function createFuse(entries) {
 function buildEntryMap(entries) {
   return new Map(entries.map((entry) => [catalogEntryKey(entry.msgid, entry.msgctxt), entry]));
 }
-function applyWorkingState(baseEntry, workingEntry) {
-  if (!workingEntry) {
-    return baseEntry;
-  }
-  return {
-    ...baseEntry,
-    msgstr: workingEntry.msgstr,
-    flags: workingEntry.flags,
-    previous: workingEntry.previous,
-    obsolete: workingEntry.obsolete,
-    hasTranslation: workingEntry.hasTranslation,
-    isFuzzy: workingEntry.isFuzzy,
-    translationOrigin: workingEntry.translationOrigin
-  };
+function getEntryValue(entry) {
+  if (!entry?.msgstr?.length) return "";
+  return entry.msgstr.find((item) => item.trim().length > 0)?.trim() ?? "";
 }
 async function fileExists2(path) {
   try {
@@ -303,27 +324,9 @@ async function fileExists2(path) {
     return false;
   }
 }
-async function readCatIndex(catalog) {
-  const { basePoPath, workingPoPath } = getTranslationHelperConfig();
-  let path = "";
-  if (catalog === "base") {
-    path = basePoPath;
-  } else {
-    const exists = await fileExists2(workingPoPath);
-    if (!exists) return null;
-    path = workingPoPath;
-  }
-  const raw = await readFile2(path);
-  const parsed = gettextParser.po.parse(raw);
-  const entries = flattenPoEntries(parsed, catalog);
-  return {
-    entries,
-    fuse: createFuse(entries)
-  };
-}
 async function readParsedCatalog(catalog) {
-  const { basePoPath, workingPoPath } = getTranslationHelperConfig();
-  const path = catalog === "base" ? basePoPath : workingPoPath;
+  const { basePoPath } = getTranslationHelperConfig();
+  const path = catalog === "base" ? basePoPath : await getEffectiveWorkingPoPath();
   if (catalog === "working") {
     const exists = await fileExists2(path);
     if (!exists) return null;
@@ -338,15 +341,183 @@ async function ensureWorkingCatalog() {
     await copyFile(basePoPath, workingPoPath);
   }
 }
+function getWorkingDraftPoPath() {
+  const { workingPoPath } = getTranslationHelperConfig();
+  const extension = extname2(workingPoPath);
+  const stem = workingPoPath.slice(0, workingPoPath.length - extension.length);
+  return `${stem}.angy-draft${extension}`;
+}
+async function getEffectiveWorkingPoPath() {
+  const draftPoPath = getWorkingDraftPoPath();
+  if (await fileExists2(draftPoPath)) {
+    return draftPoPath;
+  }
+  return getTranslationHelperConfig().workingPoPath;
+}
+async function ensureWorkingDraftCatalog() {
+  await ensureWorkingCatalog();
+  const { workingPoPath } = getTranslationHelperConfig();
+  const draftPoPath = getWorkingDraftPoPath();
+  const exists = await fileExists2(draftPoPath);
+  if (!exists) {
+    await copyFile(workingPoPath, draftPoPath);
+  }
+}
 function removeFuzzyFlag(flagString) {
   if (!flagString) return "";
   return flagString.split(",").map((item) => item.trim()).filter(Boolean).filter((item) => item !== "fuzzy").join(", ");
 }
 async function writeWorkingCatalog(parsed) {
+  await ensureWorkingDraftCatalog();
+  const draftPoPath = getWorkingDraftPoPath();
+  const compiled = gettextParser.po.compile(parsed);
+  await writeFile2(draftPoPath, compiled);
+}
+async function promoteWorkingDraftToRuntime() {
+  await ensureWorkingDraftCatalog();
   const { workingPoPath } = getTranslationHelperConfig();
+  const draftPoPath = getWorkingDraftPoPath();
+  const publishPath = `${workingPoPath}.angy-publish`;
+  const compiled = await readFile2(draftPoPath);
   suspendWorkingCatalogWatch(workingPoPath);
-  const compiled = gettextParser.po.compile(parsed);
-  await writeFile2(workingPoPath, compiled);
+  await writeFile2(publishPath, compiled);
+  await rm(workingPoPath, { force: true });
+  await rename(publishPath, workingPoPath);
+}
+function collectCatalogIntegrityIssues(baseEntries, workingEntries) {
+  const issues = [];
+  const baseMap = buildEntryMap(baseEntries);
+  const workingMap = buildEntryMap(workingEntries);
+  for (const baseEntry of baseEntries) {
+    const key = catalogEntryKey(baseEntry.msgid, baseEntry.msgctxt);
+    const workingEntry = workingMap.get(key);
+    if (!workingEntry) {
+      issues.push({
+        type: "key_mismatch",
+        msgid: baseEntry.msgid,
+        msgctxt: baseEntry.msgctxt,
+        reason: "missing_in_working"
+      });
+      continue;
+    }
+    const baseValue = getEntryValue(baseEntry);
+    const workingValue = getEntryValue(workingEntry);
+    if (baseValue && !workingValue) {
+      issues.push({
+        type: "missing_working_translation",
+        msgid: baseEntry.msgid,
+        msgctxt: baseEntry.msgctxt,
+        baseValue
+      });
+    }
+  }
+  for (const workingEntry of workingEntries) {
+    const key = catalogEntryKey(workingEntry.msgid, workingEntry.msgctxt);
+    if (!baseMap.has(key)) {
+      issues.push({
+        type: "key_mismatch",
+        msgid: workingEntry.msgid,
+        msgctxt: workingEntry.msgctxt,
+        reason: "missing_in_base"
+      });
+    }
+  }
+  return issues;
+}
+function assertCatalogIntegrity(baseEntries, workingEntries) {
+  const issues = collectCatalogIntegrityIssues(baseEntries, workingEntries);
+  if (issues.length) {
+    throw new CatalogIntegrityError(
+      "Working catalog is out of sync with the base catalog. Regenerate or replace the working catalog before using Angy.",
+      issues
+    );
+  }
+}
+function collectRotationImpact(baseEntries, workingMap) {
+  const impacted = [];
+  for (const baseEntry of baseEntries) {
+    const workingEntry = workingMap.get(catalogEntryKey(baseEntry.msgid, baseEntry.msgctxt));
+    if (!workingEntry) continue;
+    const baseValue = getEntryValue(baseEntry);
+    const workingValue = getEntryValue(workingEntry);
+    if (!workingValue) continue;
+    if (baseValue === workingValue) continue;
+    impacted.push({
+      msgid: baseEntry.msgid,
+      msgctxt: baseEntry.msgctxt,
+      baseValue,
+      workingValue
+    });
+  }
+  return impacted;
+}
+function resolveTranslationState(baseEntry, workingEntry) {
+  const baseValue = getEntryValue(baseEntry);
+  const workingValue = getEntryValue(workingEntry);
+  const activeEntry = workingEntry && workingValue ? workingEntry : baseEntry;
+  const fuzzy = Boolean(activeEntry.isFuzzy);
+  let translationOrigin = "base";
+  let translationStatus = "none";
+  let effectiveEntry = baseEntry;
+  if (workingEntry && workingValue) {
+    effectiveEntry = workingEntry;
+    if (!baseValue || workingValue !== baseValue) {
+      translationOrigin = "working";
+      translationStatus = "working";
+    } else {
+      translationOrigin = "base";
+      translationStatus = "base";
+    }
+  } else if (baseValue) {
+    effectiveEntry = baseEntry;
+    translationOrigin = "base";
+    translationStatus = "base";
+  }
+  if (fuzzy) {
+    translationStatus = "fuzzy";
+  }
+  return {
+    effectiveEntry,
+    baseValue,
+    workingValue,
+    translationOrigin,
+    translationStatus,
+    hasTranslation: Boolean(getEntryValue(effectiveEntry)),
+    isFuzzy: fuzzy
+  };
+}
+async function readCatalogPair(options) {
+  if (options?.ensureWorking) {
+    await ensureWorkingCatalog();
+  }
+  const [baseParsed, workingParsed] = await Promise.all([
+    readParsedCatalog("base"),
+    readParsedCatalog("working")
+  ]);
+  if (!baseParsed || !workingParsed) {
+    throw new Error("Unable to load base and working catalogs.");
+  }
+  const baseEntries = flattenPoEntries(baseParsed, "base");
+  const workingEntries = flattenPoEntries(workingParsed, "working");
+  assertCatalogIntegrity(baseEntries, workingEntries);
+  const baseMap = buildEntryMap(baseEntries);
+  const workingMap = buildEntryMap(workingEntries);
+  const rotationImpact = collectRotationImpact(baseEntries, workingMap);
+  return {
+    baseEntries,
+    workingEntries,
+    baseMap,
+    workingMap,
+    rotationImpact
+  };
+}
+async function getRotationPreflight() {
+  const { rotationImpact } = await readCatalogPair({ ensureWorking: true });
+  return {
+    safe: true,
+    status: "ok",
+    affected: rotationImpact
+  };
 }
 function timestampForBackup() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -357,18 +528,21 @@ function buildBackupPath(path, label) {
   const stem = basename2(path, extension);
   return join(directory, `${stem}.${label}.${timestampForBackup()}${extension}`);
 }
-async function rotateCatalogs() {
+async function rotateCatalogs(options) {
   const { basePoPath, workingPoPath } = getTranslationHelperConfig();
-  const workingExists = await fileExists2(workingPoPath);
+  const draftPoPath = getWorkingDraftPoPath();
+  const effectiveWorkingPoPath = await getEffectiveWorkingPoPath();
+  const workingExists = await fileExists2(effectiveWorkingPoPath);
   if (!workingExists) {
     return { ok: false, error: "Working catalog does not exist" };
   }
   const baseBackupPath = buildBackupPath(basePoPath, "base-backup");
   const workingBackupPath = buildBackupPath(workingPoPath, "working-backup");
   await copyFile(basePoPath, baseBackupPath);
-  await copyFile(workingPoPath, workingBackupPath);
-  await copyFile(workingPoPath, basePoPath);
+  await copyFile(effectiveWorkingPoPath, workingBackupPath);
+  await copyFile(effectiveWorkingPoPath, basePoPath);
   await copyFile(basePoPath, workingPoPath);
+  await copyFile(workingPoPath, draftPoPath);
   return {
     ok: true,
     basePoPath,
@@ -384,10 +558,8 @@ function runtimeKey(msgid, msgctxt) {
 }
 async function writeTranslationToWorkingCatalog(resolvedMsgid, resolvedMsgctxt, translationValue) {
   await ensureWorkingCatalog();
-  const [baseParsed, workingParsed] = await Promise.all([
-    readParsedCatalog("base"),
-    readParsedCatalog("working")
-  ]);
+  await readCatalogPair({ ensureWorking: true });
+  const [baseParsed, workingParsed] = await Promise.all([readParsedCatalog("base"), readParsedCatalog("working")]);
   if (!baseParsed || !workingParsed) {
     return { ok: false, error: "Unable to load catalogs" };
   }
@@ -409,11 +581,12 @@ async function writeTranslationToWorkingCatalog(resolvedMsgid, resolvedMsgctxt,
   entry.comments.flag = removeFuzzyFlag(entry.comments.flag);
   await writeWorkingCatalog(workingParsed);
   runtimeTranslations.set(runtimeKey(resolvedMsgid, resolvedMsgctxt), translationValue);
+  const workingCatalogName = inferLocaleFromCatalogPath(getTranslationHelperConfig().workingPoPath) ?? "working";
   return {
     ok: true,
     msgid: resolvedMsgid,
     msgctxt: resolvedMsgctxt,
-    workingCatalog: "en-working.po"
+    workingCatalog: workingCatalogName
   };
 }
 function cloneEntryForWorking(baseEntry, msgid, msgctxt) {
@@ -443,6 +616,22 @@ async function handleCommitBatch(request) {
       { status: 400 }
     );
   }
+  try {
+    await readCatalogPair({ ensureWorking: true });
+  } catch (error) {
+    if (error instanceof CatalogIntegrityError) {
+      return json(
+        {
+          success: false,
+          error: error.message,
+          code: "catalog_integrity_error",
+          issues: error.issues
+        },
+        { status: 409 }
+      );
+    }
+    throw error;
+  }
   const results = [];
   for (const item of items) {
     const resolvedMsgid = item.resolvedMsgid?.trim();
@@ -490,7 +679,7 @@ async function handleCommitBatch(request) {
   }
   return json({
     success: true,
-    message: `Committed ${results.length} translations to en-working.po`,
+    message: `Committed ${results.length} translations to Angy draft working catalog`,
     results
   });
 }
@@ -525,21 +714,85 @@ async function handleCommit(request) {
   }
   return json({
     success: true,
-    message: "Translation written to en-working.po",
+    message: "Translation written to Angy draft working catalog",
     msgid: result.msgid,
     msgctxt: result.msgctxt,
     workingCatalog: result.workingCatalog
   });
 }
-async function handleRotateCatalogs() {
-  const result = await rotateCatalogs();
+async function handlePromoteWorkingPreview() {
+  try {
+    await readCatalogPair({ ensureWorking: true });
+    await promoteWorkingDraftToRuntime();
+    return json({
+      success: true,
+      message: `Promoted Angy draft into ${basename3(getTranslationHelperConfig().workingPoPath)}`
+    });
+  } catch (error) {
+    if (error instanceof CatalogIntegrityError) {
+      return json(
+        {
+          success: false,
+          error: error.message,
+          code: "catalog_integrity_error",
+          issues: error.issues
+        },
+        { status: 409 }
+      );
+    }
+    throw error;
+  }
+}
+async function handleRotatePreflight() {
+  try {
+    const preflight = await getRotationPreflight();
+    return json({
+      success: true,
+      safe: preflight.safe,
+      status: preflight.status,
+      affected: preflight.affected
+    });
+  } catch (error) {
+    if (error instanceof CatalogIntegrityError) {
+      return json(
+        {
+          success: false,
+          error: error.message,
+          code: "catalog_integrity_error",
+          issues: error.issues
+        },
+        { status: 409 }
+      );
+    }
+    throw error;
+  }
+}
+async function handleRotateCatalogs(request) {
+  const data = await request.json().catch(() => null);
+  const confirmDestructive = data?.confirmDestructive === true;
+  const preflight = await getRotationPreflight();
+  if (!preflight.safe && !confirmDestructive) {
+    return json(
+      {
+        success: false,
+        error: "Catalog rotation would overwrite working-only translations. Confirm rotation explicitly to continue.",
+        code: "rotation_confirmation_required",
+        status: preflight.status,
+        affected: preflight.affected
+      },
+      { status: 409 }
+    );
+  }
+  const result = await rotateCatalogs({ allowOutOfSync: confirmDestructive });
   if (!result.ok) {
     return json(
       {
         success: false,
-        error: result.error
+        error: result.error,
+        status: "status" in result ? result.status : void 0,
+        affected: "affected" in result ? result.affected : void 0
       },
-      { status: 400 }
+      { status: "status" in result && result.status === "out_of_sync" ? 409 : 400 }
     );
   }
   return json({
@@ -725,13 +978,16 @@ function buildAlternativePool(topDirectAlternatives, sharedReferenceAlternatives
   return alternatives.slice(0, MAX_ALTERNATIVES);
 }
 async function findTranslationContext(key, currentPath) {
-  const baseIndex = await readCatIndex("base");
-  if (!baseIndex) return null;
-  const workingIndex = await readCatIndex("working");
-  const workingMap = workingIndex ? buildEntryMap(workingIndex.entries) : /* @__PURE__ */ new Map();
-  const effectiveEntries = baseIndex.entries.map(
-    (entry) => applyWorkingState(entry, workingMap.get(entryKey(entry.msgid, entry.msgctxt)))
-  );
+  const catalogPair = await readCatalogPair({ ensureWorking: true });
+  const effectiveEntries = catalogPair.baseEntries.map((entry) => {
+    const state = resolveTranslationState(entry, catalogPair.workingMap.get(entryKey(entry.msgid, entry.msgctxt)));
+    return {
+      ...state.effectiveEntry,
+      hasTranslation: state.hasTranslation,
+      isFuzzy: state.isFuzzy,
+      translationOrigin: state.translationOrigin
+    };
+  });
   const effectiveIndex = {
     entries: effectiveEntries,
     fuse: createFuse(effectiveEntries)
@@ -789,47 +1045,48 @@ async function findTranslationContext(key, currentPath) {
       untranslatedSimilarityAlternatives
     ),
     routeReference,
-    workingMap
+    baseMap: catalogPair.baseMap,
+    workingMap: catalogPair.workingMap,
+    catalogState: {
+      status: "ok",
+      affectedCount: catalogPair.rotationImpact.length
+    }
   };
 }
 function toPublicEntry(entry, workingEntry) {
-  const effective = workingEntry ?? entry;
-  const baseValue = entry.msgstr[0] ?? "";
-  const workingValue = workingEntry?.msgstr[0] ?? "";
-  const workingDiffersFromBase = Boolean(workingEntry?.hasTranslation) && workingValue !== baseValue;
+  const state = resolveTranslationState(entry, workingEntry);
   return {
     msgid: entry.msgid,
     msgctxt: entry.msgctxt,
     msgidPlural: entry.msgidPlural,
-    msgstr: effective.msgstr,
+    msgstr: state.effectiveEntry.msgstr,
     references: entry.references,
     extractedComments: entry.extractedComments,
-    flags: effective.flags,
-    previous: effective.previous,
-    obsolete: effective.obsolete,
-    hasTranslation: effective.hasTranslation,
-    isFuzzy: effective.isFuzzy,
-    isCommittedToWorking: workingDiffersFromBase,
-    matchesTargetTranslation: Boolean(effective.hasTranslation) && (!workingEntry?.hasTranslation || workingValue === baseValue),
-    translationOrigin: workingDiffersFromBase ? "working" : "base"
+    flags: state.effectiveEntry.flags,
+    previous: state.effectiveEntry.previous,
+    obsolete: state.effectiveEntry.obsolete,
+    hasTranslation: state.hasTranslation,
+    isFuzzy: state.isFuzzy,
+    isCommittedToWorking: state.translationOrigin === "working",
+    matchesTargetTranslation: state.translationOrigin === "base" && state.hasTranslation,
+    translationOrigin: state.translationOrigin,
+    translationStatus: state.translationStatus
   };
 }
 function toPublicAlternative(entry, score, workingEntry) {
-  const effective = workingEntry ?? entry;
-  const baseValue = entry.msgstr[0] ?? "";
-  const workingValue = workingEntry?.msgstr[0] ?? "";
-  const workingDiffersFromBase = Boolean(workingEntry?.hasTranslation) && workingValue !== baseValue;
+  const state = resolveTranslationState(entry, workingEntry);
   return {
     msgid: entry.msgid,
     msgctxt: entry.msgctxt,
     score,
     references: entry.references,
-    msgstr: effective.msgstr,
-    hasTranslation: effective.hasTranslation,
-    isFuzzy: effective.isFuzzy,
-    isCommittedToWorking: workingDiffersFromBase,
-    matchesTargetTranslation: Boolean(effective.hasTranslation) && (!workingEntry?.hasTranslation || workingValue === baseValue),
-    translationOrigin: workingDiffersFromBase ? "working" : "base"
+    msgstr: state.effectiveEntry.msgstr,
+    hasTranslation: state.hasTranslation,
+    isFuzzy: state.isFuzzy,
+    isCommittedToWorking: state.translationOrigin === "working",
+    matchesTargetTranslation: state.translationOrigin === "base" && state.hasTranslation,
+    translationOrigin: state.translationOrigin,
+    translationStatus: state.translationStatus
   };
 }
 async function handleContext(request) {
@@ -845,7 +1102,23 @@ async function handleContext(request) {
       { status: 400 }
     );
   }
-  const baseFound = await findTranslationContext(key, currentPath);
+  let baseFound;
+  try {
+    baseFound = await findTranslationContext(key, currentPath);
+  } catch (error) {
+    if (error instanceof CatalogIntegrityError) {
+      return json2(
+        {
+          success: false,
+          error: error.message,
+          code: "catalog_integrity_error",
+          issues: error.issues
+        },
+        { status: 409 }
+      );
+    }
+    throw error;
+  }
   if (!baseFound) {
     return json2(
       {
@@ -855,7 +1128,7 @@ async function handleContext(request) {
       { status: 404 }
     );
   }
-  const bestBase = baseFound.best.entry;
+  const bestBase = baseFound.baseMap.get(entryKey(baseFound.best.entry.msgid, baseFound.best.entry.msgctxt)) ?? baseFound.best.entry;
   const bestWorking = baseFound.workingMap.get(entryKey(bestBase.msgid, bestBase.msgctxt));
   return json2({
     success: true,
@@ -863,10 +1136,12 @@ async function handleContext(request) {
       score: baseFound.best.score,
       via: baseFound.best.variant
     },
+    catalogState: baseFound.catalogState,
     entry: toPublicEntry(bestBase, bestWorking),
     alternatives: baseFound.alternatives.map((item) => {
-      const workingAlt = baseFound.workingMap.get(entryKey(item.entry.msgid, item.entry.msgctxt));
-      return toPublicAlternative(item.entry, item.score, workingAlt);
+      const baseAlt = baseFound.baseMap.get(entryKey(item.entry.msgid, item.entry.msgctxt)) ?? item.entry;
+      const workingAlt = baseFound.workingMap.get(entryKey(baseAlt.msgid, baseAlt.msgctxt));
+      return toPublicAlternative(baseAlt, item.score, workingAlt);
     })
   });
 }
@@ -1078,7 +1353,13 @@ async function handleTranslationRequest(request, url, options) {
     return handleSuggestions(request);
   }
   if (intent === "rotate-catalogs") {
-    return handleRotateCatalogs();
+    return handleRotateCatalogs(request);
+  }
+  if (intent === "rotate-preflight") {
+    return handleRotatePreflight();
+  }
+  if (intent === "promote-working-preview") {
+    return handlePromoteWorkingPreview();
   }
   return handleCommit(request);
 }
@@ -1087,8 +1368,14 @@ function createAngyHandler(options) {
 }
 var handler = createAngyHandler();
 export {
+  CatalogIntegrityError,
+  collectCatalogIntegrityIssues,
+  collectRotationImpact,
   defineAngyConfig,
+  getRotationPreflight,
   handleTranslationRequest,
-  handler
+  handler,
+  readCatalogPair,
+  resolveTranslationState
 };
 //# sourceMappingURL=server.js.map