hyperframes 0.8.151 → 0.8.153

package/dist/{chunk-3SVC7SW4.js → chunk-V6UUZGP6.js}

@@ -39,7 +39,7 @@ import {
   stripEmbeddedRuntimeScripts,
   styleElementsFor,
   warnUnknownEnumValues
-} from "./chunk-QBYHNRHU.js";
+} from "./chunk-GV7I3ZSQ.js";
 import {
   cssVariableName
 } from "./chunk-VC76R6W2.js";
@@ -49,7 +49,7 @@ import {
 } from "./chunk-OFQWTKPW.js";
 import {
   lintHyperframeHtml
-} from "./chunk-GNTVYF7E.js";
+} from "./chunk-YOEGUBBY.js";
 import {
   checkSubCompositionUsability,
   resolveSubCompositionContent
@@ -72,7 +72,7 @@ import {
 } from "./chunk-SDYDNHEE.js";
 import {
   parse
-} from "./chunk-2PSPARWP.js";
+} from "./chunk-TYXH3EKP.js";
 
 // ../core/dist/compiler/htmlCompiler.js
 import { resolve } from "path";
@@ -1036,12 +1036,16 @@ function wrapScopedCompositionScript(source, compositionId, errorLabel = "[Hyper
   var __hfBaseHyperframes = window.__hyperframes;
   var __hfScopedHyperframes = ${SCOPED_HYPERFRAMES_EXPRESSION};
   var __hfRun = function() {
+    var report = window.__hfScriptState;
+    if (typeof report === "function") report("start", __hfCompositionSrc || "index.html");
     try {
       (function(document, gsap, window, __hyperframes) {
 ${source.replace(/<\/(script)/gi, "<\\/$1")}
       }).call(window, __hfScopedDocument, __hfScopedGsap, __hfScopedWindow, __hfScopedHyperframes);
     } catch (_err) {
       console.error(__hfErrorLabel, __hfCompId, _err);
+    } finally {
+      if (typeof report === "function") report("finish", __hfCompositionSrc || "index.html");
     }
   };
   // What the script started on the global gsap timeline, by any route, for a scene swap to revert.

package/dist/{chunk-LFNQDTSH.js → chunk-VYKPBRCB.js}

@@ -15,8 +15,9 @@ import {
   ancestor,
   full,
   parse,
+  parseExpressionAt,
   simple
-} from "./chunk-2PSPARWP.js";
+} from "./chunk-TYXH3EKP.js";
 import {
   __toESM
 } from "./chunk-M2WBOQ2Q.js";
