@playdrop/playdrop-cli 0.3.1-build.1

package/node_modules/@playdrop/entity-three/dist/src/exporters/image.d.ts

@@ -0,0 +1,18 @@
+import type * as THREEType from 'three';
+import type { Entity } from '@playdrop/entity-core';
+import { type ExportMode } from './glb.js';
+declare const DIRECTION_VECTORS: Record<string, [number, number, number]>;
+export interface RenderEntityImageOptions {
+    THREE: typeof THREEType;
+    renderer: THREEType.WebGLRenderer;
+    entity: Entity;
+    mode?: ExportMode;
+    animationIds?: string[] | null;
+    animationId?: string | null;
+    width?: number;
+    height?: number;
+    direction?: keyof typeof DIRECTION_VECTORS;
+    background?: THREEType.ColorRepresentation | null;
+}
+export declare function renderEntityToDataURL(options: RenderEntityImageOptions): Promise<string>;
+export {};

package/node_modules/@playdrop/entity-three/dist/src/exporters/image.js

@@ -0,0 +1,288 @@
+import { createEntityScene } from '../scene.js';
+import { createEntitySceneGraph } from './glb.js';
+import { buildEntitySkinnedMesh } from '../skinned-mesh.js';
+import { buildAnimations } from '../animations.js';
+function findNodeById(root, id) {
+    if (root.id === id)
+        return root;
+    for (const child of root.children) {
+        const found = findNodeById(child, id);
+        if (found)
+            return found;
+    }
+    return null;
+}
+const DIRECTION_VECTORS = {
+    preview: [1.2, 1.4, 1.3],
+    headshot: [-0.35, 0.05, 1.0],
+    top: [0, 1, 0],
+    bottom: [0, -1, 0],
+    front: [0, 0, 1],
+    back: [0, 0, -1],
+    left: [-1, 0, 0],
+    right: [1, 0, 0],
+};
+const UP_VECTORS = {
+    top: [0, 0, -1],
+    bottom: [0, 0, 1],
+};
+const CAMERA_DISTANCE_FACTOR = 1.25;
+const DEFAULT_MIN_DISTANCE = 2.5;
+const HEADSHOT_MIN_DISTANCE = 2;
+const HEADSHOT_RADIUS_PADDING = 1.3;
+const HEAD_NODE_IDS = ['head', 'Head'];
+const HEADSHOT_VERTICAL_OFFSET_RATIO = 2 / 3;
+const AMBIENT_LIGHT_COLOR = 0xb4c6fc;
+const AMBIENT_LIGHT_INTENSITY = 2.2;
+const DIRECTIONAL_LIGHT_COLOR = 0xf8fafc;
+const DIRECTIONAL_LIGHT_INTENSITY = 1.3;
+const DIRECTIONAL_LIGHT_MIN_HEIGHT_OFFSET = 2;
+const SHADOW_MAP_SIZE = 2048;
+const SHADOW_BIAS = -0.00012;
+const SHADOW_NORMAL_BIAS = 0.006;
+const SUPER_SAMPLE_RATIO = 2;
+export async function renderEntityToDataURL(options) {
+    const { THREE: three, renderer, entity, mode = 'hierarchical', animationId, width, height, direction = 'preview', background = null, } = options;
+    const sizeTarget = new three.Vector2();
+    renderer.getSize(sizeTarget);
+    const previousWidth = sizeTarget.x;
+    const previousHeight = sizeTarget.y;
+    const previousPixelRatio = renderer.getPixelRatio();
+    const previousShadowEnabled = renderer.shadowMap.enabled;
+    const previousShadowType = renderer.shadowMap.type;
+    const previousShadowAutoUpdate = renderer.shadowMap.autoUpdate;
+    const clearColor = renderer.getClearColor(new three.Color());
+    const clearAlpha = renderer.getClearAlpha();
+    const targetWidth = width ?? (previousWidth || 1024);
+    const targetHeight = height ?? (previousHeight || 1024);
+    renderer.setPixelRatio(SUPER_SAMPLE_RATIO);
+    renderer.setSize(targetWidth, targetHeight, false);
+    renderer.shadowMap.enabled = true;
+    renderer.shadowMap.autoUpdate = true;
+    renderer.shadowMap.type = three.PCFSoftShadowMap;
+    if (background === null) {
+        renderer.setClearColor(0x000000, 0);
+    }
+    else if (background !== undefined) {
+        const color = new three.Color(background);
+        renderer.setClearColor(color, 1);
+    }
+    let disposeScene;
+    let root;
+    let animations = [];
+    let nodeLookup = null;
+    if (mode === 'hierarchical') {
+        const scene = createEntityScene({ THREE: three, entity });
+        disposeScene = scene.dispose;
+        root = scene.root;
+        animations = scene.animations;
+        nodeLookup = new Map();
+        scene.nodes.forEach(meta => {
+            nodeLookup.set(meta.id, meta.object);
+        });
+    }
+    else if (mode === 'skinned') {
+        const skinned = buildEntitySkinnedMesh({ THREE: three, entity });
+        const group = new three.Group();
+        group.add(skinned.mesh);
+        disposeScene = () => {
+            skinned.dispose();
+        };
+        root = group;
+        nodeLookup = new Map();
+        skinned.boneMap.forEach((bone, nodeId) => nodeLookup.set(nodeId, bone));
+        animations = buildAnimations(three, entity, nodeLookup);
+    }
+    else {
+        const sceneGraph = createEntitySceneGraph({ THREE: three, model: entity, mode });
+        disposeScene = sceneGraph.dispose;
+        root = sceneGraph.root;
+        animations = sceneGraph.animations;
+        nodeLookup = sceneGraph.nodeLookup;
+    }
+    const scene = new three.Scene();
+    scene.background = background === null ? null : background === undefined ? null : new three.Color(background);
+    scene.add(root);
+    root.traverse(obj => {
+        const mesh = obj;
+        if (mesh.isMesh) {
+            mesh.castShadow = true;
+            mesh.receiveShadow = true;
+        }
+    });
+    const ambient = new three.AmbientLight(AMBIENT_LIGHT_COLOR, AMBIENT_LIGHT_INTENSITY);
+    const directional = new three.DirectionalLight(DIRECTIONAL_LIGHT_COLOR, DIRECTIONAL_LIGHT_INTENSITY);
+    directional.castShadow = true;
+    directional.shadow.mapSize.set(SHADOW_MAP_SIZE, SHADOW_MAP_SIZE);
+    directional.shadow.bias = SHADOW_BIAS;
+    directional.shadow.normalBias = SHADOW_NORMAL_BIAS;
+    scene.add(ambient);
+    scene.add(directional);
+    let dataUrl = '';
+    const requestedAnimationId = typeof animationId === 'string' && animationId.trim().length > 0 ? animationId.trim() : null;
+    const normalizedRequestedAnimationId = requestedAnimationId?.toLowerCase();
+    let sampleClip = null;
+    if (requestedAnimationId) {
+        sampleClip =
+            animations.find(entry => entry.id === requestedAnimationId ||
+                entry.id.toLowerCase() === normalizedRequestedAnimationId) ?? null;
+        if (!sampleClip) {
+            throw new Error(`Animation "${requestedAnimationId}" was not found for this entity.`);
+        }
+    }
+    else if ((direction === 'preview' || direction === 'headshot') && animations.length > 0) {
+        const idleAnimation = animations.find(entry => entry.id.toLowerCase().includes('idle'));
+        if (idleAnimation) {
+            sampleClip = idleAnimation;
+        }
+    }
+    let mixer = null;
+    if (sampleClip) {
+        mixer = new three.AnimationMixer(root);
+        const action = mixer.clipAction(sampleClip.clip);
+        action.play();
+        action.paused = true;
+        const firstKeyframe = sampleClip.channels.reduce((min, channel) => {
+            const times = channel.track.times;
+            if (!times || times.length === 0) {
+                return min;
+            }
+            const firstTime = times[0];
+            return Number.isFinite(firstTime) && firstTime < min ? firstTime : min;
+        }, Number.POSITIVE_INFINITY);
+        const sampleTime = Number.isFinite(firstKeyframe) ? firstKeyframe : 0;
+        mixer.setTime(sampleTime);
+        mixer.update(0);
+    }
+    try {
+        root.updateMatrixWorld(true);
+        const bounds = new three.Box3().setFromObject(root);
+        const sphere = bounds.getBoundingSphere(new three.Sphere());
+        const center = sphere.center.clone();
+        let radius = sphere.radius || 1;
+        let headCenter = null;
+        if (direction === 'headshot' && nodeLookup) {
+            const headObject = HEAD_NODE_IDS.map(id => nodeLookup.get(id)).find(Boolean);
+            if (headObject) {
+                let headBounds;
+                // For skinned meshes (bones), use node definition to avoid bone hierarchy inflation
+                if (mode === 'skinned' && headObject.type === 'Bone') {
+                    const headNode = findNodeById(entity.geometry.root, headObject.name);
+                    if (headNode?.size) {
+                        // Calculate bounds from node definition
+                        headObject.updateMatrixWorld(true);
+                        const nodeCenter = headNode.center ?? [0, 0, 0];
+                        const halfSize = headNode.size.map(s => s / 2);
+                        // Create local bounds
+                        const localMin = new three.Vector3(nodeCenter[0] - halfSize[0], nodeCenter[1] - halfSize[1], nodeCenter[2] - halfSize[2]);
+                        const localMax = new three.Vector3(nodeCenter[0] + halfSize[0], nodeCenter[1] + halfSize[1], nodeCenter[2] + halfSize[2]);
+                        // Transform to world space
+                        localMin.applyMatrix4(headObject.matrixWorld);
+                        localMax.applyMatrix4(headObject.matrixWorld);
+                        headBounds = new three.Box3(localMin, localMax);
+                    }
+                    else {
+                        // Fallback to setFromObject if no size defined
+                        headBounds = new three.Box3().setFromObject(headObject);
+                    }
+                }
+                else {
+                    // For hierarchical mode, use setFromObject as before
+                    headBounds = new three.Box3().setFromObject(headObject);
+                }
+                if (!headBounds.isEmpty()) {
+                    headCenter = headBounds.getCenter(new three.Vector3());
+                    center.copy(headCenter);
+                    const headSphere = headBounds.getBoundingSphere(new three.Sphere());
+                    const headRadius = headSphere.radius || radius;
+                    radius = Math.max(headRadius * HEADSHOT_RADIUS_PADDING, headRadius);
+                    center.y -= radius * HEADSHOT_VERTICAL_OFFSET_RATIO;
+                }
+            }
+        }
+        const camera = new three.PerspectiveCamera(50, targetWidth / targetHeight, 0.1, Math.max(1000, radius * 10));
+        const dir = DIRECTION_VECTORS[direction] ?? DIRECTION_VECTORS.preview;
+        const target = new three.Vector3().fromArray(dir).normalize();
+        const minDistance = direction === 'headshot' ? HEADSHOT_MIN_DISTANCE : DEFAULT_MIN_DISTANCE;
+        let distance = Math.max(radius * CAMERA_DISTANCE_FACTOR, minDistance);
+        const basePosition = center.clone().add(target.clone().multiplyScalar(distance));
+        if (direction === 'headshot' && headCenter) {
+            const deltaY = headCenter.y - center.y;
+            if (Math.abs(deltaY) >= distance) {
+                distance = Math.abs(deltaY) + 0.1;
+            }
+            const horizontalMagnitude = Math.sqrt(Math.max(0, distance * distance - deltaY * deltaY));
+            const horizontalDir = new three.Vector3(target.x, 0, target.z);
+            if (horizontalDir.lengthSq() > 0) {
+                horizontalDir.normalize().multiplyScalar(horizontalMagnitude);
+                camera.position.set(center.x + horizontalDir.x, headCenter.y, center.z + horizontalDir.z);
+            }
+            else {
+                camera.position.set(center.x, headCenter.y, center.z);
+            }
+        }
+        else {
+            camera.position.copy(basePosition);
+        }
+        camera.aspect = targetWidth / targetHeight;
+        camera.updateProjectionMatrix();
+        camera.lookAt(center);
+        const up = UP_VECTORS[direction];
+        if (up) {
+            camera.up.set(up[0], up[1], up[2]);
+        }
+        else {
+            camera.up.set(0, 1, 0);
+        }
+        const lightPosition = camera.position.clone();
+        lightPosition.y = Math.max(lightPosition.y, center.y + DIRECTIONAL_LIGHT_MIN_HEIGHT_OFFSET);
+        directional.position.copy(lightPosition);
+        directional.target.position.copy(center);
+        directional.target.updateMatrixWorld();
+        const shadowCamera = directional.shadow.camera;
+        const cameraRange = Math.max(10, radius * 4);
+        shadowCamera.left = -cameraRange;
+        shadowCamera.right = cameraRange;
+        shadowCamera.top = cameraRange;
+        shadowCamera.bottom = -cameraRange;
+        shadowCamera.near = 0.1;
+        shadowCamera.far = Math.max(50, radius * 8);
+        shadowCamera.updateProjectionMatrix();
+        scene.add(directional.target);
+        renderer.render(scene, camera);
+        if (typeof document !== 'undefined') {
+            const captureCanvas = document.createElement('canvas');
+            captureCanvas.width = targetWidth;
+            captureCanvas.height = targetHeight;
+            const ctx = captureCanvas.getContext('2d');
+            if (!ctx) {
+                dataUrl = renderer.domElement.toDataURL('image/png');
+            }
+            else {
+                ctx.clearRect(0, 0, targetWidth, targetHeight);
+                ctx.drawImage(renderer.domElement, 0, 0, targetWidth, targetHeight);
+                dataUrl = captureCanvas.toDataURL('image/png');
+            }
+        }
+        else {
+            dataUrl = renderer.domElement.toDataURL('image/png');
+        }
+        scene.remove(directional.target);
+    }
+    finally {
+        if (mixer) {
+            mixer.stopAllAction();
+        }
+        scene.remove(root);
+        scene.remove(ambient);
+        scene.remove(directional);
+        disposeScene();
+        renderer.setSize(previousWidth || targetWidth, previousHeight || targetHeight, false);
+        renderer.setPixelRatio(previousPixelRatio || 1);
+        renderer.shadowMap.enabled = previousShadowEnabled;
+        renderer.shadowMap.type = previousShadowType;
+        renderer.shadowMap.autoUpdate = previousShadowAutoUpdate;
+        renderer.setClearColor(clearColor, clearAlpha);
+    }
+    return dataUrl;
+}

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

