akari-video 0.1.19 → 0.1.21

package/package.json

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

@@ -62,6 +62,7 @@
     "packages/export-nle/package.json",
     "packages/intake-form/package.json",
     "packages/intake-form/README.md",
+    "packages/matte-rvm/package.json",
     "packages/media-bin/package.json",
     "packages/overlay-runtime/package.json",
     "packages/overlay-runtime/README.md",

package/vendor/docs/contract-2026-07-23-analysis-person-matte.md

@@ -57,7 +57,7 @@
     "person_matte": {                        // null（未生成）/ string（旧形）も有効
       "path": "matte/person-matte.webm",     // 必須。VP9 alpha WebM への相対 or 絶対パス
       "fps": 24,                             // 必須。マット動画の fps（元素材と異なってよい）
-      "quality": "balanced",                 // 任意。fast / balanced / accurate を例示（enum 強制はしない）
+      "quality": "balanced",                 // 任意。fast / balanced / accurate / best を例示（enum 強制はしない）
       "generated_at": "2026-07-23T01:33:30.069Z",  // 任意。ISO8601
       "tool": "vision-person-segmentation"   // 任意。生成手段の記録
     }
@@ -72,7 +72,7 @@
 | `tracks.person_matte` | object \| string \| null | **必須（キー）** | — | `null` = 未生成。string = 旧形（`{path}` の糖衣・非推奨） |
 | `person_matte.path` | string | **必須** | — | マット動画へのパス。相対パスは **analysis.json の所在ディレクトリ**基準、区切りは `/`。実体は VP9 alpha WebM（§3） |
 | `person_matte.fps` | number | **必須** | — | マット動画の fps。0 より大きい。**元素材の fps と一致しなくてよい**（§4 の時刻対応は fps に依存しない） |
-| `person_matte.quality` | string | 否 | — | 生成品質。`fast` / `balanced` / `accurate` を例示。**enum 強制はしない** |
+| `person_matte.quality` | string | 否 | — | 生成品質。`fast` / `balanced` / `accurate` / `best` を例示。**enum 強制はしない** |
 | `person_matte.generated_at` | string | 否 | — | 生成時刻（ISO8601） |
 | `person_matte.tool` | string | 否 | — | 生成手段の記録。`vision-person-segmentation` を例示 |
 
@@ -171,6 +171,45 @@ HEVC alpha MOV は「Apple 系ツールへの受け渡しが要るとき」の
 quality を上げると Vision の側が伸びる（`accurate` は 135ms/frame・peak 638MB）。
 `fast` は輪郭が階段状になり本番品質に達しないため、当たり付け専用とする。
 
+| quality | engine | 用途・実測 |
+|---|---|---|
+| `fast` | Vision | 当たり付け専用。256x192 のマット |
+| `balanced`（既定） | Vision | 通常の本番用途。512x384 のマット |
+| `accurate` | Vision | 寄りカットの仕上げ。2016x1512 のマット |
+| `best` | RVM mobilenetv3 | 髪の毛レベルの細部が必要なときだけ明示指定。CPU 実測 **約 178〜289 ms/frame** |
+| `best --model resnet50` | RVM resnet50 | 処理時間をさらに許容できる場合のこだわり指定 |
+
+Mac では `fast` / `balanced` / `accurate` に Vision、`best` に RVM を使う。Windows の対応は
+§6.2 で定める。
+
+### 6.1 RVM の ExecutionProvider 規律
+
+RVM は **CPU のみ**で実行する。較正ではアクセラレーション用 EP が CPU と異なるマットを出し、
+二値マスク IoU が 0.8057 まで崩れた。将来別の EP を追加するときは、採用候補と CPU の出力一致を
+同一 raw BGRA 入力で測り、**IoU ≈ 1.0 を実測してから**有効化することを受け入れ条件とする。
+
+### 6.2 Windows
+
+Windows（`win32`）では Vision を利用できないため、**全品質段を RVM へ接続する**。`quality` は
+ユーザーが指定した値をそのまま結果と `tracks.person_matte.quality` に残すが、実行エンジンと既定モデルは
+次の表に固定する。
+
+| quality | engine | 既定モデル |
+|---|---|---|
+| `fast` | RVM | mobilenetv3 |
+| `balanced`（既定） | RVM | mobilenetv3 |
+| `accurate` | RVM | mobilenetv3 |
+| `best` | RVM | mobilenetv3 |
+| `best --model resnet50` | RVM | resnet50 |
+
+Windows では RVM が唯一のエンジンなので、mobilenetv3 モデルの配備を必須とする。`--check` はモデルが
+無ければ `available:false` と取得用の `fetchHint` を返す。Mac では従来どおり、RVM モデルが無くても
+Vision の品質段を使えるため `available:true` のままとする。
+
+ffmpeg / ffprobe は OS の PATH 名を直接起動せず、`packages/media-bin` の `resolveFfmpeg()` /
+`resolveFfprobe()` で解決する。これにより Windows では同梱されたプラットフォーム別バイナリも探索対象に
+なり、デコード、VP9 alpha エンコード、出力検証の全工程で同じ解決規則を使う。
+
 手順は `skills/analyze-footage/person-matte.md`（`bin/person-matte/` のヘルパー）に置く。
 
 ## 7. 検証
