@woosh/meep-engine 3.28.0 → 3.30.0

package/src/shade/renderer/geometry/virtual/format/vgeo_validate_container.js

@@ -2,6 +2,7 @@ import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
 import { round_up } from "../../../../../core/math/round_up.js";
 import { VGEO_CHILD_TABLE_ENTRY_SIZE } from "./frame/VGEO_CHILD_TABLE_ENTRY_SIZE.js";
 import { VGEO_CLUSTER_RECORD_SIZE } from "./cluster/VGEO_CLUSTER_RECORD_SIZE.js";
+import { VGEO_CODEC_DEFLATE } from "./frame/VGEO_CODEC_DEFLATE.js";
 import { VGEO_CODEC_LZ4 } from "./frame/VGEO_CODEC_LZ4.js";
 import { VGEO_CODEC_RAW } from "./frame/VGEO_CODEC_RAW.js";
 import { vgeo_compute_asset_id } from "./checksum/vgeo_compute_asset_id.js";
@@ -242,9 +243,16 @@ function check_header(buffer, out) {
     const format_version = buffer.readUint16();
 
     if (format_version !== VGEO_FORMAT_VERSION) {
+        /*
+         Fatal rather than one defect among many. Record layouts move between versions — 5 put
+         `subtree_aabb` where `bounds_sphere` was and shifted everything after it — so reading on
+         would decode every cluster of another version's file by this version's sequence and report
+         a page's worth of invented defects about fields that are not there. The reader keeps the
+         older layouts; this does not.
+        */
         out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `format_version is ${format_version}, this validator knows ${VGEO_FORMAT_VERSION}`));
 
-        usable = false;
+        return false;
     }
 
     const min_reader_version = buffer.readUint16();
@@ -353,7 +361,7 @@ function check_header(buffer, out) {
         out.push(new VGeoDefect(VGEO_DEFECT.HEADER, 'reserved u16 at 100 is not zero'));
     }
 
