@salsita-ai/sdk 0.0.0-stage → 0.49.0-develop.cbee856178

package/dist/domain/mocks/create-mock-domain-runtime.js

@@ -0,0 +1 @@
+import{createDomainRuntime as o}from"../domain-runtime/index.js";import{createMockDomainRuntimeServices as e}from"./create-mock-domain-runtime-services.js";import{createMockSessionContext as t}from"./create-mock-session-context.js";export const createMockDomainRuntime=(i,a)=>{let{sessionData:n,mode:r,role:s}=a,c={...i,createTransformers:o=>a.transformers.map(e=>e.transformer.register(o,e.priority??1/0))},m=o({config:c,services:e()});return m.actions.sessionContext.setSessionContext(t(s,n)),m.actions.access.setConfiguratorAccessInfo({raw:"mock-access-token",viewMode:"read"===r,revisionId:void 0,configurationId:"mock"}),m.actions.domainData.setDomainData({publishedData:a.publishedData,frontendData:a.frontendData,backendData:a.backendData}),m.actions.loadedData.completeConfiguratorLoad({initialRevisionId:"mock-revision",initialEntities:a.entities,modelVersion:c.domain.domainFactory.modelVersion,rootEntityType:a.rootEntityType,schemaIdentity:c.domain.domainFactory}),m};

package/dist/domain/mocks/create-mock-domain.d.ts

@@ -0,0 +1,10 @@
+import type { ApplicationConfig } from '../application/index.js';
+import type { $DomainEntity, Domain, DomainEntity, DomainMode } from '../core/index.js';
+export declare const createMockDomain: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, NAVIGATION_STATES extends string, VIEW_STATES extends string, TOOL_STATES extends string, EXPORT_STATES extends string, CHAT_CONTEXT extends Record<string, unknown>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ADMIN_ENTITIES extends DomainEntity<string>, ADMIN_ALLOWED_ROOT_ENTITIES extends ADMIN_ENTITIES, ADMIN_$MAP extends Record<ADMIN_ENTITIES['type'], $DomainEntity<ADMIN_ENTITIES>>, ADMIN_NAVIGATION_STATES extends string, ADMIN_VIEW_STATES extends string>(cfg: ApplicationConfig<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES, CHAT_CONTEXT, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ADMIN_ENTITIES, ADMIN_ALLOWED_ROOT_ENTITIES, ADMIN_$MAP, ADMIN_NAVIGATION_STATES, ADMIN_VIEW_STATES>, mocks: {
+    frontendData: FRONTEND_DATA;
+    publishedData: PUBLISHED_DATA;
+    sessionData: SESSION_DATA;
+    backendData: Record<string, unknown> | undefined;
+    mode: DomainMode;
+    role: 'anonymous' | 'user' | 'admin' | 'superadmin';
+}) => Domain<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP>;

package/dist/domain/mocks/create-mock-domain.js

@@ -0,0 +1 @@
+import{createDomainRuntime as o}from"../domain-runtime/index.js";import{createMockDomainRuntimeServices as e}from"./create-mock-domain-runtime-services.js";import{createMockSessionContext as t}from"./create-mock-session-context.js";export const createMockDomain=(i,n)=>{let{frontendData:s,publishedData:a,sessionData:c,backendData:r,mode:m,role:d}=n,f=o({config:i,services:e()});return f.actions.access.setConfiguratorAccessInfo({raw:"mock-access-token",viewMode:"read"===m,revisionId:void 0,configurationId:"mock-configuration"}),"finalize"===m&&f.actions.domainContext.configurator.setExecutionMode("finalize"),f.actions.domainData.setDomainData({publishedData:a,frontendData:s,backendData:r}),f.actions.sessionContext.setSessionContext(t(d,c)),f.selectors.domainContext.configurator.getDomain()};

package/dist/domain/mocks/create-mock-session-context.d.ts

@@ -0,0 +1,2 @@
+import type { DomainSessionContext } from '../domain-runtime/index.js';
+export declare const createMockSessionContext: (role: DomainSessionContext['role'], data: Record<string, unknown>) => DomainSessionContext;

package/dist/domain/mocks/create-mock-session-context.js

@@ -0,0 +1 @@
+export const createMockSessionContext=(e,o)=>({role:e,data:o});

package/dist/domain/mocks/create-mock-state.d.ts

@@ -0,0 +1,6 @@
+import type { ApplicationConfig } from '../application/index.js';
+import type { $DomainEntity, DomainEntity, DomainState } from '../core/index.js';
+export declare const createMockState: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, NAVIGATION_STATES extends string, VIEW_STATES extends string, TOOL_STATES extends string, EXPORT_STATES extends string, CHAT_CONTEXT extends Record<string, unknown>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ADMIN_ENTITIES extends DomainEntity<string>, ADMIN_ALLOWED_ROOT_ENTITIES extends ADMIN_ENTITIES, ADMIN_$MAP extends Record<ADMIN_ENTITIES['type'], $DomainEntity<ADMIN_ENTITIES>>, ADMIN_NAVIGATION_STATES extends string, ADMIN_VIEW_STATES extends string>(cfg: ApplicationConfig<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, NAVIGATION_STATES, VIEW_STATES, TOOL_STATES, EXPORT_STATES, CHAT_CONTEXT, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ADMIN_ENTITIES, ADMIN_ALLOWED_ROOT_ENTITIES, ADMIN_$MAP, ADMIN_NAVIGATION_STATES, ADMIN_VIEW_STATES>, mocks: {
+    entities: ENTITIES[];
+    rootEntityType: ALLOWED_ROOT_ENTITIES['type'];
+}) => DomainState<ENTITIES>;

package/dist/domain/mocks/create-mock-state.js

@@ -0,0 +1 @@
+export const createMockState=(t,e)=>{let{entities:o,rootEntityType:i}=e,n=o.find(t=>t.type===i)?.id;if(!n)throw Error(`Root entity ${i} not found in the mocks`);return{entities:t.domain.domainFactory.validateAndMigrateState(o,t.domain.domainFactory.modelVersion),rootEntityId:n,rootEntityType:i,ephemeralRecords:[]}};

package/dist/domain/mocks/index.d.ts

@@ -0,0 +1,6 @@
+export { createMockDomain } from './create-mock-domain.js';
+export { createMockState } from './create-mock-state.js';
+export { createMockDomainContext, type MockTransformer } from './create-mock-domain-context.js';
+export { createMockDomainRuntime } from './create-mock-domain-runtime.js';
+export { createMockSessionContext } from './create-mock-session-context.js';
+export { createMockDomainRuntimeServices } from './create-mock-domain-runtime-services.js';

package/dist/domain/mocks/index.js

@@ -0,0 +1 @@
+export{createMockDomain}from"./create-mock-domain.js";export{createMockState}from"./create-mock-state.js";export{createMockDomainContext}from"./create-mock-domain-context.js";export{createMockDomainRuntime}from"./create-mock-domain-runtime.js";export{createMockSessionContext}from"./create-mock-session-context.js";export{createMockDomainRuntimeServices}from"./create-mock-domain-runtime-services.js";

package/dist/domain/projections/blender-projections/blender-projections.d.ts

@@ -0,0 +1,32 @@
+import type { BlenderLight } from '@salsita-ai/contracts/webhook';
+import type { DomainEntity, DomainState } from '../../core/index.js';
+import type { DomainContextSelectors } from '../../domain-runtime/domain-context/index.js';
+import type { DomainServicesSelectors } from '../../domain-runtime/domain-services/index.js';
+import type { BlenderCamera, BlenderImageConfig, BlenderImageSize, BlenderSceneConfig, BlenderSceneObject, SceneEntityNode } from './types.js';
+/**
+ * Constructor context of a `BlenderProjections`. It reaches its domain collaborators through the
+ * domain-context selectors, like every other projection on that slice, so the context names no
+ * instances and stops being parameterised over entity types.
+ */
+export interface BlenderProjectionsContext {
+    readonly selectors: DomainContextSelectors;
+    readonly domainServicesSelectors: DomainServicesSelectors;
+}
+/** BlenderProjections with its entity types erased — how the runtime selectors expose the instance. */
+export type AnyBlenderProjections = BlenderProjections<any>;
+export declare class BlenderProjections<ENTITIES extends DomainEntity<string>> {
+    private readonly _context;
+    constructor(_context: BlenderProjectionsContext);
+    private readonly _readEntityComponents;
+    private readonly _traverse;
+    getSceneEntityTree: (state: DomainState<ENTITIES>) => SceneEntityNode;
+    private readonly _getBlenderObjects;
+    getBlenderObjects: (state: DomainState<ENTITIES>) => BlenderSceneObject[];
+    private readonly _prepareExportState;
+    private readonly _getBlenderLights;
+    getBlenderLights: (state: DomainState<ENTITIES>) => BlenderLight[];
+    getBlenderCamera: (state: DomainState<ENTITIES>, imageSize: BlenderImageSize) => BlenderCamera;
+    private readonly _getBlenderSceneConfigFromState;
+    getBlenderSceneConfig: (state: DomainState<ENTITIES>, exportState: string, exportedEntityId: ENTITIES['id']) => BlenderSceneConfig;
+    getBlenderImageConfig: (state: DomainState<ENTITIES>, exportState: string, exportedEntityId: ENTITIES['id'], imageSize: BlenderImageSize) => BlenderImageConfig;
+}

