Back to Nappakura
SOURCE / PINNED RELEASE

Made of little things.

Nappakura

Release
a75ca0f8b596…
Author-recorded commit
4463126213fa…
License
LICENSE
Author’s source reference
nostr://npub182jczunncwe0jn6frpqwq3e0qjws7yqqnc3auccqv9nte2dnd63scjm4rf/wss%3A%2F%2Fgit.napplet.soy%2F/n-8db03001b62

Archive hash verified: b448d77b767ae754…. The source-to-build association is the author’s claim; it has not been independently rebuilt.

tests/geometry.test.mjs
import test from 'node:test';
import assert from 'node:assert/strict';
import { readFile, mkdir, writeFile } from 'node:fs/promises';
import ts from 'typescript';
const dir = new URL('../.napplet-space/geometry-test/', import.meta.url);
await mkdir(dir, { recursive: true });
for (const name of [
  'mesh',
  'depth-renderer',
  'gizmo',
  'unfold',
  'pdf',
  'modelling',
  'project',
  'commands',
]) {
  const source = await readFile(new URL(`../src/${name}.ts`, import.meta.url), 'utf8');
  await writeFile(
    new URL(`${name}.js`, dir),
    ts.transpileModule(source, {
      compilerOptions: {
        target: ts.ScriptTarget.ES2022,
        module: ts.ModuleKind.ESNext,
      },
    }).outputText,
  );
}
const { parseModel, makeMesh, demoMesh, distance, overlaps } = await import(
  new URL('mesh.js', dir)
);
const { newPattern, unfold, toggleSeam, drawPiece, planTabs, printIssues, pack, DEFAULT_SETTINGS } =
  await import(new URL('unfold.js', dir));
const { createPDF } = await import(new URL('pdf.js', dir));
const { serialize, deserialize } = await import(new URL('project.js', dir));
const bytes = (s) => new TextEncoder().encode(s);
const cube = `v -1 -1 -1\nv 1 -1 -1\nv 1 1 -1\nv -1 1 -1\nv -1 -1 1\nv 1 -1 1\nv 1 1 1\nv -1 1 1\nf 1 4 3 2\nf 5 6 7 8\nf 1 2 6 5\nf 2 3 7 6\nf 3 4 8 7\nf 4 1 5 8\n`;

