@lalalic/markcut 1.2.0 → 2.1.0

package/src/descriptive/compiler.ts

@@ -18,6 +18,8 @@ import { uid, walkDown } from "../utils/index";
 
 export interface CompileOptions {
   defaults?: Partial<Record<"image" | "video" | "audio" | "component" | "rhythm" | "include" | "map", number>>;
+  /** Google Maps API key, injected onto map nodes during compilation. */
+  googleMapsApiKey?: string;
 }
 
 /** A single effect spec — either a bare animation name or an object with options. */
@@ -65,6 +67,10 @@ export interface DescriptiveAudio extends DescriptiveBaseNode {
   src?: string;
   /** Narration text for TTS generation. When set without src, triggers TTS pipeline. */
   script?: string;
+  /** Speaker name for multi-turn dialogue. Set by resolveDialogue when expanding
+   *  `SpeakerName: text` format scripts. Used for per-speaker voice selection and
+   *  subtitle prefix. */
+  speaker?: string;
   volume?: number;
   foreground?: boolean;
   startFrom?: number;
@@ -183,6 +189,12 @@ export interface DescriptiveRoot {
   imports?: never;
   /** Raw imports block source (from \`\`\`imports code fence). Parsed by parseImportsBlock. */
   importsBlock?: string;
+  /** Per-speaker voice mapping for multi-turn dialogue.
+   *  Keys are speaker names (e.g. "Ray", "Alice"), values are TTS voice names
+   *  (e.g. "en-US-GuyNeural", "en-US-JennyNeural").
+   *  When a dialogue node has a matching `speaker` field, its TTS voice is
+   *  substituted from this map. */
+  voices?: Record<string, string>;
   children: DescriptiveNode[];
 }
 
@@ -250,6 +262,7 @@ export function resolveAllTemplateVars(
 
 interface CompileContext {
   defaults: Record<"image" | "video" | "audio" | "component" | "rhythm" | "include" | "map" | "effect", number>;
+  googleMapsApiKey: string;
 }
 
 interface CompileResult {
@@ -422,24 +435,18 @@ function wrapWithEffects(
   if (!rawEffects || rawEffects.length === 0) return result;
 
   const effects = rawEffects.map(normalizeEffectSpec);
-  const innerStream = result.stream;
-  const innerActions = (innerStream as any).actions ?? [];
-  const firstAction = innerActions[0] ?? {};
-  const absStart = firstAction.start ?? 0;
-  const absEnd = firstAction.end ?? result.duration;
+  const innerStream = result.stream as any;
+  const absStart = innerStream.start ?? 0;
+  const absEnd = innerStream.end ?? result.duration;
   const duration = absEnd - absStart;
 
-  // Reset inner stream's actions to be relative (start=0) so the effect
+  // Reset inner stream's timing to be relative (start=0) so the effect
   // wrapper owns the absolute timing. The EffectWrapper renders children
-  // with their relative actions inside its own Sequence.
+  // with their relative timing inside its own Sequence.
   const resetStream = {
     ...innerStream,
-    actions: [{
-      ...firstAction,
-      id: uid(),
-      start: 0,
-      end: duration,
-    }],
+    start: 0,
+    end: duration,
     durationInSeconds: duration,
   } as any;
 
@@ -466,11 +473,8 @@ function wrapWithEffects(
       animationIterationCount: spec.animationIterationCount ?? 1,
       customKeyframes: spec.customKeyframes,
       children: [currentStream],
-      actions: [{
-        id: uid(),
-        start: effStart,
-        end: effEnd,
-      }],
+      start: effStart,
+      end: effEnd,
       visible: true,
       ...pickOn(node),
     } as Effect;
@@ -490,21 +494,12 @@ function compileLeaf(node: Exclude<DescriptiveNode, DescriptiveContainer | Descr
     style: node.style,
     visible: node.visible ?? true,
     isBackground: node.isBackground,
-    durationInSeconds: end,
-    ...pickOn(node),
-  };
-
-  const action = {
-    id: uid(),
     start,
     end,
     startFrom: node.type === "video" || node.type === "audio" ? node.startFrom : undefined,
     endAt: node.type === "video" || node.type === "audio" ? node.endAt : undefined,
-    loop: node.type === "audio" ? node.loop : undefined,
-    volume:
-      node.type === "video" || node.type === "audio" || node.type === "rhythm"
-        ? node.volume
-        : undefined,
+    durationInSeconds: end,
+    ...pickOn(node),
   };
 
   switch (node.type) {
@@ -517,7 +512,6 @@ function compileLeaf(node: Exclude<DescriptiveNode, DescriptiveContainer | Descr
         playbackRate: node.playbackRate,
         width: node.width ?? 1080,
         height: node.height ?? 1920,
-        actions: [action],
       };
       return { stream, duration: end };
     }
@@ -528,7 +522,8 @@ function compileLeaf(node: Exclude<DescriptiveNode, DescriptiveContainer | Descr
         src: node.src,
         volume: node.volume ?? 1,
         foreground: node.foreground,
-        actions: [action],
+        loop: node.loop,
+        speaker: node.speaker,
       };
       return { stream, duration: end };
     }
@@ -538,7 +533,6 @@ function compileLeaf(node: Exclude<DescriptiveNode, DescriptiveContainer | Descr
         type: "image",
         src: node.src,
         fit: node.fit ?? "contain",
-        actions: [action],
       };
       return { stream, duration: end };
     }
@@ -561,7 +555,6 @@ function compileLeaf(node: Exclude<DescriptiveNode, DescriptiveContainer | Descr
         type: "component",
         jsx: node.jsx,
         data: Object.keys(bindings).length ? bindings : undefined,
-        actions: [action],
       };
       return { stream, duration: end };
     }
@@ -574,7 +567,6 @@ function compileLeaf(node: Exclude<DescriptiveNode, DescriptiveContainer | Descr
         volume: node.volume ?? 1,
         spots: node.spots,
         children: [],
-        actions: [action],
       };
       return { stream, duration: end };
     }