package/dist/domain/projections/blender-projections/blender-projections.js

@@ -0,0 +1 @@
+import{Matrix4 as e}from"three";import{groupComponentsByEntityIdAndName as t}from"../../components/group-components-by-entity-id-and-name.js";import{resolveMorphTargetInfluences as n}from"../../scene/index.js";import{customSceneEntityComponent as r,hiddenEntityComponent as i,materialOverridePropertyTransitionComponent as o,materialOverrideTransformerComponent as s,sceneEntityAmbientLightComponent as a,sceneEntityBoxObjectComponent as c,sceneEntityDirectionalLightComponent as l,sceneEntityLocalMaterialOverrideComponent as m,sceneEntityMaterialOverrideComponent as d,sceneEntityObjectClipComponent as g,sceneEntityObjectComponent as p,sceneEntityObjectDecalComponent as h,sceneEntityObjectGroupComponent as f,sceneEntityObjectLocalMaterialOverrideComponent as y,sceneEntityObjectMaterialOverrideComponent as j,sceneEntityObjectPropertiesComponent as x,sceneEntityObjectRemoteMaterialOverrideComponent as u,sceneEntityObjectTextDecalComponent as S,sceneEntityObjectTransformerComponent as v,sceneEntityObjectTransmissiveMaterialOverrideComponent as b,sceneEntityPointLightComponent as _,sceneEntityPropertiesComponent as E,sceneEntityRectAreaLightComponent as O,sceneEntityRemoteMaterialOverrideComponent as N,sceneEntityRemoteObjectComponent as B,sceneEntitySpotLightComponent as I,sceneEntityTransmissiveMaterialOverrideComponent as w}from"../../system-components/index.js";import{createSceneObjectGroupTransformResolver as $}from"../common/scene-object-transform.js";import{reduceMaterialOverrides as L}from"../material-overrides.js";import{projectBlenderCamera as C}from"./camera.js";import{getBlenderObjectMaterialOverrides as T}from"./entity-overrides.js";import{projectBlenderLight as D}from"./lights.js";import{projectBlenderMaterialOverrides as P}from"./materials.js";import{getBlenderObjectTransform as M}from"./transforms.js";let U=e=>"fileUrl"in e,R=(e,t)=>`${e}_${t}`;export class BlenderProjections{_context;constructor(e){this._context=e}_readEntityComponents=(e,n)=>t(this._context.selectors.getComponentReader().readManyComponents({entityIds:[e],componentTypes:[r,i,E,B,p,c,N,m,d,w,x,f,j,y,u,b,S,h,v,g,s,o,_,I,l,a,O]},n)).get(e);_traverse=(e,t,r)=>{let i=this._readEntityComponents(e.id,r),o=[...i?.sceneEntityRemoteObject??[],...i?.sceneEntityObject??[],...i?.sceneEntityBoxObject??[]],s={worldMatrix:this._context.selectors.getPositionProjections().getEntityWorldMatrix(e.id,r,null)},a=(i?.hiddenEntity?.length??0)>0,c={id:e.id,parent:t,customEntity:i?.customSceneEntity?.[0]?.state.node,isHidden:a,overrideComponents:i,properties:s,sceneObjects:o.map(r=>{let o=i?.sceneEntityObjectProperties?.find(e=>e.componentInstance.instanceName===r.componentInstance.instanceName)?.state,s=i?.sceneEntityObjectTextDecal?.filter(e=>e.componentInstance.instanceName===r.componentInstance.instanceName),a=i?.sceneEntityObjectDecal?.filter(e=>e.componentInstance.instanceName===r.componentInstance.instanceName),c=i?.sceneEntityObjectTransformer?.filter(e=>e.state.target===r.componentInstance.instanceName),l=n(o?.morphTargetInfluences,t=>this._context.domainServicesSelectors.getLogger().warn(`Morph target "${t}" on object ${r.componentInstance.instanceName} of entity ${e.id} has scaleZero equal to scaleOne, so its influence is undefined and is exported to Blender as 0. Give scaleZero and scaleOne different values.`)),m=i?.sceneEntityObjectClip?.filter(e=>e.state.target===r.componentInstance.instanceName),{overrides:d,transformations:g,transitions:p}=T(i??{},t,r.componentInstance.instanceName);return{instanceName:r.componentInstance.instanceName,object:r.state,properties:o,morphTargetInfluences:l,textDecals:s,decals:a,materialOverrides:d,materialOverrideTransformations:g,materialOverridePropertyTransitions:p,objectTransformations:c,clips:m}}),nodes:[]};for(let t of e.nodes){let e=this._traverse(t.node,c,r);c.nodes.push(e)}return c};getSceneEntityTree=e=>{let{root:t}=this._context.selectors.getCompositionProjections().getTree(e);return this._traverse(t,null,e)};_getBlenderObjects=(t,n)=>{let r=this._context.selectors.getDimensionSystem().getDataDistanceUnit(t),i=[],o=t=>{if(t.isHidden)return;if(null!=t.customEntity)return void this._context.domainServicesSelectors.getLogger().warn(`Custom entity ${t.id} is not supported in Blender.`);let n=t.overrideComponents?.materialOverrideTransformer??[];n.length>0&&this._context.domainServicesSelectors.getLogger().warn(`Entity ${t.id} has ${n.length} material override transformer(s), they are not applied in Blender. Set the final material values on the overrides active in the export state.`);let s=t.properties,a=$(t.overrideComponents?.sceneEntityObjectGroup?.map(e=>({instanceName:e.componentInstance.instanceName,state:e.state}))??[],r),c=new Map(t.sceneObjects.map(e=>[e,a(e.properties?.targetParentGroup,e.instanceName)]));for(let n of t.sceneObjects){let o=c.get(n);if(o?.visible===!1||n.properties?.visible===!1||n.properties?.rendered===!1)continue;if(!U(n.object)){this._context.domainServicesSelectors.getLogger().warn(`Object ${n.instanceName} is not a remote object, it will not be rendered in Blender.`);continue}n.textDecals&&n.textDecals.length>0&&this._context.domainServicesSelectors.getLogger().warn(`Object ${n.instanceName} of entity ${t.id} has text decals, they are not rendered in Blender.`),n.decals&&n.decals.length>0&&this._context.domainServicesSelectors.getLogger().warn(`Object ${n.instanceName} of entity ${t.id} has decals, they are not rendered in Blender.`),n.objectTransformations&&n.objectTransformations.length>0&&this._context.domainServicesSelectors.getLogger().warn(`Object ${n.instanceName} of entity ${t.id} has object transformers, they are not applied in Blender. Express the transform through sceneEntityObjectProperties or a sceneEntityObjectGroup active in the export state.`),n.clips&&n.clips.length>0&&this._context.domainServicesSelectors.getLogger().warn(`Object ${n.instanceName} of entity ${t.id} has animation clips, they are not played in Blender.`);let a=n.object,{position:l,scale:m,rotation:d}=M(o?new e().multiplyMatrices(s.worldMatrix,o.matrix):s.worldMatrix,n.properties,a.dimensionUnit??r,r),g=L(n.materialOverrides??[]),p=P({logger:this._context.domainServicesSelectors.getLogger(),materialOverrides:g,objectInstanceName:n.instanceName,transitions:n.materialOverridePropertyTransitions??[]});i.push({id:R(t.id,n.instanceName),objectName:a.objectName,position:l,scale:m,rotation:d,morphTargetInfluences:n.morphTargetInfluences,materialOverrides:p})}for(let e of t.nodes)o(e)};return o(n),i};getBlenderObjects=e=>this._getBlenderObjects(e,this.getSceneEntityTree(e));_prepareExportState=(e,t,n)=>{let r=this._context.selectors.getNavigationSystem().getExportUpdate(t,n),i=this._context.selectors.getStoreSystem().prepareStateEmission([r],e,"staged");if(!i.validity.valid)throw this._context.domainServicesSelectors.getLogger().error(`Setting an export state to ${t} for entity ${n} resulted in an invalid state! Check if there isn't a transformer corrupting the state as a reaction to setting the export state.`,i),Error("Exported state is invalid!");return i.state};_getBlenderLights=(e,t)=>{let n=this._context.selectors.getDimensionSystem().getDataDistanceUnit(e),r=[],i=e=>{if(e.isHidden||null!=e.customEntity)return;let t=e.overrideComponents,o=t?.sceneEntityAmbientLight??[];for(let i of(o.length>0&&this._context.domainServicesSelectors.getLogger().warn(`Entity "${e.id}" has ${o.length} ambient light component(s) which are not exported to Blender because Blender has no equivalent ambient light type. Use HDRI lighting or additional point/area lights instead.`),[...t?.sceneEntityPointLight??[],...t?.sceneEntitySpotLight??[],...t?.sceneEntityDirectionalLight??[],...t?.sceneEntityRectAreaLight??[]])){let t=D({entityId:e.id,entityWorldMatrix:e.properties.worldMatrix,snapshot:i,distanceUnit:n});null!=t?r.push(t):this._context.domainServicesSelectors.getLogger().warn(`Unknown light component type for ${i.componentInstance.instanceName}`)}for(let t of e.nodes)i(t)};return i(t),r};getBlenderLights=e=>this._getBlenderLights(e,this.getSceneEntityTree(e));getBlenderCamera=(e,t)=>C(e,t,{componentReader:this._context.selectors.getComponentReader(),dimensionSystem:this._context.selectors.getDimensionSystem(),positionProjections:this._context.selectors.getPositionProjections()});_getBlenderSceneConfigFromState=e=>{let t=this.getSceneEntityTree(e),n=this._getBlenderObjects(e,t),r=this._getBlenderLights(e,t);return{renderedEntities:n.map(e=>({id:e.id,type:"default",objectName:e.objectName,position:e.position,scale:e.scale,rotation:e.rotation,materialOverrides:e.materialOverrides,morphTargetInfluences:e.morphTargetInfluences})),lights:r.length>0?r:void 0}};getBlenderSceneConfig=(e,t,n)=>{let r=this._prepareExportState(e,t,n);return this._getBlenderSceneConfigFromState(r)};getBlenderImageConfig=(e,t,n,r)=>{let i=this._prepareExportState(e,t,n);return{width:r.width,height:r.height,...this._getBlenderSceneConfigFromState(i),camera:this.getBlenderCamera(i,r)}}}

