hyperframes 0.8.68 → 0.8.70

package/dist/commands/layout-audit.browser.js

@@ -27,6 +27,16 @@
     return Math.round(value * 100) / 100;
   }
 
+  function horizontalOverflow(subject, container, tolerance) {
+    if (subject.width <= container.width + tolerance) return null;
+    const overflow = overflowFor(subject, container, tolerance);
+    if (!overflow) return null;
+    const horizontal = {};
+    if (overflow.left != null) horizontal.left = overflow.left;
+    if (overflow.right != null) horizontal.right = overflow.right;
+    return Object.keys(horizontal).length > 0 ? horizontal : null;
+  }
+
   function overflowFor(subject, container, tolerance, vTolerance) {
     // Horizontal axis uses `tolerance`; vertical axis uses `vTolerance` (defaults to the same).
     // A separate vertical tolerance lets text overflow checks absorb glyph ink that exceeds a
@@ -550,20 +560,40 @@
     return issues;
   }
 
+  function isNowrapTextChild(child) {
+    if (!isVisibleElement(child) || hasAllowOverflowFlag(child)) return false;
+    if (getComputedStyle(child).whiteSpace !== "nowrap") return false;
+    return (child.textContent || "").trim().length > 0;
+  }
+
+  function hasNowrapTextChild(element) {
+    return Array.from(element.children).some(isNowrapTextChild);
+  }
+
   function containerOverflowIssues(root, time, tolerance) {
     const issues = [];
     const containers = Array.from(root.querySelectorAll("*")).filter((element) => {
       if (!isVisibleElement(element) || hasAllowOverflowFlag(element)) return false;
       const style = getComputedStyle(element);
-      return clipsOverflow(style) || element.hasAttribute("data-layout-boundary");
+      return (
+        clipsOverflow(style) ||
+        element.hasAttribute("data-layout-boundary") ||
+        hasNowrapTextChild(element)
+      );
     });
 
     for (const container of containers) {
+      const style = getComputedStyle(container);
+      const checksEveryChild =
+        clipsOverflow(style) || container.hasAttribute("data-layout-boundary");
       const containerRect = toRect(container.getBoundingClientRect());
       for (const child of Array.from(container.children)) {
         if (!isVisibleElement(child) || hasAllowOverflowFlag(child)) continue;
+        if (!checksEveryChild && !isNowrapTextChild(child)) continue;
         const childRect = toRect(child.getBoundingClientRect());
-        const overflow = overflowFor(childRect, containerRect, tolerance);
+        const overflow = checksEveryChild
+          ? overflowFor(childRect, containerRect, tolerance)
+          : horizontalOverflow(childRect, containerRect, tolerance);
         if (!overflow) continue;
         issues.push({
           code: "container_overflow",
@@ -571,7 +601,9 @@
           time,
           selector: selectorFor(child),
           containerSelector: selectorFor(container),
-          message: "Element extends outside a clipping layout container.",
+          message: checksEveryChild
+            ? "Element extends outside a clipping layout container."
+            : "Nowrap text is wider than its container.",
           rect: childRect,
           containerRect,
           overflow,
@@ -911,7 +943,7 @@
   }
 
   function hasAllowOcclusionFlag(element) {
-    return !!element.closest("[data-layout-allow-occlusion]");
+    return element.hasAttribute("data-layout-allow-occlusion");
   }
 
   // A foreign element is one painted independently of the text — not the text

package/dist/fontLocalizeCli.js

@@ -72911,17 +72911,17 @@ function truncateSnippet(value, maxLength = 220) {
   return `${normalized2.slice(0, maxLength - 3)}...`;
 }
 function normalized(source) {
-  let text = "";
+  const chars = [];
   const offsets = [];
+  let lastWasSpace = false;
   for (let i = 0; i < source.length; i++) {
-    const char = source[i];
-    if (/\s/.test(char)) {
-      if (text.endsWith(" ")) continue;
-      text += " ";
-    } else text += char;
+    const isSpace = /\s/.test(source[i]);
+    if (isSpace && lastWasSpace) continue;
+    chars.push(isSpace ? " " : source[i]);
     offsets.push(i);
+    lastWasSpace = isSpace;
   }
-  return { text, offsets };
+  return { text: chars.join(""), offsets };
 }
 function createSourceLocator(source) {
   const tags = parseHtmlStructure(source).tags;
@@ -79430,6 +79430,15 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
       `FFmpeg exited successfully but produced no frames (start=${startTime}, duration=${duration})`
     );
   }
+  if (framePaths.size > 0 && duration > 0 && !options.finalFrameOnly) {
+    const expectedAtFps = extractionFrameCountForDuration(duration, normalizedFps, metadata.isVFR);
+    if (expectedAtFps > 0 && framePaths.size <= expectedAtFps * 0.6) {
+      const correctedDuration = startTime + framePaths.size / fps;
+      if (correctedDuration < metadata.videoStreamDurationSeconds) {
+        metadata.videoStreamDurationSeconds = correctedDuration;
+      }
+    }
+  }
   return {
     videoId,
     srcPath: videoPath,
@@ -94205,6 +94214,12 @@ function resolveFontFetchRetryPolicy(configured) {
     )
   };
 }
+function placeAfterEveryStylesheet(document2, head, styleEl) {
+  const stylesheets = document2.querySelectorAll("style, link[rel~=stylesheet]");
+  const lastStylesheet = stylesheets[stylesheets.length - 1];
+  if (lastStylesheet) lastStylesheet.after(styleEl);
+  else head.appendChild(styleEl);
+}
 async function injectDeterministicFontFaces(html, options = {}) {
   const failClosedFontFetch = options.failClosedFontFetch === true;
   const fetchImpl = options.fetchImpl ?? fetch;
@@ -94255,7 +94270,7 @@ async function injectDeterministicFontFaces(html, options = {}) {
   const styleEl = document2.createElement("style");
   styleEl.setAttribute("data-hyperframes-deterministic-fonts", "true");
   styleEl.textContent = css;
-  head.insertBefore(styleEl, head.firstChild);
+  placeAfterEveryStylesheet(document2, head, styleEl);
   defaultLogger.info(
     `[Compiler] Injected deterministic @font-face rules for ${pendingFamilies.size - unresolved.length} requested font families`
   );
@@ -103722,8 +103737,8 @@ async function runFontLocalize(io, localize) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.8.68" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.68" : "0.0.0-dev";
+var VERSION = true ? "0.8.70" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.70" : "0.0.0-dev";
 
 // src/fontLocalizeCli.ts
 async function readStdin() {