@playdrop/playdrop-cli 0.7.15 → 0.7.17

package/node_modules/@playdrop/boxel-three/dist/test/scene-smoke.test.js

@@ -1,63 +1,85 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import * as THREE from 'three';
-import { createBoxelScene } from '../src/index.js';
-test('createBoxelScene exposes node metadata and animations for editor tooling', () => {
-    const entity = {
-        id: 'scene-smoke',
-        geometry: {
-            id: 'geom',
-            root: {
-                id: 'Root',
-                position: [0, 0, 0],
-                children: [
-                    {
-                        id: 'Child',
-                        position: [1, 0, 0],
-                        mesh: 'box',
-                        children: [],
-                    },
-                ],
-            },
-        },
-        primitives: [
-            {
-                id: 'box',
-                kind: 'plain_box',
-                size: [1, 1, 1],
-                material: 'mat',
-            },
-        ],
-        materials: [{ id: 'mat', baseColor: [200, 120, 60] }],
-        textures: [],
-        patterns: [],
-        animations: [
-            {
-                id: 'wiggle',
-                duration: 2,
-                channels: [
-                    {
-                        node: 'Child',
-                        property: 'position',
-                        keyframes: [
-                            { time: 0, value: [1, 0, 0] },
-                            { time: 1, value: [1, 0.5, 0] },
-                            { time: 2, value: [1, 0, 0] },
-                        ],
-                    },
-                ],
-            },
-        ],
-    };
-    const result = createBoxelScene({ THREE, entity });
-    assert.ok(result.root.children.length >= 1, 'scene root should contain children');
-    const childMeta = result.nodes.get('Child');
-    assert.ok(childMeta, 'child node metadata should exist');
-    assert.strictEqual(childMeta.object.userData?.nodeId, 'Child');
-    assert.strictEqual(childMeta.object.parent?.userData?.nodeId, 'Root');
-    assert.ok(result.animations.length >= 1, 'expected animation metadata');
-    const clip = result.animations[0]?.clip;
-    assert.ok(clip, 'animation clip missing');
-    assert.ok(clip.duration >= 2, 'clip duration should cover keyframes');
-    result.dispose();
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_test = __toESM(require("node:test"));
+var import_strict = __toESM(require("node:assert/strict"));
+var THREE = __toESM(require("three"));
+var import_src = require("../src/index.js");
+(0, import_node_test.default)("createBoxelScene exposes node metadata and animations for editor tooling", () => {
+  const entity = {
+    id: "scene-smoke",
+    geometry: {
+      id: "geom",
+      root: {
+        id: "Root",
+        position: [0, 0, 0],
+        children: [
+          {
+            id: "Child",
+            position: [1, 0, 0],
+            mesh: "box",
+            children: []
+          }
+        ]
+      }
+    },
+    primitives: [
+      {
+        id: "box",
+        kind: "plain_box",
+        size: [1, 1, 1],
+        material: "mat"
+      }
+    ],
+    materials: [{ id: "mat", baseColor: [200, 120, 60] }],
+    textures: [],
+    patterns: [],
+    animations: [
+      {
+        id: "wiggle",
+        duration: 2,
+        channels: [
+          {
+            node: "Child",
+            property: "position",
+            keyframes: [
+              { time: 0, value: [1, 0, 0] },
+              { time: 1, value: [1, 0.5, 0] },
+              { time: 2, value: [1, 0, 0] }
+            ]
+          }
+        ]
+      }
+    ]
+  };
+  const result = (0, import_src.createBoxelScene)({ THREE, entity });
+  import_strict.default.ok(result.root.children.length >= 1, "scene root should contain children");
+  const childMeta = result.nodes.get("Child");
+  import_strict.default.ok(childMeta, "child node metadata should exist");
+  import_strict.default.strictEqual(childMeta.object.userData?.nodeId, "Child");
+  import_strict.default.strictEqual(childMeta.object.parent?.userData?.nodeId, "Root");
+  import_strict.default.ok(result.animations.length >= 1, "expected animation metadata");
+  const clip = result.animations[0]?.clip;
+  import_strict.default.ok(clip, "animation clip missing");
+  import_strict.default.ok(clip.duration >= 2, "clip duration should cover keyframes");
+  result.dispose();
 });

package/node_modules/@playdrop/boxel-three/dist/test/skinned-mesh.test.js

@@ -1,51 +1,73 @@
 "use strict";
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import * as THREE from 'three';
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { parseBoxel } from '@playdrop/boxel-core';
-import { buildEntitySkinnedMesh } from '../src/skinned-mesh.js';
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-const fixture = (...segments) => path.resolve(HERE, './fixtures', ...segments);
-test('buildEntitySkinnedMesh exposes atlas and connect stats', async () => {
-    const entityRaw = await readFile(fixture('entity-connect.json'), 'utf-8');
-    const entity = parseBoxel(JSON.parse(entityRaw));
-    const result = buildEntitySkinnedMesh({ THREE, entity });
-    try {
-        const { mesh, stats } = result;
-        assert.ok(mesh instanceof THREE.SkinnedMesh, 'skinned mesh returned');
-        assert.ok(!Array.isArray(mesh.material), 'single material used');
-        const material = mesh.material;
-        assert.strictEqual(material.skinning, true);
-        assert.ok(stats.atlas === null || typeof stats.atlas === 'object', 'atlas info present (or null)');
-        const breakdown = stats.connectBreakdown;
-        assert.deepEqual(Object.keys(breakdown).sort(), ['Chest'], 'connect breakdown captured child node');
-        assert.ok(breakdown.Chest.childVertices > 0, 'child vertices blended');
-        assert.ok(breakdown.Chest.parentVertices > 0, 'parent vertices blended');
-        const geometry = mesh.geometry;
-        const connectStrength = geometry.getAttribute('connectStrength');
-        assert.ok(connectStrength, 'connect strength attribute exists');
-        let sawHalf = false;
-        let sawFull = false;
-        for (let i = 0; i < connectStrength.count; i += 1) {
-            const value = connectStrength.getX(i);
-            if (Math.abs(value - 0.5) < 1e-3)
-                sawHalf = true;
-            if (Math.abs(value - 1) < 1e-3)
-                sawFull = true;
-        }
-        assert.ok(sawHalf, 'detected vertices blending 50/50');
-        assert.ok(sawFull || !breakdown.Chest.childVertices || sawHalf, 'detected vertices fully or partially reassigned when expected');
-        const skinWeights = geometry.getAttribute('skinWeight');
-        assert.ok(skinWeights, 'skin weights present');
-        for (let i = 0; i < skinWeights.count; i += 1) {
-            const sum = skinWeights.getX(i) + skinWeights.getY(i) + skinWeights.getZ(i) + skinWeights.getW(i);
-            assert.ok(Math.abs(sum - 1) < 1e-3, 'weights normalised per vertex');
-        }
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_test = __toESM(require("node:test"));
+var import_strict = __toESM(require("node:assert/strict"));
+var THREE = __toESM(require("three"));
+var import_promises = require("node:fs/promises");
+var import_node_path = __toESM(require("node:path"));
+var import_node_url = require("node:url");
+var import_boxel_core = require("@playdrop/boxel-core");
+var import_skinned_mesh = require("../src/skinned-mesh.js");
+const import_meta = {};
+const HERE = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+const fixture = (...segments) => import_node_path.default.resolve(HERE, "./fixtures", ...segments);
+(0, import_node_test.default)("buildEntitySkinnedMesh exposes atlas and connect stats", async () => {
+  const entityRaw = await (0, import_promises.readFile)(fixture("entity-connect.json"), "utf-8");
+  const entity = (0, import_boxel_core.parseBoxel)(JSON.parse(entityRaw));
+  const result = (0, import_skinned_mesh.buildEntitySkinnedMesh)({ THREE, entity });
+  try {
+    const { mesh, stats } = result;
+    import_strict.default.ok(mesh instanceof THREE.SkinnedMesh, "skinned mesh returned");
+    import_strict.default.ok(!Array.isArray(mesh.material), "single material used");
+    const material = mesh.material;
+    import_strict.default.strictEqual(material.skinning, true);
+    import_strict.default.ok(stats.atlas === null || typeof stats.atlas === "object", "atlas info present (or null)");
+    const breakdown = stats.connectBreakdown;
+    import_strict.default.deepEqual(Object.keys(breakdown).sort(), ["Chest"], "connect breakdown captured child node");
+    import_strict.default.ok(breakdown.Chest.childVertices > 0, "child vertices blended");
+    import_strict.default.ok(breakdown.Chest.parentVertices > 0, "parent vertices blended");
+    const geometry = mesh.geometry;
+    const connectStrength = geometry.getAttribute("connectStrength");
+    import_strict.default.ok(connectStrength, "connect strength attribute exists");
+    let sawHalf = false;
+    let sawFull = false;
+    for (let i = 0; i < connectStrength.count; i += 1) {
+      const value = connectStrength.getX(i);
+      if (Math.abs(value - 0.5) < 1e-3)
+        sawHalf = true;
+      if (Math.abs(value - 1) < 1e-3)
+        sawFull = true;
     }
-    finally {
-        result.dispose();
+    import_strict.default.ok(sawHalf, "detected vertices blending 50/50");
+    import_strict.default.ok(sawFull || !breakdown.Chest.childVertices || sawHalf, "detected vertices fully or partially reassigned when expected");
+    const skinWeights = geometry.getAttribute("skinWeight");
+    import_strict.default.ok(skinWeights, "skin weights present");
+    for (let i = 0; i < skinWeights.count; i += 1) {
+      const sum = skinWeights.getX(i) + skinWeights.getY(i) + skinWeights.getZ(i) + skinWeights.getW(i);
+      import_strict.default.ok(Math.abs(sum - 1) < 1e-3, "weights normalised per vertex");
     }
+  } finally {
+    result.dispose();
+  }
 });

package/node_modules/@playdrop/boxel-three/dist/test/textured-overlay.test.js

@@ -1,116 +1,136 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import * as THREE from 'three';
-import { createBoxelScene, createBoxelSceneGraph } from '../src/index.js';
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_test = __toESM(require("node:test"));
+var import_strict = __toESM(require("node:assert/strict"));
+var THREE = __toESM(require("three"));
+var import_src = require("../src/index.js");
 const OVERLAY_THICKNESS = 0.25;
 const overlayEntity = {
-    id: 'overlay-sample',
-    geometry: {
-        id: 'geom',
-        root: {
-            id: 'Root',
-            position: [0, 0, 0],
-            children: [
-                {
-                    id: 'BoxNode',
-                    position: [0, 0, 0],
-                    mesh: 'overlay_box',
-                    children: [],
-                },
-            ],
-        },
-    },
-    primitives: [
-        {
-            id: 'overlay_box',
-            kind: 'textured_box',
-            size: [2, 2, 2],
-            all: 'base_texture',
-            northOverlay: 'overlay_texture',
-        },
-    ],
-    textures: [
-        {
-            id: 'base_texture',
-            pattern: 'base_pattern',
-            materials: ['base_material'],
-        },
-        {
-            id: 'overlay_texture',
-            pattern: 'overlay_pattern',
-            materials: ['overlay_material'],
-        },
-    ],
-    patterns: [
+  id: "overlay-sample",
+  geometry: {
+    id: "geom",
+    root: {
+      id: "Root",
+      position: [0, 0, 0],
+      children: [
         {
-            id: 'base_pattern',
-            size: [2, 2],
-            data: [0, 0, 0, 0],
-        },
-        {
-            id: 'overlay_pattern',
-            size: [2, 2],
-            data: [0, 0, 0, 0],
-        },
-    ],
-    materials: [
-        { id: 'base_material', baseColor: [255, 0, 0] },
-        { id: 'overlay_material', baseColor: [0, 255, 0] },
-    ],
-    animations: [],
-};
-test('textured box overlay attaches inflated mesh with transparent materials', () => {
-    const scene = createBoxelScene({ THREE, entity: overlayEntity });
-    let baseMesh = null;
-    let overlayMesh = null;
-    scene.root.traverse(object => {
-        if (object instanceof THREE.Mesh && object.userData?.primitiveId === 'overlay_box' && !object.userData.overlay) {
-            baseMesh = object;
-            const overlayChild = object.children.find(child => child instanceof THREE.Mesh && child.userData?.overlay);
-            if (overlayChild instanceof THREE.Mesh) {
-                overlayMesh = overlayChild;
-            }
+          id: "BoxNode",
+          position: [0, 0, 0],
+          mesh: "overlay_box",
+          children: []
         }
-    });
-    assert.ok(baseMesh, 'base textured mesh missing');
-    assert.ok(overlayMesh, 'overlay mesh missing');
-    const baseMeshRef = baseMesh;
-    const overlayMeshRef = overlayMesh;
-    const baseGeometry = baseMeshRef.geometry;
-    const overlayGeometry = overlayMeshRef.geometry;
-    assert.ok(baseGeometry && overlayGeometry, 'expected box geometries on both meshes');
-    const overlayWidth = overlayGeometry.parameters?.width ?? 0;
-    const baseWidth = baseGeometry.parameters?.width ?? 0;
-    assert.equal(overlayWidth, baseWidth + OVERLAY_THICKNESS * 2, 'overlay geometry should be inflated along X axis');
-    const overlayMaterials = (Array.isArray(overlayMeshRef.material)
-        ? overlayMeshRef.material
-        : [overlayMeshRef.material]);
-    const visibleMaterials = overlayMaterials.filter(material => material.visible !== false && material.opacity !== 0);
-    const hiddenMaterials = overlayMaterials.filter(material => material.visible === false || material.opacity === 0);
-    assert.ok(visibleMaterials.length >= 1, 'expected at least one visible overlay material');
-    assert.ok(hiddenMaterials.length >= 1, 'expected non-overlay faces to be hidden');
-    visibleMaterials.forEach((material) => {
-        assert.equal(material.transparent, true, 'overlay materials must be rendered with transparency');
-        assert.equal(material.depthWrite, false, 'overlay materials should disable depth writing');
-    });
-    scene.dispose();
+      ]
+    }
+  },
+  primitives: [
+    {
+      id: "overlay_box",
+      kind: "textured_box",
+      size: [2, 2, 2],
+      all: "base_texture",
+      northOverlay: "overlay_texture"
+    }
+  ],
+  textures: [
+    {
+      id: "base_texture",
+      pattern: "base_pattern",
+      materials: ["base_material"]
+    },
+    {
+      id: "overlay_texture",
+      pattern: "overlay_pattern",
+      materials: ["overlay_material"]
+    }
+  ],
+  patterns: [
+    {
+      id: "base_pattern",
+      size: [2, 2],
+      data: [0, 0, 0, 0]
+    },
+    {
+      id: "overlay_pattern",
+      size: [2, 2],
+      data: [0, 0, 0, 0]
+    }
+  ],
+  materials: [
+    { id: "base_material", baseColor: [255, 0, 0] },
+    { id: "overlay_material", baseColor: [0, 255, 0] }
+  ],
+  animations: []
+};
+(0, import_node_test.default)("textured box overlay attaches inflated mesh with transparent materials", () => {
+  const scene = (0, import_src.createBoxelScene)({ THREE, entity: overlayEntity });
+  let baseMesh = null;
+  let overlayMesh = null;
+  scene.root.traverse((object) => {
+    if (object instanceof THREE.Mesh && object.userData?.primitiveId === "overlay_box" && !object.userData.overlay) {
+      baseMesh = object;
+      const overlayChild = object.children.find((child) => child instanceof THREE.Mesh && child.userData?.overlay);
+      if (overlayChild instanceof THREE.Mesh) {
+        overlayMesh = overlayChild;
+      }
+    }
+  });
+  import_strict.default.ok(baseMesh, "base textured mesh missing");
+  import_strict.default.ok(overlayMesh, "overlay mesh missing");
+  const baseMeshRef = baseMesh;
+  const overlayMeshRef = overlayMesh;
+  const baseGeometry = baseMeshRef.geometry;
+  const overlayGeometry = overlayMeshRef.geometry;
+  import_strict.default.ok(baseGeometry && overlayGeometry, "expected box geometries on both meshes");
+  const overlayWidth = overlayGeometry.parameters?.width ?? 0;
+  const baseWidth = baseGeometry.parameters?.width ?? 0;
+  import_strict.default.equal(overlayWidth, baseWidth + OVERLAY_THICKNESS * 2, "overlay geometry should be inflated along X axis");
+  const overlayMaterials = Array.isArray(overlayMeshRef.material) ? overlayMeshRef.material : [overlayMeshRef.material];
+  const visibleMaterials = overlayMaterials.filter((material) => material.visible !== false && material.opacity !== 0);
+  const hiddenMaterials = overlayMaterials.filter((material) => material.visible === false || material.opacity === 0);
+  import_strict.default.ok(visibleMaterials.length >= 1, "expected at least one visible overlay material");
+  import_strict.default.ok(hiddenMaterials.length >= 1, "expected non-overlay faces to be hidden");
+  visibleMaterials.forEach((material) => {
+    import_strict.default.equal(material.transparent, true, "overlay materials must be rendered with transparency");
+    import_strict.default.equal(material.depthWrite, false, "overlay materials should disable depth writing");
+  });
+  scene.dispose();
 });
-test('merged scene graph export includes overlay atlas data', () => {
-    const graph = createBoxelSceneGraph({ THREE, model: overlayEntity, mode: 'merged' });
-    let meshCount = 0;
-    let transparentMaterialDetected = false;
-    graph.root.traverse(object => {
-        if (object instanceof THREE.Mesh) {
-            meshCount += 1;
-            const materials = Array.isArray(object.material) ? object.material : [object.material];
-            materials.forEach(material => {
-                if (material.transparent) {
-                    transparentMaterialDetected = true;
-                }
-            });
+(0, import_node_test.default)("merged scene graph export includes overlay atlas data", () => {
+  const graph = (0, import_src.createBoxelSceneGraph)({ THREE, model: overlayEntity, mode: "merged" });
+  let meshCount = 0;
+  let transparentMaterialDetected = false;
+  graph.root.traverse((object) => {
+    if (object instanceof THREE.Mesh) {
+      meshCount += 1;
+      const materials = Array.isArray(object.material) ? object.material : [object.material];
+      materials.forEach((material) => {
+        if (material.transparent) {
+          transparentMaterialDetected = true;
         }
-    });
-    assert.ok(meshCount >= 1, 'merged graph should contain at least one mesh');
-    assert.equal(transparentMaterialDetected, true, 'merged atlas material should be marked transparent when overlays are present');
-    graph.dispose();
+      });
+    }
+  });
+  import_strict.default.ok(meshCount >= 1, "merged graph should contain at least one mesh");
+  import_strict.default.equal(transparentMaterialDetected, true, "merged atlas material should be marked transparent when overlays are present");
+  graph.dispose();
 });

package/node_modules/@playdrop/boxel-three/dist/test/voxels.test.js

@@ -1,20 +1,42 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { buildVoxelMesh } from '../src/voxels/mesher.js';
-const makeMesh = () => buildVoxelMesh({
-    voxels: [1, 2],
-    dimensions: [2, 1, 1],
-    size: [2, 1, 1],
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_node_test = __toESM(require("node:test"));
+var import_strict = __toESM(require("node:assert/strict"));
+var import_mesher = require("../src/voxels/mesher.js");
+const makeMesh = () => (0, import_mesher.buildVoxelMesh)({
+  voxels: [1, 2],
+  dimensions: [2, 1, 1],
+  size: [2, 1, 1]
 });
-test('buildVoxelMesh assigns material groups without mixing palette indices', () => {
-    const result = makeMesh();
-    assert.ok(result.groups.length > 1, 'expected multiple material groups');
-    assert.equal(new Set(result.groups.map(group => group.material)).size, 2, 'should contain both palette indices');
-    let covered = 0;
-    result.groups.forEach(group => {
-        assert.equal(group.start % 6, 0, 'group should align with triangle pairs');
-        assert.equal(group.count % 6, 0, 'group count should be a multiple of a quad');
-        covered += group.count;
-    });
-    assert.equal(covered, result.indices.length, 'groups should cover entire index buffer');
+(0, import_node_test.default)("buildVoxelMesh assigns material groups without mixing palette indices", () => {
+  const result = makeMesh();
+  import_strict.default.ok(result.groups.length > 1, "expected multiple material groups");
+  import_strict.default.equal(new Set(result.groups.map((group) => group.material)).size, 2, "should contain both palette indices");
+  let covered = 0;
+  result.groups.forEach((group) => {
+    import_strict.default.equal(group.start % 6, 0, "group should align with triangle pairs");
+    import_strict.default.equal(group.count % 6, 0, "group count should be a multiple of a quad");
+    covered += group.count;
+  });
+  import_strict.default.equal(covered, result.indices.length, "groups should cover entire index buffer");
 });

package/node_modules/@playdrop/boxel-three/package.json

@@ -2,7 +2,7 @@
   "name": "@playdrop/boxel-three",
   "version": "0.7.2",
   "description": "Three.js utilities for rendering and exporting Playdrop boxels",
-  "type": "module",
+  "type": "commonjs",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
   "scripts": {

package/node_modules/@playdrop/config/client-meta.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.7.15",
+  "version": "0.7.17",
   "build": 1,
   "clients": {
     "all": {