TypeScript API Reference¶

API documentation for the published TypeScript packages.

ifc-lite ships its public npm packages under the @ifc-lite/* scope, plus the create-ifc-lite scaffolder. This page lists all of them, with API detail for the core packages. Exact type signatures live in each package's src/index.ts and shipped .d.ts files.

Package Index¶

Package	Description
`@ifc-lite/parser`	IFC/STEP parser for IFC-Lite
`@ifc-lite/geometry`	Geometry processing bridge for IFC-Lite - exact-arithmetic CSG, streamed across workers
`@ifc-lite/data`	Columnar data structures for IFC-Lite
`@ifc-lite/query`	Query system for IFC-Lite
`@ifc-lite/spatial`	Spatial indexing for IFC-Lite
`@ifc-lite/renderer`	WebGPU renderer for IFC-Lite
`@ifc-lite/export`	Export formats for IFC-Lite
`@ifc-lite/mutations`	Mutation tracking and property editing for IFC-Lite
`@ifc-lite/create`	IFC creation from scratch — walls, slabs, beams, columns, stairs, roofs with geometry, properties and quantities
`@ifc-lite/bcf`	BIM Collaboration Format (BCF) support for IFC-Lite
`@ifc-lite/ids`	IDS (Information Delivery Specification) support for IFC-Lite
`@ifc-lite/drawing-2d`	2D architectural drawing generation from IFC models - section cuts, floor plans, and elevations
`@ifc-lite/clash`	Clash detection for IFC-Lite — representation-agnostic core engine + source adapters
`@ifc-lite/diff`	Headless model-diff engine for IFC-Lite — classifies entities as added/modified/deleted/unchanged across two revisions, with separable data vs geometry scope.
`@ifc-lite/lens`	Rule-based 3D filtering and colorization for IFC models
`@ifc-lite/lists`	Configurable property tables and schedules from IFC data for IFC-Lite
`@ifc-lite/ifcx`	IFC5 (IFCX) parser for IFC-Lite
`@ifc-lite/encoding`	IFC string encoding/decoding and property value parsing for IFC-Lite
`@ifc-lite/cache`	Binary cache format for IFC-Lite - fast model loading
`@ifc-lite/pointcloud`	Point cloud decoders and types for IFC-Lite
`@ifc-lite/solar`	Solar position, sunrise/sunset and 3D sun-path geometry for IFC-Lite
`@ifc-lite/sdk`	Scripting SDK for ifc-lite — the bim.* API for BIM automation
`@ifc-lite/sandbox`	QuickJS-in-WASM sandboxed script execution for ifc-lite
`@ifc-lite/extensions`	Extension manifest, capability grammar, and slot registry for ifc-lite user customization
`@ifc-lite/mcp`	Model Context Protocol server for ifc-lite — agent-native BIM via MCP (stdio + Streamable HTTP)
`@ifc-lite/cli`	CLI toolkit for IFC files — query, validate, export, create, and script BIM data
`@ifc-lite/collab`	Real-time collaborative BIM via CRDT on IFCX
`@ifc-lite/collab-server`	Reference websocket sync server for @ifc-lite/collab
`@ifc-lite/embed-sdk`	SDK for embedding the IFC-Lite 3D viewer in any web page via iframe
`@ifc-lite/embed-protocol`	Shared postMessage protocol types for ifc-lite embed viewer and SDK
`@ifc-lite/viewer-core`	Interactive 3D viewer for IFC models — WebGL 2 browser viewer with REST API
`@ifc-lite/server-client`	TypeScript client SDK for IFC-Lite Server
`@ifc-lite/server-bin`	Pre-built IFC-Lite server binary - run without Docker or Rust
`@ifc-lite/wasm`	WebAssembly bindings for IFC-Lite
`@ifc-lite/codegen`	TypeScript code generator from IFC EXPRESS schemas
`create-ifc-lite`	Create IFC-Lite projects with one command
`@ifc-lite/ai`	Provider-independent AI request core: transport contract, typed outcomes, root budgets, usage receipts and bounded JSON output parsing
`@ifc-lite/bcf-api`	BCF API (OpenCDE) REST client for connecting to BCF servers
`@ifc-lite/charts`	Headless chart data binding for IFC-Lite: aggregate model rows into buckets that keep their element ids, build ECharts options, render SVG
`@ifc-lite/documents-api`	OpenCDE Documents API 1.0 client: select, download, query and upload documents against a buildingSMART Documents API server
`@ifc-lite/flow`	Keyed-data graph runtime for BIM workflows: typed ports, item/list/group lifting, memoised evaluation, and element tracking for re-runnable graphs
`@ifc-lite/flow-nodes`	Standard node library for @ifc-lite/flow over the ifc-lite SDK: model reads and writes, tables, viewer, and a sandboxed Script node
`@ifc-lite/load-trace`	Dependency-free load-trace spans: performance.measure plus a per-load, cross-thread span tree with worker clock alignment and Chrome-trace export
`@ifc-lite/merge`	Three-way merge engine for IFCX layers — MergePlan with auto-merged ops and explicit conflict records, merge-layer emission, rebase, and revert.
`@ifc-lite/oauth-pkce`	Browser OAuth 2.0 Authorization Code + PKCE flow, shared by ifc-lite's file-source providers
`@ifc-lite/opencde-foundation`	buildingSMART OpenCDE Foundation API client: version discovery, auth discovery, OAuth2 flows and the shared HTTP client used by every OpenCDE service client
`@ifc-lite/plugin-api`	Dependency-free type surface for ifc-lite file-source plugins
`@ifc-lite/regex-guard`	A shared, dependency-free guard against catastrophic-backtracking (ReDoS) regex patterns compiled from untrusted input
`@ifc-lite/rules`	Filter-rule vocabulary, evaluator and .rules.json information-validation engine for IFC-Lite
`@ifc-lite/semantic`	Portable semantic datasets, profiles, validation and IFC identity resolution
`@ifc-lite/source-autodesk`	Autodesk Forma and Data Exchange cloud-source provider for ifc-lite
`@ifc-lite/source-dalux`	Dalux Build (Box) file-source provider for ifc-lite
`@ifc-lite/source-dropbox`	Dropbox file-source provider for ifc-lite
`@ifc-lite/source-msgraph`	Microsoft Graph file-source provider for the signed-in user's own OneDrive
`@ifc-lite/wasm-lifecycle`	Shared WASM engine load-retry classification and cross-realm panic-forwarding, used by @ifc-lite/geometry and @ifc-lite/parser

@ifc-lite/parser¶

IFC/STEP parser producing a columnar IfcDataStore.

IfcParser¶

class IfcParser {
  // Columnar parse (recommended). Accepts ArrayBuffer or SharedArrayBuffer.
  parseColumnar(buffer: ArrayBuffer | SharedArrayBuffer, options?: ParseOptions): Promise<IfcDataStore>;

  // Legacy eager parse into a ParseResult (deprecated, kept as a compatibility adapter)
  parse(buffer: ArrayBuffer, options?: ParseOptions): Promise<ParseResult>;
}

ParseOptions¶

interface ParseOptions {
  onProgress?: (progress: { phase: string; percent: number }) => void;
  onDiagnostic?: (message: string) => void;
  // Optional IfcAPI instance for WASM-accelerated entity scanning
  wasmApi?: WasmScanApi;
  // Yield budget for large incremental parses
  yieldIntervalMs?: number;
  // Defer indexing of individual property/quantity atoms
  deferPropertyAtomIndex?: boolean;
  // Skip worker-based entity scanning and stay in-process
  disableWorkerScan?: boolean;
  // Called when the spatial hierarchy is ready, before property parsing completes
  onSpatialReady?: (partialStore: IfcDataStore) => void;
  // Pre-built entity index from another worker (e.g. the geometry pre-pass)
  preScannedEntityIndex?: PreScannedEntityIndex;
}

parseAuto¶

Auto-detects the file format (IFC/STEP vs IFCX/JSON, with transparent .ifcZIP unwrap) and parses accordingly.

import { parseAuto } from '@ifc-lite/parser';

const result = await parseAuto(buffer);
if (result.format === 'ifc') {
  const store = result.data;        // IfcDataStore
} else {
  const ifcx = result.data;         // IfcxParseResult
  const meshes = result.meshes;     // pre-extracted meshes
}

IfcDataStore¶

Result of parseColumnar(). Key fields (see src/columnar-parser.ts for the full interface):

interface IfcDataStore extends IfcStoreBase {
  source: Uint8Array;
  entityIndex: { byId: EntityByIdIndex; byType: Map<string, number[]> };

  strings: StringTable;
  entities: EntityTable;
  properties: PropertyTable;
  quantities: QuantityTable;
  relationships: RelationshipGraph;

  parseTime: number;
  // Length unit scale to metres (e.g. 0.001 for mm files)
  lengthUnitScale?: number;

  // On-demand lookup maps: entityId -> related expressIds
  onDemandPropertyMap?: Map<number, number[]>;
  onDemandQuantityMap?: Map<number, number[]>;
  onDemandClassificationMap?: Map<number, number[]>;
  onDemandMaterialMap?: Map<number, number>;
  onDemandDocumentMap?: Map<number, number[]>;
}

On-Demand Extraction¶

Properties, quantities, and attributes are extracted lazily for memory efficiency.

import {
  extractPropertiesOnDemand,
  extractQuantitiesOnDemand,
  extractEntityAttributesOnDemand,
} from '@ifc-lite/parser';

// Property sets for one entity
const psets = extractPropertiesOnDemand(store, expressId);

// Quantity sets for one entity
const qsets = extractQuantitiesOnDemand(store, expressId);

// Root attributes for one entity
const attrs = extractEntityAttributesOnDemand(store, expressId);
// { globalId, name, description, objectType, tag }

Many more on-demand extractors are exported (classifications, materials, documents, relationships, group members, georeferencing, type properties, schedules); see packages/parser/src/index.ts.

secondsToIso8601Duration(seconds: number): string | undefined is a new export: it renders a signed number of seconds as an ISO 8601 duration string suitable for IfcDuration (86400 -> "P1D", -172800 -> "-P2D"), preferring the coarsest whole unit that divides cleanly and falling back to a decimal-seconds form for fractional values. It returns undefined for non-finite input (NaN, ±Infinity) rather than fabricating "PT0S". parseIso8601Duration(value: string | undefined): number | undefined is its decode counterpart — already public before this change — and the two form a round trip: parseIso8601Duration(secondsToIso8601Duration(s)) === s for every finite, representable s. Both also accept/emit the ISO 8601-2 signed extension (-P2D) to carry IFC schedule lead time; see docs/guide/schedule-import.md.

Other exports include the STEP scanning/tokenizing building blocks (StepTokenizer, EntityExtractor, scanIfcEntities, CompactEntityIndex), unit extraction (extractProjectUnits, ProjectUnits), the STEP serializer helpers (generateStepFile, toStepLine, serializeValue), the generated IFC schema registry (SCHEMA_REGISTRY, getAttributeNames), and re-exported IFCX parsing from @ifc-lite/ifcx.

@ifc-lite/geometry¶

Bridge from IFC bytes to per-element triangle meshes, running the Rust kernel via WASM (or a native backend when available).

GeometryProcessor¶

class GeometryProcessor {
  constructor(options?: GeometryProcessorOptions);

  // Initialize WASM (required before processing)
  init(): Promise<void>;

  // Process IFC buffer and extract geometry (whole-file)
  process(buffer: Uint8Array, entityIndex?: Map<number, any>): Promise<GeometryResult>;

  // Stream geometry for large files (async generator of streaming events)
  processStreaming(/* buffer + streaming options; see the .d.ts */): AsyncGenerator<StreamingGeometryEvent>;

  // Authored IfcSweptDiskSolid curves and derived centreline measurements
  extractSweptDiskDescriptions(buffer: Uint8Array, ids?: Uint32Array): SweptDiskDescriptions | null;

  // Rust-side exporters surfaced on the processor
  exportGlb(buffer, includeMetadata?, hidden?, isolated?, hiddenTypesCsv?, lit?): Uint8Array | null;
  exportGlbFromMeshes(meshes: MeshData[], includeMetadata?, lit?): Uint8Array | null;
  exportObj(/* ... */): Uint8Array | null;
  exportKmzFromMeshes(
    meshes: MeshData[],
    latitude: number,
    longitude: number,
    altitude: number,
    xAxisAbscissa?: number,
    xAxisOrdinate?: number,
    name?: string,
    altitudeMode?: 'clampToGround' | 'absolute',
  ): Uint8Array | null;
  exportCsv(/* buffer, mode: 'entities'|'properties'|'quantities'|'spatial', ... */): Uint8Array | null;
  exportJson(/* ... */): Uint8Array | null;
  exportJsonld(/* ... */): Uint8Array | null;
  exportStep(/* ... */): Uint8Array | null;
  exportIfcx(buffer, onlyKnownProperties?, pretty?): Uint8Array | null;
  exportMerged(buffers: Uint8Array[], schema?): Uint8Array | null;
  exportHbjson(buffer, name): Uint8Array | null;
}

