@ifc-lite/viewer 1.17.6 → 1.18.0

package/src/sdk/adapters/schedule-adapter.ts

@@ -0,0 +1,73 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Schedule backend adapter — drives the `bim.schedule.*` API by calling
+ * `extractScheduleOnDemand` against the viewer's active (or requested) model.
+ *
+ * Results are cached per-model until the underlying `ifcDataStore` identity
+ * changes, so repeated script / panel queries don't re-parse the STEP source.
+ */
+
+import type { ScheduleBackendMethods, ScheduleExtractionData } from '@ifc-lite/sdk';
+import { extractScheduleOnDemand, type IfcDataStore } from '@ifc-lite/parser';
+import type { StoreApi } from './types.js';
+import { getModelForRef } from './model-compat.js';
+
+const EMPTY_EXTRACTION: ScheduleExtractionData = {
+  workSchedules: [],
+  tasks: [],
+  sequences: [],
+  hasSchedule: false,
+};
+
+/**
+ * Best-effort resolution of the data store to extract from: explicit modelId,
+ * then the legacy single-model store, then the first federated model.
+ */
+function resolveStore(store: StoreApi, modelId?: string): IfcDataStore | null {
+  const state = store.getState();
+  if (modelId) {
+    const model = getModelForRef(state, modelId);
+    return (model?.ifcDataStore as IfcDataStore | undefined) ?? null;
+  }
+  if (state.ifcDataStore) return state.ifcDataStore as IfcDataStore;
+  // Respect the user's active model selection before falling back to the
+  // first federated entry — other namespaces (query, selection, viewer)
+  // follow the same pattern.
+  const activeId = state.activeModelId as string | null | undefined;
+  if (activeId) {
+    const active = getModelForRef(state, activeId);
+    if (active?.ifcDataStore) return active.ifcDataStore as IfcDataStore;
+  }
+  const firstFederated = state.models?.values().next().value;
+  return (firstFederated?.ifcDataStore as IfcDataStore | undefined) ?? null;
+}
+
+export function createScheduleAdapter(store: StoreApi): ScheduleBackendMethods {
+  /** Cache keyed by IfcDataStore identity (WeakMap avoids leaks on model swap). */
+  const cache = new WeakMap<IfcDataStore, ScheduleExtractionData>();
+
+  const extract = (modelId?: string): ScheduleExtractionData => {
+    const ds = resolveStore(store, modelId);
+    if (!ds) return EMPTY_EXTRACTION;
+    const cached = cache.get(ds);
+    if (cached) return cached;
+    try {
+      const result = extractScheduleOnDemand(ds) as ScheduleExtractionData;
+      cache.set(ds, result);
+      return result;
+    } catch (err) {
+      console.warn('[schedule-adapter] extraction failed', err);
+      return EMPTY_EXTRACTION;
+    }
+  };
+
+  return {
+    data: (modelId) => extract(modelId),
+    tasks: (modelId) => extract(modelId).tasks,
+    workSchedules: (modelId) => extract(modelId).workSchedules,
+    sequences: (modelId) => extract(modelId).sequences,
+  };
+}

package/src/sdk/adapters/store-adapter.ts