package/dist/domain/projections/blender-projections/camera.d.ts

@@ -0,0 +1,11 @@
+import type { DomainEntity, DomainState } from '../../core/index.js';
+import type { AnyDimensionSystem } from '../../domain-context/index.js';
+import type { AnyComponentReader } from '../../domain-runtime/domain-context/index.js';
+import type { AnyPositionProjections } from '../position-projections.js';
+import type { BlenderCamera, BlenderImageSize } from './types.js';
+export interface BlenderCameraProjectionContext {
+    readonly componentReader: Pick<AnyComponentReader, 'readManyComponents' | 'readOneComponent'>;
+    readonly dimensionSystem: Pick<AnyDimensionSystem, 'getDataDistanceUnit'>;
+    readonly positionProjections: Pick<AnyPositionProjections, 'getEntityWorldMatrix'>;
+}
+export declare const projectBlenderCamera: <ENTITIES extends DomainEntity<string>>(state: DomainState<ENTITIES>, imageSize: BlenderImageSize, context: BlenderCameraProjectionContext) => BlenderCamera;

package/dist/domain/projections/blender-projections/camera.js

@@ -0,0 +1 @@
+import{Matrix4 as e,Vector3 as t}from"three";import{distanceUnitToDefault as n}from"../../dimensions/index.js";import{boundingBoxComponent as o,boundingSphereComponent as i,fitEntityOrthographicCameraComponent as r,fitEntityPerspectiveCameraComponent as a,fitRootOrthographicCameraComponent as s,fitRootPerspectiveCameraComponent as d,isFitEntityOrthographicCameraComponentSnapshot as m,isFitEntityPerspectiveCameraComponentSnapshot as c,isFitRootOrthographicCameraComponent as p,isFitRootPerspectiveCameraComponent as h,isStaticOrthographicCameraComponent as l,isStaticPerspectiveCameraComponent as f,staticOrthographicCameraComponent as u,staticPerspectiveCameraComponent as g}from"../../system-components/index.js";import{cameraOrbitToCartesian as y,getPerspectiveBoxFitDistance as w,getPerspectiveSphereFitDistance as b,resolveBoundingBox as x,resolveBoundingSphere as v,resolveCameraDistance as B,resolveCameraOrbit as I}from"../common/index.js";import{threePositionToBlender as E}from"./transforms.js";let j=(e,t,n,o,i)=>({position:E(y(t,n,o).add(e)),target:E(e),fov:i});export const projectBlenderCamera=(y,E,T)=>{let A,$,M=(e=>{if(!Number.isFinite(e.width)||e.width<=0||!Number.isFinite(e.height)||e.height<=0)throw Error(`Blender camera projection requires finite, positive image dimensions, but received width ${e.width} and height ${e.height}. Pass the same width and height used by the GenerateImages task.`);return e.width/e.height})(E),k=T.componentReader.readManyComponents({componentTypes:[d,a,r,s,g,u]},y);if(0===k.length)throw Error("No active camera component found for the current state. Make sure a camera component with matching $filter.exportStates is defined in the domain spec.");let C=k.reduce((e,t)=>(t.state.priority??1)>(e.state.priority??1)?t:e);if(l(C)||p(C)||m(C))throw Error(`Orthographic camera component "${C.componentInstance.componentType.name}" is not supported for Blender rendering. Use a perspective camera component instead.`);let O=y.entities.find(e=>e.id===C.componentInstance.entityId);if(!O)throw Error(`Blender camera component "${C.componentInstance.componentType.name}" is attached to entity "${C.componentInstance.entityId}", which is not a domain entity in the current state. Attach the camera to a domain entity included in the exported state.`);let D=T.dimensionSystem.getDataDistanceUnit(y),S=!0===C.state.relative?T.positionProjections.getEntityWorldMatrix(O.id,y,null):new e,U=I({state:C.state,dimensionUnit:D,worldMatrix:S}),{azimuthAngle:q,polarAngle:N}=U,P="fov"in C.state?C.state.fov:void 0;if(f(C)){let e=new t(n(C.state.lookAtX,D)??0,n(C.state.lookAtY,D)??0,n(C.state.lookAtZ,D)??0);return!0===C.state.relative&&e.applyMatrix4(S),j(e,q,N,B(U.distance,U,0),P)}if(!h(C)&&!c(C))throw Error(`Unsupported camera component type "${C.componentInstance.componentType.name}" for server-side Blender rendering.`);let R=h(C)?y.rootEntityId:O.id,F=!0===C.state.fitToBox,V=T.positionProjections.getEntityWorldMatrix(R,y,null);if(F){let e=T.componentReader.readOneComponent({componentType:o,entityId:R},y);if(!e)throw Error("Blender box-fit camera requires a boundingBox component on the target entity because mesh-based fitting is unavailable without a 3D scene. Add the component or use a static camera.");let n=x(e.state,V,D);A=n.getCenter(new t),$=w({boundingBox:n,fieldOfView:P??50,viewportAspectRatio:M,viewingAngles:{azimuthAngle:q,polarAngle:N}})}else{let e=T.componentReader.readOneComponent({componentType:i,entityId:R},y);if(!e)throw Error("Blender sphere-fit camera requires a boundingSphere component on the target entity because mesh-based fitting is unavailable without a 3D scene. Add the component, set fitToBox: true with a boundingBox, or use a static camera.");let t=v(e.state,V,D);A=t.center,$=b({boundingSphere:t,fieldOfView:P??50,viewportAspectRatio:M})}return j(A,q,N,B(U.distance,U,$),P)};

