@walkinissue/angy 0.2.17

package/dist/server.js

@@ -0,0 +1,1094 @@
+// src/lib/server/route.ts
+import { json as json4 } from "@sveltejs/kit";
+
+// src/lib/server/commit.ts
+import { json } from "@sveltejs/kit";
+
+// 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 { dirname as dirname2, extname as extname2, join, basename as basename2 } from "node:path";
+import gettextParser from "gettext-parser";
+import Fuse from "fuse.js";
+
+// src/lib/server/config.ts
+import { readFile, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, normalize, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pathToFileURL } from "node:url";
+import { transform } from "esbuild";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var CONFIG_FILENAMES = [
+  "angy.config.ts",
+  "angy.config.js",
+  "angy.config.mjs",
+  "angy.config.cjs"
+];
+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.`;
+}
+function assertNonEmptyString(value, key) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`[angy] ${key} is required and must be a non-empty string.`);
+  }
+}
+function validateRoutePath(routePath) {
+  if (routePath == null || routePath === "") return;
+  if (typeof routePath !== "string" || !routePath.startsWith("/")) {
+    throw new Error(`[angy] routePath must be an absolute path starting with "/".`);
+  }
+}
+function validateWatchIgnore(watchIgnore) {
+  if (watchIgnore == null) return;
+  if (!Array.isArray(watchIgnore) || watchIgnore.some((item) => typeof item !== "string")) {
+    throw new Error(`[angy] watchIgnore must be an array of strings.`);
+  }
+}
+function validateSuggestionProvider(suggestionProvider) {
+  if (suggestionProvider == null) return;
+  if (typeof suggestionProvider !== "function") {
+    throw new Error(`[angy] suggestionProvider must be a function.`);
+  }
+}
+var config = {
+  basePoPath: resolve(__dirname, "../../locales/en.po"),
+  workingPoPath: resolve(__dirname, "../../locales/en-working.po"),
+  sourceLocale: "sv",
+  targetLocale: "en",
+  routePath: "/api/translations",
+  apiKey: "",
+  systemMessage: buildDefaultSystemMessage("sv", "en"),
+  suggestionModel: "gpt-4.1-mini",
+  watchIgnore: ["**/en-working.po"]
+};
+var loadedConfigRoot = null;
+var workingCatalogWatchControllers = /* @__PURE__ */ new Set();
+function configureTranslationHelper(next) {
+  Object.assign(config, next);
+}
+function getTranslationHelperConfig() {
+  return config;
+}
+function normalizeFsPath(path) {
+  return normalize(path).replace(/\\/g, "/");
+}
+function inferLocaleFromCatalogPath(path) {
+  const fileName = basename(path);
+  if (!fileName) return null;
+  return fileName.slice(0, fileName.length - extname(fileName).length) || null;
+}
+function resolveLocaleAlias(value, paths) {
+  if (value === "working") {
+    const locale = inferLocaleFromCatalogPath(paths.workingPoPath);
+    if (!locale) {
+      throw new Error("[angy] Unable to infer locale from workingPoPath.");
+    }
+    return locale;
+  }
+  if (value === "base") {
+    const locale = inferLocaleFromCatalogPath(paths.basePoPath);
+    if (!locale) {
+      throw new Error("[angy] Unable to infer locale from basePoPath.");
+    }
+    return locale;
+  }
+  return value;
+}
+function validateLocaleAliasUsage(sourceLocale, targetLocale) {
+  if (sourceLocale === "working") {
+    throw new Error('[angy] sourceLocale cannot be "working". Use an explicit source locale.');
+  }
+  if (targetLocale === "base") {
+    throw new Error('[angy] targetLocale cannot be "base". Use an explicit target locale or "working".');
+  }
+}
+function suspendWorkingCatalogWatch(path, delayMs = 800) {
+  const normalizedPath = normalizeFsPath(path);
+  for (const controller of workingCatalogWatchControllers) {
+    controller(normalizedPath, delayMs);
+  }
+}
+function normalizeTranslationHelperConfig(root, next) {
+  const normalized = { ...next };
+  if (normalized.basePoPath && !isAbsolute(normalized.basePoPath)) {
+    normalized.basePoPath = resolve(root, normalized.basePoPath);
+  }
+  if (normalized.workingPoPath && !isAbsolute(normalized.workingPoPath)) {
+    normalized.workingPoPath = resolve(root, normalized.workingPoPath);
+  }
+  return normalized;
+}
+function resolveConfiguredLocaleAliases(next) {
+  const rawSourceLocale = next.sourceLocale;
+  const rawTargetLocale = next.targetLocale;
+  const resolvedSourceLocale = resolveLocaleAlias(rawSourceLocale, next);
+  const resolvedTargetLocale = resolveLocaleAlias(rawTargetLocale, next);
+  const usesDefaultSystemMessage = next.systemMessage === buildDefaultSystemMessage(rawSourceLocale, rawTargetLocale);
+  return {
+    ...next,
+    sourceLocale: resolvedSourceLocale,
+    targetLocale: resolvedTargetLocale,
+    systemMessage: usesDefaultSystemMessage ? buildDefaultSystemMessage(resolvedSourceLocale, resolvedTargetLocale) : next.systemMessage
+  };
+}
+function completeAngyConfig(input) {
+  assertNonEmptyString(input.basePoPath, "basePoPath");
+  assertNonEmptyString(input.workingPoPath, "workingPoPath");
+  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.`);
+  }
+  validateRoutePath(input.routePath);
+  validateWatchIgnore(input.watchIgnore);
+  validateSuggestionProvider(input.suggestionProvider);
+  return {
+    basePoPath: input.basePoPath,
+    workingPoPath: input.workingPoPath,
+    sourceLocale: input.sourceLocale,
+    targetLocale: input.targetLocale,
+    routePath: input.routePath ?? "/api/translations",
+    apiKey: input.apiKey,
+    systemMessage: input.systemMessage ?? buildDefaultSystemMessage(input.sourceLocale, input.targetLocale),
+    suggestionModel: input.suggestionModel ?? "gpt-4.1-mini",
+    watchIgnore: input.watchIgnore ?? ["**/en-working.po"],
+    suggestionProvider: input.suggestionProvider
+  };
+}
+function defineAngyConfig(config2) {
+  return completeAngyConfig(config2);
+}
+async function fileExists(path) {
+  try {
+    await readFile(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadTsConfigModule(path) {
+  const source = await readFile(path, "utf8");
+  const transformed = await transform(source, {
+    loader: "ts",
+    format: "esm",
+    target: "es2022"
+  });
+  const tempPath = `${path}.angy.tmp.mjs`;
+  await writeFile(tempPath, transformed.code, "utf8");
+  try {
+    return await import(`${pathToFileURL(tempPath).href}?t=${Date.now()}`);
+  } finally {
+    await unlink(tempPath).catch(() => void 0);
+  }
+}
+async function loadJsConfigModule(path) {
+  return import(pathToFileURL(path).href);
+}
+async function loadAngyConfigFromRoot(root) {
+  if (loadedConfigRoot === root) {
+    return config;
+  }
+  for (const filename of CONFIG_FILENAMES) {
+    const fullPath = `${root}/${filename}`.replace(/\\/g, "/");
+    if (!await fileExists(fullPath)) continue;
+    const module = filename.endsWith(".ts") ? await loadTsConfigModule(fullPath) : await loadJsConfigModule(fullPath);
+    const raw = module.default ?? module.config ?? {};
+    const next = resolveConfiguredLocaleAliases(
+      normalizeTranslationHelperConfig(root, completeAngyConfig(raw))
+    );
+    configureTranslationHelper(next);
+    loadedConfigRoot = root;
+    return config;
+  }
+  loadedConfigRoot = root;
+  return config;
+}
+
+// src/lib/server/catalog.ts
+var runtimeTranslations = /* @__PURE__ */ new Map();
+function catalogEntryKey(msgid, msgctxt) {
+  return `${msgctxt ?? ""}::${msgid}`;
+}
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function normalizeForLookup(value) {
+  return normalizeWhitespace(value).replace(/<\/?[a-z][^>]*>/gi, "<x>").replace(/<\/?\d+>/g, "<x>").replace(/\{\{?\s*[^}]+\s*\}?\}/g, "{0}").replace(/\{\d+\}/g, "{0}").replace(/[""'`´]/g, "'").toLowerCase();
+}
+function tokenizeForLookup(value) {
+  return normalizeForLookup(value).split(/[\s,.;:!?()[\]{}]+/).map((token) => token.trim()).filter(Boolean);
+}
+function buildLookupVariants(raw) {
+  const normalized = normalizeForLookup(raw);
+  const variants = /* @__PURE__ */ new Set([normalized]);
+  variants.add(normalized.replace(/<x>/g, "<0>"));
+  variants.add(normalized.replace(/<x>/g, "").replace(/\s+/g, " ").trim());
+  variants.add(normalized.replace(/\{0\}/g, "").replace(/\s+/g, " ").trim());
+  return [...variants].filter(Boolean);
+}
+function flattenPoEntries(parsed, translationOrigin) {
+  const entries = [];
+  const translations = parsed?.translations ?? {};
+  for (const [ctxKey, group] of Object.entries(translations)) {
+    for (const [msgidKey, raw] of Object.entries(group)) {
+      if (!msgidKey) continue;
+      const entry = raw;
+      const msgid = entry.msgid ?? msgidKey;
+      const msgctxt = entry.msgctxt ?? (ctxKey === "" ? null : ctxKey);
+      const msgidPlural = entry.msgid_plural ?? null;
+      const msgstr = Array.isArray(entry.msgstr) ? entry.msgstr.filter(Boolean) : [];
+      const references = entry.comments?.reference ? entry.comments.reference.split("\n").map((item) => item.trim()).filter(Boolean) : [];
+      const extractedComments = entry.comments?.extracted ? entry.comments.extracted.split("\n").map((item) => item.trim()).filter(Boolean) : [];
+      const flags = entry.comments?.flag ? entry.comments.flag.split(",").map((item) => item.trim()).filter(Boolean) : [];
+      const previous = entry.comments?.previous ? entry.comments.previous.split("\n").map((item) => item.trim()).filter(Boolean) : [];
+      const translated = entry.msgstr?.some((item) => item.trim().length > 0) ?? false;
+      const fuzzy = entry.comments?.flag?.includes("fuzzy");
+      entries.push({
+        msgid,
+        msgctxt,
+        msgidPlural,
+        msgstr,
+        references,
+        extractedComments,
+        flags,
+        previous,
+        obsolete: Boolean(entry.obsolete),
+        searchText: normalizeForLookup(msgid),
+        searchTokens: tokenizeForLookup(msgid),
+        isFuzzy: fuzzy,
+        hasTranslation: translated,
+        translationOrigin
+      });
+    }
+  }
+  return entries;
+}
+function createFuse(entries) {
+  return new Fuse(entries, {
+    includeScore: true,
+    ignoreLocation: true,
+    threshold: 0.34,
+    minMatchCharLength: 2,
+    keys: [
+      { name: "msgid", weight: 0.7 },
+      { name: "searchText", weight: 0.2 },
+      { name: "references", weight: 0.1 }
+    ]
+  });
+}
+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
+  };
+}
+async function fileExists2(path) {
+  try {
+    await access(path, fsConstants.F_OK);
+    return true;
+  } catch {
+    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;
+  if (catalog === "working") {
+    const exists = await fileExists2(path);
+    if (!exists) return null;
+  }
+  const raw = await readFile2(path);
+  return gettextParser.po.parse(raw);
+}
+async function ensureWorkingCatalog() {
+  const { basePoPath, workingPoPath } = getTranslationHelperConfig();
+  const exists = await fileExists2(workingPoPath);
+  if (!exists) {
+    await copyFile(basePoPath, workingPoPath);
+  }
+}
+function removeFuzzyFlag(flagString) {
+  if (!flagString) return "";
+  return flagString.split(",").map((item) => item.trim()).filter(Boolean).filter((item) => item !== "fuzzy").join(", ");
+}
+async function writeWorkingCatalog(parsed) {
+  const { workingPoPath } = getTranslationHelperConfig();
+  suspendWorkingCatalogWatch(workingPoPath);
+  const compiled = gettextParser.po.compile(parsed);
+  await writeFile2(workingPoPath, compiled);
+}
+function timestampForBackup() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function buildBackupPath(path, label) {
+  const directory = dirname2(path);
+  const extension = extname2(path);
+  const stem = basename2(path, extension);
+  return join(directory, `${stem}.${label}.${timestampForBackup()}${extension}`);
+}
+async function rotateCatalogs() {
+  const { basePoPath, workingPoPath } = getTranslationHelperConfig();
+  const workingExists = await fileExists2(workingPoPath);
+  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(basePoPath, workingPoPath);
+  return {
+    ok: true,
+    basePoPath,
+    workingPoPath,
+    baseBackupPath,
+    workingBackupPath
+  };
+}
+
+// src/lib/server/commit.ts
+function runtimeKey(msgid, msgctxt) {
+  return `${msgctxt ?? ""}::${msgid}`;
+}
+async function writeTranslationToWorkingCatalog(resolvedMsgid, resolvedMsgctxt, translationValue) {
+  await ensureWorkingCatalog();
+  const [baseParsed, workingParsed] = await Promise.all([
+    readParsedCatalog("base"),
+    readParsedCatalog("working")
+  ]);
+  if (!baseParsed || !workingParsed) {
+    return { ok: false, error: "Unable to load catalogs" };
+  }
+  const baseTranslations = baseParsed.translations ?? {};
+  const workingTranslations = workingParsed.translations ?? {};
+  const ctxKey = resolvedMsgctxt ?? "";
+  const baseGroup = baseTranslations[ctxKey];
+  if (!baseGroup) {
+    return { ok: false, error: "Context group not found in base catalog" };
+  }
+  const baseEntry = baseGroup[resolvedMsgid];
+  if (!baseEntry) {
+    return { ok: false, error: "Target msgid not found in base catalog" };
+  }
+  const workingGroup = workingTranslations[ctxKey] ??= {};
+  const entry = workingGroup[resolvedMsgid] ??= cloneEntryForWorking(baseEntry, resolvedMsgid, resolvedMsgctxt);
+  entry.msgstr = [translationValue];
+  entry.comments ??= {};
+  entry.comments.flag = removeFuzzyFlag(entry.comments.flag);
+  await writeWorkingCatalog(workingParsed);
+  runtimeTranslations.set(runtimeKey(resolvedMsgid, resolvedMsgctxt), translationValue);
+  return {
+    ok: true,
+    msgid: resolvedMsgid,
+    msgctxt: resolvedMsgctxt,
+    workingCatalog: "en-working.po"
+  };
+}
+function cloneEntryForWorking(baseEntry, msgid, msgctxt) {
+  return {
+    msgid,
+    msgctxt: msgctxt ?? void 0,
+    msgid_plural: baseEntry.msgid_plural,
+    msgstr: Array.isArray(baseEntry.msgstr) ? [...baseEntry.msgstr] : [""],
+    obsolete: Boolean(baseEntry.obsolete),
+    comments: baseEntry.comments ? {
+      reference: baseEntry.comments.reference,
+      extracted: baseEntry.comments.extracted,
+      flag: baseEntry.comments.flag,
+      previous: baseEntry.comments.previous
+    } : void 0
+  };
+}
+async function handleCommitBatch(request) {
+  const data = await request.json().catch(() => null);
+  const items = Array.isArray(data?.items) ? data.items : [];
+  if (!items.length) {
+    return json(
+      {
+        success: false,
+        error: "No items to commit"
+      },
+      { status: 400 }
+    );
+  }
+  const results = [];
+  for (const item of items) {
+    const resolvedMsgid = item.resolvedMsgid?.trim();
+    const resolvedMsgctxt = item.resolvedMsgctxt && item.resolvedMsgctxt.trim().length > 0 ? item.resolvedMsgctxt.trim() : null;
+    const translationValue = item.translationValue?.trim();
+    if (!resolvedMsgid || !translationValue) {
+      results.push({
+        msgid: resolvedMsgid ?? "",
+        msgctxt: resolvedMsgctxt,
+        ok: false,
+        error: "resolvedMsgid and translationValue are required"
+      });
+      continue;
+    }
+    const result = await writeTranslationToWorkingCatalog(
+      resolvedMsgid,
+      resolvedMsgctxt,
+      translationValue
+    );
+    if (!result.ok) {
+      results.push({
+        msgid: resolvedMsgid,
+        msgctxt: resolvedMsgctxt,
+        ok: false,
+        error: result.error
+      });
+      continue;
+    }
+    results.push({
+      msgid: resolvedMsgid,
+      msgctxt: resolvedMsgctxt,
+      ok: true
+    });
+  }
+  const failed = results.filter((item) => !item.ok);
+  if (failed.length) {
+    return json(
+      {
+        success: false,
+        error: "Some translations failed to commit",
+        results
+      },
+      { status: 207 }
+    );
+  }
+  return json({
+    success: true,
+    message: `Committed ${results.length} translations to en-working.po`,
+    results
+  });
+}
+async function handleCommit(request) {
+  const data = await request.formData();
+  const resolvedMsgid = data.get("resolvedMsgid")?.toString().trim();
+  const resolvedMsgctxtRaw = data.get("resolvedMsgctxt")?.toString();
+  const translationValue = data.get("translationValue")?.toString().trim();
+  const resolvedMsgctxt = resolvedMsgctxtRaw && resolvedMsgctxtRaw.trim().length > 0 ? resolvedMsgctxtRaw.trim() : null;
+  if (!resolvedMsgid || !translationValue) {
+    return json(
+      {
+        success: false,
+        error: "resolvedMsgid and translationValue are required"
+      },
+      { status: 400 }
+    );
+  }
+  const result = await writeTranslationToWorkingCatalog(
+    resolvedMsgid,
+    resolvedMsgctxt,
+    translationValue
+  );
+  if (!result.ok) {
+    return json(
+      {
+        success: false,
+        error: result.error
+      },
+      { status: 404 }
+    );
+  }
+  return json({
+    success: true,
+    message: "Translation written to en-working.po",
+    msgid: result.msgid,
+    msgctxt: result.msgctxt,
+    workingCatalog: result.workingCatalog
+  });
+}
+async function handleRotateCatalogs() {
+  const result = await rotateCatalogs();
+  if (!result.ok) {
+    return json(
+      {
+        success: false,
+        error: result.error
+      },
+      { status: 400 }
+    );
+  }
+  return json({
+    success: true,
+    message: "Catalogs rotated",
+    basePoPath: result.basePoPath,
+    workingPoPath: result.workingPoPath,
+    baseBackupPath: result.baseBackupPath,
+    workingBackupPath: result.workingBackupPath
+  });
+}
+
+// src/lib/server/context.ts
+import { json as json2 } from "@sveltejs/kit";
+var DIRECT_MATCH_LIMIT = 5;
+var MAX_ALTERNATIVES = 300;
+var TRANSLATED_TARGET = Math.floor(MAX_ALTERNATIVES * 0.2);
+var UNTRANSLATED_TARGET = MAX_ALTERNATIVES - TRANSLATED_TARGET;
+var UNTRANSLATED_RANK_BONUS = 0.03;
+function entryKey(msgid, msgctxt) {
+  return catalogEntryKey(msgid, msgctxt);
+}
+function normalizeCurrentPath(currentPath) {
+  try {
+    return new URL(currentPath, "http://localhost").pathname;
+  } catch {
+    return currentPath;
+  }
+}
+function inferPageReference(currentPath) {
+  const normalizedPath = normalizeCurrentPath(currentPath);
+  if (normalizedPath === "/") {
+    return "src/routes/+page.svelte";
+  }
+  const trimmedPath = normalizedPath.replace(/\/+$/, "");
+  return `src/routes${trimmedPath}/+page.svelte`;
+}
+function routeLooksRelevant(routeReference, refs, extractedComments) {
+  if (!routeReference) return false;
+  const haystack = [...refs, ...extractedComments].join(" ").toLowerCase();
+  return haystack.includes(routeReference.toLowerCase());
+}
+function dedupeCandidates(candidates) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const item of candidates) {
+    const id = entryKey(item.entry.msgid, item.entry.msgctxt);
+    const existing = deduped.get(id);
+    if (!existing || item.score < existing.score) {
+      deduped.set(id, item);
+    }
+  }
+  return [...deduped.values()];
+}
+function rankDirectMatches(candidates, routeReference) {
+  return [...candidates].sort((left, right) => {
+    const leftRoute = routeLooksRelevant(
+      routeReference,
+      left.entry.references,
+      left.entry.extractedComments
+    ) ? -0.08 : 0;
+    const rightRoute = routeLooksRelevant(
+      routeReference,
+      right.entry.references,
+      right.entry.extractedComments
+    ) ? -0.08 : 0;
+    const leftUntranslated = !left.entry.hasTranslation ? -UNTRANSLATED_RANK_BONUS : 0;
+    const rightUntranslated = !right.entry.hasTranslation ? -UNTRANSLATED_RANK_BONUS : 0;
+    return left.score + leftRoute + leftUntranslated - (right.score + rightRoute + rightUntranslated);
+  });
+}
+function getReferenceTokens(reference) {
+  return reference.toLowerCase().split(/[\/\[\].:_-]+/).map((token) => token.trim()).filter(Boolean);
+}
+function getReferenceSimilarity(reference, routeReference) {
+  const referenceTokens = new Set(getReferenceTokens(reference));
+  const routeTokens = getReferenceTokens(routeReference);
+  if (!routeTokens.length || !referenceTokens.size) return 0;
+  let matches = 0;
+  for (const token of routeTokens) {
+    if (referenceTokens.has(token)) {
+      matches += 1;
+    }
+  }
+  return matches / routeTokens.length;
+}
+function collectSharedReferenceAlternatives(entries, bestEntry, routeReference, excludedKeys) {
+  const sharedReferences = new Set(bestEntry.references.map((reference) => reference.toLowerCase()));
+  return entries.filter((entry) => !excludedKeys.has(entryKey(entry.msgid, entry.msgctxt))).map((entry) => {
+    const referenceMatches = entry.references.filter(
+      (reference) => sharedReferences.has(reference.toLowerCase())
+    );
+    const routeMatch = entry.references.some(
+      (reference) => reference.toLowerCase().includes(routeReference.toLowerCase())
+    );
+    if (!referenceMatches.length && !routeMatch) {
+      return null;
+    }
+    const referenceSimilarity = Math.max(
+      0,
+      ...entry.references.map((reference) => getReferenceSimilarity(reference, routeReference))
+    );
+    const untranslatedBonus = !entry.hasTranslation ? 0.35 : 0;
+    return {
+      entry,
+      score: referenceMatches.length * 100 + (routeMatch ? 25 : 0) + referenceSimilarity + untranslatedBonus,
+      variant: "shared-reference"
+    };
+  }).filter((item) => Boolean(item)).sort((left, right) => right.score - left.score);
+}
+function collectRouteFillAlternatives(entries, routeReference, excludedKeys) {
+  return entries.filter((entry) => !excludedKeys.has(entryKey(entry.msgid, entry.msgctxt))).map((entry) => {
+    const referenceSimilarity = Math.max(
+      0,
+      ...entry.references.map((reference) => getReferenceSimilarity(reference, routeReference))
+    );
+    if (referenceSimilarity <= 0) {
+      return null;
+    }
+    const untranslatedBonus = !entry.hasTranslation ? 0.2 : 0;
+    return {
+      entry,
+      score: referenceSimilarity + untranslatedBonus,
+      variant: "route-reference"
+    };
+  }).filter((item) => Boolean(item)).sort((left, right) => right.score - left.score);
+}
+function collectTranslatedCohesionAlternatives(directMatches, excludedKeys) {
+  return directMatches.filter((item) => item.entry.hasTranslation).filter((item) => !excludedKeys.has(entryKey(item.entry.msgid, item.entry.msgctxt))).map((item) => ({
+    entry: item.entry,
+    score: 1 - item.score,
+    variant: "translated-cohesion"
+  })).sort((left, right) => right.score - left.score);
+}
+function collectUntranslatedSimilarityAlternatives(directMatches, excludedKeys) {
+  return directMatches.filter((item) => !item.entry.hasTranslation).filter((item) => !excludedKeys.has(entryKey(item.entry.msgid, item.entry.msgctxt))).map((item) => ({
+    entry: item.entry,
+    score: 1 - item.score,
+    variant: "untranslated-similarity"
+  })).sort((left, right) => right.score - left.score);
+}
+function buildAlternativePool(topDirectAlternatives, sharedReferenceAlternatives, routeFillAlternatives, translatedCohesionAlternatives, untranslatedSimilarityAlternatives) {
+  const alternatives = [...topDirectAlternatives];
+  const selectedKeys = new Set(
+    topDirectAlternatives.map((item) => entryKey(item.entry.msgid, item.entry.msgctxt))
+  );
+  let translatedCount = topDirectAlternatives.filter((item) => item.entry.hasTranslation).length;
+  let untranslatedCount = topDirectAlternatives.length - translatedCount;
+  const tryAdd = (item, honorQuota = true) => {
+    if (alternatives.length >= MAX_ALTERNATIVES) return false;
+    const id = entryKey(item.entry.msgid, item.entry.msgctxt);
+    if (selectedKeys.has(id)) return false;
+    if (honorQuota) {
+      if (item.entry.hasTranslation && translatedCount >= TRANSLATED_TARGET) return false;
+      if (!item.entry.hasTranslation && untranslatedCount >= UNTRANSLATED_TARGET) return false;
+    }
+    selectedKeys.add(id);
+    alternatives.push(item);
+    if (item.entry.hasTranslation) {
+      translatedCount += 1;
+    } else {
+      untranslatedCount += 1;
+    }
+    return true;
+  };
+  const prioritizedSources = [
+    sharedReferenceAlternatives,
+    routeFillAlternatives,
+    untranslatedSimilarityAlternatives,
+    translatedCohesionAlternatives
+  ];
+  for (const source of prioritizedSources) {
+    for (const item of source) {
+      tryAdd(item, true);
+    }
+  }
+  if (alternatives.length < MAX_ALTERNATIVES) {
+    for (const source of prioritizedSources) {
+      for (const item of source) {
+        tryAdd(item, false);
+      }
+    }
+  }
+  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 effectiveIndex = {
+    entries: effectiveEntries,
+    fuse: createFuse(effectiveEntries)
+  };
+  const routeReference = inferPageReference(currentPath);
+  const directMatches = rankDirectMatches(
+    dedupeCandidates(
+      buildLookupVariants(key).flatMap(
+        (variant) => effectiveIndex.fuse.search(variant, { limit: 180 }).map((hit) => ({
+          entry: hit.item,
+          score: hit.score ?? 1,
+          variant
+        }))
+      )
+    ),
+    routeReference
+  );
+  const best = directMatches[0];
+  if (!best || best.score > 0.42) {
+    return null;
+  }
+  const effectiveDirectMatches = directMatches;
+  const bestEffective = effectiveDirectMatches[0];
+  const topDirectAlternatives = effectiveDirectMatches.slice(1, DIRECT_MATCH_LIMIT);
+  const excludedKeys = /* @__PURE__ */ new Set([
+    entryKey(best.entry.msgid, best.entry.msgctxt),
+    ...topDirectAlternatives.map((item) => entryKey(item.entry.msgid, item.entry.msgctxt))
+  ]);
+  const sharedReferenceAlternatives = collectSharedReferenceAlternatives(
+    effectiveEntries,
+    bestEffective.entry,
+    routeReference,
+    excludedKeys
+  );
+  const routeFillAlternatives = collectRouteFillAlternatives(
+    effectiveEntries,
+    routeReference,
+    excludedKeys
+  );
+  const translatedCohesionAlternatives = collectTranslatedCohesionAlternatives(
+    effectiveDirectMatches.slice(DIRECT_MATCH_LIMIT),
+    excludedKeys
+  );
+  const untranslatedSimilarityAlternatives = collectUntranslatedSimilarityAlternatives(
+    effectiveDirectMatches.slice(DIRECT_MATCH_LIMIT),
+    excludedKeys
+  );
+  return {
+    best,
+    alternatives: buildAlternativePool(
+      topDirectAlternatives,
+      sharedReferenceAlternatives,
+      routeFillAlternatives,
+      translatedCohesionAlternatives,
+      untranslatedSimilarityAlternatives
+    ),
+    routeReference,
+    workingMap
+  };
+}
+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;
+  return {
+    msgid: entry.msgid,
+    msgctxt: entry.msgctxt,
+    msgidPlural: entry.msgidPlural,
+    msgstr: effective.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"
+  };
+}
+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;
+  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"
+  };
+}
+async function handleContext(request) {
+  const data = await request.formData();
+  const key = data.get("translationKey")?.toString().trim();
+  const currentPath = data.get("currentPath")?.toString().trim();
+  if (!key || !currentPath) {
+    return json2(
+      {
+        success: false,
+        error: "translationKey and currentPath are required"
+      },
+      { status: 400 }
+    );
+  }
+  const baseFound = await findTranslationContext(key, currentPath);
+  if (!baseFound) {
+    return json2(
+      {
+        success: false,
+        error: "Translation key context not found"
+      },
+      { status: 404 }
+    );
+  }
+  const bestBase = baseFound.best.entry;
+  const bestWorking = baseFound.workingMap.get(entryKey(bestBase.msgid, bestBase.msgctxt));
+  return json2({
+    success: true,
+    match: {
+      score: baseFound.best.score,
+      via: baseFound.best.variant
+    },
+    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);
+    })
+  });
+}
+
+// src/lib/server/suggestions.ts
+import { json as json3 } from "@sveltejs/kit";
+function getEntriesForSuggestions(contextResult) {
+  return [contextResult.entry, ...contextResult.alternatives];
+}
+function getTranslatedExamples(contextResult) {
+  return getEntriesForSuggestions(contextResult).filter((entry) => entry.hasTranslation && entry.msgstr?.[0]).slice(0, 30).map((entry) => ({
+    msgid: entry.msgid,
+    msgctxt: entry.msgctxt,
+    translation: entry.msgstr[0]
+  }));
+}
+function buildUserMessage(contextResult, items) {
+  return JSON.stringify(
+    {
+      task: "Return translation suggestions for the untranslated UI strings.",
+      output_format: {
+        items: [
+          {
+            msgid: "source string",
+            msgctxt: "optional context or null",
+            suggestion: "translated suggestion"
+          }
+        ]
+      },
+      translated_examples: getTranslatedExamples(contextResult),
+      untranslated_items: items
+    },
+    null,
+    2
+  );
+}
+function parseSuggestions(responseText) {
+  try {
+    const parsed = JSON.parse(responseText);
+    const items = Array.isArray(parsed?.items) ? parsed.items : [];
+    return items.filter(
+      (item) => typeof item?.msgid === "string" && (item.msgctxt === null || typeof item.msgctxt === "string") && typeof item?.suggestion === "string"
+    );
+  } catch {
+    return [];
+  }
+}
+async function handleSuggestions(request) {
+  const {
+    apiKey,
+    suggestionModel,
+    systemMessage,
+    sourceLocale,
+    targetLocale,
+    suggestionProvider
+  } = getTranslationHelperConfig();
+  const data = await request.json().catch(() => null);
+  const context = data?.context;
+  const items = Array.isArray(data?.items) ? data.items : [];
+  if (!context || !items.length) {
+    return json3(
+      {
+        success: false,
+        error: "context and items are required"
+      },
+      { status: 400 }
+    );
+  }
+  if (suggestionProvider) {
+    const providedItems = await suggestionProvider({
+      context,
+      items,
+      sourceLocale,
+      targetLocale,
+      systemMessage,
+      model: suggestionModel,
+      apiKey
+    });
+    return json3({
+      success: true,
+      items: providedItems
+    });
+  }
+  if (!apiKey.trim()) {
+    console.warn("[angy] Suggestions disabled because apiKey is empty.");
+    return json3({
+      success: true,
+      disabled: true,
+      items: []
+    });
+  }
+  try {
+    console.info("[angy] Suggestion request starting.", {
+      model: suggestionModel,
+      sourceLocale,
+      targetLocale,
+      itemCount: items.length,
+      hasApiKey: Boolean(apiKey.trim())
+    });
+    const response = await fetch("https://api.openai.com/v1/responses", {
+      method: "POST",
+      headers: {
+        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"]
+            }
+          }
+        }
+      })
+    });
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      console.error("[angy] Suggestion request failed.", {
+        status: response.status,
+        statusText: response.statusText,
+        body: errorBody
+      });
+      return json3(
+        {
+          success: false,
+          error: `Suggestion request failed: ${response.status}`
+        },
+        { status: 502 }
+      );
+    }
+    const responseJson = await response.json();
+    const responseText = responseJson?.output_text ?? responseJson?.output?.flatMap((item) => item?.content ?? []).find((part) => part?.text)?.text ?? "";
+    return json3({
+      success: true,
+      items: parseSuggestions(responseText)
+    });
+  } catch (error) {
+    console.error("[angy] Suggestion request threw.", error);
+    return json3(
+      {
+        success: false,
+        error: "Suggestion request failed before reaching the model"
+      },
+      { status: 502 }
+    );
+  }
+}
+
+// src/lib/server/route.ts
+async function handleTranslationRequest(request, url, options) {
+  const devOnly = options?.devOnly ?? true;
+  const runtimeDev = typeof import.meta !== "undefined" && typeof import.meta.env !== "undefined" && import.meta.env.DEV === true;
+  const isDev = options?.dev ?? runtimeDev;
+  if (devOnly && !isDev) {
+    return json4(
+      {
+        success: false,
+        error: "Disabled outside dev"
+      },
+      { status: 404 }
+    );
+  }
+  if (options?.config) {
+    configureTranslationHelper(normalizeTranslationHelperConfig(process.cwd(), options.config));
+  } else {
+    await loadAngyConfigFromRoot(process.cwd());
+  }
+  const intent = url.searchParams.get("intent") ?? "commit";
+  if (intent === "commit-batch") {
+    return handleCommitBatch(request);
+  }
+  if (intent === "context") {
+    return handleContext(request);
+  }
+  if (intent === "suggestions") {
+    return handleSuggestions(request);
+  }
+  if (intent === "rotate-catalogs") {
+    return handleRotateCatalogs();
+  }
+  return handleCommit(request);
+}
+function createAngyHandler(options) {
+  return async ({ request, url }) => handleTranslationRequest(request, url, options);
+}
+var handler = createAngyHandler();
+export {
+  defineAngyConfig,
+  handleTranslationRequest,
+  handler
+};
+//# sourceMappingURL=server.js.map