extractSweptDiskDescriptions returns null until init() completes. Omit ids to inspect every product, or pass an empty Uint32Array to select none. The result is keyed by product STEP ID and contains ordered exact line and arc segments, the disk Radius and InnerRadius, and per-segment and total centreline lengths in metres. Arc bend_angle is an unsigned radian measure; the directrix's signed sweep_angle keeps its travel direction. Coordinates are double-precision, absolute IFC Z-up world metres. source_modified marks a CSG operand whose final visible shape may differ. Unsupported records have an empty directrix and directrix_metrics: null. diagnostics reports malformed representation walks. The returned data is an analytic description, not a render overlay or a mesh.

GeometryResult and MeshData¶

interface GeometryResult {
  meshes: MeshData[];
  pointClouds?: PointCloudAsset[];
  totalTriangles: number;
  totalVertices: number;
  coordinateInfo: CoordinateInfo;
}

interface MeshData {
  expressId: number;
  ifcType?: string;
  modelIndex?: number;
  positions: Float32Array;  // [x,y,z, ...]
  normals: Float32Array;    // [nx,ny,nz, ...]
  indices: Uint32Array;     // triangle indices (winding is unreliable; meshes are double-sided)
  color: [number, number, number, number];
  // ... local-frame origin, geometry class, texture fields; see src/types.ts
}

