brepjs-bim 0.19.0 → 0.20.0

package/dist/brepjs-bim.cjs

@@ -27652,27 +27652,27 @@ 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
@@ -27707,8 +27707,28 @@ 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"
+};
+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 +27836,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 +27951,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 +27983,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 +28020,8 @@ function familiesToBim(root, options) {
 	}
 	return (0, brepjs.ok)({
 		model,
-		idByKeyPath
+		idByKeyPath,
+		proxied
 	});
 }
 //#endregion

package/dist/brepjs-bim.js

@@ -27629,27 +27629,27 @@ 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
@@ -27684,8 +27684,28 @@ 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"
+};
+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 +27813,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 +27928,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 +27960,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 +27997,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.20.0",
   "description": "BIM layer for brepjs — IFC4-aligned parametric building elements",
   "keywords": [
     "bim",