@@ -0,0 +1,17 @@
+export * from './types.js';
+export { createEntityScene, createNodeScene } from './scene.js';
+export { attachEntityOverlays } from './overlays.js';
+export * from './primitives.js';
+export * from './context.js';
+export * from './textures.js';
+export * from './builders.js';
+export * from './voxels/mesher.js';
+export * from './voxels/faces.js';
+export { exportModelToGLB, createEntitySceneGraph } from './exporters/glb.js';
+export type { ExportMode } from './exporters/glb.js';
+export { renderEntityToDataURL } from './exporters/image.js';
+export type { RenderEntityImageOptions } from './exporters/image.js';
+export { __testing as __entityThreeTesting } from './exporters/glb.js';
+export * from './texture-atlas.js';
+export * from './skinned-mesh.js';
+export * from './instantiate.js';

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

@@ -0,0 +1,15 @@
+export * from './types.js';
+export { createEntityScene, createNodeScene } from './scene.js';
+export { attachEntityOverlays } from './overlays.js';
+export * from './primitives.js';
+export * from './context.js';
+export * from './textures.js';
+export * from './builders.js';
+export * from './voxels/mesher.js';
+export * from './voxels/faces.js';
+export { exportModelToGLB, createEntitySceneGraph } from './exporters/glb.js';
+export { renderEntityToDataURL } from './exporters/image.js';
+export { __testing as __entityThreeTesting } from './exporters/glb.js';
+export * from './texture-atlas.js';
+export * from './skinned-mesh.js';
+export * from './instantiate.js';

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

