hyperframes 0.8.158 → 0.8.160

package/dist/chunk-GJQHHAAX.js

@@ -0,0 +1,336 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  readCompositionFps
+} from "./chunk-WPNE5NEP.js";
+import {
+  findSyncPartner,
+  readLinkTiming,
+  syncOffsetFrames
+} from "./chunk-6JR2XUEE.js";
+import {
+  HF_AUDIO_GROUP_ATTR,
+  extractAudioMetadata,
+  extractMediaMetadata,
+  resolveReferencedDuration,
+  resolveReferencedStart
+} from "./chunk-PLEMSN3E.js";
+import {
+  byStart,
+  compositionOriginSeconds,
+  cutToHostSlots,
+  fpsToNumber,
+  hostInPointSeconds,
+  parseFpsWithDefault,
+  resolveMediaStartSeconds
+} from "./chunk-Q3TFX4OZ.js";
+import {
+  HF_AUDIO_AUTOMATION_ATTR,
+  HF_AUDIO_FX_ATTR,
+  parseAudioFxChain,
+  parseAutomation,
+  resolveAutomation
+} from "./chunk-P47XYVEQ.js";
+import {
+  topLevelElements,
+  trackKindOf
+} from "./chunk-ALLKNYC3.js";
+import {
+  parseNumeric
+} from "./chunk-3RM2ETQT.js";
+import {
+  readMediaOffsetSeconds,
+  readPlaybackRate,
+  resolveMediaDuration
+} from "./chunk-BSQ7XANM.js";
+
+// src/timeline/describeProject.ts
+import { readFileSync, realpathSync, statSync } from "fs";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "path";
+var TRACK_ORDER = ["video", "graphics", "captions", "audio"];
+function toNode(el) {
+  const attrs = {};
+  for (const { name, value } of Array.from(el.attributes)) attrs[name] = value;
+  return { tag: el.tagName, attrs, children: Array.from(el.children).map(toNode), el };
+}
+function safeChain(raw) {
+  try {
+    return parseAudioFxChain(raw);
+  } catch {
+    return void 0;
+  }
+}
+function readLanes(el) {
+  const raw = el.getAttribute(HF_AUDIO_AUTOMATION_ATTR);
+  if (!raw) return { lanes: [], laneError: null };
+  try {
+    const fx = el.getAttribute(HF_AUDIO_FX_ATTR);
+    const chain = fx ? safeChain(fx) : void 0;
+    const lanes = resolveAutomation(parseAutomation(raw), chain).lanes.map((lane) => ({
+      target: lane.target,
+      points: lane.points.map(({ t, v }) => ({ t, v }))
+    }));
+    return { lanes, laneError: null };
+  } catch (err) {
+    return { lanes: [], laneError: err instanceof Error ? err.message : String(err) };
+  }
+}
+var measureWithFfprobe = async (file, tag) => (tag === "audio" ? await extractAudioMetadata(file) : await extractMediaMetadata(file)).durationSeconds;
+var MEDIA_TAG = /^(video|audio|img)$/;
+var PROBE_CONCURRENCY = 4;
+function createProbeGate(max) {
+  let active = 0;
+  const waiting = [];
+  return async function withProbeSlot(fn) {
+    if (active >= max) await new Promise((wake) => waiting.push(wake));
+    else active += 1;
+    try {
+      return await fn();
+    } finally {
+      const next = waiting.shift();
+      if (next) next();
+      else active -= 1;
+    }
+  };
+}
+async function probeSource(scope, el, tag) {
+  const src = el.getAttribute("src");
+  if (!src) return { ok: false, reason: "no src attribute" };
+  if (/^https?:\/\//i.test(src)) return { ok: false, reason: "remote source not probed" };
+  const file = realFileInside(scope.projectDir, resolve(scope.dir, src));
+  if (!file) return { ok: false, reason: "source file not found" };
+  return scope.withProbeSlot(async () => {
+    try {
+      return { ok: true, seconds: await scope.measure(file, tag) };
+    } catch (err) {
+      return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+  });
+}
+function resolveContainerDuration(authored, children) {
+  if (authored !== null)
+    return { duration: authored, durationSource: "authored", pendingReason: null };
+  if (children.length === 0) return { duration: 0, durationSource: null, pendingReason: null };
+  const inner = children.reduce((max, c) => Math.max(max, c.end), 0);
+  return { duration: inner, durationSource: "inner", pendingReason: null };
+}
+async function resolveMediaRowDuration(scope, el, tag, authored) {
+  const getAttr = (name) => el.getAttribute(name);
+  const input = {
+    tag,
+    authoredDurationSeconds: authored,
+    mediaStartSeconds: readMediaOffsetSeconds(getAttr),
+    playbackRate: readPlaybackRate(getAttr)
+  };
+  const unprobed = resolveMediaDuration({ ...input, sourceDurationSeconds: null });
+  if (unprobed.source !== "pending") {
+    return {
+      duration: unprobed.seconds ?? 0,
+      durationSource: unprobed.source,
+      pendingReason: null
+    };
+  }
+  const probe = await probeSource(scope, el, tag);
+  const measured = probe.ok && probe.seconds > 0 ? probe.seconds : null;
+  const result = resolveMediaDuration({ ...input, sourceDurationSeconds: measured });
+  return {
+    duration: result.seconds ?? 0,
+    durationSource: result.source,
+    pendingReason: result.source === "pending" ? pendingReason(probe, result.reason) : null
+  };
+}
+function pendingReason(probe, resolverReason) {
+  if (!probe.ok) return probe.reason;
+  return probe.seconds > 0 ? resolverReason ?? "source duration unavailable" : "source reports no duration";
+}
+var roundMs = (v) => Math.round(v * 1e3) / 1e3;
+function mainTimelineStart(scope, el, start) {
+  const ordinaryStart = () => scope.origin + start;
+  if (!/^(video|audio)$/i.test(el.tagName)) return ordinaryStart();
+  return resolveMediaStartSeconds({
+    authoredStart: parseNumeric(el.getAttribute("data-start")),
+    hostStart: scope.origin,
+    hasAutoStart: el.hasAttribute("data-hf-auto-start"),
+    basis: el.getAttribute("data-hf-media-start-basis"),
+    ordinaryStart
+  });
+}
+async function resolveRowTiming(scope, node, depth) {
+  const { el } = node;
+  const start = resolveReferencedStart(scope.doc, el, scope.startCache, /* @__PURE__ */ new Set());
+  const authored = resolveReferencedDuration(scope.doc, el, scope.startCache, /* @__PURE__ */ new Set());
+  const host = el.getAttribute("data-composition-src");
+  const absStart = mainTimelineStart(scope, el, start);
+  const slots = hostInPointSeconds(el) > 0 ? [{ start: absStart, end: absStart + (authored ?? Infinity) }] : [];
+  const children = host && depth === 0 ? await readSubComposition(host, scope, compositionOriginSeconds(absStart, el), slots) : [];
+  const kind = el.tagName.toLowerCase();
+  const duration = MEDIA_TAG.test(kind) ? await resolveMediaRowDuration(scope, el, kind, authored) : resolveContainerDuration(authored, children);
+  return { start, authored, absStart, children, duration };
+}
+function describeRowFields(scope, node, timing) {
+  const { el } = node;
+  const kind = el.tagName.toLowerCase();
+  const host = el.getAttribute("data-composition-src");
+  const rate = parseNumeric(el.getAttribute("data-playback-rate"));
+  return {
+    id: el.id || el.getAttribute("data-composition-id") || kind,
+    label: null,
+    kind,
+    trackKind: trackKindOf(node).kind,
+    start: timing.start,
+    duration: timing.duration.duration,
+    end: timing.start + timing.duration.duration,
+    absStart: roundMs(timing.absStart),
+    absEnd: roundMs(timing.absStart + timing.duration.duration),
+    file: scope.file,
+    trackIndex: parseNumeric(el.getAttribute("data-track-index")) ?? 0,
+    src: el.getAttribute("src") ?? host,
+    sourceFile: host,
+    volume: parseNumeric(el.getAttribute("data-volume")),
+    ...readLanes(el),
+    playbackRate: rate === 1 ? null : rate,
+    audioGroup: el.getAttribute(HF_AUDIO_GROUP_ATTR),
+    role: null,
+    durationAuthored: timing.authored !== null,
+    durationSource: timing.duration.durationSource,
+    pendingReason: timing.duration.pendingReason,
+    children: timing.children,
+    ref: "",
+    warnings: [],
+    elementId: el.id || null,
+    hfId: el.getAttribute("data-hf-id"),
+    syncOffsetFrames: syncOffsetOf(el, scope.fps),
+    mediaStart: /^(video|audio)$/.test(kind) ? readMediaOffsetSeconds((name) => el.getAttribute(name)) : null
+  };
+}
+function syncOffsetOf(el, fps) {
+  const partner = findSyncPartner(el);
+  return partner ? syncOffsetFrames(readLinkTiming(el), readLinkTiming(partner), fps) : null;
+}
+async function describeRow(scope, node, depth) {
+  return describeRowFields(scope, node, await resolveRowTiming(scope, node, depth));
+}
+async function readSubComposition(src, parent, origin, slots) {
+  const authored = resolve(parent.dir, src);
+  const file = realFileInside(parent.projectDir, authored);
+  if (!file) return [];
+  const relativeFile = relative(parent.projectDir, authored).split(sep).join("/");
+  const source = parent.sourceOverrides.get(relativeFile) ?? readFileSync(file, "utf-8");
+  const doc = new DOMParser().parseFromString(source, "text/html");
+  const template = doc.querySelector("template");
+  const root = (template?.content ?? doc).querySelector("[data-composition-id]");
+  if (!root) return [];
+  const scope = {
+    doc,
+    dir: dirname(file),
+    startCache: /* @__PURE__ */ new Map(),
+    projectDir: parent.projectDir,
+    origin,
+    file: relative(parent.projectDir, authored).split(sep).join("/"),
+    withProbeSlot: parent.withProbeSlot,
+    measure: parent.measure,
+    sourceOverrides: parent.sourceOverrides,
+    fps: parent.fps
+  };
+  const rows = await Promise.all(
+    topLevelElements(toNode(root)).map((node) => describeRow(scope, node, 1))
+  );
+  return rows.flatMap((row) => cutRow(row, slots)).sort(byStart);
+}
+function cutRow(row, slots) {
+  const kept = cutToHostSlots({ start: row.absStart, end: row.absEnd }, slots);
+  if (kept.end === kept.start && row.absEnd > row.absStart) return [];
+  const skipped = (kept.start - row.absStart) * (row.playbackRate ?? 1);
+  const mediaStart = row.mediaStart === null ? null : roundMs(row.mediaStart + skipped);
+  return [{ ...row, absStart: roundMs(kept.start), absEnd: roundMs(kept.end), mediaStart }];
+}
+function realFileInside(projectDir, path) {
+  try {
+    const real = realpathSync(path);
+    const inside = relative(realpathSync(projectDir), real);
+    if (inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside)) return null;
+    return statSync(real).isFile() ? real : null;
+  } catch {
+    return null;
+  }
+}
+function flatten(top) {
+  const entries = [
+    ...top.map((clip) => ({ clip, host: null })),
+    ...top.flatMap((host) => host.children.map((clip) => ({ clip, host })))
+  ];
+  const byKind = TRACK_ORDER.map((kind) => ({
+    kind,
+    entries: entries.filter((e) => e.clip.trackKind === kind).sort((a, b) => a.clip.absStart - b.clip.absStart)
+  })).filter((t) => t.entries.length > 0);
+  const pointers = new Map(
+    byKind.flatMap((t) => t.entries.map((e, index) => [e.clip, { kind: t.kind, index }]))
+  );
+  const at = (clip) => pointers.get(clip);
+  const fileIds = /* @__PURE__ */ new Map();
+  for (const { entries: entries2 } of byKind) {
+    for (const { clip } of entries2) {
+      if (!clip.elementId) continue;
+      const ids = fileIds.get(clip.file) ?? /* @__PURE__ */ new Map();
+      ids.set(clip.elementId, (ids.get(clip.elementId) ?? 0) + 1);
+      fileIds.set(clip.file, ids);
+    }
+  }
+  return byKind.map(({ kind, entries: kindEntries }) => ({
+    kind,
+    rows: kindEntries.map(({ clip, host }, index) => {
+      const uniqueId = clip.elementId && fileIds.get(clip.file)?.get(clip.elementId) === 1;
+      const ref = uniqueId ? `#${clip.elementId}` : clip.hfId ? `hf:${clip.hfId}` : `${kind}/${index}`;
+      const warnings = uniqueId || clip.hfId ? [] : [
+        'row has no stable name; add id="<name>" to the element in this file, then retry with #<name>'
+      ];
+      return {
+        ...clip,
+        index,
+        ref,
+        warnings,
+        nested: host !== null,
+        host: host && host.id,
+        hostRow: host && at(host),
+        children: clip.children.map(at)
+      };
+    })
+  }));
+}
+function projectFps(source) {
+  const parsed = parseFpsWithDefault(readCompositionFps(source) ?? void 0);
+  return fpsToNumber(parsed.ok ? parsed.value : { num: 30, den: 1 });
+}
+async function describeProject(indexPath, measure = measureWithFfprobe, sourceOverrides = /* @__PURE__ */ new Map()) {
+  const projectDir = dirname(indexPath);
+  const source = sourceOverrides.get(basename(indexPath)) ?? readFileSync(indexPath, "utf-8");
+  const doc = new DOMParser().parseFromString(source, "text/html");
+  const root = doc.querySelector("[data-composition-id]") ?? doc.body;
+  const dir = projectDir;
+  const scope = {
+    doc,
+    dir,
+    startCache: /* @__PURE__ */ new Map(),
+    projectDir: dir,
+    origin: 0,
+    file: basename(indexPath),
+    withProbeSlot: createProbeGate(PROBE_CONCURRENCY),
+    measure,
+    sourceOverrides,
+    fps: projectFps(source)
+  };
+  const rows = (await Promise.all(topLevelElements(toNode(root)).map((node) => describeRow(scope, node, 0)))).sort(byStart);
+  const declared = parseNumeric(root.getAttribute("data-duration"));
+  return {
+    duration: declared ?? rows.reduce((max, r) => Math.max(max, r.end), 0),
+    tracks: flatten(rows)
+  };
+}
+
+export {
+  describeProject
+};

package/dist/{chunk-Y6E2PW7Z.js → chunk-GOASXWDD.js}

@@ -6,10 +6,10 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   withOwner
-} from "./chunk-Z347DFOL.js";
+} from "./chunk-V2FQQILJ.js";
 import {
   beginArtifactCapture
-} from "./chunk-6PIGOKTE.js";
+} from "./chunk-JGYHWVXQ.js";
 
 // src/utils/artifactCapture.ts
 async function captureArtifactRevision(projectDir) {

package/dist/{chunk-4R6OZQGX.js → chunk-GOTCGKX6.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 import {
   getMimeType,
   injectMediaCodecMapIntoHtml
-} from "./chunk-DCQCGE2W.js";
+} from "./chunk-VD7WQYTO.js";
 import {
   PROXY_VARIANT_CONFIG,
   ProxyCapacityError,
@@ -18,18 +18,75 @@ import {
   recordProxyRequest,
   resolveProxy,
   resolveProxyVariantRequest
-} from "./chunk-DISITOR6.js";
+} from "./chunk-4ID635FL.js";
 import {
   resolveAutoProxy
-} from "./chunk-GPUVPZRK.js";
+} from "./chunk-GG37I7B3.js";
 import {
   decodeWellFormedEscapes
 } from "./chunk-BSQ7XANM.js";
 
 // src/utils/staticProjectServer.ts
