@pixel-point/toolcraft 0.0.18 → 0.0.19

package/templates/starter/scripts/toolcraft-motion-reference-ffmpeg-output.mjs

@@ -0,0 +1,275 @@
+import {
+  TOOLCRAFT_MOTION_ANALYSIS_COMPONENT_MAX,
+  TOOLCRAFT_MOTION_FFMPEG_TIMESTAMP_TOLERANCE_SECONDS,
+} from "./toolcraft-motion-reference-analysis-protocol.mjs";
+
+function fail(message) {
+  throw new TypeError(`Invalid Toolcraft motion FFmpeg output: ${message}`);
+}
+
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function finiteNumber(value, label) {
+  if (typeof value === "number") {
+    if (Number.isFinite(value)) return value;
+    fail(`${label} must be finite`);
+  }
+  if (typeof value !== "string" ||
+      !/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/iu.test(value.trim())) {
+    fail(`${label} must be a finite locale-independent number`);
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) fail(`${label} must be finite`);
+  return parsed;
+}
+
+function optionalFiniteNumber(value, label) {
+  if (value === undefined || value === null || value === "" || value === "N/A") {
+    return undefined;
+  }
+  return finiteNumber(value, label);
+}
+
+function positiveInteger(value, label) {
+  const parsed = typeof value === "string" && /^\d+$/u.test(value) ?
+    Number(value) : value;
+  if (!Number.isInteger(parsed) || parsed <= 0) fail(`${label} must be positive`);
+  return parsed;
+}
+
+function nominalFrameRate(value) {
+  if (value === undefined || value === null || value === "" || value === "0/0") {
+    return undefined;
+  }
+  const match = typeof value === "string" ?
+    /^(\d+(?:\.\d+)?)\/(\d+(?:\.\d+)?)$/u.exec(value.trim()) : null;
+  if (!match) fail("visual stream frame rate must be a positive rational");
+  const numerator = finiteNumber(match[1], "frame-rate numerator");
+  const denominator = finiteNumber(match[2], "frame-rate denominator");
+  if (numerator <= 0 || denominator <= 0) fail("visual stream frame rate must be positive");
+  return numerator / denominator;
+}
+
+function pixelFormatHasAlpha(document, pixelFormat) {
+  if (!Array.isArray(document.pixel_formats)) {
+    fail("ffprobe pixel format descriptors are required");
+  }
+  const matches = document.pixel_formats.filter((descriptor) =>
+    isRecord(descriptor) && descriptor.name === pixelFormat);
+  if (matches.length === 0) fail(`pixel format descriptor ${pixelFormat} is missing`);
+  if (matches.length > 1) fail(`duplicate pixel format descriptor ${pixelFormat}`);
+  const descriptor = matches[0];
+  if (!Number.isInteger(descriptor.nb_components) || descriptor.nb_components <= 0 ||
+      !Array.isArray(descriptor.components) ||
+      descriptor.components.length !== descriptor.nb_components ||
+      descriptor.components.some((component) =>
+        !isRecord(component) || !Number.isInteger(component.index) ||
+        component.index <= 0 || !Number.isInteger(component.bit_depth) ||
+        component.bit_depth <= 0)) {
+    fail(`pixel format descriptor ${pixelFormat} has an invalid component model`);
+  }
+  if (!isRecord(descriptor.flags) ||
+      descriptor.flags.alpha !== 0 && descriptor.flags.alpha !== 1) {
+    fail(`pixel format descriptor ${pixelFormat} has an invalid alpha flag`);
+  }
+  return descriptor.flags.alpha === 1;
+}
+
+export function normalizeToolcraftMotionToolVersion(stdout, tool) {
+  if (tool !== "ffmpeg" && tool !== "ffprobe") {
+    fail("tool version owner must be ffmpeg or ffprobe");
+  }
+  if (typeof stdout !== "string") fail(`${tool} version output must be text`);
+  const match = new RegExp(`^\\s*${tool}\\s+version\\s+([^\\s]+)`, "iu").exec(stdout);
+  if (!match) fail(`${tool} version output is missing`);
+  return `${tool} ${match[1]}`;
+}
+
+export function parseToolcraftMotionFfprobeJson(stdout) {
+  let document;
+  try {
+    document = JSON.parse(stdout);
+  } catch {
+    fail("expected valid ffprobe JSON");
+  }
+  if (!isRecord(document)) {
+    fail("ffprobe JSON must be an object");
+  }
+  const visualStream = Array.isArray(document.streams) ?
+    document.streams.find((stream) =>
+      isRecord(stream) && stream.codec_type === "video") :
+    undefined;
+  if (!visualStream) fail("a visual stream is required");
+  const width = positiveInteger(visualStream.width, "visual stream width");
+  const height = positiveInteger(visualStream.height, "visual stream height");
+  if (!width || !height) fail("visual stream dimensions are required");
+  if (typeof visualStream.pix_fmt !== "string" || visualStream.pix_fmt.length === 0) {
+    fail("visual stream pixel format is required");
+  }
+  if (!Array.isArray(document.frames) || document.frames.length === 0) {
+    fail("at least one decoded frame is required");
+  }
+  const decodedFrameTimes = document.frames.map((frame, index) => {
+    if (!isRecord(frame)) fail(`decoded frame ${index} must be an object`);
+    return finiteNumber(
+      frame.best_effort_timestamp_time ?? frame.pts_time,
+      `decoded frame ${index} timestamp`,
+    );
+  });
+  decodedFrameTimes.forEach((time, index) => {
+    if (index > 0 && time <= decodedFrameTimes[index - 1]) {
+      fail("decoded frame timestamps must be strictly increasing");
+    }
+  });
+  const timelineOrigin = decodedFrameTimes[0];
+  const frameTimes = decodedFrameTimes.map((time) => time - timelineOrigin);
+  const decodedFrameCount = frameTimes.length;
+  if (visualStream.nb_frames !== undefined && visualStream.nb_frames !== "N/A" &&
+      positiveInteger(visualStream.nb_frames, "visual stream frame count") !==
+        decodedFrameCount) {
+    fail("visual stream frame count must match decoded frame records");
+  }
+  const averageRate = nominalFrameRate(visualStream.avg_frame_rate);
+  const rate = averageRate ?? nominalFrameRate(visualStream.r_frame_rate);
+  const frameTail = rate ? 1 / rate : frameTimes.length > 1 ?
+    frameTimes.at(-1) - frameTimes.at(-2) : 0;
+  const decodedDuration = frameTimes.at(-1) + frameTail;
+  const format = isRecord(document.format) ? document.format : {};
+  const rawDuration = optionalFiniteNumber(
+    format.duration ?? visualStream.duration, "visual duration",
+  );
+  const declaredStart = optionalFiniteNumber(
+    format.start_time ?? visualStream.start_time, "visual start time",
+  );
+  let declaredDuration;
+  if (rawDuration !== undefined) {
+    if (declaredStart !== undefined && declaredStart > 0 &&
+        rawDuration > decodedDuration +
+          TOOLCRAFT_MOTION_FFMPEG_TIMESTAMP_TOLERANCE_SECONDS) {
+      declaredDuration = rawDuration - declaredStart;
+    } else if (declaredStart !== undefined ||
+        rawDuration <= decodedDuration +
+          TOOLCRAFT_MOTION_FFMPEG_TIMESTAMP_TOLERANCE_SECONDS ||
+        Math.abs(timelineOrigin) <=
+          TOOLCRAFT_MOTION_FFMPEG_TIMESTAMP_TOLERANCE_SECONDS) {
+      declaredDuration = rawDuration;
+    }
+  }
+  const durationSeconds = declaredDuration !== undefined &&
+      decodedDuration - declaredDuration <=
+        TOOLCRAFT_MOTION_FFMPEG_TIMESTAMP_TOLERANCE_SECONDS ?
+    declaredDuration : Math.max(decodedDuration, declaredDuration ?? 0);
+  if (!(durationSeconds > 0)) fail("visual duration must be positive");
+  const rawVersion = isRecord(document.program_version) ?
+    document.program_version.version : undefined;
+  if (typeof rawVersion !== "string" || rawVersion.trim().length === 0) {
+    fail("ffprobe version metadata is required");
+  }
+  return {
+    decodedFrameCount,
+    durationSeconds,
+    ffprobeVersion: normalizeToolcraftMotionToolVersion(
+      `ffprobe version ${rawVersion.trim()}`, "ffprobe",
+    ),
+    frameTimes,
+    hasAlpha: pixelFormatHasAlpha(document, visualStream.pix_fmt),
+    height,
+    ...(rate === undefined ? {} : { nominalFrameRate: rate }),
+    pixelFormat: visualStream.pix_fmt,
+    width,
+  };
+}
+
+function completeRecord(records, record) {
+  if (!record) return;
+  if (record.channel !== "color" && record.channel !== "alpha") {
+    fail(`frame ${record.frameIndex} has an invalid channel`);
+  }
+  const key = `${record.channel}:${record.frameIndex}`;
+  if (records.has(key)) fail(`duplicate ${record.channel} frame record ${record.frameIndex}`);
+  records.set(key, record);
+}
+
+function parseSignalValue(record, key) {
+  if (!record.values.has(key)) fail(`frame ${record.frameIndex} is missing ${key}`);
+  const value = finiteNumber(record.values.get(key), `${key} for frame ${record.frameIndex}`);
+  if (value < 0 || value > TOOLCRAFT_MOTION_ANALYSIS_COMPONENT_MAX) {
+    fail(`${key} must be between 0 and ${TOOLCRAFT_MOTION_ANALYSIS_COMPONENT_MAX}`);
+  }
+  return value;
+}
+
+function sortedChannelRecords(records, channel) {
+  const values = [...records.values()].filter((record) => record.channel === channel)
+    .sort((left, right) => left.frameIndex - right.frameIndex);
+  values.forEach((record, index) => {
+    if (record.frameIndex !== index) fail(`missing frame record ${index} for ${channel}`);
+  });
+  return values;
+}
+
+export function parseToolcraftMotionSignalstats(stdout, { requireAlpha = false } = {}) {
+  if (typeof stdout !== "string" || stdout.trim().length === 0) {
+    fail("signalstats output is required");
+  }
+  const records = new Map();
+  let current;
+  for (const rawLine of stdout.split(/\r?\n/u)) {
+    const line = rawLine.trim();
+    if (line.length === 0) continue;
+    const header = /^frame:(\d+)\s+pts:\S+\s+pts_time:(\S+)$/u.exec(line);
+    if (header) {
+      completeRecord(records, current);
+      current = {
+        channel: "color",
+        frameIndex: Number(header[1]),
+        timeSeconds: finiteNumber(header[2], `frame ${header[1]} timestamp`),
+        values: new Map(),
+      };
+      continue;
+    }
+    if (!current) fail("signalstats metadata appeared before a frame record");
+    const separator = line.indexOf("=");
+    if (separator < 1) continue;
+    const key = line.slice(0, separator);
+    const value = line.slice(separator + 1);
+    if (key === "toolcraft.channel") {
+      current.channel = value;
+    } else if (key.startsWith("lavfi.signalstats.")) {
+      if (current.values.has(key)) fail(`duplicate ${key} in frame ${current.frameIndex}`);
+      current.values.set(key, value);
+    }
+  }
+  completeRecord(records, current);
+  const color = sortedChannelRecords(records, "color");
+  if (color.length === 0) fail("at least one color frame record is required");
+  const alpha = sortedChannelRecords(records, "alpha");
+  if (requireAlpha && alpha.length !== color.length) {
+    fail("one alpha record is required for every color frame");
+  }
+  if (alpha.length > 0 && alpha.length !== color.length) {
+    fail("alpha and color frame counts must agree");
+  }
+  return color.map((record, index) => {
+    if (index > 0 && record.timeSeconds <= color[index - 1].timeSeconds) {
+      fail("frame timestamps must be strictly increasing");
+    }
+    const alphaRecord = alpha[index];
+    if (alphaRecord && (alphaRecord.frameIndex !== record.frameIndex ||
+        alphaRecord.timeSeconds !== record.timeSeconds)) {
+      fail("alpha and color frame timestamps must agree");
+    }
+    return {
+      ...(alphaRecord ? {
+        alphaDifference: parseSignalValue(alphaRecord, "lavfi.signalstats.YDIF"),
+      } : {}),
+      frameIndex: record.frameIndex,
+      timeSeconds: record.timeSeconds,
+      uDifference: parseSignalValue(record, "lavfi.signalstats.UDIF"),
+      vDifference: parseSignalValue(record, "lavfi.signalstats.VDIF"),
+      yDifference: parseSignalValue(record, "lavfi.signalstats.YDIF"),
+    };
+  });
+}

