akari-video 1.3.0-beta.8 → 1.3.0-beta.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "1.3.0-beta.8",
+  "version": "1.3.0-beta.9",
   "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

@@ -89,6 +89,7 @@
     "docs/contract-2026-10-11-content-language.md",
     "docs/contract-2026-10-11-speaker-split-v0.md",
     "docs/contract-2026-10-11-ui-i18n.md",
+    "docs/contract-2026-10-12-caption-look-v1.md",
     "packages/akari-ear/package.json",
     "packages/akari-ear/README.md",
     "packages/akari-launcher/package.json",

package/vendor/docs/contract-2026-09-24-caption-runs-v0.md

@@ -1,5 +1,7 @@
 # 字幕の文字範囲（runs）v0
 
+v1 で拡張: [contract-2026-10-12-caption-look-v1.md](./contract-2026-10-12-caption-look-v1.md)
+
 - 日付: 2026-09-24
 - 状態: v0
 

package/vendor/docs/contract-2026-09-24-style-v0.md

@@ -1,5 +1,7 @@
 # マイスタイル v0 — 保存形と適用契約
 
+v1 で拡張: [contract-2026-10-12-caption-look-v1.md](./contract-2026-10-12-caption-look-v1.md)
+
 - 日付: 2026-09-24
 - 状態: v0
 

package/vendor/docs/contract-2026-10-12-caption-look-v1.md

