@hyperframes/core 0.8.208 → 0.8.209

package/dist/atomicFile.js

@@ -1,13 +1,11 @@
 import * as fs from "node:fs";
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { realpath } from "./safePath.js";
+import { renameWithRetry } from "./renameWithRetry.js";
 // Codes a volume without hard links (FAT, exFAT, some network shares) answers link() with.
 // EISDIR: libuv maps Windows ERROR_INVALID_FUNCTION (FAT/exFAT refusing a link) to it; nodejs/node#65817.
 const NO_HARD_LINKS = new Set(["EPERM", "ENOTSUP", "EOPNOTSUPP", "EXDEV", "EISDIR"]);
-// Windows refuses a rename while another process briefly holds the target open.
-const BUSY_RENAME = new Set(["EPERM", "EBUSY", "EACCES"]);
-const RENAME_RETRY_DELAYS_MS = [10, 20, 30, 40];
 const MAX_LINK_HOPS = 40;
 const TEMP_NAME_TRIES = 3;
 const TEMP_SUFFIX = /\.hf[0-9a-f]{6}\.tmp$/;
@@ -18,10 +16,25 @@ export function atomicTempPath(filePath) {
 export function isAtomicTempPath(path) {
     return TEMP_SUFFIX.test(path);
 }
+/** With HF_WRITE_TRACE naming a file, one JSON line per replaced .html: its hash, size and caller. */
+function traceWrite(filePath, content) {
+    const out = process.env.HF_WRITE_TRACE;
+    if (!out || !filePath.endsWith(".html"))
+        return;
+    const text = typeof content === "string" ? content : Buffer.from(content).toString("utf8");
+    const hash = createHash("sha256").update(text).digest("hex").slice(0, 8);
+    const stack = (new Error().stack ?? "")
+        .split("\n")
+        .slice(2, 7)
+        .map((line) => line.trim());
+    const file = basename(filePath);
+    fs.appendFileSync(out, `${JSON.stringify({ t: Date.now(), kind: "write", file, hash, size: text.length, stack })}\n`);
+}
 /** Replace a file only after the complete sibling temp file is written. No mode: the default one. */
 export function replaceFileAtomically(filePath, content, mode, operations = fs) {
+    traceWrite(filePath, content);
     // Node fs.rename uses libuv uv_fs_rename; win32 calls MoveFileExW with MOVEFILE_REPLACE_EXISTING.
-    publishSibling(filePath, content, mode, operations, (tempPath) => renameWithRetry(operations, tempPath, filePath));
+    publishSibling(filePath, content, mode, operations, (tempPath) => renameWithRetry(tempPath, filePath, { rename: operations.renameSync }));
 }
 /** Create a file that must not exist yet (EEXIST otherwise); readers never see it empty or partial. */
 export function createFileAtomically(filePath, content, operations = fs) {
@@ -133,20 +146,6 @@ function writeTempSibling(filePath, content, mode, operations) {
         }
     }
 }
-function renameWithRetry(operations, from, to) {
-    for (let attempt = 0;; attempt++) {
-        try {
-            operations.renameSync(from, to);
-            return;
-        }
-        catch (error) {
-            const delay = RENAME_RETRY_DELAYS_MS[attempt];
-            if (delay === undefined || !BUSY_RENAME.has(errorCode(error)))
-                throw error;
-            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay);
-        }
-    }
-}
 function errorCode(error) {
     return String(error?.code);
 }

package/dist/compiler/compositionScoping.d.ts

