@walkinissue/angy 0.2.17 → 0.2.19

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";
@@ -24,6 +25,30 @@ var CONFIG_FILENAMES = [
   "angy.config.mjs",
   "angy.config.cjs"
 ];
+var NON_REASONING_SUGGESTION_MODELS = [
+  "gpt-4.1",
+  "gpt-4.1-mini",
+  "gpt-4.1-nano"
+];
+var GPT54_REASONING_EFFORTS = ["none", "low", "medium", "high", "xhigh"];
+var GPT51_REASONING_EFFORTS = ["none", "low", "medium", "high"];
+var GPT5_REASONING_EFFORTS = ["minimal", "low", "medium", "high"];
+var GPT5_PRO_REASONING_EFFORTS = ["high"];
+var GPT5X_PRO_REASONING_EFFORTS = ["medium", "high", "xhigh"];
+var REASONING_EFFORTS_BY_MODEL = {
+  "gpt-5.4": GPT54_REASONING_EFFORTS,
+  "gpt-5.4-mini": GPT54_REASONING_EFFORTS,
+  "gpt-5.4-nano": GPT54_REASONING_EFFORTS,
+  "gpt-5.2": GPT54_REASONING_EFFORTS,
+  "gpt-5.1": GPT51_REASONING_EFFORTS,
+  "gpt-5": GPT5_REASONING_EFFORTS,
+  "gpt-5-pro": GPT5_PRO_REASONING_EFFORTS,
+  "gpt-5.2-pro": GPT5X_PRO_REASONING_EFFORTS,
+  "gpt-5.4-pro": GPT5X_PRO_REASONING_EFFORTS
+};
+var DEFAULT_SUGGESTION_MODEL = {
+  model: "gpt-4.1-mini"
+};
 function buildDefaultSystemMessage(sourceLocale, targetLocale) {
   return `You are an expert product localization assistant translating ${sourceLocale} UI copy into polished ${targetLocale}. Keep already-${targetLocale} text unchanged. Preserve placeholders like {0}, {1}, ICU fragments, HTML-like markers such as <0/> and <strong>, line breaks, punctuation, capitalization, and button-like brevity. Prefer terminology and syntax that stay close to the translated examples so the product voice remains cohesive. Do not invent extra context, do not expand abbreviations unless the examples already do, and avoid semantic drift. Return only high-confidence translation suggestions for the provided untranslated strings.`;
 }
@@ -50,6 +75,51 @@ function validateSuggestionProvider(suggestionProvider) {
     throw new Error(`[angy] suggestionProvider must be a function.`);
   }
 }
+function isNonReasoningSuggestionModel(model) {
+  return NON_REASONING_SUGGESTION_MODELS.includes(model);
+}
+function isSupportedSuggestionModel(model) {
+  return isNonReasoningSuggestionModel(model) || Object.prototype.hasOwnProperty.call(REASONING_EFFORTS_BY_MODEL, model);
+}
+function normalizeSuggestionModelConfig(input) {
+  const suggestionModel = input ?? DEFAULT_SUGGESTION_MODEL;
+  if (typeof suggestionModel !== "object" || suggestionModel == null || Array.isArray(suggestionModel)) {
+    throw new Error(
+      `[angy] suggestionModel must be an object like { model: "gpt-4.1-mini" }.`
+    );
+  }
+  if (typeof suggestionModel.model !== "string" || !suggestionModel.model.trim()) {
+    throw new Error(`[angy] suggestionModel.model is required and must be a non-empty string.`);
+  }
+  if (!isSupportedSuggestionModel(suggestionModel.model)) {
+    throw new Error(`[angy] Unsupported suggestionModel.model "${suggestionModel.model}".`);
+  }
+  if (isNonReasoningSuggestionModel(suggestionModel.model)) {
+    if (!("reasoning" in suggestionModel) || suggestionModel.reasoning === void 0 || suggestionModel.reasoning === null) {
+      return { model: suggestionModel.model, reasoning: null };
+    }
+    throw new Error(
+      `[angy] suggestionModel.reasoning is not supported for ${suggestionModel.model}.`
+    );
+  }
+  const allowedReasoning = REASONING_EFFORTS_BY_MODEL[suggestionModel.model];
+  const reasoning = suggestionModel.reasoning;
+  if (reasoning == null) {
+    if (suggestionModel.model === "gpt-5-pro") {
+      return { model: suggestionModel.model, reasoning: "high" };
+    }
+    return { model: suggestionModel.model };
+  }
+  if (!allowedReasoning.includes(reasoning)) {
+    throw new Error(
+      `[angy] suggestionModel.reasoning "${reasoning}" is not supported for ${suggestionModel.model}.`
+    );
+  }
+  return {
+    model: suggestionModel.model,
+    reasoning
+  };
+}
 var config = {
   basePoPath: resolve(__dirname, "../../locales/en.po"),
   workingPoPath: resolve(__dirname, "../../locales/en-working.po"),
@@ -58,7 +128,7 @@ var config = {
   routePath: "/api/translations",
   apiKey: "",
   systemMessage: buildDefaultSystemMessage("sv", "en"),
-  suggestionModel: "gpt-4.1-mini",
+  suggestionModel: DEFAULT_SUGGESTION_MODEL,
   watchIgnore: ["**/en-working.po"]
 };
 var loadedConfigRoot = null;
@@ -102,6 +172,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 +209,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 +224,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,15 +236,15 @@ 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",
+    suggestionModel: normalizeSuggestionModelConfig(input.suggestionModel),
     watchIgnore: input.watchIgnore ?? ["**/en-working.po"],
     suggestionProvider: input.suggestionProvider
   };
 }
 function defineAngyConfig(config2) {
-  return completeAngyConfig(config2);
+  return resolveConfiguredLocaleAliases(completeAngyConfig(config2));
 }
 async function fileExists(path) {
   try {
@@ -177,13 +264,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 +300,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 +381,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 +393,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 +410,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 +597,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 +627,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 +650,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 +685,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 +748,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 +783,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 +1047,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 +1114,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 +1171,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 +1197,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 +1205,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);
     })
   });
 }
