@wenathlan/cadria 2.0.80 → 2.0.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenathlan/cadria",
-  "version": "2.0.80",
+  "version": "2.0.84",
   "repository": {
     "type": "git",
     "url": "https://github.com/wenathlan/devthink"

package/tests/media.probe.test.ts

@@ -0,0 +1,210 @@
+// # media.probe.test — honest unit tests for the container probe, runnable with the
+// node built-in runner (no install, no dependencies):
+//   node --test tests/media.probe.test.ts
+// The fixtures are synthetic MP4 (ISO-BMFF) and WebM (EBML) heads built byte by byte
+// below — no binary files, no canvas, no decoder.
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { probeMedia, ProbeError } from "../media.probe.ts";
+
+/** big-endian u32 bytes. */
+function u32(value: number): number[] {
+  return [(value >>> 24) & 0xff, (value >>> 16) & 0xff, (value >>> 8) & 0xff, value & 0xff];
+}
+
+/** big-endian u16 bytes. */
+function u16(value: number): number[] {
+  return [(value >> 8) & 0xff, value & 0xff];
+}
+
+/** the ascii bytes of a fourcc / CodecID / DocType. */
+function ascii(text: string): number[] {
+  return [...text].map((char) => char.charCodeAt(0));
+}
+
+/** one ISO-BMFF box: size, type, body. */
+function mp4box(type: string, ...body: number[]): number[] {
+  return [...u32(body.length + 8), ...ascii(type), ...body];
+}
+
+/** big-endian float64 bytes (EBML Duration / SamplingFrequency). */
+function f64(value: number): number[] {
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, value);
+  return [...new Uint8Array(view.buffer)];
+}
+
+/** one EBML element: id (with marker), size vint (marker dropped), body. */
+function ebml(id: number[], ...body: number[]): number[] {
+  const size = body.length;
+  const sizeVint = size < 127 ? [0x80 | size] : [0x40 | (size >> 8), size & 0xff];
+  return [...id, ...sizeVint, ...body];
+}
+
+/** EBML element ids the probe walks. */
+const ID = {
+  ebml: [0x1a, 0x45, 0xdf, 0xa3],
+  docType: [0x42, 0x82],
+  segment: [0x18, 0x53, 0x80, 0x67],
+  info: [0x15, 0x49, 0xa9, 0x66],
+  timecodeScale: [0x2a, 0xd7, 0xb1],
+  duration: [0x44, 0x89],
+  tracks: [0x16, 0x54, 0xae, 0x6b],
+  trackEntry: [0xae],
+  trackType: [0x83],
+  codecId: [0x86],
+  video: [0xe0],
+  pixelWidth: [0xb0],
+  pixelHeight: [0xba],
+  audio: [0xe1],
+  samplingFrequency: [0xb5],
+  channels: [0x9f],
+};
+
+/** builds a minimal MP4 head: ftyp + moov(mvhd, video trak, audio trak). */
+function mp4Fixture(): Uint8Array {
+  const ftyp = mp4box("ftyp", ...ascii("isom"), ...u32(512), ...ascii("isom"), ...ascii("mp42"));
+  const mvhd = mp4box(
+    "mvhd",
+    0, 0, 0, 0, // version 0 + flags
+    ...u32(0), ...u32(0), // creation, modification
+    ...u32(1000), ...u32(3200), // timescale, duration → 3.2 s
+    ...new Array<number>(80).fill(0), // rate/volume/matrix/predefined/next track id
+  );
+  const tkhd = (width: number, height: number) =>
+    mp4box(
+      "tkhd",
+      0, 0, 0, 0, // version 0 + flags
+      ...u32(0), ...u32(0), ...u32(1), ...u32(0), ...u32(3200), // ids and duration
+      ...new Array<number>(8).fill(0), ...u16(0), ...u16(0), ...u16(0), ...u16(0),
+      ...new Array<number>(36).fill(0), // matrix
+      ...u32(width * 2 ** 16), ...u32(height * 2 ** 16), // fixed 16.16 extent
+    );
+  const mdhd = (timescale: number, duration: number) =>
+    mp4box("mdhd", 0, 0, 0, 0, ...u32(0), ...u32(0), ...u32(timescale), ...u32(duration), ...u16(0), ...u16(0));
+  const hdlr = (handler: string) => mp4box("hdlr", 0, 0, 0, 0, ...u32(0), ...ascii(handler), 0);
+  const stsd = (entry: number[]) => mp4box("stsd", 0, 0, 0, 0, ...u32(1), ...entry);
+  const avc1 = mp4box(
+    "avc1",
+    ...new Array<number>(6).fill(0), ...u16(1), // reserved, data reference
+    ...u16(0), ...u16(0), ...u32(0), ...u32(0), ...u32(0), // predefined/reserved
+    ...u16(320), ...u16(240), // width, height
+    ...u32(0x00480000), ...u32(0x00480000), ...u32(0), ...u16(1),
+    ...new Array<number>(32).fill(0), ...u16(24), ...u16(0xffff),
+  );
+  const mp4a = mp4box(
+    "mp4a",
+    ...new Array<number>(6).fill(0), ...u16(1),
+    ...u16(0), ...u16(0), ...u32(0), // version, revision, vendor
+    ...u16(2), ...u16(16), ...u16(0), ...u16(0), // channels, sample size
+    ...u32(48000 * 2 ** 16), // sample rate, 16.16 fixed
+  );
+  const trak = (extent: [number, number], timescale: number, duration: number, handler: string, entry: number[]) =>
+    mp4box(
+      "trak",
+      ...tkhd(...extent),
+      ...mp4box("mdia", ...mdhd(timescale, duration), ...hdlr(handler), ...mp4box("minf", ...mp4box("stbl", ...stsd(entry)))),
+    );
+  const moov = mp4box("moov", ...mvhd, ...trak([320, 240], 1000, 3200, "vide", avc1), ...trak([0, 0], 48000, 153600, "soun", mp4a));
+  return Uint8Array.from([...ftyp, ...moov]);
+}
+
+/** builds a minimal WebM head: EBML(DocType) + Segment(Info, Tracks). */
+function webmFixture(): Uint8Array {
+  const header = ebml(ID.ebml, ...ebml(ID.docType, ...ascii("webm")));
+  const info = ebml(ID.info, ...ebml(ID.timecodeScale, ...u32(1_000_000)), ...ebml(ID.duration, ...f64(3200)));
+  const videoTrack = ebml(
+    ID.trackEntry,
+    ...ebml(ID.trackType, 0x01),
+    ...ebml(ID.codecId, ...ascii("V_VP9")),
+    ...ebml(ID.video, ...ebml(ID.pixelWidth, ...u16(320)), ...ebml(ID.pixelHeight, ...u16(240))),
+  );
+  const audioTrack = ebml(
+    ID.trackEntry,
+    ...ebml(ID.trackType, 0x02),
+    ...ebml(ID.codecId, ...ascii("A_OPUS")),
+    ...ebml(ID.audio, ...ebml(ID.samplingFrequency, ...f64(48000)), ...ebml(ID.channels, 0x02)),
+  );
+  const segment = ebml(ID.segment, ...info, ...ebml(ID.tracks, ...videoTrack, ...audioTrack));
+  return Uint8Array.from([...header, ...segment]);
+}
+
+describe("media.probe mp4", () => {
+  const probe = probeMedia(mp4Fixture());
+
+  it("answers the container, brands and movie duration", () => {
+    assert.equal(probe.container, "mp4");
+    assert.equal(probe.brand, "isom");
+    assert.deepEqual(probe.brands, ["isom", "mp42"]);
+    assert.equal(probe.durationSeconds, 3.2);
+  });
+
+  it("answers one row per stream with codec and layout", () => {
+    assert.equal(probe.tracks.length, 2);
+    const [video, audio] = probe.tracks;
+    assert.equal(video.kind, "video");
+    assert.equal(video.codec, "avc1");
+    assert.equal(video.width, 320);
+    assert.equal(video.height, 240);
+    assert.equal(video.durationSeconds, 3.2);
+    assert.equal(audio.kind, "audio");
+    assert.equal(audio.codec, "mp4a");
+    assert.equal(audio.channels, 2);
+    assert.equal(audio.sampleRate, 48000);
+    assert.equal(audio.durationSeconds, 3.2);
+  });
+
+  it("feeds the transcode planner as a source", async () => {
+    const { buildTranscodePlan } = await import("../transcode.plan.ts");
+    const source = {
+      width: probe.tracks[0].width ?? 0,
+      height: probe.tracks[0].height ?? 0,
+      durationSeconds: probe.durationSeconds,
+      fps: 30,
+      videoCodec: probe.tracks[0].codec,
+      audioCodec: probe.tracks[1].codec,
+    };
+    const plan = buildTranscodePlan(source, [
+      { id: "240p", height: 240, videoCodec: "avc1", audioCodec: "mp4a", videoBitrate: "400K", audioBitrate: "64K" },
+    ]);
+    assert.equal(plan.variants[0].width, 320);
+    assert.equal(plan.variants[0].height, 240);
+  });
+});
+
+describe("media.probe webm", () => {
+  const probe = probeMedia(webmFixture());
+
+  it("answers the container, doctype and clock math", () => {
+    assert.equal(probe.container, "webm");
+    assert.equal(probe.brand, "webm");
+    assert.equal(probe.durationSeconds, 3.2);
+  });
+
+  it("answers both tracks with their EBML codecs and layouts", () => {
+    assert.equal(probe.tracks.length, 2);
+    const [video, audio] = probe.tracks;
+    assert.equal(video.codec, "V_VP9");
+    assert.equal(video.width, 320);
+    assert.equal(video.height, 240);
+    assert.equal(audio.codec, "A_OPUS");
+    assert.equal(audio.sampleRate, 48000);
+    assert.equal(audio.channels, 2);
+  });
+});
+
+describe("media.probe errors", () => {
+  it("rejects buffers too small to probe", () => {
+    assert.throws(() => probeMedia(new Uint8Array(8)), ProbeError);
+  });
+
+  it("rejects unknown containers with a typed error", () => {
+    assert.throws(() => probeMedia(new Uint8Array(64)), ProbeError);
+  });
+
+  it("rejects truncated box structure", () => {
+    const ftyp = mp4box("ftyp", ...ascii("isom"), ...u32(512));
+    const truncated = Uint8Array.from([...ftyp.slice(0, 10)]);
+    assert.throws(() => probeMedia(truncated), ProbeError);
+  });
+});