test('OBJ polygons, negative indices, STL ASCII and binary produce equivalent welded geometry', () => {
  const model = parseModel(bytes(cube), 'cube.obj');
  assert.equal(model.faces.length, 12);
  assert.equal(model.vertices.length, 8);
  assert.equal(model.edges.filter((e) => e.faces.length !== 2).length, 0);
  const obj = parseModel(bytes('v 0 0 0\nv 1 0 0\nv 0 1 0\nf -3/1 -2/2 -1/3'), 'negative.obj');
  assert.equal(obj.faces.length, 1);
  const ascii =
    'solid t\nfacet normal 0 0 1\nouter loop\nvertex 0 0 0\nvertex 1 0 0\nvertex 0 1 0\nendloop\nendfacet\nendsolid t';
  const stl = parseModel(bytes(ascii), 'a.stl');
  assert.deepEqual(stl.faces, obj.faces);
  const binary = new Uint8Array(134),
    view = new DataView(binary.buffer);
  binary.set(bytes('solid but binary'));
  view.setUint32(80, 1, true);
  view.setFloat32(108, 1, true);
  view.setFloat32(124, 1, true);
  const bin = parseModel(binary, 'binary.stl');
  assert.deepEqual(bin.vertices, obj.vertices);
});
test('concave OBJ polygon is triangulated with conserved area', () => {
  const model = parseModel(
    bytes('v 0 0 0\nv 2 0 0\nv 2 2 0\nv 1 1 0\nv 0 2 0\nf 1 2 3 4 5'),
    'concave.obj',
  );
  assert.equal(model.faces.length, 3);
  const area = model.faces.reduce((s, f) => {
    const [a, b, c] = f.map((i) => model.vertices[i]);
    return s + Math.abs((b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])) / 2;
  }, 0);
  assert.ok(Math.abs(area - 0.75) < 1e-9);
});
test('malformed models fail explicitly, degenerate faces are reported', () => {
  assert.throws(() => parseModel(bytes('v 0 0 0\nf 1 2 3'), 'broken.obj'), /missing vertex/);
  assert.throws(
    () => parseModel(bytes('v NaN 0 0\nv 1 0 0\nv 0 1 0\nf 1 2 3'), 'broken.obj'),
    /invalid coordinates/,
  );
  assert.throws(() => parseModel(new Uint8Array(84), 'bad.stl'), /no polygon|truncated/);
  const m = makeMesh(
    [
      [0, 0, 0],
      [1, 0, 0],
      [0, 1, 0],
    ],
    [
      [0, 1, 2],
      [0, 0, 1],
    ],
    'degenerate',
  );
  assert.equal(m.faces.length, 1);
  assert.ok(m.warnings.some((w) => w.includes('degenerate')));
});
test('unfolding preserves every triangle edge length without face overlaps', () => {
  for (const model of [parseModel(bytes(cube), 'cube.obj'), demoMesh()]) {
    const result = unfold(model);
    assert.equal(result.pieces.flatMap((p) => p.faces).length, model.faces.length);
    assert.equal(result.joined.length, model.faces.length - result.pieces.length);
    for (const piece of result.pieces) {
      for (const flat of piece.faces)
        for (let i = 0; i < 3; i++) {
          const expected = distance(
              model.vertices[model.faces[flat.face][i]],
              model.vertices[model.faces[flat.face][(i + 1) % 3]],
            ),
            a = flat.points[i],
            b = flat.points[(i + 1) % 3];
          assert.ok(Math.abs(expected - Math.hypot(a[0] - b[0], a[1] - b[1])) < 1e-8);
        }
      for (let i = 0; i < piece.faces.length; i++)
        for (let j = 0; j < i; j++)
          assert.equal(overlaps(piece.faces[i].points, piece.faces[j].points), false);
    }
  }
});
test('cut and rejoin are reversible; cycles are rejected without changing the pattern', () => {
  const m = demoMesh(),
    p = newPattern(m),
    n = p.pieces.length,
    e = p.joined[0];
  toggleSeam(m, p, e);
  assert.equal(p.pieces.length, n + 1);
  toggleSeam(m, p, e);
  assert.equal(p.pieces.length, n);
  const samePieceCut = m.edges.find(
    (e) =>
      !p.joined.includes(e.id) &&
      e.faces.length === 2 &&
      p.pieces.some((piece) => e.faces.every((fi) => piece.faces.some((f) => f.face === fi))),
  );
  if (samePieceCut) {
    const before = JSON.stringify(p);
    assert.throws(() => toggleSeam(m, p, samePieceCut.id), /cycle|overlap/);
    assert.equal(JSON.stringify(p), before);
  }
});
test('tab ownership is unique and face intersections are prevented', () => {
  const m = demoMesh(),
    p = newPattern(m);
  let tabs = 0;
  for (const piece of p.pieces) {
    const d = drawPiece(m, p, piece);
    tabs += d.tabs.length;
    for (const tab of d.tabs)
      for (const poly of d.polygons) assert.equal(overlaps(tab, poly.points), false);
  }
  assert.ok(tabs > 0);
  assert.ok(tabs <= m.edges.length - p.joined.length);
  assert.deepEqual(printIssues(m, p), []);
});
test('off-sheet and overlapping pieces block PDF export; arrangement recovers', () => {
  const m = demoMesh(),
    p = newPattern(m);
  toggleSeam(m, p, p.joined[0]);
  p.pieces[0].x = -999;
  assert.ok(printIssues(m, p).some((s) => s.includes('outside')));
  assert.throws(() => createPDF(m, p), /outside/);
  pack(m, p);
  assert.deepEqual(printIssues(m, p), []);
  const copy = structuredClone(p.pieces[0]);
  copy.id = p.pieces.length;
  p.pieces.push(copy);
  assert.ok(printIssues(m, p).some((s) => s.includes('overlapping')));
});
test('project roundtrip preserves seams, placements, paper and PDF bytes', () => {
  const m = demoMesh(),
    p = newPattern(m);
  toggleSeam(m, p, p.joined[0]);
  p.settings.landscape = true;
  pack(m, p);
  p.pieces[0].x += 2;
  p.pieces[0].y += 1;
  const original = { mesh: m, pattern: p },
    restored = deserialize(serialize(original));
  assert.deepEqual(restored.pattern, p);
  assert.deepEqual(createPDF(restored.mesh, restored.pattern), createPDF(m, p));
  const data = JSON.parse(serialize(original));
  data.pattern.pieces[0].page = -1;
  assert.throws(() => deserialize(JSON.stringify(data)), /valid/);
  data.pattern.pieces[0].page = 0;
  data.pattern.settings.size = NaN;
  assert.throws(() => deserialize(JSON.stringify(data)), /valid/);
});
test('PDF uses correct physical page dimensions, vector paths and xref offsets', async () => {
  const m = demoMesh(),
    p = newPattern(m),
    pdf = createPDF(m, p),
    text = new TextDecoder().decode(pdf);
  assert.match(text, /MediaBox \[0 0 595.2756 841.8898\]/);
  assert.match(text, /20 mm/);
  assert.match(text, /Print at 100%/);
  assert.match(text, /\d+\.\d+ \d+\.\d+ m/);
  const offset = Number(text.match(/startxref\n(\d+)/)[1]);
  assert.equal(text.slice(offset, offset + 4), 'xref');
  p.settings = { ...DEFAULT_SETTINGS, paper: 'letter', landscape: true };
  pack(m, p);
  assert.match(new TextDecoder().decode(createPDF(m, p)), /MediaBox \[0 0 792 612\]/);
  await writeFile(new URL('sample.pdf', dir), pdf);
  await writeFile(new URL('cube.obj', dir), cube);
});
test('automatic unfolding splits an oversized cube into printable pieces without rescaling', () => {
  const m = parseModel(bytes(cube), 'cube.obj'),
    p = newPattern(m);
  assert.ok(p.pieces.length > 1);
  assert.equal(p.settings.size, 100);
  assert.deepEqual(printIssues(m, p), []);
});
test('normal inversion survives save/restore and reverses fold types', () => {
  const m = demoMesh(),
    p = newPattern(m),
    before = p.pieces
      .flatMap((piece) => drawPiece(m, p, piece).lines)
      .filter((l) => p.joined.includes(l.edge) && l.kind !== 'flat');
  m.inverted = true;
  m.normals = m.normals.map((n) => n.map((v) => -v));
  const restored = deserialize(serialize({ mesh: m, pattern: p }));
  assert.equal(restored.mesh.inverted, true);
  const after = p.pieces
    .flatMap((piece) => drawPiece(m, p, piece).lines)
    .filter((l) => p.joined.includes(l.edge) && l.kind !== 'flat');
  assert.equal(before.length, after.length);
  before.forEach((l, i) => assert.notEqual(l.kind, after[i].kind));
  assert.deepEqual(createPDF(m, p), createPDF(restored.mesh, restored.pattern));
});
test('winding repair does not change edge identities on project reload', () => {
  const original = parseModel(bytes(cube), 'cube.obj');
  const mixed = original.faces.map((f, i) => (i % 3 === 0 ? [f[0], f[2], f[1]] : f));
  const m = makeMesh(original.vertices, mixed, 'Repaired cube'),
    p = newPattern(m);
  assert.ok(m.warnings.some((w) => w.includes('winding')));
  const restored = deserialize(serialize({ mesh: m, pattern: p }));
  assert.deepEqual(restored.mesh.edges, m.edges);
  assert.deepEqual(restored.pattern, p);
  assert.deepEqual(createPDF(m, p), createPDF(restored.mesh, restored.pattern));
});
test('unused OBJ vertices cannot distort the finished model dimensions', () => {
  const m = parseModel(bytes('v 0 0 0\nv 1 0 0\nv 0 1 0\nv 99999 0 0\nf 1 2 3'), 'unused.obj');
  assert.equal(m.vertices.length, 3);
  assert.equal(distance(m.vertices[0], m.vertices[1]), 1);
});

