akari-video 1.2.0 → 1.3.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akari-video",
-  "version": "1.2.0",
+  "version": "1.3.0-beta.1",
   "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": "1.2.0",
+  "version": "1.3.0-beta.1",
   "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/overlay-runtime/src/interaction.js

@@ -340,6 +340,96 @@ function elementBoxCompanions(style, parentStyle, width, height) {
   // テキスト編集で断片 HTML を保存するときに作者の元指定へ戻せるよう、初回値だけ保持する。
   const hitPolicyOriginalPointerEvents = new WeakMap();
   const hitPolicyAppliedContainers = new WeakSet();
+  const hitPolicyTimes = new WeakMap();
+  const staleHitPolicyContainers = new Set();
+  const pausedHitPolicyContainers = new Set();
+  let pausedHitPolicyTimer = null;
+  let lastPointerHitPolicyRefresh = -Infinity;
+
+  function hitPolicyOperationBusy() {
+    return Boolean(activeEdit || activeDrag || activeResize || activeRotate || activeLine
+      || marqueeFrame || pointerOwner != null);
+  }
+
+  function schedulePausedHitPolicyRefresh(delay = 120) {
+    if (typeof setTimeout !== 'function') return;
+    if (pausedHitPolicyTimer !== null) clearTimeout(pausedHitPolicyTimer);
+    pausedHitPolicyTimer = setTimeout(flushPausedHitPolicies, delay);
+  }
+
+  // runtime は可視コンテナの時刻だけを記録する。CSS の読み取りはここでは行わない。
+  function markOverlayHitPolicyStale(container, localTimeMs, paused = false, reentered = false,
+    animationReady = null) {
+    if (!container) return;
+    let state = hitPolicyTimes.get(container);
+    if (!state) {
+      state = { current: localTimeMs, measured: null, paused: null };
+      hitPolicyTimes.set(container, state);
+    }
+    const timeChanged = state.current !== localTimeMs;
+    const enteredPause = paused && state.paused !== true;
+    state.current = localTimeMs;
+    state.paused = paused;
+    if (reentered) {
+      state.measured = null;
+      hitPolicyAppliedContainers.delete(container);
+    }
+    if (state.measured !== localTimeMs) staleHitPolicyContainers.add(container);
+    // pause()/currentTime の pending 補正はこの tick の測定より後に解決し得る。
+    // 暫定 apply が stale を消しても、停止後の一回は別の印で必ず残す。
+    if (paused && (reentered || timeChanged || enteredPause)) pausedHitPolicyContainers.add(container);
+    if (!paused) pausedHitPolicyContainers.delete(container);
+    if (paused && pausedHitPolicyContainers.size) {
+      // スクラブ中は連続 tick をまとめ、停止後にポインタ無しで確定する。
+      schedulePausedHitPolicyRefresh();
+    }
+    if (paused && (reentered || timeChanged || enteredPause) && animationReady?.then) {
+      const expectedState = state;
+      animationReady.then(() => {
+        if (hitPolicyTimes.get(container) !== expectedState || !state.paused
+          || state.current !== localTimeMs) return;
+        // ready 後の currentTime 補正が 120ms の測定より遅れた場合も追い付く。
+        const alreadyRefreshed = !pausedHitPolicyContainers.has(container);
+        pausedHitPolicyContainers.add(container);
+        schedulePausedHitPolicyRefresh(alreadyRefreshed ? 0 : 120);
+      });
+    }
+  }
+
+  function flushPausedHitPolicies() {
+    pausedHitPolicyTimer = null;
+    if (pausedHitPolicyContainers.size === 0) return;
+    if (hitPolicyOperationBusy()) {
+      // 編集・ジェスチャーが終わるまで印を保持する。
+      pausedHitPolicyTimer = setTimeout(flushPausedHitPolicies, 120);
+      return;
+    }
+    refreshStaleHitPolicies(true);
+  }
+
+  function refreshStaleHitPolicies(includePaused = false) {
+    if (hitPolicyOperationBusy()) return false;
+    let refreshed = false;
+    const candidates = includePaused ? pausedHitPolicyContainers : staleHitPolicyContainers;
+    for (const container of candidates) {
+      if (includePaused) pausedHitPolicyContainers.delete(container);
+      if (!container.isConnected || container.style.visibility === 'hidden') {
+        staleHitPolicyContainers.delete(container);
+        continue;
+      }
+      invalidateOverlayHitPolicy(container);
+      applyOverlayHitPolicy(container);
+      refreshed = true;
+    }
+    return refreshed;
+  }
+
+  function forgetOverlayHitPolicyTracking(container) {
+    staleHitPolicyContainers.delete(container);
+    pausedHitPolicyContainers.delete(container);
+    hitPolicyTimes.delete(container);
+    hitPolicyAppliedContainers.delete(container);
+  }
 
   // overlay_write は操作順を保存する。selftest は今回の書き込みをこの記録から待つ。
   let writeTail = Promise.resolve();
@@ -982,7 +1072,8 @@ function elementBoxCompanions(style, parentStyle, width, height) {
 
   // 全画面の外側コンテナと断片ルートは素通しにし、実際に背景・枠・影・文字・置換要素を
   // 描く可視の子孫だけを拾う。data-akari-hit は最寄りの指定を配下へ継承し、機械判定より
-  // 優先する。字幕が 1,000 件級でも全件を走査しないよう、runtime の可視化時に一度だけ呼ぶ。
+  // 優先する。字幕が 1,000 件級でも全件を走査しないよう、runtime は可視コンテナの
+  // 初回・停止後・ポインタ入力時だけ適用し、再生 tick では時刻の印だけを付ける。
   function fragmentRootCoversContainer(element, container) {
     const rootRect = element.getBoundingClientRect();
     const containerRect = container.getBoundingClientRect();
@@ -1056,6 +1147,9 @@ function elementBoxCompanions(style, parentStyle, width, height) {
 
     for (const root of container.children) visit(root, null, true, true);
     hitPolicyAppliedContainers.add(container);
+    const state = hitPolicyTimes.get(container);
+    if (state) state.measured = state.current;
+    staleHitPolicyContainers.delete(container);
     updateShapeLineHitProxyWidths();
   }
 
@@ -1169,6 +1263,34 @@ function elementBoxCompanions(style, parentStyle, width, height) {
     }
   }
 
+  // 08-07 裁定: 背景は選択・削除できる。旧矩形フォールバックと違い、stage 面に
+  // 落ちたクリックで、全面を覆って自ら塗るルートだけを拾う。実際のヒット先が
+  // あるときは使わず 4680d90d8 の巻き込みを防ぎ、素通し規約は変えない。
+  function paintedStageOverlayAt(clientX, clientY) {
+    const candidates = [...stage.children]
+      .flatMap((container, index) => {
+        if (!isSelectable(container)) return [];
+        const value = Number.parseFloat(getComputedStyle(container).zIndex);
+        return [{ container, index, zIndex: Number.isFinite(value) ? value : 0 }];
+      })
+      .sort((a, b) => b.zIndex - a.zIndex || b.index - a.index);
+
+    for (const { container } of candidates) {
+      for (const root of container.children) {
+        if (root.hasAttribute("data-akari-interaction") || root.getAttribute("data-akari-hit") === "pass") continue;
+        const style = getComputedStyle(root);
+        if (style.display === "none" || Number(style.opacity) <= 0
+          || ["hidden", "collapse"].includes(style.visibility)
+          || !fragmentRootCoversContainer(root, container)
+          || !drawsOwnContent(root, style)) continue;
+        const rect = root.getBoundingClientRect();
+        if (clientX >= rect.left && clientX <= rect.right
+          && clientY >= rect.top && clientY <= rect.bottom) return container;
+      }
+    }
+    return null;
+  }
+
   function overlayForEvent(event) {
     const eventTargetOverlay = findOverlayContainer(event.target);
     if (eventTargetOverlay && !isSelectable(eventTargetOverlay)) {
@@ -1180,6 +1302,11 @@ function elementBoxCompanions(style, parentStyle, width, height) {
     ) {
       return selftestOverlayOverride;
     }
+    if (event.target === stage && !eventTargetOverlay
+      && Number.isFinite(event.clientX) && Number.isFinite(event.clientY)) {
+      const paintedOverlay = paintedStageOverlayAt(event.clientX, event.clientY);
+      if (paintedOverlay) return paintedOverlay;
+    }
     return isSelectable(eventTargetOverlay) ? eventTargetOverlay : null;
   }
 
@@ -3983,6 +4110,7 @@ function elementBoxCompanions(style, parentStyle, width, height) {
 
   function onPointerDown(event) {
     if (!interactionEnabled || !canBeginPointerInteraction(pointerOwner)) return;
+    event = correctedHitPolicyEvent(event);
     if (event.button !== 0 || activeDrag || activeResize || activeRotate || activeLine) return;
     if (selectedId && stage && event.target instanceof Element) {
       const bounds = stage.getBoundingClientRect();
@@ -4833,6 +4961,7 @@ function elementBoxCompanions(style, parentStyle, width, height) {
 
   function onClick(event) {
     if (!interactionEnabled || activeEdit) return;
+    event = correctedHitPolicyEvent(event);
     const hit = overlayForEvent(event);
     // pointerdown already toggled. Do not toggle twice or update the cycle clock.
     if (event.shiftKey && clickOrigin?.scopedHit) {
@@ -5329,11 +5458,73 @@ function elementBoxCompanions(style, parentStyle, width, height) {
   for (const type of ["pointerdown", "pointerup", "click", "dblclick"]) {
     window.addEventListener(type, passTransparentCanvasEvent, true);
   }
+  const correctedHitPolicyEvents = new WeakMap();
+  let redirectedHitPolicyClick = null;
+  function pointerInsideStage(event) {
+    if (!stage || !Number.isFinite(event.clientX) || !Number.isFinite(event.clientY)) return false;
+    const rect = stage.getBoundingClientRect();
+    return event.clientX >= rect.left && event.clientX <= rect.right
+      && event.clientY >= rect.top && event.clientY <= rect.bottom;
+  }
+  function trustedEventAtTarget(event, target) {
+    // 合成 Event は isTrusted=false になり E2 の焦点を失う。元の信頼済み
+    // イベントを保ったまま、選択処理に見せる target だけ現在の hit-test にする。
+    return new Proxy(event, { get(original, key) {
+      if (key === 'target') return target;
+      const value = Reflect.get(original, key, original);
+      return typeof value === 'function' ? value.bind(original) : value;
+    } });
+  }
+  function correctHitPolicyEvent(event, target) {
+    correctedHitPolicyEvents.set(event, target);
+    // Window capture の後続ホストにも素の HTML hit と同じ target を見せる。
+    // Event 自体は元の信頼済みイベントなので、再生停止や混在選択は一度だけ走る。
+    try { Object.defineProperty(event, 'target', { configurable: true, value: target }); }
+    catch { /* document 側は WeakMap の target へフォールバックする。 */ }
+  }
+  function correctedHitPolicyEvent(event) {
+    const target = correctedHitPolicyEvents.get(event);
+    return target && event.target !== target ? trustedEventAtTarget(event, target) : event;
+  }
+  function stopCorrectedHitPolicyPropagation(event) {
+    // window のホスト捕捉は通し、古い preview-stage への下流だけ止める。
+    if (findOverlayContainer(correctedHitPolicyEvents.get(event))) event.stopPropagation();
+  }
+  window.addEventListener('pointermove', event => {
+    if (!pointerInsideStage(event) || !staleHitPolicyContainers.size
+      || hitPolicyOperationBusy()) return;
+    const now = performance.now();
+    if (now - lastPointerHitPolicyRefresh < 125) return;
+    if (!refreshStaleHitPolicies()) return;
+    lastPointerHitPolicyRefresh = now;
+    const target = document.elementFromPoint(event.clientX, event.clientY);
+    if (target && target !== event.target) correctHitPolicyEvent(event, target);
+  }, true);
+  window.addEventListener('pointerdown', event => {
+    if (event.button !== 0 || !pointerInsideStage(event) || hitPolicyOperationBusy()) return;
+    redirectedHitPolicyClick = null;
+    if (!refreshStaleHitPolicies()) return;
+    const target = document.elementFromPoint(event.clientX, event.clientY);
+    if (!target || target === event.target) return;
+    redirectedHitPolicyClick = { x: event.clientX, y: event.clientY };
+    correctHitPolicyEvent(event, target);
+  }, true);
+  window.addEventListener('click', event => {
+    if (!redirectedHitPolicyClick) return;
+    const redirect = redirectedHitPolicyClick;
+    redirectedHitPolicyClick = null;
+    if (Math.hypot(event.clientX - redirect.x, event.clientY - redirect.y) > 6) return;
+    const target = document.elementFromPoint(event.clientX, event.clientY);
+    if (!target || target === event.target) return;
+    correctHitPolicyEvent(event, target);
+  }, true);
   listenerRoot.addEventListener('pointermove', updateShapeLineHitProxyWidths, true);
   listenerRoot.addEventListener('pointerdown', updateShapeLineHitProxyWidths, true);
   window.addEventListener('resize', updateShapeLineHitProxyWidths);
   listenerRoot.addEventListener("click", onClick, true);
   listenerRoot.addEventListener("pointerdown", onPointerDown, true);
+  listenerRoot.addEventListener("click", stopCorrectedHitPolicyPropagation, true);
+  listenerRoot.addEventListener("pointerdown", stopCorrectedHitPolicyPropagation, true);
   listenerRoot.addEventListener("dblclick", onDoubleClick, true);
   listenerRoot.addEventListener("blur", onBlur, true);
   listenerRoot.addEventListener("input", onEditableInput, true);
@@ -5444,6 +5635,8 @@ function elementBoxCompanions(style, parentStyle, width, height) {
     // ㉑ 素通し: overlay-runtime.js の tick() が可視化タイミングで呼ぶ。
     applyOverlayHitPolicy,
     invalidateOverlayHitPolicy,
+    markOverlayHitPolicyStale,
+    forgetOverlayHitPolicyTracking,
     syncOverlayHitRegion,
     // Web UI（preview-server）が編集モードを抜けるときに選択枠を畳むための公開口
     // （Phase 2-4 一本化。shell では未使用の追加 export で挙動不変）。

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

@@ -341,6 +341,7 @@ function createOverlayRuntime(options = {}) {
 
   function unmount() {
     for (const overlay of mountedOverlays) {
+      window.akari.interaction?.forgetOverlayHitPolicyTracking?.(overlay.container);
       for (const animation of overlay.animations ?? []) releaseAnimation(animation);
       for (const runtime of overlayRuntimes(overlay)) runtime.dispose(overlay.container);
     }
@@ -490,6 +491,7 @@ function createOverlayRuntime(options = {}) {
         runtimesVersion: runtimeRegistryVersion,
         keepLayoutWhenHidden,
         hitPolicyPending: false,
+        hitPolicyEntry: false,
         // getAnimations({ subtree: true }) の 250ms キャッシュ（tick() 参照）
         animations: undefined,
         animationsAt: 0,
@@ -574,6 +576,7 @@ function createOverlayRuntime(options = {}) {
       }
       mounted.container.style.setProperty("opacity", String(statics.opacity));
       mounted.hitPolicyPending = true;
+      mounted.hitPolicyEntry = true;
       mounted.statics = statics;
       mounted.keyframes = Array.isArray(value.keyframes) ? value.keyframes : undefined;
       mounted.fps = finiteNumber(summary?.output?.fps, 30);
@@ -595,6 +598,7 @@ function createOverlayRuntime(options = {}) {
     mounted.animationsAt = 0;
     mounted.animationEndTimes = [];
     mounted.hitPolicyPending = true;
+    mounted.hitPolicyEntry = true;
     return true;
   }
 
@@ -636,7 +640,14 @@ function createOverlayRuntime(options = {}) {
         // することで、実際に存在する CSS Animation を「今可視のオーバーレイ分だけ」に
         // 抑え、この地雷を踏まない。
         overlay.container.toggleAttribute("data-akari-active", visible);
+        if (!visible && !isPlaying && overlay.animations?.length) {
+          // 停止中の連続シークが同一描画フレームで外→内へ戻っても、CSS が
+          // inactive を一度観測するようにする。これが無いとゲートの off/on が
+          // 相殺され、新しい Animation が生成されず初期 opacity 0 に残る。
+          void overlay.container.offsetWidth;
+        }
         overlay.hitPolicyPending = visible;
+        overlay.hitPolicyEntry = visible;
         // getAnimations() のキャッシュ（下記）は可視化フリップで必ず捨てる。ゲート属性の付け外しで
         // CSS animation の顔ぶれが変わるため、可視化直後の tick は引き直す。非表示化でも捨て、
         // 非可視の間 Animation 参照を持ち越さない。
@@ -650,6 +661,7 @@ function createOverlayRuntime(options = {}) {
         overlay.animationsAt = 0;
         overlay.animationEndTimes = [];
         if (!visible) {
+          window.akari.interaction?.forgetOverlayHitPolicyTracking?.(overlay.container);
           if (!overlay.keepLayoutWhenHidden) {
             overlay.container.setAttribute(RUNTIME_HIDDEN_ATTRIBUTE, "");
           }
@@ -762,15 +774,18 @@ function createOverlayRuntime(options = {}) {
         runtime.render(overlay.container, localTimeMs / 1000,
           { syncVideos: true, maxRenderSize, playing: Boolean(playing) });
       }
-      // opacity と clip-path は現在時刻へ合わせ、可視な間は入場アニメの終了まで毎 tick
-      // 測り直す。フリップ時だけでは通常再生の localTimeMs がほぼ 0 となり、0% 姿勢の
-      // bbox が焼き付くため。キャッシュした有限アニメの終端とローカル時刻で確定を判断する。
-      // 終わった tick で確定する。以後は呼ばず、無限ループも終端無しとして数えないので、
-      // 対象を可視オーバーレイだけにする性能原則「見えている分だけ」は維持される。
+      const ready = !isPlaying
+        ? overlay.animations.map(animation => pendingReady.get(animation)).filter(Boolean) : [];
+      window.akari.interaction?.markOverlayHitPolicyStale?.(
+        overlay.container, localTimeMs, !isPlaying, overlay.hitPolicyEntry,
+        ready.length ? Promise.allSettled(ready) : null);
+      overlay.hitPolicyEntry = false;
+      // 初回の仮判定と有限アニメ終端の確定判定だけをここで適用する。
+      // 途中の姿は上の時刻印を使い、停止後またはポインタ入力時に interaction が
+      // 必要な可視コンテナだけ測り直す。終端 tick が存在しない断片も停止後に更新される。
       if (overlay.hitPolicyPending) {
         window.akari.interaction?.syncOverlayHitRegion?.(overlay.container);
-        // 当たり判定ポリシーは初回適用が WeakSet でガードされるため、ここでの再呼び出しは
-        // 実質 no-op（暫定適用）。確定姿勢に達した tick で invalidate してから測り直す。
+        // 初回以外は WeakSet のガードで no-op。再入場時は時刻印側が解除する。
         window.akari.interaction?.applyOverlayHitPolicy?.(overlay.container);
         if (entryAnimationsSettled(overlay.animationEndTimes, localTimeMs)) {
           window.akari.interaction?.invalidateOverlayHitPolicy?.(overlay.container);