@lalalic/markcut 3.1.0 → 3.1.1

package/tests/render.test.ts

@@ -21,6 +21,7 @@ import {
   FIXTURES_DIR,
 } from "./utils";
 import { existsSync, rmSync, mkdirSync } from "node:fs";
+import { execSync } from "node:child_process";
 import { resolve } from "node:path";
 
 // Increase timeout for integration tests (rendering + STT can take a while)
@@ -258,6 +259,97 @@ describe("Map Rendering", () => {
     // Check file size as proxy for visual content.
     expect(getFrameFileSize(frame)).toBeGreaterThan(1000);
   });
+
+  it("renders anchored overlay children at waypoints (dwell vs drive)", async () => {
+    const output = renderFixture(fixturePath("map-overlay.json"), {
+      outputName: "map-overlay.mp4",
+      timeout: RENDER_TIMEOUT,
+    });
+
+    const info = getVideoInfo(output);
+    expect(info.width).toBe(640);
+
+    // The map has a solid-magenta photo anchored at "Golden Gate" (0–4s,
+    // zoomIn), then the pin drives to SFO. The photo must be visible during
+    // the dwell and gone during the drive — guards regressions where anchored
+    // overlays silently never render (getProjection() null / lazy effect path).
+    const dwell = outPath("frames/map-overlay-dwell.png");
+    const drive = outPath("frames/map-overlay-drive.png");
+    extractFrame(output, 2.5, dwell);
+    extractFrame(output, 6, drive);
+
+    const magentaFraction = (f: string): number => {
+      const p = execSync(
+        `ffmpeg -loglevel error -i "${f}" -vf scale=160:120 -f rawvideo -pix_fmt rgb24 pipe:1`,
+      );
+      let count = 0;
+      for (let i = 0; i < p.length; i += 3) {
+        if (p[i]! > 200 && p[i + 1]! < 80 && p[i + 2]! > 200) count++;
+      }
+      return count / (p.length / 3);
+    };
+
+    expect(magentaFraction(dwell)).toBeGreaterThan(0.02); // photo visible during dwell
+    expect(magentaFraction(drive)).toBeLessThan(0.001); // gone during drive
+  });
+
+  it("renders street view panoramas non-dark", async () => {
+    const output = renderFixture(fixturePath("map-dynamic.json"), {
+      outputName: "map-dynamic-streetview.mp4",
+      timeout: RENDER_TIMEOUT,
+    });
+
+    // map-dynamic.json is a series: dolly 0–3s, cinematic 3–11s, then the
+    // static streetview-pan scene plays ~11–17s. Its panorama must not be
+    // black — guards regressions where static Street View captures dark frames
+    // (pano_changed race + too-short fallback).
+    const frame = outPath("frames/map-dynamic-streetview.png");
+    extractFrame(output, 13, frame);
+
+    const darkFraction = (f: string): number => {
+      const p = execSync(
+        `ffmpeg -loglevel error -i "${f}" -vf scale=120:90 -f rawvideo -pix_fmt rgb24 pipe:1`,
+      );
+      let dark = 0;
+      for (let i = 0; i < p.length; i += 3) {
+        const v = (p[i]! + p[i + 1]! + p[i + 2]!) / 3;
+        if (v < 20) dark++;
+      }
+      return dark / (p.length / 3);
+    };
+
+    expect(darkFraction(frame)).toBeLessThan(0.5);
+  });
+
+  it("renders street view walk (route) non-dark at both waypoints", async () => {
+    const output = renderFixture(fixturePath("streetview-walk.json"), {
+      outputName: "streetview-walk.mp4",
+      timeout: RENDER_TIMEOUT,
+    });
+
+    // The snap-walk holds at route[0] (101 Grove St) for the first half and
+    // route[1] (95 Hayes St) for the second. Both have imagery; neither frame
+    // should be black. Guards regressions where the walk's per-frame pano
+    // requests get rate-limited (429) and render dark frames.
+    const darkFraction = (f: string): number => {
+      const p = execSync(
+        `ffmpeg -loglevel error -i "${f}" -vf scale=120:90 -f rawvideo -pix_fmt rgb24 pipe:1`,
+      );
+      let dark = 0;
+      for (let i = 0; i < p.length; i += 3) {
+        const v = (p[i]! + p[i + 1]! + p[i + 2]!) / 3;
+        if (v < 20) dark++;
+      }
+      return dark / (p.length / 3);
+    };
+
+    const wp0 = outPath("frames/streetview-walk-wp0.png");
+    const wp1 = outPath("frames/streetview-walk-wp1.png");
+    extractFrame(output, 2, wp0);
+    extractFrame(output, 4.5, wp1);
+    expect(darkFraction(wp0)).toBeLessThan(0.5);
+    expect(darkFraction(wp1)).toBeLessThan(0.5);
+  });
 });
 
 // ───────────────────────────────────────────────────────────────────────────

