akari-video 0.1.45 → 0.1.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "0.1.45",
+  "version": "0.1.46",
   "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

@@ -64,6 +64,7 @@
     "docs/contract-2026-09-03-clip-adjust-v0.md",
     "docs/contract-2026-09-03-preview-playback-rate-v1.md",
     "docs/contract-2026-09-05-clip-adjust-v1.md",
+    "docs/contract-2026-09-06-vgpu-layer-v0.md",
     "packages/akari-launcher/package.json",
     "packages/akari-launcher/README.md",
     "packages/akari-tools/package.json",

package/vendor/docs/contract-2026-08-28-gpu-export-v0.md

@@ -21,6 +21,7 @@
 |---|---|---|
 | `same` | はい | 静的 HTML は起動時、対応済み字幕は unit の初回活性時に 1 回だけスプライト化する |
 | `three` | はい | JSON の宣言型 3D scene と描画先 canvas を持つ overlay。毎コマ Three.js canvas を更新し、登場表現は `three-scene-entrance-curve`、`three-scene-entrance-sampled`、または `three-scene-sampled-composite` で処理する |
+| `vgpu` | はい | pure な `data-akari-vgpu-scene` を WebGPU canvas に描き、毎コマスプライトへ転送する（[vgpu v0 契約](./contract-2026-09-06-vgpu-layer-v0.md)） |
 | `degraded` | いいえ | raster 自体は可能でも live DOM と同じ時間変化を保証できない |
 | `unsupported` | いいえ | v0 の表現範囲外であり、正しい完成画を生成できない |
 
@@ -320,6 +321,8 @@ CSS 3D は次の 3 群に分けて判定する。
   子孫の描画域が画面上で交差し、手前の要素が DOM 上で先に描かれる矛盾対を検出した場合は警告するが、
   fail-closed にはしない。
 
+vgpu の理由語彙は `vgpu-scene-canvas-direct`、`vgpu-stateful-unsupported`、`vgpu-invalid-declaration`、`vgpu-condition:<条件をカンマ連結>`（[vgpu v0 契約](./contract-2026-09-06-vgpu-layer-v0.md)）。
+
 次の条件は fail-closed のまま `degraded` とし、receipt に overlay id、理由、検出条件を全件残す。
 
 - `iframe`、`object`、`embed` の埋め込み context。

package/vendor/docs/contract-2026-08-28-v2-audio-roles-v0.md

@@ -128,6 +128,11 @@ ms へ換算し、絶対値で集計する。全 59 点の最大は 16.667 ms、
 書き出しはこの speech 鍵を消費する。プレビューサーバーへ speech 鍵を渡す配線は同契約の範囲外で、
 配線されるまでは narration 鍵だけへ劣化する。
 
+`tracks[].items[].source`（`kind: 'media'`）の `gain_db`（-60〜12・省略時 0）と
+`mute`（boolean・省略時 false）で、カットごとに埋め込み音声を減衰 / ミュートできる。
+`mute: true` は speech 宣言そのものを作らず、プレビューのサイドカー要求も PCM 化のコストも消える。
+書き出しは無音区間で尺を保つ。キー無しの既定値は従来と完全同一で、既存案件の出力は変わらない。
+
 ## 7. 速度変更した台詞のピッチ保持サイドカー
 
 `speed` が 1 以外の撮影素材の台詞は、Web Audio の `playbackRate` による近似から外す。

package/vendor/docs/contract-2026-09-06-vgpu-layer-v0.md