package/tests/transcode.plan.test.ts

@@ -0,0 +1,136 @@
+// # transcode.plan.test — honest unit tests for the transcode planner, runnable with
+// the node built-in runner (no install, no dependencies):
+//   node --test tests/transcode.plan.test.ts
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  buildTranscodePlan,
+  estimateVariantBytes,
+  evenDimension,
+  parseBitrate,
+  TranscodeError,
+  validateRung,
+  type SourceMedia,
+  type TranscodeRung,
+} from "../transcode.plan.ts";
+
+/** The probed source the plan tests build from (the media.probe.ts shape). */
+const SOURCE: SourceMedia = {
+  width: 1920,
+  height: 1080,
+  durationSeconds: 60,
+  fps: 30,
+  videoCodec: "avc1",
+  audioCodec: "mp4a",
+};
+
+/** A mixed ladder: one too tall for the source, one vp9 webm rung, an fps cap. */
+const LADDER: TranscodeRung[] = [
+  { id: "2160p", height: 2160, videoCodec: "avc1", audioCodec: "mp4a", videoBitrate: "16M", audioBitrate: "192K" },
+  { id: "1080p", height: 1080, videoCodec: "avc1", audioCodec: "mp4a", videoBitrate: "4M", audioBitrate: "128K" },
+  { id: "720p", height: 720, videoCodec: "avc1", audioCodec: "mp4a", videoBitrate: "2500K", audioBitrate: "96K", fps: 24 },
+  { id: "480p", height: 480, videoCodec: "vp09", audioCodec: "opus", videoBitrate: "1M", audioBitrate: "64K" },
+];
+
+describe("transcode.plan bitrates", () => {
+  it("parses the renderer spellings into bps", () => {
+    assert.equal(parseBitrate("4M"), 4_000_000);
+    assert.equal(parseBitrate("2500K"), 2_500_000);
+    assert.equal(parseBitrate("800k"), 800_000);
+  });
+
+  it("rejects bare numbers, missing suffixes and junk", () => {
+    assert.throws(() => parseBitrate(4_000_000 as unknown as string), TranscodeError);
+    assert.throws(() => parseBitrate("4000000"), TranscodeError);
+    assert.throws(() => parseBitrate("4G"), TranscodeError);
+    assert.throws(() => parseBitrate("0M"), TranscodeError);
+  });
+
+  it("floors dimensions onto even values the MPEG encoders demand", () => {
+    assert.equal(evenDimension(853.33), 852);
+    assert.equal(evenDimension(1920), 1920);
+    assert.equal(evenDimension(1), 2);
+  });
+});
+
+describe("transcode.plan validation", () => {
+  it("names the failing rung in every thrown error", () => {
+    assert.throws(
+      () => validateRung({ ...LADDER[1], height: 0 }),
+      (error: unknown) => error instanceof TranscodeError && error.message.includes('"1080p"'),
+    );
+    assert.throws(
+      () => validateRung({ ...LADDER[1], videoBitrate: "4" }),
+      (error: unknown) => error instanceof TranscodeError && error.message.includes('"1080p"'),
+    );
+    assert.throws(
+      () => validateRung({ ...LADDER[1], fps: -1 }),
+      (error: unknown) => error instanceof TranscodeError && error.message.includes('"1080p"'),
+    );
+    assert.throws(
+      () => validateRung({ ...LADDER[1], videoCodec: "not a codec" }),
+      (error: unknown) => error instanceof TranscodeError && error.message.includes('"1080p"'),
+    );
+  });
+
+  it("rejects broken sources and ladders before any variant is built", () => {
+    assert.throws(() => buildTranscodePlan({ ...SOURCE, height: 0 }, LADDER), TranscodeError);
+    assert.throws(() => buildTranscodePlan({ ...SOURCE, durationSeconds: 0 }, LADDER), TranscodeError);
+    assert.throws(() => buildTranscodePlan(SOURCE, []), TranscodeError);
+    assert.throws(() => buildTranscodePlan(SOURCE, [LADDER[1], { ...LADDER[1], height: 540 }]), TranscodeError);
+  });
+
+  it("answers the size estimate from the bitrates and the duration", () => {
+    assert.equal(estimateVariantBytes("4M", "128K", 60), 30_960_000);
+    assert.equal(estimateVariantBytes("1M", "64K", 10), 1_330_000);
+  });
+});
+
+describe("transcode.plan planner", () => {
+  it("builds the runnable variants: never upscales, orders highest-first", () => {
+    const plan = buildTranscodePlan(SOURCE, LADDER);
+    assert.deepEqual(
+      plan.variants.map((variant) => variant.rung.id),
+      ["1080p", "720p", "480p"],
+    );
+    assert.equal(plan.variants.length, 3);
+  });
+
+  it("keeps the aspect, even dimensions and the codec-native container", () => {
+    const plan = buildTranscodePlan(SOURCE, LADDER);
+    const [top, , low] = plan.variants;
+    assert.equal(top.width, 1920);
+    assert.equal(top.height, 1080);
+    assert.equal(top.container, "mp4");
+    assert.equal(low.width, 852, "1920×480/1080 floors onto the even 852");
+    assert.equal(low.height, 480);
+    assert.equal(low.container, "webm", "vp09 defaults to webm");
+  });
+
+  it("caps the fps by the rung and clamps by the source fps", () => {
+    const plan = buildTranscodePlan(SOURCE, LADDER);
+    assert.equal(plan.variants[0].fps, 30);
+    assert.equal(plan.variants[1].fps, 24);
+  });
+
+  it("estimates the bytes per variant and the plan total", () => {
+    const plan = buildTranscodePlan(SOURCE, LADDER);
+    assert.equal(plan.variants[0].estimatedBytes, 30_960_000);
+    assert.equal(plan.estimatedBytes, plan.variants.reduce((sum, variant) => sum + variant.estimatedBytes, 0));
+  });
+
+  it("keeps the top of the ladder under maxRungs", () => {
+    const plan = buildTranscodePlan(SOURCE, LADDER, { maxRungs: 2 });
+    assert.deepEqual(
+      plan.variants.map((variant) => variant.rung.id),
+      ["1080p", "720p"],
+    );
+  });
+
+  it("throws a traceable error when no rung fits the source", () => {
+    assert.throws(
+      () => buildTranscodePlan({ ...SOURCE, height: 360 }, [LADDER[0], LADDER[1]]),
+      (error: unknown) => error instanceof TranscodeError && error.message.includes("no rung fits"),
+    );
+  });
+});

