@bldrs-ai/conway 1.543.1513 → 1.549.1515

package/compiled/src/ifc/ifc_geometry_extraction.js

@@ -8,7 +8,7 @@ import { CanonicalMeshType } from "../core/canonical_mesh.js";
 import { yieldToEventLoop } from "../core/progress.js";
 import { ObjectPool } from "../core/native_pool.js";
 import { ExtractResult } from "../core/shared_constants.js";
-import { IfcArbitraryClosedProfileDef, IfcAxis2Placement2D, IfcAxis2Placement3D, IfcBooleanResult, IfcCartesianPointList2D, IfcCartesianPointList3D, IfcCartesianTransformationOperator3D, IfcCircleProfileDef, IfcColourRgb, IfcCompositeProfileDef, IfcDirection, IfcExtrudedAreaSolid, IfcGrid, IfcGridPlacement, IfcIndexedPolyCurve, IfcIndexedPolygonalFaceWithVoids, IfcLocalPlacement, IfcMappedItem, IfcOpeningElement, IfcOpeningStandardCase, IfcPolygonalFaceSet, IfcProduct, IfcReflectanceMethodEnum, IfcSpace, IfcSpecularExponent, IfcStyledItem, IfcSurfaceStyle, IfcSurfaceStyleRefraction, IfcSurfaceStyleRendering, IfcSurfaceStyleShading, IfcPresentationStyleAssignment, IfcSurfaceSide, IfcBooleanClippingResult, IfcCompositeCurve, IfcPolyline, IfcTrimmedCurve, IfcCartesianPoint, IfcParameterValue, IfcTrimmingPreference, IfcCircle, IfcHalfSpaceSolid, IfcPlane, IfcBoundingBox, IfcShellBasedSurfaceModel, IfcPolyLoop, IfcFacetedBrep, IfcRelAssociatesMaterial, IfcShapeRepresentation, IfcMaterialList, IfcMaterialDefinitionRepresentation, IfcMaterialLayerSetUsage, IfcMaterial, IfcRelVoidsElement, IfcRectangleProfileDef, IfcMaterialProfileSet, IfcMaterialConstituentSet, IfcMaterialConstituent, IfcMaterialProfile, IfcProject, IfcSIUnit, IfcSIPrefix, IfcUnitEnum, IfcSIUnitName, IfcConversionBasedUnit, IfcFaceBasedSurfaceModel, IfcArbitraryProfileDefWithVoids, IfcAdvancedBrep, IfcBSplineCurve, IfcBSplineSurface, IfcBSplineSurfaceWithKnots, IfcRationalBSplineSurfaceWithKnots, IfcCylindricalSurface, IfcSurfaceOfRevolution, IfcSurfaceOfLinearExtrusion, IfcRationalBSplineCurveWithKnots, IfcArbitraryOpenProfileDef, IfcBSplineCurveWithKnots, IfcEdgeLoop, IfcEdgeCurve, IfcVertexPoint, IfcRectangleHollowProfileDef, IfcEllipseProfileDef, IfcCircleHollowProfileDef, IfcIShapeProfileDef, IfcUShapeProfileDef, IfcDerivedProfileDef, IfcCartesianTransformationOperator2DnonUniform, IfcLShapeProfileDef, IfcCShapeProfileDef, IfcTShapeProfileDef, IfcZShapeProfileDef, IfcRelAggregates, IfcTriangulatedFaceSet, IfcPolygonalBoundedHalfSpace, IfcLine, IfcEllipse, IfcMaterialLayerSet, IfcSweptDiskSolid, IfcBlock, IfcRoundedRectangleProfileDef, IfcMaterialProfileSetUsage, IfcCompositeCurveSegment, IfcRevolvedAreaSolid, IfcFaceSurface, IfcVirtualGridIntersection, } from "./ifc4_gen/index.js";
+import { IfcArbitraryClosedProfileDef, IfcAxis2Placement2D, IfcAxis2Placement3D, IfcBooleanResult, IfcCartesianPointList2D, IfcCartesianPointList3D, IfcCartesianTransformationOperator3D, IfcCircleProfileDef, IfcColourRgb, IfcCompositeProfileDef, IfcDirection, IfcExtrudedAreaSolid, IfcGrid, IfcGridPlacement, IfcIndexedPolyCurve, IfcIndexedPolygonalFaceWithVoids, IfcLocalPlacement, IfcMappedItem, IfcOpeningElement, IfcOpeningStandardCase, IfcPolygonalFaceSet, IfcProduct, IfcReflectanceMethodEnum, IfcSpace, IfcSpecularExponent, IfcStyledItem, IfcSurfaceStyle, IfcSurfaceStyleRefraction, IfcSurfaceStyleRendering, IfcSurfaceStyleShading, IfcPresentationStyleAssignment, IfcSurfaceSide, IfcBooleanClippingResult, IfcCompositeCurve, IfcPolyline, IfcTrimmedCurve, IfcCartesianPoint, IfcParameterValue, IfcTrimmingPreference, IfcCircle, IfcHalfSpaceSolid, IfcPlane, IfcBoundingBox, IfcShellBasedSurfaceModel, IfcPolyLoop, IfcFacetedBrep, IfcRelAssociatesMaterial, IfcShapeRepresentation, IfcMaterialList, IfcMaterialDefinitionRepresentation, IfcMaterialLayerSetUsage, IfcMaterial, IfcRelVoidsElement, IfcRectangleProfileDef, IfcMaterialProfileSet, IfcMaterialConstituentSet, IfcMaterialConstituent, IfcMaterialProfile, IfcProject, IfcSIUnit, IfcSIPrefix, IfcUnitEnum, IfcSIUnitName, IfcConversionBasedUnit, IfcFaceBasedSurfaceModel, IfcArbitraryProfileDefWithVoids, IfcAdvancedBrep, IfcBSplineCurve, IfcBSplineSurface, IfcBSplineSurfaceWithKnots, IfcRationalBSplineSurfaceWithKnots, IfcCylindricalSurface, IfcSurfaceOfRevolution, IfcSurfaceOfLinearExtrusion, IfcRationalBSplineCurveWithKnots, IfcArbitraryOpenProfileDef, IfcBSplineCurveWithKnots, IfcEdgeLoop, IfcEdgeCurve, IfcVertexPoint, IfcRectangleHollowProfileDef, IfcEllipseProfileDef, IfcCircleHollowProfileDef, IfcIShapeProfileDef, IfcUShapeProfileDef, IfcDerivedProfileDef, IfcCartesianTransformationOperator2DnonUniform, IfcLShapeProfileDef, IfcCShapeProfileDef, IfcTShapeProfileDef, IfcZShapeProfileDef, IfcRelAggregates, IfcObjectDefinition, IfcTriangulatedFaceSet, IfcPolygonalBoundedHalfSpace, IfcLine, IfcEllipse, IfcMaterialLayerSet, IfcSweptDiskSolid, IfcBlock, IfcRoundedRectangleProfileDef, IfcMaterialProfileSetUsage, IfcCompositeCurveSegment, IfcRevolvedAreaSolid, IfcFaceSurface, IfcVirtualGridIntersection, } from "./ifc4_gen/index.js";
 import EntityTypesIfc from "./ifc4_gen/entity_types_ifc.gen.js";
 import { IfcSceneBuilder } from "./ifc_scene_builder.js";
 import Logger from "../logging/logger.js";
