@file-viewer/renderer-3d 3.0.2 → 3.1.0

package/IFC.md

@@ -0,0 +1,156 @@
+# Optional IFC viewer
+
+The explicit `@file-viewer/renderer-3d/ifc` entry adds browser-local IFC geometry,
+orbit/pan/zoom, fit-to-model, element selection, basic properties and an advanced
+That Open hook. It does not change the ordinary 3D entry or the frozen Full/Office
+presets. Applications opt in instead of paying the BIM dependency cost by default.
+
+## Install and self-host
+
+```sh
+npm install @file-viewer/renderer-3d @thatopen/components@3.4.8 @thatopen/fragments@3.4.7 web-ifc@0.0.77
+npm install -D esbuild@0.28.2
+npx file-viewer-ifc-assets public/file-viewer/vendor/ifc
+```
+
+The asset command is local: it bundles the import Worker and copies the matching
+Fragments worker and Web-IFC WASM from installed packages. No CDN or online
+conversion service is used. Ship its entire output, including licenses and manifest.
+For a nested deployment use the same custom path in the command and `assetBaseUrl`.
+Use HTTP(S), module Workers and a browser with WebGL 2. CSP needs `worker-src 'self'
+blob:`, WASM execution via `script-src 'wasm-unsafe-eval'`, and the usual local script,
+style and data/blob-image permissions of the host. Neither COOP/COEP nor a threaded
+WASM build is required for the default single import Worker.
+
+Model identifiers use Three.js's non-security UUID utility, not the secure-context-only
+`crypto.randomUUID()` API. The browser regression removes that API before loading both
+official models and still verifies selection, properties and complete Worker cleanup.
+
+```ts
+import { modelRenderer } from '@file-viewer/renderer-3d'
+import { createIfcRenderer } from '@file-viewer/renderer-3d/ifc'
+
+const options = {
+  rendererMode: 'extend',
+  renderers: [modelRenderer, createIfcRenderer({
+    assetBaseUrl: '/file-viewer/vendor/ifc/',
+    fitToModel: true,
+    enableSelection: true,
+    showProperties: true,
+    onSelectionChange(selection) {
+      console.log(selection?.name, selection?.globalId, selection?.entityType)
+    }
+  })]
+}
+// Pass these options to the normal FileViewer component. Set file to the IFC file.
+```
+
+`modelRenderer` owns the base model registry definition; the IFC plugin enhances
+only its `ifc` extension and leaves GLB/STL/STEP and other model routes unchanged.
+When the host already installs the ordinary model renderer, only add the IFC plugin.
+
+## Advanced extension
+
+```ts
+const ifc = createIfcRenderer({
+  configure({ components, fragments, world, model, signal, select }) {
+    // components/world: That Open Components; fragments: FragmentsModels core.
+    // model: the loaded FragmentsModel. No cloned internal substitute objects.
+    const handler = () => { /* host-owned integration */ }
+    window.addEventListener('my-bim-action', handler, { signal })
+    return () => window.removeEventListener('my-bim-action', handler)
+  }
+})
+```
+
+### Pre-import settings and pre-model runtime hook
+
+This data-only bridge incorporates the advanced configuration direction proposed
+by @p4535992 in PR #275, on the owned-Worker architecture from PR #276. It does not
+add the draft's duplicate runtime or separate capability/assets packages.
+
+```ts
+createIfcRenderer({
+  thatOpen: {
+    importer: {
+      webIfcSettings: { COORDINATE_TO_ORIGIN: true, CIRCLE_SEGMENTS: 24 },
+      geometryProcessSettings: { threshold: 3000 },
+      includeMaterialProperties: true
+    },
+    fragments: { settings: { maxUpdateRate: 80 } }
+  },
+  configureRuntime({ components, fragments, world, signal }) {
+    // Actual adapter-owned objects, before fragments.load() creates the model.
+    // Configure Components/camera/scene here, not through private-field assignment.
+    const handler = () => { /* application-specific integration */ }
+    window.addEventListener('bim-settings', handler, { signal })
+    return () => window.removeEventListener('bim-settings', handler)
+  },
+  configure({ model }) {
+    // Existing post-load hook remains available.
+  }
+})
+```
+
+`thatOpen.importer` accepts existing public data fields on the installed
+`IfcImporter`; `thatOpen.fragments.settings` accepts public writable fields on
+`FragmentsModels.settings`. These are advanced, upstream-version-coupled APIs,
+not a normalization of every That Open release. Omitted fields preserve defaults.
+Nested Loader/geometry bags are merged; native Sets/Maps replace contents while
+retaining library-owned collection instances. Use native `Set` for
+`attributesToExclude` and native `Map` for `relations`.
+
+Settings are copied before Worker allocation or copying file bytes. Only plain
+data, finite numbers, arrays and native Sets/Maps are accepted, limited to 2,048
+nodes, eight nesting levels and 65,536 cumulative string/key characters. Functions,
+accessors, class instances, cycles, prototype/private keys and custom collection
+properties are rejected. WASM locations, executable methods and Worker ownership
+remain adapter-controlled. Unknown top-level fields fail rather than being ignored.
+The Worker validates settings again before parsing. These shape/size guards do
+not replace upstream documentation for valid option values; configuration is
+trusted application code, never document-supplied executable metadata.
+
+Both hooks may be asynchronous and return synchronous cleanup. Cleanup runs once
+in reverse registration order, including late completion after cancellation. A
+failing cleanup does not prevent other hooks or Workers/WebGL from being disposed.
+Never dispose adapter-owned objects or replace their Worker/lifecycle methods.
+
+The adapter owns and disposes these objects. Do not dispose them in the hook.
+Return cleanup for your own resources. A late async hook is cleaned up after
+cancellation. The explicit `renderFileViewerIfc` API also returns `select(id|null)`,
+`fitToModel()` and an idempotent asynchronous `unmount()`.
+
+Parsing runs in a dedicated module Worker. Closing/changing the file aborts imports,
+terminates import workers, releases Fragments workers/models and disposes WebGL and
+camera controls. Input size defaults to 512 MiB and the loading timeout to 120 seconds;
+`maxFileBytes` and `loadTimeoutMs` allow smaller product-specific limits. These are
+safety limits, not promises that every 512 MiB model is interactive on every device.
+
+## Scope and licenses
+
+The initial scope is visual inspection, not authoring, BCF, clash detection,
+measurements or complete BIM semantics. IFC4 and IFC4.3 building samples are used
+for the repeatable browser gate. Fonts, textures and references outside the IFC
+are not fetched from remote services. Complex or unsupported geometry remains
+subject to Web-IFC's capabilities; parse failures are explicit.
+
+That Open Components and Fragments are MIT. Web-IFC is MPL-2.0, isolated behind this
+optional entry; the File Viewer adapter remains Apache-2.0. Preserve the copied
+MPL license, corresponding-source notice and bundled legal notices when distributing
+WASM/worker files. Fragments' upstream MIT text is retained in `licenses/` because
+its published tarball does not contain its root license file. Source:
+https://github.com/ThatOpen/engine_fragment/blob/main/LICENSE.md
+
+## Regression fixture attribution
+
+buildingSMART International Ltd., Certification-datasets, CC BY 4.0:
+https://github.com/buildingSMART/Certification-datasets
+Revision: `80d976a9b193a26a8e928c3e79bff67af1de68a8`.
+
+- `IFC 4.0.2.1 (IFC 4 ADD2 TC1)/Simple-Scene/Building-Architecture.ifc`
+- `IFC 4.3.2.0 (IFC 4.3 ADD2)/Simple-Scene/Building-Architecture.ifc`
+
+The input files are unmodified. Test screenshots are rendered derivatives.
+Fixture bytes are supplied separately; the browser script checks their SHA-256.
+Run `pnpm --filter @file-viewer/renderer-3d verify:ifc-browser /path/to/fixtures`
+with `ifc4.ifc` and `ifc43.ifc` in that directory after building the package.

