@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/chunk-6JR2XUEE.js

@@ -0,0 +1,127 @@
+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 {
+  readMediaOffsetSeconds
+} from "./chunk-BSQ7XANM.js";
+
+// ../core/dist/mediaLink.js
+var MEDIA_LINK_ATTR = "data-link";
+function readNumber(el, names, fallback) {
+  for (const name of names) {
+    const raw = el.getAttribute(name);
+    if (raw === null || raw.trim() === "")
+      continue;
+    const value = Number(raw);
+    if (Number.isFinite(value))
+      return value;
+  }
+  return fallback;
+}
+function readLinkTiming(el) {
+  return {
+    start: readNumber(el, ["data-start"], 0),
+    duration: readNumber(el, ["data-duration"], 0),
+    mediaStart: readMediaOffsetSeconds((name) => el.getAttribute(name)),
+    playbackRate: readNumber(el, ["data-playback-rate"], 1)
+  };
+}
+var LINK_SCOPE_SELECTOR = "[data-composition-id], [data-composition-file]";
+function mintLinkId(taken) {
+  const used = new Set(taken);
+  let n = 1;
+  while (used.has(`lk-${n}`))
+    n += 1;
+  return `lk-${n}`;
+}
+function takenLinkIds(doc) {
+  return Array.from(doc.querySelectorAll(`[id], [${MEDIA_LINK_ATTR}], [${SYNC_ORIGIN_ATTR}]`)).flatMap((el) => [
+    el.id,
+    el.getAttribute(MEDIA_LINK_ATTR) ?? "",
+    el.getAttribute(SYNC_ORIGIN_ATTR) ?? ""
+  ]);
+}
+function renameShared(doc, ids, attr, taken) {
+  const renamed = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const el = doc.getElementById(id);
+    const old = el?.getAttribute(attr);
+    if (!el || !old)
+      continue;
+    let fresh = renamed.get(old);
+    if (!fresh) {
+      fresh = mintLinkId(taken);
+      taken.add(fresh);
+      renamed.set(old, fresh);
+    }
+    el.setAttribute(attr, fresh);
+  }
+}
+function relinkSplitHalves(doc, rightHalfIds) {
+  const taken = new Set(takenLinkIds(doc));
+  renameShared(doc, rightHalfIds, MEDIA_LINK_ATTR, taken);
+  renameShared(doc, idsWithBothSidesCut(doc, rightHalfIds), SYNC_ORIGIN_ATTR, taken);
+}
+function idsWithBothSidesCut(doc, rightHalfIds) {
+  const tagsByOrigin = /* @__PURE__ */ new Map();
+  const originOf = (id) => doc.getElementById(id)?.getAttribute(SYNC_ORIGIN_ATTR) ?? null;
+  for (const id of rightHalfIds) {
+    const origin = originOf(id);
+    const tag = doc.getElementById(id)?.tagName.toLowerCase();
+    if (!origin || !tag)
+      continue;
+    tagsByOrigin.set(origin, (tagsByOrigin.get(origin) ?? /* @__PURE__ */ new Set()).add(tag));
+  }
+  return rightHalfIds.filter((id) => {
+    const tags = tagsByOrigin.get(originOf(id) ?? "");
+    return tags?.has("video") === true && tags.has("audio");
+  });
+}
+var SYNC_ORIGIN_ATTR = "data-sync-origin";
+var rateOf = (timing) => timing.playbackRate > 0 ? timing.playbackRate : 1;
+function sourceZeroTime(timing) {
+  return timing.start - timing.mediaStart / rateOf(timing);
+}
+function syncOffsetFrames(clip, partner, fps) {
+  if (Math.abs(rateOf(clip) - rateOf(partner)) > 1e-6)
+    return null;
+  const frames = Math.round((sourceZeroTime(clip) - sourceZeroTime(partner)) * fps);
+  return Object.is(frames, -0) ? 0 : frames;
+}
+function sharedSeconds(a, b) {
+  return Math.min(a.start + a.duration, b.start + b.duration) - Math.max(a.start, b.start);
+}
+function sameOriginInScope(el, tag, origin) {
+  const scopeOf = (node) => node.closest(LINK_SCOPE_SELECTOR) ?? el.ownerDocument;
+  const scope = scopeOf(el);
+  return Array.from(scope.querySelectorAll(tag)).filter((candidate) => candidate.getAttribute(SYNC_ORIGIN_ATTR) === origin && scopeOf(candidate) === scope);
+}
+function findSyncPartner(el) {
+  const origin = el.getAttribute(SYNC_ORIGIN_ATTR);
+  const tag = el.tagName.toLowerCase();
+  if (!origin || tag !== "video" && tag !== "audio")
+    return null;
+  const partnerTag = tag === "video" ? "audio" : "video";
+  const own = readLinkTiming(el);
+  let best = null;
+  for (const candidate of sameOriginInScope(el, partnerTag, origin)) {
+    const timing = readLinkTiming(candidate);
+    const shared = sharedSeconds(own, timing);
+    const distance = Math.abs(timing.start - own.start);
+    if (!best || shared > best.shared || shared === best.shared && distance < best.distance) {
+      best = { el: candidate, shared, distance };
+    }
+  }
+  return best?.el ?? null;
+}
+
+export {
+  MEDIA_LINK_ATTR,
+  readLinkTiming,
+  relinkSplitHalves,
+  syncOffsetFrames,
+  findSyncPartner
+};