@@ -0,0 +1,40 @@
+import type * as THREEType from 'three';
+import type { Entity } from '@playdrop/entity-core';
+import type { EntitySceneResult } from './types.js';
+import type { BuildSkinnedMeshResult } from './skinned-mesh.js';
+export type InstantiateEntityObject3DMode = 'hierarchy' | 'merged' | 'skinned';
+interface InstantiateBaseResult {
+    mode: InstantiateEntityObject3DMode;
+    dispose(): void;
+}
+export interface InstantiateHierarchyResult extends InstantiateBaseResult {
+    mode: 'hierarchy';
+    object: THREEType.Group;
+    scene: EntitySceneResult;
+    clips: THREEType.AnimationClip[];
+    findNode(nodeId: string): THREEType.Object3D | undefined;
+    forEachNode(visitor: (node: THREEType.Object3D, nodeId: string) => void): void;
+}
+export interface InstantiateMergedResult extends InstantiateBaseResult {
+    mode: 'merged';
+    object: THREEType.Group;
+}
+export interface InstantiateSkinnedResult extends InstantiateBaseResult {
+    mode: 'skinned';
+    object: THREEType.SkinnedMesh;
+    skeleton: THREEType.Skeleton;
+    boneMap: Map<string, THREEType.Bone>;
+    clips: THREEType.AnimationClip[];
+    stats: BuildSkinnedMeshResult['stats'];
+    warnings: string[];
+    findBone(nodeId: string): THREEType.Bone | undefined;
+    forEachBone(visitor: (bone: THREEType.Bone, nodeId: string) => void): void;
+}
+export type InstantiateEntityObject3DResult = InstantiateHierarchyResult | InstantiateMergedResult | InstantiateSkinnedResult;
+export interface InstantiateEntityObject3DOptions {
+    THREE: typeof THREEType;
+    entity: Entity;
+    mode?: InstantiateEntityObject3DMode;
+}
+export declare function instantiateEntityObject3D(options: InstantiateEntityObject3DOptions): InstantiateEntityObject3DResult;
+export {};

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

