@wenathlan/cadria 2.0.94 → 2.0.117

package/tests/versawaseanimate.test.ts

@@ -0,0 +1,106 @@
+// # versawaseanimate.test — the engine's animation sampler, runnable with vitest:
+//   pnpm vitest run tests/versawaseanimate.test.ts
+// Every test watches the promise the sampler makes: tracks resolve by target,
+// defaults hold for untouched channels, sampling lerps inside keys, the scene
+// span wraps long plays, and the world transform accumulates the parent chain
+// without hanging on a cyclic graph.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import {
+  sampleNode,
+  sampleSceneAt,
+  tracksByTarget,
+  worldTransform,
+  wrapSeconds,
+} from "../versawaseanimate.ts";
+import type { Scene3d } from "../versawase.ts";
+
+const SCENE: Scene3d = {
+  id: "scene-arm",
+  name: "arm rig",
+  fps: 30,
+  nodes: [
+    { id: "arm", kind: "group", name: "arm", parent: "" },
+    { id: "hand", kind: "mesh", name: "hand", parent: "arm" },
+  ],
+  tracks: [
+    { id: "pos-x", target: "arm", channel: "position", keys: [0, 2], values: [0, 10], loop: true },
+    { id: "scl-x", target: "hand", channel: "scale", keys: [0, 1], values: [1, 2], loop: false },
+    { id: "opa", target: "hand", channel: "opacity", keys: [0, 1], values: [1, 0], loop: false },
+    { id: "rot-y", target: "hand", channel: "rotation", keys: [0, 4], values: [0, 90], loop: false },
+  ],
+};
+
+describe("versawaseanimate", () => {
+  it("collects the tracks that target one node", () => {
+    const tracks = tracksByTarget(SCENE, "hand");
+    assert.deepEqual(tracks.map((track) => track.id), ["scl-x", "opa", "rot-y"]);
+    assert.equal(tracksByTarget(SCENE, "ghost").length, 0);
+  });
+
+  it("keeps untouched channels on their defaults", () => {
+    const bare = { id: "bare", kind: "mesh" as const, name: "bare", parent: "" };
+    const snapshot = sampleNode({ ...SCENE, tracks: [] }, bare, 1);
+    assert.deepEqual(snapshot.position, { x: 0, y: 0, z: 0 });
+    assert.deepEqual(snapshot.scale, { x: 1, y: 1, z: 1 });
+    assert.equal(snapshot.opacity, 1);
+    assert.equal(snapshot.morph, 0);
+  });
+
+  it("lerps inside the keys and rides the axis suffix", () => {
+    const arm = SCENE.nodes[0];
+    const snapshot = sampleNode(SCENE, arm, 1);
+    assert.equal(snapshot.position.x, 5);
+    assert.equal(snapshot.position.y, 0);
+  });
+
+  it("samples the whole scene at one instant", () => {
+    const snapshots = sampleSceneAt(SCENE, 1);
+    assert.equal(snapshots.size, 2);
+    assert.equal(snapshots.get("arm")?.position.x, 5);
+    assert.equal(snapshots.get("hand")?.scale.x, 2);
+    assert.equal(snapshots.get("hand")?.opacity, 0);
+    assert.equal(snapshots.get("hand")?.rotation.y, 22.5);
+  });
+
+  it("wraps long plays into the authored span", () => {
+    assert.equal(wrapSeconds(1, 4), 1);
+    assert.equal(wrapSeconds(6, 4), 2);
+    assert.equal(wrapSeconds(-1, 4), 0);
+    assert.equal(wrapSeconds(6, 0), 6);
+    const snapshots = sampleSceneAt(SCENE, 6);
+    // span is 4 (the rot-y keys); t=6 rides t=2, where the looping arm
+    // position returns to its first key value per the trackValueAt contract.
+    assert.equal(snapshots.get("arm")?.position.x, 0);
+  });
+
+  it("accumulates the parent chain into the world transform", () => {
+    const world = worldTransform(SCENE, "hand", 1);
+    assert.equal(world.position.x, 5);
+    assert.equal(world.scale.x, 2);
+    assert.equal(world.rotation.y, 22.5);
+    const root = worldTransform(SCENE, "arm", 1);
+    assert.equal(root.position.x, 5);
+    assert.equal(root.scale.x, 1);
+  });
+
+  it("cuts a cyclic parent graph at the first revisit", () => {
+    const cyclic: Scene3d = {
+      ...SCENE,
+      nodes: [
+        { id: "arm", kind: "group", name: "arm", parent: "hand" },
+        { id: "hand", kind: "mesh", name: "hand", parent: "arm" },
+      ],
+    };
+    const world = worldTransform(cyclic, "arm", 1);
+    assert.equal(world.scale.x, 2);
+    assert.equal(world.position.x, 5);
+  });
+
+  it("answers an empty scene with an empty snapshot map", () => {
+    const empty: Scene3d = { id: "empty", name: "empty", fps: 30, nodes: [], tracks: [] };
+    assert.equal(sampleSceneAt(empty, 5).size, 0);
+    const world = worldTransform(empty, "ghost", 5);
+    assert.deepEqual(world.scale, { x: 1, y: 1, z: 1 });
+  });
+});