-import { createServer } from "http";
+import { createServer, request as httpRequest } from "http";
+import { Duplex } from "stream";
 import { createReadStream, existsSync, statSync } from "fs";
 import { isAbsolute, relative, resolve } from "path";
+var REFUSED_LISTEN = /* @__PURE__ */ new Set(["EPERM", "EACCES"]);
+function socketPair() {
+  const sides = [];
+  const side = (other) => new Duplex({
+    read() {
+    },
+    write(chunk, _encoding, done) {
+      other().push(chunk);
+      done();
+    },
+    final(done) {
+      other().push(null);
+      done();
+    }
+  });
+  sides.push(
+    side(() => sides[1]),
+    side(() => sides[0])
+  );
+  return [sides[0], sides[1]];
+}
+function answerInProcess(server, request) {
+  const [client, served] = socketPair();
+  server.emit("connection", served);
+  return new Promise((resolveAnswer, rejectAnswer) => {
+    const req = httpRequest(
+      {
+        method: request.method,
+        path: request.path,
+        headers: { ...request.headers, connection: "close" },
+        // No `agent`: Node uses createConnection only when no agent is given.
+        createConnection: () => client
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("error", rejectAnswer);
+        res.on("end", () => {
+          const headers = {};
+          for (const [name, value] of Object.entries(res.headers)) {
+            if (value !== void 0 && name !== "connection" && name !== "transfer-encoding")
+              headers[name] = Array.isArray(value) ? value.join(", ") : value;
+          }
+          resolveAnswer({ status: res.statusCode ?? 500, headers, body: Buffer.concat(chunks) });
+        });
+      }
+    );
+    req.on("error", rejectAnswer);
+    req.end();
+  });
+}
+var inProcessServers = 0;
+var inProcessAnswers = /* @__PURE__ */ new Map();
+function inProcessAnswer(url) {
+  return inProcessAnswers.get(new URL(url).origin);
+}
 function serveFileWithRange(filePath, rangeHeader, res, contentType = getMimeType(filePath)) {
   const size = statSync(filePath).size;
   const headers = {
@@ -165,7 +222,24 @@ async function serveStaticProjectHtml(projectDir, html, bindErrorMessage = "Fail
       if (!resolvedPort) rejectPort(new Error(bindErrorMessage));
       else resolvePort(resolvedPort);
     });
+  }).catch((error) => {
+    if (REFUSED_LISTEN.has(error.code ?? "")) return 0;
+    throw error;
   });