const model = await import(new URL('modelling.js', dir));
const { DocumentCommands } = await import(new URL('commands.js', dir));
function editor() {
  const mesh = demoMesh();
  let doc = { mesh, pattern: newPattern(mesh) };
  const commands = new DocumentCommands(
    () => doc,
    (value) => (doc = value),
    () => false,
  );
  const run = (name, args = {}) =>
    commands.run(name, { expectedRevision: commands.revision, ...args });
  return { commands, run, get: () => doc };
}
test('polygon modelling preserves scale, identifiers, v2 round trips and undo through the print pipeline', () => {
  const { commands, run, get } = editor();
  run('create_primitive', { kind: 'box', sizeMm: 40 });
  const id = get().editable.polygons[1].id;
  const before = serialize(get());
  run('extrude_faces', { polygonIds: [id], distanceMm: 10 });
  assert.equal(get().pattern.settings.size, 50);
  assert.ok(get().editable.polygons.some((p) => p.id === id));
  run('inset_face', { polygonId: id, ratio: 0.7 });
  const edge = model.solidEdges(get().editable)[0].id;
  run('split_edge', { edgeId: edge });
  assert.equal(get().pattern.settings.size, 50);
  const vertex = get().editable.polygons.find((p) => p.id === id).vertices[0];
  run('transform_geometry', {
    kind: 'vertex',
    ids: [vertex],
    operation: 'move',
    values: [1, 0, 0],
  });
  assert.deepEqual(deserialize(serialize(get())), get());
  run('configure_print', { sizeMm: 100 });
  run('unfold_pattern');
  run('arrange_pattern');
  assert.deepEqual(printIssues(get().mesh, get().pattern), []);
  assert.ok(new TextDecoder().decode(createPDF(get().mesh, get().pattern)).startsWith('%PDF'));
  while (commands.undoStack.length > 1) run('undo');
  assert.equal(serialize(get()), before);
  run('redo');
  assert.equal(get().pattern.settings.size, 50);
});
test('modelling rejects stale, invalid and non-manifold edits atomically; drag locks edits', () => {
  const { commands, run, get } = editor();
  run('create_primitive', { kind: 'box', sizeMm: 40 });
  const before = serialize(get()),
    rev = commands.revision,
    history = commands.undoStack.length;
  assert.throws(
    () => commands.run('delete_faces', { expectedRevision: 0, polygonIds: ['p9'] }),
    /Stale/,
  );
  assert.throws(() => run('extrude_faces', { polygonIds: ['missing'], distanceMm: 4 }), /Unknown/);
  assert.throws(
    () =>
      run('transform_geometry', {
        kind: 'polygon',
        ids: ['p9'],
        operation: 'scale',
        values: [0, 1, 1],
      }),
    /positive/,
  );
  assert.throws(() =>
    run('set_model', {
      geometry: {
        ...get().editable,
        polygons: [...get().editable.polygons, get().editable.polygons[0]],
      },
    }),
  );
  assert.equal(serialize(get()), before);
  assert.equal(commands.revision, rev);
  assert.equal(commands.undoStack.length, history);
  const locked = new DocumentCommands(
    get,
    () => {},
    () => true,
  );
  assert.throws(() => locked.run('undo', { expectedRevision: 0 }), /drag/);
});
test('plane/cylinder, connected region extrusion, open boundary fill and edge collapse', () => {
  for (const kind of ['plane', 'cylinder'])
    assert.ok(model.deriveSolid(model.primitive(kind, 30)).mesh.faces.length);
  const box = model.primitive('box', 30),
    top = box.polygons[1].id;
  const open = model.editSolid(box, (s) => (s.polygons = s.polygons.filter((p) => p.id !== top)));
  const boundary = model.solidEdges(open).find((e) => e.polygons.length === 1).id;
  const closed = model.editSolid(open, (s) => model.fillBoundary(s, boundary));
  assert.ok(model.solidEdges(closed).every((e) => e.polygons.length === 2));
  const triangleMesh = model.deriveSolid(box).mesh;
  triangleMesh.facePolygons = triangleMesh.faces.map((_, i) => String(i));
  const tris = model.solidFromMesh(triangleMesh, 30);
  const pair = tris.polygons.slice(0, 2).map((p) => p.id);
  assert.equal(model.deriveSolid(model.editSolid(tris, (s) => model.extrude(s, pair, 5))).size, 35);
  const split = model.editSolid(box, (s) => model.splitEdge(s, model.solidEdges(s)[0].id));
  const edge = model
    .solidEdges(split)
    .find((e) => e.vertices.some((id) => !box.vertices.some((v) => v.id === id)));
  assert.throws(
    () => model.editSolid(split, (s) => model.weld(s, edge.vertices)),
    /must be planar/,
  );
  const plane = model.primitive('plane', 30),
    splitPlane = model.editSolid(plane, (s) => model.splitEdge(s, model.solidEdges(s)[0].id));
  const planeEdge = model
    .solidEdges(splitPlane)
    .find((e) => e.vertices.some((id) => !plane.vertices.some((v) => v.id === id)));
  assert.ok(
    model.deriveSolid(model.editSolid(splitPlane, (s) => model.weld(s, planeEdge.vertices))).mesh
      .faces.length,
  );
});

