@playdrop/playdrop-cli 0.3.1-build.1

package/node_modules/@playdrop/entity-three/dist/test/fixtures/render-worker.js

@@ -0,0 +1,63 @@
+import * as THREE from 'three';
+import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
+import { exportModelToGLB, renderEntityToDataURL } from '../../src/index.js';
+import { parseEntity } from '@playdrop/entity-core';
+function arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    const chunkSize = 0x8000;
+    let binary = '';
+    for (let index = 0; index < bytes.length; index += chunkSize) {
+        const chunk = bytes.subarray(index, index + chunkSize);
+        binary += String.fromCharCode(...chunk);
+    }
+    return btoa(binary);
+}
+let cachedRenderer = null;
+function getRenderer() {
+    if (cachedRenderer) {
+        return cachedRenderer;
+    }
+    const canvas = document.getElementById('viewport');
+    if (!canvas) {
+        throw new Error('render_canvas_unavailable');
+    }
+    cachedRenderer = new THREE.WebGLRenderer({
+        canvas,
+        antialias: true,
+        preserveDrawingBuffer: true,
+        alpha: true,
+    });
+    return cachedRenderer;
+}
+async function exportEntity(modelJson, options) {
+    const model = parseEntity(modelJson);
+    const blob = await exportModelToGLB({
+        THREE,
+        GLTFExporterCtor: GLTFExporter,
+        model,
+        mode: options?.mode,
+        animationIds: options?.animationIds,
+    });
+    const arrayBuffer = await blob.arrayBuffer();
+    return arrayBufferToBase64(arrayBuffer);
+}
+async function renderEntity(modelJson, options) {
+    const model = parseEntity(modelJson);
+    const renderer = getRenderer();
+    renderer.setPixelRatio(1);
+    return renderEntityToDataURL({
+        THREE,
+        renderer,
+        entity: model,
+        mode: options?.mode ?? 'hierarchical',
+        animationIds: options?.animationIds,
+        width: options?.width,
+        height: options?.height,
+        direction: options?.direction,
+        background: options?.background ?? null,
+    });
+}
+window.entityExport = {
+    exportEntity,
+    renderEntity,
+};

package/node_modules/@playdrop/entity-three/dist/test/glb-skinned.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,86 @@
+"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 { parseEntity } from '@playdrop/entity-core';
+import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
+import { createEntitySceneGraph, exportModelToGLB } from '../src/exporters/glb.js';
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const fixture = (...segments) => path.resolve(HERE, '../../test/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'));
+        }
+    }
+    globalThis.FileReader = NodeFileReader;
+}
+async function loadEntity(relativePath) {
+    const raw = await readFile(fixture(relativePath), 'utf-8');
+    return parseEntity(JSON.parse(raw));
+}
+test('createEntitySceneGraph skinned mode exposes skinned mesh and bones', async () => {
+    const entity = await loadEntity('entity-connect.json');
+    const graph = createEntitySceneGraph({ 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();
+    }
+});
+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');
+});

package/node_modules/@playdrop/entity-three/dist/test/index.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createEntityScene, createNodeScene, attachEntityOverlays, } from '../src/index.js';
+test('entity-three exposes renderer entry points', () => {
+    assert.equal(typeof createEntityScene, 'function');
+    assert.equal(typeof createNodeScene, 'function');
+    assert.equal(typeof attachEntityOverlays, 'function');
+});

package/node_modules/@playdrop/entity-three/dist/test/instantiate.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,68 @@
+"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 { parseEntity } from '@playdrop/entity-core';
+import { instantiateEntityObject3D, } from '../src/instantiate.js';
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const fixture = (...segments) => path.resolve(HERE, '../../test/fixtures', ...segments);
+async function loadEntity(relativePath) {
+    const raw = await readFile(fixture(relativePath), 'utf-8');
+    return parseEntity(JSON.parse(raw));
+}
+function dispose(result) {
+    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);
+    }
+});
+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);
+    }
+});
+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);
+    }
+});

package/node_modules/@playdrop/entity-three/dist/test/overlays.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as THREE from 'three';
+import { attachEntityOverlays } from '../src/index.js';
+test('attachEntityOverlays 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 = attachEntityOverlays({ 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');
+});

package/node_modules/@playdrop/entity-three/dist/test/scene-filter.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,51 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as THREE from 'three';
+import { createEntityScene, createNodeScene } from '../src/index.js';
+test('createEntityScene 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 = createEntityScene({ THREE, entity });
+    assert.ok(full.nodes.has('Arm'));
+    assert.ok(full.nodes.has('Leg'));
+    const filtered = createEntityScene({ 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 = createNodeScene({ 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();
+});

package/node_modules/@playdrop/entity-three/dist/test/scene-smoke.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,63 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as THREE from 'three';
+import { createEntityScene } from '../src/index.js';
+test('createEntityScene 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 = createEntityScene({ 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();
+});

package/node_modules/@playdrop/entity-three/dist/test/skinned-mesh.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,51 @@
+"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 { parseEntity } from '@playdrop/entity-core';
+import { buildEntitySkinnedMesh } from '../src/skinned-mesh.js';
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const fixture = (...segments) => path.resolve(HERE, '../../test/fixtures', ...segments);
+test('buildEntitySkinnedMesh exposes atlas and connect stats', async () => {
+    const entityRaw = await readFile(fixture('entity-connect.json'), 'utf-8');
+    const entity = parseEntity(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');
+        }
+    }
+    finally {
+        result.dispose();
+    }
+});

package/node_modules/@playdrop/entity-three/dist/test/textured-overlay.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,116 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as THREE from 'three';
+import { createEntityScene, createEntitySceneGraph } from '../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: '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 = createEntityScene({ 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;
+            }
+        }
+    });
+    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();
+});
+test('merged scene graph export includes overlay atlas data', () => {
+    const graph = createEntitySceneGraph({ 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();
+});

package/node_modules/@playdrop/entity-three/dist/test/voxels.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,20 @@
+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],
+});
+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');
+});

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

@@ -0,0 +1,27 @@
+{
+  "name": "@playdrop/entity-three",
+  "version": "1.0.0",
+  "description": "Three.js utilities for rendering and exporting Playdrop entities",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "npm run build && node --test dist/test/**/*.test.js",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@playdrop/entity-core": "file:../entity-core"
+  },
+  "peerDependencies": {
+    "three": "^0.181.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/three": "^0.181.0",
+    "esbuild": "^0.24.0",
+    "playwright-core": "^1.56.0",
+    "three": "^0.181.1",
+    "typescript": "^5.3.0"
+  }
+}