+  if (port === 0) {
+    server.removeAllListeners("error");
+    const url = `http://hyperframes-${++inProcessServers}.localhost/`;
+    const answer = (request) => answerInProcess(server, request);
+    inProcessAnswers.set(new URL(url).origin, answer);
+    return {
+      url,
+      port: 0,
+      close: async () => {
+        inProcessAnswers.delete(new URL(url).origin);
+      },
+      answer
+    };
+  }
   return {
     url: `http://127.0.0.1:${port}/`,
     port,
@@ -176,5 +250,6 @@ async function serveStaticProjectHtml(projectDir, html, bindErrorMessage = "Fail
 }
 
 export {
+  inProcessAnswer,
   serveStaticProjectHtml
 };

package/dist/{chunk-H6BWNY56.js → chunk-ICZVCVD3.js}

@@ -29,7 +29,7 @@ import {
 } from "./chunk-XUXGIA7H.js";
 import {
   VERSION
-} from "./chunk-RU6AIVON.js";
+} from "./chunk-TU2CQJO3.js";
 import {
   CANARIES,
   canaryEnvVar,

package/dist/{chunk-YVD5M26L.js → chunk-IGTGLGML.js}

@@ -20,7 +20,7 @@ import {
   typeDirPath,
   updateRecord,
   withFigmaErrors
-} from "./chunk-SHEVPNUR.js";
+} from "./chunk-VZ6LCTOZ.js";
 import {
   defineCommand
 } from "./chunk-S3S4TGEH.js";
