hyperframes 0.8.137 → 0.8.139

package/dist/{chunk-J4AOOISS.js → chunk-A4X2YWNQ.js}

@@ -4,11 +4,14 @@ 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 {
   firstFrameColourArgs,
   hdrToSdrToneMapFilter,
   parseFirstFrameColour
-} from "./chunk-SCCJUPPX.js";
+} from "./chunk-EJ7OWYF2.js";
 import {
   mkdirWithinProject,
   realProjectRoot,
@@ -21,7 +24,7 @@ import {
   isUnresolvedAssetPlaceholder,
   maskNonScannableRanges,
   resolveLocalAssetCandidates
-} from "./chunk-VDQCNWQI.js";
+} from "./chunk-STA43FMY.js";
 import {
   findFfBinary
 } from "./chunk-PJ3HDUCY.js";
@@ -29,9 +32,200 @@ import {
   rewriteAssetPath
 } from "./chunk-TQFG7HTI.js";
 
-// ../studio-server/dist/chunk-TTWLTYSQ.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);
@@ -40,8 +234,20 @@ function realFilePath(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 = resolveWithinProject(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);
@@ -84,7 +290,7 @@ function walkDir(dir, prefix = "") {
   return files;
 }
 
-// ../studio-server/dist/chunk-I3DRHG52.js
+// ../studio-server/dist/chunk-74JVVCWL.js
 import { existsSync, statSync } from "fs";
 import { relative as relative2, resolve, sep as sep2 } from "path";
 import { execFile } from "child_process";
@@ -390,7 +596,7 @@ async function scanProjectMediaCodecMap(projectDir, htmlSources, options = {}) {
   return map;
 }
 
-// ../studio-server/dist/chunk-YOBWV2CY.js
+// ../studio-server/dist/chunk-6RFZWPPN.js
 import { spawn } from "child_process";
 import { createHash, randomUUID } from "crypto";
 import { existsSync as existsSync2, renameSync, statSync as statSync2, unlinkSync as unlinkSync2, utimesSync } from "fs";
@@ -830,7 +1036,12 @@ async function resolveProxy(projectDir, absoluteSourcePath, variant = "h264") {
 }
 
 export {
+  STUDIO_MOTION_PATH,
+  createStudioMotionRenderBodyScript,
+  resolveWithinProject2 as resolveWithinProject,
   realFilePath,
+  isPrivateProjectPath,
+  isPrivateProjectFile,
   pinWithinProject,
   isInHiddenOrVendorDir,
   walkDir,

package/dist/{chunk-E6WZHX7J.js → chunk-BC3OY2ED.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   setHostHandlesSigint
-} from "./chunk-TTBOUHWT.js";
+} from "./chunk-QXOFUKBF.js";
 import {
   processAncestorSnapshot,
   processIdentity,

package/dist/{chunk-GR7YLWXS.js → chunk-CDJ7FPPJ.js}

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

package/dist/{chunk-4LBBWEEH.js → chunk-CDMB3PRC.js}

@@ -7,16 +7,16 @@ var __dirname = __hf_dirname(__filename);
 import {
   parseFeedbackRating,
   trackRenderFeedback
-} from "./chunk-WTGGSKAJ.js";
+} from "./chunk-25DHUDOK.js";
 import {
   shouldTrack
-} from "./chunk-X2GKNLHE.js";
+} from "./chunk-7SI7GCX6.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
 import {
   detectAgentRuntime
-} from "./chunk-OEJQAXS3.js";
+} from "./chunk-PLNWWGE7.js";
 import {
   readConfig,
   writeConfig
@@ -83,7 +83,7 @@ async function maybePromptRenderFeedback(opts) {
 async function getDoctorSummary() {
   try {
     const [{ getSystemMeta }, { findFFmpeg }] = await Promise.all([
-      import("./system-SXBUUXBG.js"),
+      import("./system-RCRNX5VF.js"),
       import("./ffmpeg-QIUFEFTY.js")
     ]);
     const sys = getSystemMeta();

package/dist/chunk-DCAI5DBR.js

@@ -0,0 +1,218 @@
+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 {
+  replaceFileAtomically
+} from "./chunk-EOVYQ3IG.js";
+import {
+  realpath
+} from "./chunk-OFQWTKPW.js";
+
+// src/utils/appHistory.ts
+import { createHash } from "crypto";
+import { lstatSync as lstatSync2, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join as join2, relative, resolve, sep } from "path";
+
+// src/utils/projectRecords.ts
+import { closeSync, constants, fstatSync, lstatSync, mkdirSync, openSync, readSync } from "fs";
+import { join } from "path";
+var NO_FOLLOW = constants.O_NOFOLLOW ?? 0;
+var NON_BLOCK = constants.O_NONBLOCK ?? 0;
+function recordsDir(projectDir, create = false) {
+  const dir = join(projectDir, ".hyperframes");
+  try {
+    return lstatSync(dir).isDirectory() ? dir : null;
+  } catch {
+    if (!create) return null;
+    try {
+      mkdirSync(dir);
+      return dir;
+    } catch {
+      return null;
+    }
+  }
+}
+function readPlainFile(path, maxBytes) {
+  let fd;
+  try {
+    fd = openSync(path, constants.O_RDONLY | NO_FOLLOW | NON_BLOCK);
+  } catch {
+    return "";
+  }
+  try {
+    const stats = fstatSync(fd);
+    const named = lstatSync(path);
+    if (!stats.isFile() || !named.isFile() || named.ino !== stats.ino || named.dev !== stats.dev)
+      return "";
+    const length = Math.min(stats.size, maxBytes);
+    const buffer = Buffer.alloc(length);
+    readSync(fd, buffer, 0, length, stats.size - length);
+    return buffer.toString("utf8");
+  } catch {
+    return "";
+  } finally {
+    closeSync(fd);
+  }
+}
+function readRecord(projectDir, name, maxBytes) {
+  const dir = recordsDir(projectDir);
+  return dir ? readPlainFile(join(dir, name), maxBytes) : "";
+}
+function recordChangedAt(projectDir, name) {
+  const dir = recordsDir(projectDir);
+  try {
+    const stats = dir ? lstatSync(join(dir, name)) : null;
+    return stats?.isFile() ? stats.mtimeMs : 0;
+  } catch {
+    return 0;
+  }
+}
+function replaceFile(path, data, mode) {
+  try {
+    replaceFileAtomically(path, data, mode);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeRecord(projectDir, name, data) {
+  const dir = recordsDir(projectDir, true);
+  return dir !== null && replaceFile(join(dir, name), data, 384);
+}
+
+// src/utils/appHistory.ts
+var APP_HISTORY = "app-history.jsonl";
+var MAX_READ_BYTES = 1024 * 1024;
+var MAX_FIELD_CHARS = 2e3;
+var MAX_WALKED_FILES = 5e3;
+var SKIPPED_DIRS = /* @__PURE__ */ new Set(["node_modules", "renders", "snapshots"]);
+var text = (value) => typeof value === "string" ? value.slice(0, MAX_FIELD_CHARS) : "";
+function toTurn(line) {
+  let raw;
+  try {
+    raw = Object(JSON.parse(line));
+  } catch {
+    return null;
+  }
+  const at = text(raw.at);
+  if (Number.isNaN(Date.parse(at))) return null;
+  const files = Array.isArray(raw.files) ? raw.files.map(text).filter(Boolean) : [];
+  return { at, engine: text(raw.engine), asked: text(raw.asked), did: text(raw.did), files };
+}
+function readAppTurns(dir) {
+  return readRecord(dir, APP_HISTORY, MAX_READ_BYTES).split("\n").flatMap((line) => toTurn(line) ?? []);
+}
+var stamp = (value) => typeof value === "string" ? Date.parse(value) || 0 : 0;
+function seenPath(dir) {
+  let real;
+  try {
+    real = realpath(dir);
+  } catch {
+    real = resolve(dir);
+  }
+  const key = createHash("sha256").update(real).digest("hex").slice(0, 32);
+  return join2(homedir(), ".hyperframes", "catch-up", `${key}.json`);
+}
+function readSeen(dir) {
+  try {
+    const seen = Object(JSON.parse(readPlainFile(seenPath(dir), 4096)));
+    const at = stamp(seen.at);
+    return { at, checked: stamp(seen.checked) || at };
+  } catch {
+    return { at: 0, checked: 0 };
+  }
+}
+function markSeen(dir, seen) {
+  const path = seenPath(dir);
+  const at = (time) => new Date(time).toISOString();
+  try {
+    mkdirSync2(dirname(path), { recursive: true, mode: 448 });
+  } catch {
+    return false;
+  }
+  return replaceFile(path, JSON.stringify({ at: at(seen.at), checked: at(seen.checked) }), 384);
+}
+function unseenTurns(dir, since, now = Date.now()) {
+  if (!since) return [];
+  return readAppTurns(dir).filter(
+    (turn) => Date.parse(turn.at) > since && Date.parse(turn.at) <= now
+  );
+}
+function filesChangedSince(dir, since) {
+  const changed = [];
+  let walked = 0;
+  const walk = (folder) => {
+    let entries;
+    try {
+      entries = readdirSync(folder, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (walked++ > MAX_WALKED_FILES) return;
+      if (entry.name.startsWith(".") || SKIPPED_DIRS.has(entry.name)) continue;
+      const path = join2(folder, entry.name);
+      if (entry.isDirectory()) walk(path);
+      else if (entry.isFile() && lstatSync2(path).mtimeMs > since)
+        changed.push(relative(dir, path).split(sep).join("/"));
+    }
+  };
+  walk(dir);
+  return changed.sort();
+}
+function projectsNamed(cwd, args) {
+  const candidates = [cwd, ...args.filter((arg) => !arg.startsWith("-"))].flatMap((arg) => {
+    const path = resolve(cwd, arg);
+    return [path, dirname(path)];
+  });
+  return [...new Set(candidates)];
+}
+function appHistoryNotice(cwd, args) {
+  for (const dir of projectsNamed(cwd, args)) {
+    const { at } = readSeen(dir);
+    if (!at || recordChangedAt(dir, APP_HISTORY) <= at) continue;
+    const count = unseenTurns(dir, at).length;
+    if (count === 0) continue;
+    const where = relative(cwd, dir);
+    const turns = count === 1 ? "1 chat turn" : `${count} chat turns`;
+    return `The HyperFrames desktop app has ${turns} on this project you haven't seen. Run \`npx hyperframes catch-up${where ? ` ${where}` : ""}\` before changing it.`;
+  }
+  return null;
+}
+var CATCH_UP_NOTE = "> **Back from the desktop app.** Once this project was opened in the HyperFrames desktop app, run `npx hyperframes catch-up` before your next change here: it lists what the person asked Framey in the app and which files changed since.";
+var SCAFFOLD_TITLE = "# HyperFrames Composition Project";
+var AFTER = "> alive through review, and stop it explicitly with `preview --stop` afterward.\n";
+function addCatchUpNote(dir) {
+  for (const name of ["CLAUDE.md", "AGENTS.md"]) {
+    const path = join2(dir, name);
+    try {
+      const text2 = readPlainFile(path, MAX_READ_BYTES);
+      if (!text2.startsWith(SCAFFOLD_TITLE) || text2.includes("hyperframes catch-up")) continue;
+      const next = text2.includes(AFTER) ? text2.replace(AFTER, `${AFTER}
+${CATCH_UP_NOTE}
+`) : `${text2.trimEnd()}
+
+${CATCH_UP_NOTE}
+`;
+      replaceFile(path, next, lstatSync2(path).mode & 511);
+    } catch {
+    }
+  }
+}
+
+export {
+  writeRecord,
+  APP_HISTORY,
+  readAppTurns,
+  readSeen,
+  markSeen,
+  unseenTurns,
+  filesChangedSince,
+  appHistoryNotice,
+  CATCH_UP_NOTE,
+  addCatchUpNote
+};

package/dist/{chunk-LSLJIVWV.js → chunk-DUQJF7FK.js}

@@ -8,7 +8,7 @@ import {
   isAllowedHtmlAttribute,
   isSafeAttributeValue,
   sanitizeRichTextChildren
-} from "./chunk-SCCJUPPX.js";
+} from "./chunk-EJ7OWYF2.js";
 import {
   removeElementWithGsapCascade
 } from "./chunk-OZUQF4NB.js";
@@ -17,10 +17,10 @@ import {
   ensureHfIds,
   mintHfId,
   walkCompositionDescendants
-} from "./chunk-HUV6BP7O.js";
+} from "./chunk-GWV2Y36Q.js";
 import {
   require_dist
-} from "./chunk-VDQCNWQI.js";
+} from "./chunk-STA43FMY.js";
 import {
   readClipTiming,
   readMediaOffsetSeconds,

package/dist/{chunk-VU7RRQNA.js → chunk-DW32KBHN.js}

@@ -4,22 +4,22 @@ 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 {
+  resolveProject
+} from "./chunk-JTAYFSLO.js";
 import {
   installPageFunctionGuard,
   resolveCliChromeGpuMode,
   seekCompositionTimeline,
   waitForRuntimeReady
-} from "./chunk-R2MFCLGW.js";
+} from "./chunk-EZ2P7LAP.js";
 import {
   resolveCompositionViewportFromHtml
 } from "./chunk-5Z63TBTX.js";
 import {
   launchManagedBrowser,
   resolveManagedGpuMode
-} from "./chunk-6IEDWKFR.js";
-import {
-  resolveProject
-} from "./chunk-J6BHZVM3.js";
+} from "./chunk-4VZBKOQJ.js";
 import {
   c
 } from "./chunk-ZTZA4UWZ.js";
@@ -33,7 +33,7 @@ import {
 import {
   printDeprecationNotice,
   withMeta
-} from "./chunk-2DQ356HE.js";
+} from "./chunk-TCWL4BKK.js";
 import {
   normalizeErrorMessage
 } from "./chunk-KNU5COPB.js";
@@ -222,7 +222,7 @@ function extractCompositionErrorsFromLint(lintResult) {
 async function localizeRemoteAssets(html) {
   let dir;
   try {
-    const { loadProducer } = await import("./producer-S77FHAAG.js");
+    const { loadProducer } = await import("./producer-5ZKKKQPB.js");
     const { localizeRemoteMediaSources, localizeRemoteImageSources, localizeRemoteFontFaces } = await loadProducer();
     dir = mkdtempSync(join(tmpdir(), "hf-validate-assets-"));
     const assetDir = dir;
@@ -243,10 +243,10 @@ async function localizeRemoteAssets(html) {
 }
 async function validateInBrowser(project, opts) {
   const projectDir = project.dir;
-  const { bundleToSingleHtml } = await import("./compiler-ENHZ73DN.js");
+  const { bundleToSingleHtml } = await import("./compiler-CWSZ4W7J.js");
   const { ensureBrowser } = await import("./manager-CT3D67CG.js");
-  const { serveStaticProjectHtml } = await import("./staticProjectServer-XUCQPVTF.js");
-  const { lintProject } = await import("./lintProject-EPVG2EFE.js");
+  const { serveStaticProjectHtml } = await import("./staticProjectServer-4VKVHPNG.js");
+  const { lintProject } = await import("./lintProject-ANMPLBIT.js");
   const lintResult = await lintProject(projectDir);
   const compositionErrors = extractCompositionErrorsFromLint(lintResult);
   const html = await bundleToSingleHtml(projectDir);
@@ -267,9 +267,9 @@ async function validateInBrowser(project, opts) {
   try {
     const browser = await ensureBrowser();
     const puppeteer = await import("puppeteer-core");
-    const { buildChromeArgs, analyzeClipMediaFit } = await import("./src-A7PS67DT.js");
+    const { buildChromeArgs, analyzeClipMediaFit } = await import("./src-YWFJILQF.js");
     const requestedGpuMode = resolveCliChromeGpuMode();
-    const { assertWebGpuAdapterAvailable, compositionRequiresWebGpu } = await import("./gpuPolicy-26BEFD3H.js");
+    const { assertWebGpuAdapterAvailable, compositionRequiresWebGpu } = await import("./gpuPolicy-NS7WZRDJ.js");
     const resolvedGpuMode = await resolveManagedGpuMode(requestedGpuMode, browser.executablePath);
     const requiresWebGpu = compositionRequiresWebGpu(html);
     const chromeBrowser = await launchManagedBrowser(puppeteer.default, {

package/dist/{chunk-GULOKZLI.js → chunk-EDUBJPGL.js}

@@ -4,10 +4,16 @@ 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 {
+  addCatchUpNote,
+  markSeen,
+  readSeen,
+  writeRecord
+} from "./chunk-DCAI5DBR.js";
 
 // src/utils/desktopApp.ts
 import { spawn, spawnSync } from "child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { basename, isAbsolute, join, relative, win32 } from "path";
 var DESKTOP_BUNDLE_IDS = ["dev.hyperframes.desktop", "dev.hyperframes.desktop.canary"];
@@ -26,6 +32,7 @@ function agentSession(env = process.env) {
   if (env.CLAUDE_CODE_SESSION_ID)
     return { engine: "claude", sessionId: env.CLAUDE_CODE_SESSION_ID };
   if (env.CODEX_THREAD_ID) return { engine: "codex", sessionId: env.CODEX_THREAD_ID };
+  if (env.GROK_SESSION_ID) return { engine: "grok", sessionId: env.GROK_SESSION_ID };
   return null;
 }
 var openWithBundle = (bundleId, dir) => spawnSync("open", ["-b", bundleId, dir], { stdio: "ignore" }).status === 0;
@@ -76,14 +83,12 @@ function desktopApps({
   });
 }
 function leaveHandoff(dir, session) {
-  if (!session) return null;
-  try {
-    mkdirSync(join(dir, ".hyperframes"), { recursive: true });
-    writeFileSync(join(dir, AGENT_HANDOFF_FILE), JSON.stringify(session));
-    return session;
-  } catch {
-    return null;
-  }
+  if (!session || !writeRecord(dir, "agent-handoff.json", JSON.stringify(session))) return null;
+  const now = Date.now();
+  if (!readSeen(dir).at && !markSeen(dir, { at: now, checked: now }))
+    console.warn("\u25C7  Couldn't note the hand-off in ~/.hyperframes, so `catch-up` won't see it.");
+  addCatchUpNote(dir);
+  return session;
 }
 function openInDesktop(dir, {
   ready = HANDOFF_READY,