@@ -36,4 +36,6 @@ export declare function wrapInlineScriptWithErrorBoundary(source: string, errorL
  * table goes through `jsonScriptLiteral` — see there for why.
  */
 export declare function buildVariablesByCompScript(variablesByComp: Record<string, Record<string, unknown>>): string | null;
+/** Writes the table in <head>, so it exists before the composition scripts, which wait for web fonts. */
+export declare function emitVariablesByCompScript(document: Document, variablesByComp: Record<string, Record<string, unknown>>): void;
 export {};

package/dist/compiler/compositionScoping.js

@@ -654,3 +654,12 @@ export function buildVariablesByCompScript(variablesByComp) {
     const json = jsonScriptLiteral(variablesByComp);
     return `window.__hfVariablesByComp = Object.assign({}, window.__hfVariablesByComp || {}, ${json});`;
 }
+/** Writes the table in <head>, so it exists before the composition scripts, which wait for web fonts. */
+export function emitVariablesByCompScript(document, variablesByComp) {
+    const text = buildVariablesByCompScript(variablesByComp);
+    if (!text || !document.head)
+        return;
+    const script = document.createElement("script");
+    script.textContent = text;
+    document.head.appendChild(script);
+}

package/dist/compiler/htmlBundler.js

@@ -21,7 +21,7 @@ import { rewriteSrcsetUrls } from "./srcset.js";
 import { compileHtml } from "./htmlCompiler.js";
 import { RUNTIME_BOOTSTRAP_ATTR, escapeInlineScriptSource, insertRuntimeTag, parseHTMLContent, stripEmbeddedRuntimeScripts, } from "./htmlDocument.js";
 // rewriteSubCompPaths functions are used by inlineSubCompositions (shared module)
-import { buildVariablesByCompScript, dedupeFontFaceRules, hoistFontFaceRules, scopeCssToComposition, wrapInlineScriptWithErrorBoundary, scopedModulePrelude, wrapScopedCompositionScript, } from "./compositionScoping.js";
+import { emitVariablesByCompScript, dedupeFontFaceRules, hoistFontFaceRules, scopeCssToComposition, wrapInlineScriptWithErrorBoundary, scopedModulePrelude, wrapScopedCompositionScript, } from "./compositionScoping.js";
 import { validateHyperframeHtmlContract } from "./staticGuard.js";
 import { getHyperframeRuntimeScript } from "../generated/runtime-inline.js";
 import { readDeclaredDefaults } from "../runtime/getVariables.js";
@@ -1158,13 +1158,7 @@ async function bundleProject(projectDir, options) {
         pushRun(styleRuns, undefined, css);
     for (const chunk of compScriptChunks)
         pushRun(scriptRuns, undefined, chunk);
-    const variablesByCompScript = buildVariablesByCompScript(compVariablesByComp);
-    if (variablesByCompScript) {
-        if (scriptRuns[0] && !scriptRuns[0].scene)
-            scriptRuns[0].chunks.unshift(variablesByCompScript);
-        else
-            scriptRuns.unshift({ chunks: [variablesByCompScript] });
-    }
+    emitVariablesByCompScript(document, compVariablesByComp);
     for (const { scene, chunks } of styleRuns) {
         const join = scene ? joinCssHoistingImports : (css) => css.join("\n\n");
         for (const style of styleElementsFor(document, chunks, join)) {

package/dist/compiler/htmlDocument.d.ts

@@ -9,6 +9,10 @@ export declare function parseHTMLContent(html: string): Document;
 export declare function stripEmbeddedRuntimeScripts(html: string): string;
 export declare function isRuntimeFileUrl(src: string | null | undefined): boolean;
 export declare function escapeInlineScriptSource(source: string): string;
+export declare function mapStartTagsAndStyles(html: string, map: {
+    tag: (tag: string) => string;
+    style: (css: string) => string;
+}): string;
 export declare function findStartTags(html: string, name: string): number[];
 export declare function hasCompositionOutsideTemplates(html: string): boolean;
 /** Insert markup before the document's own `</head>`, `</body>` or `</template>`; null if it has none. */

package/dist/compiler/htmlDocument.js

@@ -199,6 +199,28 @@ function findDocumentTag(html, tag) {
     }
     return -1;
 }
+export function mapStartTagsAndStyles(html, map) {
+    const lowered = lowerAscii(html);
+    let out = "";
+    let cursor = 0;
+    for (const open of markupStarts(lowered)) {
+        if (open < cursor || !/[a-z]/.test(lowered.charAt(open + 1)))
+            continue;
+        const end = findTagEnd(lowered, open + 1);
+        if (end === -1)
+            break;
+        out += html.slice(cursor, open) + map.tag(html.slice(open, end + 1));
+        cursor = end + 1;
+        if (!isTagAt(lowered, open, "<style"))
+            continue;
+        const close = findRawTextClose(lowered, "style", cursor);
+        if (close === -1)
+            continue;
+        out += map.style(html.slice(cursor, close));
+        cursor = close;
+    }
+    return out + html.slice(cursor);
+}
 export function findStartTags(html, name) {
     const lowered = lowerAscii(html);
     const token = `<${lowerAscii(name)}`;

package/dist/compiler/index.d.ts

@@ -9,7 +9,7 @@ export { addScenePartsManifest } from "./scenePartsManifest.js";
 export { AFTER_FONTS_SCRIPT_TYPE, compositionStyle, cssStyleMergeKey, isAlwaysAppliedStyle, deferScriptsUntilFonts, headStyleRuns, inlineScriptRuns, styleElementsFor, type CompositionStyle, type InlineScriptRun, } from "./scriptRuns.js";
 export { isJavaScriptType } from "./compositionAssembly.js";
 export { validateHyperframeHtmlContract, type HyperframeStaticFailureReason, type HyperframeStaticGuardResult, } from "./staticGuard.js";
-export { buildVariablesByCompScript, dedupeFontFaceRules, scopeCssToComposition, wrapScopedCompositionScript, } from "./compositionScoping.js";
+export { buildVariablesByCompScript, emitVariablesByCompScript, dedupeFontFaceRules, scopeCssToComposition, wrapScopedCompositionScript, } from "./compositionScoping.js";
 export { ensureExternalLinkTag, inlineSubCompositions, type InlineSubCompositionsOptions, type InlineSubCompositionsResult, } from "./inlineSubCompositions.js";
 export { extractStandaloneEntryFromIndex, isTemplateEntry } from "./standaloneEntry.js";
 export { checkSubCompositionUsability, type ParsableDocumentLike, type SubCompositionValidity, type SubCompositionValidityReason, } from "./subCompositionValidity.js";

package/dist/compiler/index.js

@@ -17,7 +17,7 @@ export { isJavaScriptType } from "./compositionAssembly.js";
 // Static guard
 export { validateHyperframeHtmlContract, } from "./staticGuard.js";
 // Composition isolation helpers
-export { buildVariablesByCompScript, dedupeFontFaceRules, scopeCssToComposition, wrapScopedCompositionScript, } from "./compositionScoping.js";
+export { buildVariablesByCompScript, emitVariablesByCompScript, dedupeFontFaceRules, scopeCssToComposition, wrapScopedCompositionScript, } from "./compositionScoping.js";
 // Sub-composition inlining (shared between bundler and producer)
 export { ensureExternalLinkTag, inlineSubCompositions, } from "./inlineSubCompositions.js";
 export { extractStandaloneEntryFromIndex, isTemplateEntry } from "./standaloneEntry.js";