akari-video 0.1.43 → 0.1.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "0.1.43",
+  "version": "0.1.45",
   "description": "AKARI Video launcher CLI — start an AI-edited video project from any directory: scaffold, connection check, then hand over to Claude Code (or opencode). AKARI Video を opencode や Claude Code で、どのディレクトリからでも始めるための `akari` ランチャー CLI。接続確認（doctor）→ 未セットアップならプロジェクト雛形を作成 → AI エージェントを起動する。外部 npm 依存ゼロ（Node.js 組み込みモジュールのみ）。",
   "type": "module",
   "bin": {

package/vendor/.akari-capability-sources.json

@@ -167,6 +167,7 @@
     "skills/harvest-asset/SKILL.md",
     "skills/manage-connections/SKILL.md",
     "skills/overlay-authoring/3d.md",
+    "skills/overlay-authoring/glass.md",
     "skills/overlay-authoring/motion.md",
     "skills/overlay-authoring/SKILL.md",
     "skills/overlay-authoring/table.md",

package/vendor/packages/akari-launcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "0.1.43",
+  "version": "0.1.45",
   "description": "AKARI Video launcher CLI — start an AI-edited video project from any directory: scaffold, connection check, then hand over to Claude Code (or opencode). AKARI Video を opencode や Claude Code で、どのディレクトリからでも始めるための `akari` ランチャー CLI。接続確認（doctor）→ 未セットアップならプロジェクト雛形を作成 → AI エージェントを起動する。外部 npm 依存ゼロ（Node.js 組み込みモジュールのみ）。 [akari-video npm vendor: bin/akari.mjs is reference-only. These CLI entrypoints are not included in the akari-video npm package. Use `akari doctor --json` and run the path reported in `render_cut.path`. Full installations provide it in a monorepo checkout, ~/.akari/app, /Applications/AKARI Video.app/Contents/Resources/packages, or %LOCALAPPDATA%\\Programs\\@akari-videoshell\\resources\\packages.]",
   "type": "module",
   "files": [

package/vendor/packages/media-bin/src/preview-audio-sidecar.mjs

@@ -6,6 +6,26 @@ import { spawn, spawnSync } from 'node:child_process';
 import { resolveFfmpeg, resolveFfprobe } from './index.mjs';
 
 export const PREVIEW_AUDIO_RECIPE = 'preview-audio-flac-v2';
+export const PREVIEW_AUDIO_PCM_RECIPE = 'preview-audio-pcm-v1';
+
+export function pcmWindowByteRange({ sampleRate, channels, bytesPerSample, frames }, startSec, endSec) {
+  if (!finitePositive(sampleRate) || !Number.isSafeInteger(channels) || channels <= 0
+    || !Number.isSafeInteger(bytesPerSample) || bytesPerSample <= 0
+    || !Number.isSafeInteger(frames) || frames < 0
+    || !Number.isFinite(startSec) || !Number.isFinite(endSec) || endSec <= startSec) return null;
+  const startFrame = Math.min(frames, Math.max(0, Math.floor(startSec * sampleRate)));
+  const endFrame = Math.min(frames, Math.max(0, Math.ceil(endSec * sampleRate)));
+  if (endFrame <= startFrame) return null;
+  const stride = channels * bytesPerSample;
+  return { startByte: startFrame * stride, endByte: endFrame * stride - 1,
+    startFrame, frameCount: endFrame - startFrame };
+}
+
+function audioFormat(options) {
+  const format = options?.format ?? 'flac';
+  if (format !== 'flac' && format !== 'pcm-s16le') throw new Error('format must be flac or pcm-s16le');
+  return format;
+}
 
 // Process-wide ceilings for the child processes this module starts. Both callers (the Theia
 // backend that also serves media bytes over HTTP Range, and preview-server's /api/summary)
@@ -71,23 +91,58 @@ class Semaphore {
   #waiters = [];
 
   acquire(limit) {
-    if (this.#active < limit) {
+    return this.reserve(limit).acquire();
+  }
+
+  reserve(limit) {
+    const waiter = { limit, state: 'waiting', resolve: null, reject: null };
+    let pending;
+    this.#waiters.push(waiter);
+    return {
+      acquire: () => {
+        if (!pending) {
+          pending = new Promise((resolve, reject) => {
+            if (waiter.state === 'cancelled') {
+              reject(new Error('semaphore reservation cancelled'));
+              return;
+            }
+            waiter.resolve = resolve;
+            waiter.reject = reject;
+          });
+          this.#drain();
+        }
+        return pending;
+      },
+      cancel: () => {
+        // Once acquired, the caller owns the slot and must release it normally.
+        if (waiter.state !== 'waiting') return;
+        waiter.state = 'cancelled';
+        this.#waiters.splice(this.#waiters.indexOf(waiter), 1);
+        waiter.reject?.(new Error('semaphore reservation cancelled'));
+        this.#drain();
+      },
+    };
+  }
+
+  #drain() {
+    if (this.#waiters.length) {
+      const waiter = this.#waiters[0];
+      // A probe reserves only its FIFO position, not an active ffmpeg slot.
+      // Later requests cannot pass it while it is still preparing to acquire.
+      if (!waiter.resolve || this.#active >= waiter.limit) return;
+      this.#waiters.shift();
       this.#active += 1;
-      return Promise.resolve();
+      waiter.state = 'acquired';
+      waiter.resolve();
+      // Let a newly activated ticket attach its await continuation before waking
+      // followers whose acquire() promises already have continuations attached.
+      queueMicrotask(() => this.#drain());
     }
-    return new Promise(resolve => this.#waiters.push({ limit, resolve }));
   }
 
   release() {
     this.#active -= 1;
-    for (let index = 0; index < this.#waiters.length;) {
-      if (this.#active < this.#waiters[index].limit) {
-        this.#active += 1;
-        this.#waiters.splice(index, 1)[0].resolve();
-      } else {
-        index += 1;
-      }
-    }
+    this.#drain();
   }
 
   async run(limit, task) {
@@ -100,6 +155,8 @@ class Semaphore {
   }
 }
 
+export const __testing = { Semaphore };
+
 const ffmpegSlots = new Semaphore();
 const ffprobeSlots = new Semaphore();
 
@@ -316,6 +373,7 @@ export function previewAudioSidecarKey(options) {
     padBeforeSec: options.padBeforeSec ?? 0,
     padAfterSec: options.padAfterSec ?? 0,
     filters: buildPreviewAudioFilterChain(options),
+    format: audioFormat(options),
   });
 }
 
@@ -330,7 +388,9 @@ function keyFor(sourcePath, stat, values) {
     formatNumber(values.padBeforeSec),
     formatNumber(values.padAfterSec),
     ...(values.filters ?? []),
-    PREVIEW_AUDIO_RECIPE,
+    // Keep the complete FLAC v2 hash input unchanged, including its final recipe token.
+    ...(values.format === 'pcm-s16le'
+      ? [PREVIEW_AUDIO_PCM_RECIPE, 'pcm-s16le', 24000, 1, 2] : [PREVIEW_AUDIO_RECIPE]),
   ].join('|')).digest('hex');
 }
 
@@ -346,6 +406,7 @@ function probeArguments(filePath) {
 function parseProbeOutput(stdout) {
   const parsed = JSON.parse(stdout || '{}');
   const stream = Array.isArray(parsed.streams) ? parsed.streams[0] : undefined;
+  if (!stream) throw new Error('ffprobe: no audio stream');
   const durationSec = Number(parsed.format?.duration);
   const sampleRate = Number(stream?.sample_rate);
   const channels = Number(stream?.channels);
@@ -406,7 +467,9 @@ export async function probePreviewAudioSourceAsync(sourcePath, options = {}) {
     const resolved = path.resolve(sourcePath);
     const stat = await fs.promises.stat(resolved);
     if (!stat.isFile()) throw new Error(`source is not a regular file: ${resolved}`);
-    const metadata = await probeAudioAsync(resolved, options.ffprobe ?? defaultFfprobe(), settingsFrom(options));
+    const metadata = await (typeof options.probeAudio === 'function'
+      ? options.probeAudio(resolved, options.ffprobe ?? defaultFfprobe())
+      : probeAudioAsync(resolved, options.ffprobe ?? defaultFfprobe(), settingsFrom(options)));
     return { ok: true, path: resolved, bytes: stat.size, ...metadata };
   } catch (error) {
     return probeFailure(sourcePath, error);
@@ -416,7 +479,7 @@ export async function probePreviewAudioSourceAsync(sourcePath, options = {}) {
 // Validates the request and derives the cache key / output path. Deliberately synchronous:
 // ensurePreviewAudioSidecar registers the in-flight promise right after this returns, so two
 // concurrent requests for the same output path cannot both slip past the in-flight check.
-function prepare(options, state) {
+function prepare(options, state, createDirectory = true) {
   if (!options || typeof options.sourcePath !== 'string' || !options.sourcePath) {
     throw new Error('sourcePath is required');
   }
@@ -428,6 +491,7 @@ function prepare(options, state) {
     throw new Error('inSec, outSec, speed, and pads must describe a positive source range');
   }
   if (options.clipFx) validateAudioClipFx(options.clipFx);
+  const format = audioFormat(options);
   if (typeof options.cacheDir !== 'string' || !options.cacheDir) {
     throw new Error('cacheDir is required');
   }
@@ -441,16 +505,20 @@ function prepare(options, state) {
     padBeforeSec,
     padAfterSec,
     filters: buildPreviewAudioFilterChain({ ...options, padBeforeSec, padAfterSec }),
+    format,
   };
   state.key = keyFor(sourcePath, stat, values);
   const outputDirectory = path.resolve(options.cacheDir, 'preview-audio');
-  state.outputPath = path.join(outputDirectory, `${state.key}.flac`);
-  fs.mkdirSync(outputDirectory, { recursive: true });
+  const extension = format === 'pcm-s16le' ? 'pcm' : 'flac';
+  state.outputPath = path.join(outputDirectory, `${state.key}.${extension}`);
+  if (createDirectory) fs.mkdirSync(outputDirectory, { recursive: true });
   return {
     sourcePath,
     outputDirectory,
     outputPath: state.outputPath,
     key: state.key,
+    format, extension,
+    recipe: format === 'pcm-s16le' ? PREVIEW_AUDIO_PCM_RECIPE : PREVIEW_AUDIO_RECIPE,
     startSec: Math.max(0, options.inSec - padBeforeSec),
     endSec: options.outSec + padAfterSec,
     speed: options.speed,
@@ -472,13 +540,20 @@ async function generate(prepared, options) {
   const settings = settingsFrom(options);
   const ffprobeOf = () => options.ffprobe ?? defaultFfprobe();
   // テスト・呼び出し側の注入シーム（T4 由来）: probeAudio があれば同期関数として尊重する。
-  const inspectAudio = async (p) => (typeof options.probeAudio === 'function'
+  const inspectAudio = async (p) => prepared.format === 'pcm-s16le' ? inspectPcm(p) : (typeof options.probeAudio === 'function'
     ? options.probeAudio(p, ffprobeOf())
     : probeAudioAsync(p, ffprobeOf(), settings));
   const fromExisting = async () => {
-    const metadata = await inspectAudio(outputPath);
+    options.slot?.cancel();
+    let metadata = readMetadata(prepared);
+    if (!metadata) {
+      metadata = await inspectAudio(outputPath);
+      writeMetadata(prepared, options, metadata, prepared.format === 'flac');
+    }
     return {
       ok: true, skipped: true, path: outputPath, key,
+      format: prepared.format,
+      ...(prepared.format === 'pcm-s16le' ? { frames: metadata.frames, bytesPerSample: 2 } : {}),
       durationSec: metadata.durationSec,
       sampleRate: metadata.sampleRate,
       channels: metadata.channels,
@@ -492,34 +567,51 @@ async function generate(prepared, options) {
   try {
     if (fs.existsSync(outputPath)) return fromExisting();
     const temporary = path.join(outputDirectory,
-      `.${path.basename(outputPath)}.${process.pid}.${Date.now()}.tmp.flac`);
+      `.${path.basename(outputPath)}.${process.pid}.${Date.now()}.tmp.${prepared.extension}`);
     try {
       const filters = prepared.filters ?? [
         'asetpts=PTS-STARTPTS',
         ...buildAtempoChain(prepared.speed).map(factor => `atempo=${formatNumber(factor)}`),
       ];
       const ffmpeg = options.ffmpeg ?? resolveFfmpeg();
-      const result = await ffmpegSlots.run(settings.concurrency.ffmpeg, () => runProcess(ffmpeg, [
+      const args = [
         '-hide_banner', '-nostdin', '-loglevel', 'error',
         ...(!prepared.clipFx ? ['-ss', formatNumber(prepared.startSec), '-to', formatNumber(prepared.endSec)] : []),
         '-i', sourcePath,
         '-map', '0:a:0', '-vn',
         '-af', filters.join(','),
-        '-ar', '48000', '-c:a', 'flac', '-compression_level', '5',
+        ...(prepared.format === 'pcm-s16le'
+          ? ['-ar', '24000', '-ac', '1', '-f', 's16le', '-c:a', 'pcm_s16le']
+          : ['-ar', '48000', '-c:a', 'flac', '-compression_level', '5']),
         '-y', temporary,
-      ], { timeoutMs: settings.timeoutMs.ffmpeg, maxBuffer: 16 * 1024 * 1024 }));
+      ];
+      const processOptions = { timeoutMs: settings.timeoutMs.ffmpeg, maxBuffer: 16 * 1024 * 1024 };
+      let result;
+      if (options.slot) {
+        await options.slot.acquire();
+        try {
+          result = await runProcess(ffmpeg, args, processOptions);
+        } finally {
+          ffmpegSlots.release();
+        }
+      } else {
+        result = await ffmpegSlots.run(settings.concurrency.ffmpeg, () => runProcess(ffmpeg, args, processOptions));
+      }
       if (result.error || result.status !== 0) {
         throw processFailure(result, 'ffmpeg failed to create the preview audio sidecar');
       }
       const outputStat = fs.statSync(temporary);
-      if (!outputStat.isFile() || outputStat.size <= 42) {
+      if (!outputStat.isFile() || outputStat.size <= (prepared.format === 'pcm-s16le' ? 0 : 42)) {
         throw new Error('ffmpeg created an empty preview audio sidecar');
       }
       const metadata = await inspectAudio(temporary);
-      if (metadata.sampleRate !== 48000) throw new Error('preview audio sidecar is not 48 kHz');
+      if (prepared.format === 'flac' && metadata.sampleRate !== 48000) throw new Error('preview audio sidecar is not 48 kHz');
       fs.renameSync(temporary, outputPath);
+      writeMetadata(prepared, options, metadata);
       return {
         ok: true, skipped: false, path: outputPath, key,
+        format: prepared.format,
+        ...(prepared.format === 'pcm-s16le' ? { frames: metadata.frames, bytesPerSample: 2 } : {}),
         durationSec: metadata.durationSec,
         sampleRate: metadata.sampleRate,
         channels: metadata.channels,
@@ -527,7 +619,7 @@ async function generate(prepared, options) {
       };
     } finally {
       for (const name of fs.readdirSync(outputDirectory)) {
-        if (name.startsWith(`.${path.basename(outputPath)}.${process.pid}.`) && name.endsWith('.tmp.flac')) {
+        if (name.startsWith(`.${path.basename(outputPath)}.${process.pid}.`) && name.endsWith(`.tmp.${prepared.extension}`)) {
           fs.rmSync(path.join(outputDirectory, name), { force: true });
         }
       }
@@ -541,6 +633,223 @@ async function generate(prepared, options) {
 // sidecar share one promise (and one ffmpeg). The entry is dropped as soon as it settles, so a
 // later request finds the finished file and takes the "already exists → reuse" path.
 const generating = new Map();
+const requested = new Map();
+const probing = new Map();
+const listeners = new Set();
+const FAILURE_RETRY_MS = 60000;
+
+function readCacheJson(filePath) {
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { return null; }
+}
+
+function writeCacheJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const temporary = `${filePath}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp.json`;
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(value), 'utf8');
+    fs.renameSync(temporary, filePath);
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+}
+
+function metadataPath(prepared) {
+  return path.join(prepared.outputDirectory, `${prepared.key}.json`);
+}
+
+function readMetadata(prepared) {
+  const value = readCacheJson(metadataPath(prepared));
+  const format = value?.format ?? 'flac';
+  return value?.recipe === prepared.recipe && value.key === prepared.key && format === prepared.format
+    && finitePositive(value.durationSec) && finitePositive(value.sampleRate)
+    && Number.isInteger(value.channels) && value.channels > 0 && finiteNonNegative(value.bytes)
+    && (format !== 'pcm-s16le' || (value.sampleRate === 24000 && value.channels === 1
+      && Number.isSafeInteger(value.frames) && value.frames > 0 && value.bytesPerSample === 2
+      && value.bytes === value.frames * 2 && value.durationSec === value.frames / 24000))
+    ? { ...value, format } : null;
+}
+
+function inspectPcm(filePath) {
+  const stat = fs.statSync(filePath);
+  if (!stat.isFile() || stat.size <= 0 || stat.size % 2 !== 0) {
+    throw new Error('preview PCM sidecar must contain complete nonempty s16le frames');
+  }
+  const frames = stat.size / 2;
+  return { sampleRate: 24000, channels: 1, frames, bytesPerSample: 2, durationSec: frames / 24000 };
+}
+
+function writeMetadata(prepared, options, metadata, legacyFlac = false) {
+  writeCacheJson(metadataPath(prepared), {
+    recipe: prepared.recipe, key: prepared.key,
+    ...(!legacyFlac ? { format: prepared.format } : {}),
+    ...(prepared.format === 'pcm-s16le' ? { frames: metadata.frames, bytesPerSample: 2 } : {}),
+    durationSec: metadata.durationSec, sampleRate: metadata.sampleRate, channels: metadata.channels,
+    bytes: fs.statSync(prepared.outputPath).size,
+    inSec: options.inSec, outSec: options.outSec, speed: options.speed,
+    padBeforeSec: options.padBeforeSec ?? 0, padAfterSec: options.padAfterSec ?? 0,
+    createdAt: Date.now(),
+  });
+}
+
+export function classifyPreviewAudioFailure(reason) {
+  // ffmpeg map errors (including builds which print an empty map), muxer errors,
+  // and our ffprobe empty-stream result all mean this fingerprint has no audio.
+  return /Stream map ['"][^'"]*['"] matches no streams|does not contain any stream|no audio stream/iu
+    .test(String(reason)) ? 'no-audio' : 'transient';
+}
+
+function retryRemaining(record) {
+  const createdAt = typeof record?.createdAt === 'number' ? record.createdAt : Date.parse(record?.createdAt);
+  return Math.max(0, createdAt + (record?.retryAfterMs ?? FAILURE_RETRY_MS) - Date.now()) || 0;
+}
+
+// Validate even duration-less requests synchronously, but obtain their real endpoint only
+// from a fingerprint-bound probe cache. No resolver or child process runs on this path.
+function requestOptions(options) {
+  if (options?.outSec !== undefined) {
+    if (finitePositive(options.decodedBytesThreshold)) {
+      prepare(options, {}, false);
+      const duration = options.outSec - options.inSec + (options.padBeforeSec ?? 0) + (options.padAfterSec ?? 0);
+      const heavy = duration * 48000 * 2 * 4 > options.decodedBytesThreshold;
+      if (!heavy && !hasAudioClipFx(options.clipFx)) return { status: { state: 'not-needed', key: null } };
+      return { options: { ...options, decodedBytesThreshold: undefined, format: heavy ? 'pcm-s16le' : 'flac' } };
+    }
+    return { options };
+  }
+  const validated = prepare({ ...options, outSec: (options?.inSec ?? 0) + 1 }, {}, false);
+  const stat = fs.statSync(validated.sourcePath);
+  const fingerprint = crypto.createHash('sha1')
+    .update([validated.sourcePath, stat.size, stat.mtimeMs].join('|')).digest('hex');
+  const probePath = path.join(validated.outputDirectory, `probe-${fingerprint}.json`);
+  const cached = readCacheJson(probePath);
+  if (cached?.error && (cached.error.class === 'no-audio' || retryRemaining(cached.error) > 0)) {
+    return { probePath, status: {
+      state: cached.error.class === 'no-audio' ? 'no-audio' : 'failed', key: null,
+      reason: cached.error.reason, probe: { fingerprint },
+      ...(cached.error.class === 'transient' ? { retryAfterMs: retryRemaining(cached.error) } : {}),
+    } };
+  }
+  if (finitePositive(cached?.durationSec)) {
+    const resolved = requestOptions({ ...options, outSec: cached.durationSec });
+    return { ...resolved, probePath, probe: { fingerprint },
+      ...(resolved.status ? { status: { ...resolved.status, probe: { fingerprint } } } : {}) };
+  }
+  return { probePath, status: { state: 'queued', key: null, probe: { fingerprint, pending: true } } };
+}
+
+export function previewAudioSidecarStatus(options) {
+  try {
+    const resolved = requestOptions(options);
+    if (resolved.status) return resolved.status;
+    if (resolved.probe) return { ...previewAudioSidecarStatus(resolved.options), probe: resolved.probe };
+    const prepared = prepare(resolved.options, {}, false);
+    const { key, outputPath, outputDirectory } = prepared;
+    if (requested.has(outputPath) || generating.has(outputPath)) return { state: 'generating', key };
+    const metadata = readMetadata(prepared);
+    if (metadata && fs.existsSync(outputPath)) {
+      const { durationSec, sampleRate, channels, bytes, format, frames, bytesPerSample } = metadata;
+      return { state: 'ready', key, path: outputPath, durationSec, sampleRate, channels, bytes, format,
+        ...(format === 'pcm-s16le' ? { frames, bytesPerSample } : {}) };
+    }
+    const noAudio = readCacheJson(path.join(outputDirectory, `${key}.no-audio.json`));
+    if (noAudio?.key === key) return { state: 'no-audio', key, reason: noAudio.reason };
+    const failed = readCacheJson(path.join(outputDirectory, `${key}.failed.json`));
+    if (failed?.key === key && retryRemaining(failed) > 0) {
+      return { state: 'failed', key, reason: failed.reason, retryAfterMs: retryRemaining(failed) };
+    }
+    return { state: fs.existsSync(outputPath) ? 'legacy' : 'missing', key };
+  } catch (error) {
+    return { state: 'invalid', reason: summarize(error?.message, 'invalid preview audio request') };
+  }
+}
+
+export function subscribePreviewAudioSidecarEvents(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+function emitSidecarEvent(event) {
+  for (const listener of [...listeners]) {
+    try { listener(event); } catch (error) { console.warn('[preview-audio] listener failed', error); }
+  }
+}
+
+export function requestPreviewAudioSidecar(options) {
+  // Internal slot ownership transfers only when a background job was queued.
+  // All synchronous terminal states (including in-flight joins) discard the ticket.
+  let queued = false;
+  try {
+    const result = requestSidecar(options);
+    queued = result.state === 'queued';
+    return result;
+  } finally {
+    if (!queued) options?.slot?.cancel();
+  }
+}
+
+function requestSidecar(options) {
+  const status = previewAudioSidecarStatus(options);
+  if (status.state === 'invalid') return status;
+  const resolved = requestOptions(options);
+  if (resolved.status) {
+    if (!status.probe?.pending || probing.has(resolved.probePath)) return status;
+    // Start after returning the declaration. The map is populated before any work runs.
+    const pending = new Promise(resolve => setImmediate(resolve)).then(async () => {
+      const slot = ffmpegSlots.reserve(settingsFrom(options).concurrency.ffmpeg);
+      let handedOff = false;
+      try {
+        const probe = await probePreviewAudioSourceAsync(options.sourcePath, options);
+        if (probe.ok) {
+          writeCacheJson(resolved.probePath, probe);
+          const result = requestPreviewAudioSidecar({ ...options, outSec: probe.durationSec, slot });
+          handedOff = true;
+          if (['ready', 'no-audio', 'failed', 'not-needed'].includes(result.state)) {
+            emitSidecarEvent({ key: result.key, state: result.state, sourcePath: path.resolve(options.sourcePath),
+              ...(result.state === 'ready'
+                ? { path: result.path, durationSec: result.durationSec } : { reason: result.reason }) });
+          }
+        } else {
+          const failureClass = classifyPreviewAudioFailure(probe.reason);
+          writeCacheJson(resolved.probePath, {
+            error: { class: failureClass, reason: probe.reason, createdAt: Date.now() },
+          });
+          // A failed probe settles the overall request; successful probes have no event.
+          emitSidecarEvent({ key: null, state: failureClass === 'no-audio' ? 'no-audio' : 'failed',
+            reason: probe.reason, sourcePath: path.resolve(options.sourcePath) });
+        }
+      } finally {
+        if (!handedOff) slot.cancel();
+      }
+    }).catch(error => console.warn('[preview-audio] probe cache failed', error))
+      .finally(() => probing.delete(resolved.probePath));
+    probing.set(resolved.probePath, pending);
+    return status;
+  }
+  if (status.state !== 'missing' && status.state !== 'legacy') return status;
+  const prepared = prepare(resolved.options, {}, false);
+  const pending = new Promise(resolve => setImmediate(resolve)).then(async () => {
+    fs.rmSync(path.join(prepared.outputDirectory, `${prepared.key}.failed.json`), { force: true });
+    const result = await ensurePreviewAudioSidecar(resolved.options);
+    let state = 'ready';
+    if (!result.ok) {
+      state = classifyPreviewAudioFailure(result.reason) === 'no-audio' ? 'no-audio' : 'failed';
+      writeCacheJson(path.join(prepared.outputDirectory, `${prepared.key}.${state}.json`), {
+        key: prepared.key, reason: result.reason, createdAt: Date.now(),
+        ...(state === 'failed' ? { retryAfterMs: FAILURE_RETRY_MS } : {}),
+      });
+    }
+    return { key: prepared.key, state, sourcePath: prepared.sourcePath,
+      ...(result.ok ? { path: result.path, durationSec: result.durationSec } : { reason: result.reason }) };
+  }).catch(error => ({ key: prepared.key, state: 'failed', sourcePath: prepared.sourcePath,
+    reason: summarize(error?.message, 'preview audio cache failed') }))
+    .finally(() => options.slot?.cancel())
+    .then(event => {
+      requested.delete(prepared.outputPath);
+      emitSidecarEvent(event);
+    });
+  requested.set(prepared.outputPath, pending);
+  return { state: 'queued', key: prepared.key, ...(status.probe ? { probe: status.probe } : {}) };
+}
 
 export function ensurePreviewAudioSidecar(options) {
   const state = { outputPath: null, key: null };
@@ -548,36 +857,53 @@ export function ensurePreviewAudioSidecar(options) {
   try {
     prepared = prepare(options, state);
   } catch (error) {
+    options?.slot?.cancel();
     return Promise.resolve(failure(state.outputPath, state.key, error));
   }
   const joined = generating.get(prepared.outputPath);
-  if (joined) return joined;
+  if (joined) {
+    options.slot?.cancel();
+    return joined;
+  }
   const pending = generate(prepared, options)
+    .finally(() => options.slot?.cancel())
     .catch(error => failure(prepared.outputPath, prepared.key, error));
   generating.set(prepared.outputPath, pending);
   void pending.finally(() => generating.delete(prepared.outputPath));
   return pending;
 }
 
-export function sweepPreviewAudioSidecars({ cacheDir, keepKeys }) {
-  const kept = new Set(Array.from(keepKeys ?? [], value => String(value).replace(/\.flac$/u, '')));
+export function sweepPreviewAudioSidecars({ cacheDir, keepKeys, minAgeMs = 0, keepProbes }) {
+  const kept = new Set(Array.from(keepKeys ?? [], value => String(value).replace(/\.(?:flac|pcm)$/u, '')));
+  const keptProbes = new Set(Array.from(keepProbes ?? [], value =>
+    String(value).replace(/^probe-/u, '').replace(/\.json$/u, '')));
   const outputDirectory = path.resolve(cacheDir, 'preview-audio');
   let removed = 0;
   let bytes = 0;
   try {
     for (const entry of fs.readdirSync(outputDirectory, { withFileTypes: true })) {
-      if (!entry.isFile() || !entry.name.endsWith('.flac')) continue;
+      if (!entry.isFile()) continue;
       // 生成途中の一時ファイル（`.<key>.flac.<pid>.<ms>.tmp.flac`）も `.flac` で終わる。
       // ffmpeg が開いている最中に rm すると Windows は EPERM を投げ、以前はそれが
       // /api/summary まで抜けてサーバごと落ちた（実機 2026-09-05 14:25）。掃除の対象外にする。
-      if (entry.name.startsWith('.') || entry.name.endsWith('.tmp.flac')) continue;
-      const key = entry.name.slice(0, -'.flac'.length);
-      if (kept.has(key)) continue;
+      if (entry.name.startsWith('.') || /\.tmp\./u.test(entry.name)) continue;
+      const match = /^(.*?)(?:\.flac|\.pcm|\.no-audio\.json|\.failed\.json|\.json)$/u.exec(entry.name);
+      if (!match) continue;
+      const key = match[1];
+      const probingFile = key.startsWith('probe-');
+      const outputPath = path.join(outputDirectory, `${key}.flac`);
+      const pcmPath = path.join(outputDirectory, `${key}.pcm`);
+      if ((!probingFile && kept.has(key)) || generating.has(outputPath)
+        || generating.has(pcmPath) || requested.has(pcmPath)
+        || (probingFile && keptProbes.has(key.slice('probe-'.length)))
+        || requested.has(outputPath) || probing.has(path.join(outputDirectory, entry.name))) continue;
       const target = path.join(outputDirectory, entry.name);
       // 1 本消せないだけで掃除全体（ましてサーバ）を止めない。ロック中・消えた直後は次回に回す。
       try {
-        bytes += fs.statSync(target).size;
+        const stat = fs.statSync(target);
+        if (minAgeMs > 0 && Date.now() - stat.mtimeMs < minAgeMs) continue;
         fs.rmSync(target, { force: true });
+        bytes += stat.size;
         removed += 1;
       } catch (error) {
         if (!['ENOENT', 'EPERM', 'EBUSY', 'EACCES'].includes(error?.code)) throw error;
@@ -593,9 +919,15 @@ export function sweepPreviewAudioSidecars({ cacheDir, keepKeys }) {
     for (const entry of fs.readdirSync(legacyDirectory, { withFileTypes: true })) {
       if (!entry.isFile() || !entry.name.endsWith('.wav')) continue;
       const target = path.join(legacyDirectory, entry.name);
-      bytes += fs.statSync(target).size;
-      fs.rmSync(target, { force: true });
-      removed += 1;
+      try {
+        const stat = fs.statSync(target);
+        if (minAgeMs > 0 && Date.now() - stat.mtimeMs < minAgeMs) continue;
+        fs.rmSync(target, { force: true });
+        bytes += stat.size;
+        removed += 1;
+      } catch (error) {
+        if (!['ENOENT', 'EPERM', 'EBUSY', 'EACCES'].includes(error?.code)) throw error;
+      }
     }
     if (fs.readdirSync(legacyDirectory).length === 0) fs.rmdirSync(legacyDirectory);
   } catch (error) {

package/vendor/packages/media-bin/test/audio-clip-fx.test.mjs

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
@@ -90,7 +90,9 @@ test('identical input reuses the cached sidecar without regenerating it', async
     assert.equal(first.skipped, true);
     assert.equal(second.skipped, true);
     assert.equal(first.path, second.path);
-    assert.equal(probes, 2);
+    // The first probe persists metadata as JSON, so cache reuse needs only one probe.
+    assert.equal(probes, 1);
+    assert.equal(existsSync(join(outputDirectory, `${key}.json`)), true);
   } finally {
     rmSync(root, { recursive: true, force: true });
   }