@glissade/export-web 0.7.0 → 0.8.0-pre.1

package/dist/index.d.ts

@@ -88,6 +88,39 @@ interface WebExportResult {
 declare class ExportUnsupportedError extends Error {
   constructor(detail: string);
 }
+/** Encodability probes — the real ones wrap mediabunny; tests inject fakes. */
+type VideoProbe = (codecs: VideoCodec[]) => Promise<VideoCodec | null>;
+type AudioProbe = (codecs: AudioCodec[]) => Promise<AudioCodec | null>;
+interface ExportSupport {
+  format: 'mp4' | 'webm';
+  /** first encodable video codec, or null if none. */
+  video: VideoCodec | null;
+  /** first encodable audio codec, or null if none. */
+  audio: AudioCodec | null;
+  /** true when video can encode (audio is optional — falls back to video-only). */
+  supported: boolean;
+}
+/**
+ * The resolved encodability matrix (§5.2): one row per container, so a UI can
+ * grey out options instead of failing mid-render. Audio absence is not a
+ * blocker — the export falls back to video-only.
+ */
+declare function probeExportSupport(opts?: {
+  width?: number;
+  height?: number;
+  bitrate?: number;
+}): Promise<ExportSupport[]>;
+/**
+ * Choose a (format, video, audio) triple. When audio is requested but no audio
+ * codec encodes, fall back to **video-only** (§5.2 — Safari 16.4–18.x is
+ * video-only) with a warning, instead of failing the whole format. Throws only
+ * when no video codec encodes at all. Probes are injected for testability.
+ */
+declare function pickCodecs(format: 'mp4' | 'webm' | 'auto', needAudio: boolean, probeVideo: VideoProbe, probeAudio: AudioProbe): Promise<{
+  format: 'mp4' | 'webm';
+  video: VideoCodec;
+  audio: AudioCodec | null;
+}>;
 /** Mix timeline audio clips sample-accurately (§5.3 browser path). Window-only (OfflineAudioContext). */
 declare function mixAudio(clips: AudioClip[], duration: number, sampleRate?: number): Promise<AudioBuffer>;
 /** Main-thread premix for the worker path: mixAudio flattened to transferable channels. */
@@ -101,4 +134,4 @@ declare function exportPngFrames(scene: Scene, doc: Timeline, onFrame: (frame: n
   frames: number;
 }>;
 //#endregion
-export { ExportUnsupportedError, type ExportWorkerRequest, type ExportWorkerResponse, MediabunnyVideoFrameSource, PremixedAudio, WebExportOptions, WebExportResult, type WorkerExportHandle, exportPngFrames, exportVideo, mixAudio, premixTimelineAudio, requestWorkerExport, serveExportRequest };
+export { AudioProbe, ExportSupport, ExportUnsupportedError, type ExportWorkerRequest, type ExportWorkerResponse, MediabunnyVideoFrameSource, PremixedAudio, VideoProbe, WebExportOptions, WebExportResult, type WorkerExportHandle, exportPngFrames, exportVideo, mixAudio, pickCodecs, premixTimelineAudio, probeExportSupport, requestWorkerExport, serveExportRequest };

package/dist/index.js

@@ -1,5 +1,5 @@
 import { ALL_FORMATS, AudioBufferSource, AudioSample, AudioSampleSource, BlobSource, BufferTarget, CanvasSink, CanvasSource, Input, Mp4OutputFormat, Output, UrlSource, WebMOutputFormat, getFirstEncodableAudioCodec, getFirstEncodableVideoCodec } from "mediabunny";
-import { audioOffsetSamples, compileTimeline, sampleTrack } from "@glissade/core";
+import { audioOffsetSamples, compileTimeline, emitDevWarning, sampleTrack } from "@glissade/core";
 import { ColdAssetError, evaluate } from "@glissade/scene";
 import { Canvas2DBackend } from "@glissade/backend-canvas2d";
 //#region src/videoSource.ts
@@ -189,25 +189,65 @@ const WEBM_VIDEO = [
 ];
 const MP4_AUDIO = ["aac", "opus"];
 const WEBM_AUDIO = ["opus"];
-async function pickCodecs(format, width, height, bitrate, needAudio) {
-	const tryFormat = async (f) => {
-		const video = await getFirstEncodableVideoCodec(f === "mp4" ? MP4_VIDEO : WEBM_VIDEO, {
-			width,
-			height,
-			bitrate
+/**
+* The resolved encodability matrix (§5.2): one row per container, so a UI can
+* grey out options instead of failing mid-render. Audio absence is not a
+* blocker — the export falls back to video-only.
+*/
+async function probeExportSupport(opts = {}) {
+	const { width = 1920, height = 1080, bitrate = 8e6 } = opts;
+	const probeVideo = (codecs) => getFirstEncodableVideoCodec(codecs, {
+		width,
+		height,
+		bitrate
+	});
+	const probeAudio = (codecs) => getFirstEncodableAudioCodec(codecs);
+	const out = [];
+	for (const format of ["mp4", "webm"]) {
+		const video = await probeVideo(format === "mp4" ? MP4_VIDEO : WEBM_VIDEO);
+		const audio = await probeAudio(format === "mp4" ? MP4_AUDIO : WEBM_AUDIO);
+		out.push({
+			format,
+			video,
+			audio,
+			supported: video !== null
 		});
-		if (!video) return null;
-		const audio = needAudio ? await getFirstEncodableAudioCodec(f === "mp4" ? MP4_AUDIO : WEBM_AUDIO) : null;
-		if (needAudio && !audio) return null;
-		return {
+	}
+	return out;
+}
+/**
+* Choose a (format, video, audio) triple. When audio is requested but no audio
+* codec encodes, fall back to **video-only** (§5.2 — Safari 16.4–18.x is
+* video-only) with a warning, instead of failing the whole format. Throws only
+* when no video codec encodes at all. Probes are injected for testability.
+*/
+async function pickCodecs(format, needAudio, probeVideo, probeAudio) {
+	let videoOnly = null;
+	for (const f of format === "auto" ? ["mp4", "webm"] : [format]) {
+		const video = await probeVideo(f === "mp4" ? MP4_VIDEO : WEBM_VIDEO);
+		if (!video) continue;
+		if (!needAudio) return {
+			format: f,
+			video,
+			audio: null
+		};
+		const audio = await probeAudio(f === "mp4" ? MP4_AUDIO : WEBM_AUDIO);
+		if (audio) return {
 			format: f,
 			video,
 			audio
 		};
-	};
-	for (const f of format === "auto" ? ["mp4", "webm"] : [format]) {
-		const picked = await tryFormat(f);
-		if (picked) return picked;
+		videoOnly ??= {
+			format: f,
+			video
+		};
+	}
+	if (videoOnly) {
+		emitDevWarning(`no encodable audio codec for '${format}'; exporting video-only (§5.2)`);
+		return {
+			...videoOnly,
+			audio: null
+		};
 	}
 	throw new ExportUnsupportedError(`format '${format}'${needAudio ? " with audio" : ""}`);
 }
@@ -263,7 +303,11 @@ async function exportVideo(scene, doc, opts = {}) {
 	const total = Math.max(1, Math.ceil(duration * fps));
 	const { w, h } = scene.size;
 	const videoBitrate = opts.videoBitrate ?? 8e6;
-	const picked = await pickCodecs(opts.format ?? "auto", w, h, videoBitrate, compiled.audio.length > 0);
+	const picked = await pickCodecs(opts.format ?? "auto", compiled.audio.length > 0, (codecs) => getFirstEncodableVideoCodec(codecs, {
+		width: w,
+		height: h,
+		bitrate: videoBitrate
+	}), (codecs) => getFirstEncodableAudioCodec(codecs));
 	const canvas = new OffscreenCanvas(w, h);
 	const backend = new Canvas2DBackend(canvas);
 	scene.setTextMeasurer(backend);
@@ -376,4 +420,4 @@ async function exportPngFrames(scene, doc, onFrame, opts = {}) {
 	return { frames: total };
 }
 //#endregion
-export { ExportUnsupportedError, MediabunnyVideoFrameSource, exportPngFrames, exportVideo, mixAudio, premixTimelineAudio, requestWorkerExport, serveExportRequest };
+export { ExportUnsupportedError, MediabunnyVideoFrameSource, exportPngFrames, exportVideo, mixAudio, pickCodecs, premixTimelineAudio, probeExportSupport, requestWorkerExport, serveExportRequest };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glissade/export-web",
-  "version": "0.7.0",
+  "version": "0.8.0-pre.1",
   "description": "glissade in-browser export: WebCodecs VideoEncoder + Mediabunny muxing, OfflineAudioContext audio mix. Frame-accurate, faster than realtime, no server.",
   "license": "Apache-2.0",
   "type": "module",
@@ -16,9 +16,9 @@
   ],
   "dependencies": {
     "mediabunny": "^1.0.0",
-    "@glissade/backend-canvas2d": "0.7.0",
-    "@glissade/core": "0.7.0",
-    "@glissade/scene": "0.7.0"
+    "@glissade/core": "0.8.0-pre.1",
+    "@glissade/backend-canvas2d": "0.8.0-pre.1",
+    "@glissade/scene": "0.8.0-pre.1"
   },
   "repository": {
     "type": "git",