CoordinateInfo carries the RTC/origin-shift information (originShift, wasmRtcOffset, hasLargeCoordinates, buildingRotation, unit scale) needed to place meshes in world space.

@ifc-lite/data¶

Columnar data structures shared by the parser and downstream packages.

Key exports:

// Deduplicated string storage
class StringTable { get(index: number): string; intern(value: string): number; /* ... */ }

// Columnar tables: built once, read everywhere
class EntityTableBuilder { /* build(): EntityTable */ }
class PropertyTableBuilder { /* build(): PropertyTable */ }
class QuantityTableBuilder { /* build(): QuantityTable */ }

// CSR-format relationship graph
class RelationshipGraphBuilder { /* build(): RelationshipGraph */ }

Each table type also has fromColumns / toColumns helpers for structured-clone transfer across workers (entityTableFromColumns, propertyTableToColumns, ...). Shared enums and types live here too: IfcTypeEnum, PropertyValueType, QuantityType, RelationshipType, SpatialHierarchy, IfcStoreBase, the generated entity-name lists (ENTITIES_IFC2X3 / IFC4 / IFC4X3), plus utilities like safeUtf8Decode and createLogger.

countEffectiveEntityTypes(store, overlay, sourceIds?) returns uppercase IFC class counts after queued creates, deletes, and retypes. Pass the same store and overlay used by iterateEffectiveEntities; supply sourceIds for a columnar source without STEP type buckets, such as IFCX.

IFC_DATA_TYPES sits alongside those entity lists: the raw, read-only table of EXPRESS defined types (IfcLengthMeasure, IfcBoolean, IfcTextAlignment, ...) across all three schemas. The upstream data the ENTITIES_* lists come from carries defined types as entity rows, so any synchronous consumer deciding "is this name a real class?" has to subtract this table — that is what @ifc-lite/parser's isKnownType does. Prefer the async findDataType(version, name) when you only need a single lookup and are not inside a synchronous guard.

@ifc-lite/parser exports two type predicates, and they answer different questions:

predicate	question	`IfcWall`	`IfcProduct`	`IfcLengthMeasure`
`isKnownType`	is this a real EXPRESS entity name?	`true`	`true`	`false`
`isInstantiable`	may I author an entity of this class?	`true`	`false`	`false`

IfcProduct is the distinction: it is a real class, so isKnownType accepts it, but it is an EXPRESS ABSTRACT SUPERTYPE and cannot legally exist as an instance. Roughly 123 classes are abstract in this way. Use isInstantiable for anything that creates entities (bim.store.addEntity, the MCP entity_create tool); isKnownType is for recognising a name you have read, not for authoring. Both resolve across the union of the bundled schemas, so IFC4X3-only classes such as IfcSignal behave the same under either.

@ifc-lite/query¶

IfcQuery¶

Fluent query builder over an IfcDataStore.

class IfcQuery {
  constructor(store: IfcDataStore);

  // Type shortcuts -> EntityQuery
  walls(): EntityQuery;      // IfcWall + IfcWallStandardCase
  doors(): EntityQuery;
  windows(): EntityQuery;
  slabs(): EntityQuery;
  columns(): EntityQuery;
  beams(): EntityQuery;
  spaces(): EntityQuery;

  // Type filter (variadic), everything, and by id
  ofType(...types: string[]): EntityQuery;
  all(): EntityQuery;
  byId(expressId: number): EntityQuery;

  // Spatial
  onStorey(storeyId: number): EntityQuery;
  inBounds(aabb: AABB): EntityQuery;
  raycast(origin: [number, number, number], direction: [number, number, number]): number[];

  // Graph navigation
  entity(expressId: number): EntityNode;
  get storeys(): EntityNode[];
  get project(): EntityNode | null;

  // SQL (DuckDB-WASM, lazily initialized on first call)
  sql(query: string): Promise<SQLResult>;
}

EntityQuery¶

class EntityQuery {
  whereProperty(psetName: string, propName: string, operator: ComparisonOperator, value: unknown): this;

  limit(count: number): this;
  offset(count: number): this;
  includeGeometry(): this;
  includeProperties(): this;
  includeQuantities(): this;
  includeAll(): this;

  // Terminals
  execute(): QueryResultEntity[];
  ids(): Promise<number[]>;
  count(): Promise<number>;
  first(): Promise<QueryResultEntity | null>;
}

EntityNode¶

Single-entity graph navigation, from IfcQuery.entity(id) or IfcQuery.storeys.

class EntityNode {
  // Spatial containment
  contains(): EntityNode[];
  containedIn(): EntityNode | null;
  storey(): EntityNode | null;
  building(): EntityNode | null;

  // Aggregation and typing
  decomposes(): EntityNode[];
  decomposedBy(): EntityNode | null;
  definingType(): EntityNode | null;
  instances(): EntityNode[];

  // Voids and fills
  voids(): EntityNode[];
  filledBy(): EntityNode[];

  // Data
  properties(): PropertySet[];
  quantities(): QuantitySet[];
  allAttributes(): Array<{ name: string; value: string | number | boolean }>;

  // Generic traversal
  traverse(relType: RelationshipType, depth: number, direction?: 'forward' | 'inverse'): EntityNode[];
}

@ifc-lite/spatial¶

Spatial indexing utilities for geometry queries and frustum culling.