-    const level_count = buffer.readUint8();
+    const level_count = buffer.readUint16();
 
     if (level_count < 1) {
         out.push(new VGeoDefect(VGEO_DEFECT.HEADER, 'level_count is 0'));
@@ -373,10 +381,9 @@ function check_header(buffer, out) {
         usable = false;
     }
 
-    if (buffer.readUint8() !== 0) {
-        out.push(new VGeoDefect(VGEO_DEFECT.HEADER, 'reserved byte at 103 is not zero'));
-    }
-
+    // Byte 103 was reserved through `format_version` 5 and is `level_count`'s high byte from 6 on,
+    // so there is nothing left to check between it and `source_vertex_count`; the read above landed
+    // at 104 and the one below expects to start there.
     const source_vertex_count = Number(buffer.readUint64());
 
     if (source_vertex_count < 3) {
@@ -503,10 +510,12 @@ function check_frames(buffer, frames, out) {
             out.push(new VGeoDefect(VGEO_DEFECT.FRAME, `page ${frame.page_index}: magic is 0x${magic.toString(16)}, expected 0x${VGEO_PAGE_MAGIC.toString(16)}`));
         }
 
-        const decodable = frame.codec === VGEO_CODEC_RAW || frame.codec === VGEO_CODEC_LZ4;
+        const decodable = frame.codec === VGEO_CODEC_RAW
+            || frame.codec === VGEO_CODEC_LZ4
+            || frame.codec === VGEO_CODEC_DEFLATE;
 
         if (!decodable) {
-            out.push(new VGeoDefect(VGEO_DEFECT.FRAME, `page ${frame.page_index}: codec is ${frame.codec}, this validator knows ${VGEO_CODEC_RAW} (raw) and ${VGEO_CODEC_LZ4} (lz4)`));
+            out.push(new VGeoDefect(VGEO_DEFECT.FRAME, `page ${frame.page_index}: codec is ${frame.codec}, this validator knows ${VGEO_CODEC_RAW} (raw), ${VGEO_CODEC_LZ4} (lz4) and ${VGEO_CODEC_DEFLATE} (deflate)`));
         }
 
         if (frame.flags !== 0) {
@@ -571,9 +580,9 @@ function check_frames(buffer, frames, out) {
  * @param {VGeoFrameExtent} frame
  * @param {number} level_count
  * @param {VGeoDefect[]} out
- * @returns {DecodedPage|undefined} `undefined` when the page is too malformed to read further
+ * @returns {Promise<DecodedPage|undefined>} `undefined` when the page is too malformed to read further
  */
-function decode_page(buffer, frame, level_count, out) {
+async function decode_page(buffer, frame, level_count, out) {
     const page = new DecodedPage();
 
     page.page_index = frame.page_index;
@@ -600,7 +609,7 @@ function decode_page(buffer, frame, level_count, out) {
 
         page.buffer = buffer;
         page.base = blob;
-    } else if (frame.codec === VGEO_CODEC_LZ4) {
+    } else if (frame.codec === VGEO_CODEC_LZ4 || frame.codec === VGEO_CODEC_DEFLATE) {
         // Bounded by `check_frames`, which has reported it, before it is believed — so a corrupt
         // length field is a defect rather than an allocation.
         if (frame.decoded_size > vgeo_frame_decode_bound(frame.codec, frame.stored_size)) {
@@ -613,7 +622,7 @@ function decode_page(buffer, frame, level_count, out) {
         page.buffer.setCapacity(frame.decoded_size);
 
         try {
-            vgeo_decode_frame_blob(page.buffer.raw_bytes, 0, buffer.raw_bytes, frame);
+            await vgeo_decode_frame_blob(page.buffer.raw_bytes, 0, buffer.raw_bytes, frame);
         } catch (error) {
             // Not suppression — the decoder's own message is what says *how* the blob is malformed,
             // and a validator that threw here would be unable to report the one thing it exists to
@@ -641,15 +650,17 @@ function decode_page(buffer, frame, level_count, out) {
 
     page.group_count = decoded.readUint16();
     page.cluster_count = decoded.readUint16();
-    page.min_level = decoded.readUint8();
-    page.max_level = decoded.readUint8();
-
-    page.node_count = decoded.readUint16();
+    page.min_level = decoded.readUint16();
+    page.max_level = decoded.readUint16();
 
     page.cluster_table_offset = decoded.readUint32();
     page.payload_offset = decoded.readUint32();
     page.payload_size = decoded.readUint32();
-    page.node_table_offset = decoded.readUint32();
+
+    page.node_count = decoded.readUint16();
+
+    // What `node_table_offset` occupied through version 5, kept zero rather than reused (§11.10).
+    const node_reserved = decoded.readUint16();
 
     page.parent_table_offset = decoded.readUint32();
     page.parent_entry_count = decoded.readUint16();
@@ -671,6 +682,10 @@ function decode_page(buffer, frame, level_count, out) {
         return undefined;
     }
 
+    if (node_reserved !== 0) {
+        out.push(new VGeoDefect(VGEO_DEFECT.PAGE_LAYOUT, `page ${frame.page_index}: the reserved u16 at ${VGEO_PAGE_OFFSET.NODE_COUNT + 2} of the page header is ${node_reserved}, not zero`));
+    }
+
     if (page.min_level > page.max_level) {
         out.push(new VGeoDefect(VGEO_DEFECT.PAGE_LAYOUT, `page ${frame.page_index}: min_level ${page.min_level} exceeds max_level ${page.max_level}`));
     }
@@ -687,13 +702,14 @@ function decode_page(buffer, frame, level_count, out) {
         return undefined;
     }
 
-    const expected_node_table_offset = VGEO_PAGE_HEADER_SIZE + page.group_count * VGEO_GROUP_RECORD_SIZE;
-
-    if (page.node_table_offset !== expected_node_table_offset) {
-        out.push(new VGeoDefect(VGEO_DEFECT.PAGE_LAYOUT, `page ${frame.page_index}: node_table_offset is ${page.node_table_offset}, expected ${expected_node_table_offset}`));
-
-        return undefined;
-    }
+    /*
+     Derived rather than read: the page header has carried no such field since `format_version` 6,
+     and it never carried anything else — the group table follows the header and the node table
+     follows the group table. The cross-check the stored copy used to provide has not been lost with
+     it, because `cluster_table_offset` *is* stored and can only agree one line down if
+     `group_count` and `node_count` both do.
+    */
+    page.node_table_offset = VGEO_PAGE_HEADER_SIZE + page.group_count * VGEO_GROUP_RECORD_SIZE;
 
     const expected_cluster_table_offset = page.node_table_offset
         + page.node_count * VGEO_NODE_RECORD_SIZE;
@@ -1298,11 +1314,10 @@ function read_clusters(page, out) {
             self_error: buffer.readFloat32(),
             parent_error: buffer.readFloat32(),
             parent_sphere: read_sphere(buffer),
-            bounds_sphere: read_sphere(buffer),
+            subtree_aabb: read_aabb(buffer),
             aabb: read_aabb(buffer),
             child_ref: buffer.readUint16(),
             child_group: buffer.readUint16(),
-            cone_reserved: buffer.readUint32(),
             encoding_flags: buffer.readUint32(),
             payload_offset: buffer.readUint32(),
             payload_size: buffer.readUint32(),
@@ -1310,14 +1325,12 @@ function read_clusters(page, out) {
             triangle_count: buffer.readUint8(),
         };
 
-        if (buffer.readUint16() !== 0 || buffer.readUint64() !== 0n) {
+        // six bytes at 106; `cone_reserved` and the four bytes that followed the record's counts
+        // went into `subtree_aabb` when format_version moved to 5
+        if (buffer.readUint16() !== 0 || buffer.readUint32() !== 0) {
             out.push(new VGeoDefect(VGEO_DEFECT.CLUSTER, `page ${page.page_index} cluster ${c}: reserved tail is not zero`));
         }
 
-        if (cluster.cone_reserved !== 0) {
-            out.push(new VGeoDefect(VGEO_DEFECT.CLUSTER, `page ${page.page_index} cluster ${c}: cone_reserved is not zero`));
-        }
-
         result.push(cluster);
     }
 
@@ -1388,7 +1401,6 @@ function check_cluster_record(page, cluster, object_sphere, object_bounds, out)
     const named_spheres = [
         ['self_sphere', cluster.self_sphere],
         ['parent_sphere', cluster.parent_sphere],
-        ['bounds_sphere', cluster.bounds_sphere],
     ];
 
     for (const [name, sphere] of named_spheres) {
@@ -1397,8 +1409,26 @@ function check_cluster_record(page, cluster, object_sphere, object_bounds, out)
         }
     }
 
-    if (!cluster.aabb.every(Number.isFinite)) {
-        out.push(new VGeoDefect(VGEO_DEFECT.METRIC, `${where}: aabb is not finite`));
+    for (const [name, box] of [['aabb', cluster.aabb], ['subtree_aabb', cluster.subtree_aabb]]) {
+        if (!box.every(Number.isFinite)) {
+            out.push(new VGeoDefect(VGEO_DEFECT.METRIC, `${where}: ${name} is not finite`));
+        }
+    }
+
+    /*
+     The cut culls a cluster — and with it every cluster reachable below it, because the child group
+     is only ever entered through this one — on `subtree_aabb`, so it must contain this cluster's own
+     box before §11.17's cross-page half checks it contains the child group's boxes. Exact, on the
+     stored values: the builder unions float32 extremes and a union of representable numbers is
+     representable, so there is nothing here for a tolerance to absorb.
+    */
+    for (let axis = 0; axis < 3; axis++) {
+        if (cluster.subtree_aabb[axis] > cluster.aabb[axis]
+            || cluster.subtree_aabb[axis + 3] < cluster.aabb[axis + 3]) {
+            out.push(new VGeoDefect(VGEO_DEFECT.METRIC, `${where}: subtree_aabb does not contain the cluster's own aabb on axis ${axis}`));
+
+            break;
+        }
     }
 
     if (!Number.isFinite(cluster.self_error) || cluster.self_error < 0) {
@@ -1430,8 +1460,22 @@ function check_cluster_record(page, cluster, object_sphere, object_bounds, out)
             break;
         }
 
-        if (!sphere_contains_point(cluster.bounds_sphere, x, y, z)) {
-            out.push(new VGeoDefect(VGEO_DEFECT.METRIC, `${where}: bounds_sphere does not contain vertex ${v}`));
+        /*
+         §11.7. The cut's first per-cluster frustum test is on `self_sphere`, and a reader meeting a
+         container written before `subtree_aabb` existed stands this sphere's cube in for that box —
+         both are conservative only because the sphere holds the cluster's own vertices, and by
+         monotonicity every vertex below it. The builder has always made it so and nothing checked
+         it; what used to be checked here was `bounds_sphere`, which the record no longer carries.
+        */
+        if (!sphere_contains_point(cluster.self_sphere, x, y, z)) {
+            out.push(new VGeoDefect(VGEO_DEFECT.METRIC, `${where}: self_sphere does not contain vertex ${v}`));
+
+            break;
+        }
+
+        if (x < cluster.subtree_aabb[0] || y < cluster.subtree_aabb[1] || z < cluster.subtree_aabb[2]
+            || x > cluster.subtree_aabb[3] || y > cluster.subtree_aabb[4] || z > cluster.subtree_aabb[5]) {
+            out.push(new VGeoDefect(VGEO_DEFECT.METRIC, `${where}: subtree_aabb does not contain vertex ${v}`));
 
             break;
         }
@@ -1566,6 +1610,28 @@ function check_dag(pages, page_groups, page_clusters, level_count, out) {
 
                     break;
                 }
+
+                /*
+                 §11.17, the half no single record can settle. The runtime culls this cluster and
+                 everything under it on its `subtree_aabb`, and what is under it is exactly this
+                 child group — so a box that does not contain a child's box is a hole the size of
+                 that child's whole subtree, inside the frustum, with nothing left standing in over
+                 it. Exact, like the containment above it.
+                */
+                let escapes = -1;
+
+                for (let axis = 0; axis < 3 && escapes < 0; axis++) {
+                    if (child.subtree_aabb[axis] < cluster.subtree_aabb[axis]
+                        || child.subtree_aabb[axis + 3] > cluster.subtree_aabb[axis + 3]) {
+                        escapes = axis;
+                    }
+                }
+
+                if (escapes >= 0) {
+                    out.push(new VGeoDefect(VGEO_DEFECT.METRIC, `${where}: subtree_aabb does not contain the subtree_aabb of cluster ${child.index} of the group it refines into, on axis ${escapes}`));
+
+                    break;
+                }
             }
         }
     }
@@ -1714,8 +1780,8 @@ function check_directory(buffer, frames, pages, out) {
             continue;
         }
 
-        reconstructed.writeUint8(page.min_level);
-        reconstructed.writeUint8(page.max_level);
+        reconstructed.writeUint16(page.min_level);
+        reconstructed.writeUint16(page.max_level);
         reconstructed.writeUint16(i === 0 ? VGEO_DIRECTORY_FLAG_ROOT_PAGE : 0);
         reconstructed.writeUint16(page.group_count);
         reconstructed.writeUint16(page.cluster_count);
@@ -1758,10 +1824,14 @@ function check_directory(buffer, frames, pages, out) {
 /**
  * Audit a `.vgeo` file.
  *
+ * It is asynchronous for the one reason the reader is: {@link VGEO_CODEC_DEFLATE} decodes through
+ * the platform's streaming zlib, and a validator that could not decode a deflate page would pass
+ * every file it could not read.
+ *
  * @param {BinaryBuffer} buffer the whole file, with `capacity` equal to its length
- * @returns {VGeoDefect[]} in discovery order; empty when the file satisfies every invariant
+ * @returns {Promise<VGeoDefect[]>} in discovery order; empty when the file satisfies every invariant
  */
-export function vgeo_validate_container(buffer) {
+export async function vgeo_validate_container(buffer) {
     const out = [];
 
     if (!check_header(buffer, out)) {
@@ -1770,7 +1840,7 @@ export function vgeo_validate_container(buffer) {
 
     buffer.position = VGEO_HEADER_OFFSET.LEVEL_COUNT;
 
-    const level_count = buffer.readUint8();
+    const level_count = buffer.readUint16();
 
     buffer.position = VGEO_HEADER_OFFSET.TOTAL_CLUSTERS;
 
@@ -1794,7 +1864,7 @@ export function vgeo_validate_container(buffer) {
     const pages = [];
 
     for (const frame of frames) {
-        const page = decode_page(buffer, frame, level_count, out);
+        const page = await decode_page(buffer, frame, level_count, out);
 
         if (page === undefined) {
             return out;

package/src/shade/renderer/geometry/virtual/format/vgeo_write_container.d.ts

@@ -4,9 +4,9 @@
  * @param {VirtualGeometryPage[]} pages in file order, root first; every group's `page` must point
  *     back at the page holding it
  * @param {VGeoWriteOptions} options
- * @returns {BinaryBuffer} the whole file; its capacity is exactly the file's length, so
+ * @returns {Promise<BinaryBuffer>} the whole file; its capacity is exactly the file's length, so
  *     `raw_bytes` is the file
  */
-export function vgeo_write_container(pages: VirtualGeometryPage[], options: VGeoWriteOptions): BinaryBuffer;
+export function vgeo_write_container(pages: VirtualGeometryPage[], options: VGeoWriteOptions): Promise<BinaryBuffer>;
 import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
 //# sourceMappingURL=vgeo_write_container.d.ts.map

package/src/shade/renderer/geometry/virtual/format/vgeo_write_container.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_write_container.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/vgeo_write_container.js"],"names":[],"mappings":"AAocA;;;;;;;;GAQG;AACH,4CANW,qBAAqB,8BAGnB,YAAY,CAmNxB;6BA5pB4B,4CAA4C"}
+{"version":3,"file":"vgeo_write_container.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/vgeo_write_container.js"],"names":[],"mappings":"AAkdA;;;;;;;;GAQG;AACH,4CANW,qBAAqB,8BAGnB,QAAQ,YAAY,CAAC,CAmOjC;6BA1rB4B,4CAA4C"}

package/src/shade/renderer/geometry/virtual/format/vgeo_write_container.js

@@ -25,6 +25,7 @@ import { VGEO_HEADER_SIZE } from "./header/VGEO_HEADER_SIZE.js";
 import { VGEO_LEVEL_RECORD_SIZE } from "./header/VGEO_LEVEL_RECORD_SIZE.js";
 import { VGEO_MAGIC } from "./header/VGEO_MAGIC.js";
 import { VGEO_MAX_CHILD_REF } from "./cluster/VGEO_MAX_CHILD_REF.js";
+import { VGEO_MAX_LEVEL_COUNT } from "./header/VGEO_MAX_LEVEL_COUNT.js";
 import { VGEO_MAX_PARENT_ENTRY_COUNT } from "./page/VGEO_MAX_PARENT_ENTRY_COUNT.js";
 import { VGEO_MAX_PARENT_REF } from "./page/VGEO_MAX_PARENT_REF.js";
 import { VGEO_MIN_READER_VERSION } from "./header/VGEO_MIN_READER_VERSION.js";
@@ -241,15 +242,21 @@ function build_page_blob(page, child_pages, parents) {
         'page parent-page table must stay within what parent_ref can index'
     );
 
+    /*
+     Derived here and derived again by the reader, rather than written down: from `format_version`
+     6 the page header has no field for it, and the four bytes it used to occupy carry `node_count`
+     and the widened band instead. Nothing is lost by the move — the group table follows the header
+     and the node table follows the group table, so this was never free to be anything else.
+    */
     const node_table_offset = VGEO_PAGE_HEADER_SIZE + page.groups.length * VGEO_GROUP_RECORD_SIZE;
     const cluster_table_offset = node_table_offset + page.nodes.length * VGEO_NODE_RECORD_SIZE;
 
     /*
      The parent section sits between the cluster records and the payload rather than beside the
-     group table, which keeps `node_table_offset`'s "= 56 + 8·group_count" true and leaves every
-     offset a reader before format 4 computed exactly where it was. Both tables hold 4-byte entries
-     and the sections above them are all multiples of four, so the payload stays word-aligned —
-     format §11.8's promise, which the meshlet batch divides by four without rounding.
+     group table, which keeps the node table's "= 56 + 8·group_count" true and leaves every offset a
+     reader before format 4 computed exactly where it was. Both tables hold 4-byte entries and the
+     sections above them are all multiples of four, so the payload stays word-aligned — format
+     §11.8's promise, which the meshlet batch divides by four without rounding.
     */
     const parent_table_offset = cluster_table_offset + clusters.length * VGEO_CLUSTER_RECORD_SIZE;
 
@@ -273,13 +280,16 @@ function build_page_blob(page, child_pages, parents) {
 
     buffer.writeUint16(page.groups.length);
     buffer.writeUint16(clusters.length);
-    buffer.writeUint8(page.min_level);
-    buffer.writeUint8(page.max_level);
-    buffer.writeUint16(page.nodes.length);
+    buffer.writeUint16(page.min_level);
+    buffer.writeUint16(page.max_level);
     buffer.writeUint32(cluster_table_offset);
     buffer.writeUint32(payload_offset);
     buffer.writeUint32(payload_size);
-    buffer.writeUint32(node_table_offset);
+    buffer.writeUint16(page.nodes.length);
+
+    // The two bytes version 6 did not need out of `node_table_offset`, and §11 requires them zero.
+    buffer.writeUint16(0);
+
     buffer.writeUint32(parent_table_offset);
     buffer.writeUint16(parent_entry_count);
     buffer.writeUint16(parent_pages.length);
@@ -380,7 +390,14 @@ function build_page_blob(page, child_pages, parents) {
             buffer.writeFloat32(cluster.self_error);
             buffer.writeFloat32(cluster.parent_error);
             buffer.writeFloat32Array(cluster.parent_sphere, 0, 4);
-            buffer.writeFloat32Array(cluster.bounds_sphere, 0, 4);
+
+            /*
+             Where `bounds_sphere` and `cone_reserved` were before `format_version` 5: the cut culls
+             a cluster and its whole subtree on this box, and the sphere it replaced was read by
+             nothing at runtime. The record is the same 112 bytes.
+            */
+            buffer.writeFloat32Array(cluster.subtree_aabb, 0, 6);
+
             buffer.writeFloat32Array(cluster.aabb, 0, 6);
 
             if (cluster.child_group === undefined) {
@@ -391,9 +408,6 @@ function build_page_blob(page, child_pages, parents) {
                 buffer.writeUint16(cluster.child_group.index_in_page);
             }
 
-            // cone_reserved
-            buffer.writeUint32(0);
-
             buffer.writeUint32(cluster.encoding_flags);
             buffer.writeUint32(cursor);
             buffer.writeUint32(cluster.payload.byteLength);
@@ -456,10 +470,10 @@ function page_size_guarantee(blobs, nominal_page_size) {
  * @param {VirtualGeometryPage[]} pages in file order, root first; every group's `page` must point
  *     back at the page holding it
  * @param {VGeoWriteOptions} options
- * @returns {BinaryBuffer} the whole file; its capacity is exactly the file's length, so
+ * @returns {Promise<BinaryBuffer>} the whole file; its capacity is exactly the file's length, so
  *     `raw_bytes` is the file
  */
-export function vgeo_write_container(pages, options) {
+export async function vgeo_write_container(pages, options) {
     assert.isArray(pages, 'pages');
     assert.greaterThan(pages.length, 0, 'pages.length');
 
@@ -467,9 +481,25 @@ export function vgeo_write_container(pages, options) {
         assert.equal(page.index, index, `page ${index} carries index ${page.index}`);
     });
 
+    assert.lessThanOrEqual(
+        options.levels.length, VGEO_MAX_LEVEL_COUNT,
+        'level_count must stay within what the header and the page bands can name (format §4)'
+    );
+
     const parents = resolve_group_references(pages);
 
-    const blobs = pages.map((page) => {
+    /**
+     * @type {PageBlob[]}
+     */
+    const blobs = [];
+
+    /*
+     One page at a time rather than a `Promise.all` over the list. Under a stream codec that would
+     be one live `CompressionStream` per page of the container — thousands of zlib instances for a
+     conversion that is builder-bound anyway — and under the synchronous codecs it would be the
+     same loop with a promise around each step.
+     */
+    for (const page of pages) {
         const blob = new PageBlob();
 
         blob.child_pages = collect_child_pages(page);
@@ -479,7 +509,7 @@ export function vgeo_write_container(pages, options) {
         // Compression happens here, before a single offset is known, and that is what keeps the
         // layout non-circular: a frame's extent follows from its *stored* size and its child count,
         // and neither depends on any offset value, because the child table is plaintext.
-        const encoded = vgeo_encode_frame_blob(decoded, options.codec, options.codec_level);
+        const encoded = await vgeo_encode_frame_blob(decoded, options.codec, options.codec_level);
 
         blob.codec = encoded.codec;
         blob.stored = encoded.bytes;
@@ -491,8 +521,8 @@ export function vgeo_write_container(pages, options) {
 
         blob.fetch_size = round_up(blob.extent, VGEO_FRAME_ALIGNMENT);
 
-        return blob;
-    });
+        blobs.push(blob);
+    }
 
     const feature_flags_ignorable = page_size_guarantee(blobs, options.nominal_page_size);
 
@@ -556,7 +586,7 @@ export function vgeo_write_container(pages, options) {
     buffer.writeUint32(options.nominal_page_size);
 
     buffer.position = VGEO_HEADER_OFFSET.LEVEL_COUNT;
-    buffer.writeUint8(options.levels.length);
+    buffer.writeUint16(options.levels.length);
 
     buffer.position = VGEO_HEADER_OFFSET.SOURCE_VERTEX_COUNT;
     buffer.writeUint64(BigInt(options.source_vertex_count));
@@ -625,8 +655,8 @@ export function vgeo_write_container(pages, options) {
         buffer.writeUint64(BigInt(blob.frame_offset));
         buffer.writeUint32(blob.fetch_size);
         buffer.writeUint32(blob.decoded_size);
-        buffer.writeUint8(pages[page_index].min_level);
-        buffer.writeUint8(pages[page_index].max_level);
+        buffer.writeUint16(pages[page_index].min_level);
+        buffer.writeUint16(pages[page_index].max_level);
         buffer.writeUint16(page_index === 0 ? VGEO_DIRECTORY_FLAG_ROOT_PAGE : 0);
         buffer.writeUint16(pages[page_index].groups.length);
         buffer.writeUint16(page_cluster_count);