@sequent-org/ifc-viewer 1.2.4-ci.48.0 → 1.2.4-ci.50.0

package/README.md

@@ -367,6 +367,7 @@ npm run test:manual
 - `.gltf` - glTF JSON (часто требует внешние .bin/текстуры; надёжнее грузить по URL)
 - `.obj` - Wavefront OBJ (можно загружать один OBJ или OBJ+MTL(+текстуры) через мультивыбор файлов)
 - `.3ds` - 3D Studio (3DS) (рекомендуется загружать .3ds + текстуры через мультивыбор файлов)
+- `.3dm` - Rhino 3D (3DM) (требуются `rhino3dm.js`/`rhino3dm.wasm`, пакет копирует их в `/public/wasm/rhino3dm/` автоматически)
 - `.stl` - STL (ASCII/Binary). Обычно без материалов/цветов — отображается с дефолтным материалом.
 - `.dae` - COLLADA (DAE) (можно загружать .dae + текстуры через мультивыбор файлов)
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sequent-org/ifc-viewer",
   "private": false,
-  "version": "1.2.4-ci.48.0",
+  "version": "1.2.4-ci.50.0",
   "type": "module",
   "description": "IFC 3D model viewer component for web applications - fully self-contained with local IFCLoader",
   "main": "src/index.js",
@@ -32,7 +32,7 @@
     "access": "public"
   },
   "scripts": {
-    "postinstall": "node scripts/copy-web-ifc-wasm.mjs",
+    "postinstall": "node scripts/copy-web-ifc-wasm.mjs && node scripts/copy-rhino3dm.mjs && node scripts/patch-three-3dm-loader.mjs",
     "dev": "vite",
     "build": "vite build",
     "preview": "vite preview",
@@ -42,6 +42,7 @@
     "vite": "^7.1.2"
   },
   "dependencies": {
+    "rhino3dm": "8.4.0",
     "three": "^0.149.0",
     "web-ifc": "^0.0.74"
   }

package/scripts/copy-rhino3dm.mjs

@@ -0,0 +1,90 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function copyFile(src, dst) {
+  ensureDir(path.dirname(dst));
+  fs.copyFileSync(src, dst);
+}
+
+function main() {
+  // npm sets INIT_CWD to the original working directory where `npm install` was invoked.
+  // That is the app root we need to copy into.
+  const appRoot = process.env.INIT_CWD || process.cwd();
+
+  const req = createRequire(import.meta.url);
+
+  /** @type {string|null} */
+  let pkgJsonPath = null;
+  try {
+    pkgJsonPath = req.resolve('rhino3dm/package.json', { paths: [appRoot, process.cwd()] });
+  } catch (_) {
+    pkgJsonPath = null;
+  }
+
+  const pkgDir = pkgJsonPath ? path.dirname(pkgJsonPath) : path.join(appRoot, 'node_modules', 'rhino3dm');
+
+  const version = (() => {
+    try {
+      if (pkgJsonPath && fs.existsSync(pkgJsonPath)) {
+        const raw = fs.readFileSync(pkgJsonPath, 'utf8');
+        const json = JSON.parse(raw);
+        return String(json?.version || '').trim() || 'unknown';
+      }
+    } catch (_) {}
+    return 'unknown';
+  })();
+
+  const srcJs = path.join(pkgDir, 'rhino3dm.js');
+  const srcWasm = path.join(pkgDir, 'rhino3dm.wasm');
+
+  const dstDir = path.join(appRoot, 'public', 'wasm', 'rhino3dm');
+  const dstJs = path.join(dstDir, 'rhino3dm.js');
+  const dstWasm = path.join(dstDir, 'rhino3dm.wasm');
+
+  const dstDirV = path.join(dstDir, `v${version}`);
+  const dstJsV = path.join(dstDirV, 'rhino3dm.js');
+  const dstWasmV = path.join(dstDirV, 'rhino3dm.wasm');
+
+  if (!fs.existsSync(srcJs) || !fs.existsSync(srcWasm)) {
+    console.error('[copy-rhino3dm] Source not found', {
+      appRoot,
+      pkgDir,
+      srcJs,
+      srcWasm,
+      existsJs: fs.existsSync(srcJs),
+      existsWasm: fs.existsSync(srcWasm),
+    });
+    process.exitCode = 1;
+    return;
+  }
+
+  copyFile(srcJs, dstJs);
+  copyFile(srcWasm, dstWasm);
+
+  // Versioned location (recommended to avoid cache-mismatch for end-users)
+  copyFile(srcJs, dstJsV);
+  copyFile(srcWasm, dstWasmV);
+
+  const sJs = fs.statSync(srcJs);
+  const sWasm = fs.statSync(srcWasm);
+  const dJs = fs.statSync(dstJs);
+  const dWasm = fs.statSync(dstWasm);
+
+  console.log('[copy-rhino3dm] OK', {
+    appRoot,
+    versionDir: `v${version}`,
+    src: { js: srcJs, wasm: srcWasm },
+    dst: { js: dstJs, wasm: dstWasm },
+    dstV: { js: dstJsV, wasm: dstWasmV },
+    bytes: { js: dJs.size, wasm: dWasm.size },
+    sameSize: { js: sJs.size === dJs.size, wasm: sWasm.size === dWasm.size },
+  });
+}
+
+main();
+

