@lalalic/markcut 3.0.0 → 3.1.1

package/src/player/pipeline.mjs

@@ -243,6 +243,7 @@ function wrapWithEffects(node2, result, parentKind) {
       start: isOutermost && isBgNoEnd ? innerStream.start : effStart,
       end: isOutermost && isBgNoEnd ? void 0 : effEnd,
       visible: innerStream.visible ?? true,
+      at: node2.at,
       ...pickOn(node2)
     };
   }
@@ -261,6 +262,7 @@ function compileLeaf(node2, ctx, parentKind) {
     style: node2.style,
     visible: node2.visible ?? true,
     isBackground: node2.isBackground,
+    at: node2.at,
     start: isBgNoOwnTiming ? typeof node2.start === "number" ? node2.start : void 0 : start,
     end,
     startFrom: isBgNoOwnTiming ? void 0 : node2.type === "video" || node2.type === "audio" ? node2.startFrom : void 0,
@@ -343,6 +345,7 @@ function compileLeaf(node2, ctx, parentKind) {
       const stream = {
         ...base,
         type: "map",
+        view: node2.view ?? "route",
         waypoints: node2.waypoints,
         routeColor: node2.routeColor ?? "#4285F4",
         routeWeight: node2.routeWeight ?? 4,
@@ -353,6 +356,9 @@ function compileLeaf(node2, ctx, parentKind) {
         region: node2.region,
         travelMode: node2.travelMode ?? "DRIVING",
         routeMarker: node2.routeMarker ?? "\u{1F697}",
+        camera: node2.camera,
+        cinematic: node2.cinematic,
+        streetView: node2.streetView,
         googleMapsApiKey: ctx.googleMapsApiKey
       };
       return { stream, duration: end ?? 0 };
@@ -371,7 +377,7 @@ function compileChildren(children, ctx, parentKind) {
     } else if (isRhythm(child)) {
       result = compileRhythm(child, ctx, parentKind);
     } else if (isMap(child)) {
-      result = compileLeaf(child, ctx, parentKind);
+      result = compileMap(child, ctx, parentKind);
     } else {
       result = compileLeaf(child, ctx, parentKind);
     }
@@ -522,6 +528,44 @@ function compileRhythm(node2, ctx, parentKind) {
   };
   return { stream, duration: end };
 }
+function compileMap(node2, ctx, parentKind) {
+  const id = node2.id ?? uid();
+  const start = parentKind === "parallel" ? Math.max(0, node2.start ?? 0) : 0;
+  const ownDuration = deriveLeafDuration(node2, ctx);
+  const end = ownDuration != null ? start + ownDuration : void 0;
+  const children = node2.children ?? [];
+  const compiledChildren = children.length ? compileChildren(children, ctx, "parallel") : [];
+  const maxChildEnd = compiledChildren.reduce((max, c) => Math.max(max, c.duration), 0);
+  const mapDuration = Math.max(end ?? 0, maxChildEnd, ownDuration ?? 0);
+  const stream = {
+    id,
+    type: "map",
+    style: node2.style,
+    visible: node2.visible ?? true,
+    isBackground: node2.isBackground,
+    start,
+    end: mapDuration,
+    durationInSeconds: mapDuration,
+    view: node2.view ?? "route",
+    waypoints: node2.waypoints,
+    routeColor: node2.routeColor ?? "#4285F4",
+    routeWeight: node2.routeWeight ?? 4,
+    zoom: node2.zoom ?? 10,
+    center: node2.center,
+    mapType: node2.mapType ?? "roadmap",
+    language: node2.language,
+    region: node2.region,
+    travelMode: node2.travelMode ?? "DRIVING",
+    routeMarker: node2.routeMarker ?? "\u{1F697}",
+    camera: node2.camera,
+    cinematic: node2.cinematic,
+    streetView: node2.streetView,
+    googleMapsApiKey: ctx.googleMapsApiKey,
+    children: compiledChildren.map((c) => c.stream),
+    ...pickOn(node2)
+  };
+  return { stream, duration: mapDuration };
+}
 function compileContainer(node2, ctx, parentKind) {
   const id = node2.id ?? uid();
   ensureUniqueIds(node2.children, id);
@@ -1034,6 +1078,114 @@ var require_format = __commonJS({
   }
 });
 
+// src/utils/route-legs.ts
+function haversineKm(a, b) {
+  const dLat = toRad(b.lat - a.lat);
+  const dLng = toRad(b.lng - a.lng);
+  const h = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(a.lat)) * Math.cos(toRad(b.lat)) * Math.sin(dLng / 2) ** 2;
+  return 2 * EARTH_RADIUS_KM * Math.asin(Math.sqrt(h));
+}
+function greatCirclePath(a, b, points = 64) {
+  const \u03C61 = toRad(a.lat);
+  const \u03BB1 = toRad(a.lng);
+  const \u03C62 = toRad(b.lat);
+  const \u03BB2 = toRad(b.lng);
+  const d = haversineKm(a, b) / EARTH_RADIUS_KM;
+  const out = [];
+  for (let i = 0; i <= points; i++) {
+    if (d === 0) {
+      out.push({ lat: a.lat, lng: a.lng });
+      continue;
+    }
+    const f = i / points;
+    const A = Math.sin((1 - f) * d) / Math.sin(d);
+    const B = Math.sin(f * d) / Math.sin(d);
+    const x = A * Math.cos(\u03C61) * Math.cos(\u03BB1) + B * Math.cos(\u03C62) * Math.cos(\u03BB2);
+    const y = A * Math.cos(\u03C61) * Math.sin(\u03BB1) + B * Math.cos(\u03C62) * Math.sin(\u03BB2);
+    const z = A * Math.sin(\u03C61) + B * Math.sin(\u03C62);
+    out.push({ lat: toDeg(Math.atan2(z, Math.sqrt(x * x + y * y))), lng: toDeg(Math.atan2(y, x)) });
+  }
+  return out;
+}
+function makeSyntheticLeg(from, to, mode) {
+  const speedKmh = (mode || "").toUpperCase() === "BOAT" ? BOAT_SPEED_KMH : FLIGHT_SPEED_KMH;
+  const durationSec = haversineKm(from, to) / speedKmh * 3600;
+  return {
+    mode: mode.toUpperCase(),
+    from,
+    to,
+    durationSec,
+    steps: [{ path: greatCirclePath(from, to), durationSec }]
+  };
+}
+var FLIGHT_SPEED_KMH, BOAT_SPEED_KMH, EARTH_RADIUS_KM, toRad, toDeg;
+var init_route_legs = __esm({
+  "src/utils/route-legs.ts"() {
+    "use strict";
+    FLIGHT_SPEED_KMH = 850;
+    BOAT_SPEED_KMH = 40;
+    EARTH_RADIUS_KM = 6371;
+    toRad = (d) => d * Math.PI / 180;
+    toDeg = (d) => d * 180 / Math.PI;
+  }
+});
+
+// src/utils/directions.ts
+var directions_exports = {};
+__export(directions_exports, {
+  legDurationSec: () => legDurationSec,
+  routeLegTimings: () => routeLegTimings
+});
+function apiKey() {
+  return typeof process !== "undefined" && process.env.GOOGLE_MAPS_API_KEY || "";
+}
+async function legDurationSec(from, to, mode, key = apiKey()) {
+  const m = (mode || "").toUpperCase();
+  if (!ROAD_MODES.has(m)) {
+    return makeSyntheticLeg(from, to, m).durationSec;
+  }
+  if (!key) {
+    return straightLineSec(from, to);
+  }
+  const url = new URL("https://maps.googleapis.com/maps/api/directions/json");
+  url.searchParams.set("origin", `${from.lat},${from.lng}`);
+  url.searchParams.set("destination", `${to.lat},${to.lng}`);
+  url.searchParams.set("mode", m.toLowerCase());
+  url.searchParams.set("key", key);
+  try {
+    const res = await fetch(url);
+    const data = await res.json();
+    const dur = data?.routes?.[0]?.legs?.[0]?.duration?.value;
+    if (typeof dur === "number" && dur > 0) return dur;
+    return straightLineSec(from, to);
+  } catch {
+    return straightLineSec(from, to);
+  }
+}
+function straightLineSec(from, to) {
+  return haversineKm(from, to) / 50 * 3600;
+}
+async function routeLegTimings(waypoints, defaultMode = "DRIVING", key = apiKey()) {
+  if (waypoints.length < 2) return [];
+  const out = [];
+  for (let i = 0; i < waypoints.length - 1; i++) {
+    const from = waypoints[i];
+    const to = waypoints[i + 1];
+    const mode = (from.mode ?? defaultMode).toUpperCase();
+    const durationSec = await legDurationSec(from, to, mode, key) ?? 0;
+    out.push({ mode, from, to, durationSec });
+  }
+  return out;
+}
+var ROAD_MODES;
+var init_directions = __esm({
+  "src/utils/directions.ts"() {
+    "use strict";
+    init_route_legs();
+    ROAD_MODES = /* @__PURE__ */ new Set(["DRIVING", "WALKING", "BICYCLING", "TRANSIT"]);
+  }
+});
+
 // src/player/pipeline.ts
 init_compiler();
 
@@ -9952,19 +10104,50 @@ function parseWaypoints(raw) {
     const bits = splitTokens(part.replace(/,/g, " "));
     const lat = Number(bits[0] ?? 0);
     const lng = Number(bits[1] ?? 0);
-    const labelRaw = bits[2];
-    const label = labelRaw ? unquote(labelRaw) : void 0;
-    return { lat, lng, label };
+    let mode;
+    const values = [];
+    for (const tok of bits.slice(2)) {
+      const value2 = unquote(tok);
+      if (!isQuoted(tok) && value2 && KNOWN_TRAVEL_MODES.has(value2.toUpperCase())) {
+        mode = value2.toUpperCase();
+        continue;
+      }
+      values.push(value2);
+    }
+    const label = values[0] || void 0;
+    const media = values[1] || void 0;
+    return { lat, lng, label, media, mode };
   });
 }
