@hyperframes/studio-server 0.7.94 → 0.7.96

package/dist/helpers/mediaProxyPreview.d.ts

@@ -1,4 +1,4 @@
-export { P as PreviewApiAdapter, i as injectMediaCodecMap, e as injectMediaCodecMapIntoHtml, f as isAutoProxyEnabled, p as proxyEtagSalt, r as resolvePreviewMediaCodecProbeCache } from '../mediaProxyPreview-pJzYIpV9.js';
+export { P as PreviewApiAdapter, i as injectMediaCodecMap, e as injectMediaCodecMapIntoHtml, f as isAutoProxyEnabled, p as proxyEtagSalt, r as resolvePreviewMediaCodecProbeCache } from '../mediaProxyPreview-DVTxBkRO.js';
 import './mediaCodecMap.js';
 import '@hyperframes/core';
 import '@hyperframes/parsers';

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Hono } from 'hono';
-import { S as StudioApiAdapter, M as MediaProcessingJobState } from './mediaProxyPreview-pJzYIpV9.js';
-export { L as LintResult, P as PreviewApiAdapter, R as RenderJobState, a as ResolvedProject, b as StudioSelectionResponse, c as StudioSelectionSnapshot, d as StudioSelectionTextField } from './mediaProxyPreview-pJzYIpV9.js';
+import { S as StudioApiAdapter, M as MediaProcessingJobState } from './mediaProxyPreview-DVTxBkRO.js';
+export { L as LintResult, P as PreviewApiAdapter, R as RenderJobState, a as ResolvedProject, b as StudioSelectionResponse, c as StudioSelectionSnapshot, d as StudioSelectionTextField } from './mediaProxyPreview-DVTxBkRO.js';
 export { ScreenshotClip, getElementScreenshotClip } from './helpers/screenshotClip.js';
 export { STUDIO_MANUAL_EDITS_PATH, StudioManualEditsRenderScriptOptions, createStudioManualEditsRenderBodyScript, createStudioPositionSeekReapplyScript } from './helpers/manualEditsRenderScript.js';
 export { STUDIO_MOTION_PATH, StudioMotionRenderScriptOptions, createStudioMotionRenderBodyScript } from './helpers/studioMotionRenderScript.js';
@@ -57,6 +57,15 @@ declare function consumeFileWriteReceipt(absPath: string): FileWriteReceipt | nu
  */
 declare function buildSubCompositionHtml(projectDir: string, compPath: string, runtimeUrl: string, baseHref?: string, rawOverride?: string): string | null;
 