@@ -2195,19 +2196,19 @@ function collectIdentifierBindingIndex(ast) {
   }
 }
 function addBinding(bindings, scopeNode, name, selector) {
-  let scoped = bindings.get(scopeNode);
+  let scoped = bindings.byScope.get(scopeNode);
   if (!scoped) {
     scoped = /* @__PURE__ */ new Map();
-    bindings.set(scopeNode, scoped);
+    bindings.byScope.set(scopeNode, scoped);
   }
   if (!scoped.has(name)) scoped.set(name, selector);
 }
 function lookupBindingFromAncestors(name, ancestors, bindings) {
   for (const scopeNode of scopeChainFromAncestors(ancestors)) {
-    const selector = bindings.get(scopeNode)?.get(name);
+    const selector = bindings.byScope.get(scopeNode)?.get(name);
     if (selector !== void 0) return selector;
   }
-  return bindings.get(null)?.get(name) ?? null;
+  return bindings.byScope.get(null)?.get(name) ?? null;
 }
 function isFunctionNode2(node) {
   return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression" || node?.type === "FunctionDeclaration";
@@ -2246,7 +2247,7 @@ function collectScopeBindings(ast) {
   return bindings;
 }
 function collectTargetBindings(ast, scope, identifierBindings) {
-  const bindings = /* @__PURE__ */ new Map();
+  const bindings = { byScope: /* @__PURE__ */ new Map(), identifiers: identifierBindings };
   ancestor(ast, {
     VariableDeclarator(node, _, ancestors) {
       const name = node.id?.name;
@@ -2327,7 +2328,18 @@ function resolveTargetSelector(node, ancestors, scope, bindings) {
     return typeof node.value === "string" ? node.value : null;
   }
   if (node.type === "Identifier") {
-    return lookupBindingFromAncestors(node.name, ancestors, bindings);
+    const bound = lookupBindingFromAncestors(node.name, ancestors, bindings);
+    if (bound) return bound;
+    const declaration = findVisibleIdentifierDeclaration(
+      node.name,
+      ancestors,
+      bindings.identifiers,
+      node.start
+    );
+    if (declaration?.kind !== "const" || bindings.identifiers.reassignedDeclarations.has(declaration.node))
+      return null;
+    const literal = resolveNode(declaration.node.init, scope);
+    return typeof literal === "string" ? literal : null;
   }
   if (node.type === "CallExpression") {
     return selectorFromQueryCall(node, scope);
@@ -2352,7 +2364,7 @@ function describeProxyTarget(targetNode, varsNode, scope) {
   const onUpdate = findPropertyNode(varsNode, "onUpdate");
   const driven = onUpdate ? drivenDomChannel(onUpdate) : void 0;
   if (driven) return `proxy \u2192 ${driven}`;
-  return "dwell/hold";
+  return objNode.properties.length === 0 && !onUpdate ? "dwell/hold" : "proxy (unresolved DOM association)";
 }
 function isStyleAssignmentTarget(left) {
   return left?.type === "MemberExpression" && left.object?.type === "MemberExpression" && left.object.property?.name === "style" && !!left.property?.name;
@@ -2871,6 +2883,8 @@ function tweenCallToAnimation(call, scope, source, identifierBindings) {
     duration,
     ease
   };
+  if (["stagger", "repeat", "repeatDelay", "delay"].some((key) => findPropertyNode(call.varsArg, key)))
+    anim.inspectionTiming = inspectionTiming(call.varsArg, scope);
   if (targetIdentity) anim.targetIdentity = targetIdentity;
   if (!hasPositionArg) anim.implicitPosition = true;
   let group = classifyTweenPropertyGroup(properties);
@@ -2893,14 +2907,51 @@ function tweenCallToAnimation(call, scope, source, identifierBindings) {
   if (provenance) anim.provenance = provenance;
   return anim;
 }
+function inspectionTiming(varsNode, scope) {
+  const numeric2 = (key) => {
+    const node2 = findPropertyNode(varsNode, key);
+    if (!node2) return 0;
+    const value = resolveNode(node2, scope);
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+  };
+  const node = findPropertyNode(varsNode, "stagger");
+  let stagger = { each: 0 };
+  if (node) {
+    const value = resolveNode(node, scope);
+    stagger = typeof value === "number" ? { each: value } : null;
+    if (node.type === "ObjectExpression" && !(node.properties ?? []).some(
+      (p) => !["each", "amount", "from", "ease", "axis", "grid"].includes(propKeyName(p) ?? "")
+    )) {
+      const each = resolveNode(findPropertyNode(node, "each"), scope);
+      const amount = resolveNode(findPropertyNode(node, "amount"), scope);
+      if (!findPropertyNode(node, "grid") && !findPropertyNode(node, "axis")) {
+        if (typeof amount === "number") stagger = { amount };
+        else if (typeof each === "number") stagger = { each };
+      }
+    }
+  }
+  return {
+    repeat: numeric2("repeat"),
+    repeatDelay: numeric2("repeatDelay"),
+    delay: numeric2("delay"),
+    stagger
+  };
+}
 function staggerAmount(raw) {
   if (typeof raw === "number") return raw;
   if (typeof raw !== "string") return void 0;
   const src = raw.startsWith("__raw:") ? raw.slice(6) : raw;
-  const m = /(?:each\s*:\s*)?(-?\d+(?:\.\d+)?)/.exec(src);
-  if (!m) return void 0;
-  const n2 = Number.parseFloat(m[1]);
-  return Number.isFinite(n2) ? n2 : void 0;
+  try {
+    const node = parseExpressionAt(src, 0, { ecmaVersion: "latest" });
+    if (src.slice(node.end).trim()) return void 0;
+    const value = resolveNode(
+      node.type === "ObjectExpression" ? findPropertyNode(node, "each") : node,
+      /* @__PURE__ */ new Map()
+    );
+    return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+  } catch {
+    return void 0;
+  }
 }
 function restValue(prop) {
   return prop === "opacity" || prop.startsWith("scale") ? 1 : 0;

package/dist/{chunk-S22FKF6G.js → chunk-WNCGJFTZ.js}

@@ -20,7 +20,7 @@ import {
   SDR_RGB_TO_BT709_FILTER,
   SDR_RGB_TO_TAGGED_BT709_FILTER,
   renderProvenanceArgs
-} from "./chunk-IZPN423R.js";
+} from "./chunk-2F6LWCSF.js";
 
 // src/background-removal/pipeline.ts
 import { spawn } from "child_process";
@@ -270,7 +270,7 @@ function inferInputKind(inputPath) {
 }
 async function probeMedia(inputPath) {
   const isImage = inferInputKind(inputPath) === "image";
-  const engine = await import("./src-2NN2WB6X.js");
+  const engine = await import("./src-YMUDUVXQ.js");
   const meta = await engine.extractMediaMetadata(inputPath);
   if (isImage) {
     return { width: meta.width, height: meta.height, fps: 0, frameCount: 1 };

package/dist/{chunk-XNDXENJQ.js → chunk-WQMTHPTK.js}

@@ -14,14 +14,14 @@ import {
   isAllowedHtmlAttribute,
   isSafeAttributeValue,
   sanitizeRichTextChildren
-} from "./chunk-XQKVEQNY.js";
+} from "./chunk-ZDEEHQ2Y.js";
 import {
   decodedUrlPath,
   removeElementWithGsapCascade
-} from "./chunk-LFNQDTSH.js";
+} from "./chunk-VYKPBRCB.js";
 import {
   require_dist
-} from "./chunk-GNTVYF7E.js";
+} from "./chunk-YOEGUBBY.js";
 import {
   readClipTiming,
   writeClipTiming

package/dist/{chunk-4LE27ST4.js → chunk-XQYLUY2F.js}

@@ -19,10 +19,10 @@ import {
 import {
   formatVariableValidationIssue,
   validateVariables
-} from "./chunk-XQKVEQNY.js";
+} from "./chunk-ZDEEHQ2Y.js";
 import {
   extractCompositionMetadata
-} from "./chunk-LFNQDTSH.js";
+} from "./chunk-VYKPBRCB.js";
 
 // src/utils/variables.ts
 import { readFileSync } from "fs";

package/dist/chunk-XSEGMQYA.js

@@ -0,0 +1,30 @@
+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);
+
+// src/utils/checkSnapshotDirectory.ts
+import { randomUUID } from "crypto";
+import { join, resolve } from "path";
+var runDirectories = /* @__PURE__ */ new Map();
+function checkSnapshotDirectory(projectDir) {
+  const project = resolve(projectDir);
+  let directory = runDirectories.get(project);
+  if (!directory) {
+    directory = join(project, ".hyperframes", "artifacts", "snapshots", randomUUID());
+    runDirectories.set(project, directory);
+  }
+  return directory;
+}
+
+// src/utils/checkTypes.ts
+function rectToBbox(rect) {
+  return { x: rect.left, y: rect.top, width: rect.width, height: rect.height };
+}
+
+export {
+  checkSnapshotDirectory,
+  rectToBbox
+};

package/dist/{chunk-35PWWBGZ.js → chunk-YI6OBVWQ.js}

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

package/dist/{chunk-GNTVYF7E.js → chunk-YOEGUBBY.js}

@@ -25,7 +25,7 @@ import {
   extractMediaSrcMutations,
   isSafeMediaUrl,
   resolveAliasDisplayName
-} from "./chunk-APDLWWFG.js";
+} from "./chunk-3VGU2SH7.js";
 import {
   findFfBinary
 } from "./chunk-VAS6HQX3.js";
@@ -49,7 +49,7 @@ import {
 import {
   parse,
   simple
-} from "./chunk-2PSPARWP.js";
+} from "./chunk-TYXH3EKP.js";
 import {
   isSceneLikeCompositionId,
   parseSlideshowManifest,
@@ -7437,18 +7437,18 @@ function deriveDurationFromClips(tags, rootTag) {
   return resolveCompositionDuration({ authoredDurationSeconds: null, clipEndsSeconds: clipEnds });
 }
 async function loadParseGsapScript() {
-  const mod = await import("./gsapParserAcorn-VXZ3ZIF2.js");
+  const mod = await import("./gsapParserAcorn-7NCK2LVT.js");
   return mod.parseGsapScriptAcorn;
 }
 async function loadGsapScriptMotionPathFirstUseIndex() {
-  const mod = await import("./gsapParserAcorn-VXZ3ZIF2.js");
+  const mod = await import("./gsapParserAcorn-7NCK2LVT.js");
   return mod.gsapScriptMotionPathFirstUseIndex;
 }
 var SCENE_BOUNDARY_EPSILON_SECONDS = 0.05;
 var UNRESOLVED_TARGET = "__unresolved__";
 function targetHasNoStableIdentity(selector, identity) {
   if (identity) return false;
-  return selector === UNRESOLVED_TARGET || selector === "dwell/hold" || selector.startsWith("proxy \u2192 ");
+  return selector === UNRESOLVED_TARGET || selector === "dwell/hold" || selector.startsWith("proxy ");
 }
 function unwrapRaw(value) {
   if (typeof value === "number") return value;

package/dist/{chunk-FAIYEIZ4.js → chunk-YYMJEQ4D.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-HVW7ABXD.js";
 import {
   DEFAULT_REGISTRY_URL
-} from "./chunk-YZTVHRJ2.js";
+} from "./chunk-2XEBNYG5.js";
 
 // src/utils/projectConfig.ts
 import { readFileSync, writeFileSync } from "fs";

package/dist/{chunk-LKQS72D5.js → chunk-Z6CSYA7U.js}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-AWDFDFI3.js";
 import {
   isBlockedNetworkHost
-} from "./chunk-IZPN423R.js";
+} from "./chunk-2F6LWCSF.js";
 import {
   DOMParser,
   parseHTML

package/dist/{chunk-XQKVEQNY.js → chunk-ZDEEHQ2Y.js}

@@ -9,7 +9,7 @@ import {
   parseStrictFiniteTimingNumber,
   resolveNaturalMediaTimelineDuration,
   resolveTimedImageDurationSeconds
-} from "./chunk-QBYHNRHU.js";
+} from "./chunk-GV7I3ZSQ.js";
 import {
   CANVAS_DIMENSIONS,
   isCompositionElement,
@@ -17,7 +17,7 @@ import {
   isTextElement,
   keyframesToGsapAnimations,
   serializeGsapAnimations
-} from "./chunk-LFNQDTSH.js";
+} from "./chunk-VYKPBRCB.js";
 import {
   COMPOSITION_ATTRIBUTES,
   parseStartExpression

package/dist/chunk-ZQMYD22O.js

@@ -0,0 +1,215 @@
+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 {
+  DEFAULT_HISTORY_ROOT,
+  HistoryBusyError,
+  MAX_WINDOW_IDLE_MS,
+  openProjectHistory,
+  readProjectHistory
+} from "./chunk-7FYFEXD2.js";
+import {
+  resolveProject
+} from "./chunk-JQ57FAYN.js";
+import {
+  findPreviewServerForProject,
+  studioApiUrl
+} from "./chunk-DQBY7FRR.js";
+
+// src/utils/historyOwner.ts
+import { randomUUID } from "crypto";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+var historyDeps = {
+  historyRoot: resolve(process.env.HYPERFRAMES_HISTORY_ROOT || DEFAULT_HISTORY_ROOT),
+  findServer: (projectDir) => findPreviewServerForProject(projectDir),
+  /** A turn with no write for this long has ended, through a preview or not. */
+  turnIdleMs: MAX_WINDOW_IDLE_MS,
+  ownerWaitMs: void 0,
+  now: () => Date.now()
+};
+var Refusal = class extends Error {
+};
+var turnFile = (dir) => join(dir, ".hyperframes", "history-turn.json");
+function readTurn(dir) {
+  try {
+    const turn = JSON.parse(readFileSync(turnFile(dir), "utf-8"));
+    return typeof turn.lastWriteAt === "number" ? { ...turn, parts: turn.parts ?? [] } : null;
+  } catch {
+    return null;
+  }
+}
+function writeTurn(dir, turn) {
+  if (!turn) return rmSync(turnFile(dir), { force: true });
+  mkdirSync(dirname(turnFile(dir)), { recursive: true });
+  writeFileSync(turnFile(dir), JSON.stringify(turn));
+}
+var lastTurnsFile = (dir) => join(dir, ".hyperframes", "history-turns.json");
+function readLastTurns(dir) {
+  try {
+    const turns = JSON.parse(readFileSync(lastTurnsFile(dir), "utf-8"));
+    return turns && typeof turns === "object" ? turns : {};
+  } catch {
+    return {};
+  }
+}
+function lastTurnParts(dir, name) {
+  return readLastTurns(dir)[name] ?? null;
+}
+var samePart = (a, b) => a.who.kind === b.who.kind && a.who.name === b.who.name && a.label === b.label && a.startedAt === b.startedAt;
+async function endTurn(owner, turn, dir) {
+  const entry = await owner.end(turn.id);
+  const cut = (await owner.list()).filter((other) => samePart(other, entry ?? turn));
+  const own = entry ? [entry.id] : [];
+  const parts = [.../* @__PURE__ */ new Set([...turn.parts, ...cut.map((part) => part.id), ...own])];
+  const draft = `${lastTurnsFile(dir)}.${process.pid}.tmp`;
+  mkdirSync(dirname(draft), { recursive: true });
+  writeFileSync(draft, JSON.stringify({ ...readLastTurns(dir), [turn.who.name]: parts }));
+  renameSync(draft, lastTurnsFile(dir));
+  writeTurn(dir, null);
+  return { entry, parts };
+}
+function previewOwner(route) {
+  const call = async (path, body, signal) => {
+    const init = {
+      ...body && {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body)
+      },
+      ...signal && { signal }
+    };
+    const response = await fetch(route(path), init);
+    if (response.ok) return response;
+    const error = await response.json().catch(() => null);
+    throw new Refusal(error?.error ?? `The preview answered ${response.status}.`);
+  };
+  const json = async (path, body, signal) => (await call(path, body, signal)).json();
+  const list = async () => (await json("")).entries;
+  return {
+    via: "preview",
+    list,
+    peek: async (point) => (await json(`/peek/${encodeURIComponent(point)}`)).files,
+    blob: async (hash) => Buffer.from(await (await call(`/blob/${hash}`)).arrayBuffer()),
+    undo: (id, who, mode) => json("/undo", { entryId: id, who, mode }),
+    restore: (point, who) => json("/restore", { point, who }),
+    pin: async (id, pinned) => void await json("/pin", { entryId: id, pinned }),
+    begin: async (who, label, exclusive) => {
+      const opened = await json("/window", {
+        who,
+        label,
+        idleMs: historyDeps.turnIdleMs,
+        ...exclusive && { exclusive: true }
+      });
+      return { id: opened.windowId, startedAt: opened.startedAt ?? historyDeps.now() };
+    },
+    // A preview restarted since begin committed the window on its way down.
+    end: (id) => json(`/window/${id}/close`, {}).then((closed) => closed.entry).catch(async () => (await list()).find((entry) => entry.id === id) ?? null),
+    checkpoint: async () => void await json("/checkpoint", {}, AbortSignal.timeout(5e3)),
+    close: async () => {
+    }
+  };
+}
+async function directOwner(projectDir) {
+  let turn = null;
+  const history = await openProjectHistory({
+    projectDir,
+    historyRoot: historyDeps.historyRoot,
+    now: () => historyDeps.now(),
+    pruneGoneProjectsBudgetMs: 1e3,
+    ownerWaitMs: historyDeps.ownerWaitMs,
+    closedWindowAfterOwnership: () => {
+      turn = readTurn(projectDir);
+      return turn ? {
+        id: turn.id,
+        who: turn.who,
+        label: turn.label,
+        startedAt: turn.startedAt,
+        lastWriteAt: turn.lastWriteAt,
+        idleMs: historyDeps.turnIdleMs
+      } : void 0;
+    }
+  });
+  return {
+    turn,
+    owner: {
+      via: "direct",
+      list: async () => history.list(),
+      peek: async (point) => history.peek(point),
+      blob: (hash) => history.readBlob(hash),
+      undo: (id, who, mode) => history.undo(id, { who, ...mode && { mode } }),
+      restore: (point, who) => history.restore(point, who),
+      pin: async (id, pinned) => history.pin(id, pinned),
+      // Opening filed every earlier write; the turn's own writes are filed to it when the next open passes it.
+      begin: async () => ({ id: randomUUID(), startedAt: historyDeps.now() }),
+      end: async (id) => history.list().find((entry) => entry.id === id) ?? null,
+      checkpoint: () => history.checkpoint(),
+      close: () => history.close()
+    }
+  };
+}
+async function connect(projectDir) {
+  const server = await historyDeps.findServer(projectDir);
+  if (server) {
+    const route = (path) => studioApiUrl(server, `history${path}`);
+    const status = await fetch(route("")).then(
+      (response) => response.status,
+      () => 404
+    );
+    if (status !== 404) return { owner: previewOwner(route), turn: readTurn(projectDir) };
+  }
+  return directOwner(projectDir);
+}
+async function withOwner(dir, task) {
+  const { dir: projectDir } = resolveProject(dir);
+  const { owner, turn } = await connect(projectDir);
+  try {
+    return await task(owner, turn, projectDir);
+  } finally {
+    try {
+      if (owner.via === "direct" && turn) {
+        const kept = (await owner.list()).find((entry) => entry.id === turn.id);
+        if (readTurn(projectDir)?.id === turn.id) {
+          const lastWriteAt = kept ? kept.endedAt : turn.lastWriteAt;
+          const parts = kept ? [...turn.parts, kept.id] : turn.parts;
+          writeTurn(projectDir, { ...turn, via: "direct", id: randomUUID(), lastWriteAt, parts });
+        }
+      }
+    } finally {
+      await owner.close();
+    }
+  }
+}
+async function withReader(dir, task) {
+  try {
+    return await withOwner(dir, (owner) => task(owner));
+  } catch (error) {
+    if (!(error instanceof HistoryBusyError)) throw error;
+  }
+  const view = readProjectHistory({
+    projectDir: resolveProject(dir).dir,
+    historyRoot: historyDeps.historyRoot
+  });
+  return task({
+    via: "direct",
+    list: async () => view.list(),
+    peek: async (point) => view.peek(point),
+    // The owner may have pruned a blob since its log was read.
+    blob: (hash) => view.readBlob(hash).catch((error) => {
+      throw error.code === "ENOENT" ? new Refusal("That point is no longer kept") : error;
+    })
+  });
+}
+
+export {
+  historyDeps,
+  Refusal,
+  writeTurn,
+  lastTurnParts,
+  endTurn,
+  withOwner,
+  withReader
+};