package/scripts/patch-three-3dm-loader.mjs

@@ -0,0 +1,60 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+function main() {
+  const appRoot = process.env.INIT_CWD || process.cwd();
+  const req = createRequire(import.meta.url);
+
+  /** @type {string|null} */
+  let threePkgJson = null;
+  try {
+    threePkgJson = req.resolve('three/package.json', { paths: [appRoot, process.cwd()] });
+  } catch (_) {
+    threePkgJson = null;
+  }
+
+  const threeDir = threePkgJson ? path.dirname(threePkgJson) : path.join(appRoot, 'node_modules', 'three');
+  const target = path.join(threeDir, 'examples', 'jsm', 'loaders', '3DMLoader.js');
+
+  if (!fs.existsSync(target)) {
+    console.warn('[patch-three-3dm-loader] Target not found, skip', { target });
+    return;
+  }
+
+  const src = fs.readFileSync(target, 'utf8');
+  // Already patched?
+  if (src.includes('doc.instanceDefinitions().count;') || src.includes('doc.materials().count;')) {
+    console.log('[patch-three-3dm-loader] Already patched');
+    return;
+  }
+
+  let out = src;
+  const replacements = [
+    ['doc.instanceDefinitions().count()', 'doc.instanceDefinitions().count'],
+    ['doc.materials().count()', 'doc.materials().count'],
+    ['doc.layers().count()', 'doc.layers().count'],
+    ['doc.views().count()', 'doc.views().count'],
+    ['doc.namedViews().count()', 'doc.namedViews().count'],
+    ['doc.groups().count()', 'doc.groups().count'],
+    ['doc.strings().count()', 'doc.strings().count'],
+  ];
+
+  let changed = 0;
+  for (const [from, to] of replacements) {
+    const before = out;
+    out = out.split(from).join(to);
+    if (out !== before) changed++;
+  }
+
+  if (out === src) {
+    console.warn('[patch-three-3dm-loader] No changes applied (unexpected)', { target });
+    return;
+  }
+
+  fs.writeFileSync(target, out, 'utf8');
+  console.log('[patch-three-3dm-loader] Patched', { target, rulesApplied: changed });
+}
+
+main();
+

package/src/IfcViewer.js

@@ -21,6 +21,7 @@ import { ObjModelLoader } from "./model-loading/loaders/ObjModelLoader.js";
 import { TdsModelLoader } from "./model-loading/loaders/TdsModelLoader.js";
 import { StlModelLoader } from "./model-loading/loaders/StlModelLoader.js";
 import { DaeModelLoader } from "./model-loading/loaders/DaeModelLoader.js";
