@bldrs-ai/conway 1.530.1503 → 1.535.1506

package/compiled/examples/browser-bundled.cjs

@@ -30,7 +30,7 @@ var import_node_process = require("node:process");
 var readline = __toESM(require("node:readline"), 1);
 
 // compiled/src/version/version.js
-var versionString = "Conway v1.530.1503";
+var versionString = "Conway v1.535.1506";
 
 // compiled/dependencies/conway-geom/interface/conway_geometry.js
 var wasmType = "";
@@ -71239,6 +71239,257 @@ var CanonicalMeshType;
   CanonicalMeshType2[CanonicalMeshType2["BUFFER_GEOMETRY"] = 0] = "BUFFER_GEOMETRY";
 })(CanonicalMeshType || (CanonicalMeshType = {}));
 
+// compiled/src/ifc/geometry_residency.js
+var BYTES_PER_VERTEX_ELEMENT = 8;
+var BYTES_PER_INDEX_ELEMENT = 4;
+var VOID_STORE_BIT = 1;
+var BYTES_PER_MIB = 1024 * 1024;
+var GeometryResidency = class {
+  constructor() {
+    this.budgetBytes_ = Number.POSITIVE_INFINITY;
+    this.liveBytes_ = 0;
+    this.everEvicted_ = false;
+    this.order_ = /* @__PURE__ */ new Map();
+    this.natives_ = /* @__PURE__ */ new Map();
+    this.stores_ = [];
+  }
+  /**
+   * @return {boolean} Whether a finite budget is configured. Every hook below
+   * returns immediately when this is false, so an unbudgeted model pays one
+   * predictable-branch per geometry add and lookup rather than the
+   * bookkeeping — `getByLocalID` is on the scene-walk hot path.
+   */
+  get enabled() {
+    return this.budgetBytes_ !== Number.POSITIVE_INFINITY;
+  }
+  /**
+   * @return {number} The configured budget in bytes, or Infinity.
+   */
+  get budgetBytes() {
+    return this.budgetBytes_;
+  }
+  /**
+   * @return {number} Bytes currently accounted resident.
+   */
+  get liveBytes() {
+    return this.liveBytes_;
+  }
+  /**
+   * @return {number} How many assets are tracked.
+   */
+  get residentCount() {
+    return this.order_.size;
+  }
+  /**
+   * @return {boolean} Whether this model has ever had geometry evicted.
+   */
+  get everEvicted() {
+    return this.everEvicted_;
+  }
+  /**
+   * Register a store so a budget enabled later can see what it already
+   * holds.
+   *
+   * @param store The store.
+   */
+  registerStore(store) {
+    this.stores_.push(store);
+  }
+  /**
+   * Set the budget. A non-finite or non-positive value disables eviction,
+   * which is the default and the behaviour every consumer had before this
+   * existed.
+   *
+   * Raising or lowering it takes effect at the next eviction pass rather than
+   * immediately, so a caller that lowers the budget mid-load does not stall
+   * the current batch freeing memory.
+   *
+   * **Enabling seeds from what is already cached.** The bookkeeping is fed
+   * by `noteAdded`, which no-ops while unlimited, so a model that pumped
+   * batches before a budget arrived — or one whose budget was disabled and
+   * re-enabled — would start counting from zero and evict nothing until it
+   * had extracted a budget's worth MORE geometry. The pre-existing residency
+   * would sit there permanently while liveBytes reported the ceiling was
+   * satisfied. That is precisely the case SetGeometryBudget exists for: a
+   * tab already under pressure.
+   *
+   * Seeding takes the stores in iteration order, which is extraction order,
+   * so the recency order it produces is oldest-first — the right guess when
+   * no better information survived.
+   *
+   * @param bytes The new ceiling, or Infinity to disable.
+   */
+  setBudgetBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes <= 0) {
+      this.budgetBytes_ = Number.POSITIVE_INFINITY;
+      this.order_.clear();
+      this.natives_.clear();
+      this.liveBytes_ = 0;
+      return;
+    }
+    const wasDisabled = !this.enabled;
+    this.budgetBytes_ = bytes;
+    if (wasDisabled) {
+      this.seedFromStores_();
+    }
+  }
+  /**
+   * Account for everything the stores already hold, for a budget enabled
+   * after extraction has started.
+   */
+  seedFromStores_() {
+    for (const store of this.stores_) {
+      for (const mesh of store) {
+        this.noteAdded(store, mesh);
+      }
+    }
+  }
+  /**
+   * Record an asset as resident, or refresh one being replaced.
+   *
+   * @param store The store holding it.
+   * @param mesh The mesh added.
+   */
+  noteAdded(store, mesh) {
+    if (!this.enabled) {
+      return;
+    }
+    const key = residencyKey(store, mesh.localID);
+    if (this.order_.has(key)) {
+      this.releaseKey_(key);
+    }
+    if (mesh.type !== CanonicalMeshType.BUFFER_GEOMETRY) {
+      return;
+    }
+    const native = mesh.geometry;
+    const tracked = this.natives_.get(native);
+    if (tracked !== void 0) {
+      tracked.keys.add(key);
+    } else {
+      const bytes = meshBytes(mesh);
+      this.natives_.set(native, { bytes, keys: /* @__PURE__ */ new Set([key]) });
+      this.liveBytes_ += bytes;
+    }
+    this.order_.set(key, { store, native });
+  }
+  /**
+   * Drop one key's reference, reporting whether the native it names is now
+   * unreferenced and therefore safe to free.
+   *
+   * @param key The composite key.
+   * @return {boolean} True when this was the last reference.
+   */
+  releaseKey_(key) {
+    const entry = this.order_.get(key);
+    this.order_.delete(key);
+    if (entry === void 0) {
+      return true;
+    }
+    const tracked = this.natives_.get(entry.native);
+    if (tracked === void 0) {
+      return true;
+    }
+    tracked.keys.delete(key);
+    if (tracked.keys.size > 0) {
+      return false;
+    }
+    this.liveBytes_ -= tracked.bytes;
+    this.natives_.delete(entry.native);
+    return true;
+  }
+  /**
+   * Whether freeing the native behind a store entry is safe — false while
+   * another cached mesh still references the same native.
+   *
+   * @param store The store.
+   * @param localID The asset's local ID.
+   * @return {boolean} True when the caller should free the native.
+   */
+  releaseReference(store, localID) {
+    if (!this.enabled) {
+      return true;
+    }
+    return this.releaseKey_(residencyKey(store, localID));
+  }
+  /**
+   * Record a use, moving the asset to the most-recent end.
+   *
+   * @param store The store queried.
+   * @param localID The asset's local ID.
+   */
+  noteUsed(store, localID) {
+    if (!this.enabled) {
+      return;
+    }
+    const key = residencyKey(store, localID);
+    const existing = this.order_.get(key);
+    if (existing === void 0) {
+      return;
+    }
+    this.order_.delete(key);
+    this.order_.set(key, existing);
+  }
+  /**
+   * Stop accounting for an asset something else freed — an explicit delete,
+   * or the extractor reclaiming its own temporaries. Without this the budget
+   * would keep charging for bytes nobody holds and evict live assets to make
+   * room for them.
+   *
+   * @param store The store it was in.
+   * @param localID The asset's local ID.
+   */
+  noteRemoved(store, localID) {
+    if (!this.enabled) {
+      return;
+    }
+    this.releaseKey_(residencyKey(store, localID));
+  }
+  /**
+   * Evict least-recently-used assets until the live set fits the budget.
+   *
+   * @return {{evicted: number, freedBytes: number}} What this pass reclaimed.
+   */
+  evictToBudget() {
+    if (!this.enabled) {
+      return { evicted: 0, freedBytes: 0 };
+    }
+    let evicted = 0;
+    let freedBytes = 0;
+    for (const [key, entry] of this.order_) {
+      if (this.liveBytes_ <= this.budgetBytes_) {
+        break;
+      }
+      const localID = localIDOf(key);
+      const bytes = this.natives_.get(entry.native)?.bytes ?? 0;
+      entry.store.delete(localID);
+      this.everEvicted_ = true;
+      ++evicted;
+      freedBytes += bytes;
+    }
+    return { evicted, freedBytes };
+  }
+};
+function residencyKey(store, localID) {
+  return localID * 2 + (store.isVoid ? VOID_STORE_BIT : 0);
+}
+function localIDOf(key) {
+  return (key - key % 2) / 2;
+}
+function meshBytes(mesh) {
+  if (mesh.type !== CanonicalMeshType.BUFFER_GEOMETRY) {
+    return 0;
+  }
+  try {
+    const allocated = mesh.geometry.getAllocationSize?.();
+    if (typeof allocated === "number" && allocated > 0) {
+      return allocated;
+    }
+    return mesh.geometry.GetVertexDataSize() * BYTES_PER_VERTEX_ELEMENT + mesh.geometry.GetIndexDataSize() * BYTES_PER_INDEX_ELEMENT;
+  } catch {
+    return 0;
+  }
+}
+
 // compiled/src/core/canonical_material.js
 var ROUGNESS_CONVERSION_FACTOR = 2;
 function roughnessToExponent(roughness) {
@@ -71318,6 +71569,7 @@ var IfcModelGeometry = class {
     this.model = model2;
     this.isVoid = isVoid;
     this.meshes_ = /* @__PURE__ */ new Map();
+    model2.geometryResidency.registerStore(this);
   }
   /**
    * Get the number of items in this.
@@ -71334,7 +71586,8 @@ var IfcModelGeometry = class {
     for (const [key, value] of this.meshes_) {
       if (value.temporary) {
         this.meshes_.delete(key);
-        if (value.type === CanonicalMeshType.BUFFER_GEOMETRY) {
+        const isLastReference = this.model.geometryResidency.releaseReference(this, key);
+        if (value.type === CanonicalMeshType.BUFFER_GEOMETRY && isLastReference) {
           value.geometry.delete();
         }
       }
@@ -71362,6 +71615,7 @@ var IfcModelGeometry = class {
       mesh.geometry.GetVertexData();
     }
     this.meshes_.set(mesh.localID, mesh);
+    this.model.geometryResidency.noteAdded(this, mesh);
   }
   /**
    * Drop the mesh for a particular local ID
@@ -71372,7 +71626,8 @@ var IfcModelGeometry = class {
     const value = this.meshes_.get(localID);
     if (value !== void 0) {
       this.meshes_.delete(localID);
-      if (value.type === CanonicalMeshType.BUFFER_GEOMETRY) {
+      const isLastReference = this.model.geometryResidency.releaseReference(this, localID);
+      if (value.type === CanonicalMeshType.BUFFER_GEOMETRY && isLastReference) {
         value.geometry.delete();
       }
     }
@@ -71384,6 +71639,7 @@ var IfcModelGeometry = class {
    * @return {CanonicalMesh | undefined}
    */
   getByLocalID(localID) {
+    this.model.geometryResidency.noteUsed(this, localID);
     return this.meshes_.get(localID);
   }
   /**
@@ -71844,6 +72100,7 @@ var IfcStepModel = class extends step_model_base_default {
   constructor(buffer, elementIndex, provider) {
     super(schema_ifc_gen_default, buffer, elementIndex, provider);
     this.externalMappingType = ifc_step_external_mapping_default;
+    this.geometryResidency = new GeometryResidency();
     this.geometry = new IfcModelGeometry(this);
     this.voidGeometry = new IfcModelGeometry(this, true);
     this.profiles = new IfcModelProfile(this);