test('agent undo cannot cross a private-document boundary; manual history preserves it and revokes access', async () => {
  const { DocumentCommands } = await import(new URL('commands.js', dir));
  let d = { mesh: demoMesh(), pattern: newPattern(demoMesh()) },
    revocations = 0;
  const c = new DocumentCommands(
    () => d,
    (v) => (d = v),
    () => false,
    () => revocations++,
  );
  c.run('create_primitive', {
    kind: 'box',
    sizeMm: 40,
    expectedRevision: c.revision,
  });
  c.record(serialize(d));
  c.resetContext();
  d = { mesh: demoMesh(), pattern: newPattern(demoMesh()) };
  assert.equal(revocations, 1);
  assert.throws(() => c.run('undo', { expectedRevision: c.revision }), /another document/);
  c.run('create_primitive', {
    kind: 'plane',
    sizeMm: 20,
    expectedRevision: c.revision,
  });
  c.run('undo', { expectedRevision: c.revision });
  assert.throws(() => c.run('undo', { expectedRevision: c.revision }), /another document/);
  c.run('undo', { expectedRevision: c.revision }, true);
  assert.equal(revocations, 2);
  assert.equal(c.inspect().polygons, 6);
  assert.throws(() => c.run('redo', { expectedRevision: c.revision }), /another document/);
  c.run('redo', { expectedRevision: c.revision }, true);
  assert.equal(revocations, 3);
  const before = serialize(d),
    revision = c.revision;
  assert.throws(
    () => c.run('delete_faces', { polygonIds: [], expectedRevision: revision }),
    /at least one/,
  );
  assert.equal(c.revision, revision);
  assert.equal(serialize(d), before);
});

