npm - @hyperframes/producer - Versions diffs - 0.2.3 → 0.2.4 - Mend

@hyperframes/producer 0.2.3 → 0.2.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/hyperframe.manifest.json +1 -1
package/dist/hyperframe.runtime.iife.js +5 -5
package/dist/index.js +154 -26
package/dist/index.js.map +4 -4
package/dist/public-server.js +154 -26
package/dist/public-server.js.map +4 -4
package/dist/server.d.ts +4 -0
package/dist/server.d.ts.map +1 -1
package/dist/services/renderOrchestrator.d.ts.map +1 -1
package/dist/utils/semaphore.d.ts +16 -0
package/dist/utils/semaphore.d.ts.map +1 -0
package/package.json +3 -3

package/dist/public-server.js CHANGED Viewed

@@ -102074,7 +102074,8 @@ function truncateSnippet(value, maxLength = 220) {
 // ../core/src/lint/context.ts
 function buildLintContext(html, options = {}) {
-  let source2 = html || "";
+  const rawSource = html || "";
+  let source2 = rawSource;
   const templateMatch = source2.match(/<template[^>]*>([\s\S]*)<\/template>/i);
   if (templateMatch?.[1]) source2 = templateMatch[1];
   const tags = extractOpenTags(source2);
@@ -102085,6 +102086,7 @@ function buildLintContext(html, options = {}) {
   const rootCompositionId = readAttr(rootTag?.raw || "", "data-composition-id");
   return {
     source: source2,
+    rawSource,
     tags,
     styles,
     scripts,
@@ -103258,6 +103260,56 @@ var compositionRules = [
     }
     return findings;
   },
+  // root_composition_missing_data_start
+  ({ rootTag }) => {
+    const findings = [];
+    if (!rootTag) return findings;
+    const compId = readAttr(rootTag.raw, "data-composition-id");
+    if (!compId) return findings;
+    const hasStart = readAttr(rootTag.raw, "data-start") !== null;
+    if (!hasStart) {
+      findings.push({
+        code: "root_composition_missing_data_start",
+        severity: "warning",
+        message: `Root composition "${compId}" is missing data-start. The runtime needs data-start="0" on the root element to begin playback.`,
+        fixHint: 'Add data-start="0" to the root composition element.',
+        snippet: truncateSnippet(rootTag.raw)
+      });
+    }
+    return findings;
+  },
+  // standalone_composition_wrapped_in_template
+  ({ rawSource, options }) => {
+    const findings = [];
+    if (options.isSubComposition) return findings;
+    const trimmed = rawSource.trimStart().toLowerCase();
+    if (trimmed.startsWith("<template")) {
+      findings.push({
+        code: "standalone_composition_wrapped_in_template",
+        severity: "warning",
+        message: "Root index.html is wrapped in a <template> tag. Only sub-compositions loaded via data-composition-src should use <template> wrappers. The runtime cannot play a standalone composition inside a template.",
+        fixHint: "Remove the <template> wrapper. Use <!DOCTYPE html><html>...<div data-composition-id>...</div>...</html> instead."
+      });
+    }
+    return findings;
+  },
+  // root_composition_missing_html_wrapper
+  ({ rawSource, options }) => {
+    const findings = [];
+    if (options.isSubComposition) return findings;
+    const trimmed = rawSource.trimStart().toLowerCase();
+    const hasDoctype = trimmed.startsWith("<!doctype") || trimmed.startsWith("<html");
+    const hasComposition = rawSource.includes("data-composition-id");
+    if (hasComposition && !hasDoctype) {
+      findings.push({
+        code: "root_composition_missing_html_wrapper",
+        severity: "warning",
+        message: "Composition is missing <!DOCTYPE html> and <html> wrapper. The bundler and preview expect a complete HTML document for index.html files.",
+        fixHint: 'Wrap the composition in <!DOCTYPE html><html><head><meta charset="UTF-8"></head><body>...</body></html>.'
+      });
+    }
+    return findings;
+  },
   // requestanimationframe_in_composition
   ({ scripts }) => {
     const findings = [];
@@ -103458,18 +103510,36 @@ async function getCdpSession(page) {
   return client;
 }
 var lastFrameCache = /* @__PURE__ */ new WeakMap();
+var PENDING_FRAME_RETRIES = 5;
+async function sendBeginFrame(client, params) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await client.send("HeadlessExperimental.beginFrame", params);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const isPending = msg.includes("Another frame is pending");
+      if (isPending && attempt < PENDING_FRAME_RETRIES) {
+        await new Promise((r) => setTimeout(r, 50 * 2 ** attempt));
+        continue;
+      }
+      if (isPending) {
+        throw new Error(
+          `[BeginFrame] Frame still pending after ${PENDING_FRAME_RETRIES} retries \u2014 CPU overloaded by parallel renders. Reduce concurrent renders or use --docker for isolation.`
+        );
+      }
+      throw err;
+    }
+  }
+}
 async function beginFrameCapture(page, options, frameTimeTicks, interval) {
   const client = await getCdpSession(page);
-  const format3 = options.format === "png" ? "png" : "jpeg";
-  const result = await client.send("HeadlessExperimental.beginFrame", {
-    frameTimeTicks,
-    interval,
-    screenshot: {
-      format: format3,
-      quality: format3 === "jpeg" ? options.quality ?? 80 : void 0,
-      optimizeForSpeed: true
-    }
-  });
+  const isPng = options.format === "png";
+  const screenshot = {
+    format: isPng ? "png" : "jpeg",
+    quality: isPng ? void 0 : options.quality ?? 80,
+    optimizeForSpeed: true
+  };
+  const result = await sendBeginFrame(client, { frameTimeTicks, interval, screenshot });
   let buffer;
   if (result.screenshotData) {
     buffer = Buffer.from(result.screenshotData, "base64");
@@ -103479,16 +103549,12 @@ async function beginFrameCapture(page, options, frameTimeTicks, interval) {
     if (cached) {
       buffer = cached;
     } else {
-      const retry2 = await client.send("HeadlessExperimental.beginFrame", {
+      const fallback = await sendBeginFrame(client, {
         frameTimeTicks: frameTimeTicks + 1e-3,
         interval,
-        screenshot: {
-          format: format3,
-          quality: format3 === "jpeg" ? options.quality ?? 80 : void 0,
-          optimizeForSpeed: true
-        }
+        screenshot
       });
-      buffer = retry2.screenshotData ? Buffer.from(retry2.screenshotData, "base64") : Buffer.alloc(0);
+      buffer = fallback.screenshotData ? Buffer.from(fallback.screenshotData, "base64") : Buffer.alloc(0);
       if (buffer.length > 0) lastFrameCache.set(page, buffer);
     }
   }
@@ -104991,7 +105057,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
     });
   });
 }
