fluidcad 0.0.32 → 0.0.34

package/lib/dist/filters/edge/belongs-to-face.js

@@ -1,16 +1,53 @@
+import { Face } from "../../common/shapes.js";
+import { Explorer } from "../../oc/explorer.js";
+import { TopologyIndex } from "../../oc/topology-index.js";
 import { FilterBase } from "../filter-base.js";
-export class BelongsToFaceFilter extends FilterBase {
+class BelongsToFaceFilterBase extends FilterBase {
     faceFilterBuilders;
+    scopeSolids = [];
     scopeFaces = [];
+    faceByHash = new Map();
     constructor(faceFilterBuilders) {
         super();
         this.faceFilterBuilders = faceFilterBuilders;
     }
-    setScopeFaces(faces) {
-        this.scopeFaces = faces;
+    setScopeIndex(solids, extraFaces, faceByHash) {
+        this.scopeSolids = solids;
+        this.scopeFaces = extraFaces;
+        this.faceByHash = faceByHash;
     }
+    findContainingFaces(edge) {
+        const edgeShape = edge.getShape();
+        const seen = new Set();
+        const result = [];
+        for (const solid of this.scopeSolids) {
+            const index = solid.getEdgeToFacesIndex();
+            const rawFaces = TopologyIndex.seekShapes(index, edgeShape);
+            for (const raw of rawFaces) {
+                const wrapper = resolveFaceWrapper(raw, this.faceByHash);
+                if (wrapper && !seen.has(wrapper)) {
+                    seen.add(wrapper);
+                    result.push(wrapper);
+                }
+            }
+        }
+        if (this.scopeFaces.length > 0) {
+            for (const face of this.scopeFaces) {
+                if (seen.has(face)) {
+                    continue;
+                }
+                if (face.hasEdge(edgeShape) !== null) {
+                    seen.add(face);
+                    result.push(face);
+                }
+            }
+        }
+        return result;
+    }
+}
+export class BelongsToFaceFilter extends BelongsToFaceFilterBase {
     match(shape) {
-        const containingFaces = this.scopeFaces.filter(face => face.hasEdge(shape.getShape()) !== null);
+        const containingFaces = this.findContainingFaces(shape);
         return this.faceFilterBuilders.every(builder => {
             const filters = builder.getFilters();
             return containingFaces.some(face => filters.every(f => f.match(face)));
@@ -32,18 +69,9 @@ export class BelongsToFaceFilter extends FilterBase {
         return new BelongsToFaceFilter(transformed);
     }
 }
-export class NotBelongsToFaceFilter extends FilterBase {
-    faceFilterBuilders;
-    scopeFaces = [];
-    constructor(faceFilterBuilders) {
-        super();
-        this.faceFilterBuilders = faceFilterBuilders;
-    }
-    setScopeFaces(faces) {
-        this.scopeFaces = faces;
-    }
+export class NotBelongsToFaceFilter extends BelongsToFaceFilterBase {
     match(shape) {
-        const containingFaces = this.scopeFaces.filter(face => face.hasEdge(shape.getShape()) !== null);
+        const containingFaces = this.findContainingFaces(shape);
         return !this.faceFilterBuilders.every(builder => {
             const filters = builder.getFilters();
             return containingFaces.some(face => filters.every(f => f.match(face)));
@@ -65,3 +93,24 @@ export class NotBelongsToFaceFilter extends FilterBase {
         return new NotBelongsToFaceFilter(transformed);
     }
 }
+function resolveFaceWrapper(rawFace, faceByHash) {
+    const hash = rawFace.HashCode(2147483647);
+    const bucket = faceByHash.get(hash);
+    if (bucket) {
+        for (const candidate of bucket) {
+            if (candidate.getShape().IsSame(rawFace)) {
+                return candidate;
+            }
+        }
+    }
+    // Not in scope (e.g. neighbor face from another part / out-of-scope solid).
+    // Wrap on the fly so the face filters can still evaluate it.
+    const wrapped = Face.fromTopoDSFace(Explorer.toFace(rawFace));
+    if (!bucket) {
+        faceByHash.set(hash, [wrapped]);
+    }
+    else {
+        bucket.push(wrapped);
+    }
+    return wrapped;
+}

package/lib/dist/filters/filter-builder-base.d.ts

@@ -1,12 +1,37 @@
 import { Shape } from "../common/shapes.js";
 import { FilterBase } from "./filter-base.js";
+export type IndexSelector = {
+    type: 'first';
+} | {
+    type: 'last';
+} | {
+    type: 'at';
+    index: number;
+};
 export declare class FilterBuilderBase<TShape extends Shape = Shape> {
     protected filters: FilterBase<TShape>[];
     protected _withTangents: boolean;
+    protected _indexSelector?: IndexSelector;
     filter(filter: FilterBase<TShape>): this;
     /**
      * Expands the selection to include all shapes transitively connected
      * by tangency (G1 continuity) to the initially matched shapes.
      */
     withTangents(): this;
+    /**
+     * Selects the first matching shape (in iteration order). If called multiple
+     * times on the same builder, the last positional call wins.
+     */
+    first(): this;
+    /**
+     * Selects the last matching shape (in iteration order). If called multiple
+     * times on the same builder, the last positional call wins.
+     */
+    last(): this;
+    /**
+     * Selects the matching shape at the given zero-based index.
+     * Out-of-range indices yield no match. Negative indices are not supported;
+     * use {@link last} for the final element.
+     */
+    at(index: number): this;
 }

package/lib/dist/filters/filter-builder-base.js

@@ -1,6 +1,7 @@
 export class FilterBuilderBase {
     filters = [];
     _withTangents = false;
+    _indexSelector;
     filter(filter) {
         this.filters.push(filter);
         return this;
@@ -13,6 +14,34 @@ export class FilterBuilderBase {
         this._withTangents = true;
         return this;
     }
+    /**
+     * Selects the first matching shape (in iteration order). If called multiple
+     * times on the same builder, the last positional call wins.
+     */
+    first() {
+        this._indexSelector = { type: 'first' };
+        return this;
+    }
+    /**
+     * Selects the last matching shape (in iteration order). If called multiple
+     * times on the same builder, the last positional call wins.
+     */
+    last() {
+        this._indexSelector = { type: 'last' };
+        return this;
+    }
+    /**
+     * Selects the matching shape at the given zero-based index.
+     * Out-of-range indices yield no match. Negative indices are not supported;
+     * use {@link last} for the final element.
+     */
+    at(index) {
+        if (!Number.isInteger(index) || index < 0) {
+            throw new Error(`at(index): index must be a non-negative integer (got ${index}). Use last() for the final element.`);
+        }
+        this._indexSelector = { type: 'at', index };
+        return this;
+    }
     /**
       * @internal
     */
@@ -22,6 +51,12 @@ export class FilterBuilderBase {
     /**
       * @internal
     */
+    getIndexSelector() {
+        return this._indexSelector;
+    }
+    /**
+      * @internal
+    */
     getFilters() {
         return this.filters;
     }
@@ -34,6 +69,9 @@ export class FilterBuilderBase {
             transformedBuilder.filter(filter.transform(matrix));
         }
         transformedBuilder._withTangents = this._withTangents;
+        // Index is invariant under Matrix4: the selector is re-applied against
+        // the transformed shape's own ordered match list at evaluation time.
+        transformedBuilder._indexSelector = this._indexSelector;
         return transformedBuilder;
     }
     /**
@@ -45,6 +83,7 @@ export class FilterBuilderBase {
             remappedBuilder.filter(filter.remap(remap));
         }
         remappedBuilder._withTangents = this._withTangents;
+        remappedBuilder._indexSelector = this._indexSelector;
         return remappedBuilder;
     }
     /**
@@ -54,6 +93,14 @@ export class FilterBuilderBase {
         if (this._withTangents !== other._withTangents) {
             return false;
         }
+        const a = this._indexSelector;
+        const b = other._indexSelector;
+        if ((a?.type) !== (b?.type)) {
+            return false;
+        }
+        if (a?.type === 'at' && b?.type === 'at' && a.index !== b.index) {
+            return false;
+        }
         if (this.filters.length !== other.filters.length) {
             return false;
         }

package/lib/dist/filters/filter.js

@@ -10,30 +10,55 @@ export class ShapeFilter {
         if (!this.builders?.length) {
             return this.shapes;
         }
-        const result = [];
-        for (const shape of this.shapes) {
-            for (const filter of this.builders) {
-                const filters = filter.getFilters();
-                if (filters.every(f => {
+        const result = new Set();
+        for (const builder of this.builders) {
+            const filters = builder.getFilters();
+            // Per-builder ordered match list — preserves input (OCC iteration) order
+            // so positional selectors (.first/.last/.at) are deterministic.
+            const matched = [];
+            for (const shape of this.shapes) {
+                let ok = true;
+                for (const f of filters) {
                     try {
-                        return f.match(shape);
+                        if (!f.match(shape)) {
+                            ok = false;
+                            break;
+                        }
                     }
                     catch (e) {
                         console.error('Error applying filter:', e, f);
-                        return false;
-                    }
-                })) {
-                    if (!result.includes(shape)) {
-                        result.push(shape);
+                        ok = false;
+                        break;
                     }
                 }
+                if (ok) {
+                    matched.push(shape);
+                }
+            }
+            const sel = builder.getIndexSelector();
+            let selected;
+            if (!sel) {
+                selected = matched;
+            }
+            else if (sel.type === 'first') {
+                selected = matched.length > 0 ? [matched[0]] : [];
+            }
+            else if (sel.type === 'last') {
+                selected = matched.length > 0 ? [matched[matched.length - 1]] : [];
+            }
+            else {
+                selected = sel.index < matched.length ? [matched[sel.index]] : [];
+            }
+            for (const s of selected) {
+                result.add(s);
             }
         }
+        const resultArr = [...result];
         // Tangent expansion: if any builder requests it, expand result set via BFS
         const needsExpansion = this.builders.some(b => b.hasTangentExpansion());
-        if (needsExpansion && result.length > 0) {
-            return TangentExpander.expand(result, this.shapes);
+        if (needsExpansion && resultArr.length > 0) {
+            return TangentExpander.expand(resultArr, this.shapes);
         }
-        return result;
+        return resultArr;
     }
 }

package/lib/dist/filters/from-object.d.ts

@@ -1,3 +1,4 @@
+import type { TopTools_MapOfShape } from "occjs-wrapper";
 import { Matrix4 } from "../math/matrix4.js";
 import { Shape } from "../common/shapes.js";
 import { ShapeType } from "../common/shape-type.js";
@@ -6,8 +7,11 @@ import { FilterBase } from "./filter-base.js";
 export declare class FromSceneObjectFilter<TShape extends Shape> extends FilterBase<TShape> {
     private sceneObjects;
     private shapeType;
+    private membershipSet;
     constructor(sceneObjects: SceneObject[], shapeType: ShapeType);
     getSceneObjects(): SceneObject[];
+    getShapeType(): ShapeType;
+    setMembershipSet(set: TopTools_MapOfShape | null): void;
     match(shape: TShape): boolean;
     compareTo(other: FromSceneObjectFilter<TShape>): boolean;
     transform(_matrix: Matrix4): FromSceneObjectFilter<TShape>;

package/lib/dist/filters/from-object.js

@@ -2,6 +2,7 @@ import { FilterBase } from "./filter-base.js";
 export class FromSceneObjectFilter extends FilterBase {
     sceneObjects;
     shapeType;
+    membershipSet = null;
     constructor(sceneObjects, shapeType) {
         super();
         this.sceneObjects = sceneObjects;
@@ -10,7 +11,16 @@ export class FromSceneObjectFilter extends FilterBase {
     getSceneObjects() {
         return this.sceneObjects;
     }
+    getShapeType() {
+        return this.shapeType;
+    }
+    setMembershipSet(set) {
+        this.membershipSet = set;
+    }
     match(shape) {
+        if (this.membershipSet) {
+            return this.membershipSet.Contains(shape.getShape());
+        }
         for (const obj of this.sceneObjects) {
             const subShapes = obj.getShapes().flatMap(s => s.getSubShapes(this.shapeType));
             if (subShapes.some(sub => sub.isSame(shape))) {

package/lib/dist/helpers/clone-transform.d.ts

@@ -1,3 +1,4 @@
 import { Matrix4 } from "../math/matrix4.js";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 import { SceneObject } from "../common/scene-object.js";
-export declare function cloneWithTransform(objects: SceneObject[], transform: Matrix4, container: SceneObject): SceneObject[];
+export declare function cloneWithTransform(objects: SceneObject[], transform: Matrix4 | LazyMatrix, container: SceneObject): SceneObject[];

package/lib/dist/helpers/scene-helpers.d.ts

@@ -12,7 +12,7 @@ export declare function fuseWithSceneObjects(sceneObjects: SceneObject[], extrus
     modifiedShapes: any[];
     toolHistory?: undefined;
 } | {
-    newShapes: Shape<import("occjs-wrapper").TopoDS_Shape>[];
+    newShapes: Shape<any>[];
     modifiedShapes: {
         shape: Shape<any>;
         object: SceneObject;

package/lib/dist/helpers/scene-helpers.js

@@ -42,23 +42,105 @@ export function fuseWithSceneObjects(sceneObjects, extrusions, opts) {
     // stay on their original owners so we must not duplicate them.
     const unconsumed = sceneShapes.filter(s => !modifiedShapes.includes(s));
     const shapesToAdd = result.filter(s => !unconsumed.some(u => u.getShape().IsPartner(s.getShape())));
+    // Clean each addition with UnifySameDomain so that coplanar wall pieces
+    // split by the boolean fuse merge back into single faces (the visible
+    // "artifact seams" on the target solid). Lineage is captured per cleanup
+    // so downstream history can be remapped onto post-clean faces.
+    const cleanedShapesToAdd = [];
+    const cleanups = [];
+    const runCleanups = () => {
+        for (const shape of shapesToAdd) {
+            const cleanup = ShapeOps.cleanShapeWithLineage(shape);
+            cleanedShapesToAdd.push(cleanup.shape);
+            cleanups.push(cleanup);
+        }
+    };
+    p ? p.record('Clean fuse result', runCleanups) : runCleanups();
     let toolHistory;
     if (opts?.recordHistoryFor) {
         const recordHistory = () => {
-            recordFusionHistory(opts.recordHistoryFor, sceneShapes, objShapeMap, shapesToAdd, maker, p);
+            recordFusionHistory(opts.recordHistoryFor, sceneShapes, objShapeMap, cleanedShapesToAdd, maker, cleanups, p);
             // Separately track tool-side (extrusion) lineage so callers can remap
             // pre-fusion categorizations (start/end/side/…) onto the post-fusion
-            // faces. We don't store these as modifications on any scene object —
-            // from the user's POV they are additions on the caller already.
-            // Tool-side history is only consumed by `remapClassifiedFaces`, which
-            // touches modifiedFaces only — skip the added* output traversal.
+            // faces. Tool-side history is only consumed by `remapClassifiedFaces`,
+            // which touches modifiedFaces only — skip the added* output traversal.
             const collectTools = () => ShapeHistoryTracker.collect(maker, extrusions, { skipAdded: true });
-            toolHistory = p ? p.record('Collect tool history', collectTools) : collectTools();
+            const rawToolHistory = p ? p.record('Collect tool history', collectTools) : collectTools();
+            toolHistory = remapHistoryThroughCleanups(rawToolHistory, cleanups);
         };
         p ? p.record('Record fusion history', recordHistory) : recordHistory();
     }
+    for (const cleanup of cleanups) {
+        cleanup.dispose();
+    }
     dispose();
-    return { newShapes: shapesToAdd, modifiedShapes: modified, toolHistory };
+    return { newShapes: cleanedShapesToAdd, modifiedShapes: modified, toolHistory };
+}
+// Remap a pre-clean history through a set of cleanup lineages. Modified
+// records get their result faces/edges replaced with the post-clean image;
+// records whose results entirely vanish during cleanup are dropped (the
+// caller will have already recorded removals for the corresponding sources).
+function remapHistoryThroughCleanups(history, cleanups) {
+    const remapFaces = (faces) => {
+        const out = [];
+        for (const f of faces) {
+            let mapped = null;
+            for (const c of cleanups) {
+                const r = c.remapFace(f);
+                if (r !== null) {
+                    mapped = r;
+                    break;
+                }
+            }
+            if (mapped) {
+                out.push(...mapped);
+            }
+            else {
+                out.push(f);
+            }
+        }
+        return out;
+    };
+    const remapEdges = (edges) => {
+        const out = [];
+        for (const e of edges) {
+            let mapped = null;
+            for (const c of cleanups) {
+                const r = c.remapEdge(e);
+                if (r !== null) {
+                    mapped = r;
+                    break;
+                }
+            }
+            if (mapped) {
+                out.push(...mapped);
+            }
+            else {
+                out.push(e);
+            }
+        }
+        return out;
+    };
+    return {
+        addedFaces: remapFaces(history.addedFaces),
+        modifiedFaces: history.modifiedFaces
+            .map(r => ({ sources: r.sources, results: remapFaces(r.results) }))
+            .filter(r => r.results.length > 0),
+        generatedFaces: history.generatedFaces.map(r => ({
+            sources: r.sources,
+            results: remapFaces(r.results),
+        })),
+        removedFaces: history.removedFaces,
+        addedEdges: remapEdges(history.addedEdges),
+        modifiedEdges: history.modifiedEdges
+            .map(r => ({ sources: r.sources, results: remapEdges(r.results) }))
+            .filter(r => r.results.length > 0),
+        generatedEdges: history.generatedEdges.map(r => ({
+            sources: r.sources,
+            results: remapEdges(r.results),
+        })),
+        removedEdges: history.removedEdges,
+    };
 }
 /**
  * Record faces/edges from each shape as additions on `caller`. Used when a
@@ -86,12 +168,50 @@ function recordShapesAsAdditions(caller, shapes) {
  * of a scene-shape modification. This captures both extrusion-derived faces
  * (which appear in the result via tool-side Modified()) and truly new faces.
  */
-function recordFusionHistory(caller, sceneShapes, owners, newShapes, maker, p) {
+function recordFusionHistory(caller, sceneShapes, owners, newShapes, maker, cleanups, p) {
     const oc = getOC();
     const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
     const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
     const claimedFaces = new oc.TopTools_MapOfShape();
     const claimedEdges = new oc.TopTools_MapOfShape();
+    // Remap pre-clean faces/edges through whichever cleanup handled them,
+    // mirroring the cut-side helper. Faces no cleanup knew about pass through.
+    const remapFaces = (faces) => {
+        const out = [];
+        for (const face of faces) {
+            let matched = false;
+            for (const cleanup of cleanups) {
+                const remapped = cleanup.remapFace(face);
+                if (remapped !== null) {
+                    out.push(...remapped);
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                out.push(face);
+            }
+        }
+        return out;
+    };
+    const remapEdges = (edges) => {
+        const out = [];
+        for (const edge of edges) {
+            let matched = false;
+            for (const cleanup of cleanups) {
+                const remapped = cleanup.remapEdge(edge);
+                if (remapped !== null) {
+                    out.push(...remapped);
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                out.push(edge);
+            }
+        }
+        return out;
+    };
     const collectScene = () => {
         for (const sceneShape of sceneShapes) {
             const owner = owners.get(sceneShape);
@@ -103,14 +223,28 @@ function recordFusionHistory(caller, sceneShapes, owners, newShapes, maker, p) {
             // need to compute its own added* sets.
             const history = ShapeHistoryTracker.collect(maker, [sceneShape], { skipAdded: true });
             for (const record of history.modifiedFaces) {
-                owner.recordModifiedFaces(record.sources, record.results, caller);
-                for (const r of record.results) {
+                const postCleanResults = remapFaces(record.results);
+                if (postCleanResults.length === 0) {
+                    for (const src of record.sources) {
+                        owner.recordRemovedFace(src, caller);
+                    }
+                    continue;
+                }
+                owner.recordModifiedFaces(record.sources, postCleanResults, caller);
+                for (const r of postCleanResults) {
                     claimedFaces.Add(r.getShape());
                 }
             }
             for (const record of history.modifiedEdges) {
-                owner.recordModifiedEdges(record.sources, record.results, caller);
-                for (const r of record.results) {
+                const postCleanResults = remapEdges(record.results);
+                if (postCleanResults.length === 0) {
+                    for (const src of record.sources) {
+                        owner.recordRemovedEdge(src, caller);
+                    }
+                    continue;
+                }
+                owner.recordModifiedEdges(record.sources, postCleanResults, caller);
+                for (const r of postCleanResults) {
                     claimedEdges.Add(r.getShape());
                 }
             }

package/lib/dist/index.d.ts

@@ -17,7 +17,13 @@ export type SceneParserContext = {
     getActiveSketch(): Sketch | null;
 };
 export declare function registerBuilder<T extends Function>(builder: (context: SceneParserContext) => T): T;
-export declare function init(rootPath?: string): Promise<{
+export interface FluidCADOptions {
+    mesh?: {
+        lineDeflection?: number;
+        angularDeflection?: number;
+    };
+}
+export declare function init(options?: FluidCADOptions): Promise<{
     currentScene: Scene;
     currentFile: string;
     renderer: import("./rendering/render.js").SceneRenderer;

package/lib/dist/index.js

@@ -88,8 +88,8 @@ export function registerBuilder(builder) {
     return fn;
     ;
 }
-export async function init(rootPath) {
+export async function init(options) {
     await loadOC();
-    const resolvedPath = rootPath || process.env.FLUIDCAD_WORKSPACE_PATH || '';
-    return createManager(resolvedPath);
+    const resolvedPath = process.env.FLUIDCAD_WORKSPACE_PATH || '';
+    return createManager(resolvedPath, options);
 }

package/lib/dist/io/file-import.d.ts

@@ -4,5 +4,9 @@ export declare class FileImport {
     static deserializeShapes(fileName: string): Solid[];
     static serializeShape(shape: Shape, workspacePath: string, fileName: string): void;
     static importFile(workspacePath: string, fileName: string, data: Uint8Array): Solid[];
-    static deserializeShapesWithMetadata(fileName: string): Solid[];
+    static deserializeShapesWithMetadata(fileName: string, options?: {
+        noColors?: boolean;
+        include?: Set<number>;
+        exclude?: Set<number>;
+    }): Solid[];
 }

package/lib/dist/io/file-import.js

@@ -49,32 +49,43 @@ export class FileImport {
         console.log(`Imported ${solids.length} solids with color metadata`);
         return solids;
     }
-    static deserializeShapesWithMetadata(fileName) {
+    static deserializeShapesWithMetadata(fileName, options) {
         // Read geometry from .brep
         const brepFileName = fileName.replace(/\.(step|stp|brep)$/i, '');
         const shapes = FileImport.deserializeShapes(brepFileName);
-        // Read color metadata from JSON sidecar
-        const sceneManager = getSceneManager();
-        const jsonPath = join(sceneManager.rootPath, 'imports', brepFileName + '.colors.json');
+        // Read color metadata from JSON sidecar (skipped when noColors is set)
         let colorData = [];
-        if (fs.existsSync(jsonPath)) {
-            colorData = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
-            console.log(`Loaded color metadata from ${jsonPath}`);
+        if (!options?.noColors) {
+            const sceneManager = getSceneManager();
+            const jsonPath = join(sceneManager.rootPath, 'imports', brepFileName + '.colors.json');
+            if (fs.existsSync(jsonPath)) {
+                colorData = JSON.parse(fs.readFileSync(jsonPath, 'utf8'));
+                console.log(`Loaded color metadata from ${jsonPath}`);
+            }
         }
-        // Build Solid objects and apply colors by face index
-        const solids = shapes.map((shape, solidIndex) => {
-            const solid = shape;
+        const include = options?.include;
+        const exclude = options?.exclude;
+        // Build Solid objects, filter by original index, and apply colors by face index.
+        const solids = [];
+        for (let solidIndex = 0; solidIndex < shapes.length; solidIndex++) {
+            if (include && !include.has(solidIndex)) {
+                continue;
+            }
+            if (exclude && exclude.has(solidIndex)) {
+                continue;
+            }
+            const solid = shapes[solidIndex];
             const solidColors = colorData[solidIndex];
-            if (!solidColors)
-                return solid;
-            const faces = OcIO.findFaces(solid);
-            for (const entry of solidColors.faces) {
-                if (entry.faceIndex < faces.length) {
-                    solid.setColor(faces[entry.faceIndex].getShape(), entry.color);
+            if (solidColors) {
+                const faces = OcIO.findFaces(solid);
+                for (const entry of solidColors.faces) {
+                    if (entry.faceIndex < faces.length) {
+                        solid.setColor(faces[entry.faceIndex].getShape(), entry.color);
+                    }
                 }
             }
-            return solid;
-        });
+            solids.push(solid);
+        }
         console.log(`Deserialized ${solids.length} solids with color metadata`);
         return solids;
     }