@@ -0,0 +1,70 @@
+import { createEntityScene } from './scene.js';
+import { createEntitySceneGraph } from './exporters/glb.js';
+import { buildEntitySkinnedMesh } from './skinned-mesh.js';
+import { buildAnimations } from './animations.js';
+function instantiateHierarchy(options) {
+    const { THREE, entity } = options;
+    const scene = createEntityScene({ THREE, entity });
+    const clips = scene.animations.map(animation => animation.clip);
+    return {
+        mode: 'hierarchy',
+        object: scene.root,
+        scene,
+        clips,
+        findNode: (nodeId) => scene.nodes.get(nodeId)?.object,
+        forEachNode: (visitor) => {
+            scene.nodes.forEach(meta => visitor(meta.object, meta.id));
+        },
+        dispose: () => {
+            scene.dispose();
+        },
+    };
+}
+function instantiateMerged(options) {
+    const { THREE, entity } = options;
+    const graph = createEntitySceneGraph({ THREE, model: entity, mode: 'merged' });
+    const { root } = graph;
+    return {
+        mode: 'merged',
+        object: root,
+        dispose: () => {
+            graph.dispose();
+        },
+    };
+}
+function instantiateSkinned(options) {
+    const { THREE, entity } = options;
+    const result = buildEntitySkinnedMesh({ THREE, entity });
+    const boneMap = result.boneMap;
+    const animations = buildAnimations(THREE, entity, boneMap);
+    const clips = animations.map(animation => animation.clip);
+    return {
+        mode: 'skinned',
+        object: result.mesh,
+        skeleton: result.skeleton,
+        boneMap,
+        clips,
+        stats: result.stats,
+        warnings: result.warnings,
+        findBone: (nodeId) => boneMap.get(nodeId),
+        forEachBone: (visitor) => {
+            boneMap.forEach((bone, nodeId) => visitor(bone, nodeId));
+        },
+        dispose: () => {
+            result.dispose();
+        },
+    };
+}
+export function instantiateEntityObject3D(options) {
+    const mode = options.mode ?? 'hierarchy';
+    switch (mode) {
+        case 'hierarchy':
+            return instantiateHierarchy(options);
+        case 'merged':
+            return instantiateMerged(options);
+        case 'skinned':
+            return instantiateSkinned(options);
+        default:
+            throw new Error(`Unknown entity instantiation mode: ${String(mode)}`);
+    }
+}