buildSpatialIndex¶

import { buildSpatialIndex, buildSpatialIndexAsync } from '@ifc-lite/spatial';
import type { MeshData } from '@ifc-lite/geometry';

function buildSpatialIndex(meshes: MeshData[]): SpatialIndex;

Example:

import { GeometryProcessor } from '@ifc-lite/geometry';
import { buildSpatialIndex } from '@ifc-lite/spatial';
import { Renderer } from '@ifc-lite/renderer';

const geometry = new GeometryProcessor();
await geometry.init();
const result = await geometry.process(new Uint8Array(buffer));

// Build spatial index for frustum culling
const spatialIndex = buildSpatialIndex(result.meshes);

const renderer = new Renderer(canvas);
await renderer.init();
renderer.loadGeometry(result);

// Render with frustum culling
renderer.render({
  enableFrustumCulling: true,
  spatialIndex
});

SpatialIndex¶

interface SpatialIndex {
  // Query AABB: expressIds of meshes intersecting bounds
  queryAABB(bounds: AABB): number[];

  // Raycast: expressIds of meshes hit by ray
  raycast(origin: [number, number, number], direction: [number, number, number]): number[];

  // Query frustum: expressIds of meshes visible in frustum
  queryFrustum(frustum: Frustum): number[];
}

The underlying BVH class, AABBUtils, and FrustumUtils are also exported.

@ifc-lite/renderer¶

Renderer¶

WebGPU-based 3D renderer.

class Renderer {
  constructor(canvas: HTMLCanvasElement);

  // Initialize WebGPU
  init(): Promise<void>;

  // Rebuild a lost GPU device and reconstructable scene resources in place.
  // Transient GPU-only layers that were cleared are named in `omissions`.
  recoverDevice(): Promise<DeviceRecoveryResult>;

  // Load geometry (main entry point for IFC geometry). Returns a typed
  // outcome instead of throwing when the GPU device is lost (#4885) — check
  // `.ok` before assuming the geometry was uploaded.
  loadGeometry(geometry: GeometryResult | MeshData[]): GpuUploadOutcome<void>;

  // Add meshes incrementally (for streaming). Same lost-device contract as
  // loadGeometry.
  addMeshes(meshes: MeshData[], isStreaming?: boolean): GpuUploadOutcome<void>;

  // Rendering
  render(options?: RenderOptions): void;

  // Camera controls
  fitToView(): void;
  getCamera(): Camera;

  // Selection (GPU picking)
  pick(x: number, y: number, options?: PickOptions): Promise<PickResult | null>;

  // Scene access
  // Narrower than the package-internal `Scene` class on purpose: `SceneContents`
  // names the scene members callers actually use, and widening it is a major bump.
  getScene(): SceneContents;
  getPipeline(): RenderPipeline | null;
  getGPUDevice(): GPUDevice | null;
  isReady(): boolean;

  // Resize handling
  resize(width: number, height: number): void;
}

Visibility is passed via render() options (hiddenIds, isolatedIds); frustum culling via enableFrustumCulling plus a spatialIndex from @ifc-lite/spatial.

DeviceRecoveryResult is a discriminated union. Success carries an omissions array (point-clouds, reference-images, or transient overlay kinds); failure carries a stable reason, including cpu-geometry-released, scene-not-settled, cold-restore-failed, device-init-failed, and scene-restore-failed. Recovery preserves the renderer and camera rather than remounting the viewport.

PickResult carries expressId (the product) plus the optional modelIndex, worldXYZ and geometryItemId. The last is the IfcRepresentationItem the clicked surface was built from, and the key is absent, never 0, where the renderer has no item identity for that hit. See Which representation item was picked.

Other exports: Camera, Picker, Raycaster, SnapDetector, BVH, RaycastEngine, SectionPlaneRenderer, PointCloudRenderer, FederationRegistry (multi-model id ranges), and the section-cap / plane-basis helpers.

Renderer.hasActiveClipping() reports section, terrain or box clipping from the last rendered frame. raycastScene() applies the same clip state and its Intersection includes modelIndex, plus geometryItemId and sourceTriangleIndex when the hit has unambiguous representation-item and canonical evaluated-surface provenance. appearanceSourceTriangle(mesh, triangleIndex) performs that strict provenance lookup directly and returns undefined for absent, stale or mixed-corner identity.

An appearance preview may carry an AppearancePartition whose sourceGeometryItemId and triangleCount name one canonical evaluated surface. Its before and after parts use side-local partId values and canonical triangle ordinals, allowing repeated representation-item ids across streaming fragments. validateAppearancePartition(partition, before, after) verifies bounded, disjoint and complete provenance plus exact ownership, placement and corner geometry; invertAppearancePartition(partition) describes the reverse transition for Undo.

Scene and Section2DOverlayRenderer are package-internal from 2.0: reach the scene through getScene(): SceneContents, and the 3D line overlays through Renderer.setLineOverlay. PickingManager is package-internal from 2.0 as well: its constructor takes the now-internal Scene, so an exported class nobody could construct would have been worse than no export. Pick through Renderer.pick / Renderer.pickRect.

@ifc-lite/export¶

Client-side exporters that operate on a parsed IfcDataStore.

StepExporter¶

Export IFC models back to STEP, with optional visible-only filtering and mutation baking.

class StepExporter {
  constructor(dataStore: IfcDataStore, mutationView?: MutablePropertyView);

  export(options: StepExportOptions): StepExportResult;
}

interface StepExportOptions {
  // Output schema; converts entity types when needed
  schema: 'IFC2X3' | 'IFC4' | 'IFC4X3' | 'IFC5';
  description?: string;
  author?: string;
  organization?: string;
  application?: string;
  filename?: string;

  includeGeometry?: boolean;       // default true
  includeProperties?: boolean;     // default true
  includeQuantities?: boolean;     // default true
  includeRelationships?: boolean;  // default true

  applyMutations?: boolean;        // bake MutablePropertyView edits
  deltaOnly?: boolean;             // only entities with mutations
  visibleOnly?: boolean;           // filter to viewer-visible entities
  hiddenEntityIds?: Set<number>;   // required when visibleOnly is true
  // ... isolation, progress; see src/step-exporter.ts
}

MergedExporter¶

Merge multiple IFC models into a single STEP file with a unified ID space, spatial-hierarchy unification, and unit-aware reconciliation.

class MergedExporter {
  constructor(models: MergeModelInput[]);
  export(options: MergeExportOptions): MergeExportResult;               // synchronous
  exportAsync(options: MergeExportOptions): Promise<MergeExportResult>; // progress + mutations
}