package/bin/copy-ifc-assets.mjs

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { realpathSync } from "node:fs";
+import { dirname, resolve, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  mkdir,
+  copyFile,
+  readFile,
+  writeFile,
+  mkdtemp,
+  rm,
+  readdir,
+} from "node:fs/promises";
+import { createHash } from "node:crypto";
+
+const require = createRequire(import.meta.url);
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+async function packageDir(name, resolver = require) {
+  let current = dirname(resolver.resolve(name));
+  for (;;) {
+    try {
+      const metadata = JSON.parse(
+        await readFile(join(current, "package.json"), "utf8"),
+      );
+      if (metadata.name === name) return { path: current, metadata };
+    } catch {}
+    const parent = dirname(current);
+    if (parent === current)
+      throw new Error(`Cannot locate ${name} package root`);
+    current = parent;
+  }
+}
+export async function copyIfcAssets(destination) {
+  const [webIfc, fragments, three] = await Promise.all(
+    ["web-ifc", "@thatopen/fragments", "three"].map((name) => packageDir(name)),
+  );
+  const fragmentRequire = createRequire(join(fragments.path, "package.json"));
+  const packages = [
+    webIfc,
+    fragments,
+    three,
+    ...(await Promise.all(
+      ["earcut", "flatbuffers", "lru-cache", "pako"].map((name) =>
+        packageDir(name, fragmentRequire),
+      ),
+    )),
+  ];
+  if (
+    webIfc.metadata.version !== "0.0.77" ||
+    fragments.metadata.version !== "3.4.7"
+  )
+    throw new Error(
+      "IFC assets must match the tested web-ifc@0.0.77 and @thatopen/fragments@3.4.7 engines",
+    );
+  const { build } = await import("esbuild");
+  destination = resolve(destination);
+  await mkdir(dirname(destination), { recursive: true });
+  const stage = await mkdtemp(join(dirname(destination), ".ifc-assets-"));
+  try {
+    await copyFile(
+      join(webIfc.path, "web-ifc.wasm"),
+      join(stage, "web-ifc.wasm"),
+    );
+    await copyFile(
+      join(webIfc.path, "web-ifc-mt.wasm"),
+      join(stage, "web-ifc-mt.wasm"),
+    );
+    await copyFile(
+      join(fragments.path, "dist/Worker/worker.mjs"),
+      join(stage, "fragments.worker.mjs"),
+    );
+    await build({
+      entryPoints: [join(packageRoot, "dist/ifc-import.worker.js")],
+      outfile: join(stage, "ifc-import.worker.js"),
+      bundle: true,
+      format: "esm",
+      platform: "browser",
+      target: "es2022",
+      legalComments: "linked",
+      minify: true,
+      logLevel: "silent",
+    });
+    const licenses = join(stage, "licenses");
+    await mkdir(licenses);
+    await copyFile(
+      join(packageRoot, "licenses/thatopen-fragments-MIT.txt"),
+      join(licenses, "thatopen-fragments-MIT.txt"),
+    );
+    for (const pkg of packages) {
+      const names = (await readdir(pkg.path)).filter((name) =>
+        /^licen[cs]e(?:[.-]|$)/i.test(name),
+      );
+      for (const name of names)
+        await copyFile(
+          join(pkg.path, name),
+          join(licenses, `${pkg.metadata.name.replace(/[@/]/g, "_")}-${name}`),
+        );
+    }
+    const notice = [
+      "Optional IFC runtime assets for File Viewer.",
+      "These assets are not loaded by the ordinary model/Office entry.",
+      "web-ifc is MPL-2.0. Its WASM and bundled import code are unmodified upstream implementations.",
+      "Corresponding source and build instructions: https://github.com/ThatOpen/engine_web-ifc (release 0.0.77).",
+      "Fragments is MIT: https://github.com/ThatOpen/engine_fragment (release 3.4.7).",
+      "Preserve licenses/, the linked worker legal notices and this notice when redistributing.",
+      ...packages.map(
+        (pkg) =>
+          `${pkg.metadata.name}@${pkg.metadata.version}: ${pkg.metadata.license || "See package license"}`,
+      ),
+      "",
+    ].join("\n");
+    await writeFile(join(stage, "NOTICE.txt"), notice);
+    const files = {};
+    for (const name of await readdir(stage)) {
+      if (name === "licenses") continue;
+      const bytes = await readFile(join(stage, name));
+      files[name] = {
+        bytes: bytes.length,
+        sha256: createHash("sha256").update(bytes).digest("hex"),
+      };
+    }
+    await writeFile(
+      join(stage, "manifest.json"),
+      JSON.stringify(
+        {
+          schema: 1,
+          packages: packages.map((pkg) => ({
+            name: pkg.metadata.name,
+            version: pkg.metadata.version,
+            license: pkg.metadata.license,
+          })),
+          files,
+        },
+        null,
+        2,
+      ) + "\n",
+    );
+    // Only replace our own asset names, never remove a user's destination directory.
+    await mkdir(join(destination, "licenses"), { recursive: true });
+    for (const name of await readdir(stage)) {
+      if (name === "licenses") {
+        for (const license of await readdir(licenses))
+          await copyFile(
+            join(licenses, license),
+            join(destination, "licenses", license),
+          );
+      } else await copyFile(join(stage, name), join(destination, name));
+    }
+    return { destination, files };
+  } finally {
+    await rm(stage, { recursive: true, force: true });
+  }
+}
+function isEntryPoint() {
+  try {
+    // npm/pnpm execute bin entries through a symlink; import.meta.url points
+    // at the real module. Do not silently skip the installed CLI in that case.
+    return Boolean(process.argv[1]) &&
+      realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+  } catch {
+    // Importing this helper from eval/another program is not CLI execution.
+    return false;
+  }
+}
+if (isEntryPoint()) {
+  if (process.argv.includes("--help")) {
+    console.log("Usage: file-viewer-ifc-assets [destination-directory]");
+    process.exit(0);
+  }
+  if (process.argv.length > 3 || process.argv[2]?.startsWith("-")) {
+    console.error("Expected one destination directory");
+    process.exit(1);
+  }
+  copyIfcAssets(process.argv[2] || "public/file-viewer/vendor/ifc")
+    .then((result) =>
+      console.log(`IFC assets installed: ${result.destination}`),
+    )
+    .catch((error) => {
+      console.error(error.message);
+      process.exitCode = 1;
+    });
+}