@@ -215,3 +254,64 @@ JSON として読めるかまでしか見ていない（`analysis.schema` チェ
   マットが取れることと、それを本番の合成として出せることは別である
   （`skills/overlay-authoring/text-behind-person.md` の「現在の制約を先に判定する」と同じ判断）
 - overlay 断片からの**相対 video URL の解決**（preview / 書き出し双方）が未整備
+
+## 10. 配線コマンド person-cutout
+
+`skills/analyze-footage/bin/person-matte/person-cutout.mjs` は、編集済みカットの人物マット生成と
+v2 `edit.json` への配線を 1 回で行う決定論的 CLI である。§4 の素材全体マットとは異なり、これは
+プロジェクト固有のカット区間マットを `analysis.json` を経由せず編集トラックへ直接置く。
+
+### 10.1 引数と出力規律
+
+```text
+--project <dir>                         必須。edit.json を持つプロジェクト
+--cut <index[,index...]>                必須。0 始まり
+--quality fast|balanced|accurate|best   省略時 balanced
+--model mobilenetv3|resnet50            best のときだけ指定可
+--dry-run                               生成・書き換えを行わず予定だけ返す
+```
+
+v2 だけを受理し、v0/v1 は「v2 へ migrate してから」という復旧案内付きで失敗する。stdout は成功・
+失敗とも 1 行 JSON とし、成功時は `ok`、マットのパスと実測値、追加または更新したレイヤー、track
+変更の有無、検証結果を含む。失敗時は `ok:false` と `reason` を返し、exit code を非 0 にする。
+
+`--dry-run` は edit.json とファイルシステムを変更しない。選択対象は v2 `tracks[]` を下から上、
+各 `items[]` を宣言順に走査した visual `source.kind:"media"` item である。自動生成した
+`person-N` item と `assets/matte/person-N.webm` source は index の母集団から除外するため、再実行後も
+同じ index が同じ元カットを指す。
+
+### 10.2 置き場、時間、速度
+
+マットは `<project>/assets/matte/person-<cut index>.webm` に固定する。元カットの source path、
+`source.in` / `source.out`、出力 `at` / `duration` を解決し、プロジェクトの整数 fps を使う。
+
+`source.speed` がある場合は、ffmpeg の `setpts=(PTS-STARTPTS)/speed` 相当を**マット生成より先に**
+適用する。省略時は source 区間と出力 duration が 1 フレーム以内なら 1 倍、それを超えて異なる場合は
+`(out-in) / (duration/fps)` を実効速度とする。速度適用済みの一時動画は `os.tmpdir()` 下に置き、成功・
+失敗を問わず削除する。`person-matte.mjs` には出力 fps を渡し、生成 item の `at` / `duration` は元
+カットと同じ整数フレーム値にする。
+
+### 10.3 v2 track と z 順
+
+現行 v2 は旧版のトップレベル `layers[]` / `timeline.tracks` を持たない。`tracks[]` の配列順そのものが
+画面の下から上への z 順で、各 visual track の `items[]` が旧 layer item の役割を持つ。このため
+コマンドは次を v2 ネイティブ表現として出力する。
+
+- `sources[]`: `{id:"person-cutout-N", path:"assets/matte/person-N.webm"}`
+- 最前面 visual track: `{id:"person-cutout", lane:"visual", items:[...]}`
+- item: 元カットと同じ `at` / `duration`、`source.kind:"media"`、`in:0`、
+  `out:duration/fps`
+
+既存 track の相互順は保持し、人物 track だけを末尾（最前面）へ挿入または移動する。これにより人物は
+HTML overlay / telop より上に来る。`deriveTracks` 相当の既定順は変更しない。
+
+### 10.4 冪等性と書き込みゲート
+
+同じ cut の再実行では `person-cutout-N` source、`person-N` item、既存マットを更新し、重複を追加しない。
+人物 track も常に 1 本である。複数 cut 指定では同じ track に item を集約し、`at`、次いで id の順に
+決定的に並べる。
+
+パッチ候補はまず v2 reader で閉じた語彙、参照、一意性、整数フレームを検証し、同一ディレクトリの
+一時 edit.json に書いて `packages/schemas/bin/validate-edit.mjs` も通す。両方が成功した場合だけ元
+`edit.json` へ atomic rename する。不合格なら一時ファイルを削除し、元 edit.json は一切変更しない。
+バックアップは作らない（git 管理を復旧手段とする）。

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

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "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. Run them from a full AKARI Video app installation (normally ~/.akari/app) or a monorepo checkout.]",
   "type": "module",
   "files": [

package/vendor/packages/edit-lint/src/edit-lint.mjs

@@ -20,11 +20,16 @@ import { resolveFfmpeg, resolveFfprobe } from "../../media-bin/src/index.mjs";
 
 const {
   areCutsAdjacent,
+  cutOverlapFrames,
+  findCrossTrackLayerEvacuations,
   findUnsupportedDeclaredTrackTransitions,
+  isStillImageSourcePath,
+  planTransitionHandleWindow,
   projectLegacyEdit,
   readInternalEdit,
   resolveCaptionDisplay,
   visualContentEndSeconds,
+  TRANSITION_TYPE_IDS,
 } = createRequire(import.meta.url)("../../edit-store/lib/index.js");
 
 const VERSION = 1;
@@ -135,6 +140,7 @@ export async function lintProject(input, options = {}) {
   const rawEdit = edit;
   const internalEdit = readInternalEdit(rawEdit);
   const legacyEdit = projectLegacyEdit(internalEdit);
+  validateTransitionLayerEvacuations(rawEdit, internalEdit, findings);
   const rawAudio = isRecord(rawEdit.audio) ? rawEdit.audio : {};
   const projectedAudio = projectAudioForLint(internalEdit);
   edit = {
@@ -254,7 +260,7 @@ export async function lintProject(input, options = {}) {
   validateCutTransformFields(edit.cuts, findings);
   validateStillImageCuts(edit, findings);
   const cutTrackSegments = computeCutTrackSegments(edit.cuts);
-  validateTransitionAdjacency(edit.cuts, cutTrackSegments, edit.fps, findings);
+  validateTransitionAdjacency(edit.cuts, cutTrackSegments, edit.sources, edit.fps, findings);
   for (const segment of findTrackOverlaps(cutTrackSegments)) {
     if (isDeclaredTransitionOverlap(edit.cuts, cutTrackSegments, segment, edit.fps)) continue;
     addFinding(findings, {
@@ -319,14 +325,47 @@ export async function lintProject(input, options = {}) {
   return writeResult(findings, skipped, inputs, paths, options);
 }
 
-function validateTransitionAdjacency(cuts, segments, fps, findings) {
+function validateTransitionAdjacency(cuts, segments, sources, fps, findings) {
+  const sourcePaths = new Map((Array.isArray(sources) ? sources : [])
+    .filter(source => isRecord(source) && typeof source.id === "string")
+    .map(source => [source.id, source.path]));
+  const isStillCut = cut => isStillImageSourcePath(sourcePaths.get(cut?.src) ?? cut?.src);
   for (let position = 0; position < segments.length; position += 1) {
     const earlier = segments[position];
     const transition = cuts?.[earlier.index]?.transition_out;
     if (!isRecord(transition) || !isPositiveNumber(transition.duration)) continue;
     const later = segments.slice(position + 1).find(candidate => candidate.track === earlier.track);
-    if (!later || later.start <= earlier.end) continue;
-    if (areCutsAdjacent(
+    if (!later) continue;
+    const overlapFrames = cutOverlapFrames(
+      { tlEnd: earlier.end },
+      { tlStart: later.start },
+      fps,
+    );
+    if (overlapFrames === 0) {
+      const outgoingCut = cuts?.[earlier.index];
+      const incomingCut = cuts?.[later.index];
+      const incomingSpeed = isPositiveNumber(incomingCut?.speed) ? incomingCut.speed : 1;
+      const plan = planTransitionHandleWindow({
+        declaredSeconds: transition.duration,
+        outgoingTailRoomSeconds: Number.POSITIVE_INFINITY,
+        incomingHeadRoomSeconds: isStillCut(incomingCut)
+          ? Number.POSITIVE_INFINITY : Math.max(0, Number(incomingCut?.in) || 0) / incomingSpeed,
+        outgoingDurationSeconds: Math.max(0, earlier.end - earlier.start),
+        incomingDurationSeconds: Math.max(0, later.end - later.start),
+      });
+      if (plan.effectiveSeconds <= 0) {
+        addFinding(findings, {
+          severity: "warning",
+          check: "cuts.transition-out.zero-overlap",
+          message: "トランジションを宣言していますが、のりしろにできる素材の余りがないため効きません。素材のトリムを調整するか、トランジションを削除してください。",
+          path: `edit.json#cuts[${earlier.index}].transition_out`,
+          range: { start: earlier.end, end: later.start },
+        });
+      }
+      continue;
+    }
+    // 正の重なりは、宣言尺未満なら既存の短縮クランプ、宣言尺超なら track-overlap が担当する。
+    if (overlapFrames > 0 || areCutsAdjacent(
       { tlEnd: earlier.end, transitionOut: { duration: transition.duration } },
       { tlStart: later.start },
       fps,
@@ -341,6 +380,50 @@ function validateTransitionAdjacency(cuts, segments, fps, findings) {
   }
 }
 
+function validateTransitionLayerEvacuations(rawEdit, internalEdit, findings) {
+  if (!isRecord(rawEdit) || rawEdit.version !== 2) return;
+  const crossTrackCauses = new Map();
+  for (const cause of findCrossTrackLayerEvacuations(rawEdit)) {
+    if (!crossTrackCauses.has(cause.itemId)) crossTrackCauses.set(cause.itemId, cause);
+  }
+  const rawLocations = new Map();
+  if (Array.isArray(rawEdit.tracks)) {
+    rawEdit.tracks.forEach((track, trackIndex) => {
+      if (!isRecord(track) || !Array.isArray(track.items)) return;
+      track.items.forEach((item, itemIndex) => {
+        if (isRecord(item) && typeof item.id === "string") {
+          rawLocations.set(item.id, { trackIndex, itemIndex });
+        }
+      });
+    });
+  }
+  for (const track of internalEdit.tracks) {
+    for (const item of track.items) {
+      const transition = item.declaration?.transition_out;
+      if (item.legacy.collection !== "layers" || !isRecord(transition)) continue;
+      const location = rawLocations.get(item.id);
+      const cause = crossTrackCauses.get(item.id);
+      const reason = cause
+        ? `このクリップは他トラックのアイテム（${cause.causeItemId}）と重なっているため PiP 経路へ退避され、宣言したトランジションは書き出されません。`
+        : "このクリップは合成機能または同一トラック内の重なりにより PiP 経路へ退避され、宣言したトランジションは書き出されません。";
+      addFinding(findings, {
+        severity: "warning",
+        check: "cuts.transition-out.layer-evacuated",
+        message: `${reason}重なりを解消するか、トランジションを削除してください。`,
+        path: location
+          ? `edit.json#tracks[${location.trackIndex}].items[${location.itemIndex}].source.transition_out`
+          : `edit.json#tracks[${track.z}].items`,
+        ...(cause ? {
+          range: {
+            start: cause.overlapStartFrames / internalEdit.output.fps,
+            end: cause.overlapEndFrames / internalEdit.output.fps,
+          },
+        } : {}),
+      });
+    }
+  }
+}
+
 function projectAudioForLint(internalEdit) {
   const sfx = [];
   const narration = [];
@@ -829,8 +912,8 @@ function validateTransitionOut(value, findings, path) {
     addFinding(findings, { severity: "error", check: "cuts.transition-out.structure", message: "transition_out must be an object", path });
     return;
   }
-  if (!["dissolve", "fade-black", "fade-white", "reveal-down", "reveal-up"].includes(value.type)) {
-    addFinding(findings, { severity: "error", check: "cuts.transition-out.type", message: "type must be dissolve/fade-black/fade-white/reveal-down/reveal-up", path });
+  if (!TRANSITION_TYPE_IDS.includes(value.type)) {
+    addFinding(findings, { severity: "error", check: "cuts.transition-out.type", message: `type must be ${TRANSITION_TYPE_IDS.join("/")}`, path });
   }
   if (!isPositiveNumber(value.duration)) {
     addFinding(findings, { severity: "error", check: "cuts.transition-out.duration", message: "duration must be a positive number", path });
@@ -1023,17 +1106,6 @@ function validateCutTransformFields(cuts, findings) {
   }
 }
 
-// docs/contract-2026-08-12-still-image-cut-source-v0.md 裁定1: 判定は拡張子のみ。同じ集合
-// (png/jpe?g/webp/bmp/gif, 大小無視) を packages/render-cut/src/layers.mjs の
-// IMAGE_LAYER_SOURCE_PATTERN / plan.mjs の chroma_key 背景判定と揃える。edit-lint はスキーマ
-// パッケージから独立しているため、ここでは同じパターンを別リテラルとして持つ（3面パリティ
-// テストと同じ流儀: packages/preview-server/test/image-layer-source.test.mjs 参照）。
-const IMAGE_CUT_SOURCE_PATTERN = /\.(png|jpe?g|webp|bmp|gif)$/iu;
-
-function isImageCutSourcePath(pathValue) {
-  return typeof pathValue === "string" && IMAGE_CUT_SOURCE_PATTERN.test(pathValue);
-}
-
 // 裁定3〜5（in/out 意味論・freeze/speed 警告・v0 空 cuts 拒否）。source が静止画のときだけ発火する。
 function validateStillImageCuts(edit, findings) {
   if (!isRecord(edit)) return;
@@ -1041,7 +1113,7 @@ function validateStillImageCuts(edit, findings) {
 
   const imageSourceIds = new Set(
     (Array.isArray(edit.sources) ? edit.sources : [])
-      .filter((source) => isRecord(source) && isImageCutSourcePath(source.path))
+      .filter((source) => isRecord(source) && isStillImageSourcePath(source.path))
       .map((source) => source.id),
   );
   if (imageSourceIds.size === 0) return;

package/vendor/packages/edit-store/lib/cut-adjacency.d.ts

@@ -12,6 +12,31 @@ export interface CutAdjacencyEarlierLike {
 export interface CutAdjacencyLaterLike {
     tlStart: number;
 }
+export declare const DEFAULT_CUT_ADJACENCY_FPS = 30;
+export declare function effectiveCutFps(fps: number): number;
+/**
+ * earlier の終端と later の開始を出力 fps へ量子化し、実重なりをフレーム数で返す。
+ * 正数は重なり、0 は突き合わせ、負数はすき間を表す。
+ */
+export declare function cutOverlapFrames(earlier: Pick<CutAdjacencyEarlierLike, 'tlEnd'>, later: CutAdjacencyLaterLike, fps?: number): number;
+export interface TransitionHandleWindowInput {
+    declaredSeconds: number;
+    /** outgoing の out より後ろに残る素材尺（出力秒）。不明なら Infinity。 */
+    outgoingTailRoomSeconds: number;
+    /** incoming の in より前に残る素材尺（出力秒）。 */
+    incomingHeadRoomSeconds: number;
+    outgoingDurationSeconds: number;
+    incomingDurationSeconds: number;
+}
+export interface TransitionHandleWindowPlan {
+    effectiveSeconds: number;
+    halfSeconds: number;
+    outcome: 'full' | 'clamped' | 'none';
+}
+/** 隠れのりしろ窓の実効尺を秒の連続量で決める単一定義。 */
+export declare function planTransitionHandleWindow(input: TransitionHandleWindowInput): TransitionHandleWindowPlan;
+export declare const STILL_IMAGE_SOURCE_PATTERN: RegExp;
+export declare function isStillImageSourcePath(path: unknown): boolean;
 /**
  * ギャップ 0、または earlier の宣言済み transitionOut.duration で説明できる重なりだけを
  * 隣接とみなす。秒の誤差ではなく、出力 fps で量子化したフレーム数を比較する。

package/vendor/packages/edit-store/lib/cut-adjacency.js

@@ -4,20 +4,50 @@
  * タイムライン UI と edit-lint は必ずこの関数を使い、フレーム量子化の条件式を複製しない。
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.STILL_IMAGE_SOURCE_PATTERN = exports.DEFAULT_CUT_ADJACENCY_FPS = void 0;
+exports.effectiveCutFps = effectiveCutFps;
+exports.cutOverlapFrames = cutOverlapFrames;
+exports.planTransitionHandleWindow = planTransitionHandleWindow;
+exports.isStillImageSourcePath = isStillImageSourcePath;
 exports.areCutsAdjacent = areCutsAdjacent;
-const DEFAULT_CUT_ADJACENCY_FPS = 30;
-function effectiveFps(fps) {
-    return Number.isFinite(fps) && fps > 0 ? fps : DEFAULT_CUT_ADJACENCY_FPS;
+exports.DEFAULT_CUT_ADJACENCY_FPS = 30;
+function effectiveCutFps(fps) {
+    return Number.isFinite(fps) && fps > 0 ? fps : exports.DEFAULT_CUT_ADJACENCY_FPS;
+}
+/**
+ * earlier の終端と later の開始を出力 fps へ量子化し、実重なりをフレーム数で返す。
+ * 正数は重なり、0 は突き合わせ、負数はすき間を表す。
+ */
+function cutOverlapFrames(earlier, later, fps = exports.DEFAULT_CUT_ADJACENCY_FPS) {
+    const resolvedFps = effectiveCutFps(fps);
+    return Math.round(earlier.tlEnd * resolvedFps) - Math.round(later.tlStart * resolvedFps);
+}
+const nonNegativeRoom = (value) => value === Number.POSITIVE_INFINITY
+    ? value
+    : Number.isFinite(value) && value > 0 ? value : 0;
+/** 隠れのりしろ窓の実効尺を秒の連続量で決める単一定義。 */
+function planTransitionHandleWindow(input) {
+    const declaredSeconds = Number.isFinite(input.declaredSeconds) && input.declaredSeconds > 0
+        ? input.declaredSeconds : 0;
+    const effectiveSeconds = Math.max(0, Math.min(declaredSeconds, 2 * nonNegativeRoom(input.outgoingTailRoomSeconds), 2 * nonNegativeRoom(input.incomingHeadRoomSeconds), 2 * nonNegativeRoom(input.outgoingDurationSeconds), 2 * nonNegativeRoom(input.incomingDurationSeconds)));
+    return {
+        effectiveSeconds,
+        halfSeconds: effectiveSeconds / 2,
+        outcome: effectiveSeconds <= 0 ? 'none'
+            : effectiveSeconds < declaredSeconds ? 'clamped' : 'full'
+    };
+}
+exports.STILL_IMAGE_SOURCE_PATTERN = /\.(png|jpe?g|webp|bmp|gif)$/iu;
+function isStillImageSourcePath(path) {
+    return typeof path === 'string' && exports.STILL_IMAGE_SOURCE_PATTERN.test(path);
 }
 /**
  * ギャップ 0、または earlier の宣言済み transitionOut.duration で説明できる重なりだけを
  * 隣接とみなす。秒の誤差ではなく、出力 fps で量子化したフレーム数を比較する。
  */
-function areCutsAdjacent(earlier, later, fps = DEFAULT_CUT_ADJACENCY_FPS) {
-    const resolvedFps = effectiveFps(fps);
-    const earlierEndFrame = Math.round(earlier.tlEnd * resolvedFps);
-    const laterStartFrame = Math.round(later.tlStart * resolvedFps);
-    const overlapFrames = earlierEndFrame - laterStartFrame;
+function areCutsAdjacent(earlier, later, fps = exports.DEFAULT_CUT_ADJACENCY_FPS) {
+    const resolvedFps = effectiveCutFps(fps);
+    const overlapFrames = cutOverlapFrames(earlier, later, resolvedFps);
     const declaredDuration = earlier.transitionOut?.duration;
     const declaredOverlapFrames = typeof declaredDuration === 'number'
         && Number.isFinite(declaredDuration) && declaredDuration > 0

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

@@ -1,3 +1,4 @@
+import { type ReadableTransitionType, type TransitionType } from './transition-vocabulary';
 export interface EditCut {
     in: number;
     out: number;
@@ -11,7 +12,7 @@ export interface EditCut {
     opacity?: number;
     speed?: number;
     transitionOut?: {
-        type: 'dissolve' | 'fade-black' | 'fade-white' | 'reveal-down' | 'reveal-up';
+        type: ReadableTransitionType;
         duration: number;
     };
     at?: number;
@@ -140,9 +141,19 @@ export declare function updateCutTransformInSource(source: string, cutIndex: num
 }): string;
 export declare function updateCutOpacityInSource(source: string, cutIndex: number, opacity: number | null): string;
 export declare function setCutTransitionOutInSource(source: string, cutIndex: number, transitionOut: {
-    type: 'dissolve' | 'fade-black' | 'fade-white' | 'reveal-down' | 'reveal-up';
+    type: TransitionType;
     duration: number;
 } | null): string;
+export interface RemoveV2TransitionOutWithHandleRetractInput {
+    itemId: string;
+    retractFrames: number;
+    fps: number;
+}
+/**
+ * v0.1.20 の自動のりしろ debris を、transition_out の削除と同じ 1 回の
+ * byte-preserving 手術で回収する。新意味論の通常操作では trim を一切変更しない。
+ */
+export declare function removeV2TransitionOutWithHandleRetractInSource(source: string, input: RemoveV2TransitionOutWithHandleRetractInput): string;
 export declare function reorderCutsInSource(source: string, fromIndex: number, toIndex: number): string;
 export declare function splitCutInSource(source: string, cutIndex: number, atSeconds: number): string;
 export declare function deleteCutInSource(source: string, cutIndex: number): {

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

@@ -9,6 +9,7 @@ exports.setCutSpeedInSource = setCutSpeedInSource;
 exports.updateCutTransformInSource = updateCutTransformInSource;
 exports.updateCutOpacityInSource = updateCutOpacityInSource;
 exports.setCutTransitionOutInSource = setCutTransitionOutInSource;
+exports.removeV2TransitionOutWithHandleRetractInSource = removeV2TransitionOutWithHandleRetractInSource;
 exports.reorderCutsInSource = reorderCutsInSource;
 exports.splitCutInSource = splitCutInSource;
 exports.deleteCutInSource = deleteCutInSource;
@@ -37,6 +38,7 @@ exports.removeOverlayInSource = removeOverlayInSource;
 exports.writeTimelineTracksInSource = writeTimelineTracksInSource;
 exports.updateArrayElementByIndex = updateArrayElementByIndex;
 exports.updateOverlayVarInSource = updateOverlayVarInSource;
+const transition_vocabulary_1 = require("./transition-vocabulary");
 const JSON_NUMBER = '-?(?:0|[1-9]\\d*)(?:\\.\\d+)?(?:[eE][+-]?\\d+)?';
 const LAYER_BLEND_MODES = [
     'normal', 'screen', 'multiply', 'add', 'difference',
@@ -318,9 +320,7 @@ function updateCutOpacityInSource(source, cutIndex, opacity) {
 }
 function setCutTransitionOutInSource(source, cutIndex, transitionOut) {
     if (transitionOut !== null) {
-        if (transitionOut.type !== 'dissolve' && transitionOut.type !== 'fade-black'
-            && transitionOut.type !== 'fade-white' && transitionOut.type !== 'reveal-down'
-            && transitionOut.type !== 'reveal-up') {
+        if (!(0, transition_vocabulary_1.isTransitionType)(transitionOut.type)) {
             throw new Error('トランジションの種別が不正です。');
         }
         if (!Number.isFinite(transitionOut.duration) || transitionOut.duration <= 0) {
@@ -348,6 +348,72 @@ function setCutTransitionOutInSource(source, cutIndex, transitionOut) {
         }
     });
 }
+/**
+ * v0.1.20 の自動のりしろ debris を、transition_out の削除と同じ 1 回の
+ * byte-preserving 手術で回収する。新意味論の通常操作では trim を一切変更しない。
+ */
+function removeV2TransitionOutWithHandleRetractInSource(source, input) {
+    const raw = JSON.parse(source);
+    if (raw.version !== 2) {
+        throw new Error('v2 へ変換してから編集してください。');
+    }
+    if (!input.itemId) {
+        throw new Error('トランジション対象のアイテム id が空です。');
+    }
+    if (!Number.isInteger(input.retractFrames) || input.retractFrames <= 0
+        || !Number.isFinite(input.fps) || input.fps <= 0) {
+        throw new Error('のりしろの復元量が不正です。');
+    }
+    const tracks = locateArray(source, 'tracks');
+    const trackElements = splitTopLevelElements(tracks.inner);
+    const matches = [];
+    for (const track of trackElements) {
+        let items;
+        try {
+            items = locateArray(track.text, 'items');
+        }
+        catch {
+            continue;
+        }
+        const item = splitTopLevelElements(items.inner)
+            .find(candidate => readStringProperty(candidate.text, 'id') === input.itemId);
+        if (item)
+            matches.push({ track, items, item });
+    }
+    if (matches.length !== 1) {
+        throw new Error(matches.length === 0
+            ? `アイテム ${input.itemId} が見つかりません`
+            : `アイテム ${input.itemId} が複数あります`);
+    }
+    const match = matches[0];
+    const label = `アイテム ${input.itemId}`;
+    const durationFrames = readNumberProperty(match.item.text, 'duration', label);
+    if (!Number.isInteger(durationFrames) || durationFrames < input.retractFrames) {
+        throw new Error(`${label} の duration を安全に復元できません。`);
+    }
+    const mediaSource = locateTopLevelObjectProperty(match.item.text, 'source');
+    if (readStringProperty(mediaSource.text, 'kind') !== 'media') {
+        throw new Error(`${label} は映像素材ではありません。`);
+    }
+    const sourceIn = readNumberProperty(mediaSource.text, 'in', label);
+    const sourceOut = readNumberProperty(mediaSource.text, 'out', label);
+    const speed = (sourceOut - sourceIn) / (durationFrames / input.fps);
+    if (!Number.isFinite(speed) || speed <= 0) {
+        throw new Error(`${label} の speed を安全に復元できません。`);
+    }
+    const nextOut = sourceOut - (input.retractFrames / input.fps) * speed;
+    if (!Number.isFinite(nextOut) || nextOut < sourceIn) {
+        throw new Error(`${label} の out を安全に復元できません。`);
+    }
+    let nextMediaSource = removeObjectProperty(mediaSource.text, 'transition_out');
+    nextMediaSource = replaceNumberProperty(nextMediaSource, 'out', nextOut, label);
+    let nextItem = match.item.text.slice(0, mediaSource.start)
+        + nextMediaSource
+        + match.item.text.slice(mediaSource.end);
+    nextItem = replaceNumberProperty(nextItem, 'duration', durationFrames - input.retractFrames, label);
+    const nextTrack = replaceElement(match.track.text, match.items.openIndex + 1, match.item, nextItem);
+    return replaceElement(source, tracks.openIndex + 1, match.track, nextTrack);
+}
 function reorderCutsInSource(source, fromIndex, toIndex) {
     const array = locateArray(source, 'cuts');
     const elements = splitTopLevelElements(array.inner);

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

@@ -16,5 +16,6 @@ export * from './retime';
 export * from './track-order';
 export * from './track-transition-compatibility';
 export * from './cut-adjacency';
+export * from './transition-vocabulary';
 export { parseEdit } from './migrate/legacy-parse';
 export { LegacyEditVersionError } from './migrate/error';

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

@@ -33,6 +33,7 @@ __exportStar(require("./retime"), exports);
 __exportStar(require("./track-order"), exports);
 __exportStar(require("./track-transition-compatibility"), exports);
 __exportStar(require("./cut-adjacency"), exports);
+__exportStar(require("./transition-vocabulary"), exports);
 // Legacy parser implementation lives in the frozen migration unit. This re-export keeps
 // text-surgery consumers source-compatible while preventing legacy knowledge from returning
 // to edit-store.ts.

package/vendor/packages/edit-store/lib/internal-model.d.ts

@@ -167,6 +167,19 @@ export declare function readInternalSources(source: string | unknown): InternalS
  * 検証される側であり、検証対象自身を尺の分母に混ぜると常に「収まっている」判定になってしまう。
  */
 export declare function visualContentEndSeconds(internal: InternalEdit): number;
+export interface CrossTrackLayerEvacuation {
+    itemId: string;
+    trackId: string;
+    causeItemId: string;
+    causeTrackId: string;
+    overlapStartFrames: number;
+    overlapEndFrames: number;
+}
+/**
+ * 別 visual track との重なりが原因で upper item が layers へ退避される組を返す。
+ * edit-lint と UI は理由文言に必要な相手 id を、この単一定義から得る。
+ */
+export declare function findCrossTrackLayerEvacuations(edit: unknown): CrossTrackLayerEvacuation[];
 export interface LegacyEditView {
     cuts: EditCut[];
     sources?: EditSource[];