package/node_modules/@playdrop/entity-three/dist/src/nodes.d.ts

@@ -0,0 +1,8 @@
+import type * as THREEType from 'three';
+import type { Node } from '@playdrop/entity-core';
+import type { PrimitiveBuilderContext } from './context.js';
+export interface NodeBuildResult {
+    object: THREEType.Object3D;
+    nodes: Map<string, THREEType.Object3D>;
+}
+export declare function buildNodeObject(context: PrimitiveBuilderContext, node: Node, visitedPrimitives?: Set<string>): NodeBuildResult;

package/node_modules/@playdrop/entity-three/dist/src/nodes.js

@@ -0,0 +1,63 @@
+import { createPrimitiveObject, createBoundingBoxMesh } from './builders.js';
+function applyNodeTransforms(context, object, node) {
+    object.position.set(node.position[0], node.position[1], node.position[2]);
+    if (node.rotation) {
+        object.rotation.set(context.THREE.MathUtils.degToRad(node.rotation[0]), context.THREE.MathUtils.degToRad(node.rotation[1]), context.THREE.MathUtils.degToRad(node.rotation[2]));
+    }
+    if (node.scale) {
+        object.scale.set(node.scale[0], node.scale[1], node.scale[2]);
+    }
+}
+export function buildNodeObject(context, node, visitedPrimitives = new Set()) {
+    const connectMode = node.connect ?? 'none';
+    const object = new context.THREE.Object3D();
+    object.name = node.id;
+    object.userData = {
+        ...(object.userData ?? {}),
+        kind: 'entity-node',
+        nodeId: node.id,
+        primitiveId: node.mesh ?? (object.userData?.primitiveId ?? undefined),
+        connectMode,
+    };
+    if (node.size) {
+        object.userData.size = [...node.size];
+    }
+    if (node.center) {
+        object.userData.center = [...node.center];
+    }
+    applyNodeTransforms(context, object, node);
+    const nodes = new Map();
+    nodes.set(node.id, object);
+    if (node.mesh) {
+        const primitive = context.primitivesById.get(node.mesh);
+        if (primitive) {
+            const mesh = createPrimitiveObject(context, primitive, 'centered', visitedPrimitives);
+            if (mesh) {
+                if (node.center) {
+                    mesh.position.set(node.center[0], node.center[1], node.center[2]);
+                }
+                object.add(mesh);
+                if (mesh.userData?.size && !object.userData.size) {
+                    object.userData.size = mesh.userData.size;
+                }
+                if (mesh.userData?.sockets) {
+                    object.userData.sockets = mesh.userData.sockets;
+                }
+            }
+        }
+    }
+    else if (node.size) {
+        const mesh = createBoundingBoxMesh(context, node.size);
+        mesh.name = `${node.id}__placeholder`;
+        if (node.center) {
+            mesh.position.set(node.center[0], node.center[1], node.center[2]);
+        }
+        object.add(mesh);
+    }
+    node.children.forEach(child => {
+        const childResult = buildNodeObject(context, child, new Set(visitedPrimitives));
+        object.add(childResult.object);
+        childResult.nodes.forEach((value, key) => nodes.set(key, value));
+    });
+    return { object, nodes };
+}

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

