mulmocast 2.17.0 → 2.19.0

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/jinglescript.d.ts

@@ -0,0 +1,12 @@
+import type { MulmoStudioContext } from "../types/index.js";
+type JingleScore = Record<string, unknown>;
+export declare const getJingleFilePath: (score: JingleScore, context: MulmoStudioContext) => string;
+export declare const getJingleScores: (context: MulmoStudioContext) => {
+    score: Record<string, unknown>;
+    beatIndex: number;
+    effectIndex: number;
+}[];
+export declare const validateJingleScores: (context: MulmoStudioContext) => void;
+export declare const renderJingleScores: (context: MulmoStudioContext) => Promise<void>;
+export declare const writeFileAtomically: (filePath: string, data: Uint8Array) => void;
+export {};

package/lib/utils/jinglescript.js

@@ -0,0 +1,63 @@
+import fs from "fs";
+import path from "path";
+import { GraphAILogger } from "graphai";
+import { checkScore, formatProblem, loadSamples, parseScore, render, toWav } from "jinglescript";
+import { MulmoStudioContextMethods } from "../methods/mulmo_studio_context.js";
+import { hashSHA256, mkdir } from "./file.js";
+import { userAssert } from "./utils.js";
+// The audio mix (addBGMAgent) runs at 44.1 kHz.
+const JINGLE_SAMPLE_RATE = 44100;
+// Per download of a recorded sample (grandpiano: about 1.2 MB per note).
+const SAMPLE_FETCH_TIMEOUT_MS = 60000;
+// Rendered jingles are cached by the hash of their score, so identical scores share one file.
+export const getJingleFilePath = (score, context) => {
+    return path.join(MulmoStudioContextMethods.getAudioDirPath(context), `jingle_${hashSHA256(JSON.stringify(score))}.wav`);
+};
+export const getJingleScores = (context) => {
+    return context.studio.script.beats.flatMap((beat, beatIndex) => (beat.soundEffects ?? []).flatMap((soundEffect, effectIndex) => soundEffect.source.kind === "jinglescript" ? [{ score: soundEffect.source.score, beatIndex, effectIndex }] : []));
+};
+// Checks every JingleScript score in the script; throws listing every problem with its location.
+export const validateJingleScores = (context) => {
+    const problems = getJingleScores(context).flatMap(({ score, beatIndex, effectIndex }) => checkScore(score).errors.map((problem) => `beats[${beatIndex}].soundEffects[${effectIndex}].source.score: ${formatProblem(problem).trim()}`));
+    userAssert(problems.length === 0, `Invalid JingleScript score:\n${problems.join("\n")}`);
+};
+const fetchWithTimeout = (input, init) => fetch(input, { ...init, signal: AbortSignal.timeout(SAMPLE_FETCH_TIMEOUT_MS) });
+// Sampled instruments (grandpiano) play recordings that jinglescript downloads on first use and
+// caches; a score without them loads nothing.
+const loadJingleSamples = async (score, location) => {
+    try {
+        return await loadSamples(score, { fetch: fetchWithTimeout });
+    }
+    catch (error) {
+        throw new Error(`${location}: failed to load JingleScript samples: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+};
+// Renders the JingleScript scores of the script to WAV files (skipping cached ones unless forced).
+export const renderJingleScores = async (context) => {
+    validateJingleScores(context);
+    for (const { score, beatIndex, effectIndex } of getJingleScores(context)) {
+        const filePath = getJingleFilePath(score, context);
+        if (!context.force && fs.existsSync(filePath)) {
+            continue;
+        }
+        const parsed = parseScore(score);
+        const samples = await loadJingleSamples(parsed, `beats[${beatIndex}].soundEffects[${effectIndex}].source.score`);
+        const { audio, sampleRate } = render(parsed, { sampleRate: JINGLE_SAMPLE_RATE, samples });
+        mkdir(path.dirname(filePath));
+        writeFileAtomically(filePath, toWav(audio, sampleRate));
+        GraphAILogger.info(`jinglescript: rendered ${filePath}`);
+    }
+};
+// Writes to a temporary file next to the target, then renames it, so an interrupted write never
+// leaves a partial WAV that a later run would take for a cached one.
+export const writeFileAtomically = (filePath, data) => {
+    const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        fs.writeFileSync(tmpPath, data);
+        fs.renameSync(tmpPath, filePath);
+    }
+    catch (error) {
+        fs.rmSync(tmpPath, { force: true });
+        throw error;
+    }
+};

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.19.0",
   "description": "",
   "type": "module",
   "main": "lib/index.node.js",
@@ -120,6 +120,7 @@
     "clipboardy": "^5.3.2",
     "dotenv": "^17.4.2",
     "graphai": "^2.0.18",
+    "jinglescript": "^0.6.0",
     "js-tiktoken": "^1.0.21",
     "jsdom": "^29.1.1",
     "marked": "^18.1.0",
@@ -149,7 +150,7 @@
     "@types/jsdom": "^28.0.3",
     "@types/node": "^26.6.4",
     "@types/yargs": "^17.0.35",
-    "avatarscript": "^0.3.2",
+    "avatarscript": "^0.4.0",
     "cross-env": "^10.1.0",
     "esbuild": "^0.28.2",
     "eslint": "^10.12.0",
@@ -179,7 +180,7 @@
     "@remotion/shapes": "^4.0.533",
     "@remotion/three": "^4.0.533",
     "@remotion/transitions": "^4.0.533",
-    "avatarscript": "^0.3.2",
+    "avatarscript": "^0.4.0",
     "onnxruntime-node": "^1.30.0",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
@@ -240,6 +241,6 @@
     }
   },
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=22.13.0"
   }
 }

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_jinglescript_sound_effects.json

@@ -0,0 +1,101 @@
+{
+  "$mulmocast": { "version": "1.1" },
+  "lang": "ja",
+  "title": "JingleScript sound effects test",
+  "audioParams": { "bgmVolume": 0.05 },
+  "beats": [
+    {
+      "text": "チク、タク、チク、タク。時計がなりますよ。",
+      "image": { "type": "textSlide", "slide": { "title": "チクタク、チーン" } },
+      "soundEffects": [
+        {
+          "source": {
+            "kind": "jinglescript",
+            "score": {
+              "format": "jinglescript/1",
+              "title": "Clock ticks into a chime",
+              "tempo": 120,
+              "length": { "seconds": 5 },
+              "cues": { "hit": { "seconds": 3 } },
+              "tracks": [
+                {
+                  "instrument": "clock",
+                  "reverb": false,
+                  "gain": -4,
+                  "notes": [{ "at": 0, "variant": ["tick", "tock"], "vel": 0.7, "repeat": { "every": 1, "until": "hit-1" } }]
+                },
+                {
+                  "instrument": "glockenspiel",
+                  "notes": [
+                    { "at": "hit", "pitch": ["C6", "G6"], "vel": 0.8 },
+                    { "at": "hit+1", "pitch": "C7", "vel": 0.4 }
+                  ]
+                }
+              ]
+            }
+          },
+          "volume": 0.7
+        }
+      ]
+    },
+    {
+      "text": "ポン、ポン、ポン！ 星が三つ出てきました。",
+      "image": { "type": "textSlide", "slide": { "title": "ポン、ポン、ポン" } },
+      "soundEffects": [
+        {
+          "source": {
+            "kind": "jinglescript",
+            "score": {
+              "format": "jinglescript/1",
+              "tempo": 120,
+              "length": { "seconds": 2 },
+              "tracks": [
+                {
+                  "instrument": "pop",
+                  "reverb": false,
+                  "notes": [
+                    { "at": 0, "pitch": "E6", "vel": 0.8 },
+                    { "at": 0.5, "pitch": "G6", "vel": 0.8 },
+                    { "at": 1, "pitch": "C7", "vel": 0.9 }
+                  ]
+                }
+              ]
+            }
+          },
+          "startAt": 0.2
+        }
+      ]
+    },
+    {
+      "text": "よくできました！",
+      "image": { "type": "textSlide", "slide": { "title": "よくできました" } },
+      "soundEffects": [
+        {
+          "source": {
+            "kind": "jinglescript",
+            "score": {
+              "format": "jinglescript/1",
+              "title": "Well done",
+              "tempo": 130,
+              "length": { "seconds": 3 },
+              "cues": { "hit": { "seconds": 0.7 } },
+              "tracks": [
+                {
+                  "instrument": "marimba",
+                  "notes": [
+                    { "at": 0, "pitch": "G4", "vel": 0.8 },
+                    { "at": 0.5, "pitch": "C5", "vel": 0.85 },
+                    { "at": "hit", "pitch": ["C5", "E5", "G5", "C6"], "vel": 1.0 }
+                  ]
+                },
+                { "instrument": "marimba", "notes": [{ "at": "hit", "pitch": ["C3", "G3"], "vel": 0.9 }] }
+              ]
+            }
+          },
+          "startAt": 0.8,
+          "volume": 0.8
+        }
+      ]
+    }
+  ]
+}

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_sound_effects.json

@@ -0,0 +1,64 @@
+{
+  "$mulmocast": { "version": "1.1" },
+  "lang": "ja",
+  "title": "Sound effects test",
+  "audioParams": { "bgmVolume": 0.1 },
+  "beats": [
+    {
+      "text": "時計の針が動いています。チク、タク、チク、タク。",
+      "image": { "type": "textSlide", "slide": { "title": "チクタク" } },
+      "soundEffects": [
+        {
+          "source": {
+            "kind": "url",
+            "url": "https://github.com/receptron/mulmocast-media/raw/refs/heads/main/soundeffects/opengameart/bart-ticking-clock/ticking_clock.wav"
+          },
+          "startAt": 0,
+          "volume": 0.6,
+          "loop": true
+        }
+      ]
+    },
+    {
+      "text": "ボールがはねました。そして、コインをゲット！",
+      "image": { "type": "textSlide", "slide": { "title": "ビヨーン、チャリン" } },
+      "soundEffects": [
+        {
+          "source": {
+            "kind": "url",
+            "url": "https://github.com/receptron/mulmocast-media/raw/refs/heads/main/soundeffects/opengameart/ezduzziteh-boings/bing_01.mp3"
+          },
+          "startAt": 0.8
+        },
+        {
+          "source": {
+            "kind": "url",
+            "url": "https://github.com/receptron/mulmocast-media/raw/refs/heads/main/soundeffects/opengameart/junkala-512-retro-sfx/general-sounds/coins/sfx_coin_single1.wav"
+          },
+          "startAt": 2.2,
+          "volume": 0.7
+        }
+      ]
+    },
+    {
+      "text": "パチーン！ 大正解です。",
+      "image": { "type": "textSlide", "slide": { "title": "大正解" } },
+      "soundEffects": [
+        {
+          "source": {
+            "kind": "url",
+            "url": "https://github.com/receptron/mulmocast-media/raw/refs/heads/main/soundeffects/kenney/impact-sounds/impactPunch_medium_000.ogg"
+          }
+        },
+        {
+          "source": {
+            "kind": "url",
+            "url": "https://github.com/receptron/mulmocast-media/raw/refs/heads/main/soundeffects/opengameart/junkala-512-retro-sfx/general-sounds/fanfares/sfx_sounds_fanfare1.wav"
+          },
+          "startAt": 0.6,
+          "volume": 0.8
+        }
+      ]
+    }
+  ]
+}