@xiboplayer/schedule 0.6.1 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiboplayer/schedule",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Complete scheduling solution: campaigns, dayparting, interrupts, and overlays",
   "type": "module",
   "main": "./src/index.js",
@@ -12,7 +12,7 @@
     "./overlays": "./src/overlays.js"
   },
   "dependencies": {
-    "@xiboplayer/utils": "0.6.1"
+    "@xiboplayer/utils": "0.6.3"
   },
   "devDependencies": {
     "vitest": "^2.0.0"

package/src/index.d.ts

@@ -14,6 +14,6 @@ export class ScheduleManager {
 
 export const scheduleManager: ScheduleManager;
 
-export function calculateTimeline(layouts: any[], durations: Map<string, number>, options?: any): any[];
-export function parseLayoutDuration(xlf: string): number;
+export function calculateTimeline(queue: Array<{layoutId: string, duration: number}>, queuePosition: number, options?: any): any[];
+export function parseLayoutDuration(xlf: string, videoDurations?: Map<string, number> | null): { duration: number; isDynamic: boolean };
 export function buildScheduleQueue(schedule: any, durations: Map<string, number>): any[];

package/src/schedule.dayparting.test.js

@@ -35,13 +35,8 @@ function getDifferentDay() {
 
 // Helper to mock Date at specific time
 function mockTimeAt(targetDate) {
-  const RealDate = Date;
-  vi.spyOn(global, 'Date').mockImplementation((...args) => {
-    if (args.length === 0) {
-      return new RealDate(targetDate);
-    }
-    return new RealDate(...args);
-  });
+  vi.useFakeTimers({ shouldAdvanceTime: false });
+  vi.setSystemTime(new Date(targetDate));
 }
 
 describe('ScheduleManager - Dayparting', () => {
@@ -50,14 +45,10 @@ describe('ScheduleManager - Dayparting', () => {
 
   beforeEach(() => {
     manager = new ScheduleManager();
-    originalDate = global.Date;
   });
 
   afterEach(() => {
-    // Restore Date
-    if (vi.isMockFunction(global.Date)) {
-      global.Date = originalDate;
-    }
+    vi.useRealTimers();
   });
 
   describe('Weekday Schedules', () => {

package/src/timeline.js

@@ -10,15 +10,22 @@
  * Parse layout duration from XLF XML string.
  * Lightweight parser — uses DOMParser, no rendering.
  *
+ * Single source of truth for XLF-based duration calculation.
+ * Supports a 3-phase progressive refinement pipeline:
+ *   Phase 1 (ESTIMATE):     parseLayoutDuration(xlf) — static duration from XLF
+ *   Phase 2 (PROBE):        parseLayoutDuration(xlf, videoDurations) — refined with real video lengths
+ *   Phase 3 (LIVE UPDATE):  renderer's updateLayoutDuration() — corrections from DURATION comments
+ *
  * Duration resolution order:
  *  1. Explicit <layout duration="60"> attribute
  *  2. Sum of widget <media duration="X"> per region (max across regions)
  *  3. Fallback: 60s
  *
  * @param {string} xlfXml - Raw XLF XML string
+ * @param {Map<string, number>|null} [videoDurations=null] - Optional map of fileId → probed duration in seconds
  * @returns {{ duration: number, isDynamic: boolean }} Duration in seconds and whether any widget has useDuration=0
  */
-export function parseLayoutDuration(xlfXml) {
+export function parseLayoutDuration(xlfXml, videoDurations = null) {
   const doc = new DOMParser().parseFromString(xlfXml, 'text/xml');
   const layoutEl = doc.querySelector('layout');
   if (!layoutEl) return { duration: 60, isDynamic: false };
@@ -31,18 +38,34 @@ export function parseLayoutDuration(xlfXml) {
   let maxDuration = 0;
   let isDynamic = false;
   for (const regionEl of layoutEl.querySelectorAll('region')) {
+    const regionType = regionEl.getAttribute('type');
+    if (regionType === 'drawer') continue; // Drawers are action-triggered, not timed
+    const isCanvas = regionType === 'canvas';
     let regionDuration = 0;
     for (const mediaEl of regionEl.querySelectorAll('media')) {
       const dur = parseInt(mediaEl.getAttribute('duration') || '0', 10);
       const useDuration = parseInt(mediaEl.getAttribute('useDuration') || '1', 10);
-      if (dur > 0 && useDuration !== 0) {
-        regionDuration += dur;
+      const fileId = mediaEl.getAttribute('fileId') || '';
+      const probed = videoDurations?.get(fileId);
+
+      let widgetDuration;
+      if (probed !== undefined) {
+        widgetDuration = probed;           // Phase 2: probed video duration
+      } else if (dur > 0 && useDuration !== 0) {
+        widgetDuration = dur;              // Explicit CMS duration
       } else {
         // Video with useDuration=0 means "play to end" — estimate 60s,
         // corrected later via recordLayoutDuration() when video metadata loads
-        regionDuration += 60;
+        widgetDuration = 60;
         isDynamic = true;
       }
+
+      if (isCanvas) {
+        // Canvas regions play all widgets simultaneously — duration is max, not sum
+        regionDuration = Math.max(regionDuration, widgetDuration);
+      } else {
+        regionDuration += widgetDuration;
+      }
     }
     maxDuration = Math.max(maxDuration, regionDuration);
   }
@@ -97,23 +120,6 @@ function canSimulatedPlay(history, maxPlaysPerHour, timeMs) {
   return true;
 }
 
-/**
- * Seed simulated play history from real play history.
- * Maps layoutId-based history to layoutFile-based history.
- * @param {Map<string, number[]>} realHistory - schedule.playHistory (layoutId → [timestamps])
- * @returns {Map<string, number[]>} layoutFile → [timestamps]
- */
-function seedPlayHistory(realHistory) {
-  const simulated = new Map();
-  if (!realHistory) return simulated;
-
-  for (const [layoutId, timestamps] of realHistory) {
-    const file = `${layoutId}.xlf`;
-    simulated.set(file, [...timestamps]);
-  }
-  return simulated;
-}
-
 /**
  * From a list of layout metadata, apply simulated rate limiting and priority
  * filtering to determine which layouts can actually play at the given time.
@@ -143,129 +149,63 @@ function getPlayableLayouts(allLayouts, simPlays, timeMs) {
 }
 
 /**
- * Calculate a deterministic playback timeline by simulating round-robin scheduling
- * with rate limiting (maxPlaysPerHour) and priority fallback. Produces a real
- * schedule prediction that matches actual player behavior.
+ * Calculate a deterministic playback timeline by walking the pre-built schedule queue.
  *
- * When high-priority layouts hit their maxPlaysPerHour limit, the simulation
- * falls back to lower-priority scheduled layouts before using the CMS default.
+ * The queue already has all constraints baked in (maxPlaysPerHour, priorities,
+ * dayparting, default layout fills). This function simply cycles through it from
+ * the current position, generating time-stamped entries for the overlay.
  *
- * @param {Object} schedule - ScheduleManager instance (needs getAllLayoutsAtTime(), schedule.default, playHistory)
- * @param {Map<string, number>} durations - Map of layoutFile → duration in seconds
+ * @param {Array<{layoutId: string, duration: number}>} queue - Pre-built schedule queue from buildScheduleQueue()
+ * @param {number} queuePosition - Current position in the queue (from schedule._queuePosition)
  * @param {Object} [options]
  * @param {Date}   [options.from]    - Start time (default: now)
- * @param {number} [options.hours]   - Hours to simulate (default: 2)
- * @param {number} [options.defaultDuration] - Fallback duration in seconds (default: 60)
+ * @param {number} [options.hours]   - Hours to project (default: 2)
+ * @param {string} [options.defaultLayout] - Default layout file (to tag isDefault entries)
+ * @param {Map<string, number>} [options.durations] - Live durations map (overrides queue entry durations with corrected values)
  * @param {Date}   [options.currentLayoutStartedAt] - When current layout started (adjusts first entry to remaining time)
  * @returns {Array<{layoutFile: string, startTime: Date, endTime: Date, duration: number, isDefault: boolean}>}
  */
-export function calculateTimeline(schedule, durations, options = {}) {
+export function calculateTimeline(queue, queuePosition, options = {}) {
   const from = options.from || new Date();
   const hours = options.hours || 2;
   const to = new Date(from.getTime() + hours * 3600000);
-  const defaultDuration = options.defaultDuration || 60;
   const currentLayoutStartedAt = options.currentLayoutStartedAt || null;
+  const defaultLayout = options.defaultLayout || null;
+  const durations = options.durations || null;
+
+  if (!queue || queue.length === 0) return [];
+
   const timeline = [];
   let currentTime = new Date(from);
+  let pos = queuePosition % queue.length;
   let isFirstEntry = true;
-
-  // Use getAllLayoutsAtTime if available (new API), fall back to getLayoutsAtTime (old API)
-  const hasFullApi = typeof schedule.getAllLayoutsAtTime === 'function';
-
-  // Seed simulated play history from real plays
-  const simPlays = seedPlayHistory(schedule.playHistory);
-
   const maxEntries = 500;
 
   while (currentTime < to && timeline.length < maxEntries) {
-    const timeMs = currentTime.getTime();
-    let playable;
-
-    let hiddenLayouts = null;
-
-    if (hasFullApi) {
-      // Full simulation: get ALL active layouts, apply rate limiting + priority
-      const allLayouts = schedule.getAllLayoutsAtTime(currentTime);
-      playable = allLayouts.length > 0
-        ? getPlayableLayouts(allLayouts, simPlays, timeMs)
-        : [];
-      // Detect hidden layouts (lower priority, not playing)
-      if (allLayouts.length > playable.length) {
-        hiddenLayouts = allLayouts
-          .filter(l => !playable.includes(l.file))
-          .map(l => ({ file: l.file, priority: l.priority }));
-      }
-    } else {
-      // Legacy fallback: no rate limiting simulation
-      playable = schedule.getLayoutsAtTime(currentTime);
+    const entry = queue[pos];
+    // Use live-corrected duration (from video metadata, etc.) if available,
+    // otherwise fall back to the queue's baked-in duration
+    let dur = (durations && durations.get(entry.layoutId)) || entry.duration;
+
+    // First entry: use remaining duration if we know when the current layout started
+    if (isFirstEntry && currentLayoutStartedAt) {
+      const elapsedSec = (from.getTime() - currentLayoutStartedAt.getTime()) / 1000;
+      dur = Math.max(1, Math.round(dur - elapsedSec));
+      isFirstEntry = false;
     }
 
-    if (playable.length === 0) {
-      // No playable layouts — use CMS default or skip ahead
-      const defaultFile = schedule.schedule?.default;
-      if (defaultFile) {
-        const dur = durations.get(defaultFile) || defaultDuration;
-        timeline.push({
-          layoutFile: defaultFile,
-          startTime: new Date(currentTime),
-          endTime: new Date(timeMs + dur * 1000),
-          duration: dur,
-          isDefault: true,
-        });
-        currentTime = new Date(timeMs + dur * 1000);
-      } else {
-        currentTime = new Date(timeMs + 60000);
-      }
-      continue;
-    }
+    const endMs = currentTime.getTime() + dur * 1000;
 
-    // Round-robin through playable layouts
-    for (let i = 0; i < playable.length && currentTime < to && timeline.length < maxEntries; i++) {
-      const file = playable[i];
-      let dur = durations.get(file) || defaultDuration;
-
-      // First entry: use remaining duration if we know when the current layout started
-      if (isFirstEntry && currentLayoutStartedAt) {
-        const elapsedSec = (from.getTime() - currentLayoutStartedAt.getTime()) / 1000;
-        const remaining = Math.max(1, Math.round(dur - elapsedSec));
-        dur = remaining;
-        isFirstEntry = false;
-      }
+    timeline.push({
+      layoutFile: entry.layoutId,
+      startTime: new Date(currentTime),
+      endTime: new Date(endMs),
+      duration: dur,
+      isDefault: defaultLayout ? entry.layoutId === defaultLayout : false,
+    });
 
-      const endMs = currentTime.getTime() + dur * 1000;
-
-      const entry = {
-        layoutFile: file,
-        startTime: new Date(currentTime),
-        endTime: new Date(endMs),
-        duration: dur,
-        isDefault: false,
-      };
-      if (hiddenLayouts && hiddenLayouts.length > 0) {
-        entry.hidden = hiddenLayouts;
-      }
-      timeline.push(entry);
-
-      // Record simulated play
-      if (hasFullApi) {
-        if (!simPlays.has(file)) simPlays.set(file, []);
-        simPlays.get(file).push(currentTime.getTime());
-      }
-
-      currentTime = new Date(endMs);
-
-      // Re-evaluate: if playable set changed, re-enter outer loop
-      if (hasFullApi) {
-        const nextAll = schedule.getAllLayoutsAtTime(currentTime);
-        const nextPlayable = nextAll.length > 0
-          ? getPlayableLayouts(nextAll, simPlays, currentTime.getTime())
-          : [];
-        if (!arraysEqual(playable, nextPlayable)) break;
-      } else {
-        const next = schedule.getLayoutsAtTime(currentTime);
-        if (!arraysEqual(playable, next)) break;
-      }
-    }
+    currentTime = new Date(endMs);
+    pos = (pos + 1) % queue.length;
   }
 
   return timeline;

package/src/timeline.test.js

@@ -0,0 +1,461 @@
+/**
+ * Timeline Calculator Tests
+ *
+ * Tests for calculateTimeline() — walks a pre-built queue to produce
+ * time-stamped playback predictions for the overlay.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { calculateTimeline, parseLayoutDuration } from './timeline.js';
+
+// Fixed "now" for deterministic tests
+const NOW = new Date('2026-03-03T10:00:00Z');
+
+// ── Tests ────────────────────────────────────────────────────────
+
+describe('calculateTimeline', () => {
+  describe('Basic queue walking', () => {
+    it('should produce entries from a single-entry queue', () => {
+      const queue = [{ layoutId: '100.xlf', duration: 30 }];
+
+      const timeline = calculateTimeline(queue, 0, {
+        from: NOW, hours: 0.1,
+      });
+
+      expect(timeline.length).toBeGreaterThan(0);
+      expect(timeline[0].layoutFile).toBe('100.xlf');
+      expect(timeline[0].duration).toBe(30);
+      expect(timeline[0].isDefault).toBe(false);
+    });
+
+    it('should tag default layout entries', () => {
+      const queue = [{ layoutId: 'default.xlf', duration: 45 }];
+
+      const timeline = calculateTimeline(queue, 0, {
+        from: NOW, hours: 0.1,
+        defaultLayout: 'default.xlf',
+      });
+
+      expect(timeline[0].layoutFile).toBe('default.xlf');
+      expect(timeline[0].isDefault).toBe(true);
+      expect(timeline[0].duration).toBe(45);
+    });
+
+    it('should cycle through multiple queue entries', () => {
+      const queue = [
+        { layoutId: '100.xlf', duration: 30 },
+        { layoutId: '200.xlf', duration: 45 },
+      ];
+
+      const timeline = calculateTimeline(queue, 0, {
+        from: NOW, hours: 0.1,
+      });
+
+      const files = timeline.map(e => e.layoutFile);
+      expect(files).toContain('100.xlf');
+      expect(files).toContain('200.xlf');
+      // Should alternate
+      expect(files[0]).toBe('100.xlf');
+      expect(files[1]).toBe('200.xlf');
+      expect(files[2]).toBe('100.xlf');
+    });
+
+    it('should use live durations map over queue baked-in durations', () => {
+      const queue = [{ layoutId: '100.xlf', duration: 60 }]; // queue says 60s
+      const durations = new Map([['100.xlf', 300]]); // video metadata says 300s
+
+      const timeline = calculateTimeline(queue, 0, {
+        from: NOW, hours: 0.5, durations,
+      });
+
+      expect(timeline[0].duration).toBe(300);
+      // Only ~6 entries in 30min at 300s each, not 30 at 60s
+      expect(timeline.length).toBeLessThanOrEqual(7);
+    });
+
+    it('should fall back to queue duration when not in durations map', () => {
+      const queue = [{ layoutId: '100.xlf', duration: 45 }];
+      const durations = new Map(); // empty
+
+      const timeline = calculateTimeline(queue, 0, {
+        from: NOW, hours: 0.1, durations,
+      });
+
+      expect(timeline[0].duration).toBe(45);
+    });
+
+    it('should start from the given queue position', () => {
+      const queue = [
+        { layoutId: '100.xlf', duration: 30 },
+        { layoutId: '200.xlf', duration: 30 },
+        { layoutId: '300.xlf', duration: 30 },
+      ];
+
+      const timeline = calculateTimeline(queue, 2, {
+        from: NOW, hours: 0.1,
+      });
+
+      expect(timeline[0].layoutFile).toBe('300.xlf');
+      expect(timeline[1].layoutFile).toBe('100.xlf');
+      expect(timeline[2].layoutFile).toBe('200.xlf');
+    });
+
+    it('should wrap queue position when past end', () => {
+      const queue = [
+        { layoutId: '100.xlf', duration: 30 },
+        { layoutId: '200.xlf', duration: 30 },
+      ];
+
+      const timeline = calculateTimeline(queue, 5, {
+        from: NOW, hours: 0.1,
+      });
+
+      // 5 % 2 = 1, so starts at 200.xlf
+      expect(timeline[0].layoutFile).toBe('200.xlf');
+      expect(timeline[1].layoutFile).toBe('100.xlf');
+    });
+  });
+
+  describe('currentLayoutStartedAt (remaining time adjustment)', () => {
+    it('should adjust first entry duration to remaining time', () => {
+      const queue = [{ layoutId: '100.xlf', duration: 60 }];
+
+      // Layout started 20 seconds ago → 40 seconds remaining
+      const startedAt = new Date(NOW.getTime() - 20000);
+
+      const timeline = calculateTimeline(queue, 0, {
+        from: NOW, hours: 0.5,
+        currentLayoutStartedAt: startedAt,
+      });
+
+      expect(timeline[0].duration).toBe(40); // 60 - 20 = 40
+    });
+
+    it('should clamp remaining time to at least 1 second', () => {
+      const queue = [{ layoutId: '100.xlf', duration: 30 }];
+
+      // Layout started 60 seconds ago but duration is only 30 → already overdue
+      const startedAt = new Date(NOW.getTime() - 60000);
+
+      const timeline = calculateTimeline(queue, 0, {
+        from: NOW, hours: 0.1,
+        currentLayoutStartedAt: startedAt,
+      });
+
+      expect(timeline[0].duration).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should only adjust first entry, not subsequent', () => {
+      const queue = [{ layoutId: '100.xlf', duration: 60 }];
+      const startedAt = new Date(NOW.getTime() - 20000);
+
+      const timeline = calculateTimeline(queue, 0, {
+        from: NOW, hours: 0.1,
+        currentLayoutStartedAt: startedAt,
+      });
+
+      expect(timeline[0].duration).toBe(40);
+      expect(timeline[1].duration).toBe(60); // Full duration
+    });
+  });
+
+  describe('Time boundaries', () => {
+    it('should not produce entries beyond the simulation window', () => {
+      const queue = [{ layoutId: '100.xlf', duration: 30 }];
+
+      const timeline = calculateTimeline(queue, 0, {
+        from: NOW, hours: 1,
+      });
+
+      const endOfWindow = new Date(NOW.getTime() + 3600000);
+      for (const entry of timeline) {
+        expect(entry.startTime.getTime()).toBeLessThan(endOfWindow.getTime());
+      }
+    });
+
+    it('should produce continuous timeline (no gaps between entries)', () => {
+      const queue = [
+        { layoutId: '100.xlf', duration: 30 },
+        { layoutId: '200.xlf', duration: 45 },
+      ];
+
+      const timeline = calculateTimeline(queue, 0, {
+        from: NOW, hours: 0.5,
+      });
+
+      for (let i = 1; i < timeline.length; i++) {
+        expect(timeline[i].startTime.getTime()).toBe(timeline[i - 1].endTime.getTime());
+      }
+    });
+
+    it('should handle a large number of entries without exceeding 500 cap', () => {
+      const queue = [{ layoutId: '100.xlf', duration: 5 }]; // 5s = many entries
+
+      const timeline = calculateTimeline(queue, 0, {
+        from: NOW, hours: 2,
+      });
+
+      expect(timeline.length).toBeLessThanOrEqual(500);
+    });
+  });
+
+  describe('Determinism', () => {
+    it('should produce identical output for identical inputs', () => {
+      const queue = [
+        { layoutId: '100.xlf', duration: 30 },
+        { layoutId: '200.xlf', duration: 45 },
+      ];
+
+      const t1 = calculateTimeline(queue, 0, { from: NOW, hours: 1 });
+      const t2 = calculateTimeline(queue, 0, { from: NOW, hours: 1 });
+
+      expect(t1.length).toBe(t2.length);
+      for (let i = 0; i < t1.length; i++) {
+        expect(t1[i].layoutFile).toBe(t2[i].layoutFile);
+        expect(t1[i].startTime.getTime()).toBe(t2[i].startTime.getTime());
+        expect(t1[i].endTime.getTime()).toBe(t2[i].endTime.getTime());
+        expect(t1[i].duration).toBe(t2[i].duration);
+      }
+    });
+
+    it('should produce DIFFERENT output when "from" time changes', () => {
+      const queue = [{ layoutId: '100.xlf', duration: 30 }];
+
+      const t1 = calculateTimeline(queue, 0, { from: NOW, hours: 1 });
+      const laterNow = new Date(NOW.getTime() + 300000); // 5 min later
+      const t2 = calculateTimeline(queue, 0, { from: laterNow, hours: 1 });
+
+      // Start times must differ because the anchor moved
+      expect(t1[0].startTime.getTime()).not.toBe(t2[0].startTime.getTime());
+    });
+
+    it('should produce DIFFERENT output when position changes', () => {
+      const queue = [
+        { layoutId: '100.xlf', duration: 30 },
+        { layoutId: '200.xlf', duration: 30 },
+      ];
+
+      const t1 = calculateTimeline(queue, 0, { from: NOW, hours: 0.1 });
+      const t2 = calculateTimeline(queue, 1, { from: NOW, hours: 0.1 });
+
+      expect(t1[0].layoutFile).toBe('100.xlf');
+      expect(t2[0].layoutFile).toBe('200.xlf');
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should return empty array for empty queue', () => {
+      const timeline = calculateTimeline([], 0, { from: NOW, hours: 1 });
+      expect(timeline).toEqual([]);
+    });
+
+    it('should return empty array for null queue', () => {
+      const timeline = calculateTimeline(null, 0, { from: NOW, hours: 1 });
+      expect(timeline).toEqual([]);
+    });
+
+    it('should handle mixed default and scheduled entries in queue', () => {
+      const queue = [
+        { layoutId: '100.xlf', duration: 30 },
+        { layoutId: 'default.xlf', duration: 60 },
+      ];
+
+      const timeline = calculateTimeline(queue, 0, {
+        from: NOW, hours: 0.1,
+        defaultLayout: 'default.xlf',
+      });
+
+      expect(timeline[0].isDefault).toBe(false);
+      expect(timeline[1].isDefault).toBe(true);
+    });
+  });
+});
+
+// ── parseLayoutDuration Tests ───────────────────────────────────
+
+/** Helper to build minimal XLF strings */
+function xlf({ duration = 0, regions = [] } = {}) {
+  const regionXml = regions.map(r => {
+    const type = r.type ? ` type="${r.type}"` : '';
+    const widgets = (r.widgets || []).map(w => {
+      const attrs = Object.entries(w).map(([k, v]) => `${k}="${v}"`).join(' ');
+      return `<media ${attrs}/>`;
+    }).join('');
+    return `<region${type}>${widgets}</region>`;
+  }).join('');
+  return `<layout duration="${duration}">${regionXml}</layout>`;
+}
+
+describe('parseLayoutDuration', () => {
+  describe('Basic duration parsing', () => {
+    it('should return explicit layout duration when set', () => {
+      const result = parseLayoutDuration(xlf({ duration: 120 }));
+      expect(result).toEqual({ duration: 120, isDynamic: false });
+    });
+
+    it('should fallback to 60s when no layout element exists', () => {
+      const result = parseLayoutDuration('<invalid/>');
+      expect(result).toEqual({ duration: 60, isDynamic: false });
+    });
+
+    it('should calculate max region duration from widgets', () => {
+      const result = parseLayoutDuration(xlf({
+        regions: [
+          { widgets: [
+            { duration: 30, useDuration: 1 },
+            { duration: 20, useDuration: 1 },
+          ]},
+          { widgets: [
+            { duration: 10, useDuration: 1 },
+          ]},
+        ],
+      }));
+      // Region 1: 30+20=50, Region 2: 10 → max=50
+      expect(result).toEqual({ duration: 50, isDynamic: false });
+    });
+
+    it('should estimate 60s for widgets with useDuration=0 and mark as dynamic', () => {
+      const result = parseLayoutDuration(xlf({
+        regions: [
+          { widgets: [{ duration: 0, useDuration: 0, fileId: 'v1' }] },
+        ],
+      }));
+      expect(result).toEqual({ duration: 60, isDynamic: true });
+    });
+
+    it('should fallback to 60s when all regions are empty', () => {
+      const result = parseLayoutDuration(xlf({ regions: [{ widgets: [] }] }));
+      expect(result).toEqual({ duration: 60, isDynamic: false });
+    });
+  });
+
+  describe('Drawer region skip', () => {
+    it('should skip drawer regions entirely', () => {
+      const result = parseLayoutDuration(xlf({
+        regions: [
+          { widgets: [{ duration: 30, useDuration: 1 }] },
+          { type: 'drawer', widgets: [{ duration: 300, useDuration: 1 }] },
+        ],
+      }));
+      // Only the non-drawer region counts: 30s
+      expect(result).toEqual({ duration: 30, isDynamic: false });
+    });
+
+    it('should fallback to 60s when only drawer regions exist', () => {
+      const result = parseLayoutDuration(xlf({
+        regions: [
+          { type: 'drawer', widgets: [{ duration: 120, useDuration: 1 }] },
+        ],
+      }));
+      expect(result).toEqual({ duration: 60, isDynamic: false });
+    });
+  });
+
+  describe('Canvas region duration (#186)', () => {
+    it('should use max widget duration for canvas regions (not sum)', () => {
+      const result = parseLayoutDuration(xlf({
+        regions: [
+          { type: 'canvas', widgets: [
+            { duration: 10, useDuration: 1 },
+            { duration: 30, useDuration: 1 },
+            { duration: 20, useDuration: 1 },
+          ]},
+        ],
+      }));
+      // Canvas: max(10, 30, 20) = 30, not sum(10+30+20) = 60
+      expect(result).toEqual({ duration: 30, isDynamic: false });
+    });
+
+    it('should use sum for normal regions alongside canvas', () => {
+      const result = parseLayoutDuration(xlf({
+        regions: [
+          { type: 'canvas', widgets: [
+            { duration: 10, useDuration: 1 },
+            { duration: 20, useDuration: 1 },
+          ]},
+          { widgets: [
+            { duration: 15, useDuration: 1 },
+            { duration: 25, useDuration: 1 },
+          ]},
+        ],
+      }));
+      // Canvas region: max(10, 20) = 20
+      // Normal region: sum(15+25) = 40
+      // Layout: max(20, 40) = 40
+      expect(result).toEqual({ duration: 40, isDynamic: false });
+    });
+  });
+
+  describe('videoDurations (Phase 2 probing)', () => {
+    it('should use probed duration when fileId matches', () => {
+      const videoDurations = new Map([['vid1', 45]]);
+      const result = parseLayoutDuration(xlf({
+        regions: [
+          { widgets: [{ duration: 0, useDuration: 0, fileId: 'vid1' }] },
+        ],
+      }), videoDurations);
+      expect(result).toEqual({ duration: 45, isDynamic: false });
+    });
+
+    it('should still estimate 60s for unmatched fileIds', () => {
+      const videoDurations = new Map([['other', 45]]);
+      const result = parseLayoutDuration(xlf({
+        regions: [
+          { widgets: [{ duration: 0, useDuration: 0, fileId: 'vid1' }] },
+        ],
+      }), videoDurations);
+      expect(result).toEqual({ duration: 60, isDynamic: true });
+    });
+
+    it('should return same result when videoDurations has no matching fileIds', () => {
+      const without = parseLayoutDuration(xlf({
+        regions: [
+          { widgets: [
+            { duration: 30, useDuration: 1 },
+            { duration: 0, useDuration: 0, fileId: 'vid1' },
+          ]},
+        ],
+      }));
+      const videoDurations = new Map([['no-match', 99]]);
+      const withMap = parseLayoutDuration(xlf({
+        regions: [
+          { widgets: [
+            { duration: 30, useDuration: 1 },
+            { duration: 0, useDuration: 0, fileId: 'vid1' },
+          ]},
+        ],
+      }), videoDurations);
+      expect(withMap).toEqual(without);
+    });
+
+    it('should handle mixed: some probed, some static, some estimated', () => {
+      const videoDurations = new Map([['vid1', 90]]);
+      const result = parseLayoutDuration(xlf({
+        regions: [
+          { widgets: [
+            { duration: 30, useDuration: 1 },           // Static: 30s
+            { duration: 0, useDuration: 0, fileId: 'vid1' },  // Probed: 90s
+            { duration: 0, useDuration: 0, fileId: 'vid2' },  // Estimated: 60s
+          ]},
+        ],
+      }), videoDurations);
+      // 30 + 90 + 60 = 180, isDynamic=true because vid2 is unprobed
+      expect(result).toEqual({ duration: 180, isDynamic: true });
+    });
+
+    it('should not mark as dynamic when all videos are probed', () => {
+      const videoDurations = new Map([['vid1', 45], ['vid2', 30]]);
+      const result = parseLayoutDuration(xlf({
+        regions: [
+          { widgets: [
+            { duration: 10, useDuration: 1 },
+            { duration: 0, useDuration: 0, fileId: 'vid1' },
+            { duration: 0, useDuration: 0, fileId: 'vid2' },
+          ]},
+        ],
+      }), videoDurations);
+      // 10 + 45 + 30 = 85, all resolved
+      expect(result).toEqual({ duration: 85, isDynamic: false });
+    });
+  });
+});