@@ -0,0 +1,201 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * `bim.store.*` adapter — implements StoreBackendMethods on top of the
+ * viewer's per-model MutablePropertyView. Routes through the same overlay
+ * that bim.mutate.* uses, so document-level edits and property edits stack
+ * coherently into a single export.
+ */
+
+import { StoreEditor } from '@ifc-lite/mutations';
+import {
+  addBeamToStore,
+  addColumnToStore,
+  addDoorToStore,
+  addMemberToStore,
+  addPlateToStore,
+  addRoofToStore,
+  addSlabToStore,
+  addSpaceToStore,
+  addWallToStore,
+  addWindowToStore,
+  resolveSpatialAnchor,
+  type BeamInStoreParams,
+  type ColumnInStoreParams,
+  type DoorInStoreParams,
+  type MemberInStoreParams,
+  type PlateInStoreParams,
+  type RoofInStoreParams,
+  type SlabInStoreParams,
+  type SpaceInStoreParams,
+  type WallInStoreParams,
+  type WindowInStoreParams,
+} from '@ifc-lite/create';
+import type {
+  AddBeamInStoreParams,
+  AddColumnInStoreParams,
+  AddDoorInStoreParams,
+  AddMemberInStoreParams,
+  AddPlateInStoreParams,
+  AddRoofInStoreParams,
+  AddSlabInStoreParams,
+  AddSpaceInStoreParams,
+  AddWallInStoreParams,
+  AddWindowInStoreParams,
+  EntityRef,
+  StoreBackendMethods,
+} from '@ifc-lite/sdk';
+import type { StoreApi } from './types.js';
+import { getModelForRef, LEGACY_MODEL_ID } from './model-compat.js';
+import { getOrCreateMutationView, normalizeMutationModelId } from './mutation-view.js';
+
+export function createStoreAdapter(store: StoreApi): StoreBackendMethods {
+  // One StoreEditor per (modelId, MutablePropertyView) pair. Editors are
+  // cheap, but caching avoids re-scanning the entity index on every call.
+  const editors = new WeakMap<object, StoreEditor>();
+
+  function resolveDataStore(modelId: string) {
+    const state = store.getState();
+    const refModelId = modelId === 'legacy' ? LEGACY_MODEL_ID : modelId;
+    const model = getModelForRef(state, refModelId);
+    return model?.ifcDataStore ?? null;
+  }
+
+  function getEditor(modelId: string): StoreEditor | null {
+    const view = getOrCreateMutationView(store, modelId);
+    if (!view) return null;
+    let editor = editors.get(view);
+    if (editor) return editor;
+
+    const dataStore = resolveDataStore(modelId);
+    if (!dataStore) return null;
+
+    editor = new StoreEditor(dataStore, view);
+    editors.set(view, editor);
+    return editor;
+  }
+
+  return {
+    addEntity(modelId: string, def: { type: string; attributes: unknown[] }): EntityRef {
+      const normalizedId = normalizeMutationModelId(store.getState(), modelId);
+      const editor = getEditor(modelId);
+      if (!editor) {
+        throw new Error(`bim.store.addEntity: no model loaded for id "${modelId}"`);
+      }
+      const ref = editor.addEntity(def.type, def.attributes as Parameters<StoreEditor['addEntity']>[1]);
+      return { modelId: normalizedId, expressId: ref.expressId };
+    },
+    removeEntity(ref: EntityRef): boolean {
+      const editor = getEditor(ref.modelId);
+      if (!editor) return false;
+      return editor.removeEntity(ref.expressId);
+    },
+    setPositionalAttribute(ref: EntityRef, index: number, value: unknown): void {
+      const editor = getEditor(ref.modelId);
+      if (!editor) {
+        throw new Error(`bim.store.setPositionalAttribute: no model loaded for id "${ref.modelId}"`);
+      }
+      editor.setPositionalAttribute(ref.expressId, index, value as Parameters<StoreEditor['setPositionalAttribute']>[2]);
+    },
+    addColumn(modelId: string, storeyExpressId: number, params: AddColumnInStoreParams): EntityRef {
+      const editor = getEditor(modelId);
+      const dataStore = resolveDataStore(modelId);
+      if (!editor || !dataStore) {
+        throw new Error(`bim.store.addColumn: no model loaded for id "${modelId}"`);
+      }
+      const anchor = resolveSpatialAnchor(dataStore, storeyExpressId);
+      const normalizedModelId = normalizeMutationModelId(store.getState(), modelId);
+      const result = addColumnToStore(editor, anchor, params as ColumnInStoreParams);
+      return { modelId: normalizedModelId, expressId: result.columnId };
+    },
+    addWall(modelId: string, storeyExpressId: number, params: AddWallInStoreParams): EntityRef {
+      const editor = getEditor(modelId);
+      const dataStore = resolveDataStore(modelId);
+      if (!editor || !dataStore) {
+        throw new Error(`bim.store.addWall: no model loaded for id "${modelId}"`);
+      }
+      const anchor = resolveSpatialAnchor(dataStore, storeyExpressId);
+      const normalizedModelId = normalizeMutationModelId(store.getState(), modelId);
+      const result = addWallToStore(editor, anchor, params as WallInStoreParams);
+      return { modelId: normalizedModelId, expressId: result.wallId };
+    },
+    addSlab(modelId: string, storeyExpressId: number, params: AddSlabInStoreParams): EntityRef {
+      const editor = getEditor(modelId);
+      const dataStore = resolveDataStore(modelId);
+      if (!editor || !dataStore) {
+        throw new Error(`bim.store.addSlab: no model loaded for id "${modelId}"`);
+      }
+      const anchor = resolveSpatialAnchor(dataStore, storeyExpressId);
+      const normalizedModelId = normalizeMutationModelId(store.getState(), modelId);
+      const result = addSlabToStore(editor, anchor, params as SlabInStoreParams);
+      return { modelId: normalizedModelId, expressId: result.slabId };
+    },
+    addBeam(modelId: string, storeyExpressId: number, params: AddBeamInStoreParams): EntityRef {
+      const editor = getEditor(modelId);
+      const dataStore = resolveDataStore(modelId);
+      if (!editor || !dataStore) {
+        throw new Error(`bim.store.addBeam: no model loaded for id "${modelId}"`);
+      }
+      const anchor = resolveSpatialAnchor(dataStore, storeyExpressId);
+      const normalizedModelId = normalizeMutationModelId(store.getState(), modelId);
+      const result = addBeamToStore(editor, anchor, params as BeamInStoreParams);
+      return { modelId: normalizedModelId, expressId: result.beamId };
+    },
+    addDoor(modelId: string, storeyExpressId: number, params: AddDoorInStoreParams): EntityRef {
+      const editor = getEditor(modelId);
+      const dataStore = resolveDataStore(modelId);
+      if (!editor || !dataStore) throw new Error(`bim.store.addDoor: no model loaded for id "${modelId}"`);
+      const anchor = resolveSpatialAnchor(dataStore, storeyExpressId);
+      const normalizedModelId = normalizeMutationModelId(store.getState(), modelId);
+      const result = addDoorToStore(editor, anchor, params as DoorInStoreParams);
+      return { modelId: normalizedModelId, expressId: result.doorId };
+    },
+    addWindow(modelId: string, storeyExpressId: number, params: AddWindowInStoreParams): EntityRef {
+      const editor = getEditor(modelId);
+      const dataStore = resolveDataStore(modelId);
+      if (!editor || !dataStore) throw new Error(`bim.store.addWindow: no model loaded for id "${modelId}"`);
+      const anchor = resolveSpatialAnchor(dataStore, storeyExpressId);
+      const normalizedModelId = normalizeMutationModelId(store.getState(), modelId);
+      const result = addWindowToStore(editor, anchor, params as WindowInStoreParams);
+      return { modelId: normalizedModelId, expressId: result.windowId };
+    },
+    addSpace(modelId: string, storeyExpressId: number, params: AddSpaceInStoreParams): EntityRef {
+      const editor = getEditor(modelId);
+      const dataStore = resolveDataStore(modelId);
+      if (!editor || !dataStore) throw new Error(`bim.store.addSpace: no model loaded for id "${modelId}"`);
+      const anchor = resolveSpatialAnchor(dataStore, storeyExpressId);
+      const normalizedModelId = normalizeMutationModelId(store.getState(), modelId);
+      const result = addSpaceToStore(editor, anchor, params as SpaceInStoreParams);
+      return { modelId: normalizedModelId, expressId: result.spaceId };
+    },
+    addRoof(modelId: string, storeyExpressId: number, params: AddRoofInStoreParams): EntityRef {
+      const editor = getEditor(modelId);
+      const dataStore = resolveDataStore(modelId);
+      if (!editor || !dataStore) throw new Error(`bim.store.addRoof: no model loaded for id "${modelId}"`);
+      const anchor = resolveSpatialAnchor(dataStore, storeyExpressId);
+      const normalizedModelId = normalizeMutationModelId(store.getState(), modelId);
+      const result = addRoofToStore(editor, anchor, params as RoofInStoreParams);
+      return { modelId: normalizedModelId, expressId: result.roofId };
+    },
+    addPlate(modelId: string, storeyExpressId: number, params: AddPlateInStoreParams): EntityRef {
+      const editor = getEditor(modelId);
+      const dataStore = resolveDataStore(modelId);
+      if (!editor || !dataStore) throw new Error(`bim.store.addPlate: no model loaded for id "${modelId}"`);
+      const anchor = resolveSpatialAnchor(dataStore, storeyExpressId);
+      const normalizedModelId = normalizeMutationModelId(store.getState(), modelId);
+      const result = addPlateToStore(editor, anchor, params as PlateInStoreParams);
+      return { modelId: normalizedModelId, expressId: result.plateId };
+    },
+    addMember(modelId: string, storeyExpressId: number, params: AddMemberInStoreParams): EntityRef {
+      const editor = getEditor(modelId);
+      const dataStore = resolveDataStore(modelId);
+      if (!editor || !dataStore) throw new Error(`bim.store.addMember: no model loaded for id "${modelId}"`);
+      const anchor = resolveSpatialAnchor(dataStore, storeyExpressId);
+      const normalizedModelId = normalizeMutationModelId(store.getState(), modelId);
+      const result = addMemberToStore(editor, anchor, params as MemberInStoreParams);
+      return { modelId: normalizedModelId, expressId: result.memberId };
+    },
+  };
+}

