hyperframes 0.8.138 → 0.8.140

package/dist/{chunk-FSSMOTMS.js → chunk-BJ5JWOES.js}

@@ -7,7 +7,7 @@ var __dirname = __hf_dirname(__filename);
 
 // src/utils/producer.ts
 async function loadProducer() {
-  return await import("./src-HH4C5GZV.js");
+  return await import("./src-RXTXL3VL.js");
 }
 
 export {

package/dist/{chunk-OBC75KXL.js → chunk-BQKEGPPL.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   resolveCaptureBrowserGpuMode
-} from "./chunk-PHRWQQOJ.js";
+} from "./chunk-PE2I3AFA.js";
 import {
   requestCliExit
 } from "./chunk-PBN6GBJE.js";

package/dist/{chunk-SHB5VDMH.js → chunk-BRITLL56.js}

@@ -9,7 +9,7 @@ import {
   buildAuthHeaders,
   refreshTokens,
   resolveCredential
-} from "./chunk-I465DBM6.js";
+} from "./chunk-246MOR5U.js";
 
 // src/cloud/auth.ts
 async function resolveCloudAuthHeaders() {

package/dist/{chunk-VR5UQWGV.js → chunk-C2JUHIG5.js}

@@ -7,12 +7,9 @@ var __dirname = __hf_dirname(__filename);
 import {
   diag
 } from "./chunk-VWG7OQKU.js";
-import {
-  c
-} from "./chunk-ZTZA4UWZ.js";
 import {
   getSystemMeta
-} from "./chunk-MIOBYUXT.js";
+} from "./chunk-GQJZORQP.js";
 import {
   getInvocationId
 } from "./chunk-54HJ63Q2.js";
@@ -23,7 +20,7 @@ import {
   evaluateCanary,
   findCanary,
   parseCanaryOverride
-} from "./chunk-RLNB3JCY.js";
+} from "./chunk-FXMKHHPO.js";
 import {
   hostAnswers
 } from "./chunk-K4WIOZFP.js";
@@ -37,7 +34,10 @@ import {
 } from "./chunk-XUXGIA7H.js";
 import {
   VERSION
-} from "./chunk-P75OFLZN.js";
+} from "./chunk-MUINFURL.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
 
 // src/telemetry/transport.ts
 import { spawn } from "child_process";

package/dist/{chunk-YNBXJWSD.js → chunk-DDQ4LOML.js}

@@ -17,7 +17,7 @@ import {
 } from "./chunk-ISN5GRYI.js";
 import {
   VERSION
-} from "./chunk-P75OFLZN.js";
+} from "./chunk-MUINFURL.js";
 
 // src/utils/updateCheck.ts
 import { existsSync, readFileSync } from "fs";

package/dist/{chunk-HUZYBV2Z.js → chunk-DQNOPYAG.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   VERSION
-} from "./chunk-P75OFLZN.js";
+} from "./chunk-MUINFURL.js";
 
 // src/registry/compatibility.ts
 import { compareVersions } from "compare-versions";

package/dist/{chunk-JH556Q42.js → chunk-EDYBFSPE.js}