package/templates/starter/scripts/toolcraft-motion-reference-ffmpeg-output.test.mjs

@@ -0,0 +1,294 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  normalizeToolcraftMotionToolVersion,
+  parseToolcraftMotionFfprobeJson,
+  parseToolcraftMotionSignalstats,
+} from "./toolcraft-motion-reference-ffmpeg-output.mjs";
+import {
+  createToolcraftMotionLoopSeamScore,
+  toolcraftMotionAnalysisChangeScore,
+} from "./toolcraft-motion-reference-analysis-protocol.mjs";
+
+function pixelFormatDescriptor(name, { alpha = true, components = alpha ? 4 : 3 } = {}) {
+  return {
+    components: Array.from({ length: components }, (_, index) => ({
+      bit_depth: 8,
+      index: index + 1,
+    })),
+    flags: { alpha: alpha ? 1 : 0 },
+    name,
+    nb_components: components,
+  };
+}
+
+function probeJson(overrides = {}) {
+  return JSON.stringify({
+    format: { duration: "0.100000" },
+    frames: [
+      { best_effort_timestamp_time: "0.000000" },
+      { best_effort_timestamp_time: "0.033333" },
+      { best_effort_timestamp_time: "0.066667" },
+    ],
+    program_version: { version: "8.0.1-2 tool build" },
+    pixel_formats: [pixelFormatDescriptor("yuva444p")],
+    streams: [{
+      codec_type: "video",
+      duration: "0.100000",
+      height: 360,
+      nb_frames: "3",
+      pix_fmt: "yuva444p",
+      r_frame_rate: "30/1",
+      width: 640,
+    }],
+    ...overrides,
+  });
+}
+
+function statsRecord(frame, time, {
+  alpha,
+  channel = "color",
+  u = 0,
+  v = 0,
+  y = 0,
+} = {}) {
+  return [
+    `frame:${frame} pts:${frame} pts_time:${time}`,
+    `toolcraft.channel=${channel}`,
+    `lavfi.signalstats.YDIF=${alpha ?? y}`,
+    ...(channel === "alpha" ? [] : [
+      `lavfi.signalstats.UDIF=${u}`,
+      `lavfi.signalstats.VDIF=${v}`,
+    ]),
+  ].join("\n");
+}
+
+test("normalizes visual ffprobe metadata and authoritative decoded timing", () => {
+  assert.deepEqual(parseToolcraftMotionFfprobeJson(probeJson()), {
+    decodedFrameCount: 3,
+    durationSeconds: 0.1,
+    ffprobeVersion: "ffprobe 8.0.1-2",
+    frameTimes: [0, 0.033333, 0.066667],
+    hasAlpha: true,
+    height: 360,
+    nominalFrameRate: 30,
+    pixelFormat: "yuva444p",
+    width: 640,
+  });
+});
+
+test("normalizes positive and negative decoded timestamp origins to source time zero", () => {
+  for (const origin of [10, -1]) {
+    const document = JSON.parse(probeJson());
+    document.frames = [origin, origin + 0.033333, origin + 0.066667]
+      .map((time) => ({ best_effort_timestamp_time: String(time) }));
+    const result = parseToolcraftMotionFfprobeJson(JSON.stringify(document));
+    assert.equal(result.frameTimes[0], 0);
+    assert.ok(Math.abs(result.frameTimes[1] - 0.033333) < 1e-9);
+    assert.ok(Math.abs(result.frameTimes[2] - 0.066667) < 1e-9);
+    assert.equal(result.durationSeconds, 0.1);
+  }
+});
+
+test("normalizes shifted container duration to the decoded zero-origin timeline", () => {
+  const document = JSON.parse(probeJson());
+  document.format = { duration: "12.000000", start_time: "10.000000" };
+  document.frames = Array.from({ length: 60 }, (_, index) => ({
+    best_effort_timestamp_time: (10 + index / 30).toFixed(6),
+  }));
+  document.streams[0] = {
+    ...document.streams[0],
+    duration: "11.966667",
+    nb_frames: "60",
+    start_time: "10.000000",
+  };
+  const result = parseToolcraftMotionFfprobeJson(JSON.stringify(document));
+  assert.equal(result.frameTimes[0], 0);
+  assert.ok(Math.abs(result.frameTimes.at(-1) - 59 / 30) < 1e-6);
+  assert.ok(Math.abs(result.durationSeconds - 2) < 1e-6);
+});
+
+test("preserves declared trailing duration after the last decoded frame", () => {
+  const document = JSON.parse(probeJson());
+  document.format = { duration: "0.125000", start_time: "0.000000" };
+  document.streams[0].start_time = "0.000000";
+  assert.equal(parseToolcraftMotionFfprobeJson(JSON.stringify(document)).durationSeconds,
+    0.125);
+});
+
+test("rejects malformed probe JSON and missing or invalid visual metadata", () => {
+  assert.throws(() => parseToolcraftMotionFfprobeJson("{"), /valid ffprobe JSON/iu);
+  assert.throws(() => parseToolcraftMotionFfprobeJson(JSON.stringify({
+    frames: [], streams: [{ codec_type: "audio" }],
+  })), /visual stream/iu);
+  assert.throws(() => parseToolcraftMotionFfprobeJson(probeJson({
+    streams: [{ codec_type: "video", height: 0, pix_fmt: "rgb24", width: 640 }],
+  })), /dimensions|height/iu);
+  assert.throws(() => parseToolcraftMotionFfprobeJson(probeJson({
+    frames: [],
+  })), /decoded frame/iu);
+});
+
+test("returns stable domain errors for adversarial nested ffprobe collections", () => {
+  const documents = [];
+  const invalidStreams = JSON.parse(probeJson());
+  invalidStreams.streams = [null, 7, []];
+  documents.push(invalidStreams);
+  const invalidFrames = JSON.parse(probeJson());
+  invalidFrames.frames = [null];
+  documents.push(invalidFrames);
+  const invalidDescriptors = JSON.parse(probeJson());
+  invalidDescriptors.pixel_formats = [null, 7, []];
+  documents.push(invalidDescriptors);
+  const invalidComponents = JSON.parse(probeJson());
+  invalidComponents.pixel_formats[0].components = [null, 7, []];
+  invalidComponents.pixel_formats[0].nb_components = 3;
+  documents.push(invalidComponents);
+
+  for (const document of documents) {
+    assert.throws(() => parseToolcraftMotionFfprobeJson(JSON.stringify(document)),
+      (error) => error instanceof TypeError &&
+        error.message.startsWith("Invalid Toolcraft motion FFmpeg output:"));
+  }
+});
+
+test("falls back from an unavailable average rate to the decoded stream rate", () => {
+  const document = JSON.parse(probeJson());
+  document.streams[0].avg_frame_rate = "0/0";
+  document.streams[0].r_frame_rate = "30000/1001";
+
+  assert.equal(parseToolcraftMotionFfprobeJson(JSON.stringify(document)).nominalFrameRate,
+    30000 / 1001);
+});
+
+test("derives alpha from the exact ffprobe descriptor rather than its name", () => {
+  for (const pixelFormat of ["ayuv64le", "vuya"]) {
+    const document = JSON.parse(probeJson());
+    document.streams[0].pix_fmt = pixelFormat;
+    document.pixel_formats = [pixelFormatDescriptor(pixelFormat)];
+    assert.equal(parseToolcraftMotionFfprobeJson(JSON.stringify(document)).hasAlpha, true);
+  }
+  const nonalpha = JSON.parse(probeJson());
+  nonalpha.streams[0].pix_fmt = "yuv420p10le";
+  nonalpha.pixel_formats = [pixelFormatDescriptor("yuv420p10le", { alpha: false })];
+  assert.equal(parseToolcraftMotionFfprobeJson(JSON.stringify(nonalpha)).hasAlpha, false);
+});
+
+test("rejects missing, duplicate, and structurally mismatched pixel descriptors", () => {
+  assert.throws(() => parseToolcraftMotionFfprobeJson(probeJson({
+    pixel_formats: [],
+  })), /pixel format descriptor/iu);
+  assert.throws(() => parseToolcraftMotionFfprobeJson(probeJson({
+    pixel_formats: [
+      pixelFormatDescriptor("yuva444p"), pixelFormatDescriptor("yuva444p"),
+    ],
+  })), /duplicate.*descriptor/iu);
+  assert.throws(() => parseToolcraftMotionFfprobeJson(probeJson({
+    pixel_formats: [{
+      ...pixelFormatDescriptor("yuva444p"), nb_components: 3,
+    }],
+  })), /component/iu);
+});
+
+test("rejects missing, nonfinite, duplicate, and out-of-order timestamps", () => {
+  const invalidFrames = [
+    [{ best_effort_timestamp_time: "0" }, {}],
+    [{ best_effort_timestamp_time: "0" }, { best_effort_timestamp_time: "NaN" }],
+    [{ best_effort_timestamp_time: "0" }, { best_effort_timestamp_time: "0" }],
+    [{ best_effort_timestamp_time: "0.1" }, { best_effort_timestamp_time: "0.05" }],
+  ];
+  for (const frames of invalidFrames) {
+    assert.throws(() => parseToolcraftMotionFfprobeJson(probeJson({ frames })),
+      /timestamp/iu);
+  }
+});
+
+test("parses complete color and conditional alpha signalstats records", () => {
+  const stdout = [
+    statsRecord(0, "0.000000", { y: 0 }),
+    statsRecord(0, "0.000000", { alpha: 0, channel: "alpha" }),
+    statsRecord(1, "0.033333", { u: 51, v: 12, y: 0 }),
+    statsRecord(1, "0.033333", { alpha: 102, channel: "alpha" }),
+  ].join("\n");
+  const records = parseToolcraftMotionSignalstats(stdout, { requireAlpha: true });
+
+  assert.deepEqual(records, [{
+    alphaDifference: 0,
+    frameIndex: 0,
+    timeSeconds: 0,
+    uDifference: 0,
+    vDifference: 0,
+    yDifference: 0,
+  }, {
+    alphaDifference: 102,
+    frameIndex: 1,
+    timeSeconds: 0.033333,
+    uDifference: 51,
+    vDifference: 12,
+    yDifference: 0,
+  }]);
+  assert.equal(toolcraftMotionAnalysisChangeScore(records[1]), 102 / 255);
+  assert.equal(toolcraftMotionAnalysisChangeScore(records[0]), 0);
+});
+
+test("requires one complete color record and exactly one conditional alpha record", () => {
+  assert.throws(() => parseToolcraftMotionSignalstats(
+    statsRecord(0, "0", { channel: "color", u: 2, y: 1 }).replace(
+      "lavfi.signalstats.VDIF=0", "",
+    ),
+  ), /VDIF/iu);
+  assert.throws(() => parseToolcraftMotionSignalstats(
+    statsRecord(0, "0", { channel: "color", y: 1 }), { requireAlpha: true },
+  ), /alpha/iu);
+  assert.throws(() => parseToolcraftMotionSignalstats([
+    statsRecord(0, "0", { y: 1 }),
+    statsRecord(0, "0", { y: 2 }),
+  ].join("\n")), /duplicate/iu);
+  assert.throws(() => parseToolcraftMotionSignalstats([
+    statsRecord(0, "0", { y: 1 }),
+    statsRecord(2, "0.2", { y: 2 }),
+  ].join("\n")), /missing frame/iu);
+});
+
+test("rejects nonfinite, localized, and out-of-order signalstats values", () => {
+  assert.throws(() => parseToolcraftMotionSignalstats(
+    statsRecord(0, "0", { y: "Infinity" }),
+  ), /finite/iu);
+  assert.throws(() => parseToolcraftMotionSignalstats(
+    statsRecord(0, "0,25", { y: "1,25" }),
+  ), /finite/iu);
+  assert.throws(() => parseToolcraftMotionSignalstats([
+    statsRecord(0, "0.1", { y: 1 }),
+    statsRecord(1, "0.05", { y: 2 }),
+  ].join("\n")), /increasing/iu);
+});
+
+test("normalizes tool versions without volatile build or locale text", () => {
+  assert.equal(normalizeToolcraftMotionToolVersion(
+    "ffmpeg version 8.0.1-2 Copyright (c) 2000-2026 the FFmpeg developers\nconfiguration: --enable-x",
+    "ffmpeg",
+  ), "ffmpeg 8.0.1-2");
+  assert.equal(normalizeToolcraftMotionToolVersion(
+    "ffprobe version n8.0-static built with Apple clang\nBibliotheken-Versionen:",
+    "ffprobe",
+  ), "ffprobe n8.0-static");
+  assert.throws(() => normalizeToolcraftMotionToolVersion("unrelated", "ffmpeg"),
+    /ffmpeg version/iu);
+});
+
+test("requires an exact two-record last-to-first seam", () => {
+  const records = parseToolcraftMotionSignalstats([
+    statsRecord(0, "0", { y: 0 }),
+    statsRecord(1, "1", { u: 51 }),
+  ].join("\n"));
+  assert.equal(createToolcraftMotionLoopSeamScore(2, records), 51 / 255);
+  assert.throws(() => createToolcraftMotionLoopSeamScore(2, records.slice(0, 1)),
+    /exactly two/iu);
+  assert.throws(() => createToolcraftMotionLoopSeamScore(2, [...records, {
+    ...records[1], frameIndex: 2, timeSeconds: 2,
+  }]), /exactly two/iu);
+  assert.throws(() => createToolcraftMotionLoopSeamScore(2, [
+    records[1], records[0],
+  ]), /indices|increasing/iu);
+});