@hyperframes/sdk 0.8.190 → 0.8.192

package/dist/engine/apply-patches.d.ts

@@ -16,4 +16,9 @@ import type { ParsedDocument } from "./model.js";
  * property is a no-op in applyOne, so this is safe against fresh-base misses.)
  */
 export declare function applyOverrideSet(parsed: ParsedDocument, overrides: OverrideSet): void;
-export declare function applyPatchesToDocument(parsed: ParsedDocument, patches: readonly JsonPatchOp[]): void;
+interface ApplyOptions {
+    /** Keep a copy of each removed element an inline script looks up (stored deletes replayed onto a base). */
+    keepScriptTargets?: boolean;
+}
+export declare function applyPatchesToDocument(parsed: ParsedDocument, patches: readonly JsonPatchOp[], options?: ApplyOptions): void;
+export {};

package/dist/engine/apply-patches.js

@@ -9,6 +9,7 @@
  */
 import { findById, findRoot, declarationElement, setElementStyles, setOwnText, setGsapScript, setStyleSheet, } from "./model.js";
 import { keyToPath, stylePath } from "./patches.js";
+import { scriptLooksUp } from "./scriptLookups.js";
 import { writeVariableDefault, clearVariableDefault, writeVariableDeclaration, removeVariableDeclarationEntry, } from "./variableModel.js";
 function isRawDeclarationEntry(value) {
     return (typeof value === "object" &&
@@ -120,9 +121,19 @@ export function applyOverrideSet(parsed, overrides) {
             patches.push({ op: "remove", path: stylePath(rootId, `--${key.slice("var.".length)}`) });
         }
     }
-    applyPatchesToDocument(parsed, patches);
+    applyPatchesToDocument(parsed, patches, { keepScriptTargets: true });
 }
