@playdrop/playdrop-cli 0.7.13 → 0.7.16

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

@@ -1,86 +1,104 @@
 "use strict";
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import * as THREE from 'three';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { readFile } from 'node:fs/promises';
-import { parseBoxel } from '@playdrop/boxel-core';
-import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
-import { createBoxelSceneGraph, exportModelToGLB } from '../src/exporters/glb.js';
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-const fixture = (...segments) => path.resolve(HERE, './fixtures', ...segments);
-if (typeof globalThis.FileReader === 'undefined') {
-    class NodeFileReader {
-        constructor() {
-            this.onload = null;
-            this.onloadend = null;
-            this.onerror = null;
-            this.onabort = null;
-            this.result = null;
-        }
-        readAsDataURL(blob) {
-            blob.arrayBuffer()
-                .then(buffer => {
-                const mime = blob.type || 'application/octet-stream';
-                const base64 = Buffer.from(buffer).toString('base64');
-                this.result = `data:${mime};base64,${base64}`;
-                const event = { target: { result: this.result } };
-                this.onload?.(event);
-                this.onloadend?.(event);
-            })
-                .catch(error => {
-                this.onerror?.(error);
-                this.onloadend?.({ target: { result: null } });
-            });
-        }
-        readAsArrayBuffer(blob) {
-            blob.arrayBuffer()
-                .then(buffer => {
-                this.result = buffer;
-                const event = { target: { result: this.result } };
-                this.onload?.(event);
-                this.onloadend?.(event);
-            })
-                .catch(error => {
-                this.onerror?.(error);
-                this.onloadend?.({ target: { result: null } });
-            });
-        }
-        abort() {
-            this.onabort?.(new Error('filereader_abort_not_supported'));
-        }
+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_node_path = __toESM(require("node:path"));
+var import_node_url = require("node:url");
+var import_promises = require("node:fs/promises");
+var import_boxel_core = require("@playdrop/boxel-core");
+var import_GLTFExporter = require("three/examples/jsm/exporters/GLTFExporter.js");
+var import_glb = require("../src/exporters/glb.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);
+if (typeof globalThis.FileReader === "undefined") {
+  class NodeFileReader {
+    constructor() {
+      this.onload = null;
+      this.onloadend = null;
+      this.onerror = null;
+      this.onabort = null;
+      this.result = null;
     }
-    globalThis.FileReader = NodeFileReader;
+    readAsDataURL(blob) {
+      blob.arrayBuffer().then((buffer) => {
+        const mime = blob.type || "application/octet-stream";
+        const base64 = Buffer.from(buffer).toString("base64");
+        this.result = `data:${mime};base64,${base64}`;
+        const event = { target: { result: this.result } };
+        this.onload?.(event);
+        this.onloadend?.(event);
+      }).catch((error) => {
+        this.onerror?.(error);
+        this.onloadend?.({ target: { result: null } });
+      });
+    }
+    readAsArrayBuffer(blob) {
+      blob.arrayBuffer().then((buffer) => {
+        this.result = buffer;
+        const event = { target: { result: this.result } };
+        this.onload?.(event);
+        this.onloadend?.(event);
+      }).catch((error) => {
+        this.onerror?.(error);
+        this.onloadend?.({ target: { result: null } });
+      });
+    }
+    abort() {
+      this.onabort?.(new Error("filereader_abort_not_supported"));
+    }
+  }
+  globalThis.FileReader = NodeFileReader;
 }
 async function loadEntity(relativePath) {
-    const raw = await readFile(fixture(relativePath), 'utf-8');
-    return parseBoxel(JSON.parse(raw));
+  const raw = await (0, import_promises.readFile)(fixture(relativePath), "utf-8");
+  return (0, import_boxel_core.parseBoxel)(JSON.parse(raw));
 }
-test('createBoxelSceneGraph skinned mode exposes skinned mesh and bones', async () => {
-    const entity = await loadEntity('entity-connect.json');
-    const graph = createBoxelSceneGraph({ THREE, model: entity, mode: 'skinned' });
-    try {
-        assert.ok(graph.root instanceof THREE.Object3D, 'root should be Object3D');
-        const skinnedMesh = graph.root.children.find(child => child instanceof THREE.SkinnedMesh);
-        assert.ok(skinnedMesh, 'skinned mesh missing from scene graph');
-        const boneIds = Array.from(graph.nodeLookup.keys());
-        assert.ok(boneIds.length > 0, 'expected bones in lookup');
-        assert.ok(boneIds.some(id => id.toLowerCase().includes('chest')), 'expected Chest bone in lookup');
-        assert.ok(graph.animations.every(entry => entry.clip instanceof THREE.AnimationClip), 'clips missing');
-    }
-    finally {
-        graph.dispose();
-    }
+(0, import_node_test.default)("createBoxelSceneGraph skinned mode exposes skinned mesh and bones", async () => {
+  const entity = await loadEntity("entity-connect.json");
+  const graph = (0, import_glb.createBoxelSceneGraph)({ THREE, model: entity, mode: "skinned" });
+  try {
+    import_strict.default.ok(graph.root instanceof THREE.Object3D, "root should be Object3D");
+    const skinnedMesh = graph.root.children.find((child) => child instanceof THREE.SkinnedMesh);
+    import_strict.default.ok(skinnedMesh, "skinned mesh missing from scene graph");
+    const boneIds = Array.from(graph.nodeLookup.keys());
+    import_strict.default.ok(boneIds.length > 0, "expected bones in lookup");
+    import_strict.default.ok(boneIds.some((id) => id.toLowerCase().includes("chest")), "expected Chest bone in lookup");
+    import_strict.default.ok(graph.animations.every((entry) => entry.clip instanceof THREE.AnimationClip), "clips missing");
+  } finally {
+    graph.dispose();
+  }
 });
-test('exportModelToGLB supports skinned mode', async () => {
-    const entity = await loadEntity('entity-connect.json');
-    const blob = await exportModelToGLB({
-        THREE,
-        GLTFExporterCtor: GLTFExporter,
-        model: entity,
-        mode: 'skinned',
-    });
-    const buffer = Buffer.from(await blob.arrayBuffer());
-    assert.ok(buffer.length > 0, 'skinned export should produce non-empty binary');
+(0, import_node_test.default)("exportModelToGLB supports skinned mode", async () => {
+  const entity = await loadEntity("entity-connect.json");
+  const blob = await (0, import_glb.exportModelToGLB)({
+    THREE,
+    GLTFExporterCtor: import_GLTFExporter.GLTFExporter,
+    model: entity,
+    mode: "skinned"
+  });
+  const buffer = Buffer.from(await blob.arrayBuffer());
+  import_strict.default.ok(buffer.length > 0, "skinned export should produce non-empty binary");
 });

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

@@ -1,8 +1,30 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { createBoxelScene, createBoxelNodeScene, attachBoxelOverlays, } from '../src/index.js';
-test('boxel-three exposes renderer entry points', () => {
-    assert.equal(typeof createBoxelScene, 'function');
-    assert.equal(typeof createBoxelNodeScene, 'function');
-    assert.equal(typeof attachBoxelOverlays, 'function');
+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_src = require("../src/index.js");
+(0, import_node_test.default)("boxel-three exposes renderer entry points", () => {
+  import_strict.default.equal(typeof import_src.createBoxelScene, "function");
+  import_strict.default.equal(typeof import_src.createBoxelNodeScene, "function");
+  import_strict.default.equal(typeof import_src.attachBoxelOverlays, "function");
 });

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

@@ -1,68 +1,88 @@
 "use strict";
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import * as THREE from 'three';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { readFile } from 'node:fs/promises';
-import { parseBoxel } from '@playdrop/boxel-core';
-import { instantiateEntityObject3D, } from '../src/instantiate.js';
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-const fixture = (...segments) => path.resolve(HERE, './fixtures', ...segments);
+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_node_path = __toESM(require("node:path"));
+var import_node_url = require("node:url");
+var import_promises = require("node:fs/promises");
+var import_boxel_core = require("@playdrop/boxel-core");
+var import_instantiate = require("../src/instantiate.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);
 async function loadEntity(relativePath) {
-    const raw = await readFile(fixture(relativePath), 'utf-8');
-    return parseBoxel(JSON.parse(raw));
+  const raw = await (0, import_promises.readFile)(fixture(relativePath), "utf-8");
+  return (0, import_boxel_core.parseBoxel)(JSON.parse(raw));
 }
 function dispose(result) {
-    result.dispose();
+  result.dispose();
 }
-test('instantiateEntityObject3D hierarchy mode exposes group and node helpers', async () => {
-    const entity = await loadEntity('entity-connect.json');
-    const result = instantiateEntityObject3D({ THREE, entity, mode: 'hierarchy' });
-    try {
-        assert.equal(result.mode, 'hierarchy');
-        assert.ok(result.object instanceof THREE.Group, 'hierarchy returns group');
-        assert.ok(result.scene.root === result.object, 'group matches scene root');
-        assert.ok(typeof result.findNode === 'function', 'findNode helper available');
-        assert.ok(result.findNode(entity.geometry.root.id), 'root node resolves');
-        let counted = 0;
-        result.forEachNode(() => {
-            counted += 1;
-        });
-        assert.equal(counted > 0, true, 'forEachNode iterates nodes');
-        assert.ok(Array.isArray(result.clips), 'clips array present');
-    }
-    finally {
-        dispose(result);
-    }
+(0, import_node_test.default)("instantiateEntityObject3D hierarchy mode exposes group and node helpers", async () => {
+  const entity = await loadEntity("entity-connect.json");
+  const result = (0, import_instantiate.instantiateEntityObject3D)({ THREE, entity, mode: "hierarchy" });
+  try {
+    import_strict.default.equal(result.mode, "hierarchy");
+    import_strict.default.ok(result.object instanceof THREE.Group, "hierarchy returns group");
+    import_strict.default.ok(result.scene.root === result.object, "group matches scene root");
+    import_strict.default.ok(typeof result.findNode === "function", "findNode helper available");
+    import_strict.default.ok(result.findNode(entity.geometry.root.id), "root node resolves");
+    let counted = 0;
+    result.forEachNode(() => {
+      counted += 1;
+    });
+    import_strict.default.equal(counted > 0, true, "forEachNode iterates nodes");
+    import_strict.default.ok(Array.isArray(result.clips), "clips array present");
+  } finally {
+    dispose(result);
+  }
 });
-test('instantiateEntityObject3D merged mode returns a reusable group', async () => {
-    const entity = await loadEntity('entity-connect.json');
-    const result = instantiateEntityObject3D({ THREE, entity, mode: 'merged' });
-    try {
-        assert.equal(result.mode, 'merged');
-        assert.ok(result.object instanceof THREE.Object3D, 'merged returns object3D');
-    }
-    finally {
-        dispose(result);
-    }
+(0, import_node_test.default)("instantiateEntityObject3D merged mode returns a reusable group", async () => {
+  const entity = await loadEntity("entity-connect.json");
+  const result = (0, import_instantiate.instantiateEntityObject3D)({ THREE, entity, mode: "merged" });
+  try {
+    import_strict.default.equal(result.mode, "merged");
+    import_strict.default.ok(result.object instanceof THREE.Object3D, "merged returns object3D");
+  } finally {
+    dispose(result);
+  }
 });
-test('instantiateEntityObject3D skinned mode returns skinned mesh and bone helpers', async () => {
-    const entity = await loadEntity('entity-connect.json');
-    const result = instantiateEntityObject3D({ THREE, entity, mode: 'skinned' });
-    try {
-        assert.equal(result.mode, 'skinned');
-        assert.ok(result.object instanceof THREE.SkinnedMesh, 'skinned returns SkinnedMesh');
-        assert.ok(result.skeleton instanceof THREE.Skeleton, 'skeleton available');
-        assert.ok(result.findBone(entity.geometry.root.id), 'findBone resolves root');
-        let boneCount = 0;
-        result.forEachBone(() => {
-            boneCount += 1;
-        });
-        assert.equal(boneCount > 0, true, 'forEachBone iterates bones');
-        assert.ok(Array.isArray(result.clips), 'clips array present');
-    }
-    finally {
-        dispose(result);
-    }
+(0, import_node_test.default)("instantiateEntityObject3D skinned mode returns skinned mesh and bone helpers", async () => {
+  const entity = await loadEntity("entity-connect.json");
+  const result = (0, import_instantiate.instantiateEntityObject3D)({ THREE, entity, mode: "skinned" });
+  try {
+    import_strict.default.equal(result.mode, "skinned");
+    import_strict.default.ok(result.object instanceof THREE.SkinnedMesh, "skinned returns SkinnedMesh");
+    import_strict.default.ok(result.skeleton instanceof THREE.Skeleton, "skeleton available");
+    import_strict.default.ok(result.findBone(entity.geometry.root.id), "findBone resolves root");
+    let boneCount = 0;
+    result.forEachBone(() => {
+      boneCount += 1;
+    });
+    import_strict.default.equal(boneCount > 0, true, "forEachBone iterates bones");
+    import_strict.default.ok(Array.isArray(result.clips), "clips array present");
+  } finally {
+    dispose(result);
+  }
 });

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

@@ -1,20 +1,42 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import * as THREE from 'three';
-import { attachBoxelOverlays } from '../src/index.js';
-test('attachBoxelOverlays adds helpers and disposes cleanly', () => {
-    const THREERef = THREE;
-    const target = new THREERef.Object3D();
-    target.userData.size = [1, 2, 3];
-    target.userData.sockets = [
-        [0.5, 1, 0],
-        [-0.5, 0, 0],
-    ];
-    const handles = attachBoxelOverlays({ THREE: THREERef, target }, { origin: true, bounds: true, sockets: true, color: 0xff00ff, opacity: 0.5 });
-    assert.ok(handles.origin, 'origin helper not attached');
-    assert.ok(handles.bounds && handles.bounds.length === 1, 'bounds helper missing');
-    assert.ok(handles.sockets && handles.sockets.length === 2, 'socket helpers missing');
-    assert.strictEqual(target.children.includes(handles.origin), true);
-    handles.dispose();
-    assert.strictEqual(target.children.length, 0, 'helpers should be removed after 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)("attachBoxelOverlays adds helpers and disposes cleanly", () => {
+  const THREERef = THREE;
+  const target = new THREERef.Object3D();
+  target.userData.size = [1, 2, 3];
+  target.userData.sockets = [
+    [0.5, 1, 0],
+    [-0.5, 0, 0]
+  ];
+  const handles = (0, import_src.attachBoxelOverlays)({ THREE: THREERef, target }, { origin: true, bounds: true, sockets: true, color: 16711935, opacity: 0.5 });
+  import_strict.default.ok(handles.origin, "origin helper not attached");
+  import_strict.default.ok(handles.bounds && handles.bounds.length === 1, "bounds helper missing");
+  import_strict.default.ok(handles.sockets && handles.sockets.length === 2, "socket helpers missing");
+  import_strict.default.strictEqual(target.children.includes(handles.origin), true);
+  handles.dispose();
+  import_strict.default.strictEqual(target.children.length, 0, "helpers should be removed after dispose");
 });

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

@@ -1,51 +1,73 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import * as THREE from 'three';
-import { createBoxelScene, createBoxelNodeScene } from '../src/index.js';
-test('createBoxelScene respects node filters and exposes reusable clips', () => {
-    const entity = {
-        id: 'filter-test',
-        geometry: {
-            id: 'geom',
-            root: {
-                id: 'Root',
-                position: [0, 0, 0],
-                children: [
-                    {
-                        id: 'Arm',
-                        position: [2, 0, 0],
-                        mesh: 'arm',
-                        children: [],
-                    },
-                    {
-                        id: 'Leg',
-                        position: [-2, 0, 0],
-                        mesh: 'leg',
-                        children: [],
-                    },
-                ],
-            },
-        },
-        primitives: [
-            { id: 'arm', kind: 'plain_box', size: [1, 1, 1], material: 'mat' },
-            { id: 'leg', kind: 'plain_box', size: [1, 1, 1], material: 'mat' },
-        ],
-        materials: [{ id: 'mat', baseColor: [255, 100, 100] }],
-        textures: [],
-        patterns: [],
-        animations: [],
-    };
-    const full = createBoxelScene({ THREE, entity });
-    assert.ok(full.nodes.has('Arm'));
-    assert.ok(full.nodes.has('Leg'));
-    const filtered = createBoxelScene({ THREE, entity }, { nodes: 'Arm' });
-    assert.strictEqual(filtered.root.children.length, 1, 'filtered scene should include one limb');
-    assert.ok(filtered.nodes.has('Arm'));
-    assert.ok(!filtered.nodes.has('Leg'));
-    const nodeScene = createBoxelNodeScene({ THREE, entity }, 'Leg');
-    assert.strictEqual(nodeScene.nodes.size, 1, 'node scene should only contain requested limb');
-    assert.ok(nodeScene.nodes.has('Leg'));
-    full.dispose();
-    filtered.dispose();
-    nodeScene.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 respects node filters and exposes reusable clips", () => {
+  const entity = {
+    id: "filter-test",
+    geometry: {
+      id: "geom",
+      root: {
+        id: "Root",
+        position: [0, 0, 0],
+        children: [
+          {
+            id: "Arm",
+            position: [2, 0, 0],
+            mesh: "arm",
+            children: []
+          },
+          {
+            id: "Leg",
+            position: [-2, 0, 0],
+            mesh: "leg",
+            children: []
+          }
+        ]
+      }
+    },
+    primitives: [
+      { id: "arm", kind: "plain_box", size: [1, 1, 1], material: "mat" },
+      { id: "leg", kind: "plain_box", size: [1, 1, 1], material: "mat" }
+    ],
+    materials: [{ id: "mat", baseColor: [255, 100, 100] }],
+    textures: [],
+    patterns: [],
+    animations: []
+  };
+  const full = (0, import_src.createBoxelScene)({ THREE, entity });
+  import_strict.default.ok(full.nodes.has("Arm"));
+  import_strict.default.ok(full.nodes.has("Leg"));
+  const filtered = (0, import_src.createBoxelScene)({ THREE, entity }, { nodes: "Arm" });
+  import_strict.default.strictEqual(filtered.root.children.length, 1, "filtered scene should include one limb");
+  import_strict.default.ok(filtered.nodes.has("Arm"));
+  import_strict.default.ok(!filtered.nodes.has("Leg"));
+  const nodeScene = (0, import_src.createBoxelNodeScene)({ THREE, entity }, "Leg");
+  import_strict.default.strictEqual(nodeScene.nodes.size, 1, "node scene should only contain requested limb");
+  import_strict.default.ok(nodeScene.nodes.has("Leg"));
+  full.dispose();
+  filtered.dispose();
+  nodeScene.dispose();
 });