package/tests/versawasescheduler.test.ts

@@ -0,0 +1,96 @@
+// # versawasescheduler.test — the engine's render-job scheduler, runnable with
+// vitest: pnpm vitest run tests/versawasescheduler.test.ts
+// Every test watches the promise the scheduler makes: the plan skips non-queued
+// jobs, lands every job on the least-loaded slot with ties riding the lowest
+// index, counts 3d frames through the renderJobFrames primitive, and the status
+// machine answers null on every illegal transition.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import {
+  completeJob,
+  failJob,
+  planSchedule,
+  queueCensus,
+  slotLoads,
+  startJob,
+} from "../versawasescheduler.ts";
+import type { RenderJob } from "../versawase.ts";
+
+const job = (id: string, frames: number, status: RenderJob["status"] = "queued"): RenderJob => ({
+  id,
+  kind: "3d",
+  status,
+  frameFrom: 0,
+  frameTo: frames / 30,
+});
+
+const imageJob = (id: string, status: RenderJob["status"] = "queued"): RenderJob => ({
+  id,
+  kind: "image",
+  status,
+});
+
+describe("versawasescheduler", () => {
+  it("plans queued jobs onto the least-loaded slot, ties ride the lowest index", () => {
+    const plan = planSchedule([job("a", 30), job("b", 30), job("c", 30)], 30, 2);
+    assert.equal(plan.length, 3);
+    assert.deepEqual(plan.map((entry) => entry.slot), [0, 1, 0]);
+    assert.deepEqual(plan.map((entry) => entry.order), [1, 1, 2]);
+    assert.equal(plan[2].startLoad, 30);
+  });
+
+  it("counts frames through the renderJobFrames primitive", () => {
+    const plan = planSchedule([job("long", 90)], 30, 1);
+    assert.equal(plan[0].frames, 90);
+    const image = planSchedule([imageJob("still")], 30, 1);
+    assert.equal(image[0].frames, 1);
+  });
+
+  it("skips jobs that already left the queue", () => {
+    const plan = planSchedule(
+      [job("done", 30, "ready"), job("running", 30, "rendering"), job("broken", 30, "failed"), imageJob("next")],
+      30,
+      2,
+    );
+    assert.equal(plan.length, 1);
+    assert.equal(plan[0].job.id, "next");
+  });
+
+  it("never answers an empty plan for an empty queue and guards the slot count", () => {
+    assert.equal(planSchedule([], 30, 4).length, 0);
+    const plan = planSchedule([imageJob("only")], 30, 0);
+    assert.equal(plan[0].slot, 0);
+  });
+
+  it("sums the slot loads after planning", () => {
+    const entries = planSchedule([job("a", 60), job("b", 30)], 30, 2);
+    assert.deepEqual(slotLoads(entries, 2), [60, 30]);
+    assert.deepEqual(slotLoads([], 3), [0, 0, 0]);
+  });
+
+  it("rides the pure status machine and refuses illegal transitions", () => {
+    const queued = imageJob("q");
+    const running = startJob(queued);
+    assert.equal(running?.status, "rendering");
+    assert.equal(running?.tone, "info");
+    assert.equal(completeJob(queued), null);
+    const ready = completeJob(running as RenderJob);
+    assert.equal(ready?.status, "ready");
+    assert.equal(ready?.tone, "success");
+    assert.equal(startJob(ready as RenderJob), null);
+    const failed = failJob(running as RenderJob);
+    assert.equal(failed?.status, "failed");
+    assert.equal(failJob(ready as RenderJob), null);
+  });
+
+  it("censuses the queue in one pass", () => {
+    const census = queueCensus([
+      imageJob("a"),
+      imageJob("b"),
+      job("c", 30, "rendering"),
+      job("d", 30, "ready"),
+      job("e", 30, "failed"),
+    ]);
+    assert.deepEqual(census, { queued: 2, rendering: 1, ready: 1, failed: 1 });
+  });
+});

package/tests/versawaseslices.test.ts

