@thatopen/components 3.4.6 → 3.4.7

package/dist/index.cjs

@@ -197,6 +197,15 @@ class BaseRenderer extends BaseWorldItem {
      * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this instance of the renderer.
      */
     __publicField(this, "clippingPlanes", []);
+    /**
+     * The default `isLocal` value used by {@link setPlane} when the caller
+     * doesn't pass one. When `true`, planes added without an explicit
+     * `isLocal` stay out of the global `three.clippingPlanes` list and are
+     * clipped per-material instead. The {@link Clipper} sets this to mirror
+     * its own `localClippingPlanes` flag, so consumers like `Views` that add
+     * their own planes automatically inherit the active clipping mode.
+     */
+    __publicField(this, "localClippingPlanes", false);
   }
   /**
    * Updates the clipping planes and triggers the `onClippingPlanesUpdated` event.
@@ -222,7 +231,7 @@ class BaseRenderer extends BaseWorldItem {
    * The `three.clippingPlanes` property is then updated to reflect the current state of the `clippingPlanes` array,
    * excluding any planes marked as local.
    */
-  setPlane(active, plane, isLocal) {
+  setPlane(active, plane, isLocal = this.localClippingPlanes) {
     plane.isLocal = isLocal;
     const index = this.clippingPlanes.indexOf(plane);
     if (active && index === -1) {
@@ -233,6 +242,7 @@ class BaseRenderer extends BaseWorldItem {
     this.three.clippingPlanes = this.clippingPlanes.filter(
       (plane2) => !plane2.isLocal
     );
+    this.updateClippingPlanes();
   }
 }
 const _Disposer = class _Disposer extends Component {
@@ -9487,9 +9497,11 @@ class VisibilityCuller {
     const tilesX = Math.ceil(pixelWidth / maxTextureSize);
     const tilesY = Math.ceil(pixelHeight / maxTextureSize);
     target.setSize(Math.ceil(pixelWidth / tilesX), Math.ceil(pixelHeight / tilesY));
+    const yMargin = Math.max(size.y, 1) * 0.01;
     camera.rotation.x = -Math.PI / 2;
-    camera.far = box.max.y - box.min.y + camera.near;
-    camera.position.y = box.max.y + camera.near;
+    camera.near = 0;
+    camera.far = size.y + 2 * yMargin;
+    camera.position.y = box.max.y + yMargin;
     const idScene = new THREE.Scene();
     const originalMaterials = /* @__PURE__ */ new Map();
     const originalParents = /* @__PURE__ */ new Map();
@@ -9523,7 +9535,7 @@ class VisibilityCuller {
         const tileMaxZ = tileMinZ + stepZ;
         const tileCenterX = (tileMinX + tileMaxX) / 2;
         const tileCenterZ = (tileMinZ + tileMaxZ) / 2;
-        camera.position.set(tileCenterX, box.max.y, tileCenterZ);
+        camera.position.set(tileCenterX, box.max.y + yMargin, tileCenterZ);
         const halfWidth = stepX / 2;
         const halfHeight = stepZ / 2;
         camera.left = -halfWidth;
@@ -9572,6 +9584,11 @@ class IDMaterial extends THREE.ShaderMaterial {
     super({
       glslVersion: THREE.GLSL3,
       blending: THREE.NoBlending,
+      // A flat item (a slab) seen straight down shows only one face; if its
+      // winding puts the back face toward the camera it wouldn't rasterize and
+      // the item would be culled. The pass only cares about coverage, so render
+      // both sides.
+      side: THREE.DoubleSide,
       uniforms: {
         objectId: { value: new THREE.Vector4() }
       },
@@ -12562,6 +12579,19 @@ const _FastModelPicker = class _FastModelPicker {
      * restored after.
      */
     __publicField(this, "_hiddenLods", []);
+    /**
+     * The meshes each model owns, i.e. excluding those belonging to a
+     * model nested inside it. A delta model's object is parented under
+     * its parent model's object (see the fragments EditHelper), while
+     * both are listed as separate models, so subtree membership alone
+     * does not determine ownership.
+     *
+     * Populated in {@link applyIdMaterial}, consumed by
+     * {@link renderPickPass} to isolate one model per render without
+     * relying on root visibility. A nested model can't be isolated by
+     * its root, since hiding the parent's root culls the child too.
+     */
+    __publicField(this, "_ownMeshes", /* @__PURE__ */ new Map());
     if (!world.renderer) {
       throw new Error("A renderer is needed for the FastModelPicker to work!");
     }
@@ -12802,14 +12832,14 @@ const _FastModelPicker = class _FastModelPicker {
   applyIdMaterial() {
     const fragments = this.components.get(FragmentsManager);
     const byteToModel = /* @__PURE__ */ new Map();
+    const modelRoots = this.getModelRoots();
+    this._ownMeshes.clear();
     let nextByte = 1;
     for (const [modelId, model] of fragments.list) {
       if (nextByte > _FastModelPicker.MAX_MODELS)
         break;
-      const byte = nextByte;
-      nextByte += 1;
-      let any = false;
-      model.object.traverse((child) => {
+      const owned = [];
+      this.traverseOwn(model.object, modelRoots, (child) => {
         if (!(child instanceof THREE__namespace.Mesh))
           return;
         const geom = child.geometry;
@@ -12826,13 +12856,44 @@ const _FastModelPicker = class _FastModelPicker {
         const original = child.material;
         const len = Array.isArray(original) ? original.length : 1;
         child.material = new Array(len).fill(this._idMaterial);
-        any = true;
+        owned.push(child);
       });
-      if (any)
-        byteToModel.set(byte, modelId);
+      if (!owned.length)
+        continue;
+      this._ownMeshes.set(modelId, owned);
+      byteToModel.set(nextByte, modelId);
+      nextByte += 1;
     }
     return byteToModel;
   }
+  /**
+   * The object roots of every loaded model.
+   */
+  getModelRoots() {
+    const fragments = this.components.get(FragmentsManager);
+    const roots = /* @__PURE__ */ new Set();
+    for (const [, model] of fragments.list)
+      roots.add(model.object);
+    return roots;
+  }
+  /**
+   * Like `Object3D.traverse`, but prunes the subtree of any nested model
+   * root, so each mesh is visited exactly once, by the model that owns
+   * it. A delta model's object hangs under its parent model's object
+   * while being a model in its own right; a plain `traverse` from the
+   * parent would walk into it.
+   */
+  traverseOwn(root, modelRoots, callback) {
+    const stack = [root];
+    while (stack.length) {
+      const node = stack.pop();
+      if (node !== root && modelRoots.has(node))
+        continue;
+      callback(node);
+      for (const child of node.children)
+        stack.push(child);
+    }
+  }
   /**
    * Renders the world scene to the id target one model at a time,
    * flipping the `modelByte` uniform between renders. The depth buffer
@@ -12923,21 +12984,47 @@ const _FastModelPicker = class _FastModelPicker {
       nonBimVisibility.set(child, child.visible);
       child.visible = false;
     });
-    const bimVisibilityBefore = /* @__PURE__ */ new Map();
+    const wasOnScreen = /* @__PURE__ */ new Map();
+    for (const [modelId, obj] of objectsByModel) {
+      let visible = true;
+      let node = obj;
+      while (node) {
+        if (!node.visible) {
+          visible = false;
+          break;
+        }
+        node = node.parent;
+      }
+      wasOnScreen.set(modelId, visible);
+    }
+    const rootVisibilityBefore = /* @__PURE__ */ new Map();
     for (const obj of objectsByModel.values()) {
-      bimVisibilityBefore.set(obj, obj.visible);
-      obj.visible = false;
+      rootVisibilityBefore.set(obj, obj.visible);
+      obj.visible = true;
+    }
+    const meshVisibilityBefore = /* @__PURE__ */ new Map();
+    for (const meshes of this._ownMeshes.values()) {
+      for (const mesh of meshes) {
+        meshVisibilityBefore.set(mesh, mesh.visible);
+        mesh.visible = false;
+      }
     }
     for (const [byte, modelId] of byteToModel) {
-      const obj = objectsByModel.get(modelId);
-      if (!obj)
+      if (!wasOnScreen.get(modelId))
         continue;
-      obj.visible = true;
+      const meshes = this._ownMeshes.get(modelId);
+      if (!meshes)
+        continue;
+      for (const mesh of meshes)
+        mesh.visible = meshVisibilityBefore.get(mesh);
       material.uniforms.modelByte.value = byte;
       renderer.render(scene, camera);
-      obj.visible = false;
+      for (const mesh of meshes)
+        mesh.visible = false;
     }
-    for (const [obj, was] of bimVisibilityBefore)
+    for (const [mesh, was] of meshVisibilityBefore)
+      mesh.visible = was;
+    for (const [obj, was] of rootVisibilityBefore)
       obj.visible = was;
     for (const [obj, was] of nonBimVisibility)
       obj.visible = was;
@@ -12978,8 +13065,9 @@ const _FastModelPicker = class _FastModelPicker {
     const prevClearAlpha = renderer.getClearAlpha();
     const matSwap = /* @__PURE__ */ new Map();
     const hiddenLines = [];
+    const modelRoots = this.getModelRoots();
     for (const [, model] of fragments.list) {
-      model.object.traverse((child) => {
+      this.traverseOwn(model.object, modelRoots, (child) => {
         if (!(child instanceof THREE__namespace.Mesh))
           return;
         const geom = child.geometry;
@@ -13049,6 +13137,7 @@ const _FastModelPicker = class _FastModelPicker {
       mesh.material = mat;
     }
     this._originalMaterials.clear();
+    this._ownMeshes.clear();
     for (const obj of this._hiddenLods)
       obj.visible = true;
     this._hiddenLods.length = 0;
@@ -13425,12 +13514,32 @@ class SnapResolver {
      */
     __publicField(this, "maxCacheSize", 1e3);
     __publicField(this, "components");
+    __publicField(this, "_precision", "half");
     // Map insertion order is recency order (LRU). On every read we
     // delete + re-set the entry to bump it to most-recent; on every
     // write we drop oldest entries until size <= maxCacheSize.
     __publicField(this, "cache", /* @__PURE__ */ new Map());
     this.components = components;
   }
+  /**
+   * Numeric precision for cached face/edge/vertex buffers.
+   *
+   * `"half"` uses Float32Array for lower memory footprint.
+   * `"full"` uses Float64Array for higher numeric precision.
+   * Use `"full"` for workflows that require higher geometric fidelity.
+   *
+   * Changing this value clears the snap cache so subsequent requests
+   * are rebuilt with the new precision.
+   */
+  get precision() {
+    return this._precision;
+  }
+  set precision(value) {
+    if (value === this._precision)
+      return;
+    this._precision = value;
+    this.clear();
+  }
   /** {@link Disposable.dispose} */
   dispose() {
     this.cache.clear();
@@ -13570,8 +13679,8 @@ class SnapResolver {
     }
     if (polygons.length === 0)
       return null;
-    const edges = deriveUniqueEdges(polygons);
-    const vertices = deriveUniqueVertices(polygons);
+    const edges = deriveUniqueEdges(polygons, this._precision);
+    const vertices = deriveUniqueVertices(polygons, this._precision);
     return { faces: polygons, edges, vertices };
   }
   collectPolygonsFromShell(shell, worldMatrix, out) {
@@ -13582,7 +13691,8 @@ class SnapResolver {
     const collect = (indices) => {
       if (indices.length < 3)
         return;
-      const flat = new Float32Array(indices.length * 3);
+      const Ctor = this._precision === "full" ? Float64Array : Float32Array;
+      const flat = new Ctor(indices.length * 3);
       for (let i = 0; i < indices.length; i++) {
         const p = points[indices[i]];
         tmp.set(p[0], p[1], p[2]).applyMatrix4(worldMatrix);
@@ -13691,19 +13801,33 @@ class SnapResolver {
       return null;
     let best = null;
     let bestAbs = Infinity;
+    let bestContains = false;
     for (const f of faces) {
-      const signed = f.normal.x * point.x + f.normal.y * point.y + f.normal.z * point.z - f.d;
+      const signed = this.signedDistance(f, point);
       const abs = Math.abs(signed);
-      if (abs <= this.maxDistance && abs < bestAbs) {
+      if (abs > this.maxDistance)
+        continue;
+      const contains = this.containsPoint(f, this.projectOntoPlane(point, f, signed));
+      if (bestContains && !contains)
+        continue;
+      if (contains && !bestContains) {
+        bestContains = true;
+        bestAbs = abs;
+        best = f;
+        continue;
+      }
+      if (abs < bestAbs) {
         bestAbs = abs;
         best = f;
       }
     }
     if (!best)
       return null;
-    const projected = point.clone().sub(best.normal.clone().multiplyScalar(
-      best.normal.x * point.x + best.normal.y * point.y + best.normal.z * point.z - best.d
-    ));
+    const projected = this.projectOntoPlane(
+      point,
+      best,
+      this.signedDistance(best, point)
+    );
     return {
       result: {
         point: projected,
@@ -13714,6 +13838,50 @@ class SnapResolver {
       }
     };
   }
+  signedDistance(face, point) {
+    return face.normal.x * point.x + face.normal.y * point.y + face.normal.z * point.z - face.d;
+  }
+  projectOntoPlane(point, face, signed) {
+    return point.clone().sub(face.normal.clone().multiplyScalar(signed));
+  }
+  /**
+   * Even-odd point-in-polygon test, run on the polygon projected onto its
+   * dominant plane. `point` is assumed to already lie on the face's plane.
+   */
+  containsPoint(face, point) {
+    const { points, normal } = face;
+    const count = points.length / 3;
+    if (count < 3)
+      return false;
+    const ax = Math.abs(normal.x);
+    const ay = Math.abs(normal.y);
+    const az = Math.abs(normal.z);
+    let a = 0;
+    let b = 1;
+    if (ax >= ay && ax >= az) {
+      a = 1;
+      b = 2;
+    } else if (ay >= az) {
+      a = 0;
+      b = 2;
+    }
+    const px = point.getComponent(a);
+    const py = point.getComponent(b);
+    let inside = false;
+    for (let i = 0, j = count - 1; i < count; j = i, i += 1) {
+      const xi = points[i * 3 + a];
+      const yi = points[i * 3 + b];
+      const xj = points[j * 3 + a];
+      const yj = points[j * 3 + b];
+      const straddles = yi > py !== yj > py;
+      if (!straddles)
+        continue;
+      const x = (xj - xi) * (py - yi) / (yj - yi) + xi;
+      if (px < x)
+        inside = !inside;
+    }
+    return inside;
+  }
 }
 const _tmpMatrix = new THREE__namespace.Matrix4();
 const _tmpX = new THREE__namespace.Vector3();
@@ -13781,7 +13949,7 @@ function fanTriangulation(vertexCount) {
   }
   return out;
 }
-function deriveUniqueEdges(faces) {
+function deriveUniqueEdges(faces, precision) {
   const seen = /* @__PURE__ */ new Set();
   const collected = [];
   for (const f of faces) {
@@ -13798,9 +13966,10 @@ function deriveUniqueEdges(faces) {
       collected.push(ax, ay, az, bx, by, bz);
     }
   }
-  return new Float32Array(collected);
+  const Ctor = precision === "full" ? Float64Array : Float32Array;
+  return new Ctor(collected);
 }
-function deriveUniqueVertices(faces) {
+function deriveUniqueVertices(faces, precision) {
   const seen = /* @__PURE__ */ new Set();
   const collected = [];
   for (const f of faces) {
@@ -13815,7 +13984,8 @@ function deriveUniqueVertices(faces) {
       collected.push(x, y, z);
     }
   }
-  return new Float32Array(collected);
+  const Ctor = precision === "full" ? Float64Array : Float32Array;
+  return new Ctor(collected);
 }
 function quantKey(x, y, z) {
   return `${Math.round(x * VERTEX_QUANT)},${Math.round(y * VERTEX_QUANT)},${Math.round(z * VERTEX_QUANT)}`;
@@ -14111,6 +14281,9 @@ class SimpleWorld extends Base {
      */
     __publicField(this, "enabled", true);
     __publicField(this, "_dynamicAnchor", false);
+    // Bumped on every anchor press so a slow geometry pick that resolves after a
+    // newer press is ignored (see onPointerDown).
+    __publicField(this, "_anchorRequestId", 0);
     /**
      * A unique identifier for the world. Is not meant to be changed at any moment.
      */
@@ -14122,21 +14295,36 @@ class SimpleWorld extends Base {
     __publicField(this, "_scene");
     __publicField(this, "_camera");
     __publicField(this, "_renderer", null);
-    __publicField(this, "onPointerDown", async (event) => {
+    __publicField(this, "onPointerDown", (event) => {
       if (!this.camera.hasCameraControls()) {
         throw new Error(
           "World: can't set dynamic anchor if the camera doesn't have controls."
         );
       }
+      if (event.button !== 0)
+        return;
+      const position = this.getPointerPosition(event);
+      if (!position)
+        return;
       const caster = this.components.get(Raycasters).get(this);
-      const result = await caster.castRay();
-      if (result && result.point && event.button === 0) {
+      const planePoint = this.getPlaneAnchor(caster, position);
+      if (planePoint) {
         this.camera.controls.setOrbitPoint(
-          result.point.x,
-          result.point.y,
-          result.point.z
+          planePoint.x,
+          planePoint.y,
+          planePoint.z
         );
       }
+      const requestId = ++this._anchorRequestId;
+      caster.castRay({ position }).then((result) => {
+        const isStale = requestId !== this._anchorRequestId;
+        if (isStale || this.isDisposing || !this._dynamicAnchor)
+          return;
+        if (!(result == null ? void 0 : result.point) || !this.camera.hasCameraControls())
+          return;
+        const { x, y, z } = result.point;
+        this.camera.controls.setOrbitPoint(x, y, z);
+      });
     });
     __publicField(this, "_defaultCamera");
   }
@@ -14155,10 +14343,46 @@ class SimpleWorld extends Base {
     } else {
       container.removeEventListener("pointerdown", this.onPointerDown);
     }
+    this._dynamicAnchor = value;
   }
   get dynamicAnchor() {
     return this._dynamicAnchor;
   }
+  /**
+   * The pointer position in normalized device coordinates, derived from the
+   * event rather than the raycaster's mouse: that one only tracks pointermove
+   * and touchstart, so on a bare pointerdown it would still report the center of
+   * the viewport.
+   */
+  getPointerPosition(event) {
+    var _a;
+    const dom = (_a = this.renderer) == null ? void 0 : _a.three.domElement;
+    if (!dom)
+      return null;
+    const bounds = dom.getBoundingClientRect();
+    return new THREE__namespace.Vector2(
+      (event.clientX - bounds.left) / (bounds.right - bounds.left) * 2 - 1,
+      -((event.clientY - bounds.top) / (bounds.bottom - bounds.top)) * 2 + 1
+    );
+  }
+  /**
+   * The point where the pointer ray crosses the plane that contains the current
+   * orbit target and faces the camera. Used as the anchor when the pointer
+   * doesn't land on any geometry.
+   */
+  getPlaneAnchor(caster, position) {
+    if (!this.camera.hasCameraControls())
+      return null;
+    const camera = this.camera.three;
+    caster.three.setFromCamera(position, camera);
+    const target = this.camera.controls.getTarget(new THREE__namespace.Vector3());
+    const normal = camera.getWorldDirection(new THREE__namespace.Vector3());
+    const plane = new THREE__namespace.Plane().setFromNormalAndCoplanarPoint(
+      normal,
+      target
+    );
+    return caster.three.ray.intersectPlane(plane, new THREE__namespace.Vector3());
+  }
   get defaultCamera() {
     if (!this._defaultCamera) {
       throw new Error("World: there is no default camera defined.");
@@ -14261,8 +14485,16 @@ class SimpleWorld extends Base {
   }
   /** {@link Disposable.dispose} */
   dispose(disposeResources = true) {
+    var _a;
+    if (this.isDisposing)
+      return;
     this.enabled = false;
     this.isDisposing = true;
+    const container = (_a = this.renderer) == null ? void 0 : _a.three.domElement.parentElement;
+    if (container) {
+      container.removeEventListener("pointerdown", this.onPointerDown);
+    }
+    this._dynamicAnchor = false;
     this.scene.onWorldChanged.trigger({ world: this, action: "removed" });
     this.camera.onWorldChanged.trigger({ world: this, action: "removed" });
     if (this.renderer) {
@@ -15509,16 +15741,23 @@ const _Components = class _Components {
   dispose() {
     this.enabled = false;
     let fragments;
+    let worlds;
     for (const [_id, component] of this.list) {
       component.enabled = false;
       if (_id === FragmentsManager.uuid) {
         fragments = component;
         continue;
       }
+      if (_id === Worlds.uuid) {
+        worlds = component;
+        continue;
+      }
       if (component.isDisposeable()) {
         component.dispose();
       }
     }
+    if (worlds == null ? void 0 : worlds.isDisposeable())
+      worlds.dispose();
     fragments == null ? void 0 : fragments.dispose();
     this._timer.dispose();
     this.onDisposed.trigger();
@@ -15995,7 +16234,7 @@ Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/js
 JSZip uses the library pako released under the MIT license :
 https://github.com/nodeca/pako/blob/main/LICENSE
 */
-(function(module2, exports2) {
+(function(module2, exports$1) {
   !function(e) {
     module2.exports = e();
   }(function() {
@@ -19053,33 +19292,31 @@ const _Topic = class _Topic {
   serialize() {
     var _a, _b;
     const version = this._managerVersion;
+    const isV3 = version === "3";
     const topic = {
       $Guid: this.guid,
       $TopicType: this.type,
       $TopicStatus: this.status,
       $ServerAssignedId: this.serverAssignedId,
       Title: this.title,
-      CreationAuthor: this.creationAuthor,
-      CreationDate: this.creationDate.toISOString(),
       Priority: this.priority,
       Index: version === "2.1" ? this.index : void 0,
+      Labels: isV3 ? { Label: this.createLabelTags() } : this.createLabelTags(),
+      CreationDate: this.creationDate.toISOString(),
+      CreationAuthor: this.creationAuthor,
       ModifiedDate: (_a = this.modifiedDate) == null ? void 0 : _a.toISOString(),
       ModifiedAuthor: this.modifiedAuthor,
       DueDate: (_b = this.dueDate) == null ? void 0 : _b.toISOString(),
       AssignedTo: this.assignedTo,
-      Description: this.description,
       Stage: this.stage,
-      DocumentReferences: version === "3" ? { DocumentReference: this.createDocumentReferencesTag(version) } : void 0,
-      RelatedTopics: version === "3" ? { RelatedTopic: this.createRelatedTopicTags() } : void 0,
-      RelatedTopic: version === "2.1" ? this.createRelatedTopicTags() : void 0,
-      Labels: version === "3" ? { Label: this.createLabelTags() } : void 0,
-      Viewpoints: version === "3" ? { ViewPoint: this.createViewpointTags() } : void 0,
-      Comments: version === "3" ? { Comment: this.createCommentTags() } : void 0
+      Description: this.description,
+      DocumentReferences: isV3 ? { DocumentReference: this.createDocumentReferencesTag(version) } : void 0,
+      DocumentReference: isV3 ? void 0 : this.createDocumentReferencesTag(version),
+      RelatedTopics: isV3 ? { RelatedTopic: this.createRelatedTopicTags() } : void 0,
+      RelatedTopic: isV3 ? void 0 : this.createRelatedTopicTags(),
+      Comments: isV3 ? { Comment: this.createCommentTags() } : void 0,
+      Viewpoints: isV3 ? { ViewPoint: this.createViewpointTags() } : void 0
     };
-    if (version === "2.1") {
-      topic.Labels = this.createLabelTags();
-      topic.DocumentReference = this.createDocumentReferencesTag(version);
-    }
     const markup = {
       Markup: { Topic: topic }
     };
@@ -19506,10 +19743,13 @@ const _BCFTopics = class _BCFTopics extends Component {
    */
   async export(topics = this.list.values()) {
     const zip = new JSZip();
+    const isV3 = this.config.version === "3";
+    const versionId = isV3 ? "3.0" : this.config.version;
+    const schemaRelease = isV3 ? "release_3_0" : "release_2_1";
     zip.file(
       "bcf.version",
       `<?xml version="1.0" encoding="UTF-8"?>
-    <Version VersionId="${this.config.version}" xsi:noNamespaceSchemaLocation="https://raw.githubusercontent.com/buildingSMART/BCF-XML/release_3_0/Schemas/version.xsd"
+    <Version VersionId="${versionId}" xsi:noNamespaceSchemaLocation="https://raw.githubusercontent.com/buildingSMART/BCF-XML/${schemaRelease}/Schemas/version.xsd"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
     </Version>`
     );
@@ -19544,7 +19784,7 @@ const _BCFTopics = class _BCFTopics extends Component {
         );
       }
     }
-    zip.file("bcf.extensions", this.serializeExtensions());
+    zip.file("extensions.xml", this.serializeExtensions());
     const viewpoints = this.components.get(Viewpoints);
     for (const topic of topics) {
       const topicFolder = zip.folder(topic.guid);
@@ -19616,7 +19856,7 @@ ${users}
       Comment: CommentText,
       Viewpoint: Viewpoint2
     } = markupComment;
-    if (!(Guid && CommentDate && Author && Comment))
+    if (!(Guid && CommentDate && Author && (Comment || Viewpoint2)))
       return null;
     const comment = new Comment(this.components, CommentText ?? "");
     comment.guid = Guid;
@@ -19713,14 +19953,16 @@ ${users}
     const versionFile = files.find((file) => file.name.endsWith(".version"));
     if (versionFile) {
       const versionXML = await versionFile.async("string");
-      const bcfVersion = _BCFTopics.xmlParser.parse(versionXML).Version.VersionId;
-      version = String(bcfVersion);
+      const bcfVersion = String(
+        _BCFTopics.xmlParser.parse(versionXML).Version.VersionId
+      );
+      version = bcfVersion === "3.0" ? "3" : bcfVersion;
     }
     if (!(version && (version === "2.1" || version === "3"))) {
       throw new Error(`BCFTopics: ${version} is not supported.`);
     }
     const extensionsFile = files.find(
-      (file) => file.name.endsWith(".extensions")
+      (file) => file.name.endsWith("extensions.xml") || file.name.endsWith(".extensions")
     );
     if (updateExtensionsOnImport && extensionsFile) {
       const extensionsXML = await extensionsFile.async("string");
@@ -20263,7 +20505,7 @@ class SimplePlane {
   dispose() {
     var _a;
     this._enabled = false;
-    if ((_a = this.world.camera) == null ? void 0 : _a.controls) {
+    if (!this.world.isDisposing && ((_a = this.world.camera) == null ? void 0 : _a.controls)) {
       this.world.camera.controls.removeEventListener(
         "update",
         this.updateScale
@@ -20504,8 +20746,13 @@ const _Clipper = class _Clipper extends Component {
      * Default `false` to preserve existing behavior. Set this once
      * before creating planes; toggling at runtime won't reclassify
      * planes already on the renderer.
+     *
+     * Setting this also mirrors the value onto every world's
+     * `renderer.localClippingPlanes`, so planes added by other
+     * components (e.g. the {@link Views} cut planes) default to the
+     * same mode without each call site having to pass `isLocal`.
      */
-    __publicField(this, "localClippingPlanes", false);
+    __publicField(this, "_localClippingPlanes", false);
     /**
      * The type of clipping plane to be created.
      * Default is {@link SimplePlane}.
@@ -20541,6 +20788,17 @@ const _Clipper = class _Clipper extends Component {
     this.components.add(_Clipper.uuid, this);
     this.setEvents();
   }
+  get localClippingPlanes() {
+    return this._localClippingPlanes;
+  }
+  set localClippingPlanes(value) {
+    this._localClippingPlanes = value;
+    const worlds = this.components.get(Worlds);
+    for (const [, world] of worlds.list) {
+      if (world.renderer)
+        world.renderer.localClippingPlanes = value;
+    }
+  }
   /** {@link Component.enabled} */
   get enabled() {
     return this._enabled;
@@ -23468,19 +23726,24 @@ class IDSProperty extends IDSFacet {
     );
   }
   getTypePsets(item) {
-    if (!Array.isArray(item.IsTypedBy))
-      return [];
-    const [type] = item.IsTypedBy;
-    if (!(type && Array.isArray(type.HasPropertySets))) {
-      return [];
+    const definitions = [
+      ...Array.isArray(item.IsTypedBy) ? item.IsTypedBy : [],
+      ...Array.isArray(item.IsDefinedBy) ? item.IsDefinedBy : []
+    ];
+    const psets = [];
+    for (const definition of definitions) {
+      if (Array.isArray(definition == null ? void 0 : definition.HasPropertySets)) {
+        psets.push(...definition.HasPropertySets);
+      }
     }
-    return type.HasPropertySets;
+    return psets;
   }
   async getPsets(item) {
     const typeSets = this.getTypePsets(item);
     if (!Array.isArray(item.IsDefinedBy))
       return typeSets;
     const sets = [];
+    const mergedTypeSets = /* @__PURE__ */ new Set();
     for (const definition of item.IsDefinedBy) {
       if (!("value" in definition.Name))
         continue;
@@ -23493,22 +23756,29 @@ class IDSProperty extends IDSFacet {
           return false;
         return set.Name.value === definitionName;
       });
-      if (typeSet && Array.isArray(typeSet.HasProperties) && Array.isArray(definition.HasProperties)) {
-        for (const prop of typeSet.HasProperties) {
-          if (!("value" in prop.Name))
-            continue;
-          const name = prop.Name.value;
-          const existingProp = definition.HasProperties.find((p) => {
-            if (!("value" in p.Name))
-              return false;
-            return p.Name.value === name;
-          });
-          if (!existingProp)
-            definition.HasProperties.push(prop);
+      if (typeSet) {
+        mergedTypeSets.add(typeSet);
+        if (Array.isArray(typeSet.HasProperties) && Array.isArray(definition.HasProperties)) {
+          for (const prop of typeSet.HasProperties) {
+            if (!("value" in prop.Name))
+              continue;
+            const name = prop.Name.value;
+            const existingProp = definition.HasProperties.find((p) => {
+              if (!("value" in p.Name))
+                return false;
+              return p.Name.value === name;
+            });
+            if (!existingProp)
+              definition.HasProperties.push(prop);
+          }
         }
       }
       sets.push(definition);
     }
+    for (const typeSet of typeSets) {
+      if (!mergedTypeSets.has(typeSet))
+        sets.push(typeSet);
+    }
     return sets;
   }
   // IFCPROPERTYBOUNDEDVALUE are not supported yet
@@ -23530,7 +23800,7 @@ class IDSProperty extends IDSFacet {
         return false;
       }
       const facetValue = structuredClone(this.value);
-      if (valueAttr.type === "IFCLABEL" && facetValue.type === "simple") {
+      if (typeof valueAttr.value === "string" && facetValue.type === "simple") {
         facetValue.parameter = String(facetValue.parameter);
       }
       const result = this.evalRequirement(
@@ -23586,12 +23856,38 @@ class IDSProperty extends IDSFacet {
 class IDSMaterial extends IDSFacet {
   constructor() {
     super(...arguments);
+    // Every type IfcRelAssociatesMaterial.RelatingMaterial (IfcMaterialSelect)
+    // can point at. Missing any of them silently drops every element that
+    // associates its material through it: an element can reference a layer set
+    // directly instead of through a layer set usage, and both spellings are
+    // valid IFC.
     __publicField(this, "_ifcMaterialEntities", [
       /^IFCMATERIALLAYERSETUSAGE$/,
+      /^IFCMATERIALLAYERSET$/,
+      /^IFCMATERIALPROFILESETUSAGE$/,
+      /^IFCMATERIALPROFILESET$/,
       /^IFCMATERIALCONSTITUENTSET$/,
       /^IFCMATERIAL$/,
       /^IFCMATERIALLIST$/
     ]);
+    // Attributes that lead from a material set / usage down to its IfcMaterial.
+    __publicField(this, "_materialParentAttributes", [
+      "ForLayerSet",
+      "MaterialLayers",
+      "ForProfileSet",
+      "MaterialProfiles",
+      "Material",
+      "MaterialConstituents",
+      "Materials"
+    ]);
+    __publicField(this, "_materialRelations", {
+      MaterialConstituents: { attributes: true, relations: true },
+      ForLayerSet: { attributes: true, relations: true },
+      MaterialLayers: { attributes: true, relations: true },
+      ForProfileSet: { attributes: true, relations: true },
+      MaterialProfiles: { attributes: true, relations: true },
+      Materials: { attributes: true, relations: false }
+    });
     __publicField(this, "facetType", "Material");
     __publicField(this, "value");
     __publicField(this, "uri");
@@ -23623,10 +23919,7 @@ class IDSMaterial extends IDSFacet {
       const data = await model.getItemsData(localIds, {
         relations: {
           AssociatedTo: { attributes: true, relations: false },
-          MaterialConstituents: { attributes: true, relations: true },
-          ForLayerSet: { attributes: true, relations: true },
-          MaterialLayers: { attributes: true, relations: true },
-          Materials: { attributes: true, relations: false }
+          ...this._materialRelations
         }
       });
       for (const item of data) {
@@ -23655,10 +23948,7 @@ class IDSMaterial extends IDSFacet {
         relations: {
           AssociatedTo: { attributes: false, relations: false },
           HasAssociations: { attributes: true, relations: true },
-          MaterialConstituents: { attributes: true, relations: true },
-          ForLayerSet: { attributes: true, relations: true },
-          MaterialLayers: { attributes: true, relations: true },
-          Materials: { attributes: true, relations: false }
+          ...this._materialRelations
         }
       });
       for (const item of data) {
@@ -23702,13 +23992,7 @@ class IDSMaterial extends IDSFacet {
         isValid = true;
     } else {
       for (const [name, attribute] of Object.entries(item)) {
-        if (![
-          "ForLayerSet",
-          "MaterialLayers",
-          "Material",
-          "MaterialConstituents",
-          "Materials"
-        ].includes(name))
+        if (!this._materialParentAttributes.includes(name))
           continue;
         if (!Array.isArray(attribute))
           continue;
@@ -26715,7 +26999,7 @@ function buildPreviewPositions(kind, points, cursor, style) {
   for (let i = 0; i < points.length - 1; i++) {
     positions.push(
       ...buildDimensionPositions(
-        { uuid: "", pointA: points[i], pointB: points[i + 1], offset, style: "" },
+        { pointA: points[i], pointB: points[i + 1], offset },
         style
       )
     );