-export function applyPatchesToDocument(parsed, patches) {
+/** Keep a deleted node a script looks up: serialize writes it back hidden, so the script finds it. */
+function keepDelete(parsed, el) {
+    const parent = el.parentElement;
+    (parsed.keptDeletes ??= []).push({
+        hfId: el.getAttribute("data-hf-id") ?? "",
+        html: el.outerHTML,
+        parentId: parent?.getAttribute("data-hf-id") ?? null,
+        siblingIndex: parent ? Array.from(parent.children).indexOf(el) : 0,
+    });
+}
+export function applyPatchesToDocument(parsed, patches, options = {}) {
     for (const patch of patches) {
         const p = parsePath(patch.path);
         if (!p)
@@ -130,11 +141,11 @@ export function applyPatchesToDocument(parsed, patches) {
         if (p.id && patch.path.startsWith("/elements/")) {
             p.id = p.id.replace(/~1/g, "/").replace(/~0/g, "~");
         }
-        applyOne(parsed, patch, p);
+        applyOne(parsed, patch, p, options);
     }
 }
 // fallow-ignore-next-line complexity
-function applyOne(parsed, patch, p) {
+function applyOne(parsed, patch, p, options) {
     switch (p.type) {
         case "style": {
             const el = p.id ? findById(parsed.document, p.id) : null;
@@ -220,6 +231,8 @@ function applyOne(parsed, patch, p) {
                 return;
             if (patch.op === "remove") {
                 const el = findById(parsed.document, p.id);
+                if (el && options.keepScriptTargets && scriptLooksUp(parsed.document, el))
+                    keepDelete(parsed, el);
                 el?.remove();
             }
             else if (patch.op === "add" && patch.value) {

package/dist/engine/model.d.ts

@@ -10,6 +10,14 @@ export interface ParsedDocument {
     wrapped: boolean;
     /** ensureHfIds-stamped original HTML — used as fallback / diff base. */
     stamped: string;
+    /** Replayed deletes a script still looks up: left out of the live document, written back hidden by serialize. */
+    keptDeletes?: KeptDelete[];
+}
+export interface KeptDelete {
+    hfId: string;
+    html: string;
+    parentId: string | null;
+    siblingIndex: number;
 }
 export declare function parseMutable(html: string): ParsedDocument;
 export declare function findById(document: Document, id: string): Element | null;

package/dist/engine/scriptLookups.d.ts

@@ -0,0 +1 @@
+export declare function scriptLooksUp(document: Document, el: Element): boolean;

package/dist/engine/scriptLookups.js

@@ -0,0 +1,48 @@
+// Whether an inline script could look the element up. A replayed delete of such a node is hidden,
+// not removed: a missing node makes the script throw before the timeline registers.
+const LITERAL_LOOKUP = /(getElementById|getElementsByClassName|getElementsByTagName|querySelector(?:All)?)\s*\(\s*(["'`])([\s\S]*?)\2\s*(\S?)/g;
+// A lookup whose argument is a variable or an expression: it can name any node.
+const DYNAMIC_LOOKUP = /(?:getElementById|getElementsByClassName|getElementsByTagName|querySelector(?:All)?)\s*\(\s*(?!["'`)\s])/;
+const PLACEHOLDER = /\$\{[^}]*\}/;
+function idPattern(text) {
+    const parts = text.split(new RegExp(PLACEHOLDER.source, "g"));
+    const escaped = parts.map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    return new RegExp(`^${escaped.join("[\\w-]+")}$`);
+}
+function matchesSelector(el, selector) {
+    if (PLACEHOLDER.test(selector))
+        return true;
+    try {
+        return el.matches(selector) || el.querySelector(selector) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+function lookupReaches(el, method, argument) {
+    if (PLACEHOLDER.test(argument))
+        return true;
+    const nodes = [el, ...Array.from(el.querySelectorAll("*"))];
+    if (method === "getElementById") {
+        const pattern = idPattern(argument);
+        return nodes.some((node) => pattern.test(node.getAttribute("id") ?? "\0"));
+    }
+    if (method === "getElementsByClassName") {
+        const wanted = argument.split(/\s+/).filter(Boolean);
+        return nodes.some((node) => wanted.every((name) => node.classList.contains(name)));
+    }
+    if (method === "getElementsByTagName") {
+        return argument === "*" || nodes.some((node) => node.localName === argument.toLowerCase());
+    }
+    return matchesSelector(el, argument);
+}
+export function scriptLooksUp(document, el) {
+    const scripts = Array.from(document.querySelectorAll("script:not([src])"), (s) => s.textContent ?? "").join("\n");
+    if (DYNAMIC_LOOKUP.test(scripts))
+        return true;
+    for (const [, method, , argument, next] of scripts.matchAll(LITERAL_LOOKUP)) {
+        if (next !== ")" || lookupReaches(el, method ?? "", argument ?? ""))
+            return true;
+    }
+    return false;
+}

package/dist/engine/serialize.d.ts

@@ -4,7 +4,7 @@
  * Phase 3a: generates from the live DOM. The DOM IS the mutable state.
  * Phase 3b: GSAP script section will use the meriyah/offset-splice path once available.
  */
-import type { ParsedDocument } from "./model.js";
+import { type ParsedDocument } from "./model.js";
 /**
  * Serialize the live document back to HTML.
  *

package/dist/engine/serialize.js

@@ -4,6 +4,52 @@
  * Phase 3a: generates from the live DOM. The DOM IS the mutable state.
  * Phase 3b: GSAP script section will use the meriyah/offset-splice path once available.
  */
+import { findById, getElementStyles, setElementStyles, } from "./model.js";
+// A kept delete is not a clip: without these the renderer would still schedule its media and stretch the film.
+const CLIP_ATTRIBUTES = ["data-start", "data-duration", "data-end", "data-track-index"];
+// A hidden copy still gets its media fetched, and extracted when it is a video, so it keeps no source.
+const MEDIA_SOURCE_ATTRIBUTES = ["src", "srcset", "poster"];
+/** The deleted node, hidden and no longer a clip, so a script that looks it up still finds it. */
+function hiddenCopy(doc, kept) {
+    const holder = doc.createElement("div");
+    holder.innerHTML = kept.html;
+    const node = holder.firstElementChild;
+    if (!node)
+        return null;
+    for (const el of [node, ...Array.from(node.querySelectorAll("*"))]) {
+        for (const name of CLIP_ATTRIBUTES)
+            el.removeAttribute(name);
+        for (const name of MEDIA_SOURCE_ATTRIBUTES)
+            el.removeAttribute(name);
+        const remote = Object.entries(getElementStyles(el)).filter(([, v]) => v.includes("url("));
+        if (remote.length > 0)
+            setElementStyles(el, Object.fromEntries(remote.map(([k]) => [k, null])));
+    }
+    setElementStyles(node, { display: "none" });
+    node.setAttribute("data-hidden", "");
+    return node;
+}
+/** Put the hidden copy back where the node was; null when an undo already made it live or its parent is gone. */
+function placeKeptDelete(doc, kept) {
+    if (kept.hfId && findById(doc, kept.hfId))
+        return null;
+    const node = hiddenCopy(doc, kept);
+    const parent = kept.parentId ? findById(doc, kept.parentId) : doc.body;
+    if (!node || !parent)
+        return null;
+    parent.insertBefore(node, parent.children[kept.siblingIndex] ?? null);
+    return node;
+}
+function withKeptDeletes(parsed, serialize) {
+    const placed = (parsed.keptDeletes ?? []).flatMap((kept) => placeKeptDelete(parsed.document, kept) ?? []);
+    try {
+        return serialize();
+    }
+    finally {
+        for (const node of placed)
+            node.remove();
+    }
+}
 /**
  * Serialize the live document back to HTML.
  *
@@ -11,9 +57,11 @@
  * If the original input had a full HTML shell (wrapped=false), returns the full document.
  */
 export function serializeDocument(parsed) {
-    const doc = parsed.document;
-    if (parsed.wrapped) {
-        return doc.body.innerHTML ?? "";
-    }
-    return `<!DOCTYPE html>\n${doc.documentElement.outerHTML}`;
+    return withKeptDeletes(parsed, () => {
+        const doc = parsed.document;
+        if (parsed.wrapped) {
+            return doc.body.innerHTML ?? "";
+        }
+        return `<!DOCTYPE html>\n${doc.documentElement.outerHTML}`;
+    });
 }

package/dist/session.js

@@ -49,6 +49,7 @@ class CompositionImpl {
     selectionHandlers = [];
     patchHandlers = [];
     errorHandlers = [];
+    persistErrorUnsubscribes = new Set();
     previewSelectionUnsubscribe = null;
     /** Attached by openComposition() for standalone mode. */
     historyModule = null;
@@ -626,9 +627,12 @@ class CompositionImpl {
             const typedH = h;
             this.errorHandlers.push(typedH);
             const offPersist = this.persist?.on("persist:error", typedH);
+            if (offPersist)
+                this.persistErrorUnsubscribes.add(offPersist);
             return () => {
                 this.errorHandlers = this.errorHandlers.filter((x) => x !== typedH);
-                offPersist?.();
+                if (offPersist && this.persistErrorUnsubscribes.delete(offPersist))
+                    offPersist();
             };
         }
         return () => { };
@@ -679,6 +683,9 @@ class CompositionImpl {
     dispose() {
         this.previewSelectionUnsubscribe?.();
         this.previewSelectionUnsubscribe = null;
+        for (const unsubscribe of this.persistErrorUnsubscribes)
+            unsubscribe();
+        this.persistErrorUnsubscribes.clear();
         this.persistQueueModule?.dispose();
         this.historyModule?.dispose();
         this.changeHandlers = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperframes/sdk",
-  "version": "0.8.190",
+  "version": "0.8.192",
   "description": "Headless, framework-neutral HyperFrames composition editing engine",
   "repository": {
     "type": "git",
@@ -44,8 +44,8 @@
   },
   "dependencies": {
     "linkedom": "^0.18.12",
-    "@hyperframes/parsers": "0.8.190",
-    "@hyperframes/core": "0.8.190"
+    "@hyperframes/core": "0.8.192",
+    "@hyperframes/parsers": "0.8.192"
   },
   "devDependencies": {
     "@types/node": "^25.0.10",