package/dist/domain/projections/blender-projections/entity-overrides.d.ts

@@ -0,0 +1,12 @@
+import type { ComponentSnapshot } from '../../core/index.js';
+import type { SceneEntityComponents, SceneEntityNode } from './types.js';
+export declare const getParentEntityOverrides: (parent: SceneEntityNode['parent']) => {
+    overrides: (ComponentSnapshot<import("../../index.js").SystemComponentType<"sceneEntityLocalMaterialOverride", import("../../index.js").SceneEntityLocalMaterialOverrideComponentState, never>> | ComponentSnapshot<import("../../index.js").SystemComponentType<"sceneEntityMaterialOverride", import("../../index.js").SceneEntityMaterialOverrideComponentState, never>> | ComponentSnapshot<import("../../index.js").SystemComponentType<"sceneEntityRemoteMaterialOverride", import("../../index.js").SceneEntityRemoteMaterialOverrideComponentState, never>> | ComponentSnapshot<import("../../index.js").SystemComponentType<"sceneEntityTransmissiveMaterialOverride", import("../../index.js").SceneEntityTransmissiveMaterialOverrideComponentState, never>>)[];
+    transformations: ComponentSnapshot<import("../../index.js").SystemComponentType<"materialOverrideTransformer", import("../../index.js").MaterialOverrideTransformerComponentState, never>>[];
+    transitions: ComponentSnapshot<import("../../index.js").SystemComponentType<"materialOverridePropertyTransition", import("../../index.js").MaterialOverridePropertyTransitionComponentState, never>>[];
+};
+export declare const getBlenderObjectMaterialOverrides: (components: SceneEntityComponents, parent: SceneEntityNode | null, instanceName: string) => {
+    overrides: (ComponentSnapshot<import("../../index.js").SystemComponentType<"sceneEntityLocalMaterialOverride", import("../../index.js").SceneEntityLocalMaterialOverrideComponentState, never>> | ComponentSnapshot<import("../../index.js").SystemComponentType<"sceneEntityMaterialOverride", import("../../index.js").SceneEntityMaterialOverrideComponentState, never>> | ComponentSnapshot<import("../../index.js").SystemComponentType<"sceneEntityObjectLocalMaterialOverride", import("../../index.js").SceneEntityObjectLocalMaterialOverrideComponentState, never>> | ComponentSnapshot<import("../../index.js").SystemComponentType<"sceneEntityObjectMaterialOverride", import("../../index.js").SceneEntityObjectMaterialOverrideComponentState, never>> | ComponentSnapshot<import("../../index.js").SystemComponentType<"sceneEntityObjectRemoteMaterialOverride", import("../../index.js").SceneEntityObjectRemoteMaterialOverrideComponentState, never>> | ComponentSnapshot<import("../../index.js").SystemComponentType<"sceneEntityObjectTransmissiveMaterialOverride", import("../../index.js").SceneEntityObjectTransmissiveMaterialOverrideComponentState, never>> | ComponentSnapshot<import("../../index.js").SystemComponentType<"sceneEntityRemoteMaterialOverride", import("../../index.js").SceneEntityRemoteMaterialOverrideComponentState, never>> | ComponentSnapshot<import("../../index.js").SystemComponentType<"sceneEntityTransmissiveMaterialOverride", import("../../index.js").SceneEntityTransmissiveMaterialOverrideComponentState, never>>)[];
+    transformations: ComponentSnapshot<import("../../index.js").SystemComponentType<"materialOverrideTransformer", import("../../index.js").MaterialOverrideTransformerComponentState, never>>[];
+    transitions: ComponentSnapshot<import("../../index.js").SystemComponentType<"materialOverridePropertyTransition", import("../../index.js").MaterialOverridePropertyTransitionComponentState, never>>[];
+};

package/dist/domain/projections/blender-projections/entity-overrides.js

@@ -0,0 +1 @@
+export const getParentEntityOverrides=e=>{let r=e,t=[],i=[],n=[];for(;null!=r;){let e=r.overrideComponents;t.unshift(...e?.sceneEntityRemoteMaterialOverride??[],...e?.sceneEntityLocalMaterialOverride??[],...e?.sceneEntityMaterialOverride??[],...e?.sceneEntityTransmissiveMaterialOverride??[]),e?.materialOverrideTransformer&&i.unshift(...e.materialOverrideTransformer),e?.materialOverridePropertyTransition&&n.unshift(...e.materialOverridePropertyTransition),r=r.parent}return{overrides:t,transformations:i,transitions:n}};export const getBlenderObjectMaterialOverrides=(e,r,t)=>{let i=e.sceneEntityObjectRemoteMaterialOverride?.filter(e=>e.componentInstance.instanceName===t)??[],n=e.sceneEntityObjectMaterialOverride?.filter(e=>e.componentInstance.instanceName===t)??[],a=e.sceneEntityObjectLocalMaterialOverride?.filter(e=>e.componentInstance.instanceName===t)??[],s=e.sceneEntityObjectTransmissiveMaterialOverride?.filter(e=>e.componentInstance.instanceName===t)??[],{overrides:o,transformations:c,transitions:l}=getParentEntityOverrides(r);return{overrides:[...o,...e.sceneEntityLocalMaterialOverride??[],...e.sceneEntityRemoteMaterialOverride??[],...e.sceneEntityMaterialOverride??[],...e.sceneEntityTransmissiveMaterialOverride??[],...n,...a,...i,...s],transformations:[...c,...e.materialOverrideTransformer??[]],transitions:[...l,...e.materialOverridePropertyTransition??[]]}};

package/dist/domain/projections/blender-projections/index.d.ts

@@ -0,0 +1,3 @@
+export { type AnyBlenderProjections, BlenderProjections, type BlenderProjectionsContext, } from './blender-projections.js';
+export { getBlenderObjectMaterialOverrides, getParentEntityOverrides } from './entity-overrides.js';
+export type { BlenderCamera, BlenderCameraDof, BlenderImageConfig, BlenderImageSize, BlenderMaterialOverride, BlenderRenderedEntity, BlenderRenderSettings, BlenderSceneConfig, BlenderSceneObject, SceneEntityComponents, SceneEntityNode, SceneEntityObject, SceneEntityProperties, } from './types.js';

package/dist/domain/projections/blender-projections/index.js

@@ -0,0 +1 @@
+export{BlenderProjections}from"./blender-projections.js";export{getBlenderObjectMaterialOverrides,getParentEntityOverrides}from"./entity-overrides.js";

package/dist/domain/projections/blender-projections/lights.d.ts

@@ -0,0 +1,14 @@
+import { type Matrix4 } from 'three';
+import type { BlenderLight } from '@salsita-ai/contracts/webhook';
+import type { ComponentSnapshot, EntityId } from '../../core/index.js';
+import { type DimensionUnit } from '../../dimensions/index.js';
+import { type SceneEntityDirectionalLightComponent, type SceneEntityPointLightComponent, type SceneEntityRectAreaLightComponent, type SceneEntitySpotLightComponent } from '../../system-components/index.js';
+export type BlenderLightSnapshot = ComponentSnapshot<SceneEntityPointLightComponent | SceneEntitySpotLightComponent | SceneEntityDirectionalLightComponent | SceneEntityRectAreaLightComponent>;
+interface BlenderLightProjectionProps {
+    readonly entityId: EntityId;
+    readonly entityWorldMatrix: Matrix4;
+    readonly snapshot: BlenderLightSnapshot;
+    readonly distanceUnit: DimensionUnit;
+}
+export declare const projectBlenderLight: (props: BlenderLightProjectionProps) => BlenderLight | undefined;
+export {};

package/dist/domain/projections/blender-projections/lights.js