@@ -0,0 +1,7 @@
+import type * as THREEType from 'three';
+import type { EntityOverlayOptions, EntityOverlayHandles } from './types.js';
+export interface CreateOverlayContext {
+    THREE: typeof THREEType;
+    target: THREEType.Object3D;
+}
+export declare function attachEntityOverlays(context: CreateOverlayContext, options?: EntityOverlayOptions): EntityOverlayHandles;

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

@@ -0,0 +1,97 @@
+function createOriginHelper(THREE, options) {
+    const axes = new THREE.AxesHelper(0.5);
+    if (options.opacity !== undefined) {
+        const axesMaterial = axes.material;
+        axesMaterial.opacity = options.opacity;
+        axesMaterial.transparent = options.opacity < 1;
+    }
+    return axes;
+}
+function createBoundsHelper(THREE, size, options) {
+    const geometry = new THREE.BoxGeometry(size[0], size[1], size[2]);
+    const material = new THREE.LineDashedMaterial({
+        color: options.color ?? 0xffffff,
+        dashSize: options.dashed ? 0.1 : 1,
+        gapSize: options.dashed ? 0.05 : 0,
+        transparent: options.opacity !== undefined,
+        opacity: options.opacity ?? 1,
+    });
+    const edges = new THREE.EdgesGeometry(geometry);
+    const line = new THREE.LineSegments(edges, material);
+    line.computeLineDistances();
+    return line;
+}
+function createSocketHelper(THREE, options) {
+    const geometry = new THREE.SphereGeometry(0.05, 8, 8);
+    const material = new THREE.MeshBasicMaterial({
+        color: options.color ?? 0xffff00,
+        transparent: options.opacity !== undefined,
+        opacity: options.opacity ?? 1,
+        wireframe: true,
+    });
+    return new THREE.Mesh(geometry, material);
+}
+function disposeObjectResources(object) {
+    object.traverse(entry => {
+        const mesh = entry;
+        if ('geometry' in mesh && mesh.geometry) {
+            const geometry = mesh.geometry;
+            geometry?.dispose?.();
+        }
+        if ('material' in mesh && mesh.material) {
+            const material = mesh.material;
+            const disposeMaterial = (mat) => {
+                const typedMaterial = mat;
+                typedMaterial.map?.dispose?.();
+                typedMaterial.emissiveMap?.dispose?.();
+                typedMaterial.dispose?.();
+            };
+            if (Array.isArray(material))
+                material.forEach(disposeMaterial);
+            else
+                disposeMaterial(material);
+        }
+    });
+}
+export function attachEntityOverlays(context, options = {}) {
+    const { THREE, target } = context;
+    const overlays = {
+        dispose: () => {
+            if (overlays.origin) {
+                target.remove(overlays.origin);
+                disposeObjectResources(overlays.origin);
+            }
+            overlays.bounds?.forEach(bound => {
+                target.remove(bound);
+                disposeObjectResources(bound);
+            });
+            overlays.sockets?.forEach(socket => {
+                target.remove(socket);
+                disposeObjectResources(socket);
+            });
+            overlays.origin = undefined;
+            overlays.bounds = undefined;
+            overlays.sockets = undefined;
+        },
+    };
+    if (options.origin) {
+        const origin = createOriginHelper(THREE, options);
+        overlays.origin = origin;
+        target.add(origin);
+    }
+    if (options.bounds && target.userData?.size) {
+        const bound = createBoundsHelper(THREE, target.userData.size, options);
+        overlays.bounds = [bound];
+        target.add(bound);
+    }
+    if (options.sockets && target.userData?.sockets) {
+        const sockets = target.userData.sockets.map(position => {
+            const helper = createSocketHelper(THREE, options);
+            helper.position.set(position[0], position[1], position[2]);
+            target.add(helper);
+            return helper;
+        });
+        overlays.sockets = sockets;
+    }
+    return overlays;
+}