package/tests/route-legs.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect } from "vitest";
+import {
+  haversineKm,
+  greatCirclePath,
+  makeSyntheticLeg,
+  modeEmoji,
+  routePositionAtLegs,
+  isSyntheticMode,
+  type RouteLeg,
+} from "../src/utils/route-legs";
+
+const SF = { lat: 37.7749, lng: -122.4194 };
+const LA = { lat: 34.0522, lng: -118.2437 };
+const PIER = { lat: 34.0094, lng: -118.4969 };
+
+describe("haversineKm", () => {
+  it("is ~0 for identical points", () => {
+    expect(haversineKm(SF, SF)).toBeCloseTo(0, 6);
+  });
+
+  it("is ~560 km for SF→LA (great-circle)", () => {
+    expect(haversineKm(SF, LA)).toBeGreaterThan(500);
+    expect(haversineKm(SF, LA)).toBeLessThan(620);
+  });
+});
+
+describe("greatCirclePath", () => {
+  it("includes both endpoints and is monotonic in length", () => {
+    const path = greatCirclePath(SF, LA, 32);
+    expect(path.length).toBe(33);
+    expect(path[0]).toEqual(SF);
+    const last = path[path.length - 1]!;
+    expect(last.lat).toBeCloseTo(LA.lat, 4);
+    expect(last.lng).toBeCloseTo(LA.lng, 4);
+  });
+
+  it("handles identical endpoints without NaN", () => {
+    const path = greatCirclePath(SF, SF, 8);
+    expect(path.every((p) => Number.isFinite(p.lat) && Number.isFinite(p.lng))).toBe(true);
+    expect(path[0]).toEqual(SF);
+  });
+});
+
+describe("makeSyntheticLeg", () => {
+  it("builds a FLIGHT leg with a cruise-speed duration and single arc step", () => {
+    const leg = makeSyntheticLeg(SF, LA, "FLIGHT");
+    expect(leg.mode).toBe("FLIGHT");
+    expect(leg.durationSec).toBeGreaterThan(0);
+    // SF→LA ~559 km @ 850 km/h ≈ 0.66 h ≈ 2370 s
+    expect(leg.durationSec).toBeGreaterThan(2000);
+    expect(leg.durationSec).toBeLessThan(2700);
+    expect(leg.steps).toHaveLength(1);
+    expect(leg.steps[0]!.path.length).toBeGreaterThan(10);
+  });
+
+  it("builds a BOAT leg with a slower speed (longer duration for same distance)", () => {
+    const boat = makeSyntheticLeg(SF, LA, "BOAT");
+    const flight = makeSyntheticLeg(SF, LA, "FLIGHT");
+    expect(boat.mode).toBe("BOAT");
+    expect(boat.durationSec).toBeGreaterThan(flight.durationSec);
+  });
+});
+
+describe("isSyntheticMode / modeEmoji", () => {
+  it("flags FLIGHT and BOAT as synthetic", () => {
+    expect(isSyntheticMode("FLIGHT")).toBe(true);
+    expect(isSyntheticMode("BOAT")).toBe(true);
+    expect(isSyntheticMode("flight")).toBe(true);
+    expect(isSyntheticMode("DRIVING")).toBe(false);
+    expect(isSyntheticMode("WALKING")).toBe(false);
+    expect(isSyntheticMode(undefined)).toBe(false);
+  });
+
+  it("maps modes to emoji", () => {
+    expect(modeEmoji("FLIGHT")).toBe("✈️");
+    expect(modeEmoji("BOAT")).toBe("🚢");
+    expect(modeEmoji("WALKING")).toBe("🚶");
+    expect(modeEmoji("BICYCLING")).toBe("🚲");
+    expect(modeEmoji("TRANSIT")).toBe("🚌");
+    expect(modeEmoji("DRIVING")).toBe("🚗");
+    expect(modeEmoji(undefined)).toBe("📍");
+  });
+});
+
+describe("routePositionAtLegs", () => {
+  const makeLeg = (mode: string, durationSec: number, path: { lat: number; lng: number }[]): RouteLeg => ({
+    mode,
+    from: path[0]!,
+    to: path[path.length - 1]!,
+    durationSec,
+    steps: [{ path, durationSec }],
+  });
+
+  const straight = (a: { lat: number; lng: number }, b: { lat: number; lng: number }, n = 20) => {
+    const out: { lat: number; lng: number }[] = [];
+    for (let i = 0; i <= n; i++) {
+      const t = i / n;
+      out.push({ lat: a.lat + (b.lat - a.lat) * t, lng: a.lng + (b.lng - a.lng) * t });
+    }
+    return out;
+  };
+
+  const legs: RouteLeg[] = [
+    makeLeg("FLIGHT", 10, straight(SF, LA)),
+    makeLeg("DRIVING", 30, straight(LA, PIER)),
+  ];
+
+  it("returns null for no legs", () => {
+    expect(routePositionAtLegs([], 40, 0)).toBeNull();
+  });
+
+  it("starts at the first waypoint and ends at the last", () => {
+    const start = routePositionAtLegs(legs, 40, 0)!;
+    expect(start.lat).toBeCloseTo(SF.lat, 5);
+    expect(start.lng).toBeCloseTo(SF.lng, 5);
+    expect(start.mode).toBe("FLIGHT");
+
+    const end = routePositionAtLegs(legs, 40, 40)!;
+    expect(end.lat).toBeCloseTo(PIER.lat, 5);
+    expect(end.lng).toBeCloseTo(PIER.lng, 5);
+    expect(end.mode).toBe("DRIVING");
+  });
+
+  it("splits time proportionally to leg duration and reports the current leg mode", () => {
+    // leg durations 10 + 30 = 40 total; actionDuration 40s
+    // → flight leg occupies t∈[0,10], driving leg t∈[10,40]
+    const atFlightEnd = routePositionAtLegs(legs, 40, 9.99)!;
+    expect(atFlightEnd.mode).toBe("FLIGHT");
+
+    const atDrivingStart = routePositionAtLegs(legs, 40, 10.01)!;
+    expect(atDrivingStart.mode).toBe("DRIVING");
+    expect(atDrivingStart.lat).toBeCloseTo(LA.lat, 4);
+  });
+
+  it("mid-leg position tracks the leg's path (proportional timing)", () => {
+    // leg durations [10,30]; actionDuration 40. At t=20 the driving leg is
+    // (20-10)/30 = 1/3 of the way from LA → PIER (with point quantization).
+    const atThird = 1 / 3;
+    const mid = routePositionAtLegs(legs, 40, 20)!;
+    expect(mid.mode).toBe("DRIVING");
+    expect(mid.lat).toBeCloseTo(LA.lat + (PIER.lat - LA.lat) * atThird, 2);
+    expect(mid.lng).toBeCloseTo(LA.lng + (PIER.lng - LA.lng) * atThird, 2);
+  });
+
+  it("clamps past-the-end seconds to the destination", () => {
+    const end = routePositionAtLegs(legs, 40, 100)!;
+    expect(end.lat).toBeCloseTo(PIER.lat, 5);
+    expect(end.mode).toBe("DRIVING");
+  });
+
+  it("holds at a waypoint during a dwell window", () => {
+    const stops = [{ label: "LA", at: LA, mode: "FLIGHT", fromSec: 8, toSec: 12 }];
+    // Inside the dwell → pin holds at LA, not on the flight arc.
+    const during = routePositionAtLegs(legs, 40, 10, stops)!;
+    expect(during.mode).toBe("FLIGHT");
+    expect(during.lat).toBeCloseTo(LA.lat, 4);
+    expect(during.lng).toBeCloseTo(LA.lng, 4);
+
+    // At toSec the dwell is over and motion resumes (no longer holding at LA).
+    const resumed = routePositionAtLegs(legs, 40, 12, stops)!;
+    expect(resumed.mode).toBe("FLIGHT");
+    expect(resumed.lat).toBeGreaterThan(LA.lat);
+  });
+
+  it("compresses drive time around dwells (dwell removed from drive budget)", () => {
+    const stops = [{ label: "LA", at: LA, mode: "FLIGHT", fromSec: 8, toSec: 12 }];
+    // With the 4s dwell at LA, at wall-clock t=12 the pin is only ~89% along
+    // the flight arc (still north of LA) because the drive budget shrank.
+    const withStop = routePositionAtLegs(legs, 40, 12, stops)!;
+    expect(withStop.mode).toBe("FLIGHT");
+    expect(withStop.lat).toBeGreaterThan(LA.lat);
+    expect(withStop.lat).toBeLessThan(SF.lat);
+
+    // Without the stop, t=12 is already 20% into the LA→PIER driving leg.
+    const noStop = routePositionAtLegs(legs, 40, 12)!;
+    expect(noStop.mode).toBe("DRIVING");
+  });
+});

package/tests/schema.test.ts

@@ -125,4 +125,22 @@ describe("map stream — dynamic camera views", () => {
   it("rejects an invalid view", () => {
     expect(() => mapStream.parse({ ...base, view: "drone" })).toThrow();
   });
+
+  it("carries per-waypoint travel modes (FLIGHT/BOAT/DRIVING...)", () => {
+    const m = mapStream.parse({
+      ...base,
+      waypoints: [
+        { lat: 37.77, lng: -122.41, mode: "FLIGHT" },
+        { lat: 34.05, lng: -118.25, mode: "BOAT" },
+        { lat: 34.01, lng: -118.5, mode: "WALKING" },
+      ],
+    });
+    expect(m.waypoints.map((w) => w.mode)).toEqual(["FLIGHT", "BOAT", "WALKING"]);
+  });
+
+  it("rejects an invalid waypoint travel mode", () => {
+    expect(() =>
+      mapStream.parse({ ...base, waypoints: [{ lat: 37.77, lng: -122.41, mode: "TELEPORT" }] }),
+    ).toThrow();
+  });
 });