@@ -0,0 +1 @@
+import{Vector3 as t}from"three";import{match as e}from"ts-pattern";import{distanceUnitToDefault as a}from"../../dimensions/index.js";import{isSceneEntityDirectionalLightComponent as r,isSceneEntityPointLightComponent as s,isSceneEntityRectAreaLightComponent as o,isSceneEntitySpotLightComponent as n}from"../../system-components/index.js";import{normalizeColorToHex as i}from"../common/color.js";import{blenderQuaternionFromAxisAngle as l,blenderQuaternionFromUnitVectors as d,multiplyBlenderQuaternions as g,threePositionToBlender as m}from"./transforms.js";export const projectBlenderLight=p=>{let{entityId:c,entityWorldMatrix:h,snapshot:u,distanceUnit:f}=p,w=(e,r,s)=>m(new t(a(e,f)??0,a(r,f)??0,a(s,f)??0).applyMatrix4(h)),b=w(u.state.offsetX,u.state.offsetY,u.state.offsetZ),S=(e,a,r,s)=>{let o=w(e,a,r),n=new t(o[0]-b[0],o[1]-b[1],o[2]-b[2]);if(1e-18>n.lengthSq())return;n.normalize();let i=[n.x,n.y,n.z],m=d([0,0,-1],i);return void 0!==s&&0!==s&&(m=g(l(i,s),m)),[...m]},y=`${c}_${u.componentInstance.instanceName}`,F=u.state.blender?.intensity??u.state.intensity,X={id:y,position:b,color:u.state.color?i(u.state.color):void 0,intensity:F},Y={specularFactor:u.state.blender?.specularFactor,diffuseFactor:u.state.blender?.diffuseFactor,volumeFactor:u.state.blender?.volumeFactor};return e(u).when(o,t=>({...X,...Y,type:"AREA",target:w(t.state.targetX,t.state.targetY,t.state.targetZ),rotation:S(t.state.targetX,t.state.targetY,t.state.targetZ,"number"==typeof t.state.roll&&Number.isFinite(t.state.roll)?t.state.roll:void 0),width:a(t.state.width,f),height:a(t.state.height,f),shape:t.state.blender?.shape,spread:t.state.blender?.spread})).when(s,t=>({...X,...Y,type:"POINT",castShadow:t.state.castShadow,radius:t.state.blender?.radius})).when(n,t=>({...X,...Y,type:"SPOT",castShadow:t.state.castShadow,angle:t.state.angle,penumbra:t.state.penumbra,target:w(t.state.targetX,t.state.targetY,t.state.targetZ),rotation:S(t.state.targetX,t.state.targetY,t.state.targetZ),radius:t.state.blender?.radius,showCone:t.state.blender?.showCone,useSquare:t.state.blender?.useSquare})).when(r,t=>({...X,...Y,type:"SUN",castShadow:t.state.castShadow,target:w(t.state.targetX,t.state.targetY,t.state.targetZ),rotation:S(t.state.targetX,t.state.targetY,t.state.targetZ),blenderAngle:t.state.blender?.angle})).otherwise(()=>void 0)};

package/dist/domain/projections/blender-projections/materials.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from '@salsita-ai/common/utils';
+import type { BlenderMaterialOverride } from '@salsita-ai/contracts/webhook';
+import type { ComponentSnapshot } from '../../core/index.js';
+import type { MaterialOverridePropertyTransitionComponent } from '../../system-components/index.js';
+import type { MaterialOverrides } from '../material-overrides.js';
+interface BlenderMaterialProjectionProps {
+    readonly logger?: Logger;
+    readonly materialOverrides: MaterialOverrides;
+    readonly objectInstanceName: string;
+    readonly transitions: ReadonlyArray<ComponentSnapshot<MaterialOverridePropertyTransitionComponent>>;
+}
+export declare const projectBlenderMaterialOverrides: (props: BlenderMaterialProjectionProps) => Record<string, BlenderMaterialOverride>;
+export {};

package/dist/domain/projections/blender-projections/materials.js

@@ -0,0 +1 @@
+import{normalizeColorToHex as e}from"../common/color.js";export const projectBlenderMaterialOverrides=r=>{let{logger:o,materialOverrides:a,objectInstanceName:t,transitions:n}=r,l=Object.entries(a).reduce((r,[a,t])=>{if(!("fileUrl"in t.component.state))return o?.warn(`Material override ${a} is not a remote material override, it will not be rendered in Blender.`),r;let n=t.component.state,l=n.color?e(n.color):void 0;return null!=n.color&&""!==n.color&&void 0===l&&o?.warn(`Blender export omitted color on remote material override slot "${a}" because "${n.color}" is neither valid hex nor a supported simple color name, so the exporter could not convert it. Set color to a hex string such as #RRGGBB or a supported simple color name.`),r[a]={baseMaterialName:t.materialToOverride,color:l,roughness:n.roughness,metalness:n.metalness,textureUrl:n.textureUrl,roughnessMapUrl:n.roughnessMapUrl,normalMapUrl:n.normalMapUrl,normalScale:n.normalScale,aoMapUrl:n.aoMapUrl,aoMapIntensity:n.aoMapIntensity,bumpMapUrl:n.bumpMapUrl,bumpScale:n.bumpScale,metalnessMapUrl:n.metalnessMapUrl,emissive:n.emissive?e(n.emissive):void 0,emissiveIntensity:n.emissiveIntensity,alphaMapUrl:n.alphaMapUrl,transparent:n.transparent,opacity:n.opacity,clearcoat:n.clearcoat,clearcoatRoughness:n.clearcoatRoughness,clearcoatMapUrl:n.clearcoatMapUrl,clearcoatRoughnessMapUrl:n.clearcoatRoughnessMapUrl,clearcoatNormalMapUrl:n.clearcoatNormalMapUrl,clearcoatNormalScale:n.clearcoatNormalScale,sheen:n.sheen,sheenRoughness:n.sheenRoughness,sheenColor:n.sheenColor?e(n.sheenColor):void 0,sheenColorMapUrl:n.sheenColorMapUrl,sheenRoughnessMapUrl:n.sheenRoughnessMapUrl,specularIntensity:n.specularIntensity,specularColor:n.specularColor?e(n.specularColor):void 0,specularIntensityMapUrl:n.specularIntensityMapUrl,specularColorMapUrl:n.specularColorMapUrl,ior:n.ior,transmission:n.transmission,transmissionMapUrl:n.transmissionMapUrl,anisotropyStrength:n.anisotropyStrength,anisotropyRotation:n.anisotropyRotation,anisotropyMapUrl:n.anisotropyMapUrl,displacementMapUrl:n.displacementMapUrl,displacementScale:n.displacementScale,repeatX:n.repeatX,repeatY:n.repeatY},r},{}),s=new Set;for(let r of n){let n=r.state.value;if(void 0===n){o?.warn(`Blender export skipped material override property transition on object "${t}" (target override instance "${r.state.target}", property "${r.state.property}") because value was undefined, so no end state was available to apply. Set value to the color that should appear in the export (hex such as #RRGGBB or a supported simple color name).`);continue}for(let i of Object.entries(a).filter(([,e])=>e.component.componentInstance.instanceName===r.state.target).map(([e])=>e)){let r=l[i];if(!r)continue;let a=e(n);""!==n&&void 0===a&&o?.warn(`Blender export did not apply material override property transition color on object "${t}" slot "${i}" because "${n}" is neither valid hex nor a supported simple color name, so the exporter could not convert it and left the slot color unchanged. Set the transition value to a hex string such as #RRGGBB or a supported simple color name.`),a&&(s.has(i)&&o?.warn(`Blender export applied a second material override property transition color to object "${t}" slot "${i}"; transitions are processed in array order and the last successful one wins, which can hide overlapping transition definitions. Keep at most one color transition per slot or reorder materialOverridePropertyTransitions so only the intended value remains.`),s.add(i),l[i]={...r,color:a})}}return l};

package/dist/domain/projections/blender-projections/transforms.d.ts

@@ -0,0 +1,14 @@
+import { Matrix4, Vector3 } from 'three';
+import { type DimensionUnit } from '../../dimensions/index.js';
+import type { SceneEntityObjectPropertiesComponentState } from '../../system-components/index.js';
+type BlenderQuaternion = readonly [number, number, number, number];
+export declare const threePositionToBlender: (position: Vector3) => [number, number, number];
+export declare const multiplyBlenderQuaternions: (first: BlenderQuaternion, second: BlenderQuaternion) => BlenderQuaternion;
+export declare const blenderQuaternionFromUnitVectors: (from: readonly [number, number, number], to: readonly [number, number, number]) => BlenderQuaternion;
+export declare const blenderQuaternionFromAxisAngle: (unitAxis: readonly [number, number, number], angleRadians: number) => BlenderQuaternion;
+export declare const getBlenderObjectTransform: (objectParentWorldMatrix: Matrix4, objectProperties: SceneEntityObjectPropertiesComponentState | undefined, objectDimensionUnit: DimensionUnit, dataDistanceUnit: DimensionUnit) => {
+    position: [number, number, number];
+    scale: [number, number, number] | undefined;
+    rotation: [number, number, number, number] | undefined;
+};
+export {};

