akari-video 0.1.19 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "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/packages/akari-launcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "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,6 +20,8 @@ import { resolveFfmpeg, resolveFfprobe } from "../../media-bin/src/index.mjs";
 
 const {
   areCutsAdjacent,
+  cutOverlapFrames,
+  findCrossTrackLayerEvacuations,
   findUnsupportedDeclaredTrackTransitions,
   projectLegacyEdit,
   readInternalEdit,
@@ -135,6 +137,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 = {
@@ -325,8 +328,24 @@ function validateTransitionAdjacency(cuts, segments, fps, findings) {
     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) {
+      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 +360,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 = [];

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

@@ -12,6 +12,31 @@ export interface CutAdjacencyEarlierLike {
 export interface CutAdjacencyLaterLike {
     tlStart: number;
 }
+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 type TransitionHandleExtensionOutcome = 'already-overlapping' | 'full' | 'partial' | 'none';
+export interface TransitionHandleExtensionPlan {
+    appliedSeconds: number;
+    effectiveSeconds: number;
+    appliedFrames: number;
+    outcome: TransitionHandleExtensionOutcome;
+}
+export interface TransitionHandleExtensionInput {
+    declaredSeconds: number;
+    earlierEndSeconds: number;
+    laterStartSeconds: number;
+    maxExtendSeconds: number;
+    fps?: number;
+}
+/**
+ * 突き合わせ境界へ宣言尺ぶんの重なりを作るため、outgoing を何フレーム延ばすか決める。
+ * メディア長は知らず、呼び出し側が maxExtendSeconds として渡した上限だけを使う。
+ */
+export declare function planTransitionHandleExtension(input: TransitionHandleExtensionInput): TransitionHandleExtensionPlan;
 /**
  * ギャップ 0、または earlier の宣言済み transitionOut.duration で説明できる重なりだけを
  * 隣接とみなす。秒の誤差ではなく、出力 fps で量子化したフレーム数を比較する。

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

@@ -4,20 +4,63 @@
  * タイムライン UI と edit-lint は必ずこの関数を使い、フレーム量子化の条件式を複製しない。
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.effectiveCutFps = effectiveCutFps;
+exports.cutOverlapFrames = cutOverlapFrames;
+exports.planTransitionHandleExtension = planTransitionHandleExtension;
 exports.areCutsAdjacent = areCutsAdjacent;
 const DEFAULT_CUT_ADJACENCY_FPS = 30;
-function effectiveFps(fps) {
+function effectiveCutFps(fps) {
     return Number.isFinite(fps) && fps > 0 ? fps : DEFAULT_CUT_ADJACENCY_FPS;
 }
+/**
+ * earlier の終端と later の開始を出力 fps へ量子化し、実重なりをフレーム数で返す。
+ * 正数は重なり、0 は突き合わせ、負数はすき間を表す。
+ */
+function cutOverlapFrames(earlier, later, fps = DEFAULT_CUT_ADJACENCY_FPS) {
+    const resolvedFps = effectiveCutFps(fps);
+    return Math.round(earlier.tlEnd * resolvedFps) - Math.round(later.tlStart * resolvedFps);
+}
+/**
+ * 突き合わせ境界へ宣言尺ぶんの重なりを作るため、outgoing を何フレーム延ばすか決める。
+ * メディア長は知らず、呼び出し側が maxExtendSeconds として渡した上限だけを使う。
+ */
+function planTransitionHandleExtension(input) {
+    const fps = effectiveCutFps(input.fps ?? DEFAULT_CUT_ADJACENCY_FPS);
+    const declaredFrames = Number.isFinite(input.declaredSeconds) && input.declaredSeconds > 0
+        ? Math.max(1, Math.round(input.declaredSeconds * fps)) : 0;
+    const overlapFrames = cutOverlapFrames({ tlEnd: input.earlierEndSeconds }, { tlStart: input.laterStartSeconds }, fps);
+    if (overlapFrames > 0) {
+        return {
+            appliedSeconds: 0,
+            effectiveSeconds: Math.min(declaredFrames, overlapFrames) / fps,
+            appliedFrames: 0,
+            outcome: 'already-overlapping'
+        };
+    }
+    const maximumFrames = input.maxExtendSeconds === Number.POSITIVE_INFINITY
+        ? Number.POSITIVE_INFINITY
+        : Number.isFinite(input.maxExtendSeconds) && input.maxExtendSeconds > 0
+            ? Math.max(0, Math.floor(input.maxExtendSeconds * fps + 1e-9)) : 0;
+    // すき間（負の overlapFrames）がある場合は、その穴を埋めたうえで宣言尺ぶん重ねる。
+    // UI は非隣接ガードでこの経路へ入れないが、純関数としては安全な値を返す。
+    const requiredFrames = Math.max(0, declaredFrames - overlapFrames);
+    const appliedFrames = Math.min(requiredFrames, maximumFrames);
+    const effectiveFrames = Math.max(0, Math.min(declaredFrames, overlapFrames + appliedFrames));
+    return {
+        appliedSeconds: appliedFrames / fps,
+        effectiveSeconds: effectiveFrames / fps,
+        appliedFrames,
+        outcome: appliedFrames <= 0 ? 'none'
+            : appliedFrames >= requiredFrames ? 'full' : 'partial'
+    };
+}
 /**
  * ギャップ 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;
+    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 TransitionHandleExtensionPlan } from './cut-adjacency';
 export interface EditCut {
     in: number;
     out: number;
@@ -143,6 +144,26 @@ export declare function setCutTransitionOutInSource(source: string, cutIndex: nu
     type: 'dissolve' | 'fade-black' | 'fade-white' | 'reveal-down' | 'reveal-up';
     duration: number;
 } | null): string;
+export interface SetV2TransitionOutWithHandleInput {
+    itemId: string;
+    transitionOut: {
+        type: 'dissolve' | 'fade-black' | 'fade-white' | 'reveal-down' | 'reveal-up';
+        duration: number;
+    };
+    earlierEndSeconds: number;
+    laterStartSeconds: number;
+    maxExtendSeconds: number;
+    fps: number;
+}
+export interface SetV2TransitionOutWithHandleResult {
+    source: string;
+    plan: TransitionHandleExtensionPlan;
+}
+/**
+ * v2 の transition_out 宣言と outgoing の source.out / duration 延長を 1 回の
+ * byte-preserving 手術で行う。maxExtendSeconds は出力秒軸の上限で、素材実尺は呼び出し側が決める。
+ */
+export declare function setV2TransitionOutWithHandleInSource(source: string, input: SetV2TransitionOutWithHandleInput): SetV2TransitionOutWithHandleResult;
 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.setV2TransitionOutWithHandleInSource = setV2TransitionOutWithHandleInSource;
 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 cut_adjacency_1 = require("./cut-adjacency");
 const JSON_NUMBER = '-?(?:0|[1-9]\\d*)(?:\\.\\d+)?(?:[eE][+-]?\\d+)?';
 const LAYER_BLEND_MODES = [
     'normal', 'screen', 'multiply', 'add', 'difference',
@@ -348,6 +350,104 @@ function setCutTransitionOutInSource(source, cutIndex, transitionOut) {
         }
     });
 }
+/**
+ * v2 の transition_out 宣言と outgoing の source.out / duration 延長を 1 回の
+ * byte-preserving 手術で行う。maxExtendSeconds は出力秒軸の上限で、素材実尺は呼び出し側が決める。
+ */
+function setV2TransitionOutWithHandleInSource(source, input) {
+    const raw = JSON.parse(source);
+    if (raw.version !== 2) {
+        throw new Error('v2 へ変換してから編集してください。');
+    }
+    assertTransitionOutValue(input.transitionOut);
+    if (!input.itemId) {
+        throw new Error('トランジション対象のアイテム id が空です。');
+    }
+    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);
+    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 outputDurationSeconds = durationFrames / input.fps;
+    const speed = (sourceOut - sourceIn) / outputDurationSeconds;
+    // 暗黙 speed を維持できない極端値は、素材窓を壊すより宣言だけを残す保守側へ倒す。
+    // 実用域外（1e-6 未満 / 1e6 超）の比率も浮動小数の増分が不安定なので延長しない。
+    const safeSpeed = Number.isFinite(speed) && speed >= 1e-6 && speed <= 1e6;
+    const plan = (0, cut_adjacency_1.planTransitionHandleExtension)({
+        declaredSeconds: input.transitionOut.duration,
+        earlierEndSeconds: input.earlierEndSeconds,
+        laterStartSeconds: input.laterStartSeconds,
+        maxExtendSeconds: safeSpeed ? input.maxExtendSeconds : 0,
+        fps: input.fps
+    });
+    let nextMediaSource = writeTransitionOutProperty(mediaSource.text, input.transitionOut);
+    if (plan.appliedFrames > 0) {
+        const nextOut = sourceOut + plan.appliedSeconds * speed;
+        if (!Number.isFinite(nextOut)) {
+            throw new Error(`${label} の out を安全に延長できません。`);
+        }
+        nextMediaSource = replaceNumberProperty(nextMediaSource, 'out', nextOut, label);
+    }
+    let nextItem = match.item.text.slice(0, mediaSource.start)
+        + nextMediaSource
+        + match.item.text.slice(mediaSource.end);
+    if (plan.appliedFrames > 0) {
+        nextItem = replaceNumberProperty(nextItem, 'duration', durationFrames + plan.appliedFrames, label);
+    }
+    const nextTrack = replaceElement(match.track.text, match.items.openIndex + 1, match.item, nextItem);
+    return {
+        source: replaceElement(source, tracks.openIndex + 1, match.track, nextTrack),
+        plan
+    };
+}
+function assertTransitionOutValue(transitionOut) {
+    if (transitionOut.type !== 'dissolve' && transitionOut.type !== 'fade-black'
+        && transitionOut.type !== 'fade-white' && transitionOut.type !== 'reveal-down'
+        && transitionOut.type !== 'reveal-up') {
+        throw new Error('トランジションの種別が不正です。');
+    }
+    if (!Number.isFinite(transitionOut.duration) || transitionOut.duration <= 0) {
+        throw new Error('トランジションの尺は正の数で指定してください。');
+    }
+}
+function writeTransitionOutProperty(mediaSource, transitionOut) {
+    const value = { type: transitionOut.type, duration: transitionOut.duration };
+    if (!hasTopLevelProperty(mediaSource, 'transition_out')) {
+        return appendJsonProperty(mediaSource, 'transition_out', value);
+    }
+    try {
+        const located = locateTopLevelObjectProperty(mediaSource, 'transition_out');
+        return mediaSource.slice(0, located.start) + JSON.stringify(value) + mediaSource.slice(located.end);
+    }
+    catch {
+        return appendJsonProperty(removeObjectProperty(mediaSource, 'transition_out'), 'transition_out', value);
+    }
+}
 function reorderCutsInSource(source, fromIndex, toIndex) {
     const array = locateArray(source, 'cuts');
     const elements = splitTopLevelElements(array.inner);

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[];

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

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readInternalEdit = readInternalEdit;
 exports.readInternalSources = readInternalSources;
 exports.visualContentEndSeconds = visualContentEndSeconds;
+exports.findCrossTrackLayerEvacuations = findCrossTrackLayerEvacuations;
 exports.projectLegacyEdit = projectLegacyEdit;
 exports.toLegacyTrack = toLegacyTrack;
 exports.derivedLegacyTracks = derivedLegacyTracks;
@@ -258,26 +259,16 @@ function needsLayersEngine(item, chromaKeyOf, hasOverlappingSibling = false) {
         return true;
     return false;
 }
-// P0 2026-08-23 cuts-cross-track-overlap: 'cuts' 経路は同一トラック内の同時表示だけでなく、
-// 別トラック間の同時表示も winner-take-all になり、下段を描画できない。全 visual トラックの
-// items[] を総当りで比較し、半開区間 [at, at+duration) が正の長さで交差する media アイテムを
-// layers へ退避する。終端と開始が接するだけなら交差ではない。同一トラックの交差は両方を
-// layers へ送る。別トラックの交差は、下段を cuts の不透明な基底として残し、上段が全画面不透明
-// ではない宣言を持つときだけ layers へ送る。上段が全画面不透明なら winner-take-all でも同じ絵に
-// なるため、従来の cuts / track-stack 経路を保つ。
-//
-// transition_out は同一トラックの隣接カットが意図的に作る狭い重なりで、cuts/xfade が表現する。
-// その例外は同一トラックのペアだけに適用する。別トラックとの交差は transition の有無にかかわらず
-// 真の同時表示なので layers へ退避する。
-function computeOverlappingItemIds(itemGroups) {
+function analyzeOverlappingItems(itemGroups) {
     const overlapping = new Set();
-    const entries = itemGroups.flatMap((items, trackIndex) => items.map(item => ({ item, trackIndex })));
+    const crossTrackEvacuations = [];
+    const entries = itemGroups.flatMap((group, trackIndex) => group.items.map(item => ({ item, trackIndex, trackId: group.trackId })));
     for (let i = 0; i < entries.length; i++) {
-        const { item: a, trackIndex: aTrackIndex } = entries[i];
+        const { item: a, trackIndex: aTrackIndex, trackId: aTrackId } = entries[i];
         if (a.source.kind !== 'media')
             continue;
         for (let j = i + 1; j < entries.length; j++) {
-            const { item: b, trackIndex: bTrackIndex } = entries[j];
+            const { item: b, trackIndex: bTrackIndex, trackId: bTrackId } = entries[j];
             if (b.source.kind !== 'media')
                 continue;
             if (!(a.at < b.at + b.duration && b.at < a.at + a.duration))
@@ -291,13 +282,40 @@ function computeOverlappingItemIds(itemGroups) {
                 overlapping.add(b.id);
             }
             else {
-                const upper = aTrackIndex > bTrackIndex ? a : b;
-                if (needsCrossTrackLayers(upper))
+                const upperIsA = aTrackIndex > bTrackIndex;
+                const upper = upperIsA ? a : b;
+                const lower = upperIsA ? b : a;
+                if (needsCrossTrackLayers(upper)) {
                     overlapping.add(upper.id);
+                    crossTrackEvacuations.push({
+                        itemId: upper.id,
+                        trackId: upperIsA ? aTrackId : bTrackId,
+                        causeItemId: lower.id,
+                        causeTrackId: upperIsA ? bTrackId : aTrackId,
+                        overlapStartFrames: Math.max(a.at, b.at),
+                        overlapEndFrames: Math.min(a.at + a.duration, b.at + b.duration)
+                    });
+                }
             }
         }
     }
-    return overlapping;
+    return { itemIds: overlapping, crossTrackEvacuations };
+}
+function computeOverlappingItemIds(itemGroups) {
+    return analyzeOverlappingItems(itemGroups.map((items, index) => ({
+        items,
+        trackId: String(index)
+    }))).itemIds;
+}
+/**
+ * 別 visual track との重なりが原因で upper item が layers へ退避される組を返す。
+ * edit-lint と UI は理由文言に必要な相手 id を、この単一定義から得る。
+ */
+function findCrossTrackLayerEvacuations(edit) {
+    const parsed = (0, edit_v2_1.readEditV2)(edit);
+    return analyzeOverlappingItems(parsed.tracks.flatMap(track => track.lane === 'visual' && 'items' in track
+        ? [{ items: track.items, trackId: track.id }]
+        : [])).crossTrackEvacuations;
 }
 // cuts の winner-take-all が下段を隠してよいのは、上段が全画面を不透明に覆う場合だけ。
 // transform の単位元を明示しただけなら従来経路を維持する。crop / 半透明 / keyframes は、