package/node_modules/@playdrop/entity-three/dist/src/primitives.d.ts

@@ -0,0 +1,4 @@
+import type * as THREEType from 'three';
+export type BoxSize = [number, number, number];
+export declare function createBoxGeometry(THREE: typeof THREEType, size: BoxSize): THREEType.BoxGeometry;
+export declare function collectGroupVertexIndices(geometry: THREEType.BufferGeometry): Array<Set<number>>;

package/node_modules/@playdrop/entity-three/dist/src/primitives.js

@@ -0,0 +1,20 @@
+export function createBoxGeometry(THREE, size) {
+    return new THREE.BoxGeometry(size[0], size[1], size[2]);
+}
+export function collectGroupVertexIndices(geometry) {
+    const indexAttr = geometry.index;
+    const groups = geometry.groups;
+    if (!indexAttr || !groups || groups.length === 0) {
+        return [];
+    }
+    const indices = indexAttr.array;
+    const result = [];
+    groups.forEach(group => {
+        const set = new Set();
+        for (let i = 0; i < group.count; i += 1) {
+            set.add(indices[group.start + i]);
+        }
+        result.push(set);
+    });
+    return result;
+}

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

@@ -0,0 +1,3 @@
+import type { EntityThreeContext, EntitySceneOptions, EntitySceneResult } from './types.js';
+export declare function createEntityScene(context: EntityThreeContext, options?: EntitySceneOptions): EntitySceneResult;
+export declare function createNodeScene(context: EntityThreeContext, nodeId: string, options?: EntitySceneOptions): EntitySceneResult;