+interface ThumbnailOutputDimensions {
+    width: number;
+    height: number;
+    outputWidth: number;
+    outputHeight: number;
+}
+/** Sole adapter rule for capturing authored layout at bounded physical dimensions. */
+declare function thumbnailDeviceScaleFactor({ width, height, outputWidth, outputHeight, }: ThumbnailOutputDimensions): number;
+
 type BackgroundRemovalJobOptions = Parameters<NonNullable<StudioApiAdapter["startBackgroundRemoval"]>>[0];
 type BackgroundRemovalProgressEvent = {
     kind: "info";
@@ -88,4 +97,4 @@ type BackgroundRemovalRender = (options: {
 }>;
 declare function createBackgroundRemovalJob(opts: BackgroundRemovalJobOptions, render: BackgroundRemovalRender): MediaProcessingJobState;
 
-export { type BackgroundRemovalRender, type FileWriteReceipt, MIME_TYPES, MediaProcessingJobState, StudioApiAdapter, buildSubCompositionHtml, consumeFileWriteReceipt, createBackgroundRemovalJob, createProjectSignature, createStudioApi, fileContentVersion, getMimeType, walkDir };
+export { type BackgroundRemovalRender, type FileWriteReceipt, MIME_TYPES, MediaProcessingJobState, StudioApiAdapter, type ThumbnailOutputDimensions, buildSubCompositionHtml, consumeFileWriteReceipt, createBackgroundRemovalJob, createProjectSignature, createStudioApi, fileContentVersion, getMimeType, thumbnailDeviceScaleFactor, walkDir };

package/dist/index.js

@@ -3918,10 +3918,170 @@ function registerRenderRoutes(api, adapter) {
 }
 
 // src/routes/thumbnail.ts
-import { existsSync as existsSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, statSync as statSync4 } from "fs";
+import {
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync11,
+  readdirSync as readdirSync6,
+  renameSync as renameSync2,
+  rmSync as rmSync3,
+  statSync as statSync4,
+  unlinkSync as unlinkSync4,
+  writeFileSync as writeFileSync6
+} from "fs";
 import { join as join11 } from "path";
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID3 } from "crypto";
+
+// src/routes/thumbnailGenerationCoordinator.ts
+var ThumbnailGenerationCoordinator = class {
+  constructor(concurrency = 1) {
+    this.concurrency = concurrency;
+    if (!Number.isInteger(concurrency) || concurrency < 1) {
+      throw new RangeError("Thumbnail concurrency must be a positive integer");
+    }
+  }
+  concurrency;
+  entries = /* @__PURE__ */ new Map();
+  queue = [];
+  activeEntries = /* @__PURE__ */ new Set();
+  active = 0;
+  acquire(key, signal, work) {
+    if (signal.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
+    let entry = this.entries.get(key);
+    if (!entry) {
+      let resolve5;
+      let reject;
+      const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve5 = resolvePromise;
+        reject = rejectPromise;
+      });
+      entry = {
+        key,
+        controller: new AbortController(),
+        leases: 0,
+        state: "queued",
+        work,
+        promise,
+        resolve: resolve5,
+        reject
+      };
+      this.entries.set(key, entry);
+      this.queue.push(entry);
+    }
+    entry.leases++;
+    this.pump();
+    return this.lease(entry, signal);
+  }
+  protectedKeys() {
+    return /* @__PURE__ */ new Set([...this.entries.keys(), ...[...this.activeEntries].map((entry) => entry.key)]);
+  }
+  lease(entry, signal) {
+    return new Promise((resolve5, reject) => {
+      let released = false;
+      const release = () => {
+        if (released) return;
+        released = true;
+        signal.removeEventListener("abort", onAbort);
+        entry.leases--;
+        if (entry.leases > 0 || !this.entries.has(entry.key)) return;
+        entry.controller.abort();
+        if (this.entries.get(entry.key) === entry) this.entries.delete(entry.key);
+        if (entry.state === "queued") {
+          const index = this.queue.indexOf(entry);
+          if (index >= 0) this.queue.splice(index, 1);
+          entry.reject(new DOMException("Aborted", "AbortError"));
+        }
+      };
+      const onAbort = () => {
+        release();
+        reject(new DOMException("Aborted", "AbortError"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      entry.promise.then(
+        (value) => {
+          release();
+          resolve5(value);
+        },
+        (reason) => {
+          release();
+          reject(reason);
+        }
+      );
+    });
+  }
+  pump() {
+    while (this.active < this.concurrency) {
+      const entry = this.queue.shift();
+      if (!entry) return;
+      if (entry.leases === 0) continue;
+      entry.state = "active";
+      this.activeEntries.add(entry);
+      this.active++;
+      void this.run(entry);
+    }
+  }
+  async run(entry) {
+    try {
+      entry.resolve(await entry.work(entry.controller.signal));
+    } catch (error) {
+      entry.reject(error);
+    } finally {
+      this.active--;
+      this.activeEntries.delete(entry);
+      if (this.entries.get(entry.key) === entry) this.entries.delete(entry.key);
+      this.pump();
+    }
+  }
+};
+var thumbnailGenerationCoordinator = new ThumbnailGenerationCoordinator(1);
+
+// src/routes/thumbnail.ts
 var THUMBNAIL_CACHE_VERSION = "v4";
+var THUMBNAIL_MAX_OUTPUT_WIDTH = 240;
+var THUMBNAIL_MAX_OUTPUT_HEIGHT = 135;
+var THUMBNAIL_CACHE_MAX_BYTES = 512 * 1024 * 1024;
+var THUMBNAIL_CACHE_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+var prunedCacheDirs = /* @__PURE__ */ new Set();
+function pruneThumbnailCache(cacheDir, protectedPaths, now = Date.now()) {
+  if (!existsSync8(cacheDir)) return;
+  const files = readdirSync6(cacheDir, { withFileTypes: true }).flatMap((entry) => {
+    if (!entry.isFile()) return [];
+    const path = join11(cacheDir, entry.name);
+    try {
+      const stats = statSync4(path);
+      return [{ path, bytes: stats.size, mtimeMs: stats.mtimeMs }];
+    } catch {
+      return [];
+    }
+  });
+  const retained = [];
+  for (const file of files) {
+    if (!protectedPaths.has(file.path) && now - file.mtimeMs > THUMBNAIL_CACHE_MAX_AGE_MS) {
+      rmSync3(file.path, { force: true });
+    } else {
+      retained.push(file);
+    }
+  }
+  let bytes = retained.reduce((total, file) => total + file.bytes, 0);
+  for (const file of retained.sort((left, right) => left.mtimeMs - right.mtimeMs)) {
+    if (bytes <= THUMBNAIL_CACHE_MAX_BYTES) break;
+    if (protectedPaths.has(file.path)) continue;
+    try {
+      unlinkSync4(file.path);
+      bytes -= file.bytes;
+    } catch {
+    }
+  }
+}
+function writeThumbnailAtomically(path, buffer) {
+  const temporaryPath = `${path}.${process.pid}.${randomUUID3()}.tmp`;
+  try {
+    writeFileSync6(temporaryPath, buffer, { flag: "wx" });
+    renameSync2(temporaryPath, path);
+  } finally {
+    rmSync3(temporaryPath, { force: true });
+  }
+}
 function registerThumbnailRoutes(api, adapter) {
   api.get("/projects/:id/thumbnail/*", async (c) => {
     if (!adapter.generateThumbnail) {
@@ -3942,6 +4102,8 @@ function registerThumbnailRoutes(api, adapter) {
     const selector = url.searchParams.get("selector") || void 0;
     const format = url.searchParams.get("format") === "png" ? "png" : "jpeg";
     const contentType = format === "png" ? "image/png" : "image/jpeg";
+    const requestedOutput = url.searchParams.get("output");
+    const outputMode = requestedOutput === "source" || requestedOutput !== "preview" && format === "png" ? "source" : "preview";
     const rawSelectorIndex = Number.parseInt(url.searchParams.get("selectorIndex") || "0", 10);
     const selectorIndex = Number.isFinite(rawSelectorIndex) && rawSelectorIndex > 0 ? rawSelectorIndex : void 0;
     const urlVersion = url.searchParams.get("v") || "";
@@ -3979,37 +4141,62 @@ function registerThumbnailRoutes(api, adapter) {
     const cacheDir = join11(project.dir, ".thumbnails");
     const selectorKey = selector ? `_${selector.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 80)}_${selectorIndex ?? 0}` : "";
     const urlVersionKey = urlVersion ? `_${urlVersion.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 32)}` : "";
-    const cacheKey = `${THUMBNAIL_CACHE_VERSION}${urlVersionKey}${manualEditsKey}${motionKey}${sourceKey}_${format}_${compPath.replace(/\//g, "_")}_${compW}x${compH}_${sourceMtime}_${seekTime.toFixed(2)}${selectorKey}.${format === "png" ? "png" : "jpg"}`;
+    const outputScale = outputMode === "source" ? 1 : Math.min(1, THUMBNAIL_MAX_OUTPUT_WIDTH / compW, THUMBNAIL_MAX_OUTPUT_HEIGHT / compH);
+    const outputWidth = Math.max(1, Math.round(compW * outputScale));
+    const outputHeight = Math.max(1, Math.round(compH * outputScale));
+    const cacheKey = `${THUMBNAIL_CACHE_VERSION}${urlVersionKey}${manualEditsKey}${motionKey}${sourceKey}_${format}_${outputMode}_${compPath.replace(/\//g, "_")}_${compW}x${compH}_${outputWidth}x${outputHeight}_${sourceMtime}_${seekTime.toFixed(2)}${selectorKey}.${format === "png" ? "png" : "jpg"}`;
     const cachePath = join11(cacheDir, cacheKey);
+    if (!prunedCacheDirs.has(cacheDir)) {
+      prunedCacheDirs.add(cacheDir);
+      pruneThumbnailCache(
+        cacheDir,
+        /* @__PURE__ */ new Set([...thumbnailGenerationCoordinator.protectedKeys(), cachePath])
+      );
+    }
     if (existsSync8(cachePath)) {
       return new Response(new Uint8Array(readFileSync11(cachePath)), {
         headers: { "Content-Type": contentType, "Cache-Control": "no-cache" }
       });
     }
     try {
-      const buffer = await adapter.generateThumbnail({
-        project,
-        compPath,
-        seekTime,
-        width: compW,
-        height: compH,
-        previewUrl,
-        selector,
-        format,
-        selectorIndex
-      });
+      const buffer = await thumbnailGenerationCoordinator.acquire(
+        cachePath,
+        c.req.raw.signal,
+        async (signal) => {
+          const generated = await adapter.generateThumbnail({
+            project,
+            compPath,
+            seekTime,
+            width: compW,
+            height: compH,
+            outputWidth,
+            outputHeight,
+            previewUrl,
+            selector,
+            format,
+            selectorIndex,
+            signal
+          });
+          if (!generated) return null;
+          if (!existsSync8(cacheDir)) mkdirSync5(cacheDir, { recursive: true });
+          writeThumbnailAtomically(cachePath, generated);
+          return generated;
+        }
+      );
       if (!buffer) {
         return c.json(
           { error: "Thumbnail generation failed \u2014 Chrome browser may not be available" },
           500
         );
       }
-      if (!existsSync8(cacheDir)) mkdirSync5(cacheDir, { recursive: true });
-      writeFileSync6(cachePath, buffer);
+      pruneThumbnailCache(cacheDir, thumbnailGenerationCoordinator.protectedKeys());
       return new Response(new Uint8Array(buffer), {
         headers: { "Content-Type": contentType, "Cache-Control": "no-cache" }
       });
     } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") {
+        return new Response(null, { status: 499 });
+      }
       const msg = err instanceof Error ? err.message : String(err);
       return c.json({ error: `Thumbnail generation failed: ${msg}` }, 500);
     }
@@ -4562,6 +4749,20 @@ function createStudioApi(adapter) {
   return api;
 }
 
+// src/helpers/thumbnailOutput.ts
+function thumbnailDeviceScaleFactor({
+  width,
+  height,
+  outputWidth,
+  outputHeight
+}) {
+  const dimensions = [width, height, outputWidth, outputHeight];
+  if (dimensions.some((value) => !Number.isFinite(value) || value <= 0)) {
+    throw new RangeError("Thumbnail dimensions must be positive finite numbers");
+  }
+  return Math.min(1, outputWidth / width, outputHeight / height);
+}
+
 // src/helpers/backgroundRemovalJob.ts
 function createBackgroundRemovalJob(opts, render) {
   const state = {
@@ -4631,6 +4832,7 @@ export {
   getElementScreenshotClip,
   getMimeType,
   isSafePath,
+  thumbnailDeviceScaleFactor,
   walkDir
 };
 //# sourceMappingURL=index.js.map