@@ -0,0 +1,166 @@
+---
+lifecycle: accepted
+date: 2026-09-06
+---
+
+# vgpu レイヤー v0 契約
+
+## 1. 適用範囲
+
+`data-akari-vgpu-scene` に宣言した WebGPU のフルスクリーン fragment パスを、
+`window.akari.vgpuRuntime` が外部から渡された時刻で描く。vgpu 0.4.0 は vendor 同梱し、
+実行時の依存取得は行わない。Three.js と同じ overlay sheet に置き、GPU 書き出しでは
+canvas を SpriteCompositor に登録する。毎コマ `render` の直後に `updateSprite` する。
+WebGPU canvas の提示面は一時的なので、描画せずに前回の canvas を転送してはならない。
+CPU への画素読み戻しはこの経路に追加しない。ブラウザ内部のゼロコピーを保証するものではない。
+
+## 2. 宣言スキーマ
+
+断片に次の script をちょうど 1 個置く。canvas は任意で、省略時はランタイムが作成する。
+
+```html
+<canvas></canvas>
+<script type="application/json" data-akari-vgpu-scene>
+{
+  "version": 0,
+  "mode": "pure",
+  "alphaMode": "premultiplied",
+  "seed": 0,
+  "uniforms": { "speed": 1 },
+  "passes": [{
+    "id": "main",
+    "wgsl": "struct Params { speed: f32 }; @group(0) @binding(1) var<uniform> params: Params; @fragment fn fs_main(@builtin(position) p: vec4f) -> @location(0) vec4f { let uv = akari_uv(p); return vec4f(uv, 0.5 + 0.5 * sin(akari.time * params.speed), 1.0); }",
+    "inputs": [],
+    "scale": 1
+  }]
+}
+</script>
+```
+
+| 項目 | 制約・既定値 |
+|---|---|
+| `version` | 必須、数値 `0` のみ |
+| `mode` | 必須、`pure` のみ。`stateful` は予約語で拒否 |
+| `alphaMode` | 省略時 `premultiplied`。それ以外は拒否。シェーダー出力の RGB も alpha 乗算済みにする |
+| `seed` | 任意の有限数。省略時 `0` |
+| `uniforms` | 任意の plain object。値は有限数、または長さ 2〜4 の有限数配列。省略時 `{}` |
+| `passes` | 必須、1 個以上の配列 |
+| `passes[].id` | 必須、`^[A-Za-z0-9_-]+$`、一意 |
+| `passes[].wgsl` | 必須、空白だけではない WGSL 文字列 |
+| `passes[].inputs` | 先行パス id の文字列配列、最大 8 個。省略時 `[]`。自己参照・前方参照不可 |
+| `passes[].scale` | 正の有限数、省略時 `1`。最終パスでは無視する |
+
+未知のトップレベルキー・pass キー、不正 JSON、不正な値は `readDescriptor` が TypeError にする。
+`uniforms` のキーは WGSL `Params` のメンバーに対応し、断片が
+`@group(0) @binding(1) var<uniform> params: Params;` を自分で宣言する。
+型は `f32` / `vec2f` / `vec3f` / `vec4f`。params 宣言のないパスには params を set しない。
+未宣言名・未束縛・WGSL コンパイルエラーは vgpu の検証を通じて失敗する。
+
+`pure` は「出力が指定時刻・seed・uniforms の純関数」の authoring 契約である。
+任意時刻へ直接シークでき、前回描画結果への feedback はない。任意の WGSL の数学的な純粋性を
+静的に証明するものではない。時刻を進める時計や乱数源を断片へ提供しない。
+
+## 3. 固定 prelude とパス
+
+各パスのソース先頭に次を付加する。
+
+```wgsl
+struct AkariUniforms { time: f32, aspect: f32, width: f32, height: f32, seed: f32, pad: vec3f };
+@group(0) @binding(0) var<uniform> akari: AkariUniforms;
+fn akari_uv(pos: vec4f) -> vec2f { return pos.xy / vec2f(akari.pad.x, akari.pad.y); }
+```
+
+入力があるパスには、入力数だけ texture 宣言と、共通 sampler 宣言を続ける。断片側で重複宣言しない。
+
+```wgsl
+@group(1) @binding(0) var input_0: texture_2d<f32>;
+// input_1 ... input_7 は必要な個数だけ binding 1 ... 7 に宣言
+@group(1) @binding(8) var input_sampler: sampler;
+```
+
+パスは配列順に、1 回の `frame(gpu, f => ...)` で直列描画する。
+最後のパスだけが surface、それ以前は `scale` 倍のオフスクリーン target へ描く。
+`input_i` には参照先 target の `color` を渡す。resize 後は新しい texture を再束縛する。
+`effect.draw(surface)` は使用しない（0.4.0 の surface は `frame` の `pass` で描く）。
+
+`akari.width/height` は常に等倍出力の container 実寸で、`aspect = width / height`。
+**`pad` は予約した形を維持しつつ実値を運ぶ**: x/y は当該パスの描画バッファ実幅・実高、z は previewScale。
+最終パスの x/y は canvas 実寸、中間パスはさらに pass.scale を掛けた target 実寸。
+固定 struct を変えず、`@builtin(position)` のピクセル座標を解像度に依存せず正規化するための裁定補足である。
+断片は `akari_uv(position)`、または vgpu の頂点段が供給する左上原点の `@location(0) uv` を使う。
+`position.xy / vec2f(akari.width, akari.height)` は縮小時に構図が変わるので使わない。
+
+## 4. API・解像度・ツマミ
+
+- `probe()` はページで 1 回だけ `init()` し、同じ Promise を返す。64×64 一時 surface に 2 コマ描画し、
+  GPU queue 完了と検証完了を待つ。device lost を初期化直後から監視し、一時 surface を破棄する。
+  成功値は `{ ok: true, adapter: { vendor, architecture }, ms }`。情報取得不可の文字列は空文字。
+- `render(container, localTimeSeconds, { previewScale })` は同期描画。時刻の源は引数のみ。
+  未初期化時は probe を開始して loading のまま戻る。書き出しホストは必ず先に probe を await する。
+  描画の同期エラーは `VGPU-RENDER:` を投げ、以後その container は no-op とする。
+  書き出しホストは inspect の error も確認し、空の層を成功扱いしない。
+- `inspect(container)` は `{ status, adapter, passes, previewScale, drawCount, deviceLost }`。
+  status は `idle`（宣言なし）、`loading`、`ready`、`error`。passes は構築したパス数。
+- `dispose(container)` は surface・target と自動作成 canvas を破棄する。共有 device は維持する。
+- `readDescriptor(container)` は宣言なしなら null、宣言不正なら TypeError。
+
+previewScale は辺あたり倍率で、未指定 `1`。推奨値は `1` / `0.5` / `0.25` だが、
+実装は有限数 `0 < s <= 1` を受け付ける。範囲外は警告 1 回で `1` にする。
+preview-server の既定は `PREVIEW_VGPU_SCALE = 0.5`。書き出しは options を渡さず常に `1`。
+canvas の CSS は absolute / inset 0 / width・height 100% / display block に固定する。
+内部画素だけが減り、位置・大きさ・時刻・ツマミは変わらない。描画寸法は丸め、最小 1 px。
+container が 0 サイズなら前回寸法を使い、前回もなければ描画しない。
+GPU 合成側は container の解決済み配置変換をスプライトへ渡し、プレビューの位置と拡縮を維持する。
+
+`--vgpu-<key>` が container の CSS にある場合は uniforms より優先する。
+数値または空白・カンマ区切りのベクトルを読み、宣言と同じ要素数で全部有限数の場合だけ採用する。
+不一致はキーごとに警告 1 回で宣言値を使う。既存の `vars` からそのまま設定できる。
+
+## 5. 適格性と receipt
+
+`item-keyframes` の後、three-only 判定の前に vgpu 判定を置く。
+検出条件は `vgpu-runtime`、canvas があればその次に `three-or-canvas-runtime`。
+
+| 分類 | 理由 |
+|---|---|
+| `vgpu` | `vgpu-scene-canvas-direct`: pure 宣言が妥当で、他条件が canvas 由来だけ |
+| `degraded` | `vgpu-stateful-unsupported`: stateful |
+| `degraded` | `vgpu-invalid-declaration`: JSON・version・mode・スキーマ不正 |
+| `degraded` | `vgpu-condition:<条件をカンマ連結>`: 他の動的条件や外部参照を含む |
+
+3D 宣言が同居する場合は、優先して
+`vgpu-condition:three-or-canvas-runtime(data-akari-3d-scene)` とする。
+その後、他条件、宣言検証の順に判定する。JSON はちょうど 1 宣言だけを受け付ける。
+`forceDegraded` は pure の vgpu 分類を変更しない。degraded になった vgpu は既存の規則どおり
+`forced-dom:<元理由>` で DOM 強制の対象となり、eligible は false のまま残る。
+
+`summary.vgpu` は件数が 1 以上のときだけ追加する。`spriteManifest.vgpu` は常に配列で、
+各要素は `{ id, start, duration, index, z }`。overlay sheet は three と vgpu のいずれかがある場合だけ作る。
+receipt の `gpu.vgpu` は run に vgpu があるときだけ、次の形で追加する。
+
+```json
+{ "overlays": 2, "adapter": { "vendor": "apple", "architecture": "metal-3" },
+  "previewScale": null, "deviceLost": false, "probeMs": 12.5 }
+```
+
+overlays は有限非負整数、adapter は文字列、previewScale は数値または null、
+deviceLost は boolean、probeMs は有限非負数または null に正規化する。
+summary と receipt を条件付きにしたのは、vgpu を使わない既存 fixture・receipt を byte/deep-equal で保つため。
+vgpu 不在の overlay sheet には新しい script や seek 文を一切挿入しない。
+
+## 6. fail-loud と v0 の限界
+
+- WebGPU 未提供・adapter null・初期化/試験描画失敗は `VGPU-UNAVAILABLE:` で probe を reject。
+- device lost 後の render は `VGPU-DEVICE-LOST:` で throw。復帰や別 device への切り替えは行わない。
+- `auto` でも `VGPU-` を含む失敗は OSR へフォールバックせずそのまま伝播する。
+- プレビューは失敗を捕捉し `[data-akari-vgpu-fallback]`（任意、断片の既定 display:none）を表示して、
+  console.warn を 1 回出す。他のプレビューは続行する。
+
+CLI の `--engine legacy` は既に廃止され、引数処理で拒否される。
+その CLI のエラーを変更せず、`renderProject(..., { engine: 'legacy' })` の API 直呼びには
+vgpu 宣言を検出した時点で `vgpu overlays require --engine gpu` を返す。これが元裁定の
+「engine 解決後の legacy 拒否」と異なる理由は、CLI からその分岐に到達できないためである。
+
+stateful・feedback・固定ステップ replay は未対応。OSR は同じ sheet を通すが v0 のパリティ gate 対象外。
+Windows / Linux / 他 GPU は未検証。同一機での 2 走・全コマ SHA 一致は実 GPU の検収で確認する事項であり、
+異機種間の浮動小数点の一致を保証しない。SwiftShader を WebGPU の代替として採用しない。

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

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "0.1.45",
+  "version": "0.1.46",
   "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/edit-store/lib/audio-schedule.d.ts

@@ -77,6 +77,7 @@ export interface WebAudioSpeechCut extends EditCut {
         duration_sec?: unknown;
     } | null;
     gain_db?: unknown;
+    mute?: unknown;
     gainDb?: unknown;
     volume_db?: unknown;
     transition_out?: EditCut['transitionOut'] | null;

package/vendor/packages/edit-store/lib/audio-schedule.js

