@holoscript/plugin-film3d-volumetrics 2.0.2 → 2.0.3

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@holoscript/plugin-film3d-volumetrics",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "main": "src/index.ts",
   "dependencies": {
     "@holoscript/crdt-spatial": "^1.0.2"
   },
   "peerDependencies": {
-    "loro-crdt": "^1.0.0",
-    "@holoscript/core": "8.0.6"
+    "@holoscript/core": ">=8.0.0",
+    "loro-crdt": "^1.0.0"
   },
   "peerDependenciesMeta": {
     "loro-crdt": {
@@ -23,4 +23,4 @@
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests"
   }
-}
+}

package/src/crdt-spatial-augment.ts

@@ -8,8 +8,17 @@ declare module '@holoscript/crdt-spatial' {
   // @ts-ignore -- augmenting an already-exported const from the runtime module
   export const FILM3D_VOLUMETRICS_ROOT: 'film3d_volumetrics';
   export function ensureFilm3dVolumetricsRoot(doc: LoroDoc): LoroMap<Record<string, unknown>>;
-  export function registerVolumetricNode(doc: LoroDoc, nodeId: string, meta: { format: string }): void;
-  export function setVolumetricChunk(doc: LoroDoc, nodeId: string, chunkIndex: number, data: Uint8Array): void;
+  export function registerVolumetricNode(
+    doc: LoroDoc,
+    nodeId: string,
+    meta: { format: string }
+  ): void;
+  export function setVolumetricChunk(
+    doc: LoroDoc,
+    nodeId: string,
+    chunkIndex: number,
+    data: Uint8Array
+  ): void;
   export function setVolumetricVoxelPayload(doc: LoroDoc, nodeId: string, data: Uint8Array): void;
   export function unregisterVolumetricNode(doc: LoroDoc, nodeId: string): void;
 }

package/src/index.ts

@@ -1,9 +1,17 @@
 import './crdt-spatial-augment';
 
-export { createVolumetricHandler, type VolumetricConfig, type VolumetricFormat } from './traits/VolumetricTrait';
+export {
+  createVolumetricHandler,
+  type VolumetricConfig,
+  type VolumetricFormat,
+} from './traits/VolumetricTrait';
 export { createGaussianSplatHandler, type GaussianSplatConfig } from './traits/GaussianSplatTrait';
 export { createNeRFHandler, type NeRFConfig, type NeRFMethod } from './traits/NeRFTrait';