package/tests/visualize.test.ts

@@ -0,0 +1,179 @@
+// # visualize.test — honest unit tests for the visualize library, runnable with the
+// node built-in runner (no canvas, no dependencies, no install):
+//   node --test tests/visualize.test.ts
+// The fixture is a synthetic grayscale gradient buffer shaped like ImageData.
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { gridDimensions } from "../visualize.mesh.ts";
+import { boundingBox, faceNormal, normalizedScale, vertexNormals } from "../visualize.normals.ts";
+import { materialSummary, vertexColors } from "../visualize.material.ts";
+import { visualize, VisualizeError, type ImageInput } from "../visualize.ts";
+
+/** builds a w×h grayscale horizontal ramp (left black, right white, alpha full). */
+function gradientImage(width: number, height: number): ImageInput {
+  const data = new Uint8ClampedArray(width * height * 4);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const index = (y * width + x) * 4;
+      const value = Math.round((255 * x) / (width - 1));
+      data[index] = value;
+      data[index + 1] = value;
+      data[index + 2] = value;
+      data[index + 3] = 255;
+    }
+  }
+  return { width, height, data };
+}
+
+describe("visualize pipeline", () => {
+  const image = gradientImage(8, 6);
+
+  it("counts vertices and indices for a decimated grid", () => {
+    const result = visualize(image, { depth: 10, step: 2, colors: false, normals: false });
+    const { columns, rows } = gridDimensions(8, 6, 2);
+    assert.equal(columns, 4);
+    assert.equal(rows, 3);
+    assert.equal(result.mesh.vertices.length, columns * rows * 3);
+    assert.equal(result.mesh.vertices.length / 3, 12);
+    assert.equal(result.mesh.indices.length, (columns - 1) * (rows - 1) * 6);
+    assert.equal(result.mesh.indices.length / 3, 12);
+    assert.equal(result.mesh.depth, 10);
+  });
+
+  it("extrudes heights by depth and keeps image-space x/y", () => {
+    const result = visualize(image, { depth: 10, step: 2 });
+    const lastVertex = (result.mesh.vertices.length / 3 - 1) * 3;
+    // bottom-right vertex: x = 6, y = 4, z = luminance(6/7) * 10 — within 8-bit
+    // quantization of the synthetic ramp (byte 219 instead of 218.57)
+    assert.equal(result.mesh.vertices[lastVertex], 6);
+    assert.equal(result.mesh.vertices[lastVertex + 1], 4);
+    assert.ok(Math.abs(result.mesh.vertices[lastVertex + 2] - (6 / 7) * 10) < 0.05);
+  });
+
+  it("exports OBJ that starts with a vertex and carries faces", () => {
+    const result = visualize(image, { depth: 10, step: 2 });
+    const obj = result.toObj();
+    assert.ok(obj.startsWith("v "), `expected OBJ to start with "v ", got: ${obj.slice(0, 12)}`);
+    assert.ok(obj.includes("\nf "), "expected OBJ to contain face lines");
+    const faceLines = obj.split("\n").filter((line) => line.startsWith("f "));
+    assert.equal(faceLines.length, 12);
+  });
+
+  it("exports OBJ with vertex colors in the v lines when colors are on", () => {
+    const result = visualize(image, { depth: 10, step: 2 });
+    const first = result.toObj().split("\n")[0];
+    assert.ok(first.startsWith("v "));
+    assert.equal(first.split(" ").length, 7, `expected "v x y z r g b", got: ${first}`);
+  });
+
+  it("exports STL ASCII with facet normals", () => {
+    const result = visualize(image, { depth: 10, step: 2 });
+    const stl = result.toStl();
+    assert.ok(stl.startsWith("solid cadria-visualize"));
+    assert.ok(stl.includes("facet normal"));
+    assert.ok(stl.includes("vertex"));
+    assert.ok(stl.endsWith("endsolid cadria-visualize"));
+    assert.equal(stl.split("facet normal").length - 1, 12);
+  });
+
+  it("exports binary STL with the documented byte layout", () => {
+    const result = visualize(image, { depth: 10, step: 2, colors: false, normals: false });
+    const bytes = result.toStlBinary();
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    assert.equal(bytes.byteLength, 84 + 12 * 50);
+    assert.equal(view.getUint32(80, true), 12);
+    const normalY = view.getFloat32(84 + 4, true);
+    assert.ok(Math.abs(normalY) <= 1, "facet normal must be normalized");
+  });
+
+  it("computes unit-length vertex normals", () => {
+    const result = visualize(image, { depth: 10, step: 2 });
+    const normals = result.normals;
+    assert.ok(normals, "expected normals by default");
+    assert.equal(normals.length, result.mesh.vertices.length);
+    for (let offset = 0; offset < normals.length; offset += 3) {
+      const length = Math.hypot(normals[offset], normals[offset + 1], normals[offset + 2]);
+      assert.ok(Math.abs(length - 1) < 1e-6, `normal ${offset / 3} is not unit: ${length}`);
+    }
+  });
+
+  it("keeps vertex colors within [0, 1]", () => {
+    const result = visualize(image, { depth: 10, step: 2 });
+    const colors = result.colors;
+    assert.ok(colors, "expected colors by default");
+    assert.equal(colors.length, 12 * 3);
+    for (const channel of colors) {
+      assert.ok(channel >= 0 && channel <= 1, `color channel out of range: ${channel}`);
+    }
+  });
+
+  it("minHeight carves holes into the low end of the gradient", () => {
+    const full = visualize(image, { depth: 10, colors: false, normals: false });
+    const cut = visualize(image, { depth: 10, minHeight: 0.5, colors: false, normals: false });
+    assert.ok(cut.mesh.indices.length > 0, "high half of the gradient must survive");
+    assert.ok(cut.mesh.indices.length < full.mesh.indices.length, "low half must be carved away");
+  });
+
+  it("blurRadius changes the heightmap", () => {
+    const sharp = visualize(image, { depth: 10, colors: false, normals: false });
+    const blurred = visualize(image, { depth: 10, blurRadius: 2, colors: false, normals: false });
+    let differs = false;
+    for (let i = 0; i < sharp.mesh.vertices.length; i++) {
+      if (sharp.mesh.vertices[i] !== blurred.mesh.vertices[i]) {
+        differs = true;
+        break;
+      }
+    }
+    assert.ok(differs, "blur must move vertices");
+  });
+
+  it("reports stats with counts and material summary", () => {
+    const result = visualize(image, { depth: 10, step: 2 });
+    const stats = result.stats();
+    assert.equal(stats.vertices, 12);
+    assert.equal(stats.triangles, 12);
+    assert.equal(stats.columns, 4);
+    assert.equal(stats.rows, 3);
+    assert.equal(stats.hasColors, true);
+    assert.equal(stats.hasNormals, true);
+    assert.ok(stats.material);
+    assert.equal(stats.material.minLuminance, 0);
+    assert.ok(Math.abs(stats.material.maxLuminance - 1) < 0.01);
+  });
+
+  it("rejects buffers that do not match the dimensions", () => {
+    assert.throws(() => visualize({ width: 2, height: 2, data: new Uint8ClampedArray(4) }), VisualizeError);
+    assert.throws(() => visualize(image, { step: 0 }), VisualizeError);
+  });
+
+  it("survives a decimation step larger than the image", () => {
+    const result = visualize(image, { depth: 10, step: 100, colors: false, normals: false });
+    assert.equal(result.stats().vertices, 1);
+    assert.equal(result.stats().triangles, 0);
+  });
+});
+
+describe("visualize geometry and material helpers", () => {
+  const image = gradientImage(8, 6);
+
+  it("averages adjacent face normals into vertex normals", () => {
+    const result = visualize(image, { depth: 10, step: 2, normals: false });
+    const normals = vertexNormals(result.mesh);
+    const flat = faceNormal(result.mesh.vertices, 0, 1, result.mesh.columns + 1);
+    assert.ok(flat);
+    // the first vertex only sees up-facing triangles of the same slope family
+    assert.ok(Math.abs(normals[2] - flat[2]) < 0.2);
+  });
+
+  it("bounding box, center scale and color grid agree with the mesh", () => {
+    const result = visualize(image, { depth: 10, step: 2 });
+    const box = boundingBox(result.mesh.vertices);
+    assert.equal(box.min[0], 0);
+    assert.equal(box.max[0], 6);
+    assert.ok(normalizedScale(result.mesh.vertices, 2) > 0);
+    const colors = vertexColors(image, result.mesh.columns, result.mesh.rows, 2);
+    assert.equal(colors.length, result.mesh.vertices.length);
+    const summary = materialSummary(image);
+    assert.ok(summary.average[0] > 0.4 && summary.average[0] < 0.6, "ramp average sits near mid gray");
+  });
+});