@@ -0,0 +1,75 @@
+// # versawaseslices.test — the sliced-render planner (F-CAD-027), runnable with
+// vitest: pnpm vitest run tests/versawaseslices.test.ts
+// Every test watches the promise the planner makes: slices land on the frame
+// grid with exact tick windows, the last slice carries the remainder, the
+// preview seek rides the same grid, progress weighs frames (never slice count)
+// and the wall-clock estimate pays the slowest worker.
+import assert from "node:assert/strict";
+import { describe, it } from "vitest";
+import { estimateWallClock, planSlices, sliceAt, sliceProgress } from "../versawaseslices.ts";
+import { TICKS_PER_SECOND, tickofframe } from "../timeticks.ts";
+
+describe("versawaseslices", () => {
+  it("cuts 35s at 24fps into four 10s frame-aligned slices", () => {
+    const slices = planSlices({ durationSeconds: 35, fps: 24 });
+    assert.equal(slices.length, 4);
+    assert.deepEqual(slices.map((slice) => slice.frames), [240, 240, 240, 360 - 240]);
+    assert.equal(slices[0].fromFrame, 0);
+    assert.equal(slices[0].toFrame, 240);
+    assert.equal(slices[3].toFrame, 840);
+  });
+
+  it("answers exact tick windows that ride tickofframe", () => {
+    const slices = planSlices({ durationSeconds: 10, fps: 24 });
+    assert.equal(slices[0].fromTick, 0);
+    assert.equal(slices[0].toTick, tickofframe({ num: 24, den: 1 }, 240));
+    assert.ok(slices[0].toTick > 0 && slices[0].toTick < TICKS_PER_SECOND * 11);
+  });
+
+  it("carries the remainder in the last slice and guards the max", () => {
+    const slices = planSlices({ durationSeconds: 12.5, fps: 30, sliceSeconds: 10 });
+    assert.equal(slices.length, 2);
+    assert.equal(slices[1].frames, 375 - 300);
+    const capped = planSlices({ durationSeconds: 60, fps: 30, maxSlices: 2 });
+    assert.equal(capped.length, 2);
+    assert.deepEqual(capped.map((slice) => slice.frames), [900, 900]);
+  });
+
+  it("maps a preview seek to the slice that owns the instant", () => {
+    const slices = planSlices({ durationSeconds: 35, fps: 24 });
+    assert.equal(sliceAt(slices, 0)?.index, 0);
+    assert.equal(sliceAt(slices, 12)?.index, 1);
+    assert.equal(sliceAt(slices, 34.9)?.index, 3);
+    assert.equal(sliceAt(slices, 40), undefined);
+    assert.equal(sliceAt([], 1), undefined);
+  });
+
+  it("weighs progress by frames, never by slice count", () => {
+    const slices = planSlices({ durationSeconds: 35, fps: 24 });
+    const total = 840;
+    assert.equal(sliceProgress(slices, []), 0);
+    assert.ok(Math.abs(sliceProgress(slices, [0]) - 240 / total) < 1e-12);
+    assert.equal(sliceProgress(slices, [0, 1, 2, 3]), 1);
+    // the short final slice weighs less than a full one
+    const shortOnly = sliceProgress(slices, [3]);
+    const fullOnly = sliceProgress(slices, [0]);
+    assert.ok(shortOnly < fullOnly);
+  });
+
+  it("pays the slowest worker in the honest estimate", () => {
+    const slices = planSlices({ durationSeconds: 40, fps: 24 });
+    // 4 slices of 240 frames; 2 workers ride 2 slices each — equal lanes.
+    assert.equal(estimateWallClock(slices, 0.01, 2), 480 * 0.01);
+    // 1 worker carries everything.
+    assert.equal(estimateWallClock(slices, 0.01, 1), 960 * 0.01);
+    assert.equal(estimateWallClock([], 0.01, 4), 0);
+  });
+
+  it("answers empty plans and defaults with engine defaults", () => {
+    assert.deepEqual(planSlices({ durationSeconds: 0 }), []);
+    assert.deepEqual(planSlices({ durationSeconds: 5, sliceSeconds: 0 }), []);
+    const single = planSlices({ durationSeconds: 2 });
+    assert.equal(single.length, 1);
+    assert.equal(single[0].frames, 48); // 2s at the default 24fps
+  });
+});

package/tests/visualize.test.ts

@@ -1,13 +1,13 @@
-// # 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
+// # visualize.test — honest unit tests for the visualize library, runnable
+// with vitest (no canvas):
+//   pnpm vitest run 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 { describe, it } from "vitest";
+import { type ImageInput, VisualizeError, visualize } from "../visualize.ts";
+import { materialSummary, vertexColors } from "../visualizematerial.ts";
 import { gridDimensions } from "../visualizemesh.ts";
 import { boundingBox, faceNormal, normalizedScale, vertexNormals } from "../visualizenormals.ts";
-import { materialSummary, vertexColors } from "../visualizematerial.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 {