akari-video 0.1.86 → 0.1.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "0.1.86",
+  "version": "0.1.87",
   "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.86",
+  "version": "0.1.87",
   "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/asset-resolver/test/service-urls.test.mjs

@@ -20,7 +20,7 @@ test('tracked sources and documentation cannot reintroduce the retired domain',
     'packages/akari-launcher/src/service-urls.cjs',
     'packages/asset-resolver/test/service-urls.test.mjs',
   ]);
-  const files = execFileSync('git', ['ls-files', '-z'], { cwd: repo, encoding: 'utf8' }).split('\0').filter(Boolean);
+  const files = execFileSync('git', ['ls-files', '-z'], { cwd: repo, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }).split('\0').filter(Boolean);
   const targets = files.filter(file => {
     // Evidence and changelogs record historical observations, not current defaults.
     if (/(^|\/)evidence\//.test(file) || /(^|\/)CHANGELOG[^/]*$/i.test(file)) return false;

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

@@ -7,7 +7,6 @@ const transform_1 = require("./transform");
 const transform_keyframe_edit_1 = require("./transform-keyframe-edit");
 const item_motion_js_1 = require("../../overlay-runtime/src/item-motion.js");
 const motion_keyframe_replace_1 = require("./motion-keyframe-replace");
-const motion_position_write_1 = require("./motion-position-write");
 const isRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 const recordOf = (value) => isRecord(value) ? value : {};
 const stringifyEdit = (value) => `${JSON.stringify(value, undefined, 2)}\n`;
@@ -130,19 +129,10 @@ function resolveV2Write(parsed, command) {
         const seconds = command.playheadSeconds;
         const positionOnly = Object.keys(patch).length > 0
             && Object.keys(patch).every(key => key === 'x' || key === 'y');
-        if (positionOnly) {
+        if (positionOnly || Number.isFinite(seconds)) {
             const start = [...target.ancestors, item].reduce((sum, entry) => sum + entry.at, 0);
             const frame = Number.isFinite(seconds)
                 ? Math.max(0, Math.min(item.duration, Math.round(seconds * edit.output.fps) - start)) : 0;
-            const updated = (0, motion_position_write_1.writeItemPositionAt)(item, frame, patch);
-            item.transform = updated.transform;
-            item.keyframes = updated.keyframes;
-            return;
-        }
-        if (Number.isFinite(seconds) && Array.isArray(item.keyframes)
-            && item.keyframes.some(point => point.transform)) {
-            const start = [...target.ancestors, item].reduce((sum, entry) => sum + entry.at, 0);
-            const frame = Math.round(seconds * edit.output.fps) - start;
             const updated = (0, transform_keyframe_edit_1.writeItemTransformAt)(item, frame, patch);
             item.transform = updated.transform;
             item.keyframes = updated.keyframes;
@@ -219,7 +209,8 @@ function resolveV2Write(parsed, command) {
                 throw new Error(`グループアイテムには HTML 本文・vars・HTML params を書き戻せません: ${itemId}`);
             }
             if (command.patch.xyKeyframes)
-                item.keyframes = (0, motion_keyframe_replace_1.replaceXYKeyframes)(item.keyframes, command.patch.xyKeyframes, item.duration);
+                item.keyframes = (0, transform_keyframe_edit_1.normalizeItemKeyframeGroup)({ ...item,
+                    keyframes: (0, motion_keyframe_replace_1.replaceXYKeyframes)(item.keyframes, command.patch.xyKeyframes, item.duration) }, 'position').keyframes;
             if (command.patch.transform)
                 writeTransform(command.patch.transform);
             if (!command.patch.transform && !command.patch.xyKeyframes)
@@ -264,13 +255,15 @@ function resolveV2Write(parsed, command) {
             editChanged = true;
         }
         if (command.patch.xyKeyframes) {
-            item.keyframes = (0, motion_keyframe_replace_1.replaceXYKeyframes)(item.keyframes, command.patch.xyKeyframes, item.duration);
+            item.keyframes = (0, transform_keyframe_edit_1.normalizeItemKeyframeGroup)({ ...item,
+                keyframes: (0, motion_keyframe_replace_1.replaceXYKeyframes)(item.keyframes, command.patch.xyKeyframes, item.duration) }, 'position').keyframes;
             editChanged = true;
         }
     }
     else if (command.kind === 'layer') {
         if (command.patch.xyKeyframes) {
-            item.keyframes = (0, motion_keyframe_replace_1.replaceXYKeyframes)(item.keyframes, command.patch.xyKeyframes, item.duration);
+            item.keyframes = (0, transform_keyframe_edit_1.normalizeItemKeyframeGroup)({ ...item,
+                keyframes: (0, motion_keyframe_replace_1.replaceXYKeyframes)(item.keyframes, command.patch.xyKeyframes, item.duration) }, 'position').keyframes;
             editChanged = true;
         }
         if (command.patch.transform) {
@@ -298,7 +291,8 @@ function resolveV2Write(parsed, command) {
             throw new Error(`映像アイテムではありません: ${itemId}`);
         }
         if (command.patch.xyKeyframes) {
-            item.keyframes = (0, motion_keyframe_replace_1.replaceXYKeyframes)(item.keyframes, command.patch.xyKeyframes, item.duration);
+            item.keyframes = (0, transform_keyframe_edit_1.normalizeItemKeyframeGroup)({ ...item,
+                keyframes: (0, motion_keyframe_replace_1.replaceXYKeyframes)(item.keyframes, command.patch.xyKeyframes, item.duration) }, 'position').keyframes;
             editChanged = true;
         }
         if (command.patch.transform) {

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

@@ -42,3 +42,16 @@ export { LegacyEditVersionError } from './migrate/error';
 export * from './adjust-css-visual';
 export { effectiveScale, normalizeTransform } from './transform';
 export * from './transform-keyframe-edit';
+export declare const SAVED_BY_PATH = ".akari/saved-by.json";
+export interface SavedByStamp {
+    version: 1;
+    app: 'akari-video';
+    appVersion: string;
+    savedAt: string;
+}
+export declare function parseSavedBy(text: string | undefined): SavedByStamp | undefined;
+export declare function newerSavedByVersion(text: string | undefined, currentVersion: string | undefined): string | undefined;
+export declare function isUnknownKeyEditError(error: unknown): boolean;
+export declare function newerVersionOpenNotice(savedVersion: string, currentVersion: string): string;
+export declare function newerVersionLintPrefix(savedVersion: string): string;
+export declare function withNewerVersionLintPrefix(message: string, savedVersion?: string): string;

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

@@ -14,7 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeTransform = exports.effectiveScale = exports.LegacyEditVersionError = exports.parseEdit = void 0;
+exports.SAVED_BY_PATH = exports.normalizeTransform = exports.effectiveScale = exports.LegacyEditVersionError = exports.parseEdit = void 0;
+exports.parseSavedBy = parseSavedBy;
+exports.newerSavedByVersion = newerSavedByVersion;
+exports.isUnknownKeyEditError = isUnknownKeyEditError;
+exports.newerVersionOpenNotice = newerVersionOpenNotice;
+exports.newerVersionLintPrefix = newerVersionLintPrefix;
+exports.withNewerVersionLintPrefix = withNewerVersionLintPrefix;
 /**
  * ブラウザ安全なエントリポイント（テキスト手術のみ）。
  * lint ゲート付き書き込み（Node 専用）は './write-gate' を明示的に import すること
@@ -67,3 +73,56 @@ var transform_1 = require("./transform");
 Object.defineProperty(exports, "effectiveScale", { enumerable: true, get: function () { return transform_1.effectiveScale; } });
 Object.defineProperty(exports, "normalizeTransform", { enumerable: true, get: function () { return transform_1.normalizeTransform; } });
 __exportStar(require("./transform-keyframe-edit"), exports);
+// write-gate.ts の SAVED_BY_PATH と同値に保つ。
+exports.SAVED_BY_PATH = '.akari/saved-by.json';
+const SAVED_BY_SCHEMA_VERSION = 1;
+function parseSavedBy(text) {
+    if (!text)
+        return undefined;
+    try {
+        const value = JSON.parse(text);
+        if (!value || typeof value !== 'object')
+            return undefined;
+        const stamp = value;
+        return stamp.version === SAVED_BY_SCHEMA_VERSION && stamp.app === 'akari-video'
+            && typeof stamp.appVersion === 'string' && /^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(stamp.appVersion)
+            && typeof stamp.savedAt === 'string' && !Number.isNaN(Date.parse(stamp.savedAt))
+            ? stamp : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function compareSavedByVersions(left, right) {
+    const leftParts = left.trim().match(/^(\d+)\.(\d+)\.(\d+)/);
+    const rightParts = right.trim().match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!leftParts || !rightParts)
+        return 0;
+    for (let i = 1; i <= 3; i++) {
+        const a = Number(leftParts[i]);
+        const b = Number(rightParts[i]);
+        if (a !== b)
+            return a < b ? -1 : 1;
+    }
+    return 0;
+}
+function newerSavedByVersion(text, currentVersion) {
+    const savedVersion = parseSavedBy(text)?.appVersion;
+    return savedVersion && currentVersion && compareSavedByVersions(savedVersion, currentVersion) > 0
+        ? savedVersion : undefined;
+}
+function isUnknownKeyEditError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /edit\.json[^\n]*未定義キーを使用できません/.test(message);
+}
+function newerVersionOpenNotice(savedVersion, currentVersion) {
+    return `このプロジェクトは新しい版の AKARI Video（v${savedVersion}）で保存されています。`
+        + `いまの版（v${currentVersion}）では開けない機能が使われています。AKARI Video を更新してください。`;
+}
+function newerVersionLintPrefix(savedVersion) {
+    return `このプロジェクトは新しい版（v${savedVersion}）で保存されています。`
+        + 'いまの版の検証は新しい機能を知らないため、誤ってエラーを出すことがあります。';
+}
+function withNewerVersionLintPrefix(message, savedVersion) {
+    return savedVersion ? `${newerVersionLintPrefix(savedVersion)} ${message}` : message;
+}

package/vendor/packages/edit-store/lib/motion-position-write.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeItemPositionAt = writeItemPositionAt;
+const transform_keyframe_edit_1 = require("./transform-keyframe-edit");
 /** A direct move writes only the requested position axes at the item-local frame. */
 function writeItemPositionAt(item, frame, position) {
     if (!Number.isInteger(frame) || frame < 0 || frame > item.duration
@@ -9,18 +10,5 @@ function writeItemPositionAt(item, frame, position) {
             || !Number.isFinite(position[axis]))) {
         throw new Error('位置または時刻が正しくありません');
     }
-    const copy = structuredClone(item);
-    if (Array.isArray(copy.keyframes) && copy.keyframes.length >= 2) {
-        let point = copy.keyframes.find(entry => entry.t === frame);
-        if (!point) {
-            point = { t: frame };
-            copy.keyframes.push(point);
-            copy.keyframes.sort((left, right) => left.t - right.t);
-        }
-        point.transform = { ...point.transform, ...position };
-    }
-    else {
-        copy.transform = { ...copy.transform, ...position };
-    }
-    return copy;
+    return (0, transform_keyframe_edit_1.writeItemTransformAt)(item, frame, position);
 }

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

@@ -2,8 +2,23 @@ import type { ItemV2, TransformV2 } from './edit-v2';
 export type TransformField = 'x' | 'y' | 'scale' | 'scaleX' | 'scaleY' | 'rotate';
 /** Effective local pose, in pixels, unitless scale factors, and degrees. */
 export declare function evaluatedItemTransform(item: Pick<ItemV2, 'source' | 'transform' | 'keyframes' | 'duration'>, frame: number): Required<TransformV2>;
+export type ItemKeyframeGroup = 'position' | 'size' | 'rotation' | 'opacity';
+export declare function hasItemKeyframeGroup(item: Pick<ItemV2, 'keyframes'>, group: ItemKeyframeGroup): boolean;
 export declare function hasTransformKeyframe(item: Pick<ItemV2, 'keyframes'>, field: TransformField): boolean;
-/** Toggle-on: seed the currently visible pose; media points are complete because the cut evaluator replaces a whole transform. */
+/** The same declared-point/hold/interpolation rule as the transform evaluator. */
+export declare function evaluatedItemOpacity(item: Pick<ItemV2, 'opacity' | 'keyframes' | 'duration'>, frame: number): number;
+/** Backfill old sparse points only when this group is written. Values are read before mutation. */
+export declare function normalizeItemKeyframeGroup(item: ItemV2, group: ItemKeyframeGroup): ItemV2;
+/** Add one visible-pose point. A lone group point also becomes its static value. */
+export declare function activateItemKeyframeGroup(item: ItemV2, frame: number, group: ItemKeyframeGroup): ItemV2;
+/** Item-wide diamond: all four groups share one playhead point and one item result. */
+export declare function activateItemKeyframe(item: ItemV2, frame: number): ItemV2;
 export declare function activateItemTransformKeyframe(item: ItemV2, frame: number, field: TransformField): ItemV2;
-/** One gesture produces one updated item; only animated coordinates receive a point at the playhead. */
+/** A gesture returns one updated item; every animated group auto-keys at the playhead. */
 export declare function writeItemTransformAt(item: ItemV2, frame: number, input: TransformV2): ItemV2;
+export declare function writeItemOpacityAt(item: ItemV2, frame: number, opacity: number): ItemV2;
+/** Removing the last group point freezes the pose visible immediately before deletion. */
+export declare function removeItemKeyframeGroup(item: ItemV2, frame: number, group: ItemKeyframeGroup): ItemV2;
+/** Timeline point deletion is deliberately whole-point, independent of the selected row. */
+export declare function removeItemKeyframePoint(item: ItemV2, frame: number): ItemV2;
+export declare function moveItemKeyframeGroup(item: ItemV2, fromFrame: number, toFrame: number, group: ItemKeyframeGroup): ItemV2;

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

@@ -1,11 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluatedItemTransform = evaluatedItemTransform;
+exports.hasItemKeyframeGroup = hasItemKeyframeGroup;
 exports.hasTransformKeyframe = hasTransformKeyframe;
+exports.evaluatedItemOpacity = evaluatedItemOpacity;
+exports.normalizeItemKeyframeGroup = normalizeItemKeyframeGroup;
+exports.activateItemKeyframeGroup = activateItemKeyframeGroup;
+exports.activateItemKeyframe = activateItemKeyframe;
 exports.activateItemTransformKeyframe = activateItemTransformKeyframe;
 exports.writeItemTransformAt = writeItemTransformAt;
+exports.writeItemOpacityAt = writeItemOpacityAt;
+exports.removeItemKeyframeGroup = removeItemKeyframeGroup;
+exports.removeItemKeyframePoint = removeItemKeyframePoint;
+exports.moveItemKeyframeGroup = moveItemKeyframeGroup;
 const FIELDS = ['x', 'y', 'scale', 'scaleX', 'scaleY', 'rotate'];
-const DEFAULTS = { x: 0, y: 0, scale: 1, scaleX: 1, scaleY: 1, rotate: 0 };
 const finite = (value) => typeof value === 'number' && Number.isFinite(value);
 const isMedia = (item) => item.source.kind === 'media';
 const pointsOf = (item) => Array.isArray(item.keyframes) ? item.keyframes.slice().sort((a, b) => a.t - b.t) : [];
@@ -92,8 +100,6 @@ function valueAt(points, frame, field, fallback, media, statics) {
         if (!finite(value) && (field === 'scaleX' || field === 'scaleY')) {
             value = transform.scale ?? (media ? statics[field] ?? statics.scale ?? 1 : fallback);
         }
-        if (!finite(value) && media)
-            value = DEFAULTS[field];
         return finite(value) ? [{ point, value }] : [];
     });
     if (!declared.length)
@@ -122,15 +128,59 @@ function evaluatedItemTransform(item, frame) {
         scaleY: staticValue.scaleY ?? staticValue.scale ?? 1, rotate: staticValue.rotate ?? 0
     };
     const points = pointsOf(item), media = isMedia(item);
-    if (points.length < 2 || !points.some(point => point.transform))
+    if (!points.some(point => point.transform))
         return base;
     const at = frameOf(item, frame);
     return Object.fromEntries(FIELDS.map(field => [field,
-        valueAt(points, at, field, media && field !== 'scaleX' && field !== 'scaleY'
-            ? DEFAULTS[field] : base[field], media, staticValue)]));
+        valueAt(points, at, field, base[field], media, staticValue)]));
+}
+const GROUP_FIELDS = {
+    position: ['x', 'y'], size: ['scale', 'scaleX', 'scaleY'], rotation: ['rotate']
+};
+const groupOf = (field) => field === 'x' || field === 'y' ? 'position'
+    : field === 'rotate' ? 'rotation' : 'size';
+const declares = (point, group) => group === 'opacity'
+    ? finite(point.opacity) : GROUP_FIELDS[group].some(field => finite(point.transform?.[field]));
+const groupPoints = (item, group) => pointsOf(item).filter(point => declares(point, group));
+const hasPointValue = (point) => Object.entries(point)
+    .some(([key, value]) => key !== 't' && key !== 'easing' && value !== undefined);
+function legalPointArray(item, points) {
+    const meaningful = points.filter(hasPointValue).sort((a, b) => a.t - b.t);
+    if (!meaningful.length)
+        return undefined;
+    if (meaningful.length > 1)
+        return meaningful;
+    // The existing file schema requires two array entries. This empty entry has no animated
+    // property; every evaluator and diamond list ignores it.
+    const t = meaningful[0].t < item.duration ? meaningful[0].t + 1 : meaningful[0].t - 1;
+    return [...meaningful, { t }].sort((a, b) => a.t - b.t);
+}
+function hasItemKeyframeGroup(item, group) {
+    return groupPoints(item, group).length > 0;
 }
 function hasTransformKeyframe(item, field) {
-    return pointsOf(item).some(point => finite(point.transform?.[field]));
+    return hasItemKeyframeGroup(item, groupOf(field));
+}
+/** The same declared-point/hold/interpolation rule as the transform evaluator. */
+function evaluatedItemOpacity(item, frame) {
+    const points = groupPoints(item, 'opacity');
+    const fallback = item.opacity ?? 1;
+    if (!points.length)
+        return fallback;
+    const at = frameOf(item, frame);
+    if (at <= points[0].t)
+        return points[0].opacity;
+    const last = points[points.length - 1];
+    if (at >= last.t)
+        return last.opacity;
+    for (let index = 1; index < points.length; index++) {
+        const right = points[index], left = points[index - 1];
+        if (at > right.t)
+            continue;
+        const u = eased(right, 'opacity', (at - left.t) / (right.t - left.t || 1), false);
+        return left.opacity + (right.opacity - left.opacity) * u;
+    }
+    return fallback;
 }
 function validPatch(patch) {
     for (const [field, value] of Object.entries(patch)) {
@@ -147,76 +197,166 @@ function normalizedAxisPatch(current, patch) {
     const ratio = previous > 0 ? patch.scale / previous : 1;
     return { ...patch, scaleX: current.scaleX * ratio, scaleY: current.scaleY * ratio };
 }
+function valuesAt(item, frame, group) {
+    if (group === 'opacity')
+        return evaluatedItemOpacity(item, frame);
+    const pose = evaluatedItemTransform(item, frame);
+    if (group === 'position')
+        return { x: pose.x, y: pose.y };
+    if (group === 'rotation')
+        return { rotate: pose.rotate };
+    return { scale: pose.scale, scaleX: pose.scaleX, scaleY: pose.scaleY };
+}
+function withStaticGroup(item, group, value) {
+    if (group === 'opacity')
+        return { ...item, opacity: value };
+    return { ...item, transform: { ...item.transform, ...value } };
+}
+/** Backfill old sparse points only when this group is written. Values are read before mutation. */
+function normalizeItemKeyframeGroup(item, group) {
+    const keyframes = pointsOf(item).map(point => {
+        const copy = structuredClone(point);
+        if (!declares(point, group))
+            return copy;
+        const value = valuesAt(item, point.t, group);
+        if (group === 'opacity')
+            copy.opacity = value;
+        else
+            copy.transform = { ...copy.transform, ...value };
+        return copy;
+    });
+    return keyframes.length ? { ...item, keyframes } : item;
+}
 function fullMediaPoint(item, point) {
     if (!point.transform)
         return { ...point };
     return { ...point, transform: evaluatedItemTransform(item, point.t) };
 }
-/** Toggle-on: seed the currently visible pose; media points are complete because the cut evaluator replaces a whole transform. */
-function activateItemTransformKeyframe(item, frame, field) {
-    const at = frameOf(item, frame), before = evaluatedItemTransform(item, at);
-    const points = pointsOf(item);
-    if (hasTransformKeyframe(item, field) && points.some(point => point.t === at && finite(point.transform?.[field])))
-        return item;
-    const next = points.map(point => isMedia(item) ? fullMediaPoint(item, point) : { ...point });
-    const value = isMedia(item) ? { ...before } : field === 'scale'
-        ? { scale: Math.sqrt(before.scaleX * before.scaleY), scaleX: before.scaleX, scaleY: before.scaleY }
-        : { [field]: before[field] };
-    const seat = next.find(point => point.t === at);
-    if (seat)
-        seat.transform = { ...seat.transform, ...value };
-    else
-        next.push({ t: at, transform: value });
-    if (next.length === 1) {
-        next.push({ t: at === 0 ? item.duration : 0, transform: { ...value } });
+function addGroupPoint(item, frame, group, value) {
+    const at = frameOf(item, frame);
+    const normalized = normalizeItemKeyframeGroup(item, group);
+    const keyframes = pointsOf(normalized).map(point => isMedia(item) ? fullMediaPoint(normalized, point) : structuredClone(point));
+    let seat = keyframes.find(point => point.t === at);
+    if (!seat) {
+        seat = { t: at };
+        keyframes.push(seat);
     }
-    return { ...item, keyframes: next.sort((a, b) => a.t - b.t) };
+    if (group === 'opacity') {
+        seat.opacity = value;
+        if (isMedia(item))
+            seat.transform = evaluatedItemTransform(item, at);
+    }
+    else
+        seat.transform = { ...(isMedia(item) ? evaluatedItemTransform(item, at) : seat.transform),
+            ...value };
+    return { ...normalized, keyframes: legalPointArray(item, keyframes) };
+}
+/** Add one visible-pose point. A lone group point also becomes its static value. */
+function activateItemKeyframeGroup(item, frame, group) {
+    const at = frameOf(item, frame);
+    const hadGroup = hasItemKeyframeGroup(item, group);
+    const value = valuesAt(item, at, group);
+    if (groupPoints(item, group).some(point => point.t === at))
+        return normalizeItemKeyframeGroup(item, group);
+    const updated = addGroupPoint(item, at, group, value);
+    return hadGroup ? updated : withStaticGroup(updated, group, value);
+}
+/** Item-wide diamond: all four groups share one playhead point and one item result. */
+function activateItemKeyframe(item, frame) {
+    return ['position', 'size', 'rotation', 'opacity']
+        .reduce((current, group) => activateItemKeyframeGroup(current, frame, group), item);
 }
-/** One gesture produces one updated item; only animated coordinates receive a point at the playhead. */
+function activateItemTransformKeyframe(item, frame, field) {
+    return activateItemKeyframeGroup(item, frame, groupOf(field));
+}
+function patchedGroupValue(item, frame, group, patch) {
+    const current = evaluatedItemTransform(item, frame);
+    if (group === 'position')
+        return { x: patch.x ?? current.x, y: patch.y ?? current.y };
+    if (group === 'rotation')
+        return { rotate: patch.rotate ?? current.rotate };
+    const adjusted = normalizedAxisPatch(current, patch);
+    const scaleX = adjusted.scaleX ?? current.scaleX, scaleY = adjusted.scaleY ?? current.scaleY;
+    return { scale: Math.sqrt(scaleX * scaleY), scaleX, scaleY };
+}
+function writeGroup(item, frame, group, patch) {
+    const value = patchedGroupValue(item, frame, group, patch);
+    if (!hasItemKeyframeGroup(item, group))
+        return withStaticGroup(item, group, value);
+    const initialPoint = groupPoints(item, group)[0];
+    const updated = addGroupPoint(item, frame, group, value);
+    return groupPoints(item, group).length === 1
+        ? withStaticGroup(updated, group, valuesAt(updated, initialPoint.t, group)) : updated;
+}
+/** A gesture returns one updated item; every animated group auto-keys at the playhead. */
 function writeItemTransformAt(item, frame, input) {
     validPatch(input);
-    const at = frameOf(item, frame), current = evaluatedItemTransform(item, at);
-    const patch = normalizedAxisPatch(current, input);
-    const animated = new Set(FIELDS.filter(field => hasTransformKeyframe(item, field)));
-    if (patch.scale !== undefined && (animated.has('scaleX') || animated.has('scaleY')))
-        animated.add('scale');
-    if (animated.has('scale')) {
-        animated.add('scaleX');
-        animated.add('scaleY');
-    }
-    const base = { ...item.transform };
-    const pointPatch = {};
-    for (const field of FIELDS) {
-        const value = patch[field];
-        if (value === undefined)
-            continue;
-        if (animated.has(field))
-            pointPatch[field] = value;
-        else
-            base[field] = value;
-    }
-    if (patch.scaleX !== undefined || patch.scaleY !== undefined) {
-        if (animated.has('scale')) {
-            pointPatch.scaleX ??= current.scaleX;
-            pointPatch.scaleY ??= current.scaleY;
+    return [...new Set(Object.keys(input).map(field => groupOf(field)))].reduce((current, group) => writeGroup(current, frame, group, input), item);
+}
+function writeItemOpacityAt(item, frame, opacity) {
+    if (!finite(opacity) || opacity < 0 || opacity > 1)
+        throw new Error('Invalid opacity');
+    if (!hasItemKeyframeGroup(item, 'opacity'))
+        return withStaticGroup(item, 'opacity', opacity);
+    const initialPoint = groupPoints(item, 'opacity')[0];
+    const updated = addGroupPoint(item, frame, 'opacity', opacity);
+    return groupPoints(item, 'opacity').length === 1
+        ? withStaticGroup(updated, 'opacity', valuesAt(updated, initialPoint.t, 'opacity')) : updated;
+}
+/** Removing the last group point freezes the pose visible immediately before deletion. */
+function removeItemKeyframeGroup(item, frame, group) {
+    const at = frameOf(item, frame);
+    if (!groupPoints(item, group).some(point => point.t === at))
+        return item;
+    const before = valuesAt(item, at, group);
+    const normalized = normalizeItemKeyframeGroup(item, group);
+    const keyframes = pointsOf(normalized).map(point => {
+        const copy = structuredClone(point);
+        if (copy.t !== at)
+            return copy;
+        if (group === 'opacity')
+            delete copy.opacity;
+        else if (copy.transform) {
+            for (const field of GROUP_FIELDS[group])
+                delete copy.transform[field];
+            if (!Object.keys(copy.transform).length)
+                delete copy.transform;
         }
-        const x = pointPatch.scaleX ?? base.scaleX ?? base.scale ?? current.scaleX;
-        const y = pointPatch.scaleY ?? base.scaleY ?? base.scale ?? current.scaleY;
-        if (animated.has('scale'))
-            pointPatch.scale = Math.sqrt(x * y);
-        else if (base.scaleX !== undefined || base.scaleY !== undefined)
-            base.scale = Math.sqrt(x * y);
-    }
-    let keyframes = pointsOf(item);
-    if (Object.keys(pointPatch).length) {
-        keyframes = keyframes.map(point => isMedia(item) ? fullMediaPoint(item, point) : { ...point });
-        let seat = keyframes.find(point => point.t === at);
-        if (!seat) {
-            seat = { t: at };
-            keyframes.push(seat);
+        return copy;
+    }).filter(point => point.transform || point.opacity !== undefined || point.crop || point.perspective
+        || point.animator || point.gain_db !== undefined);
+    let updated = { ...normalized, keyframes: legalPointArray(item, keyframes) };
+    const remaining = groupPoints(updated, group);
+    if (!remaining.length)
+        updated = withStaticGroup(updated, group, before);
+    else if (remaining.length === 1)
+        updated = withStaticGroup(updated, group, valuesAt(normalized, remaining[0].t, group));
+    return updated;
+}
+/** Timeline point deletion is deliberately whole-point, independent of the selected row. */
+function removeItemKeyframePoint(item, frame) {
+    const at = frameOf(item, frame);
+    const point = pointsOf(item).find(entry => entry.t === at);
+    if (!point)
+        return item;
+    const values = ['position', 'size', 'rotation', 'opacity']
+        .filter(group => declares(point, group)).map(group => [group, valuesAt(item, at, group)]);
+    const keyframes = pointsOf(item).filter(entry => entry.t !== at).map(entry => structuredClone(entry));
+    let updated = { ...item, keyframes: legalPointArray(item, keyframes) };
+    for (const [group, value] of values)
+        if (!hasItemKeyframeGroup(updated, group)) {
+            updated = withStaticGroup(updated, group, value);
         }
-        seat.transform = { ...(isMedia(item) ? current : seat.transform), ...pointPatch };
-        keyframes.sort((a, b) => a.t - b.t);
-    }
-    return { ...item, transform: base, ...(keyframes.length ? { keyframes } : {}) };
+    return updated;
+}
+function moveItemKeyframeGroup(item, fromFrame, toFrame, group) {
+    const from = frameOf(item, fromFrame), to = frameOf(item, toFrame);
+    if (from === to)
+        return item;
+    const point = groupPoints(item, group).find(entry => entry.t === from);
+    if (!point)
+        return item;
+    const value = valuesAt(item, from, group);
+    const removed = removeItemKeyframeGroup(item, from, group);
+    return addGroupPoint(removed, to, group, value);
 }

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

@@ -16,6 +16,7 @@
  * 編集不能より lint なし保存の方が被害が小さいという判断（型不正は各書き込みの
  * ローカル検証が別途残るため安全側は保たれる）。
  */
+export declare const SAVED_BY_PATH = ".akari/saved-by.json";
 export interface EditLintFinding {
     severity?: string;
     message?: string;
@@ -30,6 +31,8 @@ export interface EditLintGateResult {
 /** 候補ファイル名（プロジェクト直下からの相対パス）→ 書き込み予定の全文。null は不在扱い。 */
 export type LintCandidates = Record<string, string | null>;
 export interface DeferredLintOptions {
+    /** edit.json を保存した AKARI Video の版。不明なら既存スタンプを消す。 */
+    appVersion?: string;
     debounceMs?: number;
     onLintResult?: (result: EditLintGateResult) => void | Promise<void>;
     /** Deterministic test seam; production callers use runEditLint. */
@@ -77,6 +80,10 @@ export declare function lintProjectCandidates(projectRoot: string, candidates: L
 export declare function lintProjectCandidatesOnDisk(projectRoot: string, candidates: LintCandidates, hooks?: ShadowLintHooks): Promise<EditLintGateResult>;
 /** 互換 API。保存後 lint への移行後も、明示的に検証したい呼び出し側向けに残す。 */
 export declare function assertLintPasses(projectRoot: string, candidates: LintCandidates): Promise<void>;
+/** CLI / preview-server 等のプロセス内で書き手の版を 1 回だけ設定する。 */
+export declare function setDefaultSavedByAppVersion(version: string | undefined): void;
+/** CLI の既存 edit.json 保存直後に、スタンプだけを atomic に更新する。 */
+export declare function writeSavedByStamp(projectRoot: string, appVersion: string | undefined): Promise<void>;
 /** atomic 保存を即時完了し、lint は末尾 debounce で非同期に実行する。 */
 export declare function writeProjectFilesGuarded(projectRoot: string, candidates: LintCandidates, options?: DeferredLintOptions): Promise<void>;
 /** Web UI 旧版が生成した camelCase は schema が閉じていない legacy edit でも保存させない。 */

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

@@ -18,9 +18,12 @@
  * ローカル検証が別途残るため安全側は保たれる）。
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAVED_BY_PATH = void 0;
 exports.lintProjectCandidates = lintProjectCandidates;
 exports.lintProjectCandidatesOnDisk = lintProjectCandidatesOnDisk;
 exports.assertLintPasses = assertLintPasses;
+exports.setDefaultSavedByAppVersion = setDefaultSavedByAppVersion;
+exports.writeSavedByStamp = writeSavedByStamp;
 exports.writeProjectFilesGuarded = writeProjectFilesGuarded;
 exports.assertNoCamelCaseTransitionOut = assertNoCamelCaseTransitionOut;
 exports.scheduleProjectLint = scheduleProjectLint;
@@ -32,6 +35,16 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const url_1 = require("url");
 const os_1 = require("os");
+// index.ts の SAVED_BY_PATH と同値に保つ（Node 専用入口は index を import しない）。
+exports.SAVED_BY_PATH = '.akari/saved-by.json';
+const SAVED_BY_SCHEMA_VERSION = 1;
+const APP_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/;
+function isValidSavedByAppVersion(version) {
+    return typeof version === 'string' && APP_VERSION_PATTERN.test(version);
+}
+function serializeSavedByStamp(appVersion, savedAt = new Date().toISOString()) {
+    return `${JSON.stringify({ version: SAVED_BY_SCHEMA_VERSION, app: 'akari-video', appVersion, savedAt }, null, 2)}\n`;
+}
 /**
  * 「OS / ファイルシステムがリンク作成自体を拒んだ」エラーコード。入力が誤っている系
  * （EEXIST・ENOENT・ENOTDIR 等）は含めない — それらは従来どおり throw して原因を隠さない。
@@ -183,6 +196,22 @@ async function assertLintPasses(projectRoot, candidates) {
         throw new Error(result.errors[0] ?? 'edit-lint が変更を拒否しました');
     }
 }
+let defaultSavedByAppVersion;
+/** CLI / preview-server 等のプロセス内で書き手の版を 1 回だけ設定する。 */
+function setDefaultSavedByAppVersion(version) {
+    defaultSavedByAppVersion = isValidSavedByAppVersion(version) ? version : undefined;
+}
+/** CLI の既存 edit.json 保存直後に、スタンプだけを atomic に更新する。 */
+async function writeSavedByStamp(projectRoot, appVersion) {
+    const destination = (0, path_1.join)(projectRoot, exports.SAVED_BY_PATH);
+    if (isValidSavedByAppVersion(appVersion)) {
+        await writeAtomic(destination, serializeSavedByStamp(appVersion));
+    }
+    else {
+        // 版不明の書き手は、以前の書き手の版を主張できない。
+        await fs_1.promises.rm(destination, { force: true });
+    }
+}
 /** atomic 保存を即時完了し、lint は末尾 debounce で非同期に実行する。 */
 async function writeProjectFilesGuarded(projectRoot, candidates, options = {}) {
     const editCandidate = candidates['edit.json'];
@@ -195,7 +224,17 @@ async function writeProjectFilesGuarded(projectRoot, candidates, options = {}) {
         }
         const destination = (0, path_1.join)(projectRoot, name);
         await writeAtomic(destination, text);
-        // rename 完了直後に同期で通知する。lint スケジュールより前に出すことで、
+        if (name === 'edit.json') {
+            const version = options.appVersion ?? defaultSavedByAppVersion;
+            if (isValidSavedByAppVersion(version)) {
+                await writeAtomic((0, path_1.join)(projectRoot, exports.SAVED_BY_PATH), serializeSavedByStamp(version));
+            }
+            else {
+                // An unknown writer cannot keep a previous writer's version claim.
+                await fs_1.promises.rm((0, path_1.join)(projectRoot, exports.SAVED_BY_PATH), { force: true });
+            }
+        }
+        // edit.json とスタンプの rename が完了したら同期で通知する。lint スケジュールより前に出すことで、
         // 購読側が watcher（実測 42〜1183ms のばらつき）を待たずに済む。
         if (options.onDidWrite) {
             try {

package/vendor/packages/overlay-runtime/src/interaction.js

@@ -3,6 +3,21 @@
 window.akari = window.akari || {};
 
 window.akari.interaction = (() => {
+// A pointer gesture belongs to one controller at a time.
+function canBeginPointerInteraction(owner) { return owner == null; }
+let pointerOwner = null;
+function setPointerOwner(owner) {
+  if (owner == null) { pointerOwner = null; return; }
+  if (pointerOwner != null && pointerOwner !== owner) return false;
+  pointerOwner = owner;
+  return true;
+}
+function releasePointerOwner(owner) {
+  if (pointerOwner !== owner) return false;
+  pointerOwner = null;
+  return true;
+}
+
 // BEGIN selection-scope
 function lineage(tree, id) {
   const nodes = new Map(tree.map(node => [node.id, node]));
@@ -144,6 +159,20 @@ function marqueeHits(candidates, rect) {
   let activeDrag = null;
   let activeResize = null;
   let activeRotate = null;
+  function reportLiveValues(id, values, clear = false) {
+    if (!id || typeof window.akari?.reportLiveValues !== 'function') return;
+    window.akari.reportLiveValues({ id, ...(clear ? { clear: true } : { values }) });
+  }
+  function reportLivePose(gesture) {
+    if (!gesture || !gesture.moved) return;
+    const pose = gesture.group
+      ? gesture.pose ?? { ...gesture.transform, x: gesture.startX + gesture.dx,
+        y: gesture.startY + gesture.dy }
+      : readTransform(gesture.container);
+    reportLiveValues(gesture.overlayId, { x: pose.x, y: pose.y,
+      scale: pose.scale, scaleX: pose.scaleX ?? pose.scale,
+      scaleY: pose.scaleY ?? pose.scale, rotate: pose.rotate });
+  }
   let activeLine = null;
   let rotationBadge = null;
   let handleHint = null;
@@ -1588,6 +1617,7 @@ function marqueeHits(candidates, rect) {
     if (!activeDrag) return;
 
     const drag = activeDrag;
+    reportLiveValues(drag.overlayId, undefined, true);
     activeDrag = null;
     if (drag.group) {
       moveGroupMembers(drag, 0, 0);
@@ -2275,6 +2305,7 @@ function marqueeHits(candidates, rect) {
   function cancelRotate() {
     if (!activeRotate) return;
     const rotation = activeRotate;
+    reportLiveValues(rotation.overlayId, undefined, true);
     activeRotate = null;
     rotationBadge?.remove(); rotationBadge = null;
     document.body.style.cursor = '';
@@ -2620,6 +2651,7 @@ function marqueeHits(candidates, rect) {
     if (!activeResize) return;
 
     const resize = activeResize;
+    reportLiveValues(resize.overlayId, undefined, true);
     activeResize = null;
     handleHint?.remove(); handleHint = null;
     if (resize.group) {
@@ -2695,7 +2727,7 @@ function marqueeHits(candidates, rect) {
   }
 
   function onPointerDown(event) {
-    if (!interactionEnabled) return;
+    if (!interactionEnabled || !canBeginPointerInteraction(pointerOwner)) return;
     if (event.button !== 0 || activeDrag || activeResize || activeRotate || activeLine) return;
     if (selectedId && stage && event.target instanceof Element) {
       const bounds = stage.getBoundingClientRect();
@@ -2860,10 +2892,12 @@ function marqueeHits(candidates, rect) {
     }
     if (activeRotate && event.pointerId === activeRotate.pointerId) {
       updateRotate(event);
+      reportLivePose(activeRotate);
       return;
     }
     if (activeResize && event.pointerId === activeResize.pointerId) {
       updateResize(event);
+      reportLivePose(activeResize);
       return;
     }
 
@@ -2903,6 +2937,7 @@ function marqueeHits(candidates, rect) {
           ? { x: videoDeltaX, y: 0 }
           : event.shiftKey ? { x: 0, y: videoDeltaY } : { x: videoDeltaX, y: videoDeltaY });
       moveGroupDrag(drag, locked.x, locked.y, event.metaKey || event.ctrlKey, lockedAxis);
+      reportLivePose(drag);
       if (event.cancelable) event.preventDefault();
       return;
     }
@@ -2917,6 +2952,7 @@ function marqueeHits(candidates, rect) {
       event.metaKey || event.ctrlKey,
       lockedAxis
     );
+    reportLivePose(drag);
 
     if (event.cancelable) event.preventDefault();
   }
@@ -3374,6 +3410,7 @@ function marqueeHits(candidates, rect) {
   }
 
   function onKeyDown(event) {
+    if (!canBeginPointerInteraction(pointerOwner)) return;
     if (event.isComposing) return;
     if (handleNudge(event)) return;
     if (selectionTree().length) {
@@ -3825,6 +3862,11 @@ function marqueeHits(candidates, rect) {
   }
 
   return {
+    get pointerOwner() { return pointerOwner; },
+    get activePointerOperation() { return Boolean(activeDrag || activeResize || activeRotate || activeLine || marqueeFrame); },
+    canBeginPointerInteraction,
+    setPointerOwner,
+    releasePointerOwner,
     get selectedId() { return selectedId; },
     get selectedIds() { return [...selectedIds]; },
     get selectionKind() { return selectionKind(); },

package/vendor/packages/overlay-runtime/src/overlay-runtime.js

@@ -35,6 +35,12 @@ const PREVIEW_3D_MAX_RENDER_SIZE = 720;
 // getAnimations() 一覧のキャッシュ寿命（ms。app.js と同値）。詳細は tick() の注記。
 const ANIMATIONS_CACHE_MS = 250;
 
+// 再生中の CSS アニメは走らせたままにし、タイムラインとのずれがこの幅を超えたときだけ
+// currentTime を書き戻す（ms。出力 30fps の 1.5 フレーム相当）。詳細は syncAnimation() の注記。
+const PLAYBACK_DRIFT_MS = 50;
+// 再生速度の推定に使う最短の観測窓（ms）。これより短い区間の Δ時刻/Δ壁時計 はフレーム量子化で暴れる。
+const PLAYBACK_RATE_WINDOW_MS = 200;
+
 // maxRenderSize の正規化: 未指定 → 既定 720 / null・0・false → 無効（等倍） /
 // 正の有限数 → その値。それ以外の不正値（負数・NaN・文字列）は既定へ戻す。
 function resolveMaxRenderSize(value) {
@@ -130,6 +136,82 @@ function createOverlayRuntime(options = {}) {
     return true;
   }
 
+  // CSS アニメ 1 本をタイムラインのローカル時刻へ合わせる。
+  //
+  // 停止・スクラブ中は従来どおり pause + currentTime で毎 tick その時刻の姿勢に固定する
+  // （シーク後の絵の決定性はここで担保する）。
+  //
+  // 再生中は毎フレームのシークをやめ、Animation を走らせたまま（play）にする。毎フレーム
+  // currentTime を書くとアニメがメインスレッド駆動になり、拡大縮小を含む層が毎フレーム
+  // ラスタし直される（実測: CSS アニメ 339 本の合成断片で GPU ラスタ ~115 回/フレーム・
+  // 60Hz 表示で 30〜34fps。走らせたままにすると ~58fps・ラスタ 1/4.5）。ずれが
+  // PLAYBACK_DRIFT_MS を超えたとき（動画側の停滞・速度変更の直後など）だけ書き戻す。
+  //
+  // 有限アニメの終端以降は play() しない（finished な Animation への play() は先頭へ
+  // 巻き戻る）。pause して fill の姿勢で止め、以後は同じ値を書き直さない。
+  //
+  // 走っていた Animation の pause() / play() は次のフレームまで保留（pending）され、保留が
+  // 解けたときの時刻で currentTime が上書きされることがある（実測: 巻き戻し再生の直後に
+  // 止めると、まれに 1 フレーム 16.6ms 進んだ姿勢で止まる）。止めた時刻を pausedTargets に
+  // 記録し、保留が解けた（ready）後にもう一度書き戻す。再生へ戻ったら記録を消す。
+  const pausedTargets = new WeakMap();
+  function holdPausedTime(animation, localTimeMs) {
+    pausedTargets.set(animation, localTimeMs);
+    if (!animation.pending || !animation.ready?.then) return;
+    animation.ready.then(() => {
+      if (pausedTargets.get(animation) !== localTimeMs || animation.playState !== "paused") return;
+      if (Number(animation.currentTime) !== localTimeMs) animation.currentTime = localTimeMs;
+    }, () => {});
+  }
+
+  function syncAnimation(animation, localTimeMs, playing, playbackRate) {
+    const endTime = Number(animation.effect?.getComputedTiming?.().endTime);
+    const current = Number(animation.currentTime);
+    if (playing && !(localTimeMs >= endTime)) {
+      pausedTargets.delete(animation);
+      if (animation.playState !== "running") {
+        animation.currentTime = localTimeMs;
+        animation.playbackRate = playbackRate;
+        animation.play();
+        return;
+      }
+      if (animation.playbackRate !== playbackRate) animation.playbackRate = playbackRate;
+      if (!Number.isFinite(current) || Math.abs(current - localTimeMs) > PLAYBACK_DRIFT_MS) {
+        animation.currentTime = localTimeMs;
+      }
+      return;
+    }
+    if (playing && animation.playState === "paused" && current >= endTime) return;
+    if (animation.playState !== "paused") animation.pause();
+    if (current !== localTimeMs) animation.currentTime = localTimeMs;
+    holdPausedTime(animation, localTimeMs);
+  }
+
+  // 再生速度（タイムライン秒 / 壁時計秒）の推定。ホストは tick(t, playing) しか渡さないので、
+  // 再生中の連続 tick から測る。停止・逆行・大きな飛び（シーク）で観測をやり直す。
+  let playbackAnchor = null;
+  let playbackRate = 1;
+  function observePlaybackRate(timelineTime, playing, nowMs) {
+    if (!playing) {
+      playbackAnchor = null;
+      return playbackRate;
+    }
+    const expected = playbackAnchor
+      ? playbackAnchor.time + ((nowMs - playbackAnchor.wall) / 1000) * playbackRate
+      : timelineTime;
+    if (!playbackAnchor || timelineTime < playbackAnchor.time || Math.abs(timelineTime - expected) > 1) {
+      playbackAnchor = { time: timelineTime, wall: nowMs };
+      return playbackRate;
+    }
+    const elapsed = nowMs - playbackAnchor.wall;
+    if (elapsed >= PLAYBACK_RATE_WINDOW_MS) {
+      const measured = Math.round(((timelineTime - playbackAnchor.time) * 1000 / elapsed) * 20) / 20;
+      if (measured > 0 && Number.isFinite(measured)) playbackRate = measured;
+      playbackAnchor = { time: timelineTime, wall: nowMs };
+    }
+    return playbackRate;
+  }
+
   function unmount() {
     for (const overlay of mountedOverlays) {
       for (const runtime of renderingRuntimes(overlay.container)) runtime.dispose(overlay.container);
@@ -324,6 +406,7 @@ function createOverlayRuntime(options = {}) {
   function tick(t, playing) {
     const timelineTime = finiteNumber(t, 0);
     if (premount && !premountConfigured) applyPremountConfiguration();
+    const rate = observePlaybackRate(timelineTime, Boolean(playing), performance.now());
 
     for (const overlay of mountedOverlays) {
       const visible =
@@ -386,7 +469,7 @@ function createOverlayRuntime(options = {}) {
       // 総数」にほぼ比例する（上の注記）。断片のアニメは `[data-akari-active]` ゲートで宣言する
       // 規約なので、可視の間は顔ぶれが変わらない。毎 tick 引き直さず、可視化フリップ直後の
       // tick と 250ms ごとだけ引き直す（遅れて生える animation も拾える。app.js と同じ）。
-      // Animation オブジェクトはライブなので、キャッシュ済みでも pause / currentTime の書き込みと
+      // Animation オブジェクトはライブなので、キャッシュ済みでも syncAnimation() の書き込みと
       // 下の entryAnimationsSettled() の読み取りは現在値で動く。
       //
       // 3D 断片も必ずここを通す。three のシーンは three 側が時刻を持つ（mixer.setTime）が、
@@ -405,10 +488,7 @@ function createOverlayRuntime(options = {}) {
         overlay.animationsAt = nowMs;
       }
       const animations = overlay.animations;
-      for (const animation of animations) {
-        animation.pause();
-        animation.currentTime = localTimeMs;
-      }
+      for (const animation of animations) syncAnimation(animation, localTimeMs, Boolean(playing), rate);
       for (const runtime of renderingRuntimes(overlay.container)) {
         // playing はランタイム側の動画テクスチャの同期方式（再生中は <video> を走らせ、停止・スクラブ中はシーク）に使う
         runtime.render(overlay.container, localTimeMs / 1000, { syncVideos: true, maxRenderSize, playing: Boolean(playing) });