@@ -0,0 +1,54 @@
+# 字幕の見た目 v1 — 保存・換算・範囲・時刻・検証
+
+- 日付: 2026-10-12
+- 状態: v1
+
+## 移行と書き出し
+
+移行は render-cut の書き出し結果（HTML と CSS 変数）を保つ。移行済みの強調範囲は、描画時に `migrated_emphasis` に保存した元の項目と移行前の配列内の位置から `emphasis_words` へ戻す。残った項目の順を保ち、移した項目を位置の昇順に差し込む。追加のプロパティと項目の順序も保つ。旧形式だけの入力はそのまま描画器へ渡す。
+
+| `style_hint`（省略時の `emotion`） | `motion.in.id` |
+|---|---|
+| `one-char-bang`（`pain`、`surprise`、`anger`） | `pop` |
+| `one-char-jumble`（`disgust`） | `jitter` |
+| `size-pulse`（`joy`、`emphasis`） | `zoom-pulse` |
+
+この対応に無い hint、別の hint と同じ motion になるもの、項目ごとの `style_preset` を持つもの、語が行の表示文字列に一意に現れないもの、時刻が行の外に出るものは `emphasis_words` に残し、通知と未解決一覧に出す。移せたものだけ `fire: "spoken"` と source domain の `anchor` を持つ run にする。
+
+v1 の `look` を持つ run は px 系の値を `scale: 1` の値として保存し、描画時に run の `scale` を掛ける。旧 `stroke.width_px` を移す際は `scale` で割った値を丸めずに保存し、描画時に掛けた後だけ px 値を丸める。旧 runs v0 の `style` は保存値を従来どおり直接描く。旧 `animation` は `dormant_animation` に保管し、描画しない。
+
+`lookForCaptionRow` は `size: "keep"` なら当て先の実効 `size_px` を明示して保ち、`k = 当て先の size_px ÷ スタイルの size_px` で px 系の値を換算する。当て先の `reference_height_px` と `layout` も保つ。`size: "style"` で `layout` と `reference_height_px` が衝突するときは値を書かず、理由を返す。範囲への適用も行の実効サイズを使い、許可外の項目を落として通知する。
+
+## 保存形と互換
+
+字幕全体の見た目は `text_style` に値として保存する。新しい書き込みでは `style_preset` を使わない。旧形式の `style_preset` は現在の textstyle カタログで解決して読む。出所は描画に使わず、`style_sources: { look?, motion? }` に記録する。各 Source は `kind` (`builtin` / `library` / `my`)、`id`、`original_hash`、`applied_hash` を持ち、必要に応じて `uid`、`revision`、`applied_at`、`requires` を持つ。元の値と保存後の値を別々に照合できる。当て直しは部品全体の置換である。
+
+`runs[]` は表示文字列（`display_text` があればそれ、なければ `text`）の書記素による半開区間 `from` / `to` を持つ。v1 の id は `r-` と 4 桁以上の数字で、ファイル全体で一意にする。新しい id は `unresolved_runs[].run` も含むファイル内の最大番号に 1 を足して作る。任意の `role`、`emotion`、`look`、`motion`、`anchor`、`fire`、`style_sources`、`needs_review`、`split_from`、`migrated_from`、`migrated_emphasis`、`fire_was`、`dormant_animation` を持てる。`migrated_emphasis` は元の `emphasis_words` の `index` と `item` を持つ。範囲の効果音と `effect` は v1 では保存しない。重なる範囲では後の run の項目が勝つ。
+
+| 移行で新しく作る run のキー順 | 内容 |
+|---|---|
+| `id, from, to, role, emotion, migrated_from, migrated_emphasis, fire, anchor, motion` | 元の項目は `migrated_emphasis.item` にそのまま保存し、`index` で配列内の順序を復元する。 |
+
+旧 runs の `style` は読むときに `look` に投影する。ただし表示文字列の書記素数に対して範囲外または空の旧 run は投影も移行もせず、id を付けずに元の形で残し、文書全体の件数を通知する。旧 `animation` は描画されていなかったため `dormant_animation` に保存し、明示的に有効化するまで `motion` にしない。旧 `emphasis_words` は素材・時刻・語から行と文字範囲を一意に決められる場合だけ投影する。移行した項目は `migrated_from` と `migrated_emphasis` を付け、元の `emphasis_words` から除く。複数回の移行でも `migrated_emphasis.index` は最初の配列での位置を使い、既存の移行済み run と重複させない。一意に決まらない項目は残して通知する。未移行の `style_preset` は描画時に解決するため、見た目の固定は移行後から保証される。出所の `original_hash` と `applied_hash` は鍵を再帰的に整列した JSON を UTF-8 のバイト列にして SHA-256 で計算し、`sha256:` と 64 桁の十六進数で記録する。
+
+## look と大きさ
+
+行の許可項目は `color`、`size_px`、`reference_height_px`、`font_family`、`font_weight`、`weight`、`line_height`、`letter_spacing_em`、`text_transform`、`fill`、`strokes`、`stroke`、`background`、`shadow`、`glow`。範囲の許可項目は `color`、`font_weight`、`italic`、`underline`、`letter_spacing_em`、`scale`、`baseline_shift_em`、`rotate_deg`、`stroke`、`shadow`、`glow`、`background`。範囲に `size_px` と `font_family` は保存しない。許可外の項目は除く。`size_px` と `reference_height_px` は範囲に元から無いため通知せず、`font_family` などは通知する。
+
+大きさを保って当てる場合、保存値に `k = 当て先の size_px ÷ スタイルの size_px` を掛ける。換算対象は `stroke.width_px`、`strokes[].width_px / offset_x / offset_y`、`shadow.blur_px / distance_px`、`glow.spread / offset_x / offset_y`、`background.padding_px / radius_px`、`fill.pattern.scale`。色、透明度、角度、em 値は換算しない。当て先の `size_px` と `reference_height_px` を保ち、`size_px` が未指定なら実効値を明示する。`layout` のときも基準の `size_px` の比で計算し、描画の最終段で layout 倍率を一度掛ける。範囲の px 値は行の座標系で `scale: 1` の値として保存し、描画時に範囲の `scale` を掛ける。出力高さによる `output.height / reference_height_px` も一度だけ掛ける。
+
+## 文字範囲の寿命
+
+文字の変更では書記素単位の複数差分を対応付ける。共通の先頭と末尾を確定してから中央を対応付ける。通常の文字編集では、置換・削除の内側に丸ごと入る run を外す。表示文字列と原文の座標変換および単語帳の置換では、置換の内側に丸ごと入る run を置換後の区間へ写して `needs_review` を付け、挿入の無い削除の内側だけを外す。境界をまたぐ run は伸縮して `needs_review` を付ける。同点の対応も `needs_review` を付ける。行を分割して境界をまたぐ場合、左は元の id、右は新 id と `split_from` を持つ。anchor は両側の行の時刻へ切り詰め、空になった `spoken` 側は `shown`、`fire_was: "spoken"`、`needs_review: true` にする。隣接 run は自動結合しない。行が消えたか対応先が決まらない run はルートの `unresolved_runs[]` に `{ run, old_caption_id, old_text, old_src, old_start, old_end, reason }` として保持し、描画対象から外す。選んだ文字を行の見た目に戻す操作は、重なる各 run からその部分を切り取り、必要なら右側に新 id を与える。
+
+## anchor と発火
+
+`anchor` は `{ src?, start, end, domain }`。`domain` は `source` または `output`。`fire` は `shown`（既定）、`spoken`、`whole`。`spoken` には anchor が要る。`words[].text` の連結が行の `text` と一致するときだけ文字オフセットから実測 words に対応付ける。`display_text` が異なる場合は単語帳の文字対応を使い、対応がなければ anchor を付けず `captions.run.anchor-unmapped` を通知する。実測されていない時刻は作らない。
+
+source anchor は字幕が描かれる同じ素材の配置ごとに、速度とカットを反映して出力時刻へ写す。同じ素材の複数配置も別々に扱う。表示窓の始まりは行の開始時刻と配置の `in` の遅い方を写す。区間がすべてカットされた場合は `shown` に落とし `captions.run.anchor-cut` を通知する。output anchor は素材配置を参照せず、字幕の表示窓へ切り詰める。発火が窓より前なら窓の始まり、窓より後なら `fire: "none"` として動かさず静止の look だけを表示する。窓の外は warning で知らせる。
+
+動きの in は発火から始まり、out は字幕の終わりに終える。残る時間が in と out の合計より短ければ両者を同じ比で縮め、loop は回さない。
+
+## 検証
+
+構造は captions schema が判定する。文書の意味では v1 run の範囲外、ファイル内の run id 重複、anchor のない `spoken` を error として保存を拒む。`validate-captions` も文書の意味の層を呼び、error があれば非 0 で終了する。旧 runs v0 の範囲外・空の区間は従来どおり `captions.run-range` の warning とする。意味の error は診断を出す。描画経路での除外は後の版で行う（除外に使う純関数 `renderableCaptionRuns` は用意済み）。プロジェクトの意味では anchor の写像不能や表示窓の外を warning とし、経路の対応では選んだ描画経路が motion を描けるか判定する。診断はコード・重大度・パス・日本語メッセージを共有する。

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

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "1.3.0-beta.8",
+  "version": "1.3.0-beta.9",
   "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-lint/src/lint/captions.mjs