package/src/sdk/adapters/visibility-adapter.ts

@@ -28,6 +28,9 @@ function findDescendantNode(root: SpatialNode, expressId: number): SpatialNode |
  */
 function expandSpatialRef(ref: EntityRef, model: ModelLike): number[] {
   const dataStore = model.ifcDataStore;
+  // Native-metadata-only models have no parsed data store — visibility
+  // expansion isn't possible, fall back to the single ref.
+  if (!dataStore) return [ref.expressId];
   const typeName = dataStore.entities.getTypeName(ref.expressId) || '';
   if (!isSpatialStructureTypeName(typeName) || isSpaceLikeSpatialTypeName(typeName)) {
     return [ref.expressId];

package/src/sdk/local-backend.ts

@@ -18,10 +18,12 @@ import type {
   VisibilityBackendMethods,
   ViewerBackendMethods,
   MutateBackendMethods,
+  StoreBackendMethods,
   SpatialBackendMethods,
   ExportBackendMethods,
   LensBackendMethods,
   FilesBackendMethods,
+  ScheduleBackendMethods,
 } from '@ifc-lite/sdk';
 import type { StoreApi } from './adapters/types.js';
 import { LEGACY_MODEL_ID } from './adapters/model-compat.js';
@@ -31,10 +33,12 @@ import { createSelectionAdapter } from './adapters/selection-adapter.js';
 import { createVisibilityAdapter } from './adapters/visibility-adapter.js';
 import { createViewerAdapter } from './adapters/viewer-adapter.js';
 import { createMutateAdapter } from './adapters/mutate-adapter.js';
+import { createStoreAdapter } from './adapters/store-adapter.js';
 import { createSpatialAdapter } from './adapters/spatial-adapter.js';
 import { createLensAdapter } from './adapters/lens-adapter.js';
 import { createExportAdapter } from './adapters/export-adapter.js';
 import { createFilesAdapter } from './adapters/files-adapter.js';
+import { createScheduleAdapter } from './adapters/schedule-adapter.js';
 
 export class LocalBackend implements BimBackend {
   readonly model: ModelBackendMethods;
@@ -43,38 +47,42 @@ export class LocalBackend implements BimBackend {
   readonly visibility: VisibilityBackendMethods;
   readonly viewer: ViewerBackendMethods;
   readonly mutate: MutateBackendMethods;
+  readonly store: StoreBackendMethods;
   readonly spatial: SpatialBackendMethods;
   readonly export: ExportBackendMethods;
   readonly lens: LensBackendMethods;
   readonly files: FilesBackendMethods;
+  readonly schedule: ScheduleBackendMethods;
 
-  private store: StoreApi;
+  private storeApi: StoreApi;
 
   constructor(store: StoreApi) {
-    this.store = store;
+    this.storeApi = store;
     this.model = createModelAdapter(store);
     this.query = createQueryAdapter(store);
     this.selection = createSelectionAdapter(store);
     this.visibility = createVisibilityAdapter(store);
     this.viewer = createViewerAdapter(store);
     this.mutate = createMutateAdapter(store);
+    this.store = createStoreAdapter(store);
     this.spatial = createSpatialAdapter(store);
     this.lens = createLensAdapter(store);
     this.export = createExportAdapter(store);
     this.files = createFilesAdapter(store);
+    this.schedule = createScheduleAdapter(store);
   }
 
   subscribe(event: BimEventType, handler: (data: unknown) => void): () => void {
     switch (event) {
       case 'selection:changed':
-        return this.store.subscribe((state, prev) => {
+        return this.storeApi.subscribe((state, prev) => {
           if (state.selectedEntities !== prev.selectedEntities) {
             handler({ refs: state.selectedEntities ?? [] });
           }
         });
 
       case 'model:loaded':
-        return this.store.subscribe((state, prev) => {
+        return this.storeApi.subscribe((state, prev) => {
           if (state.models.size > prev.models.size) {
             for (const [id, model] of state.models) {
               if (!prev.models.has(id)) {
@@ -108,7 +116,7 @@ export class LocalBackend implements BimBackend {
         });
 
       case 'model:removed':
-        return this.store.subscribe((state, prev) => {
+        return this.storeApi.subscribe((state, prev) => {
           if (state.models.size < prev.models.size) {
             for (const id of prev.models.keys()) {
               if (!state.models.has(id)) {
@@ -119,7 +127,7 @@ export class LocalBackend implements BimBackend {
         });
 
       case 'visibility:changed':
-        return this.store.subscribe((state, prev) => {
+        return this.storeApi.subscribe((state, prev) => {
           if (
             state.hiddenEntities !== prev.hiddenEntities ||
             state.isolatedEntities !== prev.isolatedEntities ||
@@ -130,14 +138,14 @@ export class LocalBackend implements BimBackend {
         });
 
       case 'mutation:changed':
-        return this.store.subscribe((state, prev) => {
+        return this.storeApi.subscribe((state, prev) => {
           if (state.mutationVersion !== prev.mutationVersion) {
             handler({});
           }
         });
 
       case 'lens:changed':
-        return this.store.subscribe((state, prev) => {
+        return this.storeApi.subscribe((state, prev) => {
           if (state.activeLensId !== prev.activeLensId) {
             handler({ lensId: state.activeLensId });
           }

package/src/services/desktop-export.ts

@@ -10,7 +10,9 @@ import { readNativeFile } from '@/services/file-dialog';
 const exportHydrationByModel = new Map<string, Promise<IfcDataStore | null>>();
 
 function isDesktopRuntime(): boolean {
-  const win = globalThis as Window & { __TAURI_INTERNALS__?: { invoke?: unknown } };
+  // `globalThis` and `Window` aren't structurally compatible per TS, so
+  // route through `unknown` first — the cast is intentional.
+  const win = globalThis as unknown as Window & { __TAURI_INTERNALS__?: { invoke?: unknown } };
   return typeof win.__TAURI_INTERNALS__?.invoke === 'function';
 }
 

package/src/services/desktop-native-metadata.ts

@@ -6,10 +6,41 @@ import type {
   NativeMetadataEntityDetails,
   NativeMetadataEntitySummary,
   NativeMetadataSnapshot,
+  NativeMetadataSpatialNode,
 } from '@/store/types';
-import type { MetadataBootstrapPayload } from '@ifc-lite/geometry';
+import type {
+  MetadataBootstrapPayload,
+  MetadataBootstrapEntitySummary,
+  MetadataBootstrapSpatialNode,
+} from '@ifc-lite/geometry';
 import { getNativeModelSnapshot, setNativeModelSnapshot } from './desktop-cache';
 
+function bootstrapKindToNative(kind: string): 'spatial' | 'element' {
+  return kind === 'spatial' ? 'spatial' : 'element';
+}
+
+function summaryFromBootstrap(node: MetadataBootstrapEntitySummary): NativeMetadataEntitySummary {
+  return {
+    expressId: node.expressId,
+    type: node.typeName,
+    name: node.name,
+    globalId: node.globalId ?? null,
+    kind: bootstrapKindToNative(node.kind),
+    hasChildren: node.hasChildren,
+    elementCount: node.elementCount,
+    elevation: node.elevation ?? null,
+  };
+}
+
+function spatialNodeFromBootstrap(node: MetadataBootstrapSpatialNode | null): NativeMetadataSpatialNode | null {
+  if (!node) return null;
+  return {
+    ...summaryFromBootstrap(node),
+    children: node.children.map((c) => spatialNodeFromBootstrap(c)).filter((n): n is NativeMetadataSpatialNode => n !== null),
+    elements: node.elements.map(summaryFromBootstrap),
+  };
+}
+
 type InvokeFn = <T>(cmd: string, args?: Record<string, unknown>) => Promise<T>;
 
 async function getInvoke(): Promise<InvokeFn> {
@@ -21,13 +52,6 @@ async function getInvoke(): Promise<InvokeFn> {
   return core.invoke as InvokeFn;
 }
 
-interface NativeMetadataBootstrapPayload {
-  cacheKey: string;
-  schemaVersion: string;
-  entityCount: number;
-  spatialTree: NativeMetadataSnapshot['spatialTree'];
-}
-
 function toSchemaVersion(schemaVersion: string): NativeMetadataSnapshot['schemaVersion'] {
   if (schemaVersion === 'IFC4X3' || schemaVersion === 'IFC4' || schemaVersion === 'IFC5') {
     return schemaVersion;
@@ -45,24 +69,23 @@ export function nativeMetadataSnapshotFromBootstrap(
     filePath: path,
     schemaVersion: toSchemaVersion(payload.schemaVersion),
     entityCount: payload.entityCount,
-    spatialTree: payload.spatialTree ?? null,
+    spatialTree: spatialNodeFromBootstrap(payload.spatialTree ?? null),
   };
 }
 
 export async function bootstrapNativeMetadata(path: string, cacheKey: string): Promise<NativeMetadataSnapshot> {
   const invoke = await getInvoke();
-  const result = await invoke<NativeMetadataBootstrapPayload>('bootstrap_native_metadata', {
+  // The Tauri command returns a bootstrap-shaped payload (typeName /
+  // kind unfolded). Route through the shared `nativeMetadataSnapshotFromBootstrap`
+  // helper so both constructors apply the same `spatialNodeFromBootstrap`
+  // normalization — without this the `from cached snapshot` and
+  // `bootstrap fresh` paths produce subtly different shapes and the
+  // property panel reads break for the freshly-bootstrapped case.
+  const result = await invoke<MetadataBootstrapPayload>('bootstrap_native_metadata', {
     path,
     cacheKey,
   });
-  return {
-    mode: 'desktop-lazy',
-    cacheKey: result.cacheKey,
-    filePath: path,
-    schemaVersion: toSchemaVersion(result.schemaVersion),
-    entityCount: result.entityCount,
-    spatialTree: result.spatialTree ?? null,
-  };
+  return nativeMetadataSnapshotFromBootstrap(path, result);
 }
 
 export async function restoreNativeMetadataSnapshot(cacheKey: string): Promise<NativeMetadataSnapshot | null> {

package/src/services/file-dialog.ts

@@ -139,7 +139,10 @@ export async function openGenericFileDialog(options: GenericFileDialogOptions =
     const bytes = await readNativeFile(normalizedPath);
     const pathSegments = normalizedPath.split(/[\\/]/);
     const name = pathSegments[pathSegments.length - 1] || 'document';
-    return new File([bytes], name, { type: 'application/octet-stream' });
+    // Slice to a fresh ArrayBuffer view — TS5+ narrows `Uint8Array` to
+    // `Uint8Array<ArrayBufferLike>` which `BlobPart` doesn't accept.
+    const blobPart = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength).slice();
+    return new File([blobPart], name, { type: 'application/octet-stream' });
   } catch (error) {
     console.warn('[FileDialog] Failed to open generic native file dialog:', error);
     return null;

package/src/services/tauri-modules.d.ts

@@ -17,9 +17,34 @@ declare module '@tauri-apps/plugin-fs' {
   export function exists(path: string): Promise<boolean>;
   export function remove(path: string): Promise<void>;
   export function readDir(path: string): Promise<Array<{ name: string | null }>>;
+  export function stat(path: string): Promise<{ size: number; mtime?: number | null }>;
 }
 
 declare module '@tauri-apps/api/path' {
   export function appDataDir(): Promise<string>;
   export function join(...paths: string[]): Promise<string>;
 }
+
+declare module '@tauri-apps/api/core' {
+  /**
+   * Tauri's IPC entry point. Generic by command name.
+   */
+  export function invoke<T = unknown>(cmd: string, args?: Record<string, unknown>): Promise<T>;
+}
+
+declare module '@tauri-apps/plugin-dialog' {
+  export interface OpenDialogOptions {
+    title?: string;
+    multiple?: boolean;
+    directory?: boolean;
+    defaultPath?: string;
+    filters?: Array<{ name: string; extensions: string[] }>;
+  }
+  export interface SaveDialogOptions {
+    title?: string;
+    defaultPath?: string;
+    filters?: Array<{ name: string; extensions: string[] }>;
+  }
+  export function open(options?: OpenDialogOptions): Promise<string | string[] | null>;
+  export function save(options?: SaveDialogOptions): Promise<string | null>;
+}

package/src/store/basketVisibleSet.ts

@@ -341,6 +341,9 @@ function collectVisibleCandidates(state: ViewerStateSnapshot): VisibleCandidate[
   if (state.models.size > 0) {
     for (const [modelId, model] of state.models) {
       if (!model.visible) continue;
+      // Native-metadata models have no parsed geometry result. Skip them
+      // — they can't contribute mesh-level visible candidates.
+      if (!model.geometryResult) continue;
       const offset = model.idOffset ?? 0;
       for (const mesh of model.geometryResult.meshes) {
         if (!matchesTypeVisibility(mesh.ifcType, state.typeVisibility)) continue;

package/src/store/globalId.ts

@@ -4,7 +4,10 @@
 
 import type { EntityRef, FederatedModel } from './types.js';
 
-type ForwardModelMapLike = ReadonlyMap<string, { idOffset?: number }>;
+/** Shape accepted by `toGlobalIdFromModels` — re-export it so consumers can
+ *  drop the `as unknown as Map<...>` cast when threading the store's
+ *  federated `models` map through downstream helpers. */
+export type ForwardModelMapLike = ReadonlyMap<string, { idOffset?: number }>;
 type ReverseModelMapLike = ReadonlyMap<string, Pick<FederatedModel, 'idOffset' | 'maxExpressId'>>;
 
 /**