@makuraryu/yonde 0.4.1 → 0.4.3

package/README.md

@@ -152,7 +152,9 @@ package_asset = "uisfx/sounds/cinematic/select.mp3"
 
 翻译、语音生成和最终 MP3 合并都会显示单行进度条，包括完成比例、数量、耗时和 ETA。非交互终端按 5% 里程碑输出，避免日志刷屏。
 
-所有语音和分隔音效会统一为 24 kHz、单声道、96 kbps，最终 MP3 采用无损快速拼接，不再把数小时音频完整重编码。
+如果模型把一个输入句子的译文错误拆成多项，Yonde 会先带着数量校验错误进行严格重试；仍不符合时，仅对单句结果执行顺序合并，避免检查点永久卡在同一段。
+
+所有语音和分隔音效会统一为 24 kHz、单声道、96 kbps，最终 MP3 采用无损快速拼接，不再把数小时音频完整重编码。合并中的大临时文件写在本机临时目录，完成后再一次性写入目标位置，避免 iCloud 持续同步一个不断增长的文件。
 
 最终合并使用状态文件保护原子写入。若进程在 ffmpeg 已完成后、最终重命名前退出，下次运行会直接恢复成品；若在合并中途退出，只会重做最终合并，已经生成的翻译和 TTS 缓存不会丢失。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makuraryu/yonde",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Config-driven Bun CLI for creating bilingual Japanese listening scripts and MP3 audio",
   "type": "module",
   "bin": {

package/src/audio.ts

@@ -1,6 +1,7 @@
 import { EdgeTTS } from "node-edge-tts";
-import { lstat, mkdir, readdir, rename, rm } from "node:fs/promises";
+import { copyFile, lstat, mkdir, mkdtemp, readdir, rename, rm } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
 import { basename, dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { AppConfig, VoiceProfile } from "./config";
@@ -118,17 +119,22 @@ export function audioMergeFingerprint(value: Omit<AudioManifest, "version" | "me
   return new Bun.CryptoHasher("sha256").update(JSON.stringify(value)).digest("hex");
 }
 
-export function mergeStateCanRecover(value: unknown, fingerprint: string, outputPath: string): value is MergeState {
+function mergeTemporaryIsSafe(value: unknown, outputPath: string): value is MergeState {
   if (!value || typeof value !== "object") return false;
   const state = value as Partial<MergeState>;
-  const prefix = `${basename(outputPath)}.`;
+  return typeof state.temporary === "string"
+    && dirname(dirname(state.temporary)) === tmpdir()
+    && basename(dirname(state.temporary)).startsWith("yonde-merge-")
+    && basename(state.temporary) === `${basename(outputPath)}.tmp.mp3`;
+}
+
+export function mergeStateCanRecover(value: unknown, fingerprint: string, outputPath: string): value is MergeState {
+  if (!mergeTemporaryIsSafe(value, outputPath)) return false;
+  const state = value as Partial<MergeState>;
   return state.version === 1
     && state.status === "complete"
     && state.fingerprint === fingerprint
-    && typeof state.temporary === "string"
-    && dirname(state.temporary) === dirname(outputPath)
-    && basename(state.temporary).startsWith(prefix)
-    && basename(state.temporary).endsWith(".tmp.mp3");
+    && typeof state.expectedSeconds === "number";
 }
 
 async function temporaryOutputs(outputPath: string): Promise<string[]> {
@@ -152,11 +158,23 @@ async function estimateDurationSeconds(items: AudioItem[]): Promise<number> {
   return Math.max(1, bytes * 8 / 96_000);
 }
 
+async function installMergedOutput(source: string, outputPath: string): Promise<void> {
+  const staged = `${outputPath}.${process.pid}.${randomUUID()}.tmp.mp3`;
+  try {
+    await copyFile(source, staged);
+    await rename(staged, outputPath);
+  } catch (error) {
+    await rm(staged, { force: true });
+    throw error;
+  }
+}
+
 async function recoverCompletedMerge(outputPath: string, stateDir: string, fingerprint: string): Promise<boolean> {
   const statePath = join(stateDir, "audio-merge-state.json");
   const state = await readJson<unknown>(statePath);
   if (!mergeStateCanRecover(state, fingerprint, outputPath) || !(await fileIsUsable(state.temporary))) return false;
-  await rename(state.temporary, outputPath);
+  await installMergedOutput(state.temporary, outputPath);
+  await rm(dirname(state.temporary), { recursive: true, force: true });
   await rm(statePath, { force: true });
   for (const stale of await temporaryOutputs(outputPath)) await rm(stale, { force: true });
   const progress = new ProgressBar("恢复", 1);
@@ -164,6 +182,13 @@ async function recoverCompletedMerge(outputPath: string, stateDir: string, finge
   return true;
 }
 
+async function discardStaleMerge(outputPath: string, stateDir: string): Promise<void> {
+  const statePath = join(stateDir, "audio-merge-state.json");
+  const state = await readJson<unknown>(statePath);
+  if (mergeTemporaryIsSafe(state, outputPath)) await rm(dirname(state.temporary), { recursive: true, force: true });
+  await rm(statePath, { force: true });
+}
+
 async function readFfmpegProgress(stream: ReadableStream<Uint8Array>, progress: ProgressBar, totalSeconds: number): Promise<void> {
   const reader = stream.getReader();
   const decoder = new TextDecoder();
@@ -193,7 +218,8 @@ async function runFfmpeg(
   const paths = items.map((item) => relative(stateDir, item.path));
   if (paths.some((path) => path.startsWith("..") || /[\r\n\0]/.test(path))) throw new Error("音频缓存路径超出状态目录或含控制字符");
   await atomicWrite(listPath, paths.map((path) => `file '${escapeConcatPath(path)}'`).join("\n") + "\n");
-  const temporary = `${outputPath}.${process.pid}.${randomUUID()}.tmp.mp3`;
+  const temporaryDir = await mkdtemp(join(tmpdir(), "yonde-merge-"));
+  const temporary = join(temporaryDir, `${basename(outputPath)}.tmp.mp3`);
   const mergeStatePath = join(stateDir, "audio-merge-state.json");
   const expectedSeconds = await estimateDurationSeconds(items);
   const progress = new ProgressBar("合并", expectedSeconds);
@@ -216,7 +242,7 @@ async function runFfmpeg(
   const stderr = await stderrReader;
   if (exitCode !== 0) {
     progress.fail(`退出码 ${exitCode}`);
-    await rm(temporary, { force: true });
+    await rm(temporaryDir, { recursive: true, force: true });
     await rm(mergeStatePath, { force: true });
     const detail = stderr.trim().split("\n").at(-1);
     throw new Error(`ffmpeg 合并失败，退出码 ${exitCode}${detail ? `: ${detail}` : ""}`);
@@ -229,7 +255,8 @@ async function runFfmpeg(
     expectedSeconds,
   } satisfies MergeState);
   progress.finish(`${items.length} 个片段`);
-  await rename(temporary, outputPath);
+  await installMergedOutput(temporary, outputPath);
+  await rm(temporaryDir, { recursive: true, force: true });
   await rm(mergeStatePath, { force: true });
 }
 
@@ -352,6 +379,7 @@ export async function buildAudio(
   };
   const mergeFingerprint = audioMergeFingerprint(manifestBody);
   if (await recoverCompletedMerge(outputPath, stateDir, mergeFingerprint)) return;
+  await discardStaleMerge(outputPath, stateDir);
   const stale = await temporaryOutputs(outputPath);
   if (stale.length) console.warn(`发现 ${stale.length} 个未完成的合并临时文件，将保留语音缓存并重新合并。`);
   for (const path of stale) await rm(path, { force: true });

package/src/main.ts

@@ -11,7 +11,7 @@ type Stage = "translate" | "audio" | "all";
 type RunArgs = { command: "run"; input: string; stage: Stage; outputDir?: string; configPath?: string };
 type CliArgs = RunArgs | { command: "init"; path: string } | { command: "config-check"; configPath?: string } | { command: "help" } | { command: "version" };
 
-const VERSION = "0.4.1";
+const VERSION = "0.4.3";
 
 export const HELP_TEXT = `Yonde ${VERSION} — 配置驱动的双语听力材料生成器
 

package/src/translate.ts

@@ -15,6 +15,17 @@ type ModelTranslation = {
   glossaryUpdates?: GlossaryEntry[];
 };
 
+class TranslationCountError extends Error {
+  constructor(readonly result: ModelTranslation, expected: number) {
+    super(`译文数量不符：期望 ${expected}，得到 ${Array.isArray(result.translations) ? result.translations.length : 0}`);
+  }
+}
+
+export function coalesceSingletonTranslations(value: unknown): string | undefined {
+  if (!Array.isArray(value) || value.length < 2 || value.some((item) => typeof item !== "string" || !item.trim())) return undefined;
+  return value.map((item) => item.trim()).join("");
+}
+
 function systemPrompt(config: AppConfig): string {
   return `你是文学翻译者。任务是把 ${config.translation.sourceLanguage} 文学片段翻译成自然、准确、适合听力学习的 ${config.translation.targetLanguage}。
 必须保持叙述人称、人物称谓、专有名词和文体与已有上下文一致。不要解释，不要合并或拆分输入片段。
@@ -47,6 +58,7 @@ async function translateBatch(
   glossary: GlossaryEntry[],
   apiKey: string,
   config: AppConfig,
+  validationFeedback?: string,
 ): Promise<ModelTranslation> {
   const context = translated.slice(-config.translation.contextParagraphs).map((item) => ({
     original: item.original,
@@ -67,6 +79,8 @@ async function translateBatch(
           establishedGlossary: glossary,
           paragraph: paragraph.original,
           earlierInThisParagraph: earlierInParagraph,
+          requiredTranslationCount: sentences.length,
+          validationFeedback,
           sentences: sentences.map((text, index) => ({ index: sentenceOffset + index, text })),
         }),
       },
@@ -87,7 +101,7 @@ async function translateBatch(
   if (!content) throw new Error("翻译 API 返回了空响应");
   const parsed = parseModelJson(content);
   if (!Array.isArray(parsed.translations) || parsed.translations.length !== sentences.length) {
-    throw new Error(`译文数量不符：期望 ${sentences.length}，得到 ${parsed.translations?.length ?? 0}`);
+    throw new TranslationCountError(parsed, sentences.length);
   }
   if (parsed.translations.some((item) => typeof item !== "string" || !item.trim())) throw new Error("译文包含空项");
   return parsed;
@@ -106,6 +120,8 @@ async function translateOne(
   async function alignedBatch(offset: number, sentences: string[]): Promise<ModelTranslation> {
     let result: ModelTranslation | undefined;
     let lastError: unknown;
+    let repairableResult: ModelTranslation | undefined;
+    let validationFeedback: string | undefined;
     for (let attempt = 1; attempt <= 2; attempt += 1) {
       try {
         result = await translateBatch(
@@ -117,15 +133,27 @@ async function translateOne(
           glossary,
           apiKey,
           config,
+          validationFeedback,
         );
         break;
       } catch (error) {
         lastError = error;
+        if (error instanceof TranslationCountError) {
+          validationFeedback = `${error.message}。请重新输出，translations 必须严格只有 ${sentences.length} 项；不要把同一个句子拆成多项，也不要另行翻译整个 paragraph。`;
+          if (sentences.length === 1 && coalesceSingletonTranslations(error.result.translations)) repairableResult = error.result;
+        }
         if (attempt < 2) await Bun.sleep(750);
       }
     }
     if (result) return result;
-    if (sentences.length === 1) throw lastError;
+    if (sentences.length === 1) {
+      const repaired = coalesceSingletonTranslations(repairableResult?.translations);
+      if (repaired) return {
+        translations: [repaired],
+        glossaryUpdates: Array.isArray(repairableResult?.glossaryUpdates) ? repairableResult.glossaryUpdates : [],
+      };
+      throw lastError;
+    }
 
     const middle = Math.ceil(sentences.length / 2);
     const left = await alignedBatch(offset, sentences.slice(0, middle));