@playdrop/playdrop-cli 0.3.1-build.1 → 0.3.4-build.1

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/context.d.ts

@@ -1,5 +1,5 @@
 import type * as THREEType from 'three';
-import type { Entity, Material, Primitive } from '@playdrop/entity-core';
+import type { BoxelDefinition, Material, Primitive } from '@playdrop/boxel-core';
 import type { TextureBundle } from './textures.js';
 export interface BuilderSettings {
     enableShadows: boolean;
@@ -7,13 +7,13 @@ export interface BuilderSettings {
 export interface PrimitiveBuilderContext {
     THREE: typeof THREEType;
     settings: BuilderSettings;
-    entity: Entity | null;
+    entity: BoxelDefinition | null;
     materialsById: Map<string, Material>;
     primitivesById: Map<string, Primitive>;
     textureCache: Map<string, TextureBundle>;
 }
 export interface BuilderUpdate {
-    entity?: Entity | null;
+    entity?: BoxelDefinition | null;
     settings?: Partial<BuilderSettings>;
 }
 export declare function createBuilderContext(options: {

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/exporters/glb.d.ts

@@ -1,8 +1,8 @@
 import type * as THREEType from 'three';
 import type { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
-import type { Entity, Primitive, Material, Texture, Pattern } from '@playdrop/entity-core';
+import type { BoxelDefinition, Primitive, Material, Texture, Pattern } from '@playdrop/boxel-core';
 import { type VoxelFacePatch } from '../voxels/faces.js';
-import type { EntitySceneAnimation } from '../types.js';
+import type { BoxelSceneAnimation } from '../types.js';
 interface TexturePixels {
     id: string;
     width: number;
@@ -32,20 +32,20 @@ export type ExportMode = 'hierarchical' | 'merged' | 'skinned';
 interface ExportModelOptions {
     THREE: typeof THREEType;
     GLTFExporterCtor: new () => GLTFExporter;
-    model: Entity;
+    model: BoxelDefinition;
     mode?: ExportMode;
     binary?: boolean;
     animationIds?: string[] | null;
 }
 export declare function exportModelToGLB(options: ExportModelOptions): Promise<Blob>;
-export declare function createEntitySceneGraph(options: {
+export declare function createBoxelSceneGraph(options: {
     THREE: typeof THREEType;
-    model: Entity;
+    model: BoxelDefinition;
     mode?: ExportMode;
 }): SceneGraphResult;
 interface ExportContext {
     THREE: typeof THREEType;
-    model: Entity;
+    model: BoxelDefinition;
     materialsById: Map<string, Material>;
     primitivesById: Map<string, Primitive>;
     texturesById: Map<string, Texture>;
@@ -54,7 +54,7 @@ interface ExportContext {
     voxelSurfacesByPrimitive: Map<string, CachedVoxelPatch[]>;
     plainMaterialCache: Map<string, THREEType.MeshStandardMaterial>;
 }
-declare function createExportContext(THREE: typeof THREEType, model: Entity): ExportContext;
+declare function createExportContext(THREE: typeof THREEType, model: BoxelDefinition): ExportContext;
 interface AtlasBuildOptions {
     THREE: typeof THREEType;
     materialsById: Map<string, Material>;
@@ -63,11 +63,11 @@ interface AtlasBuildOptions {
     usedTextureIds: Set<string>;
 }
 declare function buildTextureAtlas(options: AtlasBuildOptions, extraEntries?: TexturePixels[]): TextureAtlas | null;
-declare function collectUsedTextureIds(model: Entity, primitivesById: Map<string, Primitive>): Set<string>;
+declare function collectUsedTextureIds(model: BoxelDefinition, primitivesById: Map<string, Primitive>): Set<string>;
 interface SceneGraphResult {
     root: THREEType.Object3D;
     nodeLookup: Map<string, THREEType.Object3D>;
-    animations: EntitySceneAnimation[];
+    animations: BoxelSceneAnimation[];
     dispose: () => void;
 }
 declare function buildSceneGraph(context: ExportContext, mode: ExportMode): SceneGraphResult;

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/exporters/glb.js

@@ -1,6 +1,6 @@
 import { generateVoxelFaceSurfaces, FACE_ORDER } from '../voxels/faces.js';
 import { createBoxGeometry, collectGroupVertexIndices } from '../primitives.js';
-import { createEntityScene } from '../scene.js';
+import { createBoxelScene } from '../scene.js';
 import { buildEntitySkinnedMesh } from '../skinned-mesh.js';
 import { buildAnimations } from '../animations.js';
 const DEFAULT_COLOR = [59, 130, 246];
@@ -93,7 +93,7 @@ export async function exportModelToGLB(options) {
         }
     });
 }
-export function createEntitySceneGraph(options) {
+export function createBoxelSceneGraph(options) {
     const { THREE, model } = options;
     const mode = options.mode ?? 'merged';
     const context = createExportContext(THREE, model);
@@ -493,7 +493,7 @@ function collectUsedTextureIds(model, primitivesById) {
 }
 function buildSceneGraph(context, mode) {
     if (mode === 'merged') {
-        const scene = createEntityScene({ THREE: context.THREE, entity: context.model });
+        const scene = createBoxelScene({ THREE: context.THREE, entity: context.model });
         const root = buildMergedGroupFromScene(context, scene);
         scene.dispose();
         const dispose = () => {
@@ -540,7 +540,7 @@ function buildSceneGraph(context, mode) {
             dispose,
         };
     }
-    const scene = createEntityScene({ THREE: context.THREE, entity: context.model });
+    const scene = createBoxelScene({ THREE: context.THREE, entity: context.model });
     const nodeLookup = new Map();
     scene.nodes.forEach(meta => {
         nodeLookup.set(meta.id, meta.object);

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/exporters/image.d.ts

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

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/exporters/image.js

@@ -1,5 +1,5 @@
-import { createEntityScene } from '../scene.js';
-import { createEntitySceneGraph } from './glb.js';
+import { createBoxelScene } from '../scene.js';
+import { createBoxelSceneGraph } from './glb.js';
 import { buildEntitySkinnedMesh } from '../skinned-mesh.js';
 import { buildAnimations } from '../animations.js';
 function findNodeById(root, id) {
@@ -41,7 +41,7 @@ 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) {
+export async function renderBoxelToDataURL(options) {
     const { THREE: three, renderer, entity, mode = 'hierarchical', animationId, width, height, direction = 'preview', background = null, } = options;
     const sizeTarget = new three.Vector2();
     renderer.getSize(sizeTarget);
@@ -72,7 +72,7 @@ export async function renderEntityToDataURL(options) {
     let animations = [];
     let nodeLookup = null;
     if (mode === 'hierarchical') {
-        const scene = createEntityScene({ THREE: three, entity });
+        const scene = createBoxelScene({ THREE: three, entity });
         disposeScene = scene.dispose;
         root = scene.root;
         animations = scene.animations;
@@ -94,7 +94,7 @@ export async function renderEntityToDataURL(options) {
         animations = buildAnimations(three, entity, nodeLookup);
     }
     else {
-        const sceneGraph = createEntitySceneGraph({ THREE: three, model: entity, mode });
+        const sceneGraph = createBoxelSceneGraph({ THREE: three, model: entity, mode });
         disposeScene = sceneGraph.dispose;
         root = sceneGraph.root;
         animations = sceneGraph.animations;

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

@@ -0,0 +1,17 @@
+export * from './types.js';
+export { createBoxelScene, createBoxelNodeScene } from './scene.js';
+export { attachBoxelOverlays } 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, createBoxelSceneGraph } from './exporters/glb.js';
+export type { ExportMode } from './exporters/glb.js';
+export { renderBoxelToDataURL } from './exporters/image.js';
+export type { RenderBoxelImageOptions } from './exporters/image.js';
+export { __testing as __boxelThreeTesting } from './exporters/glb.js';
+export * from './texture-atlas.js';
+export * from './skinned-mesh.js';
+export * from './instantiate.js';

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

@@ -0,0 +1,15 @@
+export * from './types.js';
+export { createBoxelScene, createBoxelNodeScene } from './scene.js';
+export { attachBoxelOverlays } 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, createBoxelSceneGraph } from './exporters/glb.js';
+export { renderBoxelToDataURL } from './exporters/image.js';
+export { __testing as __boxelThreeTesting } from './exporters/glb.js';
+export * from './texture-atlas.js';
+export * from './skinned-mesh.js';
+export * from './instantiate.js';

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/instantiate.d.ts

@@ -1,6 +1,6 @@
 import type * as THREEType from 'three';
-import type { Entity } from '@playdrop/entity-core';
-import type { EntitySceneResult } from './types.js';
+import type { BoxelDefinition } from '@playdrop/boxel-core';
+import type { BoxelSceneResult } from './types.js';
 import type { BuildSkinnedMeshResult } from './skinned-mesh.js';
 export type InstantiateEntityObject3DMode = 'hierarchy' | 'merged' | 'skinned';
 interface InstantiateBaseResult {
@@ -10,7 +10,7 @@ interface InstantiateBaseResult {
 export interface InstantiateHierarchyResult extends InstantiateBaseResult {
     mode: 'hierarchy';
     object: THREEType.Group;
-    scene: EntitySceneResult;
+    scene: BoxelSceneResult;
     clips: THREEType.AnimationClip[];
     findNode(nodeId: string): THREEType.Object3D | undefined;
     forEachNode(visitor: (node: THREEType.Object3D, nodeId: string) => void): void;
@@ -33,7 +33,7 @@ export interface InstantiateSkinnedResult extends InstantiateBaseResult {
 export type InstantiateEntityObject3DResult = InstantiateHierarchyResult | InstantiateMergedResult | InstantiateSkinnedResult;
 export interface InstantiateEntityObject3DOptions {
     THREE: typeof THREEType;
-    entity: Entity;
+    entity: BoxelDefinition;
     mode?: InstantiateEntityObject3DMode;
 }
 export declare function instantiateEntityObject3D(options: InstantiateEntityObject3DOptions): InstantiateEntityObject3DResult;

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/instantiate.js

@@ -1,10 +1,10 @@
-import { createEntityScene } from './scene.js';
-import { createEntitySceneGraph } from './exporters/glb.js';
+import { createBoxelScene } from './scene.js';
+import { createBoxelSceneGraph } 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 scene = createBoxelScene({ THREE, entity });
     const clips = scene.animations.map(animation => animation.clip);
     return {
         mode: 'hierarchy',
@@ -22,7 +22,7 @@ function instantiateHierarchy(options) {
 }
 function instantiateMerged(options) {
     const { THREE, entity } = options;
-    const graph = createEntitySceneGraph({ THREE, model: entity, mode: 'merged' });
+    const graph = createBoxelSceneGraph({ THREE, model: entity, mode: 'merged' });
     const { root } = graph;
     return {
         mode: 'merged',

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/nodes.d.ts

@@ -1,5 +1,5 @@
 import type * as THREEType from 'three';
-import type { Node } from '@playdrop/entity-core';
+import type { Node } from '@playdrop/boxel-core';
 import type { PrimitiveBuilderContext } from './context.js';
 export interface NodeBuildResult {
     object: THREEType.Object3D;

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

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

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/overlays.js

@@ -53,7 +53,7 @@ function disposeObjectResources(object) {
         }
     });
 }
-export function attachEntityOverlays(context, options = {}) {
+export function attachBoxelOverlays(context, options = {}) {
     const { THREE, target } = context;
     const overlays = {
         dispose: () => {

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

@@ -0,0 +1,3 @@
+import type { BoxelThreeContext, BoxelSceneOptions, BoxelSceneResult } from './types.js';
+export declare function createBoxelScene(context: BoxelThreeContext, options?: BoxelSceneOptions): BoxelSceneResult;
+export declare function createBoxelNodeScene(context: BoxelThreeContext, nodeId: string, options?: BoxelSceneOptions): BoxelSceneResult;

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/scene.js

@@ -1,7 +1,7 @@
 import { createBuilderContext, updateBuilderContext } from './context.js';
 import { buildNodeObject } from './nodes.js';
 import { buildAnimations } from './animations.js';
-import { attachEntityOverlays } from './overlays.js';
+import { attachBoxelOverlays } from './overlays.js';
 function normalizeNodeFilter(nodes) {
     if (!nodes)
         return null;
@@ -10,7 +10,7 @@ function normalizeNodeFilter(nodes) {
     }
     return new Set([nodes]);
 }
-export function createEntityScene(context, options = {}) {
+export function createBoxelScene(context, options = {}) {
     const { THREE, entity } = context;
     const nodeFilter = normalizeNodeFilter(options.nodes);
     const builderContext = createBuilderContext({
@@ -35,7 +35,7 @@ export function createEntityScene(context, options = {}) {
                 return null;
             })(entity.geometry.root);
         if (!node) {
-            console.warn('[entity-three] node not found', nodeId);
+            console.warn('[boxel-three] node not found', nodeId);
             return null;
         }
         const { object, nodes } = buildNodeObject(builderContext, node);
@@ -88,7 +88,7 @@ export function createEntityScene(context, options = {}) {
             if (!request.origin && !request.bounds && !request.sockets) {
                 return;
             }
-            const handles = attachEntityOverlays({ THREE, target: meta.object }, request);
+            const handles = attachBoxelOverlays({ THREE, target: meta.object }, request);
             overlayHandles.push(handles);
         });
     };
@@ -139,6 +139,6 @@ export function createEntityScene(context, options = {}) {
         dispose,
     };
 }
-export function createNodeScene(context, nodeId, options = {}) {
-    return createEntityScene(context, { ...options, nodes: nodeId });
+export function createBoxelNodeScene(context, nodeId, options = {}) {
+    return createBoxelScene(context, { ...options, nodes: nodeId });
 }

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/skinned-mesh.d.ts

@@ -1,8 +1,8 @@
 import type * as THREEType from 'three';
-import type { Entity } from '@playdrop/entity-core';
+import type { BoxelDefinition } from '@playdrop/boxel-core';
 export interface BuildSkinnedMeshOptions {
     THREE: typeof THREEType;
-    entity: Entity;
+    entity: BoxelDefinition;
 }
 export interface BuildSkinnedMeshResult {
     mesh: THREEType.SkinnedMesh;

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/textures.d.ts

@@ -1,5 +1,5 @@
 import type * as THREEType from 'three';
-import type { Material, Pattern, Texture } from '@playdrop/entity-core';
+import type { Material, Pattern, Texture } from '@playdrop/boxel-core';
 import type { PrimitiveBuilderContext } from './context.js';
 type TextureArray = Uint8Array<ArrayBuffer>;
 export interface TextureBundle {

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/textures.js

@@ -64,7 +64,7 @@ export function ensureTextureInstance(context, textureDef) {
     }
     const pattern = context.entity.patterns.find(entry => entry.id === textureDef.pattern);
     if (!pattern) {
-        console.warn('[entity-three] pattern not found for texture', textureDef.id);
+        console.warn('[boxel-three] pattern not found for texture', textureDef.id);
         return null;
     }
     const { color, emissive } = buildTexturePixels(context, textureDef, pattern, context.materialsById);
@@ -149,7 +149,7 @@ export function createTextureMaterial(context, textureId) {
     }
     const textureDef = context.entity.textures.find(entry => entry.id === textureId);
     if (!textureDef) {
-        console.warn('[entity-three] texture not found', textureId);
+        console.warn('[boxel-three] texture not found', textureId);
         return new context.THREE.MeshStandardMaterial({
             color: 0x3b82f6,
             opacity: 0.45,

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/types.d.ts

@@ -1,11 +1,11 @@
 import type * as THREEType from 'three';
-import type { ConnectMode, Entity } from '@playdrop/entity-core';
-export type { ConnectMode } from '@playdrop/entity-core';
-export interface EntityThreeContext {
+import type { ConnectMode, BoxelDefinition } from '@playdrop/boxel-core';
+export type { ConnectMode } from '@playdrop/boxel-core';
+export interface BoxelThreeContext {
     THREE: typeof THREEType;
-    entity: Entity;
+    entity: BoxelDefinition;
 }
-export interface EntitySceneOptions {
+export interface BoxelSceneOptions {
     /**
      * Optional node identifier (or list of identifiers) to render instead of the full entity.
      * When omitted, the entire entity geometry tree is emitted.
@@ -14,9 +14,9 @@ export interface EntitySceneOptions {
     /**
      * Configure optional overlay helpers (origin, bounds, sockets) to render alongside the scene.
      */
-    overlays?: EntityOverlayOptions;
+    overlays?: BoxelOverlayOptions;
 }
-export interface EntitySceneNodeMeta {
+export interface BoxelSceneNodeMeta {
     /**
      * Original entity node identifier.
      */
@@ -34,18 +34,18 @@ export interface EntitySceneNodeMeta {
      */
     connectMode: ConnectMode;
 }
-export interface EntitySceneAnimationChannel {
+export interface BoxelSceneAnimationChannel {
     nodeId: string;
     property: 'position' | 'rotation' | 'scale';
     track: THREEType.KeyframeTrack;
 }
-export interface EntitySceneAnimation {
+export interface BoxelSceneAnimation {
     id: string;
     duration: number;
-    channels: EntitySceneAnimationChannel[];
+    channels: BoxelSceneAnimationChannel[];
     clip: THREEType.AnimationClip;
 }
-export interface EntitySceneResult {
+export interface BoxelSceneResult {
     /**
      * Root object containing the full entity mesh hierarchy.
      */
@@ -53,11 +53,11 @@ export interface EntitySceneResult {
     /**
      * Lookup for every node emitted into the scene.
      */
-    nodes: Map<string, EntitySceneNodeMeta>;
+    nodes: Map<string, BoxelSceneNodeMeta>;
     /**
      * Animation payload pre-bound to Three.js tracks.
      */
-    animations: EntitySceneAnimation[];
+    animations: BoxelSceneAnimation[];
     /**
      * Ready-to-use AnimationClip objects derived from the animation payload.
      */
@@ -78,7 +78,7 @@ export interface EntitySceneResult {
 /**
  * Controls which overlay helpers should be rendered for a target along with basic styling hints.
  */
-export interface EntityOverlayOptions {
+export interface BoxelOverlayOptions {
     /**
      * Render the entity/world origin helper.
      */
@@ -104,7 +104,7 @@ export interface EntityOverlayOptions {
      */
     dashed?: boolean;
 }
-export interface EntityOverlayHandles {
+export interface BoxelOverlayHandles {
     origin?: THREEType.Object3D;
     bounds?: THREEType.Object3D[];
     sockets?: THREEType.Object3D[];

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/voxels/faces.d.ts

@@ -1,4 +1,4 @@
-import type { Material, VoxelBox } from '@playdrop/entity-core';
+import type { Material, VoxelBox } from '@playdrop/boxel-core';
 export type FaceName = 'east' | 'west' | 'top' | 'bottom' | 'north' | 'south';
 export declare const FACE_ORDER: ReadonlyArray<FaceName>;
 export interface VoxelFaceGeometry {

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/voxels/mesher.d.ts

@@ -1,4 +1,4 @@
-import { type VoxelBox } from '@playdrop/entity-core';
+import { type VoxelBox } from '@playdrop/boxel-core';
 export interface BuildVoxelMeshOptions {
     voxels: number[];
     dimensions: [number, number, number];

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/src/voxels/mesher.js

@@ -1,4 +1,4 @@
-import { generateGreedyQuads } from '@playdrop/entity-core';
+import { generateGreedyQuads } from '@playdrop/boxel-core';
 export function buildVoxelMesh(options) {
     const { voxels, dimensions, size } = options;
     const quads = generateGreedyQuads(voxels, dimensions);

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/test/export-image.playwright.test.js

@@ -37,7 +37,7 @@ function createPlaywrightLaunchError(tool, error) {
     }
     return error instanceof Error ? error : new Error(message);
 }
-test('renderEntityToDataURL produces a PNG data URL', async (t) => {
+test('renderBoxelToDataURL produces a PNG data URL', async (t) => {
     const { chromium } = await import('playwright-core');
     const bundle = await bundleEntityWorker();
     let browser = null;
@@ -45,7 +45,7 @@ test('renderEntityToDataURL produces a PNG data URL', async (t) => {
         browser = await chromium.launch({ headless: true, args: ['--no-sandbox'], chromiumSandbox: false });
     }
     catch (error) {
-        const launchError = createPlaywrightLaunchError('entity-three-test', error);
+        const launchError = createPlaywrightLaunchError('boxel-three-test', error);
         t.skip(launchError.message);
         return;
     }
@@ -62,7 +62,7 @@ test('renderEntityToDataURL produces a PNG data URL', async (t) => {
     try {
         await page.setContent('<canvas id="viewport"></canvas>', { waitUntil: 'domcontentloaded' });
         await page.addScriptTag({ type: 'module', content: bundle });
-        await page.waitForFunction(() => typeof window.entityExport !== 'undefined');
+        await page.waitForFunction(() => typeof window.boxelExport !== 'undefined');
         const minimalEntity = {
             id: 'render-test',
             geometry: {
@@ -93,7 +93,7 @@ test('renderEntityToDataURL produces a PNG data URL', async (t) => {
             patterns: [],
             animations: [],
         };
-        const dataUrl = await page.evaluate(model => window.entityExport.renderEntity(model, {
+        const dataUrl = await page.evaluate(model => window.boxelExport.renderBoxel(model, {
             mode: 'hierarchical',
             width: 512,
             height: 512,

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/test/fixtures/render-worker.d.ts

@@ -11,9 +11,9 @@ interface RenderEntityOptions extends ExportEntityOptions {
 }
 declare global {
     interface Window {
-        entityExport?: {
-            exportEntity(modelJson: unknown, options?: ExportEntityOptions): Promise<string>;
-            renderEntity(modelJson: unknown, options?: RenderEntityOptions): Promise<string>;
+        boxelExport?: {
+            exportBoxel(modelJson: unknown, options?: ExportEntityOptions): Promise<string>;
+            renderBoxel(modelJson: unknown, options?: RenderEntityOptions): Promise<string>;
         };
     }
 }

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/test/fixtures/render-worker.js

@@ -1,7 +1,7 @@
 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';
+import { exportModelToGLB, renderBoxelToDataURL } from '../../src/index.js';
+import { parseBoxel } from '@playdrop/boxel-core';
 function arrayBufferToBase64(buffer) {
     const bytes = new Uint8Array(buffer);
     const chunkSize = 0x8000;
@@ -29,8 +29,8 @@ function getRenderer() {
     });
     return cachedRenderer;
 }
-async function exportEntity(modelJson, options) {
-    const model = parseEntity(modelJson);
+async function exportBoxel(modelJson, options) {
+    const model = parseBoxel(modelJson);
     const blob = await exportModelToGLB({
         THREE,
         GLTFExporterCtor: GLTFExporter,
@@ -41,11 +41,11 @@ async function exportEntity(modelJson, options) {
     const arrayBuffer = await blob.arrayBuffer();
     return arrayBufferToBase64(arrayBuffer);
 }
-async function renderEntity(modelJson, options) {
-    const model = parseEntity(modelJson);
+async function renderBoxel(modelJson, options) {
+    const model = parseBoxel(modelJson);
     const renderer = getRenderer();
     renderer.setPixelRatio(1);
-    return renderEntityToDataURL({
+    return renderBoxelToDataURL({
         THREE,
         renderer,
         entity: model,
@@ -57,7 +57,7 @@ async function renderEntity(modelJson, options) {
         background: options?.background ?? null,
     });
 }
-window.entityExport = {
-    exportEntity,
-    renderEntity,
+window.boxelExport = {
+    exportBoxel,
+    renderBoxel,
 };

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/test/glb-skinned.test.js

@@ -5,9 +5,9 @@ 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 { parseBoxel } from '@playdrop/boxel-core';
 import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
-import { createEntitySceneGraph, exportModelToGLB } from '../src/exporters/glb.js';
+import { createBoxelSceneGraph, 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') {
@@ -55,11 +55,11 @@ if (typeof globalThis.FileReader === 'undefined') {
 }
 async function loadEntity(relativePath) {
     const raw = await readFile(fixture(relativePath), 'utf-8');
-    return parseEntity(JSON.parse(raw));
+    return parseBoxel(JSON.parse(raw));
 }
-test('createEntitySceneGraph skinned mode exposes skinned mesh and bones', async () => {
+test('createBoxelSceneGraph skinned mode exposes skinned mesh and bones', async () => {
     const entity = await loadEntity('entity-connect.json');
-    const graph = createEntitySceneGraph({ THREE, model: entity, mode: 'skinned' });
+    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);

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

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

package/node_modules/@playdrop/{entity-three → boxel-three}/dist/test/instantiate.test.js

@@ -5,13 +5,13 @@ 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 { 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, '../../test/fixtures', ...segments);
 async function loadEntity(relativePath) {
     const raw = await readFile(fixture(relativePath), 'utf-8');
-    return parseEntity(JSON.parse(raw));
+    return parseBoxel(JSON.parse(raw));
 }
 function dispose(result) {
     result.dispose();