package/dist/ifc-import.worker.d.ts

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

package/dist/ifc-import.worker.js

@@ -0,0 +1,31 @@
+import { applyIfcSettings, copyIfcImporterSettings } from "./ifcSettings.js";
+import { IfcImporter } from "@thatopen/fragments";
+// Compiled into a self-hosted module Worker by the optional asset installer.
+const scope = globalThis;
+let active = false;
+scope.onmessage = async ({ data }) => {
+    if (active)
+        return;
+    active = true;
+    try {
+        const importer = new IfcImporter();
+        importer.wasm = { path: data.wasmPath, absolute: true };
+        importer.webIfcSettings = { COORDINATE_TO_ORIGIN: true };
+        importer.includeUniqueAttributes = true;
+        importer.includeRelationNames = true;
+        applyIfcSettings(importer, copyIfcImporterSettings(data.importerSettings));
+        const result = await importer.process({
+            bytes: new Uint8Array(data.bytes),
+            progressCallback: (progress) => scope.postMessage({ kind: "progress", progress }),
+        });
+        // slice owns the exact byte range even when the importer returns a view.
+        const bytes = Uint8Array.from(result).buffer;
+        scope.postMessage({ kind: "ready", bytes }, [bytes]);
+    }
+    catch (error) {
+        scope.postMessage({
+            kind: "error",
+            message: error instanceof Error ? error.message : String(error),
+        });
+    }
+};

package/dist/ifc.d.ts

@@ -0,0 +1,57 @@
+import type { FileRenderContext, FileViewerRendererPlugin, FileRenderHandler, RendererDefinition } from "@file-viewer/core";
+import type * as OBC from "@thatopen/components";
+import type * as FRAGS from "@thatopen/fragments";
+export interface IfcSelection {
+    localId: number;
+    name: string;
+    globalId: string;
+    entityType: string;
+    attributes: FRAGS.ItemData;
+}
+export interface IfcExtensionContext {
+    components: OBC.Components;
+    fragments: FRAGS.FragmentsModels;
+    world: OBC.SimpleWorld<OBC.SimpleScene, OBC.SimpleCamera, OBC.SimpleRenderer>;
+    model: FRAGS.FragmentsModel;
+    signal: AbortSignal;
+    select: (localId: number | null) => Promise<IfcSelection | null>;
+}
+/** Advanced runtime objects are adapter-owned; return cleanup only for host resources. */
+export type IfcRuntimeContext = Pick<IfcExtensionContext, "components" | "fragments" | "world" | "signal">;
+export interface IfcThatOpenOptions {
+    /** Public IfcImporter data fields; no executable methods, WASM or Worker overrides. */
+    importer?: Readonly<Record<string, unknown>>;
+    /** Public FragmentsModels.settings fields, not constructor/Worker ownership. */
+    fragments?: {
+        settings?: Readonly<Record<string, unknown>>;
+    };
+}
+export interface IfcViewerOptions {
+    /** Optional pre-import data settings; defaults are unchanged when omitted. */
+    thatOpen?: IfcThatOpenOptions;
+    /** Runs after runtime creation, before model loading. Return host-resource cleanup. */
+    configureRuntime?: (context: IfcRuntimeContext) => void | (() => void) | Promise<void | (() => void)>;
+    /** Directory installed by file-viewer-ifc-assets. Defaults to /file-viewer/vendor/ifc/. */
+    assetBaseUrl?: string | URL;
+    fitToModel?: boolean;
+    enableSelection?: boolean;
+    showProperties?: boolean;
+    /** Whole-input limit, before a transferable copy is made. Default: 512 MiB. */
+    maxFileBytes?: number;
+    /** Bound stalled import/worker setup. Default: 120 seconds. */
+    loadTimeoutMs?: number;
+    onSelectionChange?: (selection: IfcSelection | null) => void;
+    /** Advanced, opt-in access. Return cleanup for resources created by the hook. */
+    configure?: (context: IfcExtensionContext) => void | (() => void) | Promise<void | (() => void)>;
+}
+export interface IfcViewerInstance {
+    $el: HTMLElement;
+    unmount(): Promise<void>;
+    fitToModel(): Promise<void>;
+    select(localId: number | null): Promise<IfcSelection | null>;
+}
+export declare const ifcRendererDefinition: RendererDefinition;
+export declare function createIfcRenderer(options?: IfcViewerOptions): FileViewerRendererPlugin<FileRenderHandler<IfcViewerInstance, HTMLDivElement>>;
+export declare function renderFileViewerIfc(buffer: ArrayBuffer, target: HTMLDivElement, context?: FileRenderContext, options?: IfcViewerOptions): Promise<IfcViewerInstance>;
+export declare const ifcRenderer: FileViewerRendererPlugin<FileRenderHandler<IfcViewerInstance, HTMLDivElement>>;
+export default ifcRenderer;