package/dist/domain/projections/blender-projections/transforms.js

@@ -0,0 +1 @@
+import{Matrix4 as e,Quaternion as t,Vector3 as n}from"three";import{convertDimensionUnits as o}from"../../dimensions/index.js";import{createSceneObjectTransformMatrix as r}from"../common/index.js";let i=e=>new t(e[1],e[2],e[3],e[0]),s=e=>[e.w,e.x,e.y,e.z];export const threePositionToBlender=e=>[e.x/1e3,-e.z/1e3,e.y/1e3];export const multiplyBlenderQuaternions=(e,t)=>s(i(e).multiply(i(t)));export const blenderQuaternionFromUnitVectors=(e,o)=>s(new t().setFromUnitVectors(new n(e[0],e[1],e[2]),new n(o[0],o[1],o[2])));export const blenderQuaternionFromAxisAngle=(e,o)=>s(new t().setFromAxisAngle(new n(e[0],e[1],e[2]),o));export const getBlenderObjectTransform=(i,a,m,l)=>{let x,w=r(a,l),p=new e().multiplyMatrices(i,w),b=new n,c=new t,d=new n;return p.decompose(b,c,d),[c.w,c.x,c.y,c.z].every(Number.isFinite)?c.normalize():c.identity(),{position:threePositionToBlender(b),scale:((e,t)=>{let r=o(1,t,"m"),i=new n(e.x*r,e.z*r,e.y*r);if(!(1e-9>Math.abs(i.x-1)&&1e-9>Math.abs(i.y-1)&&1e-9>Math.abs(i.z-1)))return[i.x,i.y,i.z]})(d,m),rotation:1e-9>Math.abs(Math.abs(c.w)-1)&&1e-9>Math.abs(c.x)&&1e-9>Math.abs(c.y)&&1e-9>Math.abs(c.z)?void 0:[(x=s(c))[0],x[1],-x[3],x[2]]}};

package/dist/domain/projections/blender-projections/types.d.ts

@@ -0,0 +1,95 @@
+import type { ReactNode } from 'react';
+import type { Matrix4 } from 'three';
+import type { BlenderCameraDof, BlenderLight, BlenderMaterialOverride, BlenderRenderSettings, DefaultRenderedEntity, GenerateImagesTask } from '@salsita-ai/contracts/webhook';
+import type { ComponentSnapshot, EntityId } from '../../core/index.js';
+import type { MaterialOverridePropertyTransitionComponent, MaterialOverrideTransformerComponent, SceneEntityAmbientLightComponent, SceneEntityBoxObjectComponentState, SceneEntityDirectionalLightComponent, SceneEntityLocalMaterialOverrideComponent, SceneEntityMaterialOverrideComponent, SceneEntityObjectClipComponent, SceneEntityObjectComponentState, SceneEntityObjectDecalComponent, SceneEntityObjectGroupComponent, SceneEntityObjectLocalMaterialOverrideComponent, SceneEntityObjectMaterialOverrideComponent, SceneEntityObjectPropertiesComponentState, SceneEntityObjectRemoteMaterialOverrideComponent, SceneEntityObjectTextDecalComponent, SceneEntityObjectTransformerComponent, SceneEntityObjectTransmissiveMaterialOverrideComponent, SceneEntityPointLightComponent, SceneEntityRectAreaLightComponent, SceneEntityRemoteMaterialOverrideComponent, SceneEntityRemoteObjectComponentState, SceneEntitySpotLightComponent, SceneEntityTransmissiveMaterialOverrideComponent } from '../../system-components/index.js';
+import type { MaterialOverrideComponent } from '../material-overrides.js';
+type GenerateImage = GenerateImagesTask['images'][number];
+/** Camera payload accepted by a Blender image-generation task. */
+export type BlenderCamera = NonNullable<GenerateImage['camera']>;
+/** Default rendered entity accepted by a Blender image-generation task. */
+export type BlenderRenderedEntity = DefaultRenderedEntity;
+/**
+ * Pixel dimensions of the image whose perspective camera framing is projected for Blender.
+ */
+export interface BlenderImageSize {
+    /** Output image width in pixels. */
+    readonly width: number;
+    /** Output image height in pixels. */
+    readonly height: number;
+}
+/**
+ * Blender entities and lights projected from a domain export state.
+ */
+export interface BlenderSceneConfig {
+    /** Domain entities projected into Blender coordinates and material settings. */
+    readonly renderedEntities: BlenderRenderedEntity[];
+    /** Domain lights projected into Blender, when the scene contains supported lights. */
+    readonly lights?: readonly BlenderLight[];
+}
+/**
+ * Complete Blender image projection for a domain export state and output resolution.
+ */
+export interface BlenderImageConfig extends BlenderSceneConfig {
+    /** Output image width in pixels. */
+    readonly width: number;
+    /** Output image height in pixels. */
+    readonly height: number;
+    /** Camera projected for the output image dimensions. */
+    readonly camera: BlenderCamera;
+}
+export type { BlenderCameraDof, BlenderMaterialOverride, BlenderRenderSettings };
+export interface SceneEntityComponents {
+    sceneEntityLocalMaterialOverride?: ReadonlyArray<ComponentSnapshot<SceneEntityLocalMaterialOverrideComponent>> | undefined;
+    sceneEntityMaterialOverride?: ReadonlyArray<ComponentSnapshot<SceneEntityMaterialOverrideComponent>> | undefined;
+    sceneEntityRemoteMaterialOverride?: ReadonlyArray<ComponentSnapshot<SceneEntityRemoteMaterialOverrideComponent>> | undefined;
+    sceneEntityObjectMaterialOverride?: ReadonlyArray<ComponentSnapshot<SceneEntityObjectMaterialOverrideComponent>> | undefined;
+    sceneEntityObjectLocalMaterialOverride?: ReadonlyArray<ComponentSnapshot<SceneEntityObjectLocalMaterialOverrideComponent>> | undefined;
+    sceneEntityObjectRemoteMaterialOverride?: ReadonlyArray<ComponentSnapshot<SceneEntityObjectRemoteMaterialOverrideComponent>> | undefined;
+    sceneEntityObjectTransmissiveMaterialOverride?: ReadonlyArray<ComponentSnapshot<SceneEntityObjectTransmissiveMaterialOverrideComponent>> | undefined;
+    sceneEntityTransmissiveMaterialOverride?: ReadonlyArray<ComponentSnapshot<SceneEntityTransmissiveMaterialOverrideComponent>> | undefined;
+    materialOverrideTransformer?: ReadonlyArray<ComponentSnapshot<MaterialOverrideTransformerComponent>> | undefined;
+    materialOverridePropertyTransition?: ReadonlyArray<ComponentSnapshot<MaterialOverridePropertyTransitionComponent>> | undefined;
+    sceneEntityAmbientLight?: ReadonlyArray<ComponentSnapshot<SceneEntityAmbientLightComponent>> | undefined;
+    sceneEntityPointLight?: ReadonlyArray<ComponentSnapshot<SceneEntityPointLightComponent>> | undefined;
+    sceneEntitySpotLight?: ReadonlyArray<ComponentSnapshot<SceneEntitySpotLightComponent>> | undefined;
+    sceneEntityDirectionalLight?: ReadonlyArray<ComponentSnapshot<SceneEntityDirectionalLightComponent>> | undefined;
+    sceneEntityRectAreaLight?: ReadonlyArray<ComponentSnapshot<SceneEntityRectAreaLightComponent>> | undefined;
+    sceneEntityObjectGroup?: ReadonlyArray<ComponentSnapshot<SceneEntityObjectGroupComponent>> | undefined;
+}
+export interface SceneEntityProperties {
+    readonly worldMatrix: Matrix4;
+}
+export interface SceneEntityObject {
+    instanceName: string;
+    object: SceneEntityRemoteObjectComponentState | SceneEntityObjectComponentState | SceneEntityBoxObjectComponentState;
+    properties?: SceneEntityObjectPropertiesComponentState | undefined;
+    textDecals?: Array<ComponentSnapshot<SceneEntityObjectTextDecalComponent>> | undefined;
+    decals?: Array<ComponentSnapshot<SceneEntityObjectDecalComponent>> | undefined;
+    materialOverrides?: Array<ComponentSnapshot<MaterialOverrideComponent>> | undefined;
+    materialOverrideTransformations?: Array<ComponentSnapshot<MaterialOverrideTransformerComponent>> | undefined;
+    materialOverridePropertyTransitions?: Array<ComponentSnapshot<MaterialOverridePropertyTransitionComponent>> | undefined;
+    morphTargetInfluences?: Record<string, number> | undefined;
+    objectTransformations?: Array<ComponentSnapshot<SceneEntityObjectTransformerComponent>> | undefined;
+    clips?: Array<ComponentSnapshot<SceneEntityObjectClipComponent>> | undefined;
+}
+export interface SceneEntityNode {
+    id: EntityId;
+    parent: SceneEntityNode | null;
+    customEntity?: ReactNode | undefined;
+    isHidden?: boolean | undefined;
+    sceneObjects: SceneEntityObject[];
+    properties: SceneEntityProperties;
+    overrideComponents?: SceneEntityComponents | undefined;
+    nodes: SceneEntityNode[];
+}
+/** One rendered object of `getBlenderObjects`, in Blender coordinates. */
+export interface BlenderSceneObject {
+    id: string;
+    objectName: string;
+    position: [number, number, number];
+    scale?: [number, number, number] | undefined;
+    rotation?: [number, number, number, number] | undefined;
+    morphTargetInfluences?: Record<string, number> | undefined;
+    materialOverrides?: Record<string, BlenderMaterialOverride>;
+}