function signalTower() {
  const e = editor(),
    { run, commands } = e;
  run('create_primitive', { kind: 'cylinder', sizeMm: 60, segments: 6 });
  const scale = (ids, values) =>
    run('transform_geometry', {
      kind: 'polygon',
      ids,
      operation: 'scale',
      values,
    });
  scale(commands.inspect().polygonIds, [1, 1, 0.13]);
  run('inset_face', { polygonId: 'p14', ratio: 0.62 });
  for (const [distanceMm, factor] of [
    [6, 0.75],
    [32, 0.8],
    [8, 2.6],
    [12, null],
  ]) {
    run('extrude_faces', { polygonIds: ['p14'], distanceMm });
    if (factor) scale(['p14'], [factor, factor, 1]);
  }
  run('inset_face', { polygonId: 'p14', ratio: 0.86 });
  run('extrude_faces', { polygonIds: ['p14'], distanceMm: 18 });
  scale(['p14'], [0.12, 0.12, 1]);
  run('transform_geometry', {
    kind: 'polygon',
    ids: commands.inspect().polygonIds,
    operation: 'rotate',
    values: [-90, 0, 0],
  });
  run('configure_print', { sizeMm: 80, paper: 'a4', marginMm: 10, tabs: true });
  run('unfold_pattern');
  return e;
}