MergeExportOptions.unitReconciliation controls mixed length units:

'auto' (default): a model with a different length unit is federated as its own IfcProject
'normalize': rescale it into the first model's unit (one single-unit project)
'assume-shared': force one project without rescaling

Spatial matching is tunable per container type via mergeSites / mergeBuildings ('single' | 'by-name') and mergeStoreys ('by-name' | 'by-elevation' | 'by-name-then-elevation').

ParquetExporter¶

Creates a .bos archive (ZIP of Parquet files) from a parsed store, optionally with geometry buffers.

class ParquetExporter {
  constructor(store: IfcDataStore, geometryResult?: GeometryResult, mutationView?: MutablePropertyView);

  exportBOS(options?: ParquetExportOptions): Promise<Uint8Array>;
  exportTable(tableName: string): Promise<Uint8Array>;
}

Reference Collection¶

Low-level closure walking for valid STEP export:

// Forward closure walk from root entities
function collectReferencedEntityIds(
  rootIds: Set<number>,
  source: Uint8Array,
  entityIndex: { get(id: number): { byteOffset: number; byteLength: number } | undefined; has(id: number): boolean },
  excludeIds?: Set<number>,
): Set<number>;

// Resolve viewer visibility into export roots
function getVisibleEntityIds(dataStore, hiddenIds, isolatedIds): { roots: Set<number>; hiddenProductIds: Set<number> };

// Reverse pass adding IfcStyledItem entities into the closure (mutates `closure`)
function collectStyleEntities(closure: Set<number>, source: Uint8Array, entityIndex): void;

Other exports¶

Ifc5Exporter: IFC5/IFCX JSON export
Schema conversion helpers: convertEntityType, convertStepLine, needsConversion
GLB helpers: parseGLB, parseGLBToMeshData, extractGlbMapping, countGlbMeshes
LOD generators: generateLod0, generateLod1

glTF / GLB and CSV export¶

The standalone GltfExporter and CsvExporter classes were removed. glTF/GLB and CSV are produced in Rust and exposed on GeometryProcessor (from @ifc-lite/geometry): exportGlb(buffer, ...), exportGlbFromMeshes(meshes, ...), and exportCsv(buffer, mode, ...) where mode is one of entities, properties, quantities, or spatial.

@ifc-lite/mutations¶

Property editing with bidirectional change tracking. Nothing mutates the parsed buffer; edits accumulate in an overlay and materialise during StepExporter.export({ applyMutations: true }).

iterateEffectiveEntityIds(dataStore, view, types?) enumerates the live entity set for a model: parsed entities minus tombstones, plus overlay creations, with queued class changes applied. types is an optional list of schema-expanded UPPERCASE IFC names. Results carry expressId, effective type, and overlayCreated; pass each model's own store and view together.

MutablePropertyView¶

Wraps a PropertyTable with a mutation overlay for non-destructive property editing.

class MutablePropertyView {
  constructor(baseTable: PropertyTable | null, modelId: string);

  // Reads (with mutations applied)
  getForEntity(entityId: number): PropertySet[];
  getPropertyValue(entityId: number, psetName: string, propName: string): PropertyValue | null;

  // Property edits (each returns/records a Mutation)
  setProperty(entityId, psetName, propName, value, valueType?, unit?): Mutation;
  deleteProperty(entityId, psetName, propName): Mutation | null;
  createPropertySet(entityId, psetName, properties): Mutation;
  deletePropertySet(entityId, psetName): Mutation;

  // Positional STEP-argument overrides (profiles, points, ...)
  setPositionalAttribute(entityId, index, value, skipHistory?): Mutation;
  getPositionalMutationsForEntity(entityId): Map<number, IfcAttributeValue> | null;
  removePositionalMutation(entityId, index): void;

  // Entity churn in the overlay
  createEntity(type: string, attributes: IfcAttributeValue[]): NewEntity;
  deleteEntity(expressId: number): boolean;
  getNewEntities(): NewEntity[];
  isDeleted(expressId: number): boolean;
  getTombstones(): Set<number>;
  restoreFromTombstone(expressId: number): boolean;

  // Bookkeeping
  getMutations(): Mutation[];
  hasChanges(entityId?: number): boolean;
  applyMutations(mutations: Mutation[]): void;
  exportMutations(): string;
  importMutations(json: string): void;
  clear(): void;
}

StoreEditor¶

High-level facade for editing a parsed IfcDataStore via the MutablePropertyView overlay.

import { MutablePropertyView, StoreEditor } from '@ifc-lite/mutations';

const view = new MutablePropertyView(propertyTable, modelId);
const editor = new StoreEditor(dataStore, view);

const profile = editor.addEntity('IFCRECTANGLEPROFILEDEF', [
  '.AREA.', null, '#34', 0.6, 0.4,
]);
editor.setPositionalAttribute(profile.expressId, 3, 0.7);
editor.removeEntity(unwantedExpressId);

class StoreEditor {
  constructor(store: IfcDataStore, view: MutablePropertyView);

  // Add a new entity to the overlay (returns a synthetic EntityRef with a fresh expressId)
  addEntity(type: string, attributes: IfcAttributeValue[]): EntityRef;

  // Tombstone an existing entity or forget an overlay-only one
  removeEntity(expressId: number): boolean;

  // Override a single positional STEP arg by zero-based index
  setPositionalAttribute(expressId: number, index: number, value: IfcAttributeValue): void;

  // Edit a named root attribute (Name, Description, ObjectType, ...)
  setAttribute(expressId: number, attrName: string, value: string): void;

  getNewEntity(expressId: number): NewEntity | null;
  getNewEntities(): NewEntity[];
}

Value conventions¶

addEntity and setPositionalAttribute accept the same shape that EntityExtractor.extractEntity().attributes produces:

JS value	STEP literal
`null` / `undefined`	`$`
`42` / `0.6`	integer / REAL
`true` / `false`	`.T.` / `.F.`
`"#42"` (string)	entity reference
`".AREA."` (string)	enum
`"My Column"` (string)	quoted STEP string
`[1, 2, 3]`	STEP list `(1,2,3)`, recursive

ChangeSetManager¶

Manage named groups of mutations: createChangeSet, setActiveChangeSet, addMutation, mergeChangeSets, exportChangeSet / importChangeSet, and friends.

BulkQueryEngine¶

Query and update entities in bulk.

class BulkQueryEngine {
  select(criteria: SelectionCriteria): number[];
  preview(query: BulkQuery): BulkQueryPreview;
  execute(query: BulkQuery): BulkQueryResult;
}

CsvConnector¶

Import property updates from CSV files: parse, match, generateMutations, import, preview, autoDetectMappings.