package/dist/domain/projections/blender-projections/types.js

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

package/dist/domain/projections/collision-projections.d.ts

@@ -0,0 +1,264 @@
+import { Matrix4, Mesh, Vector3 } from 'three';
+import { type DomainEntity, type DomainState, type EntityId } from '../core/index.js';
+import type { DomainContextSelectors } from '../domain-runtime/domain-context/index.js';
+import { type AnyCollisionGeometrySnapshot } from '../system-components/index.js';
+/**
+ * DE-9IM-style classification of the spatial relationship between two
+ * collision meshes.
+ *
+ * - `disjoint` — no points in common
+ * - `touches` — share a boundary but no interior (zero-volume contact)
+ * - `overlaps` — interiors intersect, neither contains the other
+ * - `within` — A is inside B (sufficient via AABB containment; conservative
+ *   for rotated meshes — A may fit but its world-axis AABB doesn't)
+ * - `contains` — B is inside A (mirror of `within`)
+ * - `equals` — A and B occupy the same volume (rare; both AABBs equal)
+ */
+export type SpatialRelationship = 'disjoint' | 'touches' | 'overlaps' | 'within' | 'contains' | 'equals';
+/**
+ * Optional per-entity override for a collision query, used during drag to
+ * evaluate "what if this entity were at this matrix instead of its
+ * committed transform?" without staging the state.
+ */
+export interface CollisionQueryOverride {
+    readonly proposedWorldMatrix?: Matrix4;
+    /**
+     * Axes whose contact should be ignored when classifying or projecting
+     * for the `touches` predicate. Used by drag-time enforcement to honour
+     * the drag plane: a hotspot whose surface normals are perpendicular to
+     * the Y axis (e.g. `(0, 1, 0)`) constrains the drag to the XZ plane,
+     * so any Y-axis face brush should not affect the verdict — the entity
+     * can't move on Y anyway.
+     *
+     * When classifying, the entity's AABB is projected onto the target's
+     * AABB along each ignored axis (its min/max on that axis are snapped
+     * to the target's), so containment, intersection and minimum-overlap-
+     * dimension all behave as if those axes were "always aligned, never
+     * the limiting axis". The unignored axes drive the verdict. Similarly
+     * the per-axis touching-projection skips ignored axes as primary
+     * candidates and as secondary correction axes.
+     */
+    readonly ignoredAxes?: ReadonlySet<'x' | 'y' | 'z'>;
+}
+/**
+ * Options for the symmetric `getRelationship` query. `instanceNameA` /
+ * `instanceNameB` pick a specific collision-geometry instance on each
+ * entity when the entity carries more than one (e.g. an inner
+ * `collisionBoxGeometry.shell` + an outer `collisionBoxGeometry.frame`).
+ * Instance names are shared across the three collision-geometry component
+ * types (mesh, box, point) on a single entity. Omit only when the entity
+ * has exactly one collision geometry — the call throws if the entity is
+ * multi-instance and no name is given.
+ */
+export interface RelationshipOptions {
+    readonly overrideA?: CollisionQueryOverride;
+    readonly overrideB?: CollisionQueryOverride;
+    readonly instanceNameA?: string;
+    readonly instanceNameB?: string;
+}
+/**
+ * Options for the asymmetric `within` family (`isWithin`,
+ * `getWithinClampDelta`). `containerInstanceName` targets a specific
+ * collision geometry on the container; `instanceName` does the same for
+ * the contained entity.
+ */
+export interface WithinOptions {
+    readonly override?: CollisionQueryOverride;
+    readonly instanceName?: string;
+    readonly containerInstanceName?: string;
+}
+/**
+ * Options for `getClosestTouchingDelta`. `targetInstanceName` selects
+ * which of the target entity's collision geometries to project onto.
+ */
+export interface TouchingOptions {
+    readonly override?: CollisionQueryOverride;
+    readonly axes?: ReadonlyArray<'x' | 'y' | 'z'>;
+    readonly instanceName?: string;
+    readonly targetInstanceName?: string;
+}
+/**
+ * Options for the boolean pair-relationship wrappers (`isDisjointFrom`,
+ * `isTouching`, `isOverlapping`). Symmetric — `otherInstanceName` filters
+ * the second entity's geometry.
+ */
+export interface PairOptions {
+    readonly override?: CollisionQueryOverride;
+    readonly instanceName?: string;
+    readonly otherInstanceName?: string;
+}
+export interface CollisionMesh {
+    component: AnyCollisionGeometrySnapshot;
+    mesh: Mesh;
+    entityId: EntityId<DomainEntity<string>>;
+}
+export interface Collision {
+    shape: CollisionMesh;
+    otherShape: CollisionMesh;
+}
+/**
+ * Constructor context of `CollisionProjections`. It carries no `selectors` member because every
+ * registry read is transitive through collaborators that own their own registry window. A
+ * hot-reloaded spec is therefore observed transitively without rebuilding the projections.
+ */
+interface CollisionProjectionsContext {
+    readonly selectors: DomainContextSelectors;
+}
+/** CollisionProjections with its entity types erased — how the runtime selectors expose the instance. */
+export type AnyCollisionProjections = CollisionProjections<any>;
+export declare class CollisionProjections<ENTITIES extends DomainEntity<string>> {
+    private readonly _context;
+    constructor(_context: CollisionProjectionsContext);
+    getCollisionMeshes: (state: DomainState<ENTITIES>) => CollisionMesh[];
+    getCollisions: (state: DomainState<ENTITIES>) => Collision[];
+    isEntityColliding: (entityId: ENTITIES['id'], state: DomainState<ENTITIES>) => boolean;
+    private readonly _prepareProposedMesh;
+    private readonly _proposedMeshCollidesWith;
+    /**
+     * Check whether the given entity would collide with any other entity if it were
+     * placed at the supplied world matrix instead of its current committed position.
+     *
+     * Used by the constraint-transformer during drag: only the dragged entity's
+     * transform is overridden; every other entity is checked at its committed
+     * position. Caches and BVHs of other entities are reused, so this is cheap to
+     * call per drag frame. Returns on the first colliding peer.
+     */
+    isEntityCollidingAt: (entityId: ENTITIES['id'], proposedWorldMatrix: Matrix4, state: DomainState<ENTITIES>, excludeEntityIds?: ReadonlySet<EntityId<DomainEntity<string>>>) => boolean;
+    /**
+     * Like {@link isEntityCollidingAt}, but returns every peer the entity would
+     * collide with if it were placed at `proposedWorldMatrix` instead of its
+     * committed position — not just whether it collides with any.
+     *
+     * Used by drag-time reactions that need the *identity* of the collided
+     * peer(s) (e.g. "swap with whatever I'm dragged onto"), which the boolean
+     * `isEntityCollidingAt` can't provide. As there, only the queried entity's
+     * transform is overridden; every peer is tested at its committed position,
+     * and the shared caches/BVHs make this cheap to call per drag frame.
+     *
+     * Each returned `Collision.shape` is the queried entity posed at
+     * `proposedWorldMatrix`; `otherShape` is the peer at its committed pose.
+     */
+    getCollisionsAt: (entityId: ENTITIES['id'], proposedWorldMatrix: Matrix4, state: DomainState<ENTITIES>, excludeEntityIds?: ReadonlySet<EntityId<DomainEntity<string>>>) => Collision[];
+    /**
+     * Compute the world-space translation that resolves any disjoint-violating
+     * overlap between the entity (at its proposed world matrix) and other
+     * entities, by iteratively applying minimum-translation-vector (MTV)
+     * pushouts. Returns `(0, 0, 0)` if the proposed position is already
+     * disjoint from every non-excluded entity.
+     *
+     * For each iteration, the worst (deepest) overlap is found and the entity
+     * is pushed along the AABB axis with the shallowest penetration on that
+     * pair. Resolving one overlap can introduce a new one against a different
+     * entity, so we iterate until either no overlap remains or `maxIterations`
+     * is exhausted.
+     *
+     * Compared to the linear-sweep + per-axis-recovery approach this replaces:
+     *
+     * - Corners pivot naturally: MTV picks the shallowest pushout direction,
+     *   which around an obstacle's corner is the perpendicular face — exactly
+     *   the user-facing "wrap around the corner" UX a sweep along the original
+     *   drag line can't achieve.
+     * - Doesn't fail when the entity's saved position is itself overlapping
+     *   (e.g. a previous tick that couldn't resolve): MTV pushes out from
+     *   wherever, no "committed in violation → revert" branch.
+     * - Composes cleanly with `touches`: the post-MTV position is at face
+     *   contact with the obstacle, which is far more often *also* on a
+     *   target's perimeter, so the touches projection has less work and far
+     *   fewer "no disjoint-safe face" reverts.
+     *
+     * `writableAxes` restricts MTV candidates to the listed axes — used by
+     * the constraint transformer to honour the drag plane (e.g. a hotspot
+     * with normal `(0, 1, 0)` excludes Y).
+     *
+     * `accept`, when supplied, filters candidate MTVs per obstacle: for the
+     * chosen obstacle the smallest candidate that the predicate accepts is
+     * picked. Used by the constraint transformer to bias the pushout toward
+     * directions that preserve a co-existing `touches` predicate — without
+     * it, a post sitting on a perimeter face overlapping another face-mate
+     * would be pushed perpendicular to the face and end up off the
+     * perimeter, where the touches projection just yanks it back, creating
+     * a steady-state cycle. The accept callback lets the transformer say
+     * "prefer pushouts that keep me on the face I was on", and only fall
+     * back to off-face pushouts if no on-face direction works.
+     *
+     * Receives `delta` in world units relative to the entity's *current*
+     * proposed position (i.e. `accumulated` already incorporated). Caller
+     * is responsible for any unit conversion.
+     */
+    computeDisjointPushout: (entityId: ENTITIES['id'], state: DomainState<ENTITIES>, override: CollisionQueryOverride, peerEntityIds: ReadonlySet<EntityId<DomainEntity<string>>>, writableAxes?: ReadonlyArray<'x' | 'y' | 'z'>, accept?: (delta: Vector3, accumulated: Vector3) => boolean, maxIterations?: number, instanceName?: string, peerInstanceNames?: ReadonlyMap<EntityId<DomainEntity<string>>, string | undefined>) => Vector3;
+    /**
+     * Classify the spatial relationship between two entities. Either side may be
+     * placed at a hypothetical world matrix via `overrideA.proposedWorldMatrix` /
+     * `overrideB.proposedWorldMatrix` — useful for drag-time "what if?" queries.
+     *
+     * The implementation cheap-checks world-axis AABB intersection first, then
+     * uses three-mesh-bvh's `intersectsGeometry` for the boolean intersect test
+     * (which handles rotated meshes correctly), then distinguishes within /
+     * contains / touches / overlaps via AABB containment and zero-volume tests.
+     *
+     * Containment via AABB is conservative for rotated entities: if A's
+     * world-axis AABB sits inside B's, A is definitely within B; if it doesn't,
+     * A might still be within B in reality (the AABB-of-OBB is loose). For
+     * axis-aligned boxes (the common case for `shape: 'box'` with no rotation)
+     * the result is exact.
+     */
+    getRelationship: (entityIdA: ENTITIES['id'], entityIdB: ENTITIES['id'], state: DomainState<ENTITIES>, options?: RelationshipOptions) => SpatialRelationship;
+    /**
+     * Resolve the single collision mesh for `(entityId, instanceName)`.
+     * Throws when the entity carries multiple collision-geometry instances
+     * and no name is given — silently picking the first mesh would return
+     * an arbitrary geometry, which is almost never what the caller wants.
+     * Returns `undefined` when the entity has no collision geometry at
+     * all, or when an explicit `instanceName` doesn't match any of the
+     * entity's instances (treated the same as a missing entity: the
+     * caller's relationship query degenerates to `disjoint`). Instance
+     * names are shared across the three collision-geometry component types
+     * — a `collisionPointGeometry.foo` resolves the same as a
+     * `collisionBoxGeometry.foo`.
+     */
+    private readonly _resolveMesh;
+    private readonly _computeRelationship;
+    isWithin: (entityId: ENTITIES['id'], containerEntityId: ENTITIES['id'], state: DomainState<ENTITIES>, options?: WithinOptions) => boolean;
+    /**
+     * Returns the world-space translation that, when added to the entity's
+     * proposed position, would bring its world-axis AABB inside the container's
+     * AABB. Returns `(0, 0, 0)` if already contained. Returns `null` if the
+     * entity is too large to fit inside the container along any axis.
+     *
+     * Use this for `within` enforcement: it produces a valid position directly
+     * (no binary sweep) and works regardless of whether the entity's current
+     * position is itself valid.
+     */
+    getWithinClampDelta: (entityId: ENTITIES['id'], containerEntityId: ENTITIES['id'], state: DomainState<ENTITIES>, options?: WithinOptions) => Vector3 | null;
+    /**
+     * World-space translation that, applied to the entity's proposed
+     * position, brings its actual surface into face/edge/corner contact
+     * with the target's surface at minimum displacement. Returns
+     * `(0, 0, 0)` when already touching, or `null` if no contact is
+     * reachable using the writable `axes`.
+     *
+     * Used by the `touches` constraint to project a proposed drag onto
+     * the nearest touching position in one step — letting the dragged
+     * entity pivot around target corners that a linear sweep can't
+     * navigate.
+     *
+     * Uses three-mesh-bvh's `closestPointToGeometry` to find the closest
+     * pair of points on the two meshes' actual triangles, so the result
+     * is geometry-aware (and orientation-aware): a rotated peer's
+     * corner-touch is the natural snap target rather than a misleading
+     * AABB face. The world-space delta from A's nearest point to B's
+     * nearest point is then projected onto the writable axes.
+     *
+     * `override.ignoredAxes` zero out the delta on those axes (the drag
+     * plane is assumed to keep them aligned). Non-writable axes that the
+     * closest-approach delta has a non-trivial component on cause the
+     * function to return `null` — applying the projected delta wouldn't
+     * actually achieve contact, so the caller should treat this peer as
+     * unreachable.
+     */
+    getClosestTouchingDelta: (entityId: ENTITIES['id'], targetEntityId: ENTITIES['id'], state: DomainState<ENTITIES>, options?: TouchingOptions) => Vector3 | null;
+    isDisjointFrom: (entityId: ENTITIES['id'], otherEntityId: ENTITIES['id'], state: DomainState<ENTITIES>, options?: PairOptions) => boolean;
+    isTouching: (entityId: ENTITIES['id'], otherEntityId: ENTITIES['id'], state: DomainState<ENTITIES>, options?: PairOptions) => boolean;
+    isOverlapping: (entityId: ENTITIES['id'], otherEntityId: ENTITIES['id'], state: DomainState<ENTITIES>, options?: PairOptions) => boolean;
+}
+export {};