test('signal tower repairs the nine omitted joins and refuses unreadable miniature assembly labels', async () => {
  const { run, get, commands } = signalTower();
  let { mesh, pattern } = get();
  assert.equal(mesh.faces.length, 104);
  const seams = () =>
    mesh.edges.filter((e) => e.faces.length === 2 && !pattern.joined.includes(e.id));
  assert.equal(planTabs(mesh, pattern).size, seams().length);
  assert.ok(printIssues(mesh, pattern).some((s) => s.includes('readable edge numbers')));
  assert.throws(() => createPDF(mesh, pattern), /readable edge numbers/);
  // Deliberately widen the tiny cap and enlarge the print; never silently rescale.
  run('transform_geometry', {
    kind: 'polygon',
    ids: ['p14'],
    operation: 'scale',
    values: [2.5, 1, 2.5],
  });
  run('configure_print', { sizeMm: 180 });
  run('unfold_pattern');
  ({ mesh, pattern } = get());
  const joins = [...pattern.joined];
  run('arrange_pattern');
  assert.deepEqual(pattern.joined, joins);
  assert.deepEqual(commands.run('check_printability').issues, printIssues(mesh, pattern));
  assert.deepEqual(printIssues(mesh, pattern), []);
  const planned = planTabs(mesh, pattern),
    labels = [];
  assert.equal(planned.size, seams().length);
  for (const piece of pattern.pieces) {
    const drawing = drawPiece(mesh, pattern, piece);
    assert.equal(drawing.omitted, 0);
    for (let i = 0; i < drawing.tabs.length; i++) {
      const tab = drawing.tabs[i];
      for (const poly of drawing.polygons) assert.equal(overlaps(tab, poly.points), false);
      for (let j = 0; j < i; j++) assert.equal(overlaps(tab, drawing.tabs[j]), false);
    }
    for (let i = 0; i < drawing.labels.length; i++) {
      const label = drawing.labels[i];
      assert.ok(label.size >= 2);
      for (let j = 0; j < i; j++) assert.equal(overlaps(label.box, drawing.labels[j].box), false);
    }
    labels.push(...drawing.labels);
  }
  for (const seam of seams())
    assert.equal(labels.filter((l) => l.text === String(seam.id + 1)).length, 2);
  const restored = deserialize(serialize(get()));
  assert.deepEqual(createPDF(restored.mesh, restored.pattern), createPDF(mesh, pattern));
  await writeFile(new URL('signal-tower.pdf', dir), createPDF(mesh, pattern));
  await writeFile(new URL('signal-tower.nappakura', dir), serialize(get()));
});

test('disabled, hidden and impossible tiny tabs fail the same tool and PDF check', () => {
  const { run, get, commands } = editor();
  run('create_primitive', { kind: 'box', sizeMm: 40 });
  const { mesh, pattern } = get(),
    seam = mesh.edges.find((e) => e.faces.length === 2 && !pattern.joined.includes(e.id));
  pattern.hiddenTabs.push(seam.id);
  assert.match(commands.run('check_printability').issues.join(' '), /missing a usable glue tab/);
  assert.throws(() => createPDF(mesh, pattern), /missing a usable glue tab/);
  pattern.hiddenTabs = [];
  pattern.settings.tabs = false;
  assert.throws(() => createPDF(mesh, pattern), /missing a usable glue tab/);
  pattern.settings.tabs = true;
  pattern.settings.size = 1;
  pack(mesh, pattern);
  assert.throws(() => createPDF(mesh, pattern), /missing a usable glue tab/);
});