@@ -3,7 +3,7 @@ import { lintText } from '../i18n.mjs';
 import { buildMatcher, protectedTermsFrom } from "../../../word-book/src/index.mjs";
 import { resolveWordBookSync, scanRecord } from "../../../word-book/src/index.mjs";
 import { EPSILON, addFinding, captionFinding, isFiniteNumber, isNonEmptyString, isPositiveNumber, isRecord, relativePath } from "./shared.mjs";
-import { resolveCaptionDisplay } from "./external.mjs";
+import { resolveCaptionDisplay, validateCaptionsSemantics, CAPTION_RUN_FIELDS } from "./external.mjs";
 import { validateCaptionAnimation, validateTextStyle } from "./caption-style.mjs";
 import { captionLanguageDefaults, resolveContentLanguage } from "../../../content-language/src/index.mjs";
 import { readContentLanguageSync } from "../../../content-language/src/node.mjs";
@@ -21,6 +21,8 @@ export function validateCaptionRunRanges(caption) {
 export function validateCaptions(captions, edit, analysis, findings, paths, cutsEndSeconds, textstylePresetIds) {
   const captionPath = relativePath(paths.projectRoot, paths.captionsPath);
   const captionsRoot = captions;
+  // The caller supplies the v2 cut projection; never interpret raw tracks as cuts.
+  const timeline = Array.isArray(edit?.cuts) ? edit.cuts : undefined;
   const wordBook = resolveWordBookSync({ projectRoot: paths.projectRoot, env: process.env });
   const wordBookMatcher = buildMatcher(wordBook.entries);
   for (const layer of wordBook.layers) {
@@ -55,7 +57,8 @@ export function validateCaptions(captions, edit, analysis, findings, paths, cuts
       if (field !== "default_text_style"
         && field !== "display_policy"
         && field !== "emphasis_words"
-        && field !== "captions") {
+        && field !== "captions"
+        && field !== "unresolved_runs") {
         captionFinding(
           findings,
           "captions.schema",
@@ -111,7 +114,7 @@ export function validateCaptions(captions, edit, analysis, findings, paths, cuts
       continue;
     }
     const required = ["id", "start", "end", "text", "speaker", "sourceRef", "edited"];
-    const optional = ["src", "time_domain", "words", "unrecognized", "style", "display_text", "display_fragments", "display_timing", "style_preset", "text_style", "runs"];
+    const optional = ["src", "time_domain", "words", "unrecognized", "style", "display_text", "display_fragments", "display_timing", "style_preset", "text_style", "runs", "style_sources"];
     for (const field of required) {
       if (!Object.hasOwn(caption, field)) {
         captionFinding(findings, "captions.schema", `${field} is required`, itemPath);
@@ -214,12 +217,12 @@ export function validateCaptions(captions, edit, analysis, findings, paths, cuts
           || (run.style !== undefined && (!isRecord(run.style)
             || Object.keys(run.style).some(key => !["color", "font_weight", "scale", "baseline_shift_em", "rotate_deg", "letter_spacing_em", "stroke", "italic", "underline"].includes(key))))
           || (run.animation !== undefined && !isRecord(run.animation))
-          || Object.keys(run).some(key => !["from", "to", "role", "style", "animation"].includes(key))) {
+          || Object.keys(run).some(key => !CAPTION_RUN_FIELDS.has(key))) {
           captionFinding(findings, "captions.schema", "run has invalid fields or types", path);
           return;
         }
         const range = outOfRange.get(runIndex);
-        if (range) {
+        if (range && !["id", "look", "motion", "anchor", "fire"].some(key => Object.hasOwn(run, key))) {
           addFinding(findings, { severity: "warning", check: "captions.run-range",
             message: `run range [${run.from}, ${run.to}) is outside ${range.count} displayed graphemes or empty; ignored`, path });
         }
@@ -449,6 +452,10 @@ export function validateCaptions(captions, edit, analysis, findings, paths, cuts
       captionFinding(findings, "captions.display-policy", error instanceof Error ? error.message : String(error), captionPath);
     }
   }
+  for (const diagnostic of validateCaptionsSemantics({ captions: captionsRoot, edit, timeline })) {
+    addFinding(findings, { severity: diagnostic.severity, check: diagnostic.code,
+      message: diagnostic.message, path: diagnostic.path });
+  }
 }
 
 function validateEmphasisWords(emphasisWords, findings, captionPath) {

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

@@ -16,8 +16,10 @@ export const {
   toAnchorCaptions,
   TRANSITION_TYPE_IDS,
   withoutItemAnchors,
+  validateCaptionsSemantics,
 } = createRequire(import.meta.url)("../../../edit-store/lib/index.js");
 
+
 export const { captionsHaveRenderableCues, collectFitBasisCandidates } = createRequire(import.meta.url)(
   "../../../edit-store/lib/migrate/index.js",
 );
@@ -27,6 +29,8 @@ const CAPTIONS_SCHEMA = JSON.parse(readFileSync(
   "utf8",
 ));
 
+export const CAPTION_RUN_FIELDS = new Set(Object.keys(CAPTIONS_SCHEMA.$defs.captionRun.properties));
+
 export const CAPTION_TEXT_STYLE_FIELDS = new Set(
   Object.keys(CAPTIONS_SCHEMA.$defs.textStyle.properties),
 );

package/vendor/packages/edit-store/lib/caption-anchor-map.d.ts

@@ -0,0 +1,51 @@
+import { type TimelineMapResult } from './timeline-map';
+import type { EditCut } from './edit-store';
+import type { CaptionRun } from './caption-runs';
+export interface RunAnchor {
+    src?: string;
+    start: number;
+    end: number;
+    domain: 'source' | 'output';
+}
+export interface CaptionAnchorRow {
+    src?: string;
+    start: number;
+    end: number;
+    time_domain?: 'source' | 'output';
+}
+export interface AnchorOutput {
+    start?: number;
+    end?: number;
+    fire: 'shown' | 'spoken' | 'whole' | 'none';
+    placement?: number;
+    diagnostics: Array<{
+        code: string;
+        severity: 'warning' | 'info';
+        message: string;
+    }>;
+}
+export declare function anchorToOutput(anchor: RunAnchor | undefined, caption: CaptionAnchorRow, timeline: TimelineMapResult | readonly EditCut[], fire?: CaptionRun['fire']): AnchorOutput[];
+export declare function anchorForCaptionRange(caption: CaptionAnchorRow & {
+    text: string;
+    display_text?: string;
+    words?: Array<{
+        text: string;
+        start: number;
+        end: number;
+    }>;
+}, from: number, to: number, displayToSource?: readonly number[]): {
+    anchor?: RunAnchor;
+    diagnostics: Array<{
+        code: string;
+        severity: 'info';
+        message: string;
+    }>;
+};
+/** 表示と原文の一致箇所から、置換の両端を含む境界対応を作る。 */
+export declare function inferCaptionDisplayToSource(display: string, source: string): Array<number | undefined>;
+export declare function fitCaptionMotionWindow(fireAt: number, endAt: number, inSeconds: number, outSeconds: number): {
+    inSeconds: number;
+    outSeconds: number;
+    loopSeconds: number;
+    active: boolean;
+};

package/vendor/packages/edit-store/lib/caption-anchor-map.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anchorToOutput = anchorToOutput;
+exports.anchorForCaptionRange = anchorForCaptionRange;
+exports.inferCaptionDisplayToSource = inferCaptionDisplayToSource;
+exports.fitCaptionMotionWindow = fitCaptionMotionWindow;
+const timeline_map_1 = require("./timeline-map");
+const caption_runs_1 = require("./caption-runs");
+function anchorToOutput(anchor, caption, timeline, fire = 'shown') {
+    const map = Array.isArray(timeline) ? (0, timeline_map_1.buildTimelineMap)(timeline) : timeline;
+    const warning = (code, message) => ({ fire: 'shown', diagnostics: [{ code, severity: 'warning', message }] });
+    if (!anchor)
+        return [{ fire: 'shown', diagnostics: [] }];
+    const clip = (start, end, windowStart, windowEnd, placement) => {
+        if (start >= windowEnd)
+            return { fire: 'none', placement,
+                diagnostics: [{ code: 'captions.run.anchor-window', severity: 'warning', message: '発火が表示窓の後にあります。' }] };
+        const before = start < windowStart;
+        return { start: Math.max(start, windowStart), end: Math.min(Math.max(end, windowStart), windowEnd),
+            fire: fire ?? 'shown', placement,
+            diagnostics: before ? [{ code: 'captions.run.anchor-window', severity: 'warning', message: '発火を表示窓の始まりへ寄せました。' }] : [] };
+    };
+    if (anchor.domain === 'output')
+        return [clip(anchor.start, anchor.end, caption.start, caption.end)];
+    const src = anchor.src ?? caption.src;
+    const placements = map.segments.filter(segment => segment.kind === 'src' && segment.src === src
+        && segment.in !== undefined && segment.out !== undefined && segment.in < caption.end && segment.out > caption.start);
+    if (anchor.end <= caption.start && placements.length)
+        return placements.map(segment => ({
+            start: segment.outStart + (Math.max(caption.start, segment.in) - segment.in)
+                / (segment.speed && segment.speed > 0 ? segment.speed : 1),
+            fire: fire ?? 'shown', placement: segment.cutIndex ?? undefined,
+            diagnostics: [{ code: 'captions.run.anchor-window', severity: 'warning',
+                    message: '発火を表示窓の始まりへ寄せました。' }]
+        }));
+    if (anchor.start >= caption.end && placements.length)
+        return placements.map(segment => ({
+            fire: 'none', placement: segment.cutIndex ?? undefined,
+            diagnostics: [{ code: 'captions.run.anchor-window', severity: 'warning',
+                    message: '発火が表示窓の後にあります。' }]
+        }));
+    const results = [];
+    for (const segment of placements) {
+        const speed = segment.speed && segment.speed > 0 ? segment.speed : 1;
+        const windowStart = segment.outStart + (Math.max(caption.start, segment.in) - segment.in) / speed;
+        const windowEnd = segment.outStart + (Math.min(caption.end, segment.out) - segment.in) / speed;
+        const sourceStart = Math.max(anchor.start, segment.in);
+        const sourceEnd = Math.min(anchor.end, segment.out);
+        if (!(sourceStart < sourceEnd))
+            continue;
+        const result = clip(segment.outStart + (sourceStart - segment.in) / speed, segment.outStart + (sourceEnd - segment.in) / speed, windowStart, windowEnd, segment.cutIndex ?? undefined);
+        if (anchor.start < Math.max(caption.start, segment.in) && !result.diagnostics.length) {
+            result.diagnostics.push({ code: 'captions.run.anchor-window', severity: 'warning',
+                message: '発火を表示窓の始まりへ寄せました。' });
+        }
+        results.push(result);
+    }
+    return results.length ? results : [warning('captions.run.anchor-cut', '発火する素材の区間がカットで消えました。')];
+}
+function anchorForCaptionRange(caption, from, to, displayToSource) {
+    const unmapped = { diagnostics: [{ code: 'captions.run.anchor-unmapped', severity: 'info',
+                message: '選んだ文字を実測の単語に対応付けられません。' }] };
+    const words = caption.words ?? [];
+    if (words.map(word => word.text).join('') !== caption.text)
+        return unmapped;
+    const display = caption.display_text ?? caption.text;
+    const shown = (0, caption_runs_1.captionGraphemes)(display);
+    const source = (0, caption_runs_1.captionGraphemes)(caption.text);
+    if (from < 0 || to > shown.length || from >= to)
+        return unmapped;
+    const mapping = displayToSource ?? (display === caption.text ? undefined
+        : inferCaptionDisplayToSource(display, caption.text));
+    const start = display === caption.text ? from : mapping?.[from];
+    const end = display === caption.text ? to : mapping?.[to];
+    if (start === undefined || end === undefined || start < 0 || end > source.length || start >= end)
+        return unmapped;
+    let offset = 0;
+    const overlapping = words.filter(word => {
+        const wordStart = offset;
+        offset += (0, caption_runs_1.captionGraphemes)(word.text).length;
+        return wordStart < end && offset > start;
+    });
+    if (!overlapping.length)
+        return unmapped;
+    return { anchor: { ...(caption.src ? { src: caption.src } : {}),
+            start: overlapping[0].start, end: overlapping[overlapping.length - 1].end,
+            domain: caption.time_domain === 'output' ? 'output' : 'source' }, diagnostics: [] };
+}
+/** 表示と原文の一致箇所から、置換の両端を含む境界対応を作る。 */
+function inferCaptionDisplayToSource(display, source) {
+    const shown = (0, caption_runs_1.captionGraphemes)(display);
+    const original = (0, caption_runs_1.captionGraphemes)(source);
+    const dp = Array.from({ length: shown.length + 1 }, () => new Uint32Array(original.length + 1));
+    for (let i = shown.length - 1; i >= 0; i--)
+        for (let j = original.length - 1; j >= 0; j--) {
+            dp[i][j] = shown[i] === original[j] ? dp[i + 1][j + 1] + 1
+                : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    const map = Array(shown.length + 1).fill(undefined);
+    map[0] = 0;
+    map[shown.length] = original.length;
+    let i = 0;
+    let j = 0;
+    while (i < shown.length && j < original.length) {
+        if (shown[i] === original[j]) {
+            map[i] = j;
+            map[i + 1] = j + 1;
+            i++;
+            j++;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1])
+            i++;
+        else
+            j++;
+    }
+    return map;
+}
+function fitCaptionMotionWindow(fireAt, endAt, inSeconds, outSeconds) {
+    const available = Math.max(0, endAt - fireAt);
+    if (!available)
+        return { inSeconds: 0, outSeconds: 0, loopSeconds: 0, active: false };
+    const total = Math.max(0, inSeconds) + Math.max(0, outSeconds);
+    const ratio = total > available ? available / total : 1;
+    return { inSeconds: inSeconds * ratio, outSeconds: outSeconds * ratio,
+        loopSeconds: total > available ? 0 : available - total, active: true };
+}

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

@@ -412,6 +412,19 @@ function resolveCaptionDisplay(captionsRoot, edit, options = {}) {
             const cueRuns = Array.isArray(sourceRuns)
                 ? (0, caption_runs_1.sliceCaptionRuns)(projectedCaptions[occurrence.caption_input_index].displayText, sourceRuns, group.charStart, group.charEnd)
                 : undefined;
+            const karaokeOffset = karaoke
+                ? captionDisplayGraphemes(projectedCaptions[occurrence.caption_input_index].displayText.slice(0, group.charStart)).length
+                : undefined;
+            const display = resolved.manual && !resolved.overflow
+                ? trimManualCueDisplay(group.lines, policy.locale, cueRuns, wordDisplay, karaokeOffset)
+                : {
+                    text,
+                    lines: group.lines,
+                    runs: cueRuns,
+                    words: wordDisplay?.words,
+                    wordStyles: wordDisplay?.wordStyles,
+                    karaokeOffset
+                };
             displayCues.push({
                 id: `${occurrence.source_cue_id}-occ-${String(occurrence.occurrence_index).padStart(4, '0')}-part-${index + 1}`,
                 source_cue_id: occurrence.source_cue_id,
@@ -422,20 +435,20 @@ function resolveCaptionDisplay(captionsRoot, edit, options = {}) {
                 fragment_count: groups.length,
                 start: group.start,
                 end: group.end,
-                text,
-                ...(cueRuns ? { runs: cueRuns } : {}),
-                ...(group.lines.length >= 2 ? { display_lines: group.lines } : {}),
-                units: measureCaptionUnits(text),
+                text: display.text,
+                ...(display.runs ? { runs: display.runs } : {}),
+                ...(display.lines.length >= 2 ? { display_lines: display.lines } : {}),
+                units: measureCaptionUnits(display.text),
                 line_override: resolved.manual,
                 ...(resolved.overflow ? { overflow: resolved.overflow } : {}),
                 ...(resolvedStyle ? { text_style: resolvedStyle } : {}),
                 ...(cueStyleVars ? { style_vars: cueStyleVars } : {}),
                 ...(styleResolution?.layout ? { layout: styleResolution.layout } : {}),
-                ...(wordDisplay ? { words: wordDisplay.words } : {}),
-                ...(wordDisplay?.wordStyles.length ? { word_styles: wordDisplay.wordStyles } : {}),
+                ...(display.words ? { words: display.words } : {}),
+                ...(display.wordStyles?.length ? { word_styles: display.wordStyles } : {}),
                 ...(karaoke ? {
                     style: 'karaoke',
-                    karaoke_offset: captionDisplayGraphemes(projectedCaptions[occurrence.caption_input_index].displayText.slice(0, group.charStart)).length
+                    karaoke_offset: display.karaokeOffset
                 } : {})
             });
         });
@@ -766,6 +779,58 @@ function buildCueWordDisplay(sourceWords, occurrence, charStart, charEnd, lines,
         wordStyles
     };
 }
+function trimManualCueDisplay(lines, locale, runs, wordDisplay, karaokeOffset) {
+    const kept = lines.map((line, index) => ({
+        start: index > 0 ? 0 : line.length - line.trimStart().length,
+        end: index < lines.length - 1 ? line.length : line.trimEnd().length
+    }));
+    const trimmedLines = lines.map((line, index) => line.slice(kept[index].start, kept[index].end));
+    if (lines.every((line, index) => line === trimmedLines[index])) {
+        return { text: joinCaptionLines(lines, locale), lines, runs,
+            words: wordDisplay?.words, wordStyles: wordDisplay?.wordStyles, karaokeOffset };
+    }
+    const graphemeBoundaries = [0];
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        let position = 0;
+        for (const grapheme of captionDisplayGraphemes(lines[lineIndex])) {
+            const visible = position >= kept[lineIndex].start
+                && position + grapheme.length <= kept[lineIndex].end;
+            graphemeBoundaries.push(graphemeBoundaries[graphemeBoundaries.length - 1] + (visible ? 1 : 0));
+            position += grapheme.length;
+        }
+    }
+    const trimmedRuns = runs?.flatMap(run => {
+        const from = graphemeBoundaries[run.from];
+        const to = graphemeBoundaries[run.to];
+        return from < to ? [{ ...run, from, to }] : [];
+    });
+    const wordPositions = lines.map(() => 0);
+    const retainedWords = [];
+    const wordBoundaries = [0];
+    for (const word of wordDisplay?.words ?? []) {
+        const position = wordPositions[word.line];
+        wordPositions[word.line] += word.text.length;
+        const start = Math.max(0, kept[word.line].start - position);
+        const end = Math.min(word.text.length, kept[word.line].end - position);
+        if (start < end)
+            retainedWords.push({ ...word, text: word.text.slice(start, end) });
+        wordBoundaries.push(retainedWords.length);
+    }
+    const wordStyles = wordDisplay?.wordStyles.flatMap(style => {
+        const from = wordBoundaries[style.from];
+        const to = wordBoundaries[style.to];
+        return from < to ? [{ ...style, from, to }] : [];
+    });
+    return {
+        text: joinCaptionLines(trimmedLines, locale),
+        lines: trimmedLines,
+        runs: trimmedRuns?.length ? trimmedRuns : undefined,
+        words: wordDisplay ? retainedWords : undefined,
+        wordStyles,
+        karaokeOffset: karaokeOffset === undefined ? undefined
+            : karaokeOffset + captionDisplayGraphemes(lines[0].slice(0, kept[0].start)).length
+    };
+}
 function roundOutputSecond(value) {
     return Number(value.toFixed(6));
 }
@@ -1501,14 +1566,14 @@ function validateManualFragments(caption, text, policy) {
     if (!Array.isArray(caption.display_fragments) || caption.display_fragments.length < 1 || caption.display_fragments.length > 6) {
         return overflow();
     }
-    if (caption.display_fragments.some((fragment) => !strictText(fragment))) {
+    if (caption.display_fragments.some((fragment) => !manualFragmentText(fragment))) {
         return overflow();
     }
     if (caption.display_fragments.join('') !== text) {
         return overflow();
     }
     for (const fragment of caption.display_fragments) {
-        if (measureCaptionUnits(fragment) > policy.max_line_units) {
+        if (measureCaptionUnits(fragment.trim()) > policy.max_line_units) {
             return overflow();
         }
     }
@@ -2616,6 +2681,9 @@ function compareDisplayCue(left, right) {
 function strictText(value) {
     return typeof value === 'string' && value.length > 0 && value.trim() === value && value.normalize('NFC') === value;
 }
+function manualFragmentText(value) {
+    return typeof value === 'string' && /\S/u.test(value) && value.normalize('NFC') === value;
+}
 function finiteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value);
 }

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

@@ -0,0 +1,2 @@
+/** 鍵を再帰的に整列した JSON を UTF-8 で SHA-256 にする。 */
+export declare function captionValueHash(value: unknown): string;

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captionValueHash = captionValueHash;
+/** 鍵を再帰的に整列した JSON を UTF-8 で SHA-256 にする。 */
+function captionValueHash(value) {
+    const sorted = (entry) => {
+        if (Array.isArray(entry))
+            return entry.map(sorted);
+        if (entry && typeof entry === 'object')
+            return Object.fromEntries(Object.keys(entry).sort().map(key => [key, sorted(entry[key])]));
+        return entry;
+    };
+    const bytes = new TextEncoder().encode(JSON.stringify(sorted(value)));
+    const length = Math.ceil((bytes.length + 9) / 64) * 64;
+    const padded = new Uint8Array(length);
+    padded.set(bytes);
+    padded[bytes.length] = 0x80;
+    const bitLength = BigInt(bytes.length) * 8n;
+    const view = new DataView(padded.buffer);
+    view.setUint32(length - 8, Number(bitLength >> 32n));
+    view.setUint32(length - 4, Number(bitLength & 0xffffffffn));
+    const constants = [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+    ];
+    const state = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+    const rotate = (n, bits) => (n >>> bits) | (n << (32 - bits));
+    const words = new Uint32Array(64);
+    for (let offset = 0; offset < length; offset += 64) {
+        for (let i = 0; i < 16; i++)
+            words[i] = view.getUint32(offset + i * 4);
+        for (let i = 16; i < 64; i++) {
+            const a = words[i - 15];
+            const b = words[i - 2];
+            words[i] = (words[i - 16] + (rotate(a, 7) ^ rotate(a, 18) ^ (a >>> 3))
+                + words[i - 7] + (rotate(b, 17) ^ rotate(b, 19) ^ (b >>> 10))) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, h] = state;
+        for (let i = 0; i < 64; i++) {
+            const first = (h + (rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25))
+                + ((e & f) ^ (~e & g)) + constants[i] + words[i]) >>> 0;
+            const second = ((rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22))
+                + ((a & b) ^ (a & c) ^ (b & c))) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + first) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (first + second) >>> 0;
+        }
+        for (const [index, value] of [a, b, c, d, e, f, g, h].entries())
+            state[index] = (state[index] + value) >>> 0;
+    }
+    return `sha256:${state.map(word => word.toString(16).padStart(8, '0')).join('')}`;
+}

package/vendor/packages/edit-store/lib/caption-look-reader.d.ts

@@ -0,0 +1,46 @@
+import { type CaptionRun } from './caption-runs';
+import { type TextstyleCatalog } from './caption-style-preset';
+type CaptionRow = Record<string, unknown> & {
+    id?: string;
+    start?: number;
+    end?: number;
+    text?: string;
+    display_text?: string;
+    src?: string;
+    runs?: CaptionRun[];
+    style_preset?: string;
+};
+type Emphasis = {
+    id: string;
+    src?: string;
+    t_start: number;
+    t_end: number;
+    word: string;
+    emotion: string;
+    style_hint?: string;
+    style_preset?: string;
+    [key: string]: unknown;
+};
+type CaptionsRoot = {
+    captions: CaptionRow[];
+    emphasis_words?: Emphasis[];
+    [key: string]: unknown;
+};
+export declare const CAPTION_EMPHASIS_MOTION: Readonly<Record<string, string>>;
+export declare function readCaptionLookV1(root: CaptionsRoot | CaptionRow[], catalog: TextstyleCatalog): {
+    captions: CaptionRow[];
+    notices: string[];
+};
+export declare function planCaptionLookMigration(captions: CaptionsRoot | CaptionRow[], catalog: TextstyleCatalog, _edit?: unknown): {
+    next: CaptionsRoot | CaptionRow[];
+    diff: Array<{
+        path: string;
+        before: unknown;
+        after: unknown;
+    }>;
+    unresolved: Emphasis[];
+    notices: string[];
+};
+/** Restore the renderer's legacy input without changing a legacy-only document. */
+export declare function captionRenderInputFromV1<T extends CaptionsRoot | CaptionRow[]>(root: T): T;
+export {};