package/dist/ifc.js

@@ -0,0 +1,31 @@
+export const ifcRendererDefinition = {
+    id: "ifc",
+    label: "IFC BIM",
+    category: "model",
+    extensions: [],
+    packageName: "@file-viewer/renderer-3d",
+    supportLevel: "structured",
+    status: "experimental",
+    enhancesRendererId: "model",
+    enhancesExtensions: ["ifc"],
+};
+export function createIfcRenderer(options = {}) {
+    return {
+        id: "file-viewer-renderer-ifc",
+        label: "Flyfish optional IFC viewer",
+        definitions: [ifcRendererDefinition],
+        handlers: [
+            {
+                rendererId: "ifc",
+                handler: (buffer, target, _type, context) => renderFileViewerIfc(buffer, target, context, options),
+            },
+        ],
+    };
+}
+export async function renderFileViewerIfc(buffer, target, context, options = {}) {
+    // Optional engines never enter the normal model/Office entry or initial bundle.
+    const { renderIfc } = await import("./ifcRuntime.js");
+    return renderIfc(buffer, target, context, options);
+}
+export const ifcRenderer = createIfcRenderer();
+export default ifcRenderer;

package/dist/ifcRuntime.d.ts

@@ -0,0 +1,3 @@
+import type { FileRenderContext } from "@file-viewer/core";
+import type { IfcViewerInstance, IfcViewerOptions } from "./ifc.js";
+export declare function renderIfc(buffer: ArrayBuffer, target: HTMLDivElement, context: FileRenderContext | undefined, options: IfcViewerOptions): Promise<IfcViewerInstance>;

package/dist/ifcRuntime.js