test('tab ownership is independent of sheet placement', () => {
  const { get } = signalTower();
  const { mesh, pattern } = get();
  const planned = planTabs(mesh, pattern);
  assert.ok(planned.size > 0);
  for (const p of pattern.pieces) {
    p.x += 57;
    p.y -= 39;
    p.rotation += 37;
    p.page += 1;
  }
  assert.deepEqual(planTabs(mesh, pattern), planned);
});

test('quad extrusion keeps polygons intact in selection, seams, counts and PDF drawings', () => {
  const { polygonCount, internalEdge, polygonEdges } = meshHelpers;
  const s = model.primitive('box', 60);
  const edited = model.editSolid(s, (s) => model.extrude(s, [s.polygons[1].id], 20));
  const m = model.deriveSolid(edited).mesh,
    p = newPattern(m);
  assert.equal(polygonCount(m), 10);
  assert.equal(m.faces.length, 20);
  const internal = m.edges.filter((e) => internalEdge(m, e));
  assert.equal(internal.length, 10);
  for (const e of internal) {
    assert.ok(p.joined.includes(e.id));
    assert.throws(() => toggleSeam(m, p, e.id), /internal polygon diagonal/);
    assert.ok(!polygonEdges(m, e.faces[0]).includes(e.id));
  }
  for (const piece of p.pieces)
    assert.ok(drawPiece(m, p, piece).lines.every((l) => !internal.some((e) => e.id === l.edge)));
  assert.deepEqual(printIssues(m, p), []);
  const imported = model.solidFromMesh(parseModel(bytes(cube), 'cube.obj'), 60);
  assert.equal(imported.polygons.length, 6);
  assert.ok(imported.polygons.every((p) => p.vertices.length === 4));
});
test('legacy projects with internal diagonal seams get a reviewed-layout migration', () => {
  const s = model.primitive('box', 40),
    m = model.deriveSolid(s).mesh,
    p = newPattern(m, { ...DEFAULT_SETTINGS, size: 40 });
  const saved = JSON.parse(serialize({ mesh: m, pattern: p, editable: s }));
  saved.pattern.joined = saved.pattern.joined.filter(
    (id) => !meshHelpers.internalEdge(m, m.edges[id]),
  );
  const restored = deserialize(JSON.stringify(saved));
  assert.deepEqual(restored.editable, s);
  assert.ok(restored.mesh.warnings.some((w) => w.includes('internal polygon diagonals')));
  assert.deepEqual(printIssues(restored.mesh, restored.pattern), []);
});
test('glue tabs taper to acute recipient corners and switch sides when the recipient is too narrow', () => {
  const m = makeMesh(
    [
      [0, 0, 0],
      [40, 0, 0],
      [0, 40, 0],
      [1, 0, 0.3],
    ],
    [
      [0, 1, 2],
      [1, 0, 3],
    ],
    'narrow',
  );
  const p = {
    ...unfold(m, new Set()),
    settings: { ...DEFAULT_SETTINGS, size: 40 },
    flipped: [],
    hiddenTabs: [],
  };
  const edge = m.edges.find((e) => e.faces.length === 2),
    tab = planTabs(m, p).get(edge.id);
  assert.ok(tab);
  assert.equal(tab.face, 1);
  const demo = demoMesh(),
    pattern = newPattern(demo),
    tabs = planTabs(demo, pattern);
  for (const [id, t] of tabs) {
    const e = demo.edges[id],
      flat = pattern.pieces[t.piece].faces.find((f) => f.face === t.face);
    const ids = demo.faces[t.face],
      a = flat.points[ids.indexOf(e.a)].map((v) => v * pattern.settings.size),
      b = flat.points[ids.indexOf(e.b)].map((v) => v * pattern.settings.size);
    const dx = b[0] - a[0],
      dy = b[1] - a[1],
      len = Math.hypot(dx, dy);
    const footprint = t.points.map((p) => [
      ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len,
      Math.abs((p[0] - a[0]) * dy - (p[1] - a[1]) * dx) / len,
    ]);
    assert.ok(unfoldHelpers.tabFitsRecipient(demo, e, t.face, footprint, pattern.settings.size));
  }
  assert.equal(
    unfoldHelpers.tabFitsRecipient(
      m,
      edge,
      0,
      [
        [0.4, 0],
        [1, 5],
        [39, 5],
        [39.6, 0],
      ],
      40,
    ),
    false,
  );
});
test('depth rendering and picking agree where centroid ordering would expose hidden surfaces', async () => {
  globalThis.ImageData = class {
    constructor(w, h) {
      this.data = new Uint8ClampedArray(w * h * 4);
    }
  };
  const { DepthRenderer } = await import(new URL('depth-renderer.js', dir));
  const a = [
      [1, 1, 1],
      [19, 1, 1],
      [1, 19, -1],
    ],
    b = [
      [1, 1, 0],
      [19, 1, 0],
      [1, 19, 0],
    ];
  for (const reverse of [false, true]) {
    const r = new DepthRenderer(22, 22),
      red = [255, 0, 0, 255],
      blue = [0, 0, 255, 255];
    if (reverse) {
      r.triangle(b, blue, 1);
      r.triangle(a, red, 0);
    } else {
      r.triangle(a, red, 0);
      r.triangle(b, blue, 1);
    }
    assert.equal(r.faceAt(3, 3), 0);
    assert.equal(r.faceAt(3, 14), 1);
    assert.deepEqual([...r.image.data.slice((14 * 22 + 3) * 4, (14 * 22 + 3) * 4 + 4)], blue);
    r.line([3, 13, -1], [3, 16, -1], [255, 255, 255, 255], 1);
    assert.deepEqual([...r.image.data.slice((14 * 22 + 3) * 4, (14 * 22 + 3) * 4 + 4)], blue);
  }
});
const meshHelpers = await import(new URL('mesh.js', dir));
const unfoldHelpers = await import(new URL('unfold.js', dir));