@@ -6,13 +6,13 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   refreshIfNeeded
-} from "./chunk-SHB5VDMH.js";
+} from "./chunk-BRITLL56.js";
 import {
   buildAuthHeaders,
   isAuthError,
   isTokenExpired,
   tryResolveCredential
-} from "./chunk-I465DBM6.js";
+} from "./chunk-246MOR5U.js";
 import {
   CSS_URL_RE,
   isNonRelativeUrl,

package/dist/{chunk-SIMYRD5P.js → chunk-F3SPK6SO.js}

@@ -4,9 +4,12 @@ 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 {
+  emitWords
+} from "./chunk-6IHWCZ3W.js";
 import {
   stoppedByCancelSignal
-} from "./chunk-DJMXTKKK.js";
+} from "./chunk-LQG6GPVK.js";
 import {
   DEFAULT_MODEL,
   ensureModel,
@@ -18,25 +21,18 @@ import {
   findFFprobe,
   getFFmpegInstallHint
 } from "./chunk-TVCRUG2S.js";
+import {
+  findWavChunk
+} from "./chunk-UOFAE5RF.js";
 
 // src/whisper/transcribe.ts
-import { execFileSync } from "child_process";
+import { execFile, execFileSync } from "child_process";
+import { once } from "events";
+import { createInterface } from "readline";
 import { existsSync, readFileSync, mkdirSync, rmSync, statSync, unlinkSync } from "fs";
 import { join, extname } from "path";
 import { tmpdir } from "os";
 import { randomUUID } from "crypto";
-function findWavDataChunk(buf) {
-  if (buf.length < 12) return null;
-  let pos = 12;
-  while (pos + 8 < buf.length) {
-    const id = buf.toString("ascii", pos, pos + 4);
-    const size = buf.readUInt32LE(pos + 4);
-    if (id === "data") return { offset: pos + 8, size: Math.min(size, buf.length - pos - 8) };
-    pos += 8 + size;
-    if (size % 2 !== 0) pos++;
-  }
-  return null;
-}
 var WHISPER_TIMEOUT_FLOOR_MS = 3e5;
 var WHISPER_TIMEOUT_PER_AUDIO_SECOND_MS = 1e4;
 var WHISPER_TIMEOUT_CAP_MS = 432e5;
@@ -129,7 +125,7 @@ function detectSpeechOnset(wavPath) {
   const MIN_INTRO_SECONDS = 3;
   try {
     const buf = readFileSync(wavPath);
-    const dataChunk = findWavDataChunk(buf);
+    const dataChunk = findWavChunk(buf, "data");
     if (!dataChunk) return null;
     const pcm = new Int16Array(buf.buffer, buf.byteOffset + dataChunk.offset, dataChunk.size / 2);
     const totalWindows = Math.floor(pcm.length / WINDOW_SAMPLES);
@@ -293,7 +289,14 @@ async function transcribe(inputPath, outputDir, options) {
   const automaticLanguage = options?.language === void 0 && !model.endsWith(".en");
   const language = options?.language ?? (automaticLanguage ? "auto" : "en");
   options?.onProgress?.("Transcribing...");
-  options?.onEvent?.({ type: "progress", phase: "transcription", model, status: "started" });
+  const wavSeconds = getPreparedWavDurationSeconds(wavPath);
+  options?.onEvent?.({
+    type: "progress",
+    phase: "transcription",
+    model,
+    status: "started",
+    durationSeconds: wavSeconds
+  });
   const outputBase = join(outputDir, "transcript");
   mkdirSync(outputDir, { recursive: true });
   const whisperArgs = [
@@ -307,15 +310,31 @@ async function transcribe(inputPath, outputDir, options) {
     "--suppress-nst"
   ];
   whisperArgs.push("--language", language);
+  const onEvent = options?.onEvent;
+  if (onEvent) whisperArgs.push("--print-progress");
   whisperArgs.push(wavPath);
-  const whisperTimeoutMs = resolveWhisperTimeoutMs(getPreparedWavDurationSeconds(wavPath), {
+  const whisperTimeoutMs = resolveWhisperTimeoutMs(wavSeconds, {
     model,
     overrideMs: options?.timeoutMs
   });
+  let through = 0;
+  const heard = (words, at) => {
+    if (!onEvent || words.length === 0 && at <= through) return;
+    through = Math.max(through, at);
+    emitWords(onEvent, model, words, through);
+  };
   try {
-    execFileSync(whisper.executablePath, whisperArgs, {
-      stdio: "ignore",
-      timeout: whisperTimeoutMs
+    await runWhisper(whisper.executablePath, whisperArgs, {
+      timeoutMs: whisperTimeoutMs,
+      signal: options?.startCancellation?.(),
+      onStdout: onEvent && ((line) => {
+        const segment = segmentWords(line);
+        if (segment) heard(segment.words, segment.end);
+      }),
+      onStderr: onEvent && wavSeconds ? (line) => {
+        const percent = /progress =\s*(\d+)%/.exec(line)?.[1];
+        if (percent) heard([], Number(percent) / 100 * wavSeconds);
+      } : void 0
     });
   } catch (err) {
     throw wrapWhisperTimeoutError(err, {
@@ -359,6 +378,45 @@ async function transcribe(inputPath, outputDir, options) {
     speechOnsetSeconds
   };
 }
+var SEGMENT_LINE = /^\[(\d+):(\d+):([\d.]+) --> (\d+):(\d+):([\d.]+)\]\s*(.*)$/;
+var toSeconds = (h, m, s) => Number(h) * 3600 + Number(m) * 60 + Number(s);
+var toMs = (seconds) => Math.round(seconds * 1e3) / 1e3;
+function segmentWords(line) {
+  const m = SEGMENT_LINE.exec(line);
+  if (!m) return null;
+  const start = toSeconds(m[1], m[2], m[3]);
+  const end = toSeconds(m[4], m[5], m[6]);
+  const texts = m[7].split(/\s+/).filter((t) => t && !t.startsWith("[_") && !t.startsWith("[BLANK"));
+  const letters = texts.reduce((n, t) => n + t.length, 0);
+  let at = start;
+  const words = texts.map((text) => {
+    const from = at;
+    at += (end - start) * text.length / letters;
+    return { text, start: toMs(from), end: toMs(at) };
+  });
+  return { words, end };
+}
+async function runWhisper(executable, args, options) {
+  let stdout = null;
+  let stderr = null;
+  const exited = new Promise((resolve, reject) => {
+    const child = execFile(
+      executable,
+      args,
+      { timeout: options.timeoutMs, signal: options.signal, maxBuffer: 256 * 1024 * 1024 },
+      (err, _out, errText) => {
+        if (!err) return resolve();
+        const timedOut = err.killed && err.signal === "SIGTERM" && !options.signal?.aborted;
+        err.message = err.message.split("\n")[0];
+        reject(Object.assign(err, { stderr: errText }, timedOut ? { code: "ETIMEDOUT" } : {}));
+      }
+    );
+    stdout = child.stdout;
+    stderr = child.stderr;
+  });
+  const read = (stream, onLine) => stream && onLine ? once(createInterface({ input: stream }).on("line", onLine), "close") : null;
+  await Promise.all([exited, read(stdout, options.onStdout), read(stderr, options.onStderr)]);
+}
 function isWhisperTimeoutError(err) {
   return err instanceof Error && err.code === "ETIMEDOUT";
 }

package/dist/chunk-FXMKHHPO.js

@@ -0,0 +1,123 @@
+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);
+
+// ../core/dist/canary.js
+function fnv1a32(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash + ((hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24)) >>> 0;
+  }
+  return hash >>> 0;
+}
+function canaryBucket(feature, unitId) {
+  return fnv1a32(`${feature}:${unitId}`) % 100;
+}
+function evaluateCanary(input) {
+  if (input.override === true)
+    return { enabled: true, reason: "forced_on" };
+  if (input.override === false)
+    return { enabled: false, reason: "forced_off" };
+  const pct = Math.max(0, Math.min(100, Math.trunc(input.percentage)));
+  if (pct <= 0)
+    return { enabled: false, reason: "out_of_cohort" };
+  if (pct >= 100)
+    return { enabled: true, reason: "in_cohort" };
+  if (input.exclude)
+    return { enabled: false, reason: "excluded" };
+  const unitId = input.unitId?.trim();
+  if (!unitId)
+    return { enabled: false, reason: "no_unit_id" };
+  const bucket = canaryBucket(input.feature, unitId);
+  return bucket < pct ? { enabled: true, reason: "in_cohort", bucket } : { enabled: false, reason: "out_of_cohort", bucket };
+}
+function parseCanaryOverride(raw) {
+  const v = raw?.trim().toLowerCase();
+  if (v === void 0 || v === "")
+    return void 0;
+  if (v === "1" || v === "true" || v === "on" || v === "yes")
+    return true;
+  if (v === "0" || v === "false" || v === "off" || v === "no")
+    return false;
+  return void 0;
+}
+var CANARY_FEATURE_PREFIX = "$feature/canary-";
+function canaryFeatureKey(name) {
+  return `${CANARY_FEATURE_PREFIX}${name}`;
+}
+function canaryReasonKey(name) {
+  return `canary_reason_${name.replace(/[^A-Za-z0-9]+/g, "_")}`;
+}
+function canaryFeatureProperties(entries) {
+  const props = {};
+  for (const entry of entries) {
+    props[canaryFeatureKey(entry.name)] = entry.enabled ? "true" : "false";
+    if (entry.reason !== void 0)
+      props[canaryReasonKey(entry.name)] = entry.reason;
+  }
+  return props;
+}
+
+// ../core/dist/canaryRegistry.js
+var CANARIES = [
+  // ── Calibration ──────────────────────────────────────────────────────────
+  // Two INERT canaries that gate nothing. They exist to validate the rollout
+  // mechanism against real traffic before anything real depends on it, and
+  // they answer questions the synthetic tests cannot:
+  //
+  //   1. Does a requested percentage land on target in the wild? The unit
+  //      tests use generated UUIDs and weight every install equally; real
+  //      render volume is heavily skewed toward a few heavy installs, so the
+  //      render-weighted share could differ from the install-weighted one.
+  //   2. How fast does CUMULATIVE exposure drift above the target? Install
+  //      ids churn (measured: 24.7x more distinct ids over 30 days than in
+  //      any single day), so the set of installs enrolled AT SOME POINT grows
+  //      even though the instantaneous share stays flat. That drift is the
+  //      real limit on a canary's blast-radius guarantee.
+  //   3. Are two canaries actually independent on real ids, not just on
+  //      generated ones? Overlap should be ~p1*p2, not ~min(p1,p2).
+  //
+  // Two different percentages so the answer is a line, not a point.
+  // Delete both once the calibration window is read.
+  {
+    name: "calibration-10",
+    percentage: 10,
+    description: "Inert. Validates rollout accuracy and cumulative-exposure drift at 10%.",
+    owner: "vance",
+    sunsetAfter: "2026-09-15"
+  },
+  {
+    name: "calibration-50",
+    percentage: 50,
+    description: "Inert. Second calibration point, and an independence check against calibration-10.",
+    owner: "vance",
+    sunsetAfter: "2026-09-15"
+  }
+];
+function findCanary(name) {
+  return CANARIES.find((c) => c.name === name);
+}
+function canaryEnvVar(name) {
+  return `HF_CANARY_${name.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}`;
+}
+function overdueCanaries(now = /* @__PURE__ */ new Date()) {
+  return CANARIES.filter((c) => {
+    const sunsetEnd = Date.parse(`${c.sunsetAfter}T23:59:59.999Z`);
+    return Number.isFinite(sunsetEnd) && now.getTime() > sunsetEnd;
+  }).map((c) => c.name);
+}
+
+export {
+  canaryBucket,
+  evaluateCanary,
+  parseCanaryOverride,
+  canaryFeatureProperties,
+  CANARIES,
+  findCanary,
+  canaryEnvVar,
+  overdueCanaries
+};

package/dist/chunk-G75ENCEZ.js

@@ -0,0 +1,283 @@
+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 {
+  STUDIO_MANUAL_EDITS_PATH
+} from "./chunk-KC5XXX3X.js";
+import {
+  realpath,
+  resolveWithinProject
+} from "./chunk-OFQWTKPW.js";
+
+// ../studio-server/dist/chunk-4ETS2LXI.js
+var STUDIO_MOTION_PATH = ".hyperframes/studio-motion.json";
+function hasStudioMotionEntries(manifestContent) {
+  try {
+    const parsed = JSON.parse(manifestContent);
+    return Array.isArray(parsed.motions) && parsed.motions.length > 0;
+  } catch {
+    return false;
+  }
+}
+function createStudioMotionRenderBodyScript(manifestContent, options = {}) {
+  if (!manifestContent.trim() || !hasStudioMotionEntries(manifestContent)) return null;
+  return `(${studioMotionRenderRuntime.toString()})(${JSON.stringify(manifestContent)}, ${JSON.stringify(options.activeCompositionPath ?? null)});`;
+}
+function studioMotionRenderRuntime(manifestContent, activeCompositionPath) {
+  const STUDIO_MOTION_TIMELINE_ID = "studio-motion";
+  const STUDIO_MOTION_ATTR = "data-hf-studio-motion";
+  const ORIGINAL_TRANSFORM_ATTR = "data-hf-studio-motion-original-transform";
+  const ORIGINAL_OPACITY_ATTR = "data-hf-studio-motion-original-opacity";
+  const ORIGINAL_VISIBILITY_ATTR = "data-hf-studio-motion-original-visibility";
+  const objectRecord = (value) => value && typeof value === "object" ? value : null;
+  const finiteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+  const runtimeWindow = window;
+  const parseMotionValues = (value) => {
+    const record = objectRecord(value);
+    if (!record) return null;
+    const parsed = {};
+    for (const key of ["x", "y", "scale", "rotation", "opacity", "autoAlpha"]) {
+      const next = finiteNumber(record[key]);
+      if (next != null) parsed[key] = next;
+    }
+    return Object.keys(parsed).length > 0 ? parsed : null;
+  };
+  const parseCustomEase = (value) => {
+    const record = objectRecord(value);
+    if (!record) return null;
+    const id = typeof record.id === "string" ? record.id.trim() : "";
+    const data = typeof record.data === "string" ? record.data.trim() : "";
+    if (!id || !data) return null;
+    return { id, data };
+  };
+  const parsedManifest = (() => {
+    try {
+      return objectRecord(JSON.parse(manifestContent));
+    } catch {
+      return null;
+    }
+  })();
+  const manifestMotions = Array.isArray(parsedManifest?.motions) ? parsedManifest.motions : [];
+  const sourceFileForElement = (element) => {
+    let current = element;
+    while (current) {
+      const sourceFile = current.getAttribute("data-composition-file") ?? current.getAttribute("data-composition-src");
+      if (sourceFile) return sourceFile;
+      current = current.parentElement;
+    }
+    return activeCompositionPath ?? "index.html";
+  };
+  const elementMatchesSourceFile = (element, sourceFile) => sourceFileForElement(element) === sourceFile;
+  const isHTMLElement = (element) => element instanceof HTMLElement;
+  const querySelectorCandidates = (selector) => {
+    const className = selector.match(/^\.([A-Za-z0-9_-]+)$/)?.[1];
+    if (className) {
+      return Array.from(document.getElementsByTagName("*")).filter(
+        (element) => isHTMLElement(element) && element.classList.contains(className)
+      );
+    }
+    if (/^[A-Za-z][A-Za-z0-9-]*$/.test(selector)) {
+      return Array.from(document.getElementsByTagName(selector)).filter(isHTMLElement);
+    }
+    return Array.from(document.querySelectorAll(selector)).filter(isHTMLElement);
+  };
+  const resolveTarget = (targetRecord) => {
+    const sourceFile = typeof targetRecord.sourceFile === "string" ? targetRecord.sourceFile : "";
+    if (!sourceFile) return null;
+    const id = typeof targetRecord.id === "string" ? targetRecord.id : "";
+    if (id) {
+      const byId = document.getElementById(id);
+      if (isHTMLElement(byId) && elementMatchesSourceFile(byId, sourceFile)) return byId;
+    }
+    const selector = typeof targetRecord.selector === "string" ? targetRecord.selector : "";
+    if (!selector) return null;
+    try {
+      const selectorIndex = Math.max(0, Math.floor(finiteNumber(targetRecord.selectorIndex) ?? 0));
+      return querySelectorCandidates(selector).filter(
+        (element) => elementMatchesSourceFile(element, sourceFile)
+      )[selectorIndex] ?? null;
+    } catch {
+      return null;
+    }
+  };
+  const restoreElement = (element) => {
+    runtimeWindow.gsap?.set?.(element, { clearProps: "transform,opacity,visibility" });
+    element.style.transform = element.getAttribute(ORIGINAL_TRANSFORM_ATTR) ?? "";
+    element.style.opacity = element.getAttribute(ORIGINAL_OPACITY_ATTR) ?? "";
+    element.style.visibility = element.getAttribute(ORIGINAL_VISIBILITY_ATTR) ?? "";
+    element.removeAttribute(STUDIO_MOTION_ATTR);
+    element.removeAttribute(ORIGINAL_TRANSFORM_ATTR);
+    element.removeAttribute(ORIGINAL_OPACITY_ATTR);
+    element.removeAttribute(ORIGINAL_VISIBILITY_ATTR);
+  };
+  const restoreStudioMotionElements = () => {
+    for (const element of Array.from(document.querySelectorAll(`[${STUDIO_MOTION_ATTR}]`))) {
+      if (isHTMLElement(element)) restoreElement(element);
+    }
+  };
+  const readCurrentTime = () => {
+    try {
+      const playerTime = runtimeWindow.__player?.getTime?.();
+      if (typeof playerTime === "number" && Number.isFinite(playerTime)) {
+        return Math.max(0, playerTime);
+      }
+    } catch {
+    }
+    try {
+      const timelineTime = runtimeWindow.__timeline?.time?.();
+      if (typeof timelineTime === "number" && Number.isFinite(timelineTime)) {
+        return Math.max(0, timelineTime);
+      }
+    } catch {
+    }
+    return 0;
+  };
+  const resolveEase = (motion) => {
+    const fallback = typeof motion.ease === "string" && motion.ease.trim() ? motion.ease.trim() : "none";
+    const customEase = parseCustomEase(motion.customEase);
+    const customEasePlugin = runtimeWindow.CustomEase;
+    if (!customEase || typeof customEasePlugin?.create !== "function") return fallback;
+    try {
+      runtimeWindow.gsap?.registerPlugin?.(customEasePlugin);
+      customEasePlugin.create(customEase.id, customEase.data);
+      return customEase.id;
+    } catch {
+      return fallback;
+    }
+  };
+  const applyManifest = () => {
+    runtimeWindow.__timelines = runtimeWindow.__timelines ?? {};
+    runtimeWindow.__timelines[STUDIO_MOTION_TIMELINE_ID]?.kill?.();
+    delete runtimeWindow.__timelines[STUDIO_MOTION_TIMELINE_ID];
+    restoreStudioMotionElements();
+    const gsap = runtimeWindow.gsap;
+    if (!gsap?.timeline || manifestMotions.length === 0) return 0;
+    const timeline = gsap.timeline({ paused: true, defaults: { overwrite: "auto" } });
+    let applied = 0;
+    for (const motionValue of manifestMotions) {
+      const motion = objectRecord(motionValue);
+      if (!motion || motion.kind !== "gsap-motion") continue;
+      const targetRecord = objectRecord(motion.target);
+      if (!targetRecord) continue;
+      const target = resolveTarget(targetRecord);
+      if (!target || typeof timeline.fromTo !== "function") continue;
+      const start = finiteNumber(motion.start);
+      const duration = finiteNumber(motion.duration);
+      if (start == null || duration == null || start < 0 || duration <= 0) continue;
+      const from = parseMotionValues(motion.from);
+      const to = parseMotionValues(motion.to);
+      if (!from || !to) continue;
+      if (!target.hasAttribute(STUDIO_MOTION_ATTR)) {
+        target.setAttribute(ORIGINAL_TRANSFORM_ATTR, target.style.transform);
+        target.setAttribute(ORIGINAL_OPACITY_ATTR, target.style.opacity);
+        target.setAttribute(ORIGINAL_VISIBILITY_ATTR, target.style.visibility);
+      }
+      target.setAttribute(STUDIO_MOTION_ATTR, "true");
+      timeline.fromTo(
+        target,
+        from,
+        { ...to, duration, ease: resolveEase(motion), overwrite: "auto", immediateRender: false },
+        start
+      );
+      applied += 1;
+    }
+    if (applied === 0) {
+      timeline.kill?.();
+      return 0;
+    }
+    runtimeWindow.__timelines[STUDIO_MOTION_TIMELINE_ID] = timeline;
+    timeline.pause?.();
+    const currentTime = readCurrentTime();
+    if (typeof timeline.totalTime === "function") timeline.totalTime(currentTime, false);
+    else timeline.time?.(currentTime);
+    return applied;
+  };
+  runtimeWindow.__hfStudioMotionApply = applyManifest;
+  applyManifest();
+}
+
+// ../studio-server/dist/chunk-DTKK7TKL.js
+import { basename, dirname, isAbsolute, join, relative, sep } from "path";
+import { readdirSync } from "fs";
+function resolveWithinProject2(base, relativePath) {
+  const resolved = resolveWithinProject(base, relativePath);
+  return resolved && !isPrivateProjectFile(base, resolved) ? resolved : null;
+}
+function realFilePath(filePath) {
+  try {
+    return realpath(filePath);
+  } catch {
+    const dir = dirname(filePath);
+    return dir === filePath ? filePath : join(realFilePath(dir), basename(filePath));
+  }
+}
+var STUDIO_FILES = /* @__PURE__ */ new Set([STUDIO_MOTION_PATH, STUDIO_MANUAL_EDITS_PATH]);
+var STUDIO_FOLDERS = [".hyperframes/prepared-assets", ".hyperframes/requests"];
+function isPrivateProjectPath(relPath) {
+  const path = relPath.toLowerCase();
+  return (path === ".hyperframes" || path.startsWith(".hyperframes/")) && !STUDIO_FILES.has(path) && !STUDIO_FOLDERS.some((folder) => path === folder || path.startsWith(`${folder}/`));
+}
+function isPrivateProjectFile(projectDir, filePath) {
+  const rel = (from, to) => relative(from, to).split(sep).join("/");
+  return [rel(projectDir, filePath), rel(realFilePath(projectDir), realFilePath(filePath))].some(
+    isPrivateProjectPath
+  );
+}
+function pinWithinProject(base, relativePath) {
+  const checked = resolveWithinProject2(base, relativePath);
+  if (!checked) return null;
+  const inside = relative(realFilePath(base), realFilePath(checked));
+  const escapes = inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside);
+  return escapes ? null : join(base, inside);
+}
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  ".thumbnails",
+  ".transcode-cache",
+  ".waveform-cache",
+  "node_modules",
+  ".git"
+]);
+function shouldIgnoreDir(rel) {
+  return rel === ".hyperframes/backup";
+}
+function isInHiddenOrVendorDir(relPath) {
+  const segments = relPath.split("/");
+  return segments.slice(0, -1).some((seg) => seg.startsWith(".") || seg === "node_modules");
+}
+var UNREADABLE_DIR_CODES = /* @__PURE__ */ new Set(["EACCES", "EPERM", "ENOENT", "ENOTDIR"]);
+function walkDir(dir, prefix = "") {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    const code = err.code;
+    if (!prefix || !code || !UNREADABLE_DIR_CODES.has(code)) throw err;
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (IGNORE_DIRS.has(entry.name) || shouldIgnoreDir(rel)) continue;
+    if (entry.isDirectory()) {
+      files.push(...walkDir(join(dir, entry.name), rel));
+    } else {
+      files.push(rel);
+    }
+  }
+  return files;
+}
+
+export {
+  STUDIO_MOTION_PATH,
+  createStudioMotionRenderBodyScript,
+  resolveWithinProject2 as resolveWithinProject,
+  realFilePath,
+  isPrivateProjectPath,
+  isPrivateProjectFile,
+  pinWithinProject,
+  isInHiddenOrVendorDir,
+  walkDir
+};

package/dist/{chunk-MIOBYUXT.js → chunk-GQJZORQP.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-AMKC3AXA.js";
 import {
   getSystemTotalMb
-} from "./chunk-7Y5SMPRV.js";
+} from "./chunk-USDEMXXL.js";
 
 // src/telemetry/system.ts
 import { cpus, freemem, platform as platform2, release as release2 } from "os";

package/dist/{chunk-Y6W4DVPS.js → chunk-HKCNZITN.js}

@@ -8,7 +8,7 @@ import {
   forceRefreshCredentials,
   resolveCloudAuthHeaders,
   resolveCloudBaseUrl
-} from "./chunk-SHB5VDMH.js";
+} from "./chunk-BRITLL56.js";
 import {
   errorBox
 } from "./chunk-IHFUKJOR.js";