-async function extractAllVideoFrames(videos, baseDir, options, signal, config2) {
+async function extractAllVideoFrames(videos, baseDir, options, signal, config2, compiledDir) {
   const startTime = Date.now();
   const extracted = [];
   const errors = [];
@@ -105004,7 +105070,8 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config2)
       try {
         let videoPath = video.src;
         if (!videoPath.startsWith("/") && !isHttpUrl(videoPath)) {
-          videoPath = join8(baseDir, videoPath);
+          const fromCompiled = compiledDir ? join8(compiledDir, videoPath) : null;
+          videoPath = fromCompiled && existsSync8(fromCompiled) ? fromCompiled : join8(baseDir, videoPath);
         }
         if (isHttpUrl(videoPath)) {
           const downloadDir = join8(options.outputDir, "_downloads");
@@ -105465,7 +105532,7 @@ async function mixAudioTracks(tracks, outputPath, totalDuration, signal, config2
     tracksProcessed: tracks.length
   };
 }
-async function processCompositionAudio(elements, baseDir, workDir, outputPath, totalDuration, signal, config2) {
+async function processCompositionAudio(elements, baseDir, workDir, outputPath, totalDuration, signal, config2, compiledDir) {
   const startMs = Date.now();
   const tracks = [];
   const errors = [];
@@ -105479,7 +105546,8 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
       try {
         let srcPath = element.src;
         if (!srcPath.startsWith("/") && !isHttpUrl(srcPath)) {
-          srcPath = join9(baseDir, srcPath);
+          const fromCompiled = compiledDir ? join9(compiledDir, srcPath) : null;
+          srcPath = fromCompiled && existsSync9(fromCompiled) ? fromCompiled : join9(baseDir, srcPath);
         }
         if (isHttpUrl(srcPath)) {
           try {
@@ -105492,7 +105560,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
           }
         }
         if (!existsSync9(srcPath)) {
-          errors.push(`Source not found: ${element.id}`);
+          errors.push(`Source not found: ${element.id} (${element.src})`);
           return;
         }
         if (element.end - element.start <= 0) {
@@ -107570,12 +107638,15 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
     const stage2Start = Date.now();
     updateJobStatus(job, "preprocessing", "Extracting video frames", 10, onProgress);
     let frameLookup = null;
+    const compiledDir = join13(workDir, "compiled");
     if (composition.videos.length > 0) {
       const extractionResult = await extractAllVideoFrames(
         composition.videos,
         projectDir,
         { fps: job.config.fps, outputDir: join13(workDir, "video-frames") },
-        abortSignal
+        abortSignal,
+        void 0,
+        compiledDir
       );
       assertNotAborted();
       if (extractionResult.extracted.length > 0) {
@@ -107615,7 +107686,9 @@ async function executeRenderJob(job, projectDir, outputPath, onProgress, abortSi
         join13(workDir, "audio-work"),
         audioOutputPath,
         job.duration,
-        abortSignal
+        abortSignal,
+        void 0,
+        compiledDir
       );
       assertNotAborted();
       hasAudio = audioResult.success;
@@ -108118,6 +108191,40 @@ function resolveRenderPaths(projectDir, outputPath, rendersDir = DEFAULT_RENDERS
   return { absoluteProjectDir, absoluteOutputPath };
 }
+// src/utils/semaphore.ts
+var Semaphore = class {
+  constructor(maxConcurrent) {
+    this.maxConcurrent = maxConcurrent;
+  }
+  queue = [];
+  active = 0;
+  async acquire() {
+    if (this.active < this.maxConcurrent) {
+      this.active++;
+      return () => this.release();
+    }
+    return new Promise((resolve13) => {
+      this.queue.push(() => {
+        this.active++;
+        resolve13(() => this.release());
+      });
+    });
+  }
+  release() {
+    this.active--;
+    const next = this.queue.shift();
+    if (next) next();
+  }
+  /** Current number of active slots. */
+  get activeCount() {
+    return this.active;
+  }
+  /** Number of waiters in the queue. */
+  get waitingCount() {
+    return this.queue.length;
+  }
+};
 // src/server.ts
 function parseRenderOptions(body) {
   const fps = [24, 30, 60].includes(body.fps) ? body.fps : 30;
@@ -108231,6 +108338,8 @@ function createRenderHandlers(options = {}) {
   const rendersDir = options.rendersDir ?? process.env.PRODUCER_RENDERS_DIR ?? "/tmp";
   const artifactTtlMs = options.artifactTtlMs ?? Number(process.env.PRODUCER_OUTPUT_ARTIFACT_TTL_MS || 15 * 60 * 1e3);
   const store = createArtifactStore(artifactTtlMs);
+  const maxConcurrentRenders = options.maxConcurrentRenders ?? Number(process.env.PRODUCER_MAX_CONCURRENT_RENDERS || 2);
+  const renderSemaphore = new Semaphore(maxConcurrentRenders);
   const startTime = Date.now();
   const health = (c) => c.json({
     status: "ok",
@@ -108287,6 +108396,7 @@ function createRenderHandlers(options = {}) {
     );
     const outputDir = dirname11(absoluteOutputPath);
     if (!existsSync16(outputDir)) mkdirSync10(outputDir, { recursive: true });
+    const release = await renderSemaphore.acquire();
     log.info("render started", {
       requestId,
       projectDir: input2.projectDir,
@@ -108354,6 +108464,7 @@ function createRenderHandlers(options = {}) {
         500
       );
     } finally {
+      release();
       cleanupTempDir(cleanupProjectDir, log);
     }
   };
@@ -108410,6 +108521,16 @@ function createRenderHandlers(options = {}) {
       const abortController = new AbortController();
       const onRequestAbort = () => abortController.abort(new RenderCancelledError("request_aborted"));
       c.req.raw.signal.addEventListener("abort", onRequestAbort, { once: true });
+      if (renderSemaphore.activeCount >= maxConcurrentRenders) {
+        await stream2.writeSSE({
+          data: JSON.stringify({
+            type: "queued",
+            requestId,
+            position: renderSemaphore.waitingCount
+          })
+        });
+      }
+      const release = await renderSemaphore.acquire();
       try {
         await executeRenderJob(
           job,
@@ -108477,6 +108598,7 @@ function createRenderHandlers(options = {}) {
           })
         });
       } finally {
+        release();
         c.req.raw.signal.removeEventListener("abort", onRequestAbort);
         cleanupTempDir(cleanupProjectDir, log);
       }
@@ -108501,7 +108623,12 @@ function createRenderHandlers(options = {}) {
       }
     });
   };
-  return { render: render2, renderStream, lint, health, outputs };
+  const queue = (c) => c.json({
+    maxConcurrentRenders,
+    activeRenders: renderSemaphore.activeCount,
+    queuedRenders: renderSemaphore.waitingCount
+  });
+  return { render: render2, renderStream, lint, health, outputs, queue };
 }
 function createProducerApp(options = {}) {
   const app = new Hono2();
@@ -108509,6 +108636,7 @@ function createProducerApp(options = {}) {
   app.get("/health", handlers.health);
   app.post("/render", handlers.render);
   app.post("/render/stream", handlers.renderStream);
+  app.get("/render/queue", handlers.queue);
   app.post("/lint", handlers.lint);
   app.get("/outputs/:token", handlers.outputs);
   return app;