Mutation types cover properties (CREATE/UPDATE/DELETE_PROPERTY, CREATE/DELETE_PROPERTY_SET), quantities, named attributes (UPDATE_ATTRIBUTE), positional STEP args (UPDATE_POSITIONAL_ATTRIBUTE), and entity churn (CREATE_ENTITY, DELETE_ENTITY).

@ifc-lite/create¶

Build valid IFC4 STEP files programmatically, or add elements into an already-parsed model.

storeyPlanFrame(store, storeyExpressId, mutationView) reads the current native placement chain when a view is supplied, including named/positional edits and authored records. Omit the view for source-only reads. Live unreadable, tilted, cyclic or over-256-placement chains return null; preview callers must disclose unavailable geometry. Origins remain metres and directions remain dimensionless.

IfcCreator¶

import { IfcCreator } from '@ifc-lite/create';

const creator = new IfcCreator({ Name: 'My Project' });
const storey = creator.addIfcBuildingStorey({ Name: 'Ground Floor', Elevation: 0 });
creator.addIfcWall(storey, {
  Start: [0, 0, 0], End: [5, 0, 0],
  Thickness: 0.2, Height: 3,
});
const { content } = creator.toIfc();

Coordinates are storey-relative. Every addIfc*(storeyId, …) method chains the product's IfcLocalPlacement to that storey's placement, and the storey placement is where Elevation is applied — exactly once. An element standing on the floor of a storey at Elevation: 3 is created with Z = 0, not Z = 3; adding the elevation yourself puts it at twice the height. (addIfcWallDoor and addIfcWallWindow are the exception: their Position is wall-local, and they inherit the storey datum through their host wall.)

class IfcCreator {
  constructor(params?: ProjectParams);

  // Spatial structure
  addIfcBuildingStorey(params: StoreyParams): number;

  // Building elements (each returns the new expressId)
  addIfcWall(storeyId, params: WallParams): number;
  addIfcSlab(storeyId, params: SlabParams): number;
  addIfcColumn(storeyId, params: ColumnParams): number;
  addIfcBeam(storeyId, params: BeamParams): number;
  addIfcStair(storeyId, params: StairParams): number;
  addIfcRoof(storeyId, params: RoofParams): number;
  addIfcGableRoof(storeyId, params: GableRoofParams): number;
  addIfcDoor(storeyId, params: DoorParams): number;
  addIfcWindow(storeyId, params: WindowParams): number;
  addIfcWallDoor(wallId, params: WallDoorParams): number;    // door + opening in a wall
  addIfcWallWindow(wallId, params: WallWindowParams): number;
  addIfcRamp(storeyId, params: RampParams): number;
  addIfcRailing(storeyId, params: RailingParams): number;
  addIfcPlate(storeyId, params: PlateParams): number;
  addIfcMember(storeyId, params: MemberParams): number;
  addIfcFooting(storeyId, params: FootingParams): number;
  addIfcPile(storeyId, params: PileParams): number;
  addIfcSpace(storeyId, params: SpaceParams): number;

  // Properties, quantities, materials, colour
  addIfcPropertySet(elementId, pset: PropertySetDef): number;
  addIfcElementQuantity(elementId, qset: QuantitySetDef): number;
  addIfcMaterial(elementId, material: MaterialDef): void;
  setColor(elementId, name: string, rgb: [number, number, number]): void;

  // Generate STEP file
  toIfc(): CreateResult;
}

interface ProjectParams {
  Name?: string;
  Description?: string;
  Schema?: 'IFC2X3' | 'IFC4' | 'IFC4X3';
  LengthUnit?: string;  // 'METRE' (default), 'MILLIMETRE', 'FOOT'
  Author?: string;
  Organization?: string;
  Timestamp?: number | Date;   // fixed creation instant (header + owner history); default: wall clock
  GuidSource?: () => string;   // deterministic GlobalId source; default: platform CSPRNG
}

For byte-reproducible output (fixtures, snapshot tests, generated corpora), pin both entropy sources — the timestamp and the GlobalId stream:

import { IfcCreator } from '@ifc-lite/create';
import { generateIfcGuid, type RandomSource } from '@ifc-lite/encoding';

// Any seeded () => number in [0, 1) works; a tiny LCG shown here.
let seed = 42;
const rng: RandomSource = () => {
  seed = (seed * 1103515245 + 12345) % 2147483648;
  return seed / 2147483648;
};

const creator = new IfcCreator({
  Name: 'My Project',
  Timestamp: Date.UTC(2024, 0, 1),
  GuidSource: () => generateIfcGuid(rng),
});
// Two runs with the same seed now produce byte-identical .ifc content.

Parameter interfaces for every element type live in packages/create/src/types.ts (e.g. WallParams with Start, End, Thickness, Height, optional Openings).

In-Store Builders¶

For editing an already-parsed IfcDataStore, the package exposes anchored builders that emit a complete sub-graph (placement, profile, solid, representation, containment) into a StoreEditor overlay:

addColumnToStore, addWallToStore, addSlabToStore, addBeamToStore, addDoorToStore, addWindowToStore, addSpaceToStore, addRoofToStore, addPlateToStore, addMemberToStore.

Hosted builders take a HostAnchor from resolveHostAnchor(dataStore, hostExpressId, mutationView) instead: addOpeningToStore (IfcOpeningElement + IfcRelVoidsElement in an IfcWall or IfcSlab), addHostedDoorToStore and addHostedWindowToStore (the opening plus an IfcDoor / IfcWindow filling it through IfcRelFillsElement).

addHostedElementInStore(dataStore, editor, hostExpressId, spec) is the atomic hosted command operation used by the viewer, SDK and MCP. A spec chooses kind: 'opening' | 'door' | 'window' and the corresponding builder params. It resolves the live anchor and refuses wall cuts outside the host, overlapping existing openings, or having unreadable geometry. readHostOpeningExtents(dataStore, hostExpressId, mutationView) returns host-frame native-unit bounds and reports unreadable openings.

bim.store.joinWalls(modelId, aExpressId, bExpressId, options?) exposes the existing joinWallsInStore core through SDK, sandbox and MCP. It returns the new IfcRelConnectsPathElements reference. The core now atomically protects hosted cuts against both joined end faces and refuses unreadable cut geometry. recordCompoundMutation and undoRecordedMutationOperations in @ifc-lite/mutations record and restore complete compound overlay graphs, including forgotten earlier entities, as one operation.