package/vendor/framey/dist/chunk-73QVATIM.js

@@ -0,0 +1,362 @@
+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 {
+  toDomNode
+} from "./chunk-LLMSX6V6.js";
+import {
+  findSyncPartner,
+  readLinkTiming,
+  syncOffsetFrames
+} from "./chunk-6JR2XUEE.js";
+import {
+  readCompositionFps
+} from "./chunk-KXTKKBOC.js";
+import {
+  HF_AUDIO_GROUP_ATTR,
+  extractAudioMetadata,
+  extractMediaMetadata
+} from "./chunk-TIQB63MX.js";
+import {
+  byStart,
+  fpsToNumber,
+  parseFpsWithDefault
+} from "./chunk-DLA44CMS.js";
+import {
+  HF_AUDIO_AUTOMATION_ATTR,
+  HF_AUDIO_FX_ATTR,
+  parseAudioFxChain,
+  parseAutomation,
+  resolveAutomation
+} from "./chunk-UJZREAV6.js";
+import {
+  isSubCompositionHost,
+  topLevelElements,
+  trackKindOf
+} from "./chunk-B7RJV74O.js";
+import {
+  resolveReferencedDuration,
+  resolveReferencedStart
+} from "./chunk-4P7NX5BM.js";
+import {
+  resolveAuthoredAssetFile
+} from "./chunk-6BNTGNGD.js";
+import {
+  compositionOriginSeconds,
+  cutToHostSlots,
+  hostInPointSeconds,
+  parseNumeric,
+  resolveMediaStartSeconds
+} from "./chunk-MMQ52NIZ.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 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 found = resolveAuthoredAssetFile(scope.projectDir, scope.file, src);
+  const file = found && realFileInside(scope.projectDir, found);
+  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 inside = isSubCompositionHost(node) ? [] : await Promise.all(topLevelElements(node).map((inner) => describeRow(scope, inner, depth)));
+  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, inside, 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,
+    inside: timing.inside,
+    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(toDomNode(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);
+  const inside = row.inside.flatMap((inner) => cutRow(inner, slots));
+  return [{ ...row, absStart: roundMs(kept.start), absEnd: roundMs(kept.end), mediaStart, inside }];
+}
+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 = [];
+  const add = (clip, host, parent) => {
+    entries.push({ clip, host, parent });
+    for (const inner of clip.inside) add(inner, host, clip);
+    for (const child of clip.children) add(child, clip, null);
+  };
+  for (const clip of top) add(clip, null, null);
+  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, parent }, 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>'
+        ],
+        ...neverVisibleWarning(clip, parent)
+      ];
+      return {
+        ...clip,
+        index,
+        ref,
+        warnings,
+        nested: host !== null,
+        host: host && host.id,
+        hostRow: host && at(host),
+        children: [...clip.children, ...clip.inside].map(at),
+        parentRow: parent && at(parent)
+      };
+    })
+  }));
+}
+var NEVER_VISIBLE = "never visible";
+function neverVisibleWarning(clip, parent) {
+  if (!parent || clip.kind === "audio") return [];
+  if (clip.absEnd <= clip.absStart || parent.absEnd <= parent.absStart) return [];
+  if (clip.absEnd > parent.absStart && clip.absStart < parent.absEnd) return [];
+  const name = parent.elementId ? `#${parent.elementId}` : `its parent <${parent.kind}>`;
+  return [
+    `${NEVER_VISIBLE}: plays ${clip.absStart}-${clip.absEnd}s, but ${name} only shows ${parent.absStart}-${parent.absEnd}s; a nested data-start counts from the composition, not from ${name}`
+  ];
+}
+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(toDomNode(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 {
+  NEVER_VISIBLE,
+  describeProject
+};