mulmocast 2.17.0 → 2.18.0

package/lib/utils/html_render.js

@@ -4,6 +4,8 @@ import nodePath from "node:path";
 import crypto from "node:crypto";
 import { marked } from "marked";
 import puppeteer from "puppeteer";
+import { guardRenderPage } from "./render_network_guard.js";
+import { strictNetworkLaunchArgs, withRenderContentSecurityPolicy } from "./render_network_policy.js";
 import { GraphAILogger } from "graphai";
 const isCI = process.env.CI === "true";
 const VIDEO_LOAD_TIMEOUT_MS = 15000;
@@ -83,15 +85,16 @@ const resolveWaitUntil = (html) => {
  * and navigate via page.goto (setContent uses about:blank origin
  * which blocks file:// loading).
  */
-const loadHtmlIntoPage = async (page, html, timeout_ms) => {
+const renderTempPagePath = () => nodePath.join(os.tmpdir(), `mulmocast_render_${crypto.randomUUID()}.html`);
+const loadHtmlIntoPage = async (page, html, timeout_ms, forcedFilePath) => {
     const waitUntil = resolveWaitUntil(html);
     const hasFileUrls = /file:\/\//.test(html);
     const hasExternalScripts = /script src=["']https?:\/\//.test(html);
     // puppeteer's setContent does not accept "networkidle0" (no navigation, so network-idle states aren't meaningful in types).
     // Route any HTML that needs network-idle semantics through the page.goto path to preserve the original wait behavior.
     const needsNetworkIdle = waitUntil === "networkidle0";
-    if (hasFileUrls || hasExternalScripts || needsNetworkIdle) {
-        const tmpFile = nodePath.join(os.tmpdir(), `mulmocast_render_${crypto.randomUUID()}.html`);
+    if (forcedFilePath || hasFileUrls || hasExternalScripts || needsNetworkIdle) {
+        const tmpFile = forcedFilePath ?? renderTempPagePath();
         fs.writeFileSync(tmpFile, html);
         try {
             await page.goto(`file://${tmpFile}`, { waitUntil, timeout: timeout_ms });
@@ -109,14 +112,28 @@ const loadHtmlIntoPage = async (page, html, timeout_ms) => {
         await page.setContent(html, { waitUntil, timeout: timeout_ms });
     }
 };
-export const renderHTMLToImage = async (html, outputPath, width, height, isMermaid = false, omitBackground = false) => {
+const RENDER_LOAD_TIMEOUT_MS = 30000;
+const renderLaunchArgs = ({ strictNetwork = false }) => [
+    ...(isCI ? ["--no-sandbox"] : []),
+    "--allow-file-access-from-files",
+    ...(strictNetwork ? strictNetworkLaunchArgs() : []),
+];
+// Strict mode always loads through a file: the guard's WebRTC removal never reaches a setContent document.
+const loadGuardedPage = async (page, html, allowedFileRoots) => {
+    const pagePath = renderTempPagePath();
+    await guardRenderPage(page, [pagePath, ...allowedFileRoots]);
+    await loadHtmlIntoPage(page, withRenderContentSecurityPolicy(html), RENDER_LOAD_TIMEOUT_MS, pagePath);
+};
+const openRenderPage = async (browser, html, { strictNetwork = false, allowedFileRoots = [] }) => {
+    const page = await browser.newPage();
+    await (strictNetwork ? loadGuardedPage(page, html, allowedFileRoots) : loadHtmlIntoPage(page, html, RENDER_LOAD_TIMEOUT_MS));
+    return page;
+};
+export const renderHTMLToImage = async (html, outputPath, width, height, isMermaid = false, omitBackground = false, network = {}) => {
     // Use Puppeteer to render HTML to an image
-    const browser = await puppeteer.launch({
-        args: isCI ? ["--no-sandbox", "--allow-file-access-from-files"] : ["--allow-file-access-from-files"],
-    });
+    const browser = await puppeteer.launch({ args: renderLaunchArgs(network) });
     try {
-        const page = await browser.newPage();
-        await loadHtmlIntoPage(page, html, 30000);
+        const page = await openRenderPage(browser, html, network);
         // Adjust page settings if needed (like width, height, etc.)
         await page.setViewport({ width, height });
         // height:100% ensures background fills viewport; only reset html, let body styles come from custom CSS
@@ -158,14 +175,10 @@ export const renderHTMLToImage = async (html, outputPath, width, height, isMerma
  *
  * The user-defined render() function may be sync or async.
  */
-export const renderHTMLToFrames = async (html, outputDir, width, height, totalFrames, fps) => {
-    const browser = await puppeteer.launch({
-        args: isCI ? ["--no-sandbox", "--allow-file-access-from-files"] : ["--allow-file-access-from-files"],
-    });
+export const renderHTMLToFrames = async (html, outputDir, width, height, totalFrames, fps, network = {}) => {
+    const browser = await puppeteer.launch({ args: renderLaunchArgs(network) });
     try {
-        const page = await browser.newPage();
-        // Wait for Tailwind CSS CDN to load
-        await loadHtmlIntoPage(page, html, 30000);
+        const page = await openRenderPage(browser, html, network);
         await page.setViewport({ width, height });
         await page.addStyleTag({ content: "html{height:100%;margin:0;padding:0;overflow:hidden}" });
         // Scale content to fit viewport (same logic as renderHTMLToImage)
@@ -199,14 +212,11 @@ export const renderHTMLToFrames = async (html, outputDir, width, height, totalFr
  * The animation plays in real-time via requestAnimationFrame, and
  * page.screencast() captures frames directly to an mp4 file.
  */
-export const renderHTMLToVideo = async (html, videoPath, width, height, totalFrames, fps) => {
+export const renderHTMLToVideo = async (html, videoPath, width, height, totalFrames, fps, network = {}) => {
     const duration_ms = (totalFrames / fps) * 1000;
-    const browser = await puppeteer.launch({
-        args: isCI ? ["--no-sandbox", "--allow-file-access-from-files"] : ["--allow-file-access-from-files"],
-    });
+    const browser = await puppeteer.launch({ args: renderLaunchArgs(network) });
     try {
-        const page = await browser.newPage();
-        await loadHtmlIntoPage(page, html, 30000);
+        const page = await openRenderPage(browser, html, network);
         await page.setViewport({ width, height });
         await page.addStyleTag({ content: "html{height:100%;margin:0;padding:0;overflow:hidden}" });
         await scaleContentToFit(page, width, height);
@@ -242,13 +252,10 @@ export const renderHTMLToVideo = async (html, videoPath, width, height, totalFra
  * Loads the animated HTML, calls window.renderFinal() to set all animations
  * to their end state, then takes a screenshot. Used for PDF/thumbnail generation.
  */
-export const renderHTMLToFinalFrame = async (html, outputPath, width, height) => {
-    const browser = await puppeteer.launch({
-        args: isCI ? ["--no-sandbox", "--allow-file-access-from-files"] : ["--allow-file-access-from-files"],
-    });
+export const renderHTMLToFinalFrame = async (html, outputPath, width, height, network = {}) => {
+    const browser = await puppeteer.launch({ args: renderLaunchArgs(network) });
     try {
-        const page = await browser.newPage();
-        await loadHtmlIntoPage(page, html, 30000);
+        const page = await openRenderPage(browser, html, network);
         await page.setViewport({ width, height });
         await page.addStyleTag({ content: "html{height:100%;margin:0;padding:0;overflow:hidden}" });
         await scaleContentToFit(page, width, height);
@@ -266,11 +273,11 @@ export const renderHTMLToFinalFrame = async (html, outputPath, width, height) =>
         await browser.close();
     }
 };
-export const renderMarkdownToImage = async (markdown, style, outputPath, width, height) => {
+export const renderMarkdownToImage = async (markdown, style, outputPath, width, height, network = {}) => {
     const header = `<head><style>${style}</style></head>`;
     const body = await marked(markdown);
     const html = `<html>${header}<body>${body}</body></html>`;
-    await renderHTMLToImage(html, outputPath, width, height);
+    await renderHTMLToImage(html, outputPath, width, height, false, false, network);
 };
 export const interpolate = (template, data) => {
     return template.replace(/\$\{(.*?)\}/g, (_, key) => data[key.trim()] ?? "");

package/lib/utils/image_plugins/chart.js

@@ -3,6 +3,7 @@ import { renderHTMLToImage, interpolate } from "../html_render.js";
 import { parrotingImagePath, generateUniqueId } from "./utils.js";
 import { resolveCombinedStyle } from "./bg_image_util.js";
 import { chartHtml, escapedChartTemplateValues, resolveChartPlugins, stringifyChartData } from "./chart_html.js";
+import { MulmoStudioContextMethods } from "../../methods/mulmo_studio_context.js";
 export const imageType = "chart";
 const processChart = async (params) => {
     const { beat, imagePath, canvasSize } = params;
@@ -19,7 +20,7 @@ const processChart = async (params) => {
         chart_width: chart_width.toString(),
         chart_plugins: resolveChartPlugins(chartType),
     });
-    await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height);
+    await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height, false, false, MulmoStudioContextMethods.getRenderNetworkOptions(params.context));
     return imagePath;
 };
 const dumpHtml = async (params) => {

package/lib/utils/image_plugins/html_tailwind.js

@@ -7,6 +7,7 @@ import { framesToVideo } from "../ffmpeg_utils.js";
 import { parrotingImagePath } from "./utils.js";
 import { swipeElementsToHtml, swipeElementsToScript } from "../swipe_to_html.js";
 import { htmlTailwindMarkup } from "./html_tailwind_markup.js";
+import { MulmoStudioContextMethods } from "../../methods/mulmo_studio_context.js";
 export const imageType = "html_tailwind";
 /**
  * Resolve image:name references to file:// absolute paths using imageRefs.
@@ -178,13 +179,13 @@ const processHtmlTailwindAnimated = async (params) => {
         // imagePath is set to the .mp4 path by imagePluginAgent for animated beats
         const videoPath = imagePath;
         if (animConfig.movie) {
-            await renderHTMLToVideo(htmlData, videoPath, canvasSize.width, canvasSize.height, totalFrames, fps);
+            await renderHTMLToVideo(htmlData, videoPath, canvasSize.width, canvasSize.height, totalFrames, fps, MulmoStudioContextMethods.getRenderNetworkOptions(params.context));
         }
         else {
             const framesDir = videoPath.replace(/\.[^/.]+$/, "_frames");
             fs.mkdirSync(framesDir, { recursive: true });
             try {
-                await renderHTMLToFrames(htmlData, framesDir, canvasSize.width, canvasSize.height, totalFrames, fps);
+                await renderHTMLToFrames(htmlData, framesDir, canvasSize.width, canvasSize.height, totalFrames, fps, MulmoStudioContextMethods.getRenderNetworkOptions(params.context));
                 await framesToVideo(framesDir, videoPath, fps, canvasSize.width, canvasSize.height);
             }
             finally {
@@ -197,7 +198,7 @@ const processHtmlTailwindAnimated = async (params) => {
     // even when exact duration is unknown (e.g., PDF generation without audio).
     const finalFramePath = imagePath.replace(/_animated\.mp4$/, ".png");
     const finalHtml = buildAnimatedHtml(params, FINAL_FRAME_TOTAL, fps);
-    await renderHTMLToFinalFrame(finalHtml, finalFramePath, canvasSize.width, canvasSize.height);
+    await renderHTMLToFinalFrame(finalHtml, finalFramePath, canvasSize.width, canvasSize.height, MulmoStudioContextMethods.getRenderNetworkOptions(params.context));
     // Return video path when video was generated, otherwise return the static PNG path
     return duration !== undefined ? imagePath : finalFramePath;
 };
@@ -216,7 +217,7 @@ const processHtmlTailwindStatic = async (params) => {
     const resolvedAllRefs = resolveMovieRefs(resolvedImageRefs, params.movieRefs ?? {});
     const resolvedImages = resolveRelativeImagePaths(resolvedAllRefs, context.fileDirs.mulmoFileDirPath);
     const htmlData = resolveRelativeModelPathsInScript(resolvedImages, context.fileDirs.mulmoFileDirPath);
-    await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height);
+    await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height, false, false, MulmoStudioContextMethods.getRenderNetworkOptions(params.context));
     return imagePath;
 };
 const processHtmlTailwind = async (params) => {

package/lib/utils/image_plugins/markdown.js

@@ -5,6 +5,7 @@ import { resolveCombinedStyle } from "./bg_image_util.js";
 import { renderMarkdownContent, renderMarkdownLayout, layoutToMarkdown, toMarkdownString } from "./markdown_layout.js";
 import { resolveImageRefs, resolveMovieRefs } from "./html_tailwind.js";
 import { isObject } from "graphai";
+import { MulmoStudioContextMethods } from "../../methods/mulmo_studio_context.js";
 /**
  * This path renders once to a PNG, so a random element id is fine. The browser path needs
  * a stable one and supplies its own — that generator is the only thing the two callers of
@@ -77,7 +78,7 @@ const processMarkdown = async (params) => {
     const { html: rawHtml, hasMermaid } = await generateHtml(params);
     const resolvedImages = resolveImageRefs(rawHtml, params.imageRefs ?? {});
     const html = resolveMovieRefs(resolvedImages, params.movieRefs ?? {});
-    await renderHTMLToImage(html, imagePath, canvasSize.width, canvasSize.height, hasMermaid);
+    await renderHTMLToImage(html, imagePath, canvasSize.width, canvasSize.height, hasMermaid, false, MulmoStudioContextMethods.getRenderNetworkOptions(params.context));
     return imagePath;
 };
 const dumpHtml = async (params) => {

package/lib/utils/image_plugins/mermaid.js

@@ -5,6 +5,7 @@ import { parrotingImagePath, generateUniqueId } from "./utils.js";
 import { escapedMermaidTemplateValues, mermaidHtml } from "./mermaid_html.js";
 import { resolveCombinedStyle } from "./bg_image_util.js";
 import { resolveImageRefs, resolveMovieRefs, resolveRelativeImagePaths } from "./html_tailwind.js";
+import { MulmoStudioContextMethods } from "../../methods/mulmo_studio_context.js";
 export const imageType = "mermaid";
 /** Mermaid markup for this path. The markup itself is shared with the browser path. */
 export const generateMermaidHtml = (code, title) => mermaidHtml(code, generateUniqueId("mermaid"), title);
@@ -23,7 +24,7 @@ const processMermaid = async (params) => {
         const resolvedImageRefs = resolveImageRefs(rawHtml, params.imageRefs ?? {});
         const resolvedAllRefs = resolveMovieRefs(resolvedImageRefs, params.movieRefs ?? {});
         const htmlData = resolveRelativeImagePaths(resolvedAllRefs, context.fileDirs.mulmoFileDirPath);
-        await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height, true);
+        await renderHTMLToImage(htmlData, imagePath, canvasSize.width, canvasSize.height, true, false, MulmoStudioContextMethods.getRenderNetworkOptions(context));
     }
     return imagePath;
 };

package/lib/utils/image_plugins/slide.js

@@ -7,6 +7,7 @@ import { pathToDataUrl } from "../../methods/mulmo_media_source.js";
 import { MulmoMediaSourceMethods } from "../../methods/mulmo_media_source.js";
 import { MulmoPresentationStyleMethods } from "../../methods/mulmo_presentation_style.js";
 import { imageAction, imageFileTarget, unknownMediaType } from "../error_cause.js";
+import { MulmoStudioContextMethods } from "../../methods/mulmo_studio_context.js";
 export const imageType = "slide";
 const slideImageRefError = (refKey) => ({
     type: unknownMediaType,
@@ -167,7 +168,7 @@ const processSlide = async (params) => {
     const reference = beat.image.reference;
     const resolvedBranding = await resolveAndConvertBranding(params);
     const html = generateSlideHTML(theme, slide, reference, resolvedBranding);
-    await renderHTMLToImage(html, imagePath, canvasSize.width, canvasSize.height);
+    await renderHTMLToImage(html, imagePath, canvasSize.width, canvasSize.height, false, false, MulmoStudioContextMethods.getRenderNetworkOptions(params.context));
     return imagePath;
 };
 /**

package/lib/utils/image_plugins/text_slide.js

@@ -2,6 +2,7 @@ import { renderMarkdownToImage } from "../html_render.js";
 import { parrotingImagePath } from "./utils.js";
 import { resolveCombinedStyle } from "./bg_image_util.js";
 import { marked } from "marked";
+import { MulmoStudioContextMethods } from "../../methods/mulmo_studio_context.js";
 export const imageType = "textSlide";
 const processTextSlide = async (params) => {
     const { beat, imagePath, canvasSize } = params;
@@ -17,7 +18,7 @@ const processTextSlide = async (params) => {
         const marginTop = slide.subtitle ? canvasSize.height * 0.4 : canvasSize.height * 0.45;
         return `body {margin-top: ${marginTop}px;}`;
     })();
-    await renderMarkdownToImage(markdown, combinedStyle + topMargin, imagePath, canvasSize.width, canvasSize.height);
+    await renderMarkdownToImage(markdown, combinedStyle + topMargin, imagePath, canvasSize.width, canvasSize.height, MulmoStudioContextMethods.getRenderNetworkOptions(params.context));
     return imagePath;
 };
 const dumpMarkdown = (params) => {

package/lib/utils/image_plugins/vision.js

@@ -1,12 +1,19 @@
 import { parrotingImagePath } from "./utils.js";
 import { htmlPlugin, templateNameTofunctionName } from "mulmocast-vision";
 import { resolve as resolvePath } from "path";
+import { agentGenerationError, imageAction, unsupportedImageTypeTarget } from "../error_cause.js";
 export const imageType = "vision";
 const processVision = async (params) => {
     const { beat, imagePath, context } = params;
     const rootDir = context.fileDirs.nodeModuleRootPath ? resolvePath(context.fileDirs.nodeModuleRootPath, "mulmocast-vision") : undefined;
     if (!beat?.image || beat.image.type !== imageType)
         return;
+    // mulmocast-vision launches its own browser, which the strict network guard cannot reach.
+    if (context.strictNetwork) {
+        throw new Error("vision beats cannot be rendered with --strict-network: mulmocast-vision renders in its own browser, outside the network guard", {
+            cause: agentGenerationError("visionPlugin", imageAction, unsupportedImageTypeTarget),
+        });
+    }
     const handler = new htmlPlugin({ rootDir });
     await handler.callNamedFunction(templateNameTofunctionName(beat.image.style), beat.image.data, {
         functionName: beat.image.style,

package/lib/utils/render_network_guard.d.ts

@@ -0,0 +1,2 @@
+import type { Page } from "puppeteer";
+export declare const guardRenderPage: (page: Page, allowedFileRoots: readonly string[]) => Promise<void>;

package/lib/utils/render_network_guard.js

@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import { GraphAILogger } from "graphai";
+import { WEBRTC_REMOVAL_SCRIPT } from "./remotion/network_policy.js";
+import { POPUP_BLOCK_SCRIPT, isAllowedRenderRequest, realRoot } from "./render_network_policy.js";
+const fileRealPath = (filePath) => {
+    try {
+        return fs.realpathSync.native(filePath);
+    }
+    catch {
+        return undefined;
+    }
+};
+// Must run before the page loads anything. The WebRTC removal only reaches documents created after this call,
+// which is why strict mode always navigates to a file instead of using setContent.
+export const guardRenderPage = async (page, allowedFileRoots) => {
+    const realRoots = allowedFileRoots.map((root) => realRoot(root, fileRealPath));
+    const reported = new Set();
+    await page.setRequestInterception(true);
+    page.on("request", (request) => {
+        if (request.isInterceptResolutionHandled())
+            return;
+        const url = request.url();
+        // The page can close while a request is still pending; that rejection is not a failure of the render.
+        if (isAllowedRenderRequest(url, realRoots, fileRealPath)) {
+            request.continue().catch(() => undefined);
+            return;
+        }
+        if (!reported.has(url)) {
+            reported.add(url);
+            GraphAILogger.info(`strict network: blocked ${url}`);
+        }
+        request.abort("blockedbyclient").catch(() => undefined);
+    });
+    await page.evaluateOnNewDocument(WEBRTC_REMOVAL_SCRIPT);
+    await page.evaluateOnNewDocument(POPUP_BLOCK_SCRIPT);
+};

package/lib/utils/render_network_policy.d.ts

@@ -0,0 +1,15 @@
+export declare const RENDER_CDN_HOSTS: string[];
+export declare const RENDER_JSDELIVR_PATHS: string[];
+export type RenderNetworkOptions = {
+    strictNetwork?: boolean;
+    allowedFileRoots?: readonly string[];
+};
+export declare const STRICT_NETWORK_ENV = "MULMO_STRICT_NETWORK";
+export declare const strictNetworkFromEnv: (env: Record<string, string | undefined>) => boolean;
+export type RealPath = (filePath: string) => string | undefined;
+export declare const isAllowedRenderRequest: (url: string, realRoots?: readonly string[], realPath?: RealPath) => boolean;
+export declare const realRoot: (root: string, realPath: RealPath) => string;
+export declare const strictNetworkLaunchArgs: () => string[];
+export declare const POPUP_BLOCK_SCRIPT = "Object.defineProperty(globalThis, \"open\", { value: () => null, writable: false, configurable: false });";
+export declare const RENDER_CONTENT_SECURITY_POLICY = "connect-src 'self' data: blob:";
+export declare const withRenderContentSecurityPolicy: (html: string) => string;

package/lib/utils/render_network_policy.js

@@ -0,0 +1,85 @@
+import nodePath from "node:path";
+import { fileURLToPath } from "node:url";
+// What an HTML renderer's page may reach in strict network mode: files under the allowed roots, in-memory
+// URLs, and the CDNs our own templates load from. Kept free of I/O so the rules can be tested without a browser.
+export const RENDER_CDN_HOSTS = ["cdn.tailwindcss.com", "cdn.jsdelivr.net", "fonts.googleapis.com", "fonts.gstatic.com"];
+// jsDelivr serves any file of any package and publishes per-version and per-file hit counts, so a page free to
+// choose the path could signal through them; only the exact files our templates load are allowed.
+export const RENDER_JSDELIVR_PATHS = [
+    "/npm/mermaid/dist/mermaid.min.js",
+    "/npm/mermaid@10/dist/mermaid.min.js",
+    "/npm/chart.js",
+    "/npm/chart.js@4",
+    "/npm/chartjs-chart-sankey",
+    "/npm/chartjs-chart-treemap@3",
+];
+const JSDELIVR_HOST = "cdn.jsdelivr.net";
+const IN_MEMORY_SCHEMES = ["data:", "blob:", "about:"];
+export const STRICT_NETWORK_ENV = "MULMO_STRICT_NETWORK";
+export const strictNetworkFromEnv = (env) => ["1", "true"].includes(env[STRICT_NETWORK_ENV] ?? "");
+const parseUrl = (url) => {
+    try {
+        return new URL(url);
+    }
+    catch {
+        return undefined;
+    }
+};
+const filePathOf = (parsed) => {
+    try {
+        return fileURLToPath(parsed);
+    }
+    catch {
+        return undefined;
+    }
+};
+const isWithin = (root, filePath) => {
+    const relative = nodePath.relative(root, filePath);
+    return relative === "" || (!relative.startsWith("..") && !nodePath.isAbsolute(relative));
+};
+// The URL parser has already collapsed dot segments (encoded or not); the roots must already be real paths.
+const isInsideFileRoots = (parsed, realRoots, realPath) => {
+    const filePath = filePathOf(parsed);
+    const realFilePath = filePath === undefined ? undefined : realPath(filePath);
+    return realFilePath !== undefined && realRoots.some((root) => isWithin(root, realFilePath));
+};
+const identityRealPath = (filePath) => nodePath.resolve(filePath);
+const isAllowedCdnUrl = (parsed) => {
+    if (parsed.protocol !== "https:" || parsed.port !== "" || !RENDER_CDN_HOSTS.includes(parsed.hostname))
+        return false;
+    return parsed.hostname !== JSDELIVR_HOST || (parsed.search === "" && RENDER_JSDELIVR_PATHS.includes(parsed.pathname));
+};
+export const isAllowedRenderRequest = (url, realRoots = [], realPath = identityRealPath) => {
+    const parsed = parseUrl(url);
+    if (!parsed)
+        return false;
+    if (IN_MEMORY_SCHEMES.includes(parsed.protocol))
+        return true;
+    if (parsed.protocol === "file:")
+        return isInsideFileRoots(parsed, realRoots, realPath);
+    return isAllowedCdnUrl(parsed);
+};
+// A root that does not exist yet (the temp page before it is written) is its real parent plus its name.
+export const realRoot = (root, realPath) => {
+    const resolved = nodePath.resolve(root);
+    const parent = nodePath.dirname(resolved);
+    return realPath(resolved) ?? nodePath.join(realPath(parent) ?? parent, nodePath.basename(resolved));
+};
+// Popups and preconnect hints open connections outside the page's request interception, so the whole browser
+// talks through a proxy that does not exist, except for the CDNs (loopback included, which Chromium bypasses by default).
+const UNREACHABLE_PROXY = "http://127.0.0.1:1";
+export const strictNetworkLaunchArgs = () => [`--proxy-server=${UNREACHABLE_PROXY}`, `--proxy-bypass-list=${RENDER_CDN_HOSTS.join(";")};<-loopback>`];
+// A popup the page writes into gets no evaluateOnNewDocument script, so it would still have WebRTC.
+export const POPUP_BLOCK_SCRIPT = 'Object.defineProperty(globalThis, "open", { value: () => null, writable: false, configurable: false });';
+// Request interception does not see WebSocket or EventSource connections; this does.
+export const RENDER_CONTENT_SECURITY_POLICY = "connect-src 'self' data: blob:";
+const CSP_META = `<meta http-equiv="Content-Security-Policy" content="${RENDER_CONTENT_SECURITY_POLICY}">`;
+// The meta must come before anything a script could hide in, so it is never placed by searching for <head>
+// (a comment or script text can contain one): right after a leading doctype, else first. Before a doctype it
+// would switch the page to quirks mode; first otherwise, the parser still puts it in the head.
+const LEADING_DOCTYPE = /^(\uFEFF?)(\s*<!doctype[^>]*>)?/i;
+export const withRenderContentSecurityPolicy = (html) => {
+    const [prefix = "", bom = "", doctype] = LEADING_DOCTYPE.exec(html) ?? [];
+    const insertAt = doctype ? prefix.length : bom.length;
+    return [html.slice(0, insertAt), CSP_META, html.slice(insertAt)].join("");
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mulmocast",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "description": "",
   "type": "module",
   "main": "lib/index.node.js",

package/scripts/test/test_genai.json

@@ -55,24 +55,25 @@
       "moviePrompt": "a woman takes a selfie with her phone"
     },
     {
-      "id": "genai_veo3",
-      "text": "movie generated by veo3",
+      "id": "genai_omni",
+      "text": "movie generated by gemini omni",
       "moviePrompt": "a woman is walking through a busy Tokyo street at night, she is wearing dark sunglasses",
       "movieParams": {
-        "model": "veo-3.1-lite-generate-preview"
+        "model": "gemini-omni-1.1-flash"
       }
     },
     {
-      "id": "genai_veo3_1",
-      "text": "movie generated by veo3_1",
+      "id": "genai_omni_long",
+      "text": "a twelve-second movie generated by gemini omni, extended once",
+      "duration": 12,
       "moviePrompt": "a woman is walking through a busy Tokyo street at night, she is wearing dark sunglasses",
       "movieParams": {
-        "model": "veo-3.1-generate-preview"
+        "model": "gemini-omni-1.1-flash"
       }
     },
     {
-      "id": "genai_veo3_image",
-      "text": "movie generated by veo3",
+      "id": "genai_omni_image",
+      "text": "movie generated by gemini omni from a first frame",
       "duration": 5,
       "imagePrompt": "a woman is walking through a busy Tokyo street at night, she is wearing dark sunglasses",
       "imageParams": {
@@ -80,7 +81,7 @@
       },
       "moviePrompt": "a woman is walking through a busy Tokyo street at night, she is wearing dark sunglasses",
       "movieParams": {
-        "model": "veo-3.1-lite-generate-preview"
+        "model": "gemini-omni-1.1-flash"
       }
     }
   ]

package/scripts/test/test_genai_movie.json

@@ -11,7 +11,7 @@
   "lang": "en",
   "movieParams": {
     "provider": "google",
-    "model": "veo-3.1-generate-preview"
+    "model": "gemini-omni-1.1-flash"
   },
   "beats": [
     {

package/scripts/test/test_image_references.json

@@ -15,7 +15,8 @@
   },
   "movieParams": {
     "provider": "google",
-    "model": "veo-3.1-generate-preview"
+    "model": "veo-3.1-generate-001",
+    "vertexai_project": "YOUR_PROJECT_ID"
   },
   "lang": "en",
   "beats": [
@@ -24,7 +25,7 @@
       "text": "veo-3.1 with both ASSET and STYLE reference images",
       "moviePrompt": "the woman runs through narrow alleyways, neon signs blurring in the rain",
       "movieParams": {
-        "model": "veo-3.1-generate-preview",
+        "model": "veo-3.1-generate-001",
         "referenceImages": [
           { "imageName": "character", "referenceType": "ASSET" },
           { "imageName": "black_cat", "referenceType": "ASSET" }

package/scripts/test/test_movie_references.json

@@ -5,7 +5,8 @@
   "canvasSize": { "width": 1280, "height": 720 },
   "movieParams": {
     "provider": "google",
-    "model": "veo-3.1-generate-preview"
+    "model": "veo-3.1-generate-001",
+    "vertexai_project": "YOUR_PROJECT_ID"
   },
   "imageParams": {
     "images": {

package/scripts/test/test_veo31_lite.json

@@ -5,13 +5,13 @@
   "canvasSize": { "width": 1280, "height": 720 },
   "beats": [
     {
-      "id": "google_genai_lite",
-      "text": "Google GenAI veo-3.1-lite-generate-preview text-to-video",
+      "id": "google_genai_omni",
+      "text": "Google GenAI gemini-omni-1.1-flash text-to-video",
       "duration": 4,
       "moviePrompt": "A calm ocean wave rolling onto a sandy beach at golden hour",
       "movieParams": {
         "provider": "google",
-        "model": "veo-3.1-lite-generate-preview"
+        "model": "gemini-omni-1.1-flash"
       }
     },
     {