Type objects and materials take the storey-free anchor from resolveAuthoringAnchor(dataStore, mutationView): addElementTypeToStore and assignTypeInStore (IfcRelDefinesByType), and addMaterialToStore, addMaterialLayerSetToStore, addMaterialLayerSetUsageToStore and assignMaterialInStore (IfcRelAssociatesMaterial). The assign* builders take the model's existing relationships from readRelatedLists.

import { StoreEditor } from '@ifc-lite/mutations';
import { addColumnToStore, resolveSpatialAnchor } from '@ifc-lite/create';

const editor = new StoreEditor(dataStore, mutationView);
const anchor = resolveSpatialAnchor(dataStore, storeyExpressId, mutationView);

const result = addColumnToStore(editor, anchor, {
  Position: [1, 1, 0],
  Width: 0.3, Depth: 0.4, Height: 3,
  Name: 'Column 1',
});

resolveSpatialAnchor¶

Reads the parsed IfcDataStore and, when supplied, a live mutation view for the references every in-store builder needs. Deleted or retyped-away anchors are excluded; created storeys and placements are accepted. IfcOwnerHistory is optional in IFC4 and required in IFC2X3. Throws if a required context or the storey's IfcLocalPlacement cannot be resolved.

import type { MutablePropertyView } from '@ifc-lite/mutations';
function resolveSpatialAnchor(store: IfcDataStore, storeyExpressId: number, view?: MutablePropertyView | null): SpatialAnchor;

interface SpatialAnchor {
  ownerHistoryId: number | null; // optional from IFC4 onward
  bodyContextId: number;     // 'Body' subcontext (or parent context fallback)
  storeyId: number;
  storeyPlacementId: number; // the storey's own IfcLocalPlacement
  guidRandom?: RandomSource; // optional seeded [0,1) source: pins the emitted
                             // GlobalIds for reproducible in-store builds
                             // (counterpart of ProjectParams.GuidSource)
}

duplicateInStore takes the same knob as options.guidRandom (it has no anchor), and generateSpacesFromWalls / generateSpaces forward options.guidRandom to the spaces they emit.

For byte-reproducible exported files, seed the exporter too: builders that attach property or quantity sets (e.g. addSpaceToStore) park them in the mutation overlay, and StepExporter mints the IfcPropertySet / IfcElementQuantity / IfcRelDefinesByProperties GlobalIds itself at export time. Pass the same source as StepExportOptions.guidRandom, plus timeStamp to pin the STEP header instant.

@ifc-lite/bcf¶

BCF (BIM Collaboration Format) support for topic tracking. Implements BCF 2.1 and 3.0.

readBCF / writeBCF¶

// Read a BCF/BCFzip file (accepts File, Blob, or ArrayBuffer)
function readBCF(file: File | Blob | ArrayBuffer): Promise<BCFProject>;

// Write a BCF file (returns a Blob)
function writeBCF(project: BCFProject): Promise<Blob>;

Creation and mutation helpers¶

function createBCFProject(options?: { name?: string; version?: '2.1' | '3.0' }): BCFProject;
function createBCFTopic(options: { title: string; author: string; /* ... */ }): BCFTopic;
function createBCFComment(options: { author: string; comment: string }): BCFComment;

function addTopicToProject(project: BCFProject, topic: BCFTopic): void;
function addCommentToTopic(topic: BCFTopic, comment: BCFComment): void;
function addViewpointToTopic(topic: BCFTopic, viewpoint: BCFViewpoint): void;
function updateTopicStatus(/* topic, status, ... */): void;

Viewpoints¶

// Create a viewpoint from viewer state (camera, section plane, selection, visibility, snapshot)
function createViewpoint(options): BCFViewpoint;

// Extract viewer state from a BCF viewpoint
function extractViewpointState(viewpoint: BCFViewpoint): {
  camera?: ViewerCameraState;
  sectionPlane?: ViewerSectionPlane;
  selectedGuids: string[];
  hiddenGuids: string[];
  visibleGuids: string[];
  coloredGuids: { color: string; guids: string[] }[];
};

Utilities¶

GUID conversion (uuidToIfcGuid, ifcGuidToUuid, generateIfcGuid, isValidIfcGuid), ARGB colour helpers (parseARGBColor, toARGBColor), 3D marker positioning (computeMarkerPositions), and createBCFFromIDSReport to turn an IDS validation report into BCF topics.

@ifc-lite/ids¶

IDS (Information Delivery Specification) validation. Implements IDS 1.0 with all facet and constraint types.

parseIDS / validateIDS¶

// Parse an IDS XML file (accepts string or ArrayBuffer)
function parseIDS(xmlContent: string | ArrayBuffer): IDSDocument;

// Run validation against IFC data
function validateIDS(
  document: IDSDocument,
  accessor: IFCDataAccessor,
  modelInfo: IDSModelInfo,
  options?: ValidatorOptions
): Promise<IDSValidationReport>;

function checkFacet(facet, entity, accessor): boolean;
function filterByFacet(facet, entities, accessor): EntityRef[];
function checkEntityFacet(facet, entity): boolean;
function checkAttributeFacet(facet, entity, accessor): boolean;
function checkPropertyFacet(facet, entity, accessor): boolean;
function checkClassificationFacet(facet, entity, accessor): boolean;
function checkMaterialFacet(facet, entity, accessor): boolean;
function checkPartOfFacet(facet, entity, accessor): boolean;

Constraints, audit, translation¶

function matchConstraint(constraint: IDSConstraint, value: unknown): boolean;
function formatConstraint(constraint: IDSConstraint): string;
function getConstraintMismatchReason(constraint: IDSConstraint, value: unknown): string;

// IDS document correctness audit
function auditIDSDocument(/* ... */): IDSAuditReport;
function auditIDSStructure(/* ... */): IDSAuditReport;

// Report localisation
function createTranslationService(locale: 'en' | 'de' | 'fr'): TranslationService;

@ifc-lite/drawing-2d¶

2D architectural drawing generation from 3D IFC models: section cuts, floor plans, and elevations.

High-level generation¶

class Drawing2DGenerator {
  initialize(): Promise<void>;
  generate(meshes: MeshData[], config: SectionConfig, options?: Partial<GeneratorOptions>): Promise<Drawing2D>;
  dispose(): void;
}

function generateFloorPlan(meshes: MeshData[], elevation: number, options?: Partial<GeneratorOptions>): Promise<Drawing2D>;
function generateSection(meshes: MeshData[], axis: 'x' | 'z', position: number, options?: Partial<GeneratorOptions>): Promise<Drawing2D>;
function createSectionConfig(axis: 'x' | 'y' | 'z', position: number, options?: Partial<Omit<SectionConfig, 'plane'>>): SectionConfig;

Pipeline pieces¶