+import { ThreeDmModelLoader } from "./model-loading/loaders/ThreeDmModelLoader.js";
 import './style.css';
 
 
@@ -34,6 +35,7 @@ export class IfcViewer {
    * @param {string} [options.modelUrl] - URL для загрузки модели (любой поддерживаемый формат)
    * @param {File} [options.modelFile] - File объект модели (любой поддерживаемый формат)
    * @param {string} [options.wasmUrl] - URL для загрузки WASM файла web-ifc
+   * @param {string} [options.rhino3dmLibraryPath] - Путь (директория) к rhino3dm.js и rhino3dm.wasm (для .3dm)
    * @param {boolean} [options.useTestPreset=true] - Включать ли пресет "Тест" по умолчанию (рекомендованные тени/визуал)
    * @param {boolean} [options.showSidebar=false] - Показывать ли боковую панель с деревом
    * @param {boolean} [options.showControls=false] - Показывать ли панель управления (нижние кнопки)
@@ -65,6 +67,7 @@ export class IfcViewer {
       modelUrl: options.modelUrl || null,
       modelFile: options.modelFile || null,
       wasmUrl: options.wasmUrl || null,
+      rhino3dmLibraryPath: options.rhino3dmLibraryPath || '/wasm/rhino3dm/',
       // По умолчанию включаем пресет "Тест" для корректного вида теней (как в демо-настройках)
       useTestPreset: options.useTestPreset !== false,
       showSidebar: options.showSidebar === true, // по умолчанию false
@@ -207,6 +210,7 @@ export class IfcViewer {
         result = await this.modelLoaders.loadUrl(loadSource, {
           viewer: this.viewer,
           wasmUrl: this.options.wasmUrl,
+          rhino3dmLibraryPath: this.options.rhino3dmLibraryPath,
           logger: console,
         });
       } else if (Array.isArray(loadSource) || (typeof FileList !== 'undefined' && loadSource instanceof FileList)) {
@@ -215,17 +219,20 @@ export class IfcViewer {
           ? await this.modelLoaders.loadFiles(files, {
             viewer: this.viewer,
             wasmUrl: this.options.wasmUrl,
+            rhino3dmLibraryPath: this.options.rhino3dmLibraryPath,
             logger: console,
           })
           : await this.modelLoaders.loadFile(files[0], {
             viewer: this.viewer,
             wasmUrl: this.options.wasmUrl,
+            rhino3dmLibraryPath: this.options.rhino3dmLibraryPath,
             logger: console,
           });
       } else if (loadSource instanceof File) {
         result = await this.modelLoaders.loadFile(loadSource, {
           viewer: this.viewer,
           wasmUrl: this.options.wasmUrl,
+          rhino3dmLibraryPath: this.options.rhino3dmLibraryPath,
           logger: console,
         });
       } else {
@@ -531,7 +538,8 @@ export class IfcViewer {
       .register(new ObjModelLoader())
       .register(new TdsModelLoader())
       .register(new StlModelLoader())
-      .register(new DaeModelLoader());
+      .register(new DaeModelLoader())
+      .register(new ThreeDmModelLoader({ libraryPath: this.options.rhino3dmLibraryPath }));
 
     // Если в интерфейсе есть file input — настроим accept
     try {

package/src/index.js

@@ -22,3 +22,4 @@ export { ObjModelLoader } from "./model-loading/loaders/ObjModelLoader.js";
 export { TdsModelLoader } from "./model-loading/loaders/TdsModelLoader.js";
 export { StlModelLoader } from "./model-loading/loaders/StlModelLoader.js";
 export { DaeModelLoader } from "./model-loading/loaders/DaeModelLoader.js";
+export { ThreeDmModelLoader } from "./model-loading/loaders/ThreeDmModelLoader.js";

package/src/main.js

@@ -10,6 +10,7 @@ import { ObjModelLoader } from "./model-loading/loaders/ObjModelLoader.js";
 import { TdsModelLoader } from "./model-loading/loaders/TdsModelLoader.js";
 import { StlModelLoader } from "./model-loading/loaders/StlModelLoader.js";
 import { DaeModelLoader } from "./model-loading/loaders/DaeModelLoader.js";
+import { ThreeDmModelLoader } from "./model-loading/loaders/ThreeDmModelLoader.js";
 
 // Инициализация three.js Viewer в контейнере #app
 const app = document.getElementById("app");
@@ -354,7 +355,10 @@ if (app) {
     .register(new ObjModelLoader())
     .register(new TdsModelLoader())
     .register(new StlModelLoader())
-    .register(new DaeModelLoader());
+    .register(new DaeModelLoader())
+    .register(new ThreeDmModelLoader());
+
+  const rhino3dmLibraryPath = '/wasm/rhino3dm/';
 
   const uploadBtn = document.getElementById("uploadBtn");
   const ifcInput = document.getElementById("ifcInput");
@@ -369,8 +373,8 @@ if (app) {
       try {
         // Multi-file: e.g. OBJ+MTL (+textures)
         result = (files.length > 1)
-          ? await modelLoaders.loadFiles(files, { viewer, wasmUrl: wasmOverride, logger: console })
-          : await modelLoaders.loadFile(files[0], { viewer, wasmUrl: wasmOverride, logger: console });
+          ? await modelLoaders.loadFiles(files, { viewer, wasmUrl: wasmOverride, rhino3dmLibraryPath, logger: console })
+          : await modelLoaders.loadFile(files[0], { viewer, wasmUrl: wasmOverride, rhino3dmLibraryPath, logger: console });
         activeCapabilities = result?.capabilities || null;
       } catch (err) {
         console.error('Model load error', err);
@@ -611,7 +615,7 @@ if (app) {
     const params = new URLSearchParams(location.search);
     const ifcUrlParam = params.get('ifc');
     const ifcUrl = ifcUrlParam || DEFAULT_IFC_URL;
-    const result = await modelLoaders.loadUrl(encodeURI(ifcUrl), { viewer, wasmUrl: wasmOverride, logger: console });
+    const result = await modelLoaders.loadUrl(encodeURI(ifcUrl), { viewer, wasmUrl: wasmOverride, rhino3dmLibraryPath, logger: console });
     activeCapabilities = result?.capabilities || null;
     if (result?.object3D) {
       if (activeCapabilities?.kind === 'ifc' && activeCapabilities?.ifcService) {

package/src/model-loading/ModelLoaderRegistry.js

@@ -191,12 +191,24 @@ export class ModelLoaderRegistry {
    * @returns {Promise<any|null>} LoadResult or null on error
    */
   async loadUrl(url, ctx = {}) {
-    const loader = this.getLoaderForName(url);
+    const logger = ctx?.logger || console;
+    let loader = this.getLoaderForName(url);
+
+    // If URL doesn't contain an extension, try to infer format via headers/signature.
+    // This is required for CDN-style links like /ifc-files/<id> (no ".ifc" suffix).
+    if (!loader) {
+      try {
+        loader = await this._guessLoaderForUrl(url, logger);
+      } catch (e) {
+        logger?.warn?.('[ModelLoaderRegistry] url sniff failed', { url, error: e });
+        loader = null;
+      }
+    }
+
     if (!loader) {
       throw new Error(`Формат не поддерживается: ${url || 'unknown url'}`);
     }
 
-    const logger = ctx?.logger || console;
     const t0 = (typeof performance !== 'undefined' && performance.now) ? performance.now() : Date.now();
 
     try {
@@ -213,6 +225,193 @@ export class ModelLoaderRegistry {
     }
   }
 
+  /**
+   * Tries to infer loader for URL without extension.
+   *
+   * Strategy:
+   * - Use Content-Disposition filename (if present) to resolve extension
+   * - Else sniff the first bytes (streaming) and match known signatures
+   *
+   * @param {string} url
+   * @param {any} logger
+   * @returns {Promise<any|null>}
+   */
+  async _guessLoaderForUrl(url, logger) {
+    const u = String(url || '');
+    if (!u) return null;
+
+    // 1) Try HEAD headers (may expose filename and/or content-type)
+    try {
+      if (typeof fetch === 'function') {
+        const head = await fetch(u, { method: 'HEAD' });
+        const cd = head?.headers?.get?.('content-disposition') || head?.headers?.get?.('Content-Disposition');
+        if (cd) {
+          const fileName = this._tryParseFilenameFromContentDisposition(cd);
+          if (fileName) {
+            const byName = this.getLoaderForName(fileName);
+            if (byName) {
+              logger?.log?.('[ModelLoaderRegistry] url sniff: Content-Disposition matched', { url: u, fileName, loader: byName.id });
+              return byName;
+            }
+          }
+        }
+        const ct = head?.headers?.get?.('content-type') || head?.headers?.get?.('Content-Type');
+        // Content-Type is often "application/octet-stream", but keep a couple of strong signals.
+        if (ct) {
+          const lower = String(ct).toLowerCase();
+          if (lower.includes('model/gltf-binary') || lower.includes('model/gltf+json')) {
+            const byCt = this.getLoaderForName(lower.includes('binary') ? 'model.glb' : 'model.gltf');
+            if (byCt) {
+              logger?.log?.('[ModelLoaderRegistry] url sniff: Content-Type matched', { url: u, contentType: ct, loader: byCt.id });
+              return byCt;
+            }
+          }
+        }
+      }
+    } catch (_) {
+      // ignore HEAD failures, proceed to signature sniff
+    }
+
+    // 2) Sniff first bytes (prefer Range; fall back to stream+abort)
+    const prefix = await this._readUrlPrefix(u, 4096);
+    if (!prefix || !prefix.length) return null;
+
+    const sig = this._detectSignature(prefix);
+    if (!sig) return null;
+
+    const virtualName = sig.virtualName;
+    const bySig = this.getLoaderForName(virtualName);
+    if (bySig) {
+      logger?.log?.('[ModelLoaderRegistry] url sniff: signature matched', { url: u, signature: sig.kind, virtualName, loader: bySig.id });
+      return bySig;
+    }
+
+    return null;
+  }
+
+  _tryParseFilenameFromContentDisposition(cd) {
+    try {
+      const s = String(cd || '');
+      // filename*=UTF-8''... (RFC 5987)
+      const mStar = s.match(/filename\*\s*=\s*([^;]+)/i);
+      if (mStar) {
+        const v = mStar[1].trim();
+        const parts = v.split("''");
+        const encoded = parts.length >= 2 ? parts.slice(1).join("''") : v;
+        const cleaned = encoded.replace(/^["']|["']$/g, '');
+        try { return decodeURIComponent(cleaned); } catch (_) { return cleaned; }
+      }
+      // filename="..."
+      const m = s.match(/filename\s*=\s*([^;]+)/i);
+      if (m) {
+        const v = m[1].trim().replace(/^["']|["']$/g, '');
+        return v || null;
+      }
+    } catch (_) {}
+    return null;
+  }
+
+  _detectSignature(bytes) {
+    try {
+      const b0 = bytes[0];
+      const b1 = bytes[1];
+      const b2 = bytes[2];
+      const b3 = bytes[3];
+
+      // ZIP: "PK"
+      if (b0 === 0x50 && b1 === 0x4b) {
+        // Could be IFZ/IFCZIP most often for this package
+        return { kind: 'zip', virtualName: 'model.ifczip' };
+      }
+
+      // GLB: "glTF"
+      if (b0 === 0x67 && b1 === 0x6c && b2 === 0x54 && b3 === 0x46) {
+        return { kind: 'glb', virtualName: 'model.glb' };
+      }
+
+      // Text signatures: decode a small prefix as ASCII
+      const n = Math.min(bytes.length, 256);
+      let text = '';
+      for (let i = 0; i < n; i++) {
+        const c = bytes[i];
+        text += (c >= 32 && c <= 126) ? String.fromCharCode(c) : ' ';
+      }
+      const t = text.trim().toUpperCase();
+
+      // IFC STEP: "ISO-10303-21"
+      if (t.startsWith('ISO-10303-21')) {
+        return { kind: 'ifc-step', virtualName: 'model.ifc' };
+      }
+
+      // DAE: XML with <COLLADA ...>
+      if (t.startsWith('<?XML') || t.startsWith('<COLLADA') || t.includes('<COLLADA')) {
+        return { kind: 'dae-xml', virtualName: 'model.dae' };
+      }
+
+      // OBJ: common first tokens ("mtllib", "o", "v", "#")
+      if (/^(#|MTLLIB\s+|O\s+|V\s+|VN\s+|VT\s+)/i.test(text.trim())) {
+        return { kind: 'obj-text', virtualName: 'model.obj' };
+      }
+
+      // STL ASCII: starts with "solid"
+      if (t.startsWith('SOLID')) {
+        return { kind: 'stl-ascii', virtualName: 'model.stl' };
+      }
+
+      return null;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  async _readUrlPrefix(url, maxBytes = 4096) {
+    if (typeof fetch !== 'function') return new Uint8Array();
+    const u = String(url || '');
+    const n = Math.max(1, Number(maxBytes) || 4096);
+
+    const controller = (typeof AbortController !== 'undefined') ? new AbortController() : null;
+    const headers = {};
+    // Attempt Range. Some servers may ignore it; we still stop reading after maxBytes.
+    try { headers.Range = `bytes=0-${n - 1}`; } catch (_) {}
+
+    const res = await fetch(u, { method: 'GET', headers, signal: controller?.signal });
+    if (!res || !res.ok) {
+      throw new Error(`Failed to fetch url prefix: ${res?.status || 'unknown'}`);
+    }
+
+    // Prefer streaming to avoid downloading whole file if Range is ignored.
+    const reader = res.body?.getReader?.();
+    if (!reader) {
+      const buf = new Uint8Array(await res.arrayBuffer());
+      return buf.slice(0, n);
+    }
+
+    /** @type {Uint8Array[]} */
+    const chunks = [];
+    let total = 0;
+    while (total < n) {
+      // eslint-disable-next-line no-await-in-loop
+      const { value, done } = await reader.read();
+      if (done) break;
+      if (value && value.length) {
+        chunks.push(value);
+        total += value.length;
+      }
+    }
+
+    try { controller?.abort?.(); } catch (_) {}
+
+    const out = new Uint8Array(Math.min(total, n));
+    let offset = 0;
+    for (const c of chunks) {
+      if (offset >= out.length) break;
+      const take = Math.min(c.length, out.length - offset);
+      out.set(c.subarray(0, take), offset);
+      offset += take;
+    }
+    return out;
+  }
+
   _validateResult(result, loaderId) {
     if (!result || typeof result !== 'object') {
       throw new Error(`Loader "${loaderId}" returned invalid result`);

package/src/model-loading/loaders/ThreeDmModelLoader.js

@@ -0,0 +1,147 @@
+import { Box3, Vector3 } from 'three';
+import { Rhino3dmLoader } from 'three/examples/jsm/loaders/3DMLoader.js';
+
+/**
+ * Rhino 3DM loader.
+ *
+ * Notes:
+ * - Requires `rhino3dm.js` and `rhino3dm.wasm` to be served from a library path.
+ *   In this package we copy them to `/public/wasm/rhino3dm/` via postinstall script.
+ */
+export class ThreeDmModelLoader {
+  /**
+   * @param {{ libraryPath?: string, workerLimit?: number, rotateXNeg90?: boolean, alignToGround?: boolean }} [options]
+   */
+  constructor(options = {}) {
+    this.id = '3dm';
+    this.extensions = ['.3dm'];
+    this._libraryPath = options.libraryPath || '/wasm/rhino3dm/';
+    this._workerLimit = Number.isFinite(options.workerLimit) ? Number(options.workerLimit) : 4;
+    // Many 3DM assets are effectively Z-up; viewer is Y-up. Keep consistent with other format loaders.
+    this._rotateXNeg90 = options.rotateXNeg90 !== false; // default true
+    // Bring model down to ground plane so shadow receiver is correct.
+    this._alignToGround = options.alignToGround !== false; // default true
+  }
+
+  /**
+   * @param {File} file
+   * @param {any} ctx
+   */
+  async loadFile(file, ctx) {
+    const url = URL.createObjectURL(file);
+    try {
+      const obj = await this._loadInternal(url, ctx);
+      return {
+        object3D: obj,
+        format: this.id,
+        name: file?.name || '',
+        replacedInViewer: false,
+        capabilities: { kind: 'generic' },
+      };
+    } finally {
+      try { URL.revokeObjectURL(url); } catch (_) {}
+    }
+  }
+
+  /**
+   * @param {string} url
+   * @param {any} ctx
+   */
+  async loadUrl(url, ctx) {
+    const obj = await this._loadInternal(url, ctx);
+    return {
+      object3D: obj,
+      format: this.id,
+      name: String(url || ''),
+      replacedInViewer: false,
+      capabilities: { kind: 'generic' },
+    };
+  }
+
+  async _loadInternal(url, ctx) {
+    const logger = ctx?.logger || console;
+    const libraryPath = (ctx?.rhino3dmLibraryPath || this._libraryPath || '').toString();
+    const normalizedPath = libraryPath.endsWith('/') ? libraryPath : `${libraryPath}/`;
+
+    const loader = new Rhino3dmLoader();
+    loader.setLibraryPath(normalizedPath);
+    loader.setWorkerLimit(this._workerLimit);
+
+    logger?.log?.('[ThreeDmModelLoader] load', {
+      url: String(url || ''),
+      libraryPath: normalizedPath,
+      workerLimit: this._workerLimit,
+    });
+
+    let obj = null;
+    try {
+      obj = await new Promise((resolve, reject) => {
+        try {
+          loader.load(
+            url,
+            (result) => resolve(result),
+            undefined,
+            (err) => reject(err)
+          );
+        } catch (e) {
+          reject(e);
+        }
+      });
+    } catch (e) {
+      const msg = String(e?.message || e?.error?.message || e || '');
+      if (msg.includes('.count is not a function')) {
+        logger?.error?.(
+          '[ThreeDmModelLoader] rhino3dm API mismatch detected. This often happens when rhino3dm version is not compatible with three/examples 3DMLoader. ' +
+            'For three@0.149.0 a compatible rhino3dm version is ~8.4.0.'
+        );
+      }
+      throw e;
+    }
+
+    // Axis + grounding BEFORE Viewer.replaceWithModel(): ensures bbox/shadowReceiver computed correctly.
+    try {
+      if (obj) {
+        if (this._rotateXNeg90) {
+          obj.rotation.x = -Math.PI / 2;
+          obj.updateMatrixWorld?.(true);
+        }
+        if (this._alignToGround) {
+          const box = new Box3().setFromObject(obj);
+          const minY = box.min.y;
+          if (Number.isFinite(minY)) {
+            obj.position.y -= minY;
+            obj.position.y += 0.001; // epsilon to avoid z-fighting with shadow receiver
+            obj.updateMatrixWorld?.(true);
+          }
+        }
+      }
+    } catch (_) {}
+
+    // Basic diagnostics
+    try {
+      let meshes = 0;
+      let mats = 0;
+      obj?.traverse?.((n) => {
+        if (!n?.isMesh) return;
+        meshes++;
+        const m = n.material;
+        const arr = Array.isArray(m) ? m : [m];
+        for (const mi of arr) if (mi) mats++;
+      });
+      let bbox = null;
+      try {
+        const b = new Box3().setFromObject(obj);
+        const size = b.getSize(new Vector3());
+        const center = b.getCenter(new Vector3());
+        bbox = {
+          size: { x: +size.x.toFixed(3), y: +size.y.toFixed(3), z: +size.z.toFixed(3) },
+          center: { x: +center.x.toFixed(3), y: +center.y.toFixed(3), z: +center.z.toFixed(3) },
+        };
+      } catch (_) {}
+      logger?.log?.('[ThreeDmModelLoader] parsed', { meshes, materials: mats, bbox });
+    } catch (_) {}
+
+    return obj;
+  }
+}
+

package/src/viewer/Viewer.js

@@ -1373,6 +1373,10 @@ export class Viewer {
     this.activeModel = object3D;
     this.scene.add(object3D);
 
+    // Сброс MMB-pan (viewOffset) при загрузке новой модели:
+    // иначе экранный сдвиг может "унести" модель из кадра даже при корректном кадрировании по bbox.
+    try { this._mmbPan?.controller?.reset?.(); } catch (_) {}
+
     // Пересчитать плоскость под моделью (3x по площади bbox по X/Z)
     this.#updateShadowReceiverFromModel(object3D);
 
@@ -1627,13 +1631,40 @@ export class Viewer {
       const center = box.getCenter(new THREE.Vector3());
       const minY = box.min.y;
 
-      // Требование: площадь плоскости = 3x площади объекта (bbox по X/Z).
+      // Базовая плоскость: площадь = 3x площади объекта (bbox по X/Z).
       // => множитель по размерам = sqrt(3).
       const areaMultiplier = 3;
       const dimMul = Math.sqrt(areaMultiplier);
 
+      // Доп. запас по X/Z из-за длины тени: высокая модель при наклонном солнце
+      // может давать тень далеко за bbox по X/Z.
+      // Оценка смещения тени по земле: displacementXZ ≈ height * |dirXZ| / |dirY|
+      // где dir = (target - lightPos) нормализованный.
+      let extraX = 0;
+      let extraZ = 0;
+      try {
+        const sun = this.sunLight;
+        if (sun) {
+          const targetPos = (sun.target?.position?.clone?.() || center.clone());
+          const dir = targetPos.sub(sun.position).normalize();
+          const ay = Math.max(1e-3, Math.abs(dir.y));
+          extraX = Math.abs(dir.x) * (Math.max(0, size.y) / ay);
+          extraZ = Math.abs(dir.z) * (Math.max(0, size.y) / ay);
+          // небольшой коэффициент запаса, чтобы не ловить «пограничные» обрезания
+          const pad = 1.05;
+          extraX *= pad;
+          extraZ *= pad;
+        }
+      } catch (_) {
+        extraX = 0;
+        extraZ = 0;
+      }
+
       this.shadowReceiver.position.set(center.x, minY + 0.001, center.z);
-      this.shadowReceiver.scale.set(Math.max(0.001, size.x * dimMul), Math.max(0.001, size.z * dimMul), 1);
+      // receiver.scale: X->world X, Y->world Z (PlaneGeometry is X/Y in local, rotated -90° around X)
+      const receiverX = Math.max(0.001, (size.x * dimMul) + extraX * 2);
+      const receiverZ = Math.max(0.001, (size.z * dimMul) + extraZ * 2);
+      this.shadowReceiver.scale.set(receiverX, receiverZ, 1);
       this.shadowReceiver.updateMatrixWorld();
 
       // Обновим bbox здания для градиента тени (в XZ)
@@ -1647,8 +1678,8 @@ export class Viewer {
       // чтобы при включении теней они не "обрезались" слишком маленькой областью.
       if (this.sunLight) {
         const cam = this.sunLight.shadow.camera;
-        const halfX = (size.x * dimMul) / 2;
-        const halfZ = (size.z * dimMul) / 2;
+        const halfX = receiverX / 2;
+        const halfZ = receiverZ / 2;
         cam.left = -halfX;
         cam.right = halfX;
         cam.top = halfZ;