@@ -229,7 +229,7 @@ var asset_default = defineCommand({
           rendered > 0 ? `(${results.length} nodes, ${rendered} rendered in 1 figma request)` : `(${results.length} nodes, all reused from cache \u2014 no figma request)`
         );
       }
-      const { trackFigmaImport } = await import("./telemetry-D6A2TRK6.js");
+      const { trackFigmaImport } = await import("./telemetry-7AWYECPL.js");
       trackFigmaImport({
         phase: "asset",
         reused: results.every((r) => r.reused),

package/dist/{chunk-KEGTYA7V.js → chunk-IK3SOMZ4.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-7KDQAD2W.js";
 import {
   runCancellableProcess
-} from "./chunk-54DMWFQZ.js";
+} from "./chunk-D3ZWBHZP.js";
 import {
   findFfBinary
 } from "./chunk-VAS6HQX3.js";
@@ -202,7 +202,7 @@ function detectH264EncoderMode(ffmpegPath, gpuRequested) {
   const encoders = execFileSync2(ffmpegPath, ["-hide_banner", "-encoders"], {
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "pipe"],
-    timeout: 5e3,
+    timeout: FIRST_LAUNCH_TIMEOUT_MS,
     windowsHide: true
   });
   return resolveH264EncoderMode(encoders, gpuRequested);
@@ -210,7 +210,7 @@ function detectH264EncoderMode(ffmpegPath, gpuRequested) {
 async function detectH264EncoderModeForRender(ffmpegPath, gpuRequested, signal) {
   const result = await runCancellableProcess(ffmpegPath, ["-hide_banner", "-encoders"], {
     signal,
-    timeoutMs: 5e3
+    timeoutMs: FIRST_LAUNCH_TIMEOUT_MS
   });
   return resolveH264EncoderMode(result.stdout, gpuRequested);
 }
@@ -220,6 +220,7 @@ function findFFmpeg() {
 function findFFprobe() {
   return findFfBinary("ffprobe", { configuredMustExist: true });
 }
+var FIRST_LAUNCH_TIMEOUT_MS = 6e4;
 var FFMPEG_DOWNLOAD_URL = "https://ffmpeg.org/download.html";
 function getFFmpegInstallCommand() {
   switch (process.platform) {
@@ -260,6 +261,7 @@ export {
   detectH264EncoderModeForRender,
   findFFmpeg,
   findFFprobe,
+  FIRST_LAUNCH_TIMEOUT_MS,
   getFFmpegInstallCommand,
   getFFmpegInstallHint
 };