Section cutting: SectionCutter, cutMeshesStreaming, GPU-accelerated GPUSectionCutter + isGPUComputeAvailable
Polygons: PolygonBuilder, simplifyPolygon, polygonBounds
Edges and visibility: EdgeExtractor, HiddenLineClassifier, projectProfiles
Hatching: HatchGenerator, HATCH_PATTERNS, getHatchPattern
Openings and symbols: buildOpeningRelationships, generateDoorSymbol, generateWindowSymbol, generateStairArrow
Graphic overrides: GraphicOverrideEngine, createOverrideEngine, presets ARCHITECTURAL_PRESET and FIRE_SAFETY_PRESET
SVG output: SVGExporter, exportToSVG
Sheets: createFrame, createTitleBlock, renderFrame, renderTitleBlock, PAPER_SIZE_REGISTRY
Constants: LINE_STYLES, COMMON_SCALES, PAPER_SIZES

@ifc-lite/clash¶

Clash detection with a representation-agnostic core engine plus source adapters. Key exports: createClashEngine (pluggable ClashBackend, including the WASM-native one), groupClashes, matchesSelector, exclusion helpers (makeExclusionSet, isExcluded, pairKey), and the shared clash types.

@ifc-lite/diff¶

Headless model-diff engine: classifies entities as added / modified / deleted / unchanged across two revisions, with separable data vs geometry scope. Main entry point: diffModels.

@ifc-lite/lens¶

Rule-based 3D filtering and colorization for IFC models: evaluateLens applies shared rule selections, evaluateAutoColorLens groups by data values, and class/data-source discovery (discoverClasses, discoverDataSources) supports the BUILTIN_LENSES presets.

@ifc-lite/lists¶

Configurable property tables and schedules from IFC data: executeList, listResultToCSV, summariseListRows, column discovery (discoverColumns), name patterns (compileNameMatcher), and LIST_PRESETS.

@ifc-lite/ifcx¶

IFC5 (IFCX) parser: parseIfcx, parseFederatedIfcx, composeIfcx, detectFormat, layer stacking (createLayerStack, addIfcxOverlay), entity/property/geometry extractors, and hierarchy building. Re-exported through @ifc-lite/parser for parseAuto.

@ifc-lite/encoding¶

IFC string encoding/decoding and property value parsing: decodeIfcString, encodeIfcString, parsePropertyValue.

@ifc-lite/cache¶

Binary cache format for fast model loading: BinaryCacheWriter, BinaryCacheReader, plus hashing (xxhash64) and buffer utilities. Used by the viewer to skip re-parsing unchanged files.

@ifc-lite/pointcloud¶

Point cloud decoders and types: decodePcd, LAS/LAZ support including LasStreamingSource for chunked streaming, and decompressLZF.

@ifc-lite/solar¶

Solar position, sunrise/sunset, and 3D sun-path geometry: sunPosition, sunTimes, and the sun-path dome builders (day paths, hourly analemmas). Renderer-agnostic.

@ifc-lite/sdk¶

Scripting SDK: the bim.* API for BIM automation. createBimContext builds a BimContext whose namespaces (QueryNamespace, ModelNamespace, ViewerNamespace, MutateNamespace, StoreNamespace, ...) run against either the browser viewer or a headless backend.

@ifc-lite/sandbox¶

QuickJS-in-WASM sandboxed script execution: createSandbox / Sandbox, buildBridge (marshals the bim.* API across the sandbox boundary), and transpileTypeScript.

buildBridge returns { logs, resetLogs, dispose }. resetLogs is part of the contract, not an implementation detail: the console capture budget (byte total and entry count) is scoped to one run, so a caller driving buildBridge directly must invoke resetLogs() at the start of every run. Skip it and a script that exhausts the budget silences the logs of every later run on the same bridge. Sandbox.eval already does this for you — only direct buildBridge callers carry the obligation.

@ifc-lite/extensions¶

Extension manifest, capability grammar, and slot registry for user customization: validateManifest, migrateManifest, SlotRegistry, capability and when-clause evaluation, bundle and storage helpers.

@ifc-lite/mcp¶

Model Context Protocol server for ifc-lite: agent-native BIM via MCP over stdio or Streamable HTTP. Exports MCPServer plus the model-registry and tool-context types; also ships the ifc-lite-mcp CLI entry point.

@ifc-lite/cli¶

CLI toolkit for IFC files (binary name ifc-lite): query, validate (IDS), export (CSV/JSON/IFC/glTF/Parquet), create, merge, convert, diff, clash-check, and script the SDK.

@ifc-lite/collab¶

Real-time collaborative BIM via CRDT on IFCX: document schema, entity/relationship/geometry operations, and snapshot support.

@ifc-lite/collab-server¶

Reference websocket sync server for @ifc-lite/collab.

@ifc-lite/embed-sdk¶

SDK for embedding the IFC-Lite 3D viewer in any web page via iframe. Main export: the IFCLiteEmbed class with typed commands and an EventMap for viewer events.

@ifc-lite/embed-protocol¶

Shared postMessage protocol types for the embed viewer and SDK: message envelope, inbound command and outbound event types, and PROTOCOL_VERSION.

@ifc-lite/viewer-core¶

Interactive 3D viewer for IFC models: a WebGL 2 browser viewer with a REST API. Published from packages/viewer; main export is getViewerHtml plus the server/embedding helpers.

@ifc-lite/server-client¶

TypeScript client SDK for IFC-Lite Server: typed REST client plus Parquet geometry decoding (decodeParquetGeometry, decodeOptimizedParquetGeometry).

@ifc-lite/server-bin¶

Pre-built ifc-lite-server binaries for deployment without a Rust toolchain or Docker. Installs a launcher (ifc-lite-server) that downloads and verifies the platform binary.

Supported platforms:

Platform	Architecture
`linux-x64`	x86_64
`linux-arm64`	aarch64
`linux-x64-musl`	x86_64 (musl libc)
`darwin-x64`	x86_64 (macOS)
`darwin-arm64`	aarch64 (macOS Apple Silicon)
`win32-x64`	x86_64 (Windows)

@ifc-lite/wasm¶

WebAssembly bindings (the IfcAPI class and mesh/profile/clash types). See the WASM API reference.

@ifc-lite/codegen¶

TypeScript code generator from IFC EXPRESS schemas. Produces the 876-entity type definitions, CRC32 type ids, serializers, and the parser's generated Rust tables (generateTypeIds, generateSerializers, generateRust). Primarily a build-time tool, not used at runtime.

create-ifc-lite¶

Project scaffolder: npm create ifc-lite (binary create-ifc-lite) sets up a new IFC-Lite project with one command.