-export { createCinematicCameraHandler, type CinematicCameraConfig, type CameraMovement } from './traits/CinematicCameraTrait';
+export {
+  createCinematicCameraHandler,
+  type CinematicCameraConfig,
+  type CameraMovement,
+} from './traits/CinematicCameraTrait';
 export {
   createGCodeSlicerHandler,
   type GCodeSlicerConfig,
@@ -15,7 +23,7 @@ export {
   buildAdhesionLayerPlan,
   buildInsetPerimeterTraversal,
   buildSemanticGCodePreamble,
-  buildTraversalStackFromMesh
+  buildTraversalStackFromMesh,
 } from './traits/GCodeSlicerTrait';
 export * from './traits/types';
 
@@ -25,7 +33,7 @@ import {
   registerVolumetricNode,
   setVolumetricChunk,
   setVolumetricVoxelPayload,
-  unregisterVolumetricNode
+  unregisterVolumetricNode,
 } from '@holoscript/crdt-spatial';
 import { createVolumetricHandler } from './traits/VolumetricTrait';
 import { createGaussianSplatHandler } from './traits/GaussianSplatTrait';
@@ -39,7 +47,7 @@ export {
   registerVolumetricNode,
   setVolumetricChunk,
   setVolumetricVoxelPayload,
-  unregisterVolumetricNode
+  unregisterVolumetricNode,
 };
 
 import type { LoroDoc } from 'loro-crdt';
@@ -61,6 +69,12 @@ export const pluginMeta = {
   version: '1.0.0',
   traits: ['volumetric', 'gaussian_splat', 'nerf', 'cinematic_camera', 'gcode_slicer'],
   /** Root map on the shared Loro doc replicated by LoroWebRTCProvider */
-  crdtVolumetricsRoot: FILM3D_VOLUMETRICS_ROOT
+  crdtVolumetricsRoot: FILM3D_VOLUMETRICS_ROOT,
 };
-export const traitHandlers = [createVolumetricHandler(), createGaussianSplatHandler(), createNeRFHandler(), createCinematicCameraHandler(), createGCodeSlicerHandler()];
+export const traitHandlers = [
+  createVolumetricHandler(),
+  createGaussianSplatHandler(),
+  createNeRFHandler(),
+  createCinematicCameraHandler(),
+  createGCodeSlicerHandler(),
+];

package/src/traits/CinematicCameraTrait.ts

@@ -1,25 +1,85 @@
 /** @cinematic_camera Trait — Film-grade virtual camera control. @trait cinematic_camera */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type CameraMovement = 'static' | 'dolly' | 'truck' | 'pedestal' | 'pan' | 'tilt' | 'roll' | 'crane' | 'steadicam' | 'drone' | 'handheld';
-export interface CinematicCameraConfig { focalLengthMm: number; sensorWidth: number; sensorHeight: number; tStop: number; focusDistanceM: number; movement: CameraMovement; shutterAngle: number; iso: number; whiteBalanceK: number; anamorphic: boolean; }
+export type CameraMovement =
+  | 'static'
+  | 'dolly'
+  | 'truck'
+  | 'pedestal'
+  | 'pan'
+  | 'tilt'
+  | 'roll'
+  | 'crane'
+  | 'steadicam'
+  | 'drone'
+  | 'handheld';
+export interface CinematicCameraConfig {
+  focalLengthMm: number;
+  sensorWidth: number;
+  sensorHeight: number;
+  tStop: number;
+  focusDistanceM: number;
+  movement: CameraMovement;
+  shutterAngle: number;
+  iso: number;
+  whiteBalanceK: number;
+  anamorphic: boolean;
+}
 
-const defaultConfig: CinematicCameraConfig = { focalLengthMm: 50, sensorWidth: 36, sensorHeight: 24, tStop: 2.8, focusDistanceM: 3, movement: 'static', shutterAngle: 180, iso: 800, whiteBalanceK: 5600, anamorphic: false };
+const defaultConfig: CinematicCameraConfig = {
+  focalLengthMm: 50,
+  sensorWidth: 36,
+  sensorHeight: 24,
+  tStop: 2.8,
+  focusDistanceM: 3,
+  movement: 'static',
+  shutterAngle: 180,
+  iso: 800,
+  whiteBalanceK: 5600,
+  anamorphic: false,
+};
 
 export function createCinematicCameraHandler(): TraitHandler<CinematicCameraConfig> {
-  return { name: 'cinematic_camera', defaultConfig,
+  return {
+    name: 'cinematic_camera',
+    defaultConfig,
     onAttach(n: HSPlusNode, c: CinematicCameraConfig, ctx: TraitContext) {
       const fovDeg = 2 * Math.atan(c.sensorWidth / (2 * c.focalLengthMm)) * (180 / Math.PI);
-      n.__camState = { fovDeg, isRecording: false, frameCount: 0, dofBlurRadius: c.focalLengthMm / (2 * c.tStop) };
-      ctx.emit?.('camera:configured', { focal: c.focalLengthMm, fov: fovDeg, movement: c.movement });
+      n.__camState = {
+        fovDeg,
+        isRecording: false,
+        frameCount: 0,
+        dofBlurRadius: c.focalLengthMm / (2 * c.tStop),
+      };
+      ctx.emit?.('camera:configured', {
+        focal: c.focalLengthMm,
+        fov: fovDeg,
+        movement: c.movement,
+      });
+    },
+    onDetach(n: HSPlusNode, _c: CinematicCameraConfig, ctx: TraitContext) {
+      delete n.__camState;
+      ctx.emit?.('camera:removed');
+    },
+    onUpdate(n: HSPlusNode, _c: CinematicCameraConfig, _ctx: TraitContext, _d: number) {
+      const s = n.__camState as Record<string, unknown> | undefined;
+      if (s?.isRecording) (s.frameCount as number)++;
     },
-    onDetach(n: HSPlusNode, _c: CinematicCameraConfig, ctx: TraitContext) { delete n.__camState; ctx.emit?.('camera:removed'); },
-    onUpdate(n: HSPlusNode, _c: CinematicCameraConfig, _ctx: TraitContext, _d: number) { const s = n.__camState as Record<string, unknown> | undefined; if (s?.isRecording) (s.frameCount as number)++; },
     onEvent(n: HSPlusNode, _c: CinematicCameraConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__camState as Record<string, unknown> | undefined; if (!s) return;
-      if (e.type === 'camera:record') { s.isRecording = true; ctx.emit?.('camera:recording'); }
-      if (e.type === 'camera:cut') { s.isRecording = false; ctx.emit?.('camera:cut', { frames: s.frameCount }); s.frameCount = 0; }
-      if (e.type === 'camera:rack_focus') { ctx.emit?.('camera:focus_pulling', { to: e.payload?.distance }); }
+      const s = n.__camState as Record<string, unknown> | undefined;
+      if (!s) return;
+      if (e.type === 'camera:record') {
+        s.isRecording = true;
+        ctx.emit?.('camera:recording');
+      }
+      if (e.type === 'camera:cut') {
+        s.isRecording = false;
+        ctx.emit?.('camera:cut', { frames: s.frameCount });
+        s.frameCount = 0;
+      }
+      if (e.type === 'camera:rack_focus') {
+        ctx.emit?.('camera:focus_pulling', { to: e.payload?.distance });
+      }
     },
   };
 }

package/src/traits/GCodeSlicerTrait.ts

@@ -67,10 +67,15 @@ const defaultConfig: GCodeSlicerConfig = {
   adhesionLayerCount: 3,
   adhesionLayerHeightMm: 0.25,
   adhesionBrimMm: 2,
-  printSpeedMmS: 50
+  printSpeedMmS: 50,
 };
 
-function bbox2D(vertices: [number, number, number][]): { minX: number; maxX: number; minY: number; maxY: number } {
+function bbox2D(vertices: [number, number, number][]): {
+  minX: number;
+  maxX: number;
+  minY: number;
+  maxY: number;
+} {
   let minX = Infinity;
   let maxX = -Infinity;
   let minY = Infinity;
@@ -92,7 +97,9 @@ export function buildAdhesionLayerPlan(c: GCodeSlicerConfig): AdhesionLayerPlanE
   const out: AdhesionLayerPlanEntry[] = [];
   let z = 0;
   for (let i = 0; i < c.adhesionLayerCount; i++) {
-    const temp = c.nozzleTempC + (i === 0 ? c.firstLayerNozzleBoostC : Math.max(0, c.firstLayerNozzleBoostC - i * 3));
+    const temp =
+      c.nozzleTempC +
+      (i === 0 ? c.firstLayerNozzleBoostC : Math.max(0, c.firstLayerNozzleBoostC - i * 3));
     out.push({ layerIndex: i, zMm: z + c.adhesionLayerHeightMm, nozzleTempC: Math.round(temp) });
     z += c.adhesionLayerHeightMm;
   }
@@ -120,7 +127,7 @@ export function buildInsetPerimeterTraversal(
       [maxX, minY, layerZMm],
       [maxX, maxY, layerZMm],
       [minX, maxY, layerZMm],
-      [minX, minY, layerZMm]
+      [minX, minY, layerZMm],
     ];
   }
   const edge = (x0: number, y0: number, x1: number, y1: number): [number, number, number][] => {
@@ -135,7 +142,7 @@ export function buildInsetPerimeterTraversal(
     ...edge(ix0, iy0, ix1, iy0),
     ...edge(ix1, iy0, ix1, iy1).slice(1),
     ...edge(ix1, iy1, ix0, iy1).slice(1),
-    ...edge(ix0, iy1, ix0, iy0).slice(1)
+    ...edge(ix0, iy1, ix0, iy0).slice(1),
   ];
 }
 
@@ -148,7 +155,7 @@ export function buildSemanticGCodePreamble(c: GCodeSlicerConfig, mesh?: MeshSlic
     `M140 S${Math.round(c.bedTempC)} ; bed target`,
     `M104 S${Math.round(c.nozzleTempC)} ; nozzle standby → target`,
     `M190 S${Math.round(c.bedTempC)} ; wait for bed`,
-    `M109 S${Math.round(c.nozzleTempC + c.firstLayerNozzleBoostC)} ; first layer nozzle (boosted)`
+    `M109 S${Math.round(c.nozzleTempC + c.firstLayerNozzleBoostC)} ; first layer nozzle (boosted)`,
   ];
   const adhesion = buildAdhesionLayerPlan(c);
   for (const layer of adhesion) {
@@ -164,18 +171,23 @@ export function buildSemanticGCodePreamble(c: GCodeSlicerConfig, mesh?: MeshSlic
       `; vertices=${mesh.verticesMm.length}`
     );
   }
-  lines.push(`; layerHeight=${c.layerHeightMm} infill=${c.infillPercent}% F=${c.printSpeedMmS}mm/s`);
+  lines.push(
+    `; layerHeight=${c.layerHeightMm} infill=${c.infillPercent}% F=${c.printSpeedMmS}mm/s`
+  );
   return lines.join('\n');
 }
 
-export function buildTraversalStackFromMesh(c: GCodeSlicerConfig, mesh: MeshSliceInput): TraversalLayerPlan[] {
+export function buildTraversalStackFromMesh(
+  c: GCodeSlicerConfig,
+  mesh: MeshSliceInput
+): TraversalLayerPlan[] {
   if (!mesh.verticesMm.length) return [];
   const plans: TraversalLayerPlan[] = [];
   const adhesion = buildAdhesionLayerPlan(c);
   for (const layer of adhesion) {
     plans.push({
       layerZMm: layer.zMm,
-      pointsMm: buildInsetPerimeterTraversal(mesh.verticesMm, layer.zMm, c.adhesionBrimMm)
+      pointsMm: buildInsetPerimeterTraversal(mesh.verticesMm, layer.zMm, c.adhesionBrimMm),
     });
   }
   let z = adhesion.length ? adhesion[adhesion.length - 1]!.zMm : 0;
@@ -184,7 +196,11 @@ export function buildTraversalStackFromMesh(c: GCodeSlicerConfig, mesh: MeshSlic
     z += c.layerHeightMm;
     plans.push({
       layerZMm: z,
-      pointsMm: buildInsetPerimeterTraversal(mesh.verticesMm, z, c.adhesionBrimMm + c.layerHeightMm * 2)
+      pointsMm: buildInsetPerimeterTraversal(
+        mesh.verticesMm,
+        z,
+        c.adhesionBrimMm + c.layerHeightMm * 2
+      ),
     });
   }
   return plans;
@@ -205,9 +221,11 @@ export function createGCodeSlicerHandler(): TraitHandler<GCodeSlicerConfig> {
         mesh,
         adhesionPlan,
         traversal,
-        gcodePreamble: buildSemanticGCodePreamble(c, mesh.verticesMm.length ? mesh : undefined)
+        gcodePreamble: buildSemanticGCodePreamble(c, mesh.verticesMm.length ? mesh : undefined),
       };
-      ctx.emit?.('gcode_slicer:ready', { semantic: { adhesionPlan, traversalLayers: traversal.length } });
+      ctx.emit?.('gcode_slicer:ready', {
+        semantic: { adhesionPlan, traversalLayers: traversal.length },
+      });
     },
     onDetach(n: HSPlusNode, _c: GCodeSlicerConfig, ctx: TraitContext) {
       delete n.__slicerState;
@@ -223,7 +241,7 @@ export function createGCodeSlicerHandler(): TraitHandler<GCodeSlicerConfig> {
       s.gcodePreamble = buildSemanticGCodePreamble(c, mesh.verticesMm.length ? mesh : undefined);
       ctx.emit?.('gcode_slicer:semantic_updated', {
         adhesionPlan: s.adhesionPlan,
-        traversalLayers: s.traversal?.length ?? 0
+        traversalLayers: s.traversal?.length ?? 0,
       });
     },
     onEvent(n: HSPlusNode, c: GCodeSlicerConfig, ctx: TraitContext, e: TraitEvent) {
@@ -239,7 +257,10 @@ export function createGCodeSlicerHandler(): TraitHandler<GCodeSlicerConfig> {
         s.adhesionPlan = buildAdhesionLayerPlan(c);
         s.traversal = buildTraversalStackFromMesh(c, mesh);
         s.gcodePreamble = buildSemanticGCodePreamble(c, mesh);
-        ctx.emit?.('gcode_slicer:mesh_bound', { vertexCount: verts.length, layers: s.traversal?.length ?? 0 });
+        ctx.emit?.('gcode_slicer:mesh_bound', {
+          vertexCount: verts.length,
+          layers: s.traversal?.length ?? 0,
+        });
       }
 
       if (e.type === 'gcode_slicer:slice' && !s.isSlicing) {
@@ -250,9 +271,12 @@ export function createGCodeSlicerHandler(): TraitHandler<GCodeSlicerConfig> {
         const meshVol = s.mesh?.verticesMm.length
           ? bbox2D(s.mesh.verticesMm)
           : { minX: 0, maxX: 50, minY: 0, maxY: 50 };
-        const xyArea = Math.max(1, meshVol.maxX - meshVol.minX) * Math.max(1, meshVol.maxY - meshVol.minY);
-        const volumeEstimate = xyArea * (c.adhesionLayerCount * c.adhesionLayerHeightMm + c.layerHeightMm * 12);
-        s.estimatedPrintTimeMs = (volumeEstimate / Math.max(0.01, c.printSpeedMmS * c.layerHeightMm)) * 1000;
+        const xyArea =
+          Math.max(1, meshVol.maxX - meshVol.minX) * Math.max(1, meshVol.maxY - meshVol.minY);
+        const volumeEstimate =
+          xyArea * (c.adhesionLayerCount * c.adhesionLayerHeightMm + c.layerHeightMm * 12);
+        s.estimatedPrintTimeMs =
+          (volumeEstimate / Math.max(0.01, c.printSpeedMmS * c.layerHeightMm)) * 1000;
 
         setTimeout(() => {
           s.isSlicing = false;
@@ -264,10 +288,10 @@ export function createGCodeSlicerHandler(): TraitHandler<GCodeSlicerConfig> {
             estimatedTimeMs: s.estimatedPrintTimeMs,
             preamble,
             adhesionPlan: s.adhesionPlan,
-            traversal: s.traversal
+            traversal: s.traversal,
           });
         }, 1500);
       }
-    }
+    },
   };
 }

package/src/traits/GaussianSplatTrait.ts

@@ -1,22 +1,53 @@
 /** @gaussian_splat Trait — 3D Gaussian Splatting rendering. @trait gaussian_splat */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export interface GaussianSplatConfig { splatCount: number; shDegree: number; sortMethod: 'radix' | 'bitonic' | 'cpu'; enableAntialiasing: boolean; opacityThreshold: number; maxSplatSize: number; lodLevels: number; }
+export interface GaussianSplatConfig {
+  splatCount: number;
+  shDegree: number;
+  sortMethod: 'radix' | 'bitonic' | 'cpu';
+  enableAntialiasing: boolean;
+  opacityThreshold: number;
+  maxSplatSize: number;
+  lodLevels: number;
+}
 
-const defaultConfig: GaussianSplatConfig = { splatCount: 0, shDegree: 3, sortMethod: 'radix', enableAntialiasing: true, opacityThreshold: 0.005, maxSplatSize: 0.1, lodLevels: 4 };
+const defaultConfig: GaussianSplatConfig = {
+  splatCount: 0,
+  shDegree: 3,
+  sortMethod: 'radix',
+  enableAntialiasing: true,
+  opacityThreshold: 0.005,
+  maxSplatSize: 0.1,
+  lodLevels: 4,
+};
 
 export function createGaussianSplatHandler(): TraitHandler<GaussianSplatConfig> {
-  return { name: 'gaussian_splat', defaultConfig,
-    onAttach(n: HSPlusNode, c: GaussianSplatConfig, ctx: TraitContext) { n.__gsplatState = { loaded: false, visibleSplats: 0, sortTimeMs: 0, lodLevel: 0 }; ctx.emit?.('gsplat:initialized', { count: c.splatCount, sort: c.sortMethod }); },
-    onDetach(n: HSPlusNode, _c: GaussianSplatConfig, ctx: TraitContext) { delete n.__gsplatState; ctx.emit?.('gsplat:disposed'); },
+  return {
+    name: 'gaussian_splat',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: GaussianSplatConfig, ctx: TraitContext) {
+      n.__gsplatState = { loaded: false, visibleSplats: 0, sortTimeMs: 0, lodLevel: 0 };
+      ctx.emit?.('gsplat:initialized', { count: c.splatCount, sort: c.sortMethod });
+    },
+    onDetach(n: HSPlusNode, _c: GaussianSplatConfig, ctx: TraitContext) {
+      delete n.__gsplatState;
+      ctx.emit?.('gsplat:disposed');
+    },
     onUpdate(n: HSPlusNode, _c: GaussianSplatConfig, ctx: TraitContext, _d: number) {
       const s = n.__gsplatState as Record<string, unknown> | undefined;
       if (s?.loaded) ctx.emit?.('gsplat:frame', { visible: s.visibleSplats, sortMs: s.sortTimeMs });
     },
     onEvent(n: HSPlusNode, _c: GaussianSplatConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__gsplatState as Record<string, unknown> | undefined; if (!s) return;
-      if (e.type === 'gsplat:load') { s.loaded = true; ctx.emit?.('gsplat:loaded'); }
-      if (e.type === 'gsplat:set_lod') { s.lodLevel = e.payload?.level; ctx.emit?.('gsplat:lod_changed', { level: s.lodLevel }); }
+      const s = n.__gsplatState as Record<string, unknown> | undefined;
+      if (!s) return;
+      if (e.type === 'gsplat:load') {
+        s.loaded = true;
+        ctx.emit?.('gsplat:loaded');
+      }
+      if (e.type === 'gsplat:set_lod') {
+        s.lodLevel = e.payload?.level;
+        ctx.emit?.('gsplat:lod_changed', { level: s.lodLevel });
+      }
     },
   };
 }

package/src/traits/NeRFTrait.ts

@@ -2,19 +2,55 @@
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
 export type NeRFMethod = 'instant_ngp' | 'nerfacto' | 'tensorf' | 'mip_nerf' | 'zip_nerf';
-export interface NeRFConfig { method: NeRFMethod; resolution: number; nearPlane: number; farPlane: number; samplesPerRay: number; batchSize: number; enableDeformation: boolean; }
+export interface NeRFConfig {
+  method: NeRFMethod;
+  resolution: number;
+  nearPlane: number;
+  farPlane: number;
+  samplesPerRay: number;
+  batchSize: number;
+  enableDeformation: boolean;
+}
 
-const defaultConfig: NeRFConfig = { method: 'instant_ngp', resolution: 512, nearPlane: 0.01, farPlane: 100, samplesPerRay: 64, batchSize: 4096, enableDeformation: false };
+const defaultConfig: NeRFConfig = {
+  method: 'instant_ngp',
+  resolution: 512,
+  nearPlane: 0.01,
+  farPlane: 100,
+  samplesPerRay: 64,
+  batchSize: 4096,
+  enableDeformation: false,
+};
 
 export function createNeRFHandler(): TraitHandler<NeRFConfig> {
-  return { name: 'nerf', defaultConfig,
-    onAttach(n: HSPlusNode, c: NeRFConfig, ctx: TraitContext) { n.__nerfState = { isRendering: false, fps: 0, trainStep: 0, psnr: 0 }; ctx.emit?.('nerf:loaded', { method: c.method }); },
-    onDetach(n: HSPlusNode, _c: NeRFConfig, ctx: TraitContext) { delete n.__nerfState; ctx.emit?.('nerf:unloaded'); },
-    onUpdate(n: HSPlusNode, _c: NeRFConfig, _ctx: TraitContext, _d: number) { const s = n.__nerfState as Record<string, unknown> | undefined; if (s?.isRendering) { (s.trainStep as number)++; } },
+  return {
+    name: 'nerf',
+    defaultConfig,
+    onAttach(n: HSPlusNode, c: NeRFConfig, ctx: TraitContext) {
+      n.__nerfState = { isRendering: false, fps: 0, trainStep: 0, psnr: 0 };
+      ctx.emit?.('nerf:loaded', { method: c.method });
+    },
+    onDetach(n: HSPlusNode, _c: NeRFConfig, ctx: TraitContext) {
+      delete n.__nerfState;
+      ctx.emit?.('nerf:unloaded');
+    },
+    onUpdate(n: HSPlusNode, _c: NeRFConfig, _ctx: TraitContext, _d: number) {
+      const s = n.__nerfState as Record<string, unknown> | undefined;
+      if (s?.isRendering) {
+        (s.trainStep as number)++;
+      }
+    },
     onEvent(n: HSPlusNode, _c: NeRFConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__nerfState as Record<string, unknown> | undefined; if (!s) return;
-      if (e.type === 'nerf:render') { s.isRendering = true; ctx.emit?.('nerf:rendering'); }
-      if (e.type === 'nerf:stop') { s.isRendering = false; ctx.emit?.('nerf:stopped', { steps: s.trainStep }); }
+      const s = n.__nerfState as Record<string, unknown> | undefined;
+      if (!s) return;
+      if (e.type === 'nerf:render') {
+        s.isRendering = true;
+        ctx.emit?.('nerf:rendering');
+      }
+      if (e.type === 'nerf:stop') {
+        s.isRendering = false;
+        ctx.emit?.('nerf:stopped', { steps: s.trainStep });
+      }
     },
   };
 }

package/src/traits/VolumetricTrait.ts

@@ -2,17 +2,40 @@
 import {
   registerVolumetricNode,
   setVolumetricVoxelPayload,
-  unregisterVolumetricNode
+  unregisterVolumetricNode,
 } from '@holoscript/crdt-spatial';
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type VolumetricFormat = 'point_cloud' | 'voxel' | 'mesh_sequence' | 'depth_map' | 'holographic';
-export interface VolumetricConfig { format: VolumetricFormat; resolution: number; frameRate: number; compressionLevel: number; streamingEnabled: boolean; boundingBoxM: [number, number, number]; colorDepth: 8 | 10 | 12; }
+export type VolumetricFormat =
+  | 'point_cloud'
+  | 'voxel'
+  | 'mesh_sequence'
+  | 'depth_map'
+  | 'holographic';
+export interface VolumetricConfig {
+  format: VolumetricFormat;
+  resolution: number;
+  frameRate: number;
+  compressionLevel: number;
+  streamingEnabled: boolean;
+  boundingBoxM: [number, number, number];
+  colorDepth: 8 | 10 | 12;
+}
 
-const defaultConfig: VolumetricConfig = { format: 'point_cloud', resolution: 1024, frameRate: 30, compressionLevel: 5, streamingEnabled: false, boundingBoxM: [2, 2, 2], colorDepth: 8 };
+const defaultConfig: VolumetricConfig = {
+  format: 'point_cloud',
+  resolution: 1024,
+  frameRate: 30,
+  compressionLevel: 5,
+  streamingEnabled: false,
+  boundingBoxM: [2, 2, 2],
+  colorDepth: 8,
+};
 
 export function createVolumetricHandler(): TraitHandler<VolumetricConfig> {
-  return { name: 'volumetric', defaultConfig,
+  return {
+    name: 'volumetric',
+    defaultConfig,
     onAttach(n: HSPlusNode, c: VolumetricConfig, ctx: TraitContext) {
       if (!n.id) {
         n.id = `vol_${Math.random().toString(36).slice(2, 11)}`;
@@ -34,14 +57,25 @@ export function createVolumetricHandler(): TraitHandler<VolumetricConfig> {
       ctx.emit?.('volumetric:unloaded');
     },
     onUpdate(n: HSPlusNode, c: VolumetricConfig, ctx: TraitContext, delta: number) {
-      const s = n.__volState as Record<string, unknown> | undefined; if (!s || !s.isPlaying) return;
+      const s = n.__volState as Record<string, unknown> | undefined;
+      if (!s || !s.isPlaying) return;
       (s.currentFrame as number) += c.frameRate * (delta / 1000);
-      if ((s.currentFrame as number) >= (s.totalFrames as number)) { s.currentFrame = 0; ctx.emit?.('volumetric:loop'); }
+      if ((s.currentFrame as number) >= (s.totalFrames as number)) {
+        s.currentFrame = 0;
+        ctx.emit?.('volumetric:loop');
+      }
     },
     onEvent(n: HSPlusNode, _c: VolumetricConfig, ctx: TraitContext, e: TraitEvent) {
-      const s = n.__volState as Record<string, unknown> | undefined; if (!s) return;
-      if (e.type === 'volumetric:play') { s.isPlaying = true; ctx.emit?.('volumetric:playing'); }
-      if (e.type === 'volumetric:pause') { s.isPlaying = false; ctx.emit?.('volumetric:paused'); }
+      const s = n.__volState as Record<string, unknown> | undefined;
+      if (!s) return;
+      if (e.type === 'volumetric:play') {
+        s.isPlaying = true;
+        ctx.emit?.('volumetric:playing');
+      }
+      if (e.type === 'volumetric:pause') {
+        s.isPlaying = false;
+        ctx.emit?.('volumetric:paused');
+      }
       const doc = ctx.spatialSync?.doc;
       const id = n.id;
       if (e.type === 'volumetric:sync_bytes' && doc && id) {

package/src/traits/types.ts

@@ -1,11 +1,26 @@
 import type { LoroDoc } from 'loro-crdt';
 
-export interface HSPlusNode { id?: string; properties?: Record<string, unknown>; [key: string]: unknown; }
+export interface HSPlusNode {
+  id?: string;
+  properties?: Record<string, unknown>;
+  [key: string]: unknown;
+}
 export interface TraitContext {
   emit?: (event: string, payload?: unknown) => void;
   /** Injected by HoloLand / spatial host so volumetric payloads sync on the shared Loro + WebRTC doc. */
   spatialSync?: { doc: LoroDoc };
   [key: string]: unknown;
 }
-export interface TraitEvent { type: string; payload?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitHandler<T = unknown> { name: string; defaultConfig: T; onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void; onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void; onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void; onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void; }
+export interface TraitEvent {
+  type: string;
+  payload?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitHandler<T = unknown> {
+  name: string;
+  defaultConfig: T;
+  onAttach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onDetach(n: HSPlusNode, c: T, ctx: TraitContext): void;
+  onUpdate(n: HSPlusNode, c: T, ctx: TraitContext, d: number): void;
+  onEvent(n: HSPlusNode, c: T, ctx: TraitContext, e: TraitEvent): void;
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025-2026 HoloScript Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.