+var KNOWN_TRAVEL_MODES = /* @__PURE__ */ new Set(["DRIVING", "WALKING", "BICYCLING", "TRANSIT", "FLIGHT", "BOAT"]);
+function rewriteTweenExprs(s) {
+  return s.replace(
+    /tween\(\s*([^,()]+?)\s*,\s*([^,()]+?)\s*(?:,\s*([^()]+?))?\s*\)/g,
+    (_match, fromRaw, toRaw, easingRaw) => {
+      const scalar = (v) => {
+        const t = v.trim();
+        if (/^[+-]?(\d+(\.\d+)?|\.\d+)$/.test(t)) return t;
+        if (/^"(?:[^"\\]|\\.)*"$/.test(t)) return t;
+        if (t === "true" || t === "false" || t === "null") return t;
+        return JSON.stringify(t);
+      };
+      const items = [scalar(fromRaw), scalar(toRaw)];
+      if (easingRaw !== void 0 && easingRaw.trim()) {
+        items.push(scalar(easingRaw));
+      }
+      return `{"__tween":[${items.join(",")}]}`;
+    }
+  );
+}
 function parseProps(raw) {
   const s = raw.trim();
   if (!s.startsWith("{") && !s.startsWith("[")) return {};
   if (!s.endsWith("}") && !s.endsWith("]")) return {};
+  const withTweens = rewriteTweenExprs(s);
   try {
-    return JSON.parse(s);
+    return JSON.parse(withTweens);
   } catch {
-    let normalized = s.replace(
+    let normalized = withTweens.replace(
       /([{,]\s*)([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:(?=\s*["{[]?)/g,
       '$1"$2":'
     );
@@ -9980,7 +10163,7 @@ function parseProps(raw) {
       return JSON.parse(normalized);
     } catch {
       try {
-        const result = (0, eval)("(" + s + ")");
+        const result = (0, eval)("(" + withTweens + ")");
         return typeof result === "object" && result !== null ? result : {};
       } catch {
         return {};
@@ -10233,6 +10416,10 @@ function preserveVariantAttrs(node2, attrs) {
     "mapType",
     "data",
     "prompt",
+    "view",
+    "camera",
+    "cinematic",
+    "streetView",
     "name",
     "title",
     "transition",
@@ -10455,6 +10642,7 @@ function parseNodeLine(content3, lineNum) {
         waypoints: attrs.waypoints ?? [],
         duration: attrs.duration,
         start: attrs.start,
+        view: attrs.view,
         routeMarker: attrs.routeMarker,
         travelMode: attrs.travelMode,
         routeColor: attrs.routeColor,
@@ -10462,6 +10650,9 @@ function parseNodeLine(content3, lineNum) {
         zoom: attrs.zoom,
         center: attrs.center,
         mapType: attrs.mapType,
+        camera: attrs.camera,
+        cinematic: attrs.cinematic,
+        streetView: attrs.streetView,
         language: attrs.language ?? attrs.lang,
         region: attrs.region,
         instruction: attrs.instruction,
@@ -10630,7 +10821,7 @@ function processMDASTListItem(item, parent, lines) {
         Object.assign(node2, attrs);
       }
     } else if (child.type === "list") {
-      if (node2.type === "series" || node2.type === "parallel" || node2.type === "transitionSeries" || node2.type === "effect" || node2.type === "include" || node2.type === "rhythm") {
+      if (node2.type === "series" || node2.type === "parallel" || node2.type === "transitionSeries" || node2.type === "effect" || node2.type === "include" || node2.type === "rhythm" || node2.type === "map") {
         for (const subItem of child.children) {
           processMDASTListItem(subItem, node2, lines);
         }
@@ -10764,7 +10955,22 @@ function probeDuration(src, baseDir) {
 }
 function resolveSrc(src, baseDir) {
   if (/^(https?:|file:|\/)/.test(src)) return src;
-  return resolvePath(baseDir ?? process.cwd(), src);
+  return resolvePath(baseDir, src);
+}
+function relativizeAssetsUnder(node2, baseDir) {
+  if (!node2 || typeof node2 !== "object") return node2;
+  if (Array.isArray(node2)) return node2.map((v) => relativizeAssetsUnder(v, baseDir));
+  const out = {};
+  for (const [k, v] of Object.entries(node2)) {
+    if (typeof v === "string" && v.startsWith(baseDir + "/")) {
+      out[k] = v.slice(baseDir.length + 1);
+    } else if (v && typeof v === "object") {
+      out[k] = relativizeAssetsUnder(v, baseDir);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
 }
 var COMMON_RESOLUTIONS = [
   { width: 1920, height: 1080 },
@@ -10809,7 +11015,7 @@ function resolveMediaSrc(src, targetWidth, targetHeight, baseDir) {
   console.warn(`  \u26A0 No matching media file for "${src}" at ${targetWidth}x${targetHeight}`);
   return exactAbs;
 }
-async function resolveMediaSrcs(root, options = {}) {
+async function resolveMediaSrcs(root, options) {
   const clone = JSON.parse(JSON.stringify(root));
   const baseDir = options.baseDir;
   const targetWidth = clone.width ?? 1080;
@@ -10830,7 +11036,7 @@ async function resolveMediaSrcs(root, options = {}) {
   });
   return clone;
 }
-async function resolveMediaDurations(root, options = {}) {
+async function resolveMediaDurations(root, options) {
   const clone = JSON.parse(JSON.stringify(root));
   const baseDir = options.baseDir;
   walkDown(clone, (node2) => {
@@ -10910,13 +11116,15 @@ async function resolveScripts(root, options) {
   const clone = JSON.parse(JSON.stringify(root));
   mkdirSync2(options.outputDir, { recursive: true });
   const allScriptNodes = [];
-  walkDown(clone, (node2) => {
-    if (node2.type !== "audio") return;
-    if (!node2.script || typeof node2.script !== "string") return;
-    if (node2.src) return;
-    const id = node2.id ?? `audio-${allScriptNodes.length}`;
-    allScriptNodes.push({ node: node2, id });
-  });
+  const collect = (node2, inherited) => {
+    const ttsOverride = typeof node2.tts === "string" && node2.tts.length > 0 ? node2.tts : inherited;
+    if (node2.type === "audio" && node2.script && typeof node2.script === "string" && !node2.src) {
+      const id = node2.id ?? `audio-${allScriptNodes.length}`;
+      allScriptNodes.push({ node: node2, id, ttsOverride });
+    }
+    for (const c of node2.children ?? []) collect(c, ttsOverride);
+  };
+  collect(clone);
   const totalScripts = allScriptNodes.length;
   let scriptsDone = 0;
   let cacheHits = 0;
@@ -10924,9 +11132,9 @@ async function resolveScripts(root, options) {
   if (totalScripts > 0) {
     console.log(`  \u{1F50A} TTS: generating ${totalScripts} script${totalScripts > 1 ? "s" : ""}...`);
   }
-  for (const { node: node2, id } of allScriptNodes) {
+  for (const { node: node2, id, ttsOverride } of allScriptNodes) {
     scriptsDone++;
-    let ttsCli = clone.tts ?? options.ttsCli ?? DEFAULT_TTS_CLI;
+    let ttsCli = ttsOverride ?? options.ttsCli ?? DEFAULT_TTS_CLI;
     if (node2.speaker && clone.voices) {
       const speakerVoice = clone.voices[node2.speaker];
       if (speakerVoice) {
@@ -11242,9 +11450,9 @@ function applyStoryboardOverrides(root, options) {
   }
   return clone;
 }
-async function resolveIncludes(root, options = {}) {
+async function resolveIncludes(root, options) {
   const clone = JSON.parse(JSON.stringify(root));
-  const baseDir = options.baseDir ?? process.cwd();
+  const baseDir = options.baseDir;
   const outputDir = options.includeOutputDir ?? join(baseDir, ".markcut", "generated", "includes");
   mkdirSync2(outputDir, { recursive: true });
   function extractImportEntriesFromRaw(raw) {
@@ -11323,7 +11531,7 @@ async function resolveIncludes(root, options = {}) {
   }
   return clone;
 }
-async function resolveAll2(root, options = {}) {
+async function resolveAll2(root, options) {
   let result = root;
   if (result.seed == null && options.seed == null && options.sourcePath) {
     const autoSeed = parseInt(computeCacheKey(result).slice(0, 8), 16);
@@ -11391,8 +11599,89 @@ async function resolveAll2(root, options = {}) {
       mergedOutputDir: options.subtitleOutputDir
     });
   }
+  result = await resolveRouteStops(result);
+  result = relativizeAssetsUnder(result, options.baseDir);
   return result;
 }
+var DEFAULT_CHILD_SECONDS = 3;
+var DEFAULT_MAP_DRIVE_SECONDS = 10;
+async function resolveRouteStops(root) {
+  const { routeLegTimings: routeLegTimings2 } = await Promise.resolve().then(() => (init_directions(), directions_exports));
+  async function resolveMap(node2) {
+    if (!node2 || typeof node2 !== "object") return;
+    if (Array.isArray(node2)) {
+      for (const n of node2) await resolveMap(n);
+      return;
+    }
+    if (node2.type === "map" && Array.isArray(node2.children) && node2.children.length) {
+      const children = node2.children;
+      const anchored = children.filter((c) => c && c.at);
+      if (anchored.length) {
+        await timeMapChildren(node2, anchored, routeLegTimings2);
+      }
+    }
+    for (const child of node2.children ?? []) await resolveMap(child);
+  }
+  await resolveMap(root.children);
+  return root;
+}
+async function timeMapChildren(map, anchored, routeLegTimings2) {
+  const waypoints = map.waypoints ?? [];
+  if (waypoints.length < 2) return;
+  const legs = await routeLegTimings2(waypoints, map.travelMode ?? "DRIVING");
+  const totalDrive = legs.reduce((s, l) => s + (l.durationSec || 0), 0);
+  if (totalDrive <= 0) return;
+  const childDuration = (c) => typeof c.duration === "number" && c.duration > 0 ? c.duration : DEFAULT_CHILD_SECONDS;
+  const dwellAt = /* @__PURE__ */ new Map();
+  for (const c of anchored) {
+    const d = childDuration(c);
+    dwellAt.set(c.at, Math.max(dwellAt.get(c.at) ?? 0, d));
+  }
+  const totalDwell = [...dwellAt.values()].reduce((s, d) => s + d, 0);
+  const hasOwnDur = typeof map.duration === "number" || typeof map.endAt === "number";
+  const totalDwellBudget = Math.max(0, map.duration ?? map.endAt ?? DEFAULT_MAP_DRIVE_SECONDS);
+  const mapDur = hasOwnDur ? map.duration ?? map.endAt ?? totalDwellBudget + totalDwell : totalDwellBudget + totalDwell;
+  const driveBudget = Math.max(0.1, mapDur - totalDwell);
+  const scale = driveBudget / totalDrive;
+  const arrivalAt = /* @__PURE__ */ new Map();
+  const wp0 = waypoints[0];
+  arrivalAt.set(wp0.label ?? String(wp0.lat) + "," + String(wp0.lng), 0);
+  let cumDrive = 0;
+  let cumDwells = 0;
+  for (let i = 0; i < legs.length; i++) {
+    cumDrive += legs[i].durationSec || 0;
+    const wp = waypoints[i + 1];
+    const arrival = cumDrive * scale + cumDwells;
+    arrivalAt.set(wp.label ?? String(wp.lat) + "," + String(wp.lng), arrival);
+    if (dwellAt.has(wp.label)) cumDwells += dwellAt.get(wp.label);
+  }
+  const schedule = [];
+  for (const c of anchored) {
+    const arrival = arrivalAt.get(c.at);
+    if (arrival == null) {
+      console.warn(`  \u26A0 map child at:"${c.at}" \u2014 no waypoint with that label; renders full-screen`);
+      continue;
+    }
+    if (typeof c.start === "number") {
+      schedule.push(`  \u{1F6D1} ${c.at}: manual ${c.start.toFixed(1)}s (unchanged)`);
+      continue;
+    }
+    const dur = childDuration(c);
+    c.start = arrival;
+    c.end = arrival + dur;
+    schedule.push(`  \u{1F6D1} ${c.at}: ${arrival.toFixed(1)}s \u2192 ${(arrival + dur).toFixed(1)}s (${dur.toFixed(1)}s)`);
+  }
+  if (schedule.length) {
+    console.log(`  \u{1F5FA} route stops (${mapDur.toFixed(1)}s total):`);
+    for (const line of schedule) console.log(line);
+  }
+  if (!hasOwnDur) {
+    map.duration = mapDur;
+  } else if ((map.duration ?? 0) < mapDur) {
+    map.duration = mapDur;
+    console.log(`  \u{1F5FA} extended map duration \u2192 ${mapDur.toFixed(1)}s (drives + dwells)`);
+  }
+}
 
 // src/player/pipeline.ts
 function isDescriptiveRoot(data) {
@@ -11408,7 +11697,7 @@ function isDescriptiveRoot(data) {
   )) return true;
   return false;
 }
-async function resolveAndCompile(data, options = {}) {
+async function resolveAndCompile(data, options) {
   const resolved = await resolveAll2(data, {
     sourcePath: options.sourcePath,
     baseDir: options.baseDir,
@@ -11427,7 +11716,7 @@ async function resolveAndCompile(data, options = {}) {
   });
   return compiled;
 }
-async function resolveAndCompileMarkdown(markdown, options = {}) {
+async function resolveAndCompileMarkdown(markdown, options) {
   const descriptive = parseMarkdownDescriptive(markdown);
   return resolveAndCompile(descriptive, options);
 }

package/src/player/pipeline.ts

@@ -21,8 +21,9 @@ import type { DescriptiveRoot } from "../descriptive/compiler";
 import type { Root } from "../schema/index";
 
 export interface ResolveAndCompileOptions {
-  /** Base directory for resolving relative media src paths */
-  baseDir?: string;
+  /** Base directory (the source file's folder) for resolving/emitting asset paths.
+   *  Always set by the CLI/server; no fallback. */
+  baseDir: string;
   /** Output directory for generated TTS audio / STT VTT files */
   scriptOutputDir?: string;
   /** Output directory for generated TTI/TTV media files */
@@ -88,7 +89,7 @@ export function isDescriptiveRoot(data: any): boolean {
  */
 export async function resolveAndCompile(
   data: DescriptiveRoot,
-  options: ResolveAndCompileOptions = {},
+  options: ResolveAndCompileOptions,
 ): Promise<Root> {
   // 1. Async resolve: durations, TTS, STT, includes
   const resolved = await resolveAll(data, {
@@ -121,7 +122,7 @@ export async function resolveAndCompile(
  */
 export async function resolveAndCompileMarkdown(
   markdown: string,
-  options: ResolveAndCompileOptions = {},
+  options: ResolveAndCompileOptions,
 ): Promise<Root> {
   const descriptive = parseMarkdownDescriptive(markdown);
   return resolveAndCompile(descriptive, options);

package/src/player/server.mjs

@@ -326,59 +326,39 @@ function makePathsRelative(obj) {
 }
 
 /**
- * Convert relative (to MARKCUT_BASE) paths in the compiled root to server-relative URLs
- * for the browser. This is the inverse of makePathsRelative — it prepends "/" to paths
- * so the browser can fetch them from the server.
+ * Convert asset paths in the compiled root to server-relative URLs for the
+ * browser. The compiled JSON now carries md-folder-relative paths (e.g.
+ * ".markcut/generated/tts/x.mp3" or "assets/photo.jpg") because the resolve
+ * step emits them relative to the source .md folder — the server document
+ * root. This prepends "/" so the browser can fetch them (resolveAsset() then
+ * maps the URL back onto the md folder).
  *
- * Handles:
- *   - compiled.imports (component bundle URL)
- *   - compiled.subtitle.src (VTT file)
- *   - Any node.src (media/tts/images) that is a relative path under MARKCUT_BASE
+ * Also handles legacy absolute paths under MARKCUT_BASE (older cached trees).
  */
 function resolveAssetPaths(root) {
   const out = JSON.parse(JSON.stringify(root));
 
+  function toServerUrl(p) {
+    if (typeof p !== "string") return p;
+    if (/^(https?:|data:|blob:)/.test(p)) return p;
+    if (p.startsWith("/")) return p;                       // already a server URL
+    // Legacy: absolute path under the .markcut base (older cached trees)
+    if (p.startsWith(MARKCUT_BASE)) return p.slice(MARKCUT_BASE.length);
+    // md-folder-relative path (new scheme): ".markcut/...", "assets/..."
+    const rel = p.startsWith("./") ? p.slice(2) : p;
+    return "/" + rel;
+  }
+
   function walkNode(node) {
     if (!node || typeof node !== "object") return;
     if (Array.isArray(node)) { node.forEach(walkNode); return; }
 
-    // Convert src fields that are relative paths
-    if (typeof node.src === "string" && !node.src.startsWith("http://") && !node.src.startsWith("https://") && !node.src.startsWith("data:")) {
-      // Already a relative path under MARKCUT_BASE (shouldn't be absolute)
-      if (!node.src.startsWith("/") && !node.src.startsWith(".")) {
-        // Plain relative path — prefix with / (server serves from project root)
-        node.src = "/" + node.src;
-      } else if (node.src.startsWith("./")) {
-        // Dot-prefixed relative path — strip ./ and prefix with /
-        node.src = "/" + node.src.slice(2);
-      }
-      // Convert absolute paths under MARKCUT_BASE
-      if (typeof node.src === "string" && node.src.startsWith(MARKCUT_BASE)) {
-        node.src = "/" + node.src.replace(MARKCUT_BASE + "/", "");
-      }
-    }
-
-    // Convert subtitle src
+    if (typeof node.src === "string") node.src = toServerUrl(node.src);
     if (node.subtitle && typeof node.subtitle.src === "string") {
-      if (node.subtitle.src.startsWith(MARKCUT_BASE)) {
-        node.subtitle.src = "/" + node.subtitle.src.replace(MARKCUT_BASE + "/", "");
-      } else if (!node.subtitle.src.startsWith("/") && !node.subtitle.src.startsWith("http")) {
-        node.subtitle.src = "/" + node.subtitle.src;
-      }
-    }
-
-    // Convert imports (component bundle URL)
-    if (typeof node.imports === "string") {
-      if (node.imports.startsWith(MARKCUT_BASE)) {
-        node.imports = "/" + node.imports.replace(MARKCUT_BASE + "/", "");
-      } else if (!node.imports.startsWith("/") && !node.imports.startsWith("http")) {
-        node.imports = "/" + node.imports;
-      }
-    }
-
-    if (Array.isArray(node.children)) {
-      node.children.forEach(walkNode);
+      node.subtitle.src = toServerUrl(node.subtitle.src);
     }
+    if (typeof node.imports === "string") node.imports = toServerUrl(node.imports);
+    if (Array.isArray(node.children)) node.children.forEach(walkNode);
   }
 
   walkNode(out);