Create polished demo videos without editing skills. Mac/Windows/Linux
fix(export): keep large saves off arraybuffer path
wiiiii1238681bfe497b4
diff --git a/electron/ipc/register/export.ts b/electron/ipc/register/export.tsindex c095cf39..ede2272f 100644--- a/electron/ipc/register/export.ts+++ b/electron/ipc/register/export.ts@@ -51,6 +51,16 @@ function getPartialExportDestinationPath(destinationPath: string) {return path.join(parsed.dir, `.recordly-partial-${parsed.name}-${suffix}${parsed.ext}`);}+const MAX_IN_MEMORY_EXPORT_BYTES = 0x7fffffff;++function getInMemoryExportTooLargeMessage(byteLength: number) {+ if (byteLength <= MAX_IN_MEMORY_EXPORT_BYTES) {+ return null;+ }++ return "Export is too large for the legacy in-memory save path. Please retry with temp-file streaming enabled.";+}+export async function moveExportedTempFile(tempPath: string, destinationPath: string) {await fs.mkdir(path.dirname(destinationPath), { recursive: true });try {@@ -700,6 +710,14 @@ export function registerExportHandlers() {"mux-exported-video-audio",async (_, videoData: ArrayBuffer, options?: NativeVideoExportFinishOptions) => {try {+ const sizeError = getInMemoryExportTooLargeMessage(videoData.byteLength);+ if (sizeError) {+ return {+ success: false,+ error: sizeError,+ };+ }+const result = await muxExportedVideoAudioBuffer(videoData, options ?? {});// Register the muxed output so finalize-exported-video / discard-// exported-temp accept it. Returning a temp path (instead of the@@ -797,6 +815,15 @@ export function registerExportHandlers() {"save-exported-video",async (event, videoData: ArrayBuffer, fileName: string) => {try {+ const sizeError = getInMemoryExportTooLargeMessage(videoData.byteLength);+ if (sizeError) {+ return {+ success: false,+ message: sizeError,+ error: sizeError,+ };+ }+// Determine file type from extensionconst isGif = fileName.toLowerCase().endsWith(".gif");const filters = isGif@@ -845,6 +872,16 @@ export function registerExportHandlers() {"write-exported-video-to-path",async (_event, videoData: ArrayBuffer, outputPath: string) => {try {+ const sizeError = getInMemoryExportTooLargeMessage(videoData.byteLength);+ if (sizeError) {+ return {+ success: false,+ message: sizeError,+ canceled: false,+ error: sizeError,+ };+ }+const resolvedPath = path.resolve(outputPath);await fs.mkdir(path.dirname(resolvedPath), { recursive: true });await fs.writeFile(resolvedPath, Buffer.from(videoData));diff --git a/src/components/video-editor/VideoEditor.tsx b/src/components/video-editor/VideoEditor.tsxindex 0145f273..9cc3d413 100644--- a/src/components/video-editor/VideoEditor.tsx+++ b/src/components/video-editor/VideoEditor.tsx@@ -76,6 +76,10 @@ import {VideoExporter,} from "@/lib/exporter";import { getMp4ExportBitrate, getSourceQualityBitrate } from "@/lib/exporter/exportBitrate";+import {+ canUseInMemoryExportSaveFallback,+ describeBlockedInMemoryExportSave,+} from "@/lib/exporter/exportSavePolicy";import { resolveMediaElementSource } from "@/lib/exporter/localMediaSource";import { resolveSourceAudioFallbackPaths } from "@/lib/exporter/sourceAudioFallback";import {@@ -1485,6 +1489,12 @@ export default function VideoEditor() {const saveBlobExport = useCallback(async (blob: Blob, fileName: string, outputPath: string | null = null) => {const extension = fileName.split(".").pop()?.toLowerCase() || "bin";+ const hasExportStreamApi =+ typeof window !== "undefined" &&+ typeof window.electronAPI?.openExportStream === "function" &&+ typeof window.electronAPI?.writeExportStreamChunk === "function" &&+ typeof window.electronAPI?.closeExportStream === "function";+ let streamError: unknown = null;try {const tempFilePath = await streamExportBlobToTempFile(blob, extension);@@ -1502,9 +1512,37 @@ export default function VideoEditor() {};}} catch (error) {- console.warn("[export] Falling back to in-memory blob save", error);+ streamError = error;+ console.warn("[export] Temp-file blob save failed", error);+ }++ if (+ !canUseInMemoryExportSaveFallback({+ blobSize: blob.size,+ extension,+ hasExportStreamApi,+ })+ ) {+ const message = describeBlockedInMemoryExportSave({+ blobSize: blob.size,+ extension,+ });+ console.error("[export] Refusing in-memory blob save fallback", {+ fileName,+ blobSize: blob.size,+ extension,+ hasExportStreamApi,+ streamError,+ });+ throw new Error(message);}+ console.warn("[export] Falling back to in-memory blob save", {+ fileName,+ blobSize: blob.size,+ extension,+ hasExportStreamApi,+ });const arrayBuffer = await blob.arrayBuffer();return {saveResult: outputPathdiff --git a/src/lib/exporter/exportSavePolicy.test.ts b/src/lib/exporter/exportSavePolicy.test.tsnew file mode 100644index 00000000..fb60c285--- /dev/null+++ b/src/lib/exporter/exportSavePolicy.test.ts@@ -0,0 +1,54 @@+import { describe, expect, it } from "vitest";+import {+ canUseInMemoryExportSaveFallback,+ describeBlockedInMemoryExportSave,+ isExportTooLargeForInMemorySave,+ MAX_IN_MEMORY_EXPORT_BYTES,+ normalizeExportExtension,+} from "./exportSavePolicy";++describe("exportSavePolicy", () => {+ it("normalizes export extensions before policy checks", () => {+ expect(normalizeExportExtension(" MP4 ")).toBe("mp4");+ });++ it("blocks the legacy in-memory save path above Node's Buffer limit", () => {+ expect(isExportTooLargeForInMemorySave(MAX_IN_MEMORY_EXPORT_BYTES + 1)).toBe(true);+ expect(+ canUseInMemoryExportSaveFallback({+ blobSize: MAX_IN_MEMORY_EXPORT_BYTES + 1,+ extension: "gif",+ hasExportStreamApi: false,+ }),+ ).toBe(false);+ });++ it("keeps Electron MP4 exports on the temp-file save path", () => {+ expect(+ canUseInMemoryExportSaveFallback({+ blobSize: 1024,+ extension: "mp4",+ hasExportStreamApi: true,+ }),+ ).toBe(false);+ });++ it("allows small non-MP4 exports to use the legacy save fallback", () => {+ expect(+ canUseInMemoryExportSaveFallback({+ blobSize: 1024,+ extension: "gif",+ hasExportStreamApi: false,+ }),+ ).toBe(true);+ });++ it("explains blocked large saves without mentioning implementation stack traces", () => {+ expect(+ describeBlockedInMemoryExportSave({+ blobSize: MAX_IN_MEMORY_EXPORT_BYTES + 1,+ extension: "mp4",+ }),+ ).toContain("too large");+ });+});diff --git a/src/lib/exporter/exportSavePolicy.ts b/src/lib/exporter/exportSavePolicy.tsnew file mode 100644index 00000000..c48516ed--- /dev/null+++ b/src/lib/exporter/exportSavePolicy.ts@@ -0,0 +1,46 @@+export const MAX_IN_MEMORY_EXPORT_BYTES = 0x7fffffff;++export function normalizeExportExtension(extension: string): string {+ return extension.trim().toLowerCase();+}++export function isExportTooLargeForInMemorySave(byteLength: number): boolean {+ return byteLength > MAX_IN_MEMORY_EXPORT_BYTES;+}++export function canUseInMemoryExportSaveFallback({+ blobSize,+ extension,+ hasExportStreamApi,+}: {+ blobSize: number;+ extension: string;+ hasExportStreamApi: boolean;+}): boolean {+ if (isExportTooLargeForInMemorySave(blobSize)) {+ return false;+ }++ // In Electron, MP4 exports should stay on the temp-file path. If that path+ // failed, silently falling back to ArrayBuffer reintroduces the >2 GiB crash.+ if (hasExportStreamApi && normalizeExportExtension(extension) === "mp4") {+ return false;+ }++ return true;+}++export function describeBlockedInMemoryExportSave({+ blobSize,+ extension,+}: {+ blobSize: number;+ extension: string;+}): string {+ const normalizedExtension = normalizeExportExtension(extension) || "export";+ if (isExportTooLargeForInMemorySave(blobSize)) {+ return `The ${normalizedExtension.toUpperCase()} export is too large to save through the legacy in-memory path. Please retry the export so Recordly can save it through the temp-file streaming path.`;+ }++ return `The ${normalizedExtension.toUpperCase()} export could not be saved through the temp-file streaming path, and Recordly will not fall back to the legacy in-memory path for MP4 exports. Please retry the export.`;+}