@bldrs-ai/conway 1.511.1441 → 1.513.1447

package/compiled/src/step/step_model_base.js

@@ -307,6 +307,9 @@ export default class StepModelBase {
         if (element.vtableIndex === void 0 && !this.populateVtableEntryRaw(element)) {
             return void 0;
         }
+        if (element.buffer === void 0) {
+            this.populateBufferEntry(localID);
+        }
         const vtable = element.vtable;
         const buffer = element.buffer;
         if (vtable === void 0 || buffer === void 0 ||
@@ -383,6 +386,12 @@ export default class StepModelBase {
         const element = this.entry(localID);
         element.buffer =
             this.bufferProvider_.acquire(element.address, element.length).buffer;
+        if (element.multiMapping !== void 0) {
+            for (const mapped of element.multiMapping) {
+                mapped.buffer =
+                    this.bufferProvider_.acquire(mapped.address, mapped.length).buffer;
+            }
+        }
     }
     /**
      * Get the size in bytes of the backing buffer for this.
@@ -504,24 +513,45 @@ export default class StepModelBase {
         if (!this.isSourceExternal) {
             return seen;
         }
-        const stack = [localID];
+        // BFS by hop: page a whole frontier in parallel so a product whose
+        // #refs sit in different OPFS chunks is one round-trip, not one
+        // await per record. Claim `seen` before the await so overlapping
+        // walks (a batch of products sharing mapped geometry) pin once.
+        const frontier = [];
+        const enqueue = (id) => {
+            if (id < this.count_ && !seen.has(id)) {
+                frontier.push(id);
+            }
+        };
+        enqueue(localID);
         if (extraLocalIDs !== void 0) {
             for (const extra of extraLocalIDs) {
-                stack.push(extra);
+                enqueue(extra);
             }
         }
-        while (stack.length > 0) {
-            const id = stack.pop();
-            if (seen.has(id) || id >= this.count_) {
-                continue;
+        while (frontier.length > 0) {
+            const wave = [];
+            for (const id of frontier) {
+                if (seen.has(id) || id >= this.count_) {
+                    continue;
+                }
+                // Claim + pin before the await so a sibling ensure cannot
+                // evict this range once its own ensurePins_ drop.
+                seen.add(id);
+                this.pinByLocalID(id);
+                wave.push(id);
+            }
+            frontier.length = 0;
+            if (wave.length === 0) {
+                break;
             }
-            seen.add(id);
-            await this.ensureResidentByLocalID(id);
-            this.pinByLocalID(id);
-            for (const expressID of this.scanRecordRefs_(id)) {
-                const referenced = this.expressIDMap_.get(expressID);
-                if (referenced !== void 0 && !seen.has(referenced)) {
-                    stack.push(referenced);
+            await Promise.all(wave.map((id) => this.ensureResidentByLocalID(id)));
+            for (const id of wave) {
+                for (const expressID of this.scanRecordRefs_(id)) {
+                    const referenced = this.expressIDMap_.get(expressID);
+                    if (referenced !== void 0 && !seen.has(referenced)) {
+                        frontier.push(referenced);
+                    }
                 }
             }
         }
@@ -550,6 +580,35 @@ export default class StepModelBase {
         }
         this.bufferProvider_.unpinRange?.(this.address_[localID], this.length_[localID]);
     }
+    /**
+     * Drop captured source-window views on `localIDs` so the LRU can
+     * evict those chunks. Vtables stay — `acquire` of the same
+     * `(address, length)` is at a stable base. The next
+     * `ensureResident` + field read rematerialises the view.
+     *
+     * @param localIDs Records whose `buffer` views to drop.
+     */
+    releaseSourceViews(localIDs) {
+        if (!this.isSourceExternal) {
+            return;
+        }
+        for (const localID of localIDs) {
+            if (localID >= this.count_) {
+                continue;
+            }
+            const item = this.complexEntries_?.get(localID) ?? this.descriptorCache_[localID];
+            if (item === void 0) {
+                continue;
+            }
+            item.buffer = void 0;
+            if (item.multiMapping !== void 0) {
+                for (const mapped of item.multiMapping) {
+                    mapped.buffer = void 0;
+                }
+            }
+        }
+        releaseScratchParsingBuffer();
+    }
     /**
      * Unpin every local ID in `localIDs` (best-effort; missing IDs are
      * ignored). Use after {@link ensureResidentClosureByLocalID}, which

package/compiled/src/version/version.js

@@ -5,5 +5,5 @@
 // only the first segment (major) is meaningful and is the one CI carries forward.
 // Must stay in `vN.N.N` shape: the CI stamp regex, scripts/updateVersion.mjs, and
 // statistics.ts all match `v\d+\.\d+\.\d+`.
-const versionString = 'Conway v1.511.1441';
+const versionString = 'Conway v1.513.1447';
 export { versionString };