@@ -590,7 +582,7 @@ function compileLeaf(node: Exclude<DescriptiveNode, DescriptiveContainer | Descr
         mapType: node.mapType ?? "roadmap",
         travelMode: node.travelMode ?? "DRIVING",
         routeMarker: node.routeMarker ?? "🚗",
-        actions: [action],
+        googleMapsApiKey: ctx.googleMapsApiKey,
       };
       return { stream, duration: end };
     }
@@ -668,6 +660,7 @@ function compileScene(
         type: "folder",
         visible: true,
         isSeries: true,
+        start: 0,
         transition: sceneKind === "transitionSeries" ? resolved.name : undefined,
         transitionTime: sceneKind === "transitionSeries" ? resolved.time : 0.5,
         children: compiledChildren.map((c) => c.stream),
@@ -691,6 +684,7 @@ function compileScene(
     style: node.style,
     visible: node.visible ?? true,
     isBackground: node.isBackground,
+    start,
     children: sceneChildren,
     durationInSeconds: end,
     ...pickOn(node),
@@ -732,13 +726,8 @@ function compileInclude(
     src: node.src,
     volume: node.volume ?? 1,
     children: compiledChildren.map((c) => c.stream),
-    actions: [
-      {
-        id: uid(),
-        start,
-        end,
-      },
-    ],
+    start,
+    end,
     durationInSeconds: end,
     ...pickOn(node),
   };
@@ -802,14 +791,8 @@ function compileRhythm(
     volume: node.volume ?? 1,
     spots: node.spots,
     children: compiledChildren,
-    actions: [
-      {
-        id: uid(),
-        start,
-        end,
-        volume: node.volume,
-      },
-    ],
+    start,
+    end,
     durationInSeconds: end,
     ...pickOn(node),
   };
@@ -833,6 +816,7 @@ function compileContainer(node: DescriptiveContainer, ctx: CompileContext, paren
     style: node.style,
     visible: node.visible ?? true,
     isBackground: node.isBackground,
+    start: 0,
     isSeries: node.type !== "parallel",
     transition: node.type === "transitionSeries" ? resolved.name : undefined,
     transitionTime: node.type === "transitionSeries" ? resolved.time : 0.5,
@@ -1191,11 +1175,18 @@ export function resolveVariantOverrides(
 }
 
 export function compileDescriptiveRoot(input: DescriptiveRoot, options: CompileOptions = {}): Root {
+  const root: DescriptiveRoot = typeof input === "string" ? JSON.parse(input) : input;
+
+  const resolved = resolveTransition(root.layout ? root.transition ?? root.layout : root.transition, root.transitionTime);
+  const rootKind: "series" | "parallel" | "transitionSeries" = root.layout === "parallel" ? "parallel" : "series";
+
+  const googleMapsApiKey = options.googleMapsApiKey ?? "";
   const ctx: CompileContext = {
     defaults: {
       ...DEFAULTS,
       ...(options.defaults ?? {}),
     },
+    googleMapsApiKey,
   };
 
   // Resolve frontmatter imports / inline component defs onto each component node.
@@ -1204,8 +1195,6 @@ export function compileDescriptiveRoot(input: DescriptiveRoot, options: CompileO
 
   ensureUniqueIds(input.children, "root");
 
-  const rootKind = input.layout ?? "series";
-  const resolved = resolveTransition(input.transition, input.transitionTime);
   const children = compileChildren(input.children, ctx, rootKind);
   const duration = aggregateDuration(children, rootKind, resolved.time);
 

package/src/descriptive/markdown.ts

@@ -101,7 +101,7 @@ function preserveVariantAttrs(node: Record<string, unknown>, attrs: Record<strin
     "spots", "waypoints", "routeColor", "routeWeight", "routeMarker",
     "travelMode", "zoom", "center", "mapType", "data", "prompt",
     "name", "title", "transition", "transitionTime", "layout",
-    "componentName", "props",
+    "componentName", "props", "speaker",
   ]);
   for (const [k, v] of Object.entries(attrs)) {
     if (!STANDARD.has(k)) {
@@ -214,6 +214,7 @@ function parseNodeLine(content: string, lineNum?: number): DescriptiveNode {
         type: "audio",
         id: attrs.id as any,
         src,
+        speaker: attrs.speaker as string | undefined,
         duration: attrs.duration as any,
         start: attrs.start as any,
         startFrom: attrs.startFrom as any,
@@ -292,14 +293,14 @@ function parseNodeLine(content: string, lineNum?: number): DescriptiveNode {
     }
     case "script": {
       const raw = firstPositional ?? (attrs.script ? String(attrs.script) : undefined);
-      if (!raw) throw new DslError("script requires text content", ctx);
-      // Unquote if needed (standalone `- script "..."` preserves quotes in the token)
-      const text = isQuoted(raw) ? unquote(raw) : raw;
+      // Text may be empty — ~~~script code fence will provide it later
+      const text = raw ? (isQuoted(raw) ? unquote(raw) : raw) : undefined;
       // Script is an alias for audio — creates an audio node with TTS-needed marker.
       const scriptNode: any = {
         type: "audio",
         id: attrs.id as any,
         script: text,
+        speaker: attrs.speaker as string | undefined,
         volume: (attrs.volume as number | undefined) ?? 1,
         start: attrs.start as any,
         duration: attrs.duration as any,
@@ -667,6 +668,9 @@ function applyRootAttrs(root: DescriptiveRoot, attrs: Record<string, unknown>):
         }
         break;
       }
+      case "voices":
+        root.voices = v as Record<string, string>;
+        break;
       default:
         throw new Error(`unknown root key: ${k}`);
     }

package/src/descriptive/resolve.test.ts

@@ -119,7 +119,8 @@ describe("resolveSubtitles", () => {
         type: "scene", name: "S", layout: "parallel",
         children: [{
           id: "a1", type: "audio", src: audioPath,
-          actions: [{ id: "act1", start: 5, end: 8 }],
+          start: 5,
+          end: 8,
         } as any],
         durationInSeconds: 8,
       } as any],
@@ -490,7 +491,8 @@ describe("resolveSubtitles — additional", () => {
       stt: "custom-stt {input} --out {output}",
       children: [{
         type: "scene", name: "S", layout: "parallel",
-        children: [{ id: "a1", type: "audio", src: audioPath, actions: [{ id: "act1", start: 0, end: 2 }] } as any],
+        children: [{ id: "a1", type: "audio", src: audioPath, start: 0,
+        end: 2 } as any],
         durationInSeconds: 2,
       } as any],
     };
@@ -511,7 +513,8 @@ describe("resolveSubtitles — additional", () => {
     const root: DescriptiveRoot = {
       children: [{
         type: "scene", name: "S", layout: "parallel",
-        children: [{ id: "a1", type: "audio", src: audioPath, actions: [{ id: "act1", start: 0, end: 2 }] } as any],
+        children: [{ id: "a1", type: "audio", src: audioPath, start: 0,
+        end: 2 } as any],
         durationInSeconds: 2,
       } as any],
     };
@@ -531,7 +534,8 @@ describe("resolveSubtitles — additional", () => {
     const root: DescriptiveRoot = {
       children: [{
         type: "scene", name: "S", layout: "parallel",
-        children: [{ id: "a1", type: "audio", src: audioPath, actions: [{ id: "act1", start: 0, end: 2 }] } as any],
+        children: [{ id: "a1", type: "audio", src: audioPath, start: 0,
+        end: 2 } as any],
         durationInSeconds: 2,
       } as any],
     };
@@ -558,8 +562,10 @@ describe("resolveSubtitles — additional", () => {
       children: [{
         type: "scene", name: "S", layout: "parallel",
         children: [
-          { id: "a1", type: "audio", src: a1, actions: [{ id: "act1", start: 0, end: 2 }] },
-          { id: "a2", type: "audio", src: a2, actions: [{ id: "act2", start: 3, end: 5 }] },
+          { id: "a1", type: "audio", src: a1, start: 0,
+        end: 2 },
+          { id: "a2", type: "audio", src: a2, start: 3,
+        end: 5 },
         ],
         durationInSeconds: 5,
       }],
@@ -586,7 +592,8 @@ describe("resolveSubtitles — additional", () => {
     const root: any = {
       children: [{
         type: "scene", name: "S", layout: "parallel",
-        children: [{ id: "a1", type: "audio", src: audioPath, actions: [{ id: "act1", start: 0, end: 2 }] }],
+        children: [{ id: "a1", type: "audio", src: audioPath, start: 0,
+        end: 2 }],
         durationInSeconds: 2,
       }],
     };

package/src/descriptive/resolve.ts

@@ -261,6 +261,117 @@ export async function resolveMediaDurations(
   return clone;
 }
 
+// ── Dialogue expansion ──────────────────────────────────────────────────────
+
+/**
+ * Detect if a script contains multi-turn dialogue in `SpeakerName: text` format.
+ *
+ * A script is a "dialogue" if at least 2 lines match the pattern `Name: text`.
+ * Single-line `SpeakerName: text` is NOT treated as dialogue — it's just a
+ * regular script with a speaker annotation.
+ *
+ * Example dialogue:
+ * ```
+ * Ray: Hello everyone and welcome
+ * Alice: Good day to you all
+ * Ray: Let's get started
+ * ```
+ *
+ * Each line becomes a separate audio node with:
+ * - `script`: just the text (without the "SpeakerName: " prefix)
+ * - `speaker`: the speaker name
+ *
+ * The dialogue lines are wrapped in a series container so they play sequentially
+ * regardless of the parent scene's layout.
+ */
+export function parseDialogueLines(script: string): Array<{ speaker: string; text: string }> {
+  const lines = script.split("\n").map(l => l.trim()).filter(Boolean);
+  const dialoguePattern = /^([\w\u4e00-\u9fff][\w\s\u4e00-\u9fff]*?):\s*(.+)$/;
+
+  const result: Array<{ speaker: string; text: string }> = [];
+  for (const line of lines) {
+    const match = line.match(dialoguePattern);
+    if (!match) return []; // Any non-matching line invalidates the dialogue format
+    result.push({ speaker: match[1]!.trim(), text: match[2]!.trim() });
+  }
+
+  // Require at least 2 lines to be considered a dialogue
+  return result.length >= 2 ? result : [];
+}
+
+/**
+ * Walk the descriptive tree and expand multi-turn dialogue-formatted scripts
+ * into sequential per-line audio nodes.
+ *
+ * This runs BEFORE resolveScripts so each dialogue line gets its own TTS
+ * generation with the correct per-speaker voice.
+ */
+export function resolveDialogue(root: DescriptiveRoot): DescriptiveRoot {
+  const clone: DescriptiveRoot = JSON.parse(JSON.stringify(root));
+
+  // Collect dialogue nodes for expansion (walking and modifying simultaneously is tricky)
+  const expansions: Array<{
+    parent: any;
+    index: number;
+    originalNode: any;
+    lines: Array<{ speaker: string; text: string }>;
+  }> = [];
+
+  walkDown(clone as any, (node, parent) => {
+    if (node.type !== "audio") return;
+    if (!node.script || typeof node.script !== "string") return;
+    if (node.src) return; // Already has a real source
+
+    const lines = parseDialogueLines(node.script);
+    if (lines.length < 2) return; // Not a dialogue
+
+    if (!parent || !Array.isArray(parent.children)) return;
+    const idx = parent.children.indexOf(node);
+    if (idx === -1) return;
+
+    expansions.push({ parent, index: idx, originalNode: node, lines });
+  });
+
+  if (expansions.length === 0) return root;
+
+  // Apply expansions in reverse index order so splice indices stay valid
+  expansions.sort((a, b) => b.index - a.index);
+
+  for (const { parent, index, originalNode, lines } of expansions) {
+    const dialogueNodes: any[] = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i]!;
+      const { speaker, text } = line;
+      const lineNode: any = {
+        ...originalNode,
+        id: originalNode.id ? `${originalNode.id}-line-${i}` : undefined,
+        script: text,
+        speaker,
+        start: 0,
+        duration: undefined, // Will be set by TTS duration probing
+      };
+      delete lineNode.src;
+      dialogueNodes.push(lineNode);
+    }
+
+    // Wrap dialogue lines in a series container for sequential playback
+    const seriesContainer: any = {
+      type: "series",
+      id: `${originalNode.id ?? "dialogue"}-series`,
+      children: dialogueNodes,
+    };
+
+    // Replace the original node with the series container
+    parent.children.splice(index, 1, seriesContainer);
+  }
+
+  const expanded = expansions.length > 0 ? clone : root;
+  const count = expansions.reduce((sum, e) => sum + e.lines.length, 0);
+  console.log(`  💬 dialogue: expanded ${expansions.length} script${expansions.length > 1 ? "s" : ""} into ${count} lines`);
+  return expanded;
+}
+
 // ── Script → TTS → STT ─────────────────────────────────────────────────────
 
 export interface ResolveScriptOptions {
@@ -292,23 +403,30 @@ export async function resolveScripts(
   let cacheDirty = false;
 
   // Collect all audio nodes that have script text but no src yet
-  // Also store their parent scene for per-scene tts resolution
-  const allScriptNodes: Array<{ node: any; id: string; parent: any }> = [];
-  walkDown(clone as any, (node, parent) => {
+  const allScriptNodes: Array<{ node: any; id: string }> = [];
+  walkDown(clone as any, (node) => {
     if (node.type !== "audio") return;
     if (!node.script || typeof node.script !== "string") return;
     if (node.src) return; // already has real source
     const id = node.id ?? `audio-${allScriptNodes.length}`;
-    allScriptNodes.push({ node, id, parent });
+    allScriptNodes.push({ node, id });
   });
 
   if (allScriptNodes.length > 0) {
     console.log(`  🔊 TTS: generating ${allScriptNodes.length} script${allScriptNodes.length > 1 ? "s" : ""}...`);
   }
 
-  for (const { node, id, parent } of allScriptNodes) {
-    // Resolve TTS config: parent scene tts > root tts > options ttsCli > default
-    const ttsCli = parent?.tts ?? clone.tts ?? options.ttsCli ?? DEFAULT_TTS_CLI;
+  for (const { node, id } of allScriptNodes) {
+    // TTS CLI from root config only
+    let ttsCli = clone.tts ?? options.ttsCli ?? DEFAULT_TTS_CLI;
+
+    // Per-speaker voice appends extra CLI flags from root voices config
+    if (node.speaker && clone.voices) {
+      const speakerVoice = clone.voices[node.speaker];
+      if (speakerVoice) {
+        ttsCli = `${ttsCli} ${speakerVoice}`;
+      }
+    }
 
     // Content-addressed filename: hash of script + CLI, so identical scripts
     // across different source files share the same audio file.
@@ -318,7 +436,8 @@ export async function resolveScripts(
     // Check cache — skip TTS if script + config unchanged AND audio file exists
     const cached = checkCache(cache, `tts:${cacheKey}`, cacheKey);
     let generated: string;
-    const label = firstWords(node.script, 8);
+    const speakerLabel = node.speaker ? `${node.speaker}: ` : "";
+    const label = `${speakerLabel}${firstWords(node.script, 8)}`;
     if (cached) {
       generated = cached;
       console.log(`  ✓ TTS: ${label} (cached)`);
@@ -378,15 +497,16 @@ export async function resolveSubtitles(
   let cacheDirty = false;
 
   // Collect { audioSrc, absoluteOffset } from the compiled tree
-  const clips: Array<{ audioSrc: string; offset: number }> = [];
+  const clips: Array<{ audioSrc: string; offset: number; speaker?: string }> = [];
 
   /**
    * Walk an array of sibling nodes, tracking cumulative offset for series layouts.
    *
-   * In the compiled stream tree, container nodes (Folder/Scene) don't carry `actions`
-   * — their position on the timeline is implicit in the `<Series>`/`<TransitionSeries>`
-   * renderer which plays each child sequentially based on `durationInSeconds`.
-   * This function replicates that logic to compute absolute audio offsets.
+   * In the compiled stream tree, container nodes (Folder/Scene) don't carry leaf
+   * timing (start/end) — their position on the timeline is implicit in the
+   * `<Series>`/`<TransitionSeries>` renderer which plays each child sequentially
+   * based on `durationInSeconds`. This function replicates that logic to compute
+   * absolute audio offsets.
    */
   function walkSiblings(
     nodes: any[],
@@ -404,13 +524,13 @@ export async function resolveSubtitles(
       // In a series, each child starts after all previous siblings' durations.
       // In parallel, all children share the parent offset.
       const nodeStart = parentIsSeries ? seriesOffset : parentOffset;
-      // Leaf nodes (video/audio/image/component) carry an action start offset
-      // relative to the container start (e.g., parallel layout with staggered start).
-      const actionStart = node.actions?.[0]?.start ?? 0;
+      // Leaf nodes carry a start offset relative to the container start
+      // (e.g., parallel layout with staggered start) directly on the base field.
+      const actionStart = node.start ?? 0;
       const effectiveOffset = nodeStart + actionStart;
 
       if (node.type === "audio" && node.src) {
-        clips.push({ audioSrc: node.src, offset: effectiveOffset });
+        clips.push({ audioSrc: node.src, offset: effectiveOffset, speaker: node.speaker });
       }
 
       // Recurse into children — determine their layout from the node type
@@ -449,7 +569,7 @@ export async function resolveSubtitles(
     }
   }
 
-  // Walk the compiled tree (with actions) for correct absolute offsets;
+  // Walk the compiled tree (with base timing) for correct absolute offsets;
   // fall back to the descriptive tree if no compiled tree provided.
   const treeToWalk = options.compiled ?? (clone as any);
   walkSiblings(
@@ -466,7 +586,7 @@ export async function resolveSubtitles(
 
   let sttFailedCount = 0;
 
-  for (const { audioSrc, offset } of clips) {
+  for (const { audioSrc, offset, speaker } of clips) {
     // Cache key: audio hash + STT CLI string
     const audioHash = existsSync(audioSrc)
       ? createHash("sha1").update(readFileSync(audioSrc)).digest("hex").slice(0, 12)
@@ -518,7 +638,11 @@ export async function resolveSubtitles(
         const sec = (s % 60).toFixed(3).padStart(6, "0");
         return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${sec}`;
       };
-      const text = lines.slice(lines.indexOf(tline) + 1).join("\n").trim();
+      let text = lines.slice(lines.indexOf(tline) + 1).join("\n").trim();
+      // Prepend speaker prefix for dialogue cues
+      if (speaker) {
+        text = `${speaker}: ${text}`;
+      }
       mergedLines.push(String(cueIndex++));
       mergedLines.push(`${formatSec(toSec(a) + offset)} --> ${formatSec(toSec(z) + offset)}`);
       mergedLines.push(text, "");
@@ -864,6 +988,10 @@ export async function resolveAll(
     skip: options.skip,
   });
 
+  // Step 4.5: Expand multi-turn dialogue (SpeakerName: text format)
+  // Must run before TTS so each dialogue line gets its own audio node
+  result = resolveDialogue(result);
+
   // Step 5: Script → TTS
   if (options.scriptOutputDir) {
     result = await resolveScripts(result, {