@@ -0,0 +1,500 @@
+import { applyIfcSettings, copyIfcImporterSettings, copyIfcSettings, } from "./ifcSettings.js";
+import * as THREE from "three";
+import * as OBC from "@thatopen/components";
+import * as FRAGS from "@thatopen/fragments";
+const css = `.fv-ifc{position:relative;display:flex;flex-direction:column;height:100%;min-height:240px;background:#f5f7fa;color:#182333;font:13px/1.5 system-ui,sans-serif}.fv-ifc *{box-sizing:border-box}.fv-ifc-toolbar{display:flex;gap:8px;align-items:center;padding:9px 12px;border-bottom:1px solid #dbe2e9;background:#fff}.fv-ifc button{font:inherit;padding:5px 10px;background:#fff;color:inherit;border:1px solid #cbd5e1;border-radius:5px;cursor:pointer}.fv-ifc button:focus-visible{outline:2px solid #2563eb;outline-offset:2px}.fv-ifc-toolbar span{margin-left:auto}.fv-ifc-body{display:flex;position:relative;flex:1;min-height:0}.fv-ifc-stage{position:relative;flex:1;min-width:0;min-height:200px;overflow:hidden}.fv-ifc-stage canvas{display:block;width:100%;height:100%}.fv-ifc-properties{width:260px;max-width:45%;padding:12px;overflow:auto;border-left:1px solid #dbe2e9;background:#fff;overflow-wrap:anywhere}.fv-ifc-properties[hidden]{display:none}.fv-ifc-properties h3{margin:0 0 12px}.fv-ifc-properties dt{font-weight:600;margin-top:9px}.fv-ifc-properties dd{margin:1px 0;color:#475569;white-space:pre-wrap}.fv-ifc-status{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;text-align:center;padding:24px;background:#f5f7fa;white-space:pre-wrap}.fv-ifc-status[hidden]{display:none}@media(max-width:560px){.fv-ifc-properties{width:180px;max-width:45%}}`;
+const abortError = () => new DOMException("IFC preview cancelled", "AbortError");
+const attribute = (data, ...names) => {
+    for (const name of names) {
+        const value = data[name];
+        if (value &&
+            !Array.isArray(value) &&
+            "value" in value &&
+            value.value != null)
+            return String(value.value);
+    }
+    return "";
+};
+export async function renderIfc(buffer, target, context, options) {
+    if (context?.signal?.aborted)
+        throw abortError();
+    const maxBytes = options.maxFileBytes ?? 512 * 1024 * 1024;
+    const timeoutMs = options.loadTimeoutMs ?? 120_000;
+    if (!Number.isFinite(maxBytes) ||
+        maxBytes <= 0 ||
+        buffer.byteLength > maxBytes)
+        throw new Error("IFC input exceeds the configured size limit");
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 1)
+        throw new Error("Invalid IFC load timeout");
+    const importerSettings = copyIfcImporterSettings(options.thatOpen?.importer);
+    const fragmentsSettings = copyIfcSettings(options.thatOpen?.fragments?.settings, "IFC Fragments settings");
+    const header = new TextDecoder().decode(buffer.slice(0, 65536));
+    if (!/^\s*ISO-10303-21\s*;/i.test(header.replace(/^\uFEFF/, "")) ||
+        !/FILE_SCHEMA\s*\(\s*\(\s*['"]IFC/i.test(header))
+        throw new Error("The file is not an IFC STEP document");
+    if (typeof Worker === "undefined")
+        throw new Error("IFC preview requires Web Workers");
+    const assetBase = new URL(String(options.assetBaseUrl ?? "/file-viewer/vendor/ifc/"), target.ownerDocument.baseURI);
+    if (!/^https?:$/.test(assetBase.protocol))
+        throw new Error("IFC assets must use a local HTTP(S) asset directory");
+    if (!assetBase.pathname.endsWith("/"))
+        assetBase.pathname += "/";
+    const cn = String(context?.options?.locale || "").startsWith("zh");
+    const jp = String(context?.options?.locale || "").startsWith("ja");
+    const words = cn
+        ? [
+            "适合窗口",
+            "清除选择",
+            "属性",
+            "正在解析 IFC…",
+            "点击构件查看属性",
+            "构件",
+        ]
+        : jp
+            ? [
+                "全体表示",
+                "選択解除",
+                "プロパティ",
+                "IFC を読み込み中…",
+                "要素を選択してプロパティを表示",
+                "要素",
+            ]
+            : [
+                "Fit model",
+                "Clear selection",
+                "Properties",
+                "Loading IFC…",
+                "Select an element to inspect its properties",
+                "elements",
+            ];
+    const doc = target.ownerDocument;
+    const root = doc.createElement("div");
+    root.className = "fv-ifc";
+    root.dataset.ifcStatus = "loading";
+    const style = doc.createElement("style");
+    style.textContent = css;
+    const toolbar = doc.createElement("div");
+    toolbar.className = "fv-ifc-toolbar";
+    const button = (text) => {
+        const value = doc.createElement("button");
+        value.type = "button";
+        value.textContent = text;
+        return value;
+    };
+    const fitButton = button(words[0]);
+    const clearButton = button(words[1]);
+    const propertiesButton = button(words[2]);
+    const summary = doc.createElement("span");
+    summary.setAttribute("aria-live", "polite");
+    toolbar.append(fitButton, clearButton, propertiesButton, summary);
+    const body = doc.createElement("div");
+    body.className = "fv-ifc-body";
+    const stage = doc.createElement("div");
+    stage.className = "fv-ifc-stage";
+    const status = doc.createElement("div");
+    status.className = "fv-ifc-status";
+    status.setAttribute("role", "status");
+    status.textContent = words[3];
+    const properties = doc.createElement("aside");
+    properties.className = "fv-ifc-properties";
+    properties.hidden = options.showProperties === false;
+    properties.textContent = words[4];
+    propertiesButton.setAttribute("aria-expanded", String(!properties.hidden));
+    stage.append(status);
+    body.append(stage, properties);
+    root.append(toolbar, body);
+    target.replaceChildren(style, root);
+    const controller = new AbortController();
+    let disposed = false;
+    let importWorker;
+    let components;
+    let fragments;
+    let world;
+    let model;
+    const extensionCleanups = [];
+    let ready = false;
+    let selectionId = 0;
+    let selectionQueue = Promise.resolve();
+    let updatePending = false;
+    // Model identifiers are not security tokens; do not require a secure context.
+    const id = `ifc-${THREE.MathUtils.generateUUID()}`;
+    let timeout;
+    let removeCanvasEvents = () => { };
+    let removeControlEvents = () => { };
+    let disposePromise;
+    const ensureLive = () => {
+        if (disposed || controller.signal.aborted)
+            throw controller.signal.reason ?? abortError();
+    };
+    const showError = (error) => {
+        if (disposed)
+            return;
+        root.dataset.ifcStatus = "error";
+        status.hidden = false;
+        status.textContent = error instanceof Error ? error.message : String(error);
+    };
+    const update = async () => {
+        if (disposed || !fragments || updatePending)
+            return;
+        updatePending = true;
+        try {
+            await fragments.update();
+        }
+        catch (error) {
+            showError(error);
+        }
+        finally {
+            updatePending = false;
+        }
+    };
+    const unmount = () => {
+        if (disposePromise)
+            return disposePromise;
+        // Assign before abort/cleanup callbacks can reenter unmount(). Every caller
+        // must await the same complete resource teardown, not an early promise.
+        let finish;
+        let fail;
+        disposePromise = new Promise((resolve, reject) => {
+            finish = resolve;
+            fail = reject;
+        });
+        void (async () => {
+            disposed = true;
+            ready = false;
+            selectionId++;
+            if (!controller.signal.aborted)
+                controller.abort(abortError());
+            clearTimeout(timeout);
+            importWorker?.terminate();
+            importWorker = undefined;
+            context?.signal?.removeEventListener("abort", onAbort);
+            removeCanvasEvents();
+            removeControlEvents();
+            const currentComponents = components;
+            components = undefined;
+            const currentFragments = fragments;
+            fragments = undefined;
+            const cleanups = extensionCleanups.splice(0).reverse();
+            root.remove();
+            style.remove();
+            try {
+                const errors = [];
+                for (const cleanup of cleanups) {
+                    try {
+                        cleanup();
+                    }
+                    catch (error) {
+                        errors.push(error);
+                    }
+                }
+                if (errors.length)
+                    throw new AggregateError(errors, "IFC extension cleanup failed");
+            }
+            finally {
+                // Stop the frame loop before releasing worker-owned model geometry.
+                if (currentComponents)
+                    currentComponents.enabled = false;
+                try {
+                    if (currentFragments) {
+                        // abort() routes through the upstream connection and creates a Worker
+                        // for an unknown model ID. Before load(), there is nothing to abort.
+                        if (currentFragments.models.list.has(id))
+                            currentFragments.abort(id);
+                        await currentFragments.dispose();
+                    }
+                }
+                finally {
+                    currentComponents?.dispose();
+                }
+            }
+        })().then(finish, fail);
+        return disposePromise;
+    };
+    const onAbort = () => {
+        void unmount().catch(() => { });
+    };
+    context?.signal?.addEventListener("abort", onAbort, { once: true });
+    const withCancellation = (promise) => new Promise((resolve, reject) => {
+        const abort = () => reject(controller.signal.reason ?? abortError());
+        if (controller.signal.aborted) {
+            abort();
+            return;
+        }
+        controller.signal.addEventListener("abort", abort, { once: true });
+        promise
+            .then(resolve, reject)
+            .finally(() => controller.signal.removeEventListener("abort", abort));
+    });
+    const fitToModel = async () => {
+        ensureLive();
+        if (!world || !model)
+            return;
+        const box = model.box.clone();
+        if (box.isEmpty())
+            throw new Error("IFC model contains no renderable geometry");
+        const center = box.getCenter(new THREE.Vector3());
+        const size = Math.max(box.getSize(new THREE.Vector3()).length(), 1);
+        world.camera.three.near = Math.max(0.01, size / 10000);
+        world.camera.three.far = Math.max(1000, size * 100);
+        world.camera.three.updateProjectionMatrix();
+        await world.camera.controls.setLookAt(center.x + size, center.y + size * 0.8, center.z + size, center.x, center.y, center.z, false);
+        await world.camera.controls.fitToBox(box, false);
+        await fragments?.update(true);
+    };
+    const renderProperties = (selection) => {
+        properties.replaceChildren();
+        if (!selection) {
+            properties.textContent = words[4];
+            return;
+        }
+        const title = doc.createElement("h3");
+        title.textContent =
+            selection.name || selection.entityType || String(selection.localId);
+        properties.append(title);
+        const list = doc.createElement("dl");
+        let count = 0;
+        const append = (label, value) => {
+            if (++count > 300)
+                return;
+            const key = doc.createElement("dt");
+            key.textContent = label.slice(0, 200);
+            const item = doc.createElement("dd");
+            item.textContent = String(value ?? "").slice(0, 2048);
+            list.append(key, item);
+        };
+        append("IFC type", selection.entityType);
+        append("GlobalId", selection.globalId);
+        append("Local ID", selection.localId);
+        const visit = (data, prefix = "", depth = 0) => {
+            if (depth > 3 || count >= 300)
+                return;
+            for (const [key, value] of Object.entries(data)) {
+                if (count >= 300)
+                    break;
+                if (Array.isArray(value)) {
+                    for (const child of value.slice(0, 30))
+                        visit(child, `${prefix}${key} / `, depth + 1);
+                }
+                else if (value && "value" in value)
+                    append(prefix + key, value.value);
+            }
+        };
+        visit(selection.attributes);
+        properties.append(list);
+    };
+    const select = (localId) => {
+        const request = ++selectionId;
+        const next = selectionQueue
+            .catch(() => { })
+            .then(async () => {
+            ensureLive();
+            if (!model || !ready || request !== selectionId)
+                return null;
+            if (localId !== null && (!Number.isSafeInteger(localId) || localId < 0))
+                throw new Error("Invalid IFC local ID");
+            let selection = null;
+            if (localId !== null) {
+                const [data] = await model.getItemsData([localId], {
+                    attributesDefault: true,
+                    relations: {
+                        IsDefinedBy: { attributes: true, relations: true },
+                        DefinesOccurrence: { attributes: false, relations: false },
+                    },
+                });
+                ensureLive();
+                if (request !== selectionId)
+                    return null;
+                if (!data)
+                    throw new Error("IFC item not found");
+                selection = {
+                    localId,
+                    name: attribute(data, "Name"),
+                    globalId: attribute(data, "GlobalId", "_guid"),
+                    entityType: attribute(data, "_category", "type"),
+                    attributes: data,
+                };
+            }
+            await model.resetHighlight();
+            if (selection)
+                await model.highlight([selection.localId], {
+                    color: new THREE.Color("#3b82f6"),
+                    renderedFaces: FRAGS.RenderedFaces.TWO,
+                    opacity: 1,
+                    transparent: false,
+                });
+            ensureLive();
+            if (request !== selectionId)
+                return null;
+            root.dataset.ifcSelected = selection ? String(selection.localId) : "";
+            renderProperties(selection);
+            await fragments?.update(true);
+            options.onSelectionChange?.(selection);
+            return selection;
+        });
+        selectionQueue = next;
+        return next;
+    };
+    const configureExtension = async (hook) => {
+        ensureLive();
+        const pending = Promise.resolve()
+            .then(() => {
+            ensureLive();
+            return hook();
+        })
+            .then((cleanup) => {
+            if (cleanup !== undefined && typeof cleanup !== "function")
+                throw new TypeError("IFC extension hook must return a cleanup function or undefined");
+            if (disposed)
+                cleanup?.();
+            else if (cleanup)
+                extensionCleanups.push(cleanup);
+        });
+        await withCancellation(pending);
+        ensureLive();
+    };
+    fitButton.addEventListener("click", () => {
+        void fitToModel().catch(showError);
+    });
+    clearButton.addEventListener("click", () => {
+        void select(null).catch(showError);
+    });
+    propertiesButton.addEventListener("click", () => {
+        properties.hidden = !properties.hidden;
+        propertiesButton.setAttribute("aria-expanded", String(!properties.hidden));
+    });
+    fitButton.disabled = clearButton.disabled = true;
+    try {
+        const importResult = new Promise((resolve, reject) => {
+            importWorker = new Worker(new URL("ifc-import.worker.js", assetBase), {
+                type: "module",
+                name: "file-viewer-ifc-import",
+            });
+            importWorker.onmessage = ({ data }) => {
+                if (data?.kind === "progress")
+                    summary.textContent = `${Math.round(Math.max(0, Math.min(1, Number(data.progress) || 0)) * 100)}%`;
+                else if (data?.kind === "ready" && data.bytes instanceof ArrayBuffer)
+                    resolve(new Uint8Array(data.bytes));
+                else if (data?.kind === "error")
+                    reject(new Error(`IFC import failed: ${String(data.message)}`));
+            };
+            importWorker.onerror = (event) => reject(new Error(`IFC worker failed. Install the self-hosted assets at ${assetBase.href}: ${event.message}`));
+            importWorker.onmessageerror = () => reject(new Error("Invalid IFC worker response"));
+            const copy = buffer.slice(0);
+            importWorker.postMessage({ bytes: copy, wasmPath: assetBase.href, importerSettings }, [copy]);
+        });
+        timeout = setTimeout(() => {
+            controller.abort(new Error("IFC loading timed out"));
+            onAbort();
+        }, timeoutMs);
+        const bytes = await withCancellation(importResult);
+        ensureLive();
+        importWorker?.terminate();
+        importWorker = undefined;
+        components = new OBC.Components();
+        world = components
+            .get(OBC.Worlds)
+            .create();
+        world.scene = new OBC.SimpleScene(components);
+        world.renderer = new OBC.SimpleRenderer(components, stage, {
+            antialias: true,
+            alpha: false,
+        });
+        world.renderer.showLogo = false;
+        world.renderer.three.setPixelRatio(Math.min(target.ownerDocument.defaultView?.devicePixelRatio || 1, 2));
+        world.camera = new OBC.SimpleCamera(components);
+        world.scene.setup({ backgroundColor: new THREE.Color("#f5f7fa") });
+        components.init();
+        fragments = new FRAGS.FragmentsModels(new URL("fragments.worker.mjs", assetBase).href, { maxWorkers: 2 });
+        applyIfcSettings(fragments.settings, fragmentsSettings);
+        if (options.configureRuntime) {
+            await configureExtension(() => options.configureRuntime({
+                components: components,
+                fragments: fragments,
+                world: world,
+                signal: controller.signal,
+            }));
+        }
+        model = await withCancellation(fragments.load(bytes, { modelId: id }));
+        ensureLive();
+        model.useCamera(world.camera.three);
+        world.scene.three.add(model.object);
+        world.camera.controls.addEventListener("update", update);
+        removeControlEvents = () => world?.camera.controls.removeEventListener("update", update);
+        const ids = await withCancellation(model.getItemsIdsWithGeometry());
+        ensureLive();
+        if (!ids.length)
+            throw new Error("IFC model contains no renderable geometry");
+        root.dataset.ifcElementCount = String(ids.length);
+        root.dataset.ifcFirstElement = String(ids[0]);
+        summary.textContent = `${ids.length} ${words[5]}`;
+        if (options.fitToModel !== false)
+            await withCancellation(fitToModel());
+        ready = true;
+        const canvas = world.renderer.three.domElement;
+        let start;
+        const down = (event) => {
+            if (event.button === 0)
+                start = { x: event.clientX, y: event.clientY };
+        };
+        const up = (event) => {
+            const original = start;
+            start = undefined;
+            if (!original ||
+                options.enableSelection === false ||
+                Math.hypot(event.clientX - original.x, event.clientY - original.y) >
+                    5 ||
+                !model ||
+                !world)
+                return;
+            // Fragment raycasting takes client-pixel coordinates, not normalized NDC.
+            void model
+                .raycast({
+                camera: world.camera.three,
+                mouse: new THREE.Vector2(event.clientX, event.clientY),
+                dom: canvas,
+            })
+                .then((hit) => {
+                if (!disposed)
+                    return select(hit?.localId ?? null);
+            })
+                .catch(showError);
+        };
+        canvas.addEventListener("pointerdown", down);
+        canvas.addEventListener("pointerup", up);
+        removeCanvasEvents = () => {
+            canvas.removeEventListener("pointerdown", down);
+            canvas.removeEventListener("pointerup", up);
+        };
+        if (options.configure) {
+            await configureExtension(() => options.configure({
+                components: components,
+                fragments: fragments,
+                world: world,
+                model: model,
+                signal: controller.signal,
+                select,
+            }));
+        }
+        clearTimeout(timeout);
+        root.dataset.ifcStatus = "ready";
+        status.hidden = true;
+        fitButton.disabled = false;
+        clearButton.disabled = options.enableSelection === false;
+        context?.onProgressiveRender?.();
+        return { $el: root, unmount, fitToModel, select };
+    }
+    catch (error) {
+        const cancelled = context?.signal?.aborted || !target.contains(root);
+        const message = error instanceof Error ? error.message : String(error);
+        await unmount().catch(() => { });
+        if (!cancelled) {
+            root.dataset.ifcStatus = "error";
+            status.textContent = message;
+            status.hidden = false;
+            // Retain a helpful error surface without retaining any workers or WebGL resources.
+            stage.replaceChildren(status);
+            target.replaceChildren(style, root);
+        }
+        throw error;
+    }
+}

package/dist/ifcSettings.d.ts

@@ -0,0 +1,7 @@
+/** Bounded data-only bridge. This module does not import the optional BIM engines. */
+export type IfcSettings = Readonly<Record<string, unknown>>;
+/** Copy before allocating a Worker or transferring input. No accessors are executed. */
+export declare function copyIfcSettings(value: unknown, label?: string): Record<string, unknown>;
+export declare function copyIfcImporterSettings(value: unknown): Record<string, unknown>;
+/** Apply only existing public data fields, retaining library-owned Set/Map instances. */
+export declare function applyIfcSettings(target: object, settings: IfcSettings): void;

package/dist/ifcSettings.js

@@ -0,0 +1,153 @@
+const unsafe = (key) => key.startsWith("_") || ["constructor", "prototype"].includes(key);
+const isRecord = (value) => value !== null &&
+    typeof value === "object" &&
+    [Object.prototype, null].includes(Object.getPrototypeOf(value));
+/** Copy before allocating a Worker or transferring input. No accessors are executed. */
+export function copyIfcSettings(value, label = "IFC settings") {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value))
+        throw new TypeError(`${label} must be a plain record`);
+    let nodes = 0, characters = 0;
+    const active = new Set();
+    const copy = (input, depth) => {
+        if (++nodes > 2048 || depth > 8)
+            throw new RangeError(`${label} exceeds configuration limits`);
+        if (typeof input === "string") {
+            characters += input.length;
+            if (characters > 65536)
+                throw new RangeError(`${label} exceeds configuration limits`);
+            return input;
+        }
+        if (input === null || typeof input === "boolean")
+            return input;
+        if (typeof input === "number" && Number.isFinite(input))
+            return input;
+        if (!input || typeof input !== "object")
+            throw new TypeError(`${label} accepts data, not functions or undefined values`);
+        if (active.has(input))
+            throw new TypeError(`${label} must not contain cycles`);
+        active.add(input);
+        try {
+            if (Object.getPrototypeOf(input) === Set.prototype) {
+                if (Reflect.ownKeys(input).length)
+                    throw new TypeError(`${label} collections must not have custom properties`);
+                if (input.size > 2048)
+                    throw new RangeError(`${label} exceeds configuration limits`);
+                return new Set([...Set.prototype.values.call(input)].map((v) => copy(v, depth + 1)));
+            }
+            if (Object.getPrototypeOf(input) === Map.prototype) {
+                if (Reflect.ownKeys(input).length)
+                    throw new TypeError(`${label} collections must not have custom properties`);
+                if (input.size > 2048)
+                    throw new RangeError(`${label} exceeds configuration limits`);
+                return new Map([...Map.prototype.entries.call(input)].map(([k, v]) => {
+                    if (typeof k !== "string" && typeof k !== "number")
+                        throw new TypeError(`${label} Map keys must be strings or numbers`);
+                    if (typeof k === "string" && unsafe(k))
+                        throw new TypeError(`${label} contains a reserved key`);
+                    return [copy(k, depth + 1), copy(v, depth + 1)];
+                }));
+            }
+            const array = Array.isArray(input) &&
+                Object.getPrototypeOf(input) === Array.prototype;
+            if (!array && !isRecord(input))
+                throw new TypeError(`${label} accepts only plain data, arrays, Sets and Maps`);
+            if (array && input.length > 2048)
+                throw new RangeError(`${label} exceeds configuration limits`);
+            const output = array ? [] : {};
+            for (const key of Reflect.ownKeys(input)) {
+                if (array && key === "length")
+                    continue;
+                if (typeof key !== "string" || unsafe(key))
+                    throw new TypeError(`${label} contains a reserved key`);
+                const descriptor = Object.getOwnPropertyDescriptor(input, key);
+                if (!("value" in descriptor))
+                    throw new TypeError(`${label} must not contain accessors`);
+                if (!descriptor.enumerable)
+                    throw new TypeError(`${label} must contain enumerable data only`);
+                if (array && !/^(0|[1-9]\d*)$/.test(key))
+                    throw new TypeError(`${label} contains an invalid array key`);
+                characters += key.length;
+                if (characters > 65536)
+                    throw new RangeError(`${label} exceeds configuration limits`);
+                Object.defineProperty(output, key, {
+                    value: copy(descriptor.value, depth + 1),
+                    enumerable: true,
+                    writable: true,
+                    configurable: true,
+                });
+            }
+            if (array && input.length !== output.length)
+                throw new TypeError(`${label} must not contain sparse trailing arrays`);
+            return output;
+        }
+        finally {
+            active.delete(input);
+        }
+    };
+    return copy(value, 0);
+}
+export function copyIfcImporterSettings(value) {
+    const result = copyIfcSettings(value, "IFC importer settings");
+    for (const key of Object.keys(result)) {
+        if (["wasm", "webIfc", "worker", "workerUrl", "process", "dispose"].includes(key))
+            throw new TypeError(`IFC importer setting is adapter-owned: ${key}`);
+    }
+    return result;
+}
+/** Apply only existing public data fields, retaining library-owned Set/Map instances. */
+export function applyIfcSettings(target, settings) {
+    const merge = (old, next, path) => {
+        if (old instanceof Set) {
+            if (!(next instanceof Set))
+                throw new TypeError(`${path} requires a Set`);
+            old.clear();
+            for (const value of next)
+                old.add(value);
+            return old;
+        }
+        if (old instanceof Map) {
+            if (!(next instanceof Map))
+                throw new TypeError(`${path} requires a Map`);
+            old.clear();
+            for (const [key, value] of next)
+                old.set(key, value);
+            return old;
+        }
+        if (isRecord(old) && isRecord(next)) {
+            // Loader/geometry bags accept new upstream fields; collections stay library-owned.
+            for (const [key, value] of Object.entries(next)) {
+                if (unsafe(key))
+                    throw new TypeError(`Reserved IFC setting: ${path}.${key}`);
+                const descriptor = Object.getOwnPropertyDescriptor(old, key);
+                if (descriptor &&
+                    (!("value" in descriptor) || typeof descriptor.value === "function"))
+                    throw new TypeError(`Executable IFC setting: ${path}.${key}`);
+                Object.defineProperty(old, key, {
+                    value: descriptor
+                        ? merge(descriptor.value, value, `${path}.${key}`)
+                        : value,
+                    enumerable: true,
+                    writable: true,
+                    configurable: true,
+                });
+            }
+            return old;
+        }
+        if (old !== null &&
+            (typeof old !== typeof next || typeof old === "function"))
+            throw new TypeError(`Incompatible IFC setting: ${path}`);
+        return next;
+    };
+    for (const [key, value] of Object.entries(settings)) {
+        const descriptor = Object.getOwnPropertyDescriptor(target, key);
+        if (unsafe(key) ||
+            !descriptor ||
+            !("value" in descriptor) ||
+            !descriptor.writable ||
+            typeof descriptor.value === "function")
+            throw new TypeError(`Unknown or non-data IFC setting: ${key}`);
+        target[key] = merge(descriptor.value, value, key);
+    }
+}

package/licenses/thatopen-fragments-MIT.txt

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/renderer-3d",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "private": false,
   "type": "module",
   "description": "Standalone 3D model renderer plugin for File Viewer powered by Three.js loaders and OrbitControls.",
@@ -48,26 +48,63 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./ifc": {
+      "types": "./dist/ifc.d.ts",
+      "import": "./dist/ifc.js",
+      "default": "./dist/ifc.js"
+    }
   },
   "files": [
     "dist",
     "README.md",
     "README.en.md",
-    "LICENSE"
+    "LICENSE",
+    "bin",
+    "IFC.md",
+    "licenses"
   ],
   "dependencies": {
-    "@file-viewer/core": "3.0.2",
-    "@file-viewer/geometry-engine": "3.0.2",
-    "three": "^0.185.1"
+    "@file-viewer/core": "3.1.0",
+    "@file-viewer/geometry-engine": "3.1.0",
+    "three": "^0.186.0"
   },
   "devDependencies": {
     "@types/three": "^0.185.4",
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "@thatopen/components": "3.4.8",
+    "@thatopen/fragments": "3.4.7",
+    "web-ifc": "0.0.77",
+    "esbuild": "^0.28.2"
   },
   "license": "Apache-2.0",
+  "bin": {
+    "file-viewer-ifc-assets": "./bin/copy-ifc-assets.mjs"
+  },
+  "peerDependencies": {
+    "@thatopen/components": "3.4.8",
+    "@thatopen/fragments": "3.4.7",
+    "web-ifc": "0.0.77",
+    "esbuild": "^0.28.2"
+  },
+  "peerDependenciesMeta": {
+    "@thatopen/components": {
+      "optional": true
+    },
+    "@thatopen/fragments": {
+      "optional": true
+    },
+    "web-ifc": {
+      "optional": true
+    },
+    "esbuild": {
+      "optional": true
+    }
+  },
   "scripts": {
     "build": "tsc -b tsconfig.json",
-    "type-check": "tsc -b tsconfig.json"
+    "type-check": "tsc -b tsconfig.json",
+    "verify:ifc": "node scripts/verify-ifc-entry.mjs && node --test scripts/ifc-settings.test.mjs",
+    "verify:ifc-browser": "node scripts/verify-ifc-browser.mjs"
   }
 }