hyperframes 0.8.171 → 0.8.173

package/dist/{chunk-IWFLMU2N.js → chunk-6BNTGNGD.js}

@@ -10,7 +10,8 @@ import {
 
 // ../parsers/dist/assetResolution.js
 import { closeSync, constants, existsSync, fstatSync, openSync, readFileSync } from "fs";
-import { isAbsolute, join, posix, relative, resolve, sep } from "path";
+import { isAbsolute as isAbsolute2, join as join2, posix as posix2, relative as relative2, resolve as resolve3, sep } from "path";
+import { posix } from "path";
 function readAttributeValue(html, at) {
   while (/[\t\n\f\r ]/.test(html.charAt(at))) at++;
   const quote = ['"', "'"].includes(html.charAt(at)) ? html.charAt(at) : "";
@@ -109,6 +110,38 @@ function decodeWellFormedEscapes(path) {
     }
   });
 }
+function splitUrlSuffix(urlValue) {
+  const queryIdx = urlValue.indexOf("?");
+  const hashIdx = urlValue.indexOf("#");
+  if (queryIdx < 0 && hashIdx < 0) return { basePath: urlValue, suffix: "" };
+  let cutIdx = urlValue.length;
+  if (queryIdx >= 0) cutIdx = Math.min(cutIdx, queryIdx);
+  if (hashIdx >= 0) cutIdx = Math.min(cutIdx, hashIdx);
+  return { basePath: urlValue.slice(0, cutIdx), suffix: urlValue.slice(cutIdx) };
+}
+function encodeUrlPath(path) {
+  return encodeURIComponent(path).replace(/%2F/g, "/").replace(/['()]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function isNonRelativeUrl(val) {
+  return !val || val.startsWith("http://") || val.startsWith("https://") || val.startsWith("//") || val.startsWith("data:") || val.startsWith("#") || val.startsWith("/");
+}
+var { join, resolve: resolve2, dirname } = posix;
+var isAbsoluteOrSpecial = isNonRelativeUrl;
+function needsRewrite(val) {
+  return val.startsWith("../") || val === "..";
+}
+function rewriteAssetPath(compSrcPath, relativePath, assetExists) {
+  if (isAbsoluteOrSpecial(relativePath)) return relativePath;
+  const compDir = dirname(compSrcPath);
+  if (!compDir || compDir === ".") return relativePath;
+  const { basePath, suffix } = splitUrlSuffix(relativePath);
+  const slashed = basePath.replace(/\\/g, "/");
+  if (!slashed || slashed.startsWith("/")) return relativePath;
+  const filePath = decodeWellFormedEscapes(slashed);
+  const sibling = resolve2("/", join(compDir, filePath)).slice(1);
+  if (!needsRewrite(filePath) && (!assetExists || !assetExists(sibling))) return relativePath;
+  return encodeUrlPath(sibling) + suffix;
+}
 function isRemoteOrInlineUrl(url) {
   return /^(https?:|data:|blob:|\/\/|#)/i.test(url);
 }
@@ -137,7 +170,7 @@ function collectSubCompositionSrcs(html) {
 function cleanAssetUrl(url) {
   return url.trim().split(/[?#]/, 1)[0] ?? "";
 }
-function isWithinProjectRoot(projectDir, candidate, pathModule = { resolve, relative, isAbsolute }) {
+function isWithinProjectRoot(projectDir, candidate, pathModule = { resolve: resolve3, relative: relative2, isAbsolute: isAbsolute2 }) {
   const projectRoot = pathModule.resolve(projectDir);
   const relativePath = pathModule.relative(projectRoot, candidate);
   return relativePath === "" || !relativePath.startsWith("..") && !pathModule.isAbsolute(relativePath);
@@ -147,49 +180,55 @@ function addCandidate(candidates, candidate) {
 }
 function resolveLocalAssetCandidates(projectDir, url) {
   const cleanUrl = cleanAssetUrl(url);
-  const projectRoot = resolve(projectDir);
+  const projectRoot = resolve3(projectDir);
   const candidates = [];
   for (const variant of decodeUrlPathVariants(cleanUrl)) {
     const projectRelative = variant.startsWith("/") ? variant.slice(1) : variant;
-    const resolved = resolve(projectRoot, projectRelative);
+    const resolved = resolve3(projectRoot, projectRelative);
     if (isWithinProjectRoot(projectRoot, resolved)) {
       addCandidate(candidates, resolved);
       continue;
     }
-    const normalized = posix.normalize(projectRelative.replace(/\\/g, "/"));
+    const normalized = posix2.normalize(projectRelative.replace(/\\/g, "/"));
     const clamped = normalized.replace(/^(\.\.\/)+/, "");
     if (clamped && !clamped.startsWith("..")) {
-      addCandidate(candidates, resolve(projectRoot, clamped));
+      addCandidate(candidates, resolve3(projectRoot, clamped));
     }
   }
   return candidates;
 }
 function resolveExistingLocalAsset(projectDir, url) {
-  const projectRoot = resolve(projectDir);
+  const projectRoot = resolve3(projectDir);
   const resolved = resolveLocalAssetCandidates(projectRoot, url).find(existsSync);
   if (!resolved) return null;
-  return { resolved, rootRelativePath: relative(projectRoot, resolved) };
+  return { resolved, rootRelativePath: relative2(projectRoot, resolved) };
+}
+function resolveAuthoredAssetFile(projectDir, compositionFile, src) {
+  const cleanSrc = cleanAssetUrl(src.trim());
+  if (!cleanSrc) return null;
+  const rootRelative = cleanSrc.startsWith("/") ? cleanSrc : rewriteAssetPath(compositionFile, cleanSrc, (path) => existsSync(join2(projectDir, path)));
+  return resolveExistingLocalAsset(projectDir, rootRelative)?.resolved ?? null;
 }
 function reanchoredCandidates(variant, baseDir, compiledDir) {
-  const baseAbs = resolve(baseDir);
-  const joinedAbs = resolve(join(baseDir, variant));
+  const baseAbs = resolve3(baseDir);
+  const joinedAbs = resolve3(join2(baseDir, variant));
   if (joinedAbs === baseAbs || joinedAbs.startsWith(baseAbs + sep)) return [];
-  const stripped = posix.normalize(variant.replace(/\\/g, "/")).replace(/^(\.\.\/)+/, "");
+  const stripped = posix2.normalize(variant.replace(/\\/g, "/")).replace(/^(\.\.\/)+/, "");
   if (!stripped || stripped === variant || stripped.startsWith("..")) return [];
-  return compiledDir ? [join(compiledDir, stripped), join(baseDir, stripped)] : [join(baseDir, stripped)];
+  return compiledDir ? [join2(compiledDir, stripped), join2(baseDir, stripped)] : [join2(baseDir, stripped)];
 }
 function resolveProjectRelativeSrc(src, baseDir, compiledDir) {
   const cleanSrc = cleanAssetUrl(src);
-  if (isAbsolute(cleanSrc) && existsSync(cleanSrc)) return cleanSrc;
+  if (isAbsolute2(cleanSrc) && existsSync(cleanSrc)) return cleanSrc;
   const candidates = /* @__PURE__ */ new Set();
   for (const variant of decodeUrlPathVariants(cleanSrc)) {
     for (const candidate of reanchoredCandidates(variant, baseDir, compiledDir)) {
       candidates.add(candidate);
     }
-    if (compiledDir) candidates.add(join(compiledDir, variant));
-    candidates.add(join(baseDir, variant));
+    if (compiledDir) candidates.add(join2(compiledDir, variant));
+    candidates.add(join2(baseDir, variant));
   }
-  return [...candidates].find(existsSync) ?? join(baseDir, cleanSrc);
+  return [...candidates].find(existsSync) ?? join2(baseDir, cleanSrc);
 }
 function maskRange(src, pattern) {
   return src.replace(pattern, (m) => " ".repeat(m.length));
@@ -240,6 +279,7 @@ export {
   isWithinProjectRoot,
   resolveLocalAssetCandidates,
   resolveExistingLocalAsset,
+  resolveAuthoredAssetFile,
   resolveProjectRelativeSrc,
   maskNonScannableRanges,
   readProjectFile

package/dist/{chunk-L32QQH2K.js → chunk-6HKO6VWS.js}

@@ -1278,7 +1278,7 @@ async function withFigmaErrors(command, fn) {
   } catch (err) {
     if (err instanceof Error) {
       try {
-        const { trackCommandFailure } = await import("./events-VL2JIO4R.js");
+        const { trackCommandFailure } = await import("./events-Q2K7SNEZ.js");
         trackCommandFailure(
           command,
           err,

package/dist/{chunk-A3SQJCPU.js → chunk-6JQDH4O6.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-K2FLNJVB.js";
 import {
   trackCommandFailure
-} from "./chunk-6I24ZSCR.js";
+} from "./chunk-BYRHCRU3.js";
 import {
   failCommand
 } from "./chunk-PBN6GBJE.js";

package/dist/{chunk-D2QELIQB.js → chunk-6RIH2NDU.js}

@@ -9,28 +9,28 @@ import {
   launchManagedBrowser,
   resolveManagedGpuMode,
   rethrowAfterBrowserCleanup
-} from "./chunk-TZ3I23TZ.js";
+} from "./chunk-TNHRCZT3.js";
 import {
   resolveCompositionViewportFromHtml
 } from "./chunk-FH7WODJH.js";
 import {
-  resolveDiagnosticNavigationTimeoutMs,
+  pageNavigationTimeoutMs,
   windowsChromeCrashRemediation
-} from "./chunk-LMMFO5UV.js";
+} from "./chunk-V2D4QZBC.js";
 import {
   oneProcessOverPipe
-} from "./chunk-WICIV6R3.js";
+} from "./chunk-BRHI7EIA.js";
 import {
   resolveLocalBrowserGpuMode,
   resolveLocalWebGpu
-} from "./chunk-PXA4S6OE.js";
+} from "./chunk-KR5ZHRF2.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
 import {
   assertWebGpuAdapterAvailable,
   compositionRequiresWebGpu
-} from "./chunk-VKFYI7AQ.js";
+} from "./chunk-O433SZAJ.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -114,9 +114,9 @@ async function openSettledCompositionPage(html, url, options) {
   const { ensureBrowser, findSystemBrowser } = await import("./manager-HEUPD2YB.js");
   const browser = await ensureBrowser({ signal: options.signal });
   const puppeteer = await import("puppeteer-core");
-  const { buildChromeArgs } = await import("./src-VFTQPSQD.js");
+  const { buildChromeArgs } = await import("./src-WD5GOYON.js");
   const requestedGpuMode = options.browserGpuMode ?? resolveCliChromeGpuMode();
-  const answer = (await import("./staticProjectServer-2YNWMUSU.js")).inProcessAnswer(url);
+  const answer = (await import("./staticProjectServer-72JF5PPO.js")).inProcessAnswer(url);
   const requiresWebGpu = compositionRequiresWebGpu(html);
   let softwareWebGpu = false;
   const launch = async (executablePath) => {
@@ -175,11 +175,7 @@ ${remediation}`,
     await page.setViewport(viewport);
     if (answer) await answerPageInProcess(page, url, answer);
     await options.beforeNavigate?.(page);
-    await gotoWhenSent(
-      page,
-      url,
-      resolveDiagnosticNavigationTimeoutMs(process.env, options.navigationTimeoutMs)
-    );
+    await gotoWhenSent(page, url, pageNavigationTimeoutMs(options.navigationTimeoutMs));
     await assertWebGpuAdapterAvailable(page, requiresWebGpu, softwareWebGpu);
     const renderReadyTimedOut = !await waitForCompositionSettle(page, options);
     return { browser: chromeBrowser, page, renderReadyTimedOut };