brepjs-bim 0.19.0 → 0.21.0

package/dist/brepjs-bim.cjs

@@ -27620,7 +27620,8 @@ function assignNum(target, key, value) {
 * while the IR path serves the viewport and dedup. GlobalIds derive from
 * families key paths (stable under reordering), not insertion order.
 *
-* Scope: Storey containers, Wall/Slab/Column/Beam/Roof/Stair elements, and wall openings — a
+* Scope: Storey containers; Wall/Slab/Column/Beam/Roof/Stair, Footing/Pile,
+* Railing/Ramp, Covering/CurtainWall, and Space elements; and wall openings — a
 * fill-role void (Door/Window family) maps onto addDoor/addWindow, which cut
 * the wall and wire IfcRelVoidsElement + IfcRelFillsElement; the opening and
 * filler GlobalIds derive from the synthesized key paths. Anonymous (non-fill)
@@ -27652,35 +27653,64 @@ var GEOMETRY_PROPS = /* @__PURE__ */ new Set([
 	"psets"
 ]);
 var SPEC_ROUTES = {
-	Wall: {
+	wall: {
 		parse: parseWallSpec,
 		add: (m, spec, key) => m.addWall(spec, { stableKey: key })
 	},
-	Slab: {
+	slab: {
 		parse: parseSlabSpec,
 		add: (m, spec, key) => m.addSlab(spec, { stableKey: key })
 	},
-	Column: {
+	column: {
 		parse: parseColumnSpec,
 		add: (m, spec, key) => m.addColumn(spec, { stableKey: key })
 	},
-	Beam: {
+	beam: {
 		parse: parseBeamSpec,
 		add: (m, spec, key) => m.addBeam(spec, { stableKey: key })
 	},
-	Roof: {
+	roof: {
 		parse: parseRoofSpec,
 		add: (m, spec, key) => m.addRoof(spec, { stableKey: key })
 	},
-	Stair: {
+	stair: {
 		parse: parseStairSpec,
 		add: (m, spec, key) => m.addStair(spec, { stableKey: key }),
-		input: stairSpecInput
+		input: flightsSpecInput
+	},
+	footing: {
+		parse: parseFootingSpec,
+		add: (m, spec, key) => m.addFooting(spec, { stableKey: key })
+	},
+	pile: {
+		parse: parsePileSpec,
+		add: (m, spec, key) => m.addPile(spec, { stableKey: key })
+	},
+	railing: {
+		parse: parseRailingSpec,
+		add: (m, spec, key) => m.addRailing(spec, { stableKey: key })
+	},
+	ramp: {
+		parse: parseRampSpec,
+		add: (m, spec, key) => m.addRamp(spec, { stableKey: key }),
+		input: flightsSpecInput
+	},
+	covering: {
+		parse: parseCoveringSpec,
+		add: (m, spec, key) => m.addCovering(spec, void 0, { stableKey: key })
+	},
+	curtainWall: {
+		parse: parseCurtainWallSpec,
+		add: (m, spec, key) => m.addCurtainWall(spec, { stableKey: key })
+	},
+	space: {
+		parse: parseSpaceSpec,
+		add: (m, spec, key) => m.addSpace(spec, { stableKey: key })
 	}
 };
-/** StairSpec has no top-level origin — placement lives per flight — so the
-*  element's folded translate lands on every flight's origin instead. */
-function stairSpecInput(el) {
+/** Stair and ramp specs have no top-level origin — placement lives per flight —
+*  so the element's folded translate lands on every flight's origin instead. */
+function flightsSpecInput(el) {
 	const base = specInput(el);
 	const fold = base["origin"] ?? [
 		0,
@@ -27707,8 +27737,35 @@ function stairSpecInput(el) {
 		})
 	};
 }
-function specRoute(type) {
-	return Object.hasOwn(SPEC_ROUTES, type) ? SPEC_ROUTES[type] : void 0;
+/**
+* Families predating `archetype` are routed by their display name. Keeping
+* this fallback makes the declaration purely additive, at the cost of the
+* original trap surviving for undeclared families: rename one and it stops
+* routing.
+*/
+var NAME_ARCHETYPES = {
+	Storey: "storey",
+	Wall: "wall",
+	Slab: "slab",
+	Column: "column",
+	Beam: "beam",
+	Roof: "roof",
+	Stair: "stair",
+	Door: "door",
+	Window: "window",
+	Footing: "footing",
+	Pile: "pile",
+	Railing: "railing",
+	Ramp: "ramp",
+	Covering: "covering",
+	CurtainWall: "curtainWall",
+	Space: "space"
+};
+function archetypeFor(el) {
+	return el.archetype ?? NAME_ARCHETYPES[el.type];
+}
+function specRoute(archetype) {
+	return archetype !== void 0 && Object.hasOwn(SPEC_ROUTES, archetype) ? SPEC_ROUTES[archetype] : void 0;
 }
 /** Total of the resolved geometry's OUTER literal translate chain. The
 *  transform vocabulary is translate-only, so frame differences are exact
@@ -27816,17 +27873,18 @@ function collectSpecProps(el) {
 	return out;
 }
 function addFill(model, fill, input, identity) {
-	if (fill.type === "Door") {
+	const archetype = archetypeFor(fill);
+	if (archetype === "door") {
 		const parsed = parseDoorSpec(input);
 		if (!parsed.ok) return parsed;
 		return model.addDoor(parsed.value, identity);
 	}
-	if (fill.type === "Window") {
+	if (archetype === "window") {
 		const parsed = parseWindowSpec(input);
 		if (!parsed.ok) return parsed;
 		return model.addWindow(parsed.value, identity);
 	}
-	return (0, brepjs.err)(specError("FAMILIES_UNSUPPORTED_FILL", `familiesToBim: no fill mapping for element type '${fill.type}' at '${fill.keyPath}'`));
+	return (0, brepjs.err)(specError("FAMILIES_UNSUPPORTED_FILL", `familiesToBim: no fill mapping for element type '${fill.type}' at '${fill.keyPath}' (archetype: ${archetype ?? "none"}) — a filler needs archetype: 'door' or 'window'`));
 }
 /** Materialize an unrouted element's IR and add it as a proxy. The body is
 *  authoritative for a proxy (no parametric spec to diverge from), so baked
@@ -27930,12 +27988,14 @@ function familiesToBim(root, options) {
 	if (project !== null) model.aggregate(project.localId, siteResult.value);
 	model.aggregate(siteResult.value, buildingId);
 	const idByKeyPath = /* @__PURE__ */ new Map();
+	const proxied = [];
 	const walk = (el, storeyId, rotated) => {
 		const rotatedHere = rotated || hasRotateOp(el);
-		let proxied = false;
+		let proxiedHere = false;
 		let containerId = storeyId;
-		const route = specRoute(el.type);
-		if (el.type === "Storey") {
+		const archetype = archetypeFor(el);
+		const route = specRoute(archetype);
+		if (archetype === "storey") {
 			const keyed = requireKeyed(el);
 			if (!keyed.ok) return keyed;
 			const storeyResult = model.addStorey({
@@ -27960,26 +28020,31 @@ function familiesToBim(root, options) {
 			const added = route.add(model, parsed.value, el.keyPath);
 			if (!added.ok) return added;
 			idByKeyPath.set(el.keyPath, added.value);
-			if (containerId === null) return (0, brepjs.err)(specError("FAMILIES_NO_STOREY", `familiesToBim: '${el.keyPath}' has no Storey ancestor — IFC elements need spatial containment`));
+			if (containerId === null) return (0, brepjs.err)(specError("FAMILIES_NO_STOREY", `familiesToBim: '${el.keyPath}' has no Storey ancestor — IFC elements need spatial containment; a container family needs archetype: 'storey' to be recognised under any name`));
 			model.placeIn(added.value, containerId);
-			if (el.type === "Wall") {
+			if (archetype === "wall") {
 				const opened = addOpenings(model, el, added.value, containerId, idByKeyPath);
 				if (!opened.ok) return opened;
 			}
 		} else if (el.type === "Opening") return (0, brepjs.err)(specError("FAMILIES_OPENING_OUTSIDE_WALL", `familiesToBim: opening '${el.keyPath}' is not hosted by a Wall — only wall openings are mapped`));
 		else if (el.type !== "Group" && el.geometry.kind !== "Empty") {
-			if (options.proxyEvaluator === void 0) return (0, brepjs.err)(specError("FAMILIES_UNSUPPORTED_TYPE", `familiesToBim: no spec mapping for element type '${el.type}' at '${el.keyPath}' — add a spec route, or pass proxyEvaluator to export it as an IfcBuildingElementProxy`));
+			if (options.proxyEvaluator === void 0) return (0, brepjs.err)(specError("FAMILIES_UNSUPPORTED_TYPE", `familiesToBim: no spec mapping for element type '${el.type}' at '${el.keyPath}' (archetype: ${el.archetype ?? "none"}) — routing is by archetype, so declare one on the family, add a spec route, or pass proxyEvaluator to export it as an IfcBuildingElementProxy`));
 			const keyed = requireKeyed(el);
 			if (!keyed.ok) return keyed;
-			if (containerId === null) return (0, brepjs.err)(specError("FAMILIES_NO_STOREY", `familiesToBim: '${el.keyPath}' has no Storey ancestor — IFC elements need spatial containment`));
+			if (containerId === null) return (0, brepjs.err)(specError("FAMILIES_NO_STOREY", `familiesToBim: '${el.keyPath}' has no Storey ancestor — IFC elements need spatial containment; a container family needs archetype: 'storey' to be recognised under any name`));
 			const added = addProxyElement(model, el, options.proxyEvaluator);
 			if (!added.ok) return added;
 			model.placeIn(added.value, containerId);
 			idByKeyPath.set(el.keyPath, added.value);
-			proxied = true;
+			proxied.push({
+				keyPath: el.keyPath,
+				type: el.type,
+				archetype: el.archetype
+			});
+			proxiedHere = true;
 		}
 		for (const child of el.children) {
-			if ((el.type === "Wall" || proxied) && child.type === "Opening") continue;
+			if ((archetype === "wall" || proxiedHere) && child.type === "Opening") continue;
 			const r = walk(child, containerId, rotatedHere);
 			if (!r.ok) return r;
 		}
@@ -27992,7 +28057,8 @@ function familiesToBim(root, options) {
 	}
 	return (0, brepjs.ok)({
 		model,
-		idByKeyPath
+		idByKeyPath,
+		proxied
 	});
 }
 //#endregion

package/dist/brepjs-bim.js

@@ -27597,7 +27597,8 @@ function assignNum(target, key, value) {
 * while the IR path serves the viewport and dedup. GlobalIds derive from
 * families key paths (stable under reordering), not insertion order.
 *
-* Scope: Storey containers, Wall/Slab/Column/Beam/Roof/Stair elements, and wall openings — a
+* Scope: Storey containers; Wall/Slab/Column/Beam/Roof/Stair, Footing/Pile,
+* Railing/Ramp, Covering/CurtainWall, and Space elements; and wall openings — a
 * fill-role void (Door/Window family) maps onto addDoor/addWindow, which cut
 * the wall and wire IfcRelVoidsElement + IfcRelFillsElement; the opening and
 * filler GlobalIds derive from the synthesized key paths. Anonymous (non-fill)
@@ -27629,35 +27630,64 @@ var GEOMETRY_PROPS = /* @__PURE__ */ new Set([
 	"psets"
 ]);
 var SPEC_ROUTES = {
-	Wall: {
+	wall: {
 		parse: parseWallSpec,
 		add: (m, spec, key) => m.addWall(spec, { stableKey: key })
 	},
-	Slab: {
+	slab: {
 		parse: parseSlabSpec,
 		add: (m, spec, key) => m.addSlab(spec, { stableKey: key })
 	},
-	Column: {
+	column: {
 		parse: parseColumnSpec,
 		add: (m, spec, key) => m.addColumn(spec, { stableKey: key })
 	},
-	Beam: {
+	beam: {
 		parse: parseBeamSpec,
 		add: (m, spec, key) => m.addBeam(spec, { stableKey: key })
 	},
-	Roof: {
+	roof: {
 		parse: parseRoofSpec,
 		add: (m, spec, key) => m.addRoof(spec, { stableKey: key })
 	},
-	Stair: {
+	stair: {
 		parse: parseStairSpec,
 		add: (m, spec, key) => m.addStair(spec, { stableKey: key }),
-		input: stairSpecInput
+		input: flightsSpecInput
+	},
+	footing: {
+		parse: parseFootingSpec,
+		add: (m, spec, key) => m.addFooting(spec, { stableKey: key })
+	},
+	pile: {
+		parse: parsePileSpec,
+		add: (m, spec, key) => m.addPile(spec, { stableKey: key })
+	},
+	railing: {
+		parse: parseRailingSpec,
+		add: (m, spec, key) => m.addRailing(spec, { stableKey: key })
+	},
+	ramp: {
+		parse: parseRampSpec,
+		add: (m, spec, key) => m.addRamp(spec, { stableKey: key }),
+		input: flightsSpecInput
+	},
+	covering: {
+		parse: parseCoveringSpec,
+		add: (m, spec, key) => m.addCovering(spec, void 0, { stableKey: key })
+	},
+	curtainWall: {
+		parse: parseCurtainWallSpec,
+		add: (m, spec, key) => m.addCurtainWall(spec, { stableKey: key })
+	},
+	space: {
+		parse: parseSpaceSpec,
+		add: (m, spec, key) => m.addSpace(spec, { stableKey: key })
 	}
 };
-/** StairSpec has no top-level origin — placement lives per flight — so the
-*  element's folded translate lands on every flight's origin instead. */
-function stairSpecInput(el) {
+/** Stair and ramp specs have no top-level origin — placement lives per flight —
+*  so the element's folded translate lands on every flight's origin instead. */
+function flightsSpecInput(el) {
 	const base = specInput(el);
 	const fold = base["origin"] ?? [
 		0,
@@ -27684,8 +27714,35 @@ function stairSpecInput(el) {
 		})
 	};
 }
-function specRoute(type) {
-	return Object.hasOwn(SPEC_ROUTES, type) ? SPEC_ROUTES[type] : void 0;
+/**
+* Families predating `archetype` are routed by their display name. Keeping
+* this fallback makes the declaration purely additive, at the cost of the
+* original trap surviving for undeclared families: rename one and it stops
+* routing.
+*/
+var NAME_ARCHETYPES = {
+	Storey: "storey",
+	Wall: "wall",
+	Slab: "slab",
+	Column: "column",
+	Beam: "beam",
+	Roof: "roof",
+	Stair: "stair",
+	Door: "door",
+	Window: "window",
+	Footing: "footing",
+	Pile: "pile",
+	Railing: "railing",
+	Ramp: "ramp",
+	Covering: "covering",
+	CurtainWall: "curtainWall",
+	Space: "space"
+};
+function archetypeFor(el) {
+	return el.archetype ?? NAME_ARCHETYPES[el.type];
+}
+function specRoute(archetype) {
+	return archetype !== void 0 && Object.hasOwn(SPEC_ROUTES, archetype) ? SPEC_ROUTES[archetype] : void 0;
 }
 /** Total of the resolved geometry's OUTER literal translate chain. The
 *  transform vocabulary is translate-only, so frame differences are exact
@@ -27793,17 +27850,18 @@ function collectSpecProps(el) {
 	return out;
 }
 function addFill(model, fill, input, identity) {
-	if (fill.type === "Door") {
+	const archetype = archetypeFor(fill);
+	if (archetype === "door") {
 		const parsed = parseDoorSpec(input);
 		if (!parsed.ok) return parsed;
 		return model.addDoor(parsed.value, identity);
 	}
-	if (fill.type === "Window") {
+	if (archetype === "window") {
 		const parsed = parseWindowSpec(input);
 		if (!parsed.ok) return parsed;
 		return model.addWindow(parsed.value, identity);
 	}
-	return err(specError("FAMILIES_UNSUPPORTED_FILL", `familiesToBim: no fill mapping for element type '${fill.type}' at '${fill.keyPath}'`));
+	return err(specError("FAMILIES_UNSUPPORTED_FILL", `familiesToBim: no fill mapping for element type '${fill.type}' at '${fill.keyPath}' (archetype: ${archetype ?? "none"}) — a filler needs archetype: 'door' or 'window'`));
 }
 /** Materialize an unrouted element's IR and add it as a proxy. The body is
 *  authoritative for a proxy (no parametric spec to diverge from), so baked
@@ -27907,12 +27965,14 @@ function familiesToBim(root, options) {
 	if (project !== null) model.aggregate(project.localId, siteResult.value);
 	model.aggregate(siteResult.value, buildingId);
 	const idByKeyPath = /* @__PURE__ */ new Map();
+	const proxied = [];
 	const walk = (el, storeyId, rotated) => {
 		const rotatedHere = rotated || hasRotateOp(el);
-		let proxied = false;
+		let proxiedHere = false;
 		let containerId = storeyId;
-		const route = specRoute(el.type);
-		if (el.type === "Storey") {
+		const archetype = archetypeFor(el);
+		const route = specRoute(archetype);
+		if (archetype === "storey") {
 			const keyed = requireKeyed(el);
 			if (!keyed.ok) return keyed;
 			const storeyResult = model.addStorey({
@@ -27937,26 +27997,31 @@ function familiesToBim(root, options) {
 			const added = route.add(model, parsed.value, el.keyPath);
 			if (!added.ok) return added;
 			idByKeyPath.set(el.keyPath, added.value);
-			if (containerId === null) return err(specError("FAMILIES_NO_STOREY", `familiesToBim: '${el.keyPath}' has no Storey ancestor — IFC elements need spatial containment`));
+			if (containerId === null) return err(specError("FAMILIES_NO_STOREY", `familiesToBim: '${el.keyPath}' has no Storey ancestor — IFC elements need spatial containment; a container family needs archetype: 'storey' to be recognised under any name`));
 			model.placeIn(added.value, containerId);
-			if (el.type === "Wall") {
+			if (archetype === "wall") {
 				const opened = addOpenings(model, el, added.value, containerId, idByKeyPath);
 				if (!opened.ok) return opened;
 			}
 		} else if (el.type === "Opening") return err(specError("FAMILIES_OPENING_OUTSIDE_WALL", `familiesToBim: opening '${el.keyPath}' is not hosted by a Wall — only wall openings are mapped`));
 		else if (el.type !== "Group" && el.geometry.kind !== "Empty") {
-			if (options.proxyEvaluator === void 0) return err(specError("FAMILIES_UNSUPPORTED_TYPE", `familiesToBim: no spec mapping for element type '${el.type}' at '${el.keyPath}' — add a spec route, or pass proxyEvaluator to export it as an IfcBuildingElementProxy`));
+			if (options.proxyEvaluator === void 0) return err(specError("FAMILIES_UNSUPPORTED_TYPE", `familiesToBim: no spec mapping for element type '${el.type}' at '${el.keyPath}' (archetype: ${el.archetype ?? "none"}) — routing is by archetype, so declare one on the family, add a spec route, or pass proxyEvaluator to export it as an IfcBuildingElementProxy`));
 			const keyed = requireKeyed(el);
 			if (!keyed.ok) return keyed;
-			if (containerId === null) return err(specError("FAMILIES_NO_STOREY", `familiesToBim: '${el.keyPath}' has no Storey ancestor — IFC elements need spatial containment`));
+			if (containerId === null) return err(specError("FAMILIES_NO_STOREY", `familiesToBim: '${el.keyPath}' has no Storey ancestor — IFC elements need spatial containment; a container family needs archetype: 'storey' to be recognised under any name`));
 			const added = addProxyElement(model, el, options.proxyEvaluator);
 			if (!added.ok) return added;
 			model.placeIn(added.value, containerId);
 			idByKeyPath.set(el.keyPath, added.value);
-			proxied = true;
+			proxied.push({
+				keyPath: el.keyPath,
+				type: el.type,
+				archetype: el.archetype
+			});
+			proxiedHere = true;
 		}
 		for (const child of el.children) {
-			if ((el.type === "Wall" || proxied) && child.type === "Opening") continue;
+			if ((archetype === "wall" || proxiedHere) && child.type === "Opening") continue;
 			const r = walk(child, containerId, rotatedHere);
 			if (!r.ok) return r;
 		}
@@ -27969,7 +28034,8 @@ function familiesToBim(root, options) {
 	}
 	return ok({
 		model,
-		idByKeyPath
+		idByKeyPath,
+		proxied
 	});
 }
 //#endregion

package/dist/familiesAdapter.d.ts

@@ -18,10 +18,24 @@ export interface FamiliesToBimOptions {
      */
     readonly proxyEvaluator?: csg.Evaluator | undefined;
 }
+export interface ProxiedElement {
+    readonly keyPath: string;
+    /** The family's display name, as resolved. */
+    readonly type: string;
+    readonly archetype: string | undefined;
+}
 export interface FamiliesBimResult {
     readonly model: BimModel;
     /** LocalId per geometry-bearing families key path. */
     readonly idByKeyPath: ReadonlyMap<string, LocalId>;
+    /**
+     * Elements exported as IfcBuildingElementProxy because no spec route
+     * matched, in walk order. Only ever non-empty when `proxyEvaluator` is set:
+     * without it an unrouted element is a hard error instead. A renamed family
+     * that has lost its routing lands here rather than in the file as the type
+     * you meant, so check this before trusting an export.
+     */
+    readonly proxied: readonly ProxiedElement[];
 }
 /**
  * Project a resolved families tree into an eager BimModel. The caller owns

package/dist/index.d.ts

@@ -97,4 +97,4 @@ export type { IdsDocument, IdsSpecification, IdsFacet, IdsRestriction, IdsCardin
 export { serializeBcfFiles, parseBcfFiles } from './bcf/index.js';
 export type { BcfColoring, BcfComment, BcfComponent, BcfComponents, BcfContainerData, BcfFiles, BcfProject, BcfTopic, BcfVersion, BcfViewpoint, BcfVisibility, } from './bcf/index.js';
 export { bcfError, idsError } from './errors/bimError.js';
-export { familiesToBim, type FamiliesToBimOptions, type FamiliesBimResult, } from './familiesAdapter.js';
+export { familiesToBim, type FamiliesToBimOptions, type FamiliesBimResult, type ProxiedElement, } from './familiesAdapter.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs-bim",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "BIM layer for brepjs — IFC4-aligned parametric building elements",
   "keywords": [
     "bim",