@@ -914,6 +1258,58 @@ function parseSuggestions(responseText) {
     return [];
   }
 }
+function buildSuggestionRequestBody({
+  context,
+  items,
+  modelConfig,
+  systemMessage
+}) {
+  const body = {
+    model: modelConfig.model,
+    input: [
+      {
+        role: "system",
+        content: [{ type: "input_text", text: systemMessage }]
+      },
+      {
+        role: "user",
+        content: [{ type: "input_text", text: buildUserMessage(context, items) }]
+      }
+    ],
+    text: {
+      format: {
+        type: "json_schema",
+        name: "translation_suggestions",
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            items: {
+              type: "array",
+              items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  msgid: { type: "string" },
+                  msgctxt: { type: ["string", "null"] },
+                  suggestion: { type: "string" }
+                },
+                required: ["msgid", "msgctxt", "suggestion"]
+              }
+            }
+          },
+          required: ["items"]
+        }
+      }
+    }
+  };
+  if (modelConfig.reasoning && modelConfig.reasoning !== "none") {
+    body.reasoning = {
+      effort: modelConfig.reasoning
+    };
+  }
+  return body;
+}
 async function handleSuggestions(request) {
   const {
     apiKey,
@@ -942,7 +1338,7 @@ async function handleSuggestions(request) {
       sourceLocale,
       targetLocale,
       systemMessage,
-      model: suggestionModel,
+      suggestionModel,
       apiKey
     });
     return json3({
@@ -960,7 +1356,8 @@ async function handleSuggestions(request) {
   }
   try {
     console.info("[angy] Suggestion request starting.", {
-      model: suggestionModel,
+      model: suggestionModel.model,
+      reasoning: suggestionModel.reasoning ?? null,
       sourceLocale,
       targetLocale,
       itemCount: items.length,
@@ -972,48 +1369,14 @@ async function handleSuggestions(request) {
         Authorization: `Bearer ${apiKey}`,
         "content-type": "application/json"
       },
-      body: JSON.stringify({
-        model: suggestionModel,
-        reasoning: {
-          effort: "medium"
-        },
-        input: [
-          {
-            role: "system",
-            content: [{ type: "input_text", text: systemMessage }]
-          },
-          {
-            role: "user",
-            content: [{ type: "input_text", text: buildUserMessage(context, items) }]
-          }
-        ],
-        text: {
-          format: {
-            type: "json_schema",
-            name: "translation_suggestions",
-            schema: {
-              type: "object",
-              additionalProperties: false,
-              properties: {
-                items: {
-                  type: "array",
-                  items: {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {
-                      msgid: { type: "string" },
-                      msgctxt: { type: ["string", "null"] },
-                      suggestion: { type: "string" }
-                    },
-                    required: ["msgid", "msgctxt", "suggestion"]
-                  }
-                }
-              },
-              required: ["items"]
-            }
-          }
-        }
-      })
+      body: JSON.stringify(
+        buildSuggestionRequestBody({
+          context,
+          items,
+          modelConfig: suggestionModel,
+          systemMessage
+        })
+      )
     });
     if (!response.ok) {
       const errorBody = await response.text().catch(() => "");
@@ -1078,7 +1441,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 +1456,16 @@ function createAngyHandler(options) {
 }
 var handler = createAngyHandler();
 export {
+  CatalogIntegrityError,
+  buildSuggestionRequestBody,
+  collectCatalogIntegrityIssues,
+  collectRotationImpact,
   defineAngyConfig,
+  getRotationPreflight,
   handleTranslationRequest,
-  handler
+  handler,
+  normalizeSuggestionModelConfig,
+  readCatalogPair,
+  resolveTranslationState
 };
 //# sourceMappingURL=server.js.map