@@ -299,6 +299,8 @@ function projectSpeechDeclarations(cuts, options) {
         const cut = normalizedCuts[segment.cutIndex];
         if (!cut || typeof cut.src !== 'string' || !cut.src)
             continue;
+        if (cut.mute === true)
+            continue;
         const speed = finitePositive(cut.speed) ? cut.speed : 1;
         const segmentIn = typeof segment.in === 'number' ? segment.in : cut.in;
         const cutTimelineStart = segment.outStart - (segmentIn - cut.in) / speed;

package/vendor/packages/edit-store/lib/edit-v2.d.ts

@@ -91,6 +91,10 @@ export interface MediaSourceV2 {
     freeze?: Record<string, unknown> | null;
     fx?: unknown[];
     speed?: number;
+    /** 埋め込み音声（speech）の音量 dB。-60〜12・省略時 0。 */
+    gain_db?: number;
+    /** 埋め込み音声（speech）のミュート。省略時 false。 */
+    mute?: boolean;
     chroma_key?: Record<string, unknown> | null;
 }
 export interface AudioMediaSourceV2 {

package/vendor/packages/edit-store/lib/edit-v2.js

@@ -302,7 +302,7 @@ function validateItemSource(value, path, sourceIds) {
     switch (value.kind) {
         case 'media':
             requireExactKeys(value, new Set([
-                'kind', 'src', 'in', 'out', 'framing', 'transition_out', 'freeze', 'fx', 'speed', 'chroma_key'
+                'kind', 'src', 'in', 'out', 'framing', 'transition_out', 'freeze', 'fx', 'speed', 'chroma_key', 'gain_db', 'mute'
             ]), path);
             requireText(value.src, `${path}.src`);
             if (!sourceIds.has(value.src))
@@ -319,6 +319,10 @@ function validateItemSource(value, path, sourceIds) {
                 throw invalid(`${path}.fx`, '配列である必要があります');
             if (hasOwn(value, 'speed'))
                 requirePositiveNumber(value.speed, `${path}.speed`);
+            if (hasOwn(value, 'gain_db'))
+                requireRange(value.gain_db, -60, 12, `${path}.gain_db`);
+            if (hasOwn(value, 'mute') && typeof value.mute !== 'boolean')
+                throw invalid(`${path}.mute`, 'boolean である必要があります');
             return;
         case 'html':
             requireExactKeys(value, new Set(['kind', 'path', 'part', 'style', 'text', 'exclude', 'derivedFrom', 'vars', 'params']), path);

package/vendor/packages/edit-store/lib/generated/edit-v2-keys.d.ts

@@ -1,5 +1,5 @@
 export declare const ITEM_V2_KEYS: readonly ["id", "name", "hidden", "locked", "at", "duration", "anchor", "transform", "opacity", "blend", "crop", "adjust", "perspective", "motion", "animator", "keyframes", "items", "mask", "source", "role", "gain_db", "denoise", "lowcut_hz", "fade_in", "fade_out", "ducking", "duck_db", "duck_attack", "duck_release", "script", "reading", "provenance"];
-export declare const ITEM_SOURCE_V2_KEYS: readonly ["kind", "src", "in", "out", "framing", "transition_out", "freeze", "fx", "speed", "chroma_key", "pitch_semitones", "formant", "path", "part", "style", "text", "exclude", "derivedFrom", "vars", "params", "shape", "preset", "baked", "from", "filter", "id"];
+export declare const ITEM_SOURCE_V2_KEYS: readonly ["kind", "src", "in", "out", "framing", "transition_out", "freeze", "fx", "speed", "gain_db", "mute", "chroma_key", "pitch_semitones", "formant", "path", "part", "style", "text", "exclude", "derivedFrom", "vars", "params", "shape", "preset", "baked", "from", "filter", "id"];
 export declare const KEYFRAME_V2_KEYS: readonly ["t", "transform", "crop", "perspective", "opacity", "gain_db", "animator", "easing"];
 export declare const MOTION_V0_KEYS: readonly ["in", "out", "loop"];
 export declare const ANIMATOR_V0_KEYS: readonly ["id", "basis", "shape", "start", "end", "offset", "randomize", "amount", "ease"];
@@ -17,7 +17,7 @@ export declare const ITEM_V2_KEYS_BY_DEFINITION: {
     readonly itemV2AudioMedia: readonly ["id", "name", "hidden", "locked", "at", "duration", "role", "source", "gain_db", "denoise", "lowcut_hz", "keyframes", "fade_in", "fade_out", "ducking", "duck_db", "duck_attack", "duck_release", "script", "reading", "provenance"];
 };
 export declare const ITEM_SOURCE_V2_KEYS_BY_DEFINITION: {
-    readonly itemSourceMediaV2: readonly ["kind", "src", "in", "out", "framing", "transition_out", "freeze", "fx", "speed", "chroma_key"];
+    readonly itemSourceMediaV2: readonly ["kind", "src", "in", "out", "framing", "transition_out", "freeze", "fx", "speed", "gain_db", "mute", "chroma_key"];
     readonly itemSourceAudioMediaV2: readonly ["kind", "src", "in", "out", "speed", "pitch_semitones", "formant"];
     readonly itemSourceHtmlV2: readonly ["kind", "path", "part", "style", "text", "exclude", "derivedFrom", "vars", "params"];
     readonly itemSourceShapeV2: readonly ["kind", "shape", "params"];

package/vendor/packages/edit-store/lib/generated/edit-v2-keys.js

@@ -4,7 +4,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ITEM_SOURCE_V2_KEYS_BY_DEFINITION = exports.ITEM_V2_KEYS_BY_DEFINITION = exports.SOURCE_KIND_V2 = exports.MOTION_FILE_V0_KEYS = exports.ANIMATOR_V0_KEYS = exports.MOTION_V0_KEYS = exports.KEYFRAME_V2_KEYS = exports.ITEM_SOURCE_V2_KEYS = exports.ITEM_V2_KEYS = void 0;
 exports.ITEM_V2_KEYS = ["id", "name", "hidden", "locked", "at", "duration", "anchor", "transform", "opacity", "blend", "crop", "adjust", "perspective", "motion", "animator", "keyframes", "items", "mask", "source", "role", "gain_db", "denoise", "lowcut_hz", "fade_in", "fade_out", "ducking", "duck_db", "duck_attack", "duck_release", "script", "reading", "provenance"];
-exports.ITEM_SOURCE_V2_KEYS = ["kind", "src", "in", "out", "framing", "transition_out", "freeze", "fx", "speed", "chroma_key", "pitch_semitones", "formant", "path", "part", "style", "text", "exclude", "derivedFrom", "vars", "params", "shape", "preset", "baked", "from", "filter", "id"];
+exports.ITEM_SOURCE_V2_KEYS = ["kind", "src", "in", "out", "framing", "transition_out", "freeze", "fx", "speed", "gain_db", "mute", "chroma_key", "pitch_semitones", "formant", "path", "part", "style", "text", "exclude", "derivedFrom", "vars", "params", "shape", "preset", "baked", "from", "filter", "id"];
 exports.KEYFRAME_V2_KEYS = ["t", "transform", "crop", "perspective", "opacity", "gain_db", "animator", "easing"];
 exports.MOTION_V0_KEYS = ["in", "out", "loop"];
 exports.ANIMATOR_V0_KEYS = ["id", "basis", "shape", "start", "end", "offset", "randomize", "amount", "ease"];
@@ -204,6 +204,8 @@ exports.ITEM_SOURCE_V2_KEYS_BY_DEFINITION = {
         "freeze",
         "fx",
         "speed",
+        "gain_db",
+        "mute",
         "chroma_key"
     ],
     "itemSourceAudioMediaV2": [

package/vendor/packages/edit-store/lib/internal-model.js

@@ -962,6 +962,8 @@ function copyMediaSourceFields(source) {
         ...(source.freeze !== undefined ? { freeze: source.freeze } : {}),
         ...(source.fx !== undefined ? { fx: source.fx } : {}),
         ...(source.speed !== undefined ? { speed: source.speed } : {}),
+        ...(source.gain_db !== undefined ? { gain_db: source.gain_db } : {}),
+        ...(source.mute !== undefined ? { mute: source.mute } : {}),
         ...(source.chroma_key !== undefined ? { chroma_key: source.chroma_key } : {})
     };
 }

package/vendor/packages/edit-store/lib/webview-kernel.js

@@ -1437,6 +1437,7 @@ var AkariEditKernel = (() => {
       if (segment.kind !== "src" || segment.cutIndex === null) continue;
       const cut = normalizedCuts[segment.cutIndex];
       if (!cut || typeof cut.src !== "string" || !cut.src) continue;
+      if (cut.mute === true) continue;
       const speed = finitePositive(cut.speed) ? cut.speed : 1;
       const segmentIn = typeof segment.in === "number" ? segment.in : cut.in;
       const cutTimelineStart = segment.outStart - (segmentIn - cut.in) / speed;
@@ -2018,7 +2019,9 @@ var AkariEditKernel = (() => {
           "freeze",
           "fx",
           "speed",
-          "chroma_key"
+          "chroma_key",
+          "gain_db",
+          "mute"
         ]), path);
         requireText(value.src, `${path}.src`);
         if (!sourceIds.has(value.src)) throw invalid(`${path}.src`, `sources[].id \u306B\u5B58\u5728\u3057\u307E\u305B\u3093: ${value.src}`);
@@ -2030,6 +2033,8 @@ var AkariEditKernel = (() => {
         }
         if (hasOwn(value, "fx") && !Array.isArray(value.fx)) throw invalid(`${path}.fx`, "\u914D\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059");
         if (hasOwn(value, "speed")) requirePositiveNumber(value.speed, `${path}.speed`);
+        if (hasOwn(value, "gain_db")) requireRange(value.gain_db, -60, 12, `${path}.gain_db`);
+        if (hasOwn(value, "mute") && typeof value.mute !== "boolean") throw invalid(`${path}.mute`, "boolean \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059");
         return;
       case "html":
         requireExactKeys(value, /* @__PURE__ */ new Set(["kind", "path", "part", "style", "text", "exclude", "derivedFrom", "vars", "params"]), path);
@@ -3254,6 +3259,8 @@ var AkariEditKernel = (() => {
       ...source.freeze !== void 0 ? { freeze: source.freeze } : {},
       ...source.fx !== void 0 ? { fx: source.fx } : {},
       ...source.speed !== void 0 ? { speed: source.speed } : {},
+      ...source.gain_db !== void 0 ? { gain_db: source.gain_db } : {},
+      ...source.mute !== void 0 ? { mute: source.mute } : {},
       ...source.chroma_key !== void 0 ? { chroma_key: source.chroma_key } : {}
     };
   }

package/vendor/packages/gpu-export/README.ja.md

@@ -236,3 +236,5 @@ frame-engine bundle は生成物です。`generated/frame-engine.js` を直接
 生フレーム hash は隔離した検証専用 module からだけ利用でき、実行時 readback trap とは同時に
 有効化できません。DOM frame 検証は隔離した texture sentinel を使い、選択した settle policy
 （`raf2-paint-event` または `sync-layout`）を receipt に記録します。
+
+宣言型 `data-akari-vgpu-scene` は同梱 vgpu 0.4.0 の WebGPU ランタイムで描き、描画直後の canvas を GPU 合成へ渡す。v0 は pure な fragment パス、先行パスの texture 入力、CSS `--vgpu-*` ツマミに対応する。ライブプレビューは辺あたり半解像度、GPU 書き出しは等倍で、配置と時刻を共有する。WebGPU の probe・device 障害は `auto` でも失敗として伝播し OSR へ落とさない。receipt の `gpu.vgpu` は使用時だけ追加する。詳しくは [vgpu v0 契約](../../docs/contract-2026-09-06-vgpu-layer-v0.md)。

package/vendor/packages/gpu-export/README.md

@@ -258,3 +258,5 @@ The frame-engine bundle is generated. Do not edit `generated/frame-engine.js` di
 Frame hashing is available only through the isolated verification module and cannot be combined
 with the runtime readback trap. DOM frame verification uses an isolated texture sentinel and
 records the selected settle policy (`raf2-paint-event` or `sync-layout`) in the receipt.
+
+Declarative `data-akari-vgpu-scene` overlays use the vendored vgpu 0.4.0 WebGPU runtime and transfer each freshly drawn canvas into the GPU compositor. v0 supports pure fragment passes, earlier-pass texture inputs, and CSS `--vgpu-*` uniforms. Live preview defaults to half resolution per edge; GPU export uses full resolution with the same placement and time. WebGPU probe/device failures are fatal, including in `auto` (no OSR fallback); `gpu.vgpu` is present in receipts only when used. See the [vgpu v0 contract](../../docs/contract-2026-09-06-vgpu-layer-v0.md) (Japanese).

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

@@ -85,7 +85,8 @@ export function buildAtempoChain(speed) {
 
 // Counting semaphore whose limit is supplied per acquisition: the active count is shared by
 // the whole process while each caller may state the ceiling it accepts. Waiters are woken in
-// FIFO order and the count is bumped synchronously on wake-up, so the ceiling never overshoots.
+// FIFO order unless explicitly promoted or passed while probing. The count is bumped
+// synchronously on wake-up, so the ceiling never overshoots.
 class Semaphore {
   #active = 0;
   #waiters = [];
@@ -121,16 +122,37 @@ class Semaphore {
         waiter.reject?.(new Error('semaphore reservation cancelled'));
         this.#drain();
       },
+      promote: () => {
+        if (waiter.state !== 'waiting') return false;
+        const index = this.#waiters.indexOf(waiter);
+        if (index <= 0) return false;
+        this.#waiters.splice(index, 1);
+        this.#waiters.unshift(waiter);
+        this.#drain();
+        return true;
+      },
+      hold: () => {
+        if (waiter.state !== 'waiting' || waiter.resolve) return;
+        waiter.hold = true;
+        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();
+      let index = 0;
+      let held = 0;
+      // Only probing tickets opt in to holding one idle slot. Plain reservations
+      // remain FIFO barriers; several probing tickets together hold just one slot.
+      while (index < this.#waiters.length && !this.#waiters[index].resolve) {
+        if (!this.#waiters[index].hold) return;
+        held = 1;
+        index += 1;
+      }
+      const waiter = this.#waiters[index];
+      if (!waiter || this.#active + held >= waiter.limit) return;
+      this.#waiters.splice(index, 1);
       this.#active += 1;
       waiter.state = 'acquired';
       waiter.resolve();
@@ -635,6 +657,52 @@ async function generate(prepared, options) {
 const generating = new Map();
 const requested = new Map();
 const probing = new Map();
+// Tickets are registered synchronously, then reserved in request order when work
+// starts (or promotion is requested). This also permits immediate promotion after
+// requestPreviewAudioSidecar returns, without starting a probe in that call.
+const tickets = new Set();
+
+function registerTicket(options, prepared) {
+  const ticket = { sourcePath: prepared.sourcePath, outputDirectory: prepared.outputDirectory,
+    key: prepared.key, limit: settingsFrom(options).concurrency.ffmpeg, slot: options.slot };
+  tickets.add(ticket);
+  return ticket;
+}
+
+function reserveTickets() {
+  for (const ticket of tickets) ticket.slot ??= ffmpegSlots.reserve(ticket.limit);
+}
+
+function discardTicket(ticket, cancel = true) {
+  try { if (cancel) ticket.slot?.cancel(); } finally { tickets.delete(ticket); }
+}
+
+// keys are bare sidecar keys (an optional .flac/.pcm suffix is accepted).
+// sourcePaths identify probing requests and remain usable after probe handoff.
+// Each actual move is reported in input order; the last move has highest priority.
+export function promotePreviewAudioSidecars({ cacheDir, keys = [], sourcePaths = [] }) {
+  const outputDirectory = path.resolve(cacheDir, 'preview-audio');
+  const promoted = [];
+  const promote = (value, matches) => {
+    const matching = [...tickets].filter(ticket => ticket.outputDirectory === outputDirectory && matches(ticket));
+    if (!matching.length) return;
+    reserveTickets();
+    let moved = false;
+    for (const ticket of matching) if (ticket.slot.promote?.()) moved = true;
+    if (moved) promoted.push(value);
+  };
+  for (const key of keys) {
+    const bareKey = String(key).replace(/\.(?:flac|pcm)$/u, '');
+    promote(key, ticket => ticket.key === bareKey);
+  }
+  for (const sourcePath of sourcePaths) {
+    if (typeof sourcePath !== 'string' || !path.isAbsolute(sourcePath)) continue;
+    const resolved = path.resolve(sourcePath);
+    promote(sourcePath, ticket => ticket.sourcePath === resolved);
+  }
+  return { promoted };
+}
+
 const listeners = new Set();
 const FAILURE_RETRY_MS = 60000;
 
@@ -793,11 +861,15 @@ function requestSidecar(options) {
   const resolved = requestOptions(options);
   if (resolved.status) {
     if (!status.probe?.pending || probing.has(resolved.probePath)) return status;
+    const ticket = registerTicket(options, { sourcePath: path.resolve(options.sourcePath),
+      outputDirectory: path.dirname(resolved.probePath), key: null });
     // 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);
+      reserveTickets();
+      const { slot } = ticket;
       let handedOff = false;
       try {
+        slot.hold?.();
         const probe = await probePreviewAudioSourceAsync(options.sourcePath, options);
         if (probe.ok) {
           writeCacheJson(resolved.probePath, probe);
@@ -818,18 +890,20 @@ function requestSidecar(options) {
             reason: probe.reason, sourcePath: path.resolve(options.sourcePath) });
         }
       } finally {
-        if (!handedOff) slot.cancel();
+        discardTicket(ticket, !handedOff);
       }
     }).catch(error => console.warn('[preview-audio] probe cache failed', error))
-      .finally(() => probing.delete(resolved.probePath));
+      .finally(() => { tickets.delete(ticket); 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 ticket = registerTicket(resolved.options, prepared);
   const pending = new Promise(resolve => setImmediate(resolve)).then(async () => {
+    reserveTickets();
     fs.rmSync(path.join(prepared.outputDirectory, `${prepared.key}.failed.json`), { force: true });
-    const result = await ensurePreviewAudioSidecar(resolved.options);
+    const result = await ensurePreviewAudioSidecar({ ...resolved.options, slot: ticket.slot });
     let state = 'ready';
     if (!result.ok) {
       state = classifyPreviewAudioFailure(result.reason) === 'no-audio' ? 'no-audio' : 'failed';
@@ -842,9 +916,8 @@ function requestSidecar(options) {
       ...(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())
+    .finally(() => { discardTicket(ticket); requested.delete(prepared.outputPath); })
     .then(event => {
-      requested.delete(prepared.outputPath);
       emitSidecarEvent(event);
     });
   requested.set(prepared.outputPath, pending);
@@ -865,8 +938,10 @@ export function ensurePreviewAudioSidecar(options) {
     options.slot?.cancel();
     return joined;
   }
-  const pending = generate(prepared, options)
-    .finally(() => options.slot?.cancel())
+  const ticket = options.slot ? null : registerTicket(options, prepared);
+  if (ticket) reserveTickets();
+  const pending = generate(prepared, ticket ? { ...options, slot: ticket.slot } : options)
+    .finally(() => { if (ticket) discardTicket(ticket); else options.slot?.cancel(); })
     .catch(error => failure(prepared.outputPath, prepared.key, error));
   generating.set(prepared.outputPath, pending);
   void pending.finally(() => generating.delete(prepared.outputPath));

package/vendor/packages/media-bin/test/preview-audio-slot-order.test.mjs

@@ -4,6 +4,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import childProcess from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { PassThrough } from 'node:stream';
 import { syncBuiltinESMExports } from 'node:module';
 import { setImmediate as nextTurn, setTimeout as delay } from 'node:timers/promises';
 import test from 'node:test';
@@ -11,6 +13,7 @@ import { resolveFfmpeg, resolveFfprobe } from '../src/index.mjs';
 import {
   __testing, ensurePreviewAudioSidecar, previewAudioSidecarStatus,
   requestPreviewAudioSidecar, subscribePreviewAudioSidecarEvents,
+  promotePreviewAudioSidecars,
 } from '../src/preview-audio-sidecar.mjs';
 
 const { Semaphore } = __testing;
@@ -298,6 +301,58 @@ function realBinaries() {
 
 const binaries = realBinaries();
 
+function mockSpawn(t, run) {
+  const observed = t.mock.method(childProcess, 'spawn', (command, args) => {
+    const child = new EventEmitter();
+    child.stdout = new PassThrough();
+    child.stderr = new PassThrough();
+    child.exitCode = null;
+    child.signalCode = null;
+    child.kill = () => { child.signalCode = 'SIGKILL'; child.emit('close', null, 'SIGKILL'); };
+    setImmediate(async () => {
+      try {
+        await run(child, command, args);
+        child.exitCode = 0;
+        child.emit('close', 0, null);
+      } catch (error) {
+        child.stderr.write(error.message);
+        child.exitCode = 1;
+        child.emit('close', 1, null);
+      }
+    });
+    return child;
+  });
+  syncBuiltinESMExports();
+  t.after(() => { observed.mock.restore(); syncBuiltinESMExports(); });
+  return observed;
+}
+
+test('短 SFX の probe キャッシュは request と status の再取得で ffprobe を起動しない',
+  { timeout: 10000 }, async t => {
+    const f = fixture(t);
+    const observedSpawn = mockSpawn(t, async child => {
+      child.stdout.write(JSON.stringify({ streams: [{ sample_rate: '48000', channels: 2 }],
+        format: { duration: '0.1' } }));
+    });
+    const event = deferred();
+    t.after(subscribePreviewAudioSidecarEvents(value => event.resolve(value)));
+    const options = { ...f.options, decodedBytesThreshold: 64 * 1024 * 1024 };
+    const first = requestPreviewAudioSidecar(options);
+    assert.equal(first.probe.pending, true);
+    assert.equal((await event.promise).state, 'not-needed');
+    await nextTurn();
+    assert.equal(observedSpawn.mock.callCount(), 1);
+    assert.equal(observedSpawn.mock.calls[0].arguments[0], options.ffprobe);
+    const cached = JSON.parse(fs.readFileSync(path.join(f.directory, `probe-${first.probe.fingerprint}.json`), 'utf8'));
+    assert.ok(cached.durationSec > 0 && cached.durationSec < 1);
+    for (const read of [requestPreviewAudioSidecar, previewAudioSidecarStatus]) {
+      assert.deepEqual(read(options), { state: 'not-needed', key: null,
+        probe: { fingerprint: first.probe.fingerprint } });
+    }
+    await nextTurn();
+    assert.equal(observedSpawn.mock.callCount(), 1, '2 回目はキャッシュを読み spawn を増やさない');
+  });
+
 test('実 ffmpeg: 120 秒 WAV の A（probe）→ B → C は A が最初に ready になる',
   { skip: binaries.skip, timeout: 60000 }, async t => {
     const f = fixture(t);
@@ -328,7 +383,7 @@ test('実 ffmpeg: 120 秒 WAV の A（probe）→ B → C は A が最初に rea
     }
   });
 
-test('実 ffmpeg: 遅い probe の A と既知尺 B・C は既定 2 枠で要求順に起動する',
+test('実 ffmpeg: 遅い probe の A は既定 2 枠の 1 枠を予約し B → A → C で起動する',
   { skip: binaries.skip, timeout: 60000 }, async t => {
     const f = fixture(t);
     const sources = ['a-narration.wav', 'b-speech1.wav', 'c-speech2.wav'].map(name => path.join(f.root, name));
@@ -351,7 +406,13 @@ test('実 ffmpeg: 遅い probe の A と既知尺 B・C は既定 2 枠で要求
     });
     syncBuiltinESMExports();
     t.after(() => { observedSpawn.mock.restore(); syncBuiltinESMExports(); });
-    const reservations = observeReservations(t);
+    const reservations = [];
+    const originalReserve = Semaphore.prototype.reserve;
+    t.mock.method(Semaphore.prototype, 'reserve', function (...args) {
+      const slot = originalReserve.apply(this, args);
+      reservations.push(slot);
+      return slot;
+    });
     const events = [];
     t.after(subscribePreviewAudioSidecarEvents(event => events.push(event)));
     const probe = deferred();
@@ -360,15 +421,255 @@ test('実 ffmpeg: 遅い probe の A と既知尺 B・C は既定 2 枠で要求
       probeAudio: () => probe.promise });
     for (const sourcePath of sources.slice(1)) requestPreviewAudioSidecar({ ...common, sourcePath, outSec: 120 });
     let deadline = Date.now() + 10000;
-    while (reservations.length < 3 && Date.now() < deadline) await delay(10);
+    while (starts.length < 1 && Date.now() < deadline) await delay(1);
     const startsDuringProbe = [...starts];
     const reservationsDuringProbe = reservations.length;
     probe.resolve(metadata);
     deadline = Date.now() + 30000;
     while (events.length < 3 && Date.now() < deadline) await delay(10);
     assert.equal(reservationsDuringProbe, 3);
-    assert.deepEqual(startsDuringProbe, [], 'probe は枠を占有せず順番だけを保持する');
-    assert.deepEqual(starts, sources);
+    assert.deepEqual(startsDuringProbe, [sources[1]], 'probe は 1 枠だけ予約し B を通す');
+    assert.deepEqual(starts, [sources[1], sources[0], sources[2]]);
     assert.equal(peak, 2);
     assert.deepEqual(events.map(event => event.state), ['ready', 'ready', 'ready']);
   });
+
+test('promote は待機札を先頭へ移し先頭・取得済み・破棄済みなら何もしない', async () => {
+  const semaphore = new Semaphore();
+  await semaphore.acquire(1);
+  const slots = [semaphore.reserve(1), semaphore.reserve(1), semaphore.reserve(1)];
+  const order = [];
+  const jobs = slots.map((slot, index) => slot.acquire().then(() => order.push(index)));
+  assert.equal(slots[0].promote(), false);
+  assert.equal(slots[2].promote(), true);
+  assert.equal(slots[2].promote(), false);
+  semaphore.release();
+  await jobs[2];
+  assert.equal(slots[2].promote(), false);
+  semaphore.release();
+  await jobs[0];
+  semaphore.release();
+  await jobs[1];
+  semaphore.release();
+  assert.deepEqual(order, [2, 0, 1]);
+  const cancelled = semaphore.reserve(1);
+  cancelled.cancel();
+  assert.equal(cancelled.promote(), false);
+});
+
+test('hold は 2 枠で B だけを通し probe 完了後は A が C より先に取得する', async () => {
+  const semaphore = new Semaphore();
+  const a = semaphore.reserve(2);
+  a.hold();
+  a.hold();
+  const order = [];
+  const b = semaphore.acquire(2).then(() => order.push('B'));
+  const c = semaphore.acquire(2).then(() => order.push('C'));
+  await b;
+  await nextTurn();
+  assert.deepEqual(order, ['B']);
+  await a.acquire().then(() => order.push('A'));
+  await nextTurn();
+  assert.deepEqual(order, ['B', 'A']);
+  a.hold();
+  semaphore.release();
+  await c;
+  assert.deepEqual(order, ['B', 'A', 'C']);
+  semaphore.release();
+  semaphore.release();
+});
+
+test('hold は 1 枠なら probe 中の B と C を待たせる', async () => {
+  const semaphore = new Semaphore();
+  const a = semaphore.reserve(1);
+  a.hold();
+  const order = [];
+  const b = semaphore.acquire(1).then(() => order.push('B'));
+  const c = semaphore.acquire(1).then(() => order.push('C'));
+  await nextTurn();
+  assert.deepEqual(order, []);
+  await a.acquire().then(() => order.push('A'));
+  assert.deepEqual(order, ['A']);
+  semaphore.release();
+  await b;
+  semaphore.release();
+  await c;
+  semaphore.release();
+  assert.deepEqual(order, ['A', 'B', 'C']);
+});
+
+test('複数の hold は合計 1 枠だけを予約し通常札の FIFO 障壁は維持する', async () => {
+  const semaphore = new Semaphore();
+  const a = semaphore.reserve(2);
+  const b = semaphore.reserve(2);
+  const barrier = semaphore.reserve(2);
+  a.hold();
+  b.hold();
+  const order = [];
+  const c = semaphore.acquire(2).then(() => order.push('C'));
+  const d = semaphore.acquire(2).then(() => order.push('D'));
+  await nextTurn();
+  assert.deepEqual(order, []);
+  barrier.cancel();
+  await c;
+  await nextTurn();
+  assert.deepEqual(order, ['C']);
+  a.cancel();
+  await nextTurn();
+  assert.deepEqual(order, ['C'], '残った probe も 1 枠を予約する');
+  b.cancel();
+  await d;
+  semaphore.release();
+  semaphore.release();
+});
+
+for (const by of ['keys', 'sourcePaths']) {
+  test(`昇格 API は ${by} で 3 番目を先頭にして完了順を 3 → 1 → 2 にする`,
+    { timeout: 5000 }, async t => {
+      const f = fixture(t);
+      const sources = ['first.wav', 'second.wav', 'third.wav'].map(name => path.join(f.root, name));
+      for (const sourcePath of sources) fs.writeFileSync(sourcePath, 'fixture');
+      const starts = [];
+      mockSpawn(t, async (child, command, args) => {
+        starts.push(args[args.indexOf('-i') + 1]);
+        fs.writeFileSync(args.at(-1), Buffer.alloc(480));
+      });
+      const events = [];
+      const done = deferred();
+      t.after(subscribePreviewAudioSidecarEvents(event => {
+        events.push(event);
+        if (events.length === 3) done.resolve();
+      }));
+      const probe = deferred();
+      const probing = deferred();
+      let probeCount = 0;
+      t.after(() => probe.resolve(metadata));
+      const common = { ...f.options, ffmpeg: 'mock-ffmpeg', probeAudio: () => {
+        if (++probeCount === 3) probing.resolve();
+        return probe.promise;
+      } };
+      const statuses = sources.map(sourcePath => requestPreviewAudioSidecar({ ...common, sourcePath,
+        ...(by === 'keys' ? { outSec: 120 } : { decodedBytesThreshold: 1 }) }));
+      const target = by === 'keys' ? statuses[2].key : sources[2];
+      if (by === 'sourcePaths') await probing.promise;
+      assert.deepEqual(promotePreviewAudioSidecars({ cacheDir: path.join(f.root, 'other'), [by]: [target] }),
+        { promoted: [] });
+      assert.deepEqual(promotePreviewAudioSidecars({ cacheDir: f.root, [by]: [target, target] }),
+        { promoted: [target] });
+      probe.resolve(metadata);
+      await done.promise;
+      assert.deepEqual(events.map(event => event.state), ['ready', 'ready', 'ready']);
+      assert.deepEqual(events.map(event => event.sourcePath), [sources[2], sources[0], sources[1]]);
+      assert.deepEqual(starts, [sources[2], sources[0], sources[1]]);
+      assert.deepEqual(promotePreviewAudioSidecars({ cacheDir: f.root,
+        keys: [events[0].key, 'missing'], sourcePaths: sources }), { promoted: [] });
+      assert.deepEqual(promotePreviewAudioSidecars({ cacheDir: f.root }), { promoted: [] });
+    });
+}
+
+test('昇格 API は keys → sourcePaths の入力順に移動し取得済み札を無視する',
+  { timeout: 5000 }, async t => {
+    const f = fixture(t);
+    const sources = ['first.wav', 'second.wav', 'third.wav'].map(name => path.join(f.root, name));
+    for (const sourcePath of sources) fs.writeFileSync(sourcePath, 'fixture');
+    const entered = deferred();
+    const gate = deferred();
+    t.after(() => gate.resolve());
+    const starts = [];
+    mockSpawn(t, async (child, command, args) => {
+      starts.push(args[args.indexOf('-i') + 1]);
+      entered.resolve();
+      await gate.promise;
+      fs.writeFileSync(args.at(-1), Buffer.alloc(480));
+    });
+    const events = [];
+    const done = deferred();
+    t.after(subscribePreviewAudioSidecarEvents(event => {
+      events.push(event);
+      if (events.length === 3) done.resolve();
+    }));
+    const statuses = sources.map(sourcePath => requestPreviewAudioSidecar({ ...f.known, sourcePath,
+      ffmpeg: 'mock-ffmpeg' }));
+    const keys = [statuses[1].key, statuses[2].key];
+    assert.deepEqual(promotePreviewAudioSidecars({ cacheDir: f.root, keys, sourcePaths: [sources[0]] }),
+      { promoted: [...keys, sources[0]] });
+    await entered.promise;
+    assert.deepEqual(promotePreviewAudioSidecars({ cacheDir: f.root,
+      keys: [statuses[0].key], sourcePaths: [sources[0]] }), { promoted: [] });
+    gate.resolve();
+    await done.promise;
+    assert.deepEqual(starts, [sources[0], sources[2], sources[1]]);
+    assert.deepEqual(events.map(event => event.state), ['ready', 'ready', 'ready']);
+  });
+
+test('背景 probe の hold は B だけを通し A → C へ枠を渡す',
+  { timeout: 5000 }, async t => {
+    const f = fixture(t);
+    const sources = ['first.wav', 'second.wav', 'third.wav'].map(name => path.join(f.root, name));
+    for (const sourcePath of sources) fs.writeFileSync(sourcePath, 'fixture');
+    const gates = sources.map(() => deferred());
+    const entered = sources.map(() => deferred());
+    const probe = deferred();
+    t.after(() => { probe.resolve(metadata); for (const gate of gates) gate.resolve(); });
+    const starts = [];
+    let active = 0;
+    let peak = 0;
+    mockSpawn(t, async (child, command, args) => {
+      const sourcePath = args[args.indexOf('-i') + 1];
+      const index = sources.indexOf(sourcePath);
+      starts.push(sourcePath);
+      peak = Math.max(peak, ++active);
+      entered[index].resolve();
+      await gates[index].promise;
+      fs.writeFileSync(args.at(-1), Buffer.alloc(480));
+      active -= 1;
+    });
+    const events = [];
+    const done = deferred();
+    t.after(subscribePreviewAudioSidecarEvents(event => {
+      events.push(event);
+      if (events.length === 3) done.resolve();
+    }));
+    const common = { ...f.options, concurrency: undefined, ffmpeg: 'mock-ffmpeg' };
+    requestPreviewAudioSidecar({ ...common, sourcePath: sources[0],
+      decodedBytesThreshold: 1, probeAudio: () => probe.promise });
+    for (const sourcePath of sources.slice(1)) requestPreviewAudioSidecar({ ...common, sourcePath, outSec: 120 });
+    await entered[1].promise;
+    await nextTurn();
+    assert.deepEqual(starts, [sources[1]]);
+    probe.resolve(metadata);
+    await entered[0].promise;
+    await nextTurn();
+    assert.deepEqual(starts, [sources[1], sources[0]]);
+    gates[0].resolve();
+    await entered[2].promise;
+    assert.deepEqual(starts, [sources[1], sources[0], sources[2]]);
+    gates[1].resolve();
+    gates[2].resolve();
+    await done.promise;
+    assert.equal(peak, 2);
+    assert.deepEqual(events.map(event => event.state), ['ready', 'ready', 'ready']);
+  });
+
+test('昇格 API は ensure の待機札も動かし失敗・完了後は台帳から外す',
+  { timeout: 5000 }, async t => {
+    const f = fixture(t);
+    const sources = ['first.wav', 'second.wav', 'third.wav'].map(name => path.join(f.root, name));
+    for (const sourcePath of sources) fs.writeFileSync(sourcePath, 'fixture');
+    mockSpawn(t, async (child, command, args) => {
+      if (args[args.indexOf('-i') + 1] === sources[2]) throw new Error('test generation failure');
+      fs.writeFileSync(args.at(-1), Buffer.alloc(480));
+    });
+    const options = sources.map(sourcePath => ({ ...f.known, sourcePath, ffmpeg: 'mock-ffmpeg' }));
+    const keys = options.map(value => previewAudioSidecarStatus(value).key);
+    const order = [];
+    const jobs = options.map((value, index) => ensurePreviewAudioSidecar(value).then(result => {
+      order.push(index);
+      return result;
+    }));
+    assert.deepEqual(promotePreviewAudioSidecars({ cacheDir: f.root, keys: [keys[2]] }), { promoted: [keys[2]] });
+    const results = await Promise.all(jobs);
+    assert.deepEqual(order, [2, 0, 1]);
+    assert.deepEqual(results.map(result => result.ok), [true, true, false]);
+    assert.deepEqual(promotePreviewAudioSidecars({ cacheDir: f.root, keys, sourcePaths: sources }), { promoted: [] });
+  });

package/vendor/packages/overlay-runtime/README.md

@@ -65,6 +65,15 @@ Three.js + glTF シーンを決定的な時刻で描画し（`three-runtime.js`
    （`summary` = `EditSummary`。下記参照）。以降はタイムライン更新のたびに
    `window.akari.runtime.tick(t, playing)` を呼ぶ
 
+vgpu overlay を扱うホストは、three 群がある場合はその後に
+`src/vendor/vgpu-bundle.js` → `src/vgpu-runtime.js` の順で読み込む。
+書き出しは `await window.akari.vgpuRuntime.probe()` 後、container ごとに
+`render(container, localTimeSeconds)` → canvas の登録/更新を同じ同期処理内で行う。
+プレビューは `render(container, localTimeSeconds, { previewScale: 0.5 })`、非表示化と unmount で
+`dispose(container)` を呼ぶ。probe と render の失敗を捕捉して任意の `[data-akari-vgpu-fallback]` を表示し、
+警告は 1 回にまとめる。共有 device は container の破棄時には落とさない。
+宣言と純関数・解像度の約束は [vgpu v0 契約](../../docs/contract-2026-09-06-vgpu-layer-v0.md) を参照。
+
 ## ホストアダプタ契約（新シェル実装者向け — 本パッケージへの入力）
 
 本パッケージの各スクリプトは `window.akari` 名前空間の以下のプロパティを
@@ -240,6 +249,8 @@ Web UI（preview-server）は `slot-params.js` を `/slot-params.js` で配り
 src/
   vendor/three-bundle.js  Three.js core + GLTFLoader + RoomEnvironment の単一 IIFE
   vendor/three-LICENSE.txt  Three.js の MIT License
+  vendor/vgpu-bundle.js  vgpu 0.4.0 browser entry の単一 IIFE
+  vendor/vgpu-LICENSE.txt  vgpu の MIT License
   vendor/vendor-3d-text-bundle.js  troika-three-text + opentype.js + matter-js + poly-decomp の単一 IIFE
   vendor/troika-three-text-LICENSE.txt  troika-three-text の MIT License
   vendor/opentype.js-LICENSE.txt        opentype.js の MIT License
@@ -502,3 +513,52 @@ npm グローバルインストール禁止の制約内で完結するよう、
   231 行で区切ると `#minimap-viewport` 規則の宣言途中で切れ、閉じ括弧を欠く
   不正な CSS になるため、意図（「minimap 用ブロックを抽出」）に沿って実際の
   ブロック終端まで抽出した。詳細は `out/status.json` 隣接の `report.md` を参照
+
+## vgpu vendor の固定と再生成
+
+`src/vendor/vgpu-bundle.js` は `vgpu@0.4.0` の browser entry を `esbuild@0.24.2` で
+単一 IIFE にしたもの。実行時に npm/CDN/外部 origin を参照しない。
+取得した tarball の integrity は以下に固定する。
+
+- `vgpu@0.4.0`: `sha512-U8ofyb2FdiLpbkMJrGSu2PWu/fmiKsXYYpp3agFE3TjM5+6o7aZFD1PBl8XxxnSeN7br/Izmow7fcEmYJTpxSw==`
+- `@vgpu/core@0.4.0`: `sha512-yBkqlNzTRYaRRzOAsootOmppzsDZytL5Xe09rZfV60zJc4FTr5jWZmGCrm/zlWM/1wEKocDtKloVKfKD+2TNPw==`
+- `@vgpu/wgsl@0.4.0`: `sha512-19aESov4jNukukAlbE9VH34T/2VcIzmQPZ45WyphtrUMevFacAqTVU6qJVAP/YGX3rjQaL7Eq4jdvEhtOxNEPg==`
+- `@vgpu/wgsl-std@0.4.0`: `sha512-a0EkK1y5VeA1jCEjPxe7BW7zTebL1UKLIQlEdxqrb8T1Zr+xO7VBe5mTNsuJtKWxgF+lANUqLwScyN+Fs4ooFw==`
+- `@vgpu/adapter-mock@0.4.0`: `sha512-fqOEHCZAt+mMyOpgAA5inFWSoB9siO1LQIq9t+i6iemLbp2VBEEWlhZXCh3Hf+UDqbkut8kQaDrMPLt2J9LpvA==`
+- `esbuild@0.24.2`: `sha512-+9egpBW8I3CD5XPe0n6BfT5fxLzxrlDzqydF3aviG+9ni1lDC/OvMHcxqEFV0+LANZG5R1bFMWfUrjVsdwxJvA==`
+- `@esbuild/darwin-arm64@0.24.2`: `sha512-kj3AnYWc+CekmZnS5IPu9D+HWtUI49hbnyqk0FLEJDbzCIQt7hg7ucF1SQAilhtYpIujfaHr6O0UHlzzSPdOeA==`
+
+entry `akari-vgpu-entry.js`:
+
+```js
+import { init, effect, surface, target, frame, sampler, uniforms, clock, VGPUError } from "vgpu";
+window.AkariVgpu = Object.freeze({ init, effect, surface, target, frame, sampler, uniforms, clock, VGPUError });
+```
+
+再生成（空の一時ディレクトリ、macOS arm64。リポの package.json / lock は変更しない）:
+
+```sh
+npm pack vgpu@0.4.0 @vgpu/core@0.4.0 @vgpu/wgsl@0.4.0 @vgpu/wgsl-std@0.4.0 @vgpu/adapter-mock@0.4.0 --ignore-scripts
+npm pack esbuild@0.24.2 @esbuild/darwin-arm64@0.24.2 --ignore-scripts
+mkdir -p node_modules/vgpu node_modules/@vgpu/core node_modules/@vgpu/wgsl node_modules/@vgpu/wgsl-std node_modules/@vgpu/adapter-mock node_modules/esbuild node_modules/@esbuild/darwin-arm64
+tar -xzf vgpu-0.4.0.tgz -C node_modules/vgpu --strip-components=1
+tar -xzf vgpu-core-0.4.0.tgz -C node_modules/@vgpu/core --strip-components=1
+tar -xzf vgpu-wgsl-0.4.0.tgz -C node_modules/@vgpu/wgsl --strip-components=1
+tar -xzf vgpu-wgsl-std-0.4.0.tgz -C node_modules/@vgpu/wgsl-std --strip-components=1
+tar -xzf vgpu-adapter-mock-0.4.0.tgz -C node_modules/@vgpu/adapter-mock --strip-components=1
+tar -xzf esbuild-0.24.2.tgz -C node_modules/esbuild --strip-components=1
+tar -xzf esbuild-darwin-arm64-0.24.2.tgz -C node_modules/@esbuild/darwin-arm64 --strip-components=1
+node node_modules/esbuild/bin/esbuild akari-vgpu-entry.js \
+  --bundle --format=iife --platform=browser --target=es2020 --minify \
+  --legal-comments=inline --metafile=meta.json --outfile=vgpu-bundle.js
+cp node_modules/vgpu/LICENSE vgpu-LICENSE.txt
+grep -cE '@modelcontextprotocol/server|zod|pngjs|pixelmatch|@vgpu/adapter-node|@vgpu/adapter-mock' vgpu-bundle.js || true
+wc -c vgpu-bundle.js
+shasum -a 256 vgpu-bundle.js
+```
+
+実測: **152953 bytes** / SHA-256 `9251bb41157e72e36211af2d0766de72db7251023fb2b968c15bdc529c111c25`。
+metafile の npm 入力は `vgpu` / `@vgpu/core` / `@vgpu/wgsl` の 3 パッケージのみ。
+上記 grep は **0 件**。`vgpu/node` / `vgpu/three` / `vgpu/mock` の entry は使用しない。
+唯一の URL 文字列 `https://github.com/vercel-labs/vgpu/issues/294` はエラーメッセージの参照先で、実行時 fetch ではない。
+MIT License（Copyright (c) 2025 Vercel, Inc.）全文は `src/vendor/vgpu-LICENSE.txt` に保持する。

package/vendor/packages/schemas/edit.schema.json

@@ -1151,9 +1151,11 @@
         "freeze": { "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/cutFreeze" }] },
         "fx": { "type": "array", "items": { "$ref": "#/$defs/cutFx" } },
         "speed": { "$ref": "#/$defs/positiveNumber" },
+        "gain_db": { "type": "number", "minimum": -60, "maximum": 12 },
+        "mute": { "type": "boolean" },
         "chroma_key": { "oneOf": [{ "type": "null" }, { "$ref": "#/$defs/chromaKey" }] }
       },
-      "$comment": "notes-2026-08-18-timeline-latency-and-track-model.md §9 / §10-1。src は editV2.sources[].id を参照し、in/out は素材内の秒。参照整合と out > in は兄弟値比較のため reader / edit-lint が検証する。"
+      "$comment": "notes-2026-08-18-timeline-latency-and-track-model.md §9 / §10-1。src は editV2.sources[].id を参照し、in/out は素材内の秒。参照整合と out > in は兄弟値比較のため reader / edit-lint が検証する。gain_db / mute は埋め込み音声（speech）の減衰 / ミュートで、書き出しとプレビューで同値。省略時は gain 0・鳴る。"
     },
     "itemSourceAudioMediaV2": {
       "type": "object",

package/vendor/packages/schemas/engine-capabilities.json

@@ -77,6 +77,8 @@
     { "path": "tracks[].items[].source.fx", "applies_to": ["cuts", "layers"], "gpu": "ignored", "osr": "ignored", "runtime_warning": true, "evidence": "packages/edit-store/src/internal-model.ts copyMediaSourceFields; packages/frame-engine/src/timeline/plan.ts KNOWN_CUT_KEYS/KNOWN_LAYER_KEYS omit fx", "hint": "GPU / OSR frame-engine には登録済み cut FX が無い" },
     { "path": "tracks[].items[].source.speed", "applies_to": ["cuts"], "gpu": "consumed", "osr": "consumed", "evidence": "packages/edit-store/src/internal-model.ts buildV2VisualItem speed projection; packages/frame-engine/src/timeline/plan.ts buildResolvedTimelinePlan/layerFromPlacement" },
     { "path": "tracks[].items[].source.speed", "applies_to": ["layers"], "gpu": "ignored", "osr": "ignored", "runtime_warning": true, "evidence": "packages/edit-store/src/internal-model.ts copyMediaSourceFields; packages/frame-engine/src/timeline/plan.ts KNOWN_LAYER_KEYS omits speed" },
+    { "path": "tracks[].items[].source.gain_db", "applies_to": ["cuts"], "gpu": "other-subsystem", "osr": "other-subsystem", "evidence": "packages/render-cut/src/plan.mjs cutSpeechVolumeSuffix (appendSequentialAudioCutFilters / gap-aware); packages/edit-store/src/audio-schedule.ts projectSpeechDeclarations speechGainDb", "note": "埋め込み音声（speech）の減衰。映像エンジンではなく render-cut の cut 音声（全エンジン共通）とプレビューの音声供給が消費する" },
+    { "path": "tracks[].items[].source.mute", "applies_to": ["cuts"], "gpu": "other-subsystem", "osr": "other-subsystem", "evidence": "packages/render-cut/src/plan.mjs cut.mute -> anullsrc branch; packages/edit-store/src/audio-schedule.ts projectSpeechDeclarations skips muted cuts", "note": "埋め込み音声（speech）のミュート。尺は保ち無音区間になる" },
     { "path": "tracks[].items[].source.chroma_key", "applies_to": ["cuts", "layers"], "gpu": "partial", "osr": "partial", "runtime_warning": true, "evidence": "packages/edit-store/src/internal-model.ts needsLayersEngine/copyMediaSourceFields; packages/frame-engine/src/timeline/plan.ts KNOWN_CUT_KEYS/KNOWN_LAYER_KEYS omit chroma_key", "note": "透過 intent は layers 振り分けに使うが、frame-engine 自体は chroma key 抽出や background 置換をしない" },
     { "path": "tracks[].items[].source.path", "applies_to": ["overlays"], "gpu": "consumed", "osr": "consumed", "evidence": "packages/edit-store/src/internal-model.ts buildV2VisualItem html source; packages/gpu-export/src/page-builder.mjs loadAndBuildGpuPage; packages/osr-export/src/page-builder.mjs loadAndBuildOsrPage" },
     { "path": "tracks[].items[].source.path", "applies_to": ["captions"], "gpu": "consumed", "osr": "consumed", "evidence": "packages/edit-store/src/internal-model.ts buildV2VisualItem fixes captions.json; packages/gpu-export/src/page-builder.mjs loadAndBuildGpuPage; packages/osr-export/src/page-builder.mjs loadAndBuildOsrPage", "note": "schema が captions.json の定数に閉じている" },

package/vendor/packages/schemas/test/edit-v2-schema.test.mjs

@@ -15,6 +15,18 @@ function fixture(name) {
   return JSON.parse(readFileSync(join(examplesRoot, name, "edit.json"), "utf8"));
 }
 
+test("visual media source validates embedded speech gain and mute", () => {
+  const value = fixture("edit-v2-valid");
+  Object.assign(value.tracks[3].items[0].source, { gain_db: -12, mute: true });
+  assert.equal(validate(value), true, JSON.stringify(validate.errors));
+  for (const [key, invalid] of [['gain_db', -61], ['gain_db', 13], ['gain_db', '0'], ['mute', 'true']]) {
+    const rejected = structuredClone(value);
+    rejected.tracks[3].items[0].source[key] = invalid;
+    assert.equal(validate(rejected), false);
+    assert.ok(validate.errors.some(error => error.instancePath === `/tracks/3/items/0/source/${key}`));
+  }
+});
+
 test("editV2 is the third root branch and keeps v2 timing/output definitions separate", () => {
   assert.equal(schema.$id, "urn:akari-video:schema:edit:v1");
   assert.match(schema.title, /v0\/v1\/v2/);

package/vendor/packages/schemas/test/engine-capabilities.test.mjs

@@ -27,8 +27,8 @@ test("engine capability table declares the version, engines, and status vocabula
   assert.deepEqual(table.statuses, ["consumed", "partial", "ignored", "other-subsystem"]);
 });
 
-test("all 66 generated item, source, and keyframe keys have a capability row", () => {
-  assert.equal(canonicalPaths.size, 66);
+test("all 68 generated item, source, and keyframe keys have a capability row", () => {
+  assert.equal(canonicalPaths.size, 68);
   const covered = new Set(table.fields.map((field) => field.path));
   assert.deepEqual([...canonicalPaths].filter((path) => !covered.has(path)), []);
 });