test('gizmo resolves world-axis and plane motion, scale and snapped rotation without camera leakage', async () => {
  const { dragValues, gizmoHandles, hitHandle } = await import(new URL('gizmo.js', dir));
  const basis = [
      [0.8, 0.2],
      [0.1, -0.9],
      [0.6, 0.4],
    ],
    origin = [100, 100];
  assert.deepEqual(dragValues('move', [0], basis, [0, 0], [16, 4], origin, 2, false), [10, 0, 0]);
  const plane = dragValues('move', [0, 1], basis, [0, 0], [17, -5], origin, 2, false);
  assert.ok(Math.abs(plane[0] - 10) < 1e-9 && Math.abs(plane[1] - 5) < 1e-9);
  assert.equal(plane[2], 0);
  const scale = dragValues('scale', [0, 1], basis, [0, 0], [36, -28], origin, 2, false);
  assert.deepEqual(scale, [1.5, 1.5, 1]);
  assert.deepEqual(
    dragValues(
      'rotate',
      [2],
      [
        [1, 0],
        [0, -1],
        [0, 0],
      ],
      [150, 100],
      [100, 50],
      origin,
      2,
      true,
    ),
    [0, 0, 90],
  );
  const handles = gizmoHandles({ center: [0, 0, 0], size: 40, operation: 'move' }, origin, basis);
  assert.equal(handles.length, 6);
  assert.equal(hitHandle(handles, [164, 116]).label, 'X');
  assert.deepEqual(
    dragValues('scale', [0], basis, [0, 0], [-160, -40], origin, 2, false),
    [0.01, 1, 1],
  );
});