@@ -5462,10 +5462,28 @@ export class IfcGeometryExtraction {
             if (relating !== null && relating !== void 0) {
                 await this.ensureResidentForProductExtract(relating.localID, pinned, leafSpans);
             }
-            const related = relAggregate.RelatedObjects;
-            if (related !== null && related !== void 0) {
-                for (const product of related) {
-                    await this.ensureResidentForProductExtract(product.localID, pinned, leafSpans);
+            // By express ID rather than through `relAggregate.RelatedObjects`, for
+            // the reason relatedObjectExpressIDs_ documents: the getter memoizes
+            // the whole related-product array onto the relationship, and this
+            // prefetch runs immediately before the extract that must not retain
+            // it (conway#549 §4). Falls back to the getter for a list holding a
+            // non-reference entry, so the two paths agree on what is in the list.
+            const relatedExpressIDs = this.relatedObjectExpressIDs_(relAggregate);
+            if (relatedExpressIDs === void 0) {
+                const related = relAggregate.RelatedObjects;
+                if (related !== null && related !== void 0) {
+                    for (const product of related) {
+                        await this.ensureResidentForProductExtract(product.localID, pinned, leafSpans);
+                    }
+                }
+            }
+            else {
+                for (const relatedExpressID of relatedExpressIDs) {
+                    const relatedLocalID = this.model.resolveExpressID(relatedExpressID);
+                    if (relatedLocalID === void 0) {
+                        continue;
+                    }
+                    await this.ensureResidentForProductExtract(relatedLocalID, pinned, leafSpans);
                 }
             }
             return pinned;
@@ -5494,6 +5512,46 @@ export class IfcGeometryExtraction {
             this.extractRelAggregateGeometry(relAggregate);
         }
     }
+    /**
+     * Express IDs of one IfcRelAggregates' RelatedObjects, read straight off
+     * the relationship's own record.
+     *
+     * Deliberately NOT `relAggregate.RelatedObjects`: that generated getter
+     * memoizes the materialised entity array onto the relationship as
+     * `RelatedObjects_` (IfcRelAggregates.gen.ts), so every related product
+     * stays reachable for as long as the relationship does — and each product
+     * in turn memoizes the tessellation subtree its own getters walk
+     * (IfcPolyLoop.Polygon_, IfcCartesianPoint.Coordinates_, ...). The
+     * per-product graphs therefore SUM instead of overlapping. On SKYLARK250,
+     * whose 1,992 products are all aggregate targets, that is 2.7 GB of a
+     * 5.4 GB peak (conway#549 §4). Resolving one product at a time from IDs
+     * lets each graph die with its iteration, exactly as the ordinary product
+     * loop's iterator already does.
+     *
+     * The scan mirrors the getter's own parse — `forEachReferenceInField`
+     * runs the same optional/array-token walk over the same field
+     * coordinates — so it sees the same entries in the same order.
+     *
+     * @param relAggregate The relationship to read.
+     * @return {number[] | undefined} The related objects' express IDs in
+     * record order, or undefined when the list holds an entry that is not a
+     * `#N` reference — an inline entity, `$`, or junk. Only the generated
+     * getter can resolve (or reject) those, so the caller falls back to it
+     * rather than guessing.
+     */
+    relatedObjectExpressIDs_(relAggregate) {
+        const expressIDs = [];
+        let allReferences = true;
+        relAggregate.forEachReferenceInField(REL_AGGREGATES_RELATED_OFFSET, REL_AGGREGATES_RELATED_BASE, REL_AGGREGATES_RELATED_DEPTH, (expressID) => {
+            if (expressID === void 0) {
+                allReferences = false;
+                return false;
+            }
+            expressIDs.push(expressID);
+            return true;
+        });
+        return allReferences ? expressIDs : void 0;
+    }
     /**
      * Extract one IfcRelAggregates' related products with the relating
      * object's ("master") rel-voids — the shared per-item body of the
@@ -5505,23 +5563,87 @@ export class IfcGeometryExtraction {
      * @param relAggregate The rel-aggregates relationship to process.
      */
     extractRelAggregateGeometry(relAggregate) {
+        const stepper = this.extractRelAggregateGeometryIncremental(relAggregate);
+        let step = stepper.next();
+        while (step.done !== true) {
+            step = stepper.next();
+        }
+    }
+    /**
+     * Incremental twin of {@link extractRelAggregateGeometry}: identical
+     * extraction, suspending after each related product so a driver can
+     * report progress and yield to the event loop *inside* the relationship.
+     *
+     * Without this the whole rel-aggregates pass is a single unyielding call.
+     * On SKYLARK250 all 2,002 of the cooperative walk's suspension points
+     * fire in 16 ms — every product is an aggregate target, so the product
+     * loop skips them all — and the remaining ~60 s of real work runs inside
+     * two `extractRelAggregateGeometry` calls with no suspension point at
+     * all. That is the browser-tab hang in conway#549 §7, and it is
+     * independent of the memory fix: a small model with one big aggregate
+     * freezes the same way.
+     *
+     * Suspending here cannot show a caller a half-built product: the split is
+     * BETWEEN products, and each product's scene content is complete before
+     * the yield. Nor does it reorder emission — the products are visited in
+     * record order either way. Aggregate targets are skipped by the product
+     * pass (see aggregateTargetLocalIDs) and by the pump's product worklist,
+     * so a consumer that streams meshes mid-relationship sees the
+     * not-yet-reached products as absent rather than as uncut placeholders.
+     *
+     * @param relAggregate The rel-aggregates relationship to process.
+     * @yields {number} The number of related products extracted so far from
+     * THIS relationship, after each one.
+     */
+    *extractRelAggregateGeometryIncremental(relAggregate) {
+        // Held outside the try so the finally can free it on the abandonment
+        // path too: a driver that stops consuming (stepper.return()) unwinds
+        // through here, and the vector is native memory the GC cannot reclaim.
+        let masterRelVoids;
         try {
             // Note, this is required because the relating object
             // can be where the rel-void is applied, so we
             // used this as a top level over-ride for a rel-void.
             // for all objects in the aggregate - CS
             const relatingObject = relAggregate.RelatingObject;
-            const masterRelVoids = relatingObject instanceof IfcProduct ?
-                this.extractRelVoids(relatingObject) :
-                void 0;
-            const relatedObjects = relAggregate.RelatedObjects;
-            for (const productRepresentation of relatedObjects) {
-                if (productRepresentation instanceof IfcProduct) {
-                    this.extractProductGeometry(productRepresentation, masterRelVoids);
+            masterRelVoids =
+                relatingObject instanceof IfcProduct ?
+                    this.extractRelVoids(relatingObject) :
+                    void 0;
+            // Read before the first suspension point, deliberately: the scan
+            // reads the relationship's own record bytes, and a windowed source
+            // can page that record out while a later product is extracted.
+            const relatedExpressIDs = this.relatedObjectExpressIDs_(relAggregate);
+            let extractedCount = 0;
+            if (relatedExpressIDs === void 0) {
+                // Non-reference entry in the list — fall back to the generated
+                // getter, the only thing that can resolve an inline entity (and the
+                // only thing that decides an entry is unresolvable). Rare enough
+                // that keeping its retention is the right trade against duplicating
+                // inline resolution here.
+                for (const productRepresentation of relAggregate.RelatedObjects) {
+                    if (productRepresentation instanceof IfcProduct) {
+                        this.extractProductGeometry(productRepresentation, masterRelVoids);
+                        yield ++extractedCount;
+                    }
                 }
             }
-            if (masterRelVoids !== void 0) {
-                masterRelVoids[0].delete();
+            else {
+                for (const relatedExpressID of relatedExpressIDs) {
+                    const relatedObject = this.model.getTypedElementByExpressID(relatedExpressID, IfcObjectDefinition);
+                    if (relatedObject === void 0) {
+                        // What the getter does with the same entry: extractBufferElement
+                        // returns undefined for a reference that resolves to nothing (or
+                        // to something that is not an IfcObjectDefinition) and the getter
+                        // throws this exact message. The catch below then skips the whole
+                        // relationship, permissively, as it always has.
+                        throw new Error("Value in STEP was incorrectly typed");
+                    }
+                    if (relatedObject instanceof IfcProduct) {
+                        this.extractProductGeometry(relatedObject, masterRelVoids);
+                        yield ++extractedCount;
+                    }
+                }
             }
         }
         catch (ex) {
@@ -5537,6 +5659,11 @@ export class IfcGeometryExtraction {
                 Logger.error("Unknown exception processing IfcRelAssociateMaterials.");
             }
         }
+        finally {
+            if (masterRelVoids !== void 0) {
+                masterRelVoids[0].delete();
+            }
+        }
     }
     /**
      * Extract one product's geometry into the scene: placement, material /
@@ -5781,16 +5908,24 @@ export class IfcGeometryExtraction {
             }
             this.prepareExtractionMaps_();
             const products = this.model.types(IfcProduct);
-            // Prefix-sum counts (no iteration/materialization) — see typeCount.
-            // Slight over-count from multi-mapped elements just leaves the bar
-            // shy of 100% until endPhase; fine for progress.
-            const totalItems = this.model.typeCount(IfcProduct) + this.model.typeCount(IfcRelAggregates);
-            let completedItems = 0;
             // Products the aggregates pass re-extracts are SKIPPED here and
             // extracted exactly once, below, with the master rel-voids — one
             // scene instance per placement and no content replacement after
             // emission (see aggregateTargetLocalIDs).
             const aggregateTargets = this.aggregateTargetLocalIDs();
+            // Prefix-sum counts (no iteration/materialization) — see typeCount.
+            // Slight over-count from multi-mapped elements just leaves the bar
+            // shy of 100% until endPhase; fine for progress.
+            //
+            // Aggregate targets are counted TWICE on purpose — once for the tick
+            // the product loop spends skipping each of them, once for the tick
+            // the rel-aggregates pass spends extracting it. On a model whose
+            // products are all aggregate targets that is the difference between
+            // a bar that reaches 100% in the first 16 ms and then sits there for
+            // the entire extraction, and one that tracks the work.
+            let totalItems = this.model.typeCount(IfcProduct) + this.model.typeCount(IfcRelAggregates) +
+                aggregateTargets.size;
+            let completedItems = 0;
             for (const product of products) {
                 yield [++completedItems, totalItems];
                 if (aggregateTargets.has(product.localID)) {
@@ -5825,7 +5960,22 @@ export class IfcGeometryExtraction {
             const relAggregates = this.model.types(IfcRelAggregates);
             for (const relAggregate of relAggregates) {
                 yield [++completedItems, totalItems];
-                this.extractRelAggregateGeometry(relAggregate);
+                // Step the relationship rather than running it in one call: on an
+                // aggregate-structured model this pass IS the extraction, and
+                // without a suspension point inside it the cooperative driver
+                // awaits nothing for the whole of it (conway#549 §7). for-of, not a
+                // manual next() loop, so abandoning this generator closes the inner
+                // one and frees its master rel-voids vector.
+                const aggregateBase = completedItems;
+                for (const extractedInAggregate of this.extractRelAggregateGeometryIncremental(relAggregate)) {
+                    completedItems = aggregateBase + extractedInAggregate;
+                    // The total counts one item per product and one per relationship,
+                    // so a product reached through more than one relationship can
+                    // push completed past it. Widen rather than let the bar exceed
+                    // 100% or go backwards.
+                    totalItems = Math.max(totalItems, completedItems);
+                    yield [completedItems, totalItems];
+                }
             }
             if (RegressionCaptureState.memoization !== MemoizationCapture.FULL) {
                 this.model.geometry.deleteTemporaries();

package/compiled/src/ifc/ifc_rel_aggregate_extraction.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ifc_rel_aggregate_extraction.test.d.ts.map

package/compiled/src/ifc/ifc_rel_aggregate_extraction.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifc_rel_aggregate_extraction.test.d.ts","sourceRoot":"","sources":["../../../src/ifc/ifc_rel_aggregate_extraction.test.ts"],"names":[],"mappings":""}

package/compiled/src/ifc/ifc_rel_aggregate_extraction.test.js

@@ -0,0 +1,115 @@
+import fs from "fs";
+import { beforeAll, describe, expect, test } from "@jest/globals";
+import { ConwayGeometry } from "../../dependencies/conway-geom/index.js";
+import ParsingBuffer from "../parsing/parsing_buffer.js";
+import { IfcGeometryExtraction } from "./ifc_geometry_extraction.js";
+import IfcStepParser from "./ifc_step_parser.js";
+import { IfcProduct, IfcRelAggregates } from "./ifc4_gen/index.js";
+const conwayGeometry = new ConwayGeometry();
+/** Wasm init plus two full extractions per test; CI runners are slow. */
+// eslint-disable-next-line no-magic-numbers
+const TEST_TIMEOUT_MS = 120 * 1000;
+/** Fixtures that carry at least one IfcRelAggregates. */
+const AGGREGATE_FIXTURES = [
+    "data/index.ifc",
+    "data/aggregate_master_voids.ifc",
+];
+/**
+ * Parse a fixture into a fresh model.
+ *
+ * @param fixturePath The IFC file to parse.
+ * @return {IfcStepModel} The parsed model.
+ */
+function parseFixtureModel(fixturePath) {
+    const parser = IfcStepParser.Instance;
+    const bufferInput = new ParsingBuffer(fs.readFileSync(fixturePath));
+    parser.parseHeader(bufferInput);
+    const model = parser.parseDataToModel(bufferInput)[1];
+    expect(model).toBeDefined();
+    return model;
+}
+/**
+ * Count the IfcProducts the rel-aggregates pass will extract — the related
+ * objects of every IfcRelAggregates, which is one extraction each.
+ *
+ * @param model The model to count over.
+ * @return {number} The number of related products.
+ */
+function relatedProductCount(model) {
+    let count = 0;
+    for (const relAggregate of model.types(IfcRelAggregates)) {
+        for (const relatedObject of relAggregate.RelatedObjects) {
+            if (relatedObject instanceof IfcProduct) {
+                ++count;
+            }
+        }
+    }
+    return count;
+}
+beforeAll(async () => {
+    await conwayGeometry.initialize();
+});
+describe("rel-aggregates extraction (conway#549)", () => {
+    test("suspends once per related product, not once per relationship", () => {
+        // The tab-hang half of #549. The whole-model walk skips every aggregate
+        // target in its product loop and does the real work in the
+        // rel-aggregates pass, so a pass that suspends only between
+        // RELATIONSHIPS gives a cooperative driver nothing to yield on: on
+        // SKYLARK250 all 2,002 suspension points fire in 16 ms and the
+        // remaining ~60 s runs inside two calls with none at all.
+        //
+        // Counted rather than merely "more than before", so this fails on a
+        // pass that suspends per relationship AND on one that suspends at some
+        // other granularity.
+        for (const fixturePath of AGGREGATE_FIXTURES) {
+            const model = parseFixtureModel(fixturePath);
+            const products = model.typeCount(IfcProduct);
+            const relationships = model.typeCount(IfcRelAggregates);
+            const relatedProducts = relatedProductCount(model);
+            expect(relationships).toBeGreaterThan(0);
+            expect(relatedProducts).toBeGreaterThan(0);
+            const extraction = new IfcGeometryExtraction(conwayGeometry, model);
+            const ticks = [];
+            extraction.extractIFCGeometryData((completed, total) => ticks.push([completed, total]));
+            expect(ticks.length)
+                .toBe(products + relationships + relatedProducts);
+            // Still monotonic, still bounded by the total it reports.
+            for (let where = 1; where < ticks.length; ++where) {
+                expect(ticks[where][0]).toBeGreaterThan(ticks[where - 1][0]);
+                expect(ticks[where][0]).toBeLessThanOrEqual(ticks[where][1]);
+            }
+        }
+    }, TEST_TIMEOUT_MS);
+    test("does not leave the related-product array memoized on the relationship", () => {
+        // The memory half of #549. `RelatedObjects` memoizes the
+        // materialised entity array onto the relationship as
+        // `RelatedObjects_`, and each of those products in turn memoizes the
+        // tessellation subtree its getters walk — so a pass that reads the
+        // getter keeps the whole model's face/loop/point graph alive for the
+        // length of the relationship instead of one product at a time. On
+        // SKYLARK250 that is 2.7 GB of a 5.4 GB peak.
+        //
+        // White-box on the generated field name deliberately: the retention
+        // IS the field, and there is no black-box way to observe reachability
+        // from a test. If codegen renames it, this test stops testing
+        // anything, so it also asserts the field exists to be set.
+        for (const fixturePath of AGGREGATE_FIXTURES) {
+            const model = parseFixtureModel(fixturePath);
+            const extraction = new IfcGeometryExtraction(conwayGeometry, model);
+            extraction.extractIFCGeometryData();
+            let checked = 0;
+            for (const relAggregate of model.types(IfcRelAggregates)) {
+                const memo = relAggregate.RelatedObjects_;
+                expect(memo).toBeUndefined();
+                // Reading the getter must still populate it — i.e. the field is
+                // the one the getter memoizes into, so the assertion above is
+                // meaningful rather than vacuous.
+                expect(relAggregate.RelatedObjects).toBeDefined();
+                expect(relAggregate.RelatedObjects_)
+                    .toBeDefined();
+                ++checked;
+            }
+            expect(checked).toBeGreaterThan(0);
+        }
+    }, TEST_TIMEOUT_MS);
+});

package/compiled/src/scripts/bless_perf_snapshot.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bless_perf_snapshot.test.d.ts.map

package/compiled/src/scripts/bless_perf_snapshot.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bless_perf_snapshot.test.d.ts","sourceRoot":"","sources":["../../../src/scripts/bless_perf_snapshot.test.ts"],"names":[],"mappings":""}