@driftengine/drft 3.63.0 → 4.0.0

package/NOTICE

@@ -7,3 +7,23 @@ This product includes software developed at Drift Technologies
 Licensed under the Apache License, Version 2.0. Section 4(d) of that licence
 requires this NOTICE to be reproduced in any derivative work you distribute,
 in the source, the documentation, or a display generated by the work.
+
+Models run by DriftCapture
+--------------------------
+DriftCapture runs the models below. Their weights are not in this repository
+and are not distributed with it: tools/capture-weights/ fetches each at the
+revision its manifest pins, verifies it, and converts it, and a game that
+ships one ships it under that model's own licence. Each model's definition in
+this engine is written from its project's published code.
+
+- Depth Anything 3 Small and Depth Anything 3 Base. Apache License 2.0.
+  Copyright (c) 2025 ByteDance Ltd. and/or its affiliates.
+- Depth Anything V2 Small. Apache License 2.0. The University of Hong Kong
+  and TikTok; converted to the Transformers layout by The HuggingFace Team.
+- MobileSAM. Apache License 2.0. Its image encoder is TinyViT, Copyright (c)
+  2022 Microsoft; its prompt encoder and mask decoder are Segment Anything's,
+  Copyright (c) Meta Platforms, Inc. and affiliates.
+- SAM 2.1 tiny. Apache License 2.0. Copyright (c) Meta Platforms, Inc. and
+  affiliates.
+- OWLv2 base patch16. Apache License 2.0. Copyright 2023 Google AI and The
+  HuggingFace Team.

package/README.md

@@ -2,7 +2,7 @@
 
 The `.drft` container: read and write a baked scene. Declares no runtime dependency.
 
-**Cost: 5.0 KB gzipped.** Measured by `scripts/size-gate.test.mjs`, which fails if it drifts more than
+**Cost: 8.1 KB gzipped.** Measured by `scripts/size-gate.test.mjs`, which fails if it drifts more than
 3% — the number is a fact about the build rather than a claim in a document.
 
 Part of [DriftEngine](../../README.md). See [`docs/ARCHITECTURE.md`](../../docs/ARCHITECTURE.md)

package/dist/drftFormat.d.ts

@@ -20,7 +20,7 @@ export declare const DRFT_VERSION_MAJOR = 1;
  * Additive revisions within a generation: new optional chunks, new attribute bits, new
  * enum values with a defined fallback. Never a changed meaning.
  */
-export declare const DRFT_VERSION_MINOR = 12;
+export declare const DRFT_VERSION_MINOR = 17;
 /** Bytes before the chunk table. */
 export declare const HEADER_BYTES = 32;
 /** Bytes per chunk table entry. */
@@ -169,6 +169,57 @@ export declare const CHUNK_MORP: number;
  * fire. See `drftSubs.ts` for the layout.
  */
 export declare const CHUNK_SUBS: number;
+/**
+ * `MSHL`: a mesh's clusters and the level-of-detail graph over them.
+ *
+ * Additive, and additive is what keeps the freeze in `FORMAT.md` intact: a reader that does not
+ * know this code skips it by its length and loses only the GPU-driven path, which is the one thing
+ * it could not have drawn anyway.
+ */
+export declare const CHUNK_MSHL: number;
+/**
+ * `DTEX`: a material as a decode program over a latent, rather than as pictures.
+ *
+ * Additive on the same terms as `MSHL`: a reader that does not know this code skips it by its
+ * length and loses only the material, which it had no way to decode. See `dtex.ts` for the layout
+ * and for why the chunk validates containment rather than meaning.
+ */
+export declare const CHUNK_DTEX: number;
+/**
+ * `SDFV`: an object's signed distance field, for tracing indirect light through it.
+ *
+ * Additive on the same terms as `MSHL` and `DTEX`: a reader that does not know this code skips it
+ * by its length and loses only indirect light, which it had no way to trace anyway. See `sdfv.ts`
+ * for the layout, and for why it carries no version of its own.
+ */
+export declare const CHUNK_SDFV: number;
+/**
+ * `NNET`: the weights of the small networks the engine evaluates, found by role.
+ *
+ * Additive on the same terms as `SDFV`: a reader that does not know this code skips it by its
+ * length and loses only the networks, which it had nothing to evaluate them with. See `nnet.ts`.
+ */
+export declare const CHUNK_NNET: number;
+/**
+ * `NGRF`: a network as a graph of operators and its tensors, found by role — the form a transformer
+ * takes, which `NNET`'s perceptron table cannot. Additive on the same terms. See `ngrf.ts`.
+ */
+export declare const CHUNK_NGRF: number;
+/**
+ * `NAVM`: a polygon mesh a character can walk, with the placement it was built at.
+ *
+ * Additive on the same terms as `DTEX`: a reader that does not know this code skips it by its
+ * length and loses only the navigation, which it had nothing to walk with. See `navm.ts` for the
+ * layout, and for why the placement travels inside the chunk rather than beside it.
+ */
+export declare const CHUNK_NAVM: number;
+/**
+ * `ENTS`: the things in a scene, as the entity model wrote them.
+ *
+ * Additive on the same terms. See `ents.ts` for the layout, and for why a chunk in a binary
+ * container holds text.
+ */
+export declare const CHUNK_ENTS: number;
 /** Bytes before the records in a `SPLT` payload. See `DrftSplatBlock` for the fields. */
 export declare const SPLAT_BLOCK_PREFIX = 40;
 /**

package/dist/drftFormat.js

@@ -20,7 +20,7 @@ export const DRFT_VERSION_MAJOR = 1;
  * Additive revisions within a generation: new optional chunks, new attribute bits, new
  * enum values with a defined fallback. Never a changed meaning.
  */
-export const DRFT_VERSION_MINOR = 12;
+export const DRFT_VERSION_MINOR = 17;
 /** Bytes before the chunk table. */
 export const HEADER_BYTES = 32;
 /** Bytes per chunk table entry. */
@@ -180,6 +180,57 @@ export const CHUNK_MORP = fourCC('MORP');
  * fire. See `drftSubs.ts` for the layout.
  */
 export const CHUNK_SUBS = fourCC('SUBS');
+/**
+ * `MSHL`: a mesh's clusters and the level-of-detail graph over them.
+ *
+ * Additive, and additive is what keeps the freeze in `FORMAT.md` intact: a reader that does not
+ * know this code skips it by its length and loses only the GPU-driven path, which is the one thing
+ * it could not have drawn anyway.
+ */
+export const CHUNK_MSHL = fourCC('MSHL');
+/**
+ * `DTEX`: a material as a decode program over a latent, rather than as pictures.
+ *
+ * Additive on the same terms as `MSHL`: a reader that does not know this code skips it by its
+ * length and loses only the material, which it had no way to decode. See `dtex.ts` for the layout
+ * and for why the chunk validates containment rather than meaning.
+ */
+export const CHUNK_DTEX = fourCC('DTEX');
+/**
+ * `SDFV`: an object's signed distance field, for tracing indirect light through it.
+ *
+ * Additive on the same terms as `MSHL` and `DTEX`: a reader that does not know this code skips it
+ * by its length and loses only indirect light, which it had no way to trace anyway. See `sdfv.ts`
+ * for the layout, and for why it carries no version of its own.
+ */
+export const CHUNK_SDFV = fourCC('SDFV');
+/**
+ * `NNET`: the weights of the small networks the engine evaluates, found by role.
+ *
+ * Additive on the same terms as `SDFV`: a reader that does not know this code skips it by its
+ * length and loses only the networks, which it had nothing to evaluate them with. See `nnet.ts`.
+ */
+export const CHUNK_NNET = fourCC('NNET');
+/**
+ * `NGRF`: a network as a graph of operators and its tensors, found by role — the form a transformer
+ * takes, which `NNET`'s perceptron table cannot. Additive on the same terms. See `ngrf.ts`.
+ */
+export const CHUNK_NGRF = fourCC('NGRF');
+/**
+ * `NAVM`: a polygon mesh a character can walk, with the placement it was built at.
+ *
+ * Additive on the same terms as `DTEX`: a reader that does not know this code skips it by its
+ * length and loses only the navigation, which it had nothing to walk with. See `navm.ts` for the
+ * layout, and for why the placement travels inside the chunk rather than beside it.
+ */
+export const CHUNK_NAVM = fourCC('NAVM');
+/**
+ * `ENTS`: the things in a scene, as the entity model wrote them.
+ *
+ * Additive on the same terms. See `ents.ts` for the layout, and for why a chunk in a binary
+ * container holds text.
+ */
+export const CHUNK_ENTS = fourCC('ENTS');
 /** Bytes before the records in a `SPLT` payload. See `DrftSplatBlock` for the fields. */
 export const SPLAT_BLOCK_PREFIX = 40;
 /**
@@ -204,6 +255,13 @@ export const KNOWN_CHUNKS = new Set([
     CHUNK_ANIM,
     CHUNK_MORP,
     CHUNK_SUBS,
+    CHUNK_MSHL,
+    CHUNK_DTEX,
+    CHUNK_SDFV,
+    CHUNK_NNET,
+    CHUNK_NGRF,
+    CHUNK_NAVM,
+    CHUNK_ENTS,
 ]);
 /** Chunk flags. */
 export const CHUNK_REQUIRED = 1 << 0;

package/dist/drftMeshlets.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `MSHL`: the clusters a mesh draws as, and the level-of-detail graph over them.
+ *
+ * **One chunk per level, not one for the whole graph.** A level is a complete alternative mesh —
+ * its own positions, its own indices, its own clusters — so folding every level into one chunk
+ * would mean one payload whose parts are only meaningful together. Separate chunks let a loader
+ * stream the coarsest level first and refine, which is the same argument `coarseFirst.ts` already
+ * makes for splats.
+ *
+ * ```
+ * u32  clusterCount
+ * u32  indexTotal
+ * u32  triangleOffsets[clusterCount]   first triangle of each cluster
+ * u32  triangleCounts[clusterCount]
+ * f32  boundsCentre[clusterCount * 3]
+ * f32  boundsRadius[clusterCount]
+ * f32  coneAxis[clusterCount * 3]      average face normal, normalised
+ * f32  coneCutoff[clusterCount]        minimum dot of any face against the axis
+ * f32  ownError[clusterCount]          this cluster's geometric error
+ * f32  parentError[clusterCount]       the error of what replaces it one level up
+ * u32  indices[indexTotal]
+ * ```
+ *
+ * **No per-chunk version field**, matching `COLL` and every other chunk here: the file's own
+ * version covers the format and a second one would be a second thing to keep in step.
+ *
+ * **`parentError` may be infinite**, which is how the coarsest level says it has no parent. A
+ * float32 carries that exactly, so a reader needs no sentinel and a comparison against it needs
+ * no special case.
+ */
+/** How many clusters one level may carry. Well past what a streaming budget permits. */
+export declare const MAX_CLUSTERS: number;
+export interface MeshletLevel {
+    triangleOffsets: Uint32Array;
+    triangleCounts: Uint32Array;
+    boundsCentre: Float32Array;
+    boundsRadius: Float32Array;
+    coneAxis: Float32Array;
+    coneCutoff: Float32Array;
+    ownError: Float32Array;
+    parentError: Float32Array;
+    indices: Uint32Array;
+    count: number;
+}
+export declare function buildMeshlets(level: MeshletLevel): Uint8Array;
+/**
+ * The level an `MSHL` chunk carries, as views over the fetched buffer.
+ *
+ * Views rather than copies, like every other chunk here, so a load allocates nothing beyond the
+ * object holding them.
+ */
+export declare function readMeshlets(buffer: ArrayBuffer, offset: number, byteLength: number): MeshletLevel;

package/dist/drftMeshlets.js

@@ -0,0 +1,140 @@
+import { DrftError, align } from './drftFormat.js';
+/**
+ * `MSHL`: the clusters a mesh draws as, and the level-of-detail graph over them.
+ *
+ * **One chunk per level, not one for the whole graph.** A level is a complete alternative mesh —
+ * its own positions, its own indices, its own clusters — so folding every level into one chunk
+ * would mean one payload whose parts are only meaningful together. Separate chunks let a loader
+ * stream the coarsest level first and refine, which is the same argument `coarseFirst.ts` already
+ * makes for splats.
+ *
+ * ```
+ * u32  clusterCount
+ * u32  indexTotal
+ * u32  triangleOffsets[clusterCount]   first triangle of each cluster
+ * u32  triangleCounts[clusterCount]
+ * f32  boundsCentre[clusterCount * 3]
+ * f32  boundsRadius[clusterCount]
+ * f32  coneAxis[clusterCount * 3]      average face normal, normalised
+ * f32  coneCutoff[clusterCount]        minimum dot of any face against the axis
+ * f32  ownError[clusterCount]          this cluster's geometric error
+ * f32  parentError[clusterCount]       the error of what replaces it one level up
+ * u32  indices[indexTotal]
+ * ```
+ *
+ * **No per-chunk version field**, matching `COLL` and every other chunk here: the file's own
+ * version covers the format and a second one would be a second thing to keep in step.
+ *
+ * **`parentError` may be infinite**, which is how the coarsest level says it has no parent. A
+ * float32 carries that exactly, so a reader needs no sentinel and a comparison against it needs
+ * no special case.
+ */
+/** How many clusters one level may carry. Well past what a streaming budget permits. */
+export const MAX_CLUSTERS = 1 << 20;
+const HEADER = 8;
+function layoutOf(clusterCount, indexTotal) {
+    const triangleOffsets = HEADER;
+    const triangleCounts = triangleOffsets + clusterCount * 4;
+    const boundsCentre = triangleCounts + clusterCount * 4;
+    const boundsRadius = boundsCentre + clusterCount * 12;
+    const coneAxis = boundsRadius + clusterCount * 4;
+    const coneCutoff = coneAxis + clusterCount * 12;
+    const ownError = coneCutoff + clusterCount * 4;
+    const parentError = ownError + clusterCount * 4;
+    const indices = parentError + clusterCount * 4;
+    return {
+        triangleOffsets,
+        triangleCounts,
+        boundsCentre,
+        boundsRadius,
+        coneAxis,
+        coneCutoff,
+        ownError,
+        parentError,
+        indices,
+        size: indices + indexTotal * 4,
+    };
+}
+export function buildMeshlets(level) {
+    const { count } = level;
+    if (count > MAX_CLUSTERS) {
+        throw new DrftError(`${count} clusters exceeds the ${MAX_CLUSTERS} cap`);
+    }
+    if (level.triangleOffsets.length < count || level.triangleCounts.length < count) {
+        throw new DrftError('MSHL was given fewer cluster offsets or counts than clusters');
+    }
+    if (level.indices.length % 3 !== 0) {
+        throw new DrftError(`MSHL was given ${level.indices.length} indices, which is not whole triangles`);
+    }
+    /*
+     * Every cluster's triangles are checked to lie inside the index array before anything is
+     * written. A cluster running past the end would otherwise be a subarray of arbitrary geometry on
+     * the way back in, which is the same failure `COLL` checks its starts table for.
+     */
+    const triangles = level.indices.length / 3;
+    for (let c = 0; c < count; c += 1) {
+        const at = level.triangleOffsets[c];
+        const n = level.triangleCounts[c];
+        if (at + n > triangles) {
+            throw new DrftError(`MSHL cluster ${c} runs past the ${triangles} triangles it was given`);
+        }
+    }
+    const layout = layoutOf(count, level.indices.length);
+    const bytes = new Uint8Array(align(layout.size));
+    const view = new DataView(bytes.buffer);
+    view.setUint32(0, count, true);
+    view.setUint32(4, level.indices.length, true);
+    new Uint32Array(bytes.buffer, layout.triangleOffsets, count).set(level.triangleOffsets.subarray(0, count));
+    new Uint32Array(bytes.buffer, layout.triangleCounts, count).set(level.triangleCounts.subarray(0, count));
+    new Float32Array(bytes.buffer, layout.boundsCentre, count * 3).set(level.boundsCentre.subarray(0, count * 3));
+    new Float32Array(bytes.buffer, layout.boundsRadius, count).set(level.boundsRadius.subarray(0, count));
+    new Float32Array(bytes.buffer, layout.coneAxis, count * 3).set(level.coneAxis.subarray(0, count * 3));
+    new Float32Array(bytes.buffer, layout.coneCutoff, count).set(level.coneCutoff.subarray(0, count));
+    new Float32Array(bytes.buffer, layout.ownError, count).set(level.ownError.subarray(0, count));
+    new Float32Array(bytes.buffer, layout.parentError, count).set(level.parentError.subarray(0, count));
+    new Uint32Array(bytes.buffer, layout.indices, level.indices.length).set(level.indices);
+    return bytes;
+}
+/**
+ * The level an `MSHL` chunk carries, as views over the fetched buffer.
+ *
+ * Views rather than copies, like every other chunk here, so a load allocates nothing beyond the
+ * object holding them.
+ */
+export function readMeshlets(buffer, offset, byteLength) {
+    if (byteLength < HEADER)
+        throw new DrftError('MSHL is too short to hold its counts');
+    const view = new DataView(buffer, offset, byteLength);
+    const count = view.getUint32(0, true);
+    const indexTotal = view.getUint32(4, true);
+    if (count > MAX_CLUSTERS) {
+        throw new DrftError(`MSHL claims ${count} clusters, over the ${MAX_CLUSTERS} cap`);
+    }
+    if (indexTotal % 3 !== 0) {
+        throw new DrftError(`MSHL claims ${indexTotal} indices, which is not whole triangles`);
+    }
+    const layout = layoutOf(count, indexTotal);
+    if (byteLength < layout.size) {
+        throw new DrftError(`MSHL claims ${count} clusters and ${indexTotal} indices, which runs past the chunk`);
+    }
+    const triangleOffsets = new Uint32Array(buffer, offset + layout.triangleOffsets, count);
+    const triangleCounts = new Uint32Array(buffer, offset + layout.triangleCounts, count);
+    const triangles = indexTotal / 3;
+    for (let c = 0; c < count; c += 1) {
+        if (triangleOffsets[c] + triangleCounts[c] > triangles) {
+            throw new DrftError(`MSHL cluster ${c} runs past the ${triangles} triangles the chunk holds`);
+        }
+    }
+    return {
+        triangleOffsets,
+        triangleCounts,
+        boundsCentre: new Float32Array(buffer, offset + layout.boundsCentre, count * 3),
+        boundsRadius: new Float32Array(buffer, offset + layout.boundsRadius, count),
+        coneAxis: new Float32Array(buffer, offset + layout.coneAxis, count * 3),
+        coneCutoff: new Float32Array(buffer, offset + layout.coneCutoff, count),
+        ownError: new Float32Array(buffer, offset + layout.ownError, count),
+        parentError: new Float32Array(buffer, offset + layout.parentError, count),
+        indices: new Uint32Array(buffer, offset + layout.indices, indexTotal),
+        count,
+    };
+}

package/dist/drftRead.d.ts

@@ -18,6 +18,12 @@ import type { AnimationClip, DrftSkin } from './animationData.ts';
 import type { DrftNode } from './drftSkin.ts';
 import type { MeshData } from './meshData.ts';
 import type { DrftChunk, DrftHead, DrftMaterial, DrftSplatBlock } from './drftFormat.ts';
+import { type DrftSdfvEntry } from './sdfv.ts';
+import { type DtexEntry } from './dtex.ts';
+import { type EntsScene } from './ents.ts';
+import { type NavPolyMesh } from './navm.ts';
+import { type DrftNetwork } from './nnet.ts';
+import { type DrftGraph } from './ngrf.ts';
 /** An embedded image, still compressed. Decoding is the consumer's, through `createImageBitmap`. */
 export interface DrftTexture {
     /** What the source called this image. Empty for a file written before names existed. */
@@ -65,6 +71,24 @@ export interface DrftAsset {
      * file's coarse-first order, so a consumer that draws a prefix of them draws a sparse whole.
      */
     readonly splats: DrftSplatBlock | null;
+    /**
+     * A decode program per material, or empty for a file that carries none.
+     *
+     * Each says which `MATL` entry it belongs to. **A reader that does not know this chunk skips it
+     * by its length** and loses only the material it could not have decoded, which is what keeps the
+     * format's freeze intact.
+     */
+    readonly dtex: readonly DtexEntry[];
+    /**
+     * A way across the scene, or `null` for a file that carries none.
+     *
+     * **`null` rather than an empty mesh**, because *nobody built one* and *there is nowhere to walk*
+     * are different facts, and a consumer that cannot tell them apart cannot decide whether to build
+     * one itself.
+     */
+    readonly navigation: NavPolyMesh | null;
+    /** The things in the scene, or `null` for a file that is an asset rather than a scene. */
+    readonly entities: EntsScene | null;
     /**
      * The asset's own hierarchy, or empty for a file carrying no `NODE`.
      *
@@ -89,6 +113,29 @@ export interface DrftAsset {
         readonly material: number;
         readonly substance: string;
     }[];
+    /**
+     * The signed distance field of each mesh that carries one, or empty for a file with none.
+     *
+     * The `SDFV` chunk, added at 1.13. Views over the fetched buffer, so a file that carries fields
+     * for geometry a consumer never traces through costs one view apiece and no copy. Hand them to
+     * `composeGlobalField`, which is what turns per-object fields into a world around the camera.
+     */
+    readonly fields: readonly DrftSdfvEntry[];
+    /**
+     * The networks the file carries, each with the role a consumer asks for it by, or empty.
+     *
+     * The `NNET` chunk, added at 1.14. Weights are views over the fetched buffer, in the precision
+     * they were written in — half-precision bits stay bits, because the device uploads them as such.
+     */
+    readonly networks: readonly DrftNetwork[];
+    /**
+     * The graphs the file carries — networks built from operators — each with its role, or empty.
+     *
+     * The `NGRF` chunk, added at 1.15. Tensors are views over the fetched buffer where its alignment
+     * allows, in the precision they were written in. `@driftengine/texture` validates one before it
+     * runs, naming any operator it lacks.
+     */
+    readonly graphs: readonly DrftGraph[];
     /**
      * The convex hulls this asset collides as, or empty for a file carrying no `COLL`.
      *

package/dist/drftRead.js

@@ -16,8 +16,14 @@
  */
 import { readClip, readMorph, readNodes, readSkin } from './drftSkin.js';
 import { validateMeshData } from './meshData.js';
-import { ATTR_EMISSIVE_COLOR, ATTR_GRAIN, ATTR_JOINTS, ATTR_RELIEF, ATTR_TANGENT, ATTR_ROUGHNESS, ATTR_SPECULAR, ATTR_UVS, ATTR_WEIGHTS, CHUNK_ENTRY_BYTES, CHUNK_HEAD, CHUNK_LODM, CHUNK_LODF, CHUNK_SPLT, SPLAT_BLOCK_PREFIX, CHUNK_MESH, CHUNK_REQUIRED, DRFT_MAGIC, DRFT_VERSION_MAJOR, DrftError, HEADER_BYTES, CHUNK_MATL, CHUNK_TEXS, KNOWN_CHUNKS, MATERIAL_ENTRY_BYTES, align, fourCCName, CHUNK_ANIM, CHUNK_NODE, CHUNK_SKIN, CHUNK_MORP, CHUNK_SUBS, CHUNK_COLL, } from './drftFormat.js';
+import { ATTR_EMISSIVE_COLOR, ATTR_GRAIN, ATTR_JOINTS, ATTR_RELIEF, ATTR_TANGENT, ATTR_ROUGHNESS, ATTR_SPECULAR, ATTR_UVS, ATTR_WEIGHTS, CHUNK_ENTRY_BYTES, CHUNK_HEAD, CHUNK_LODM, CHUNK_LODF, CHUNK_DTEX, CHUNK_ENTS, CHUNK_NAVM, CHUNK_SPLT, SPLAT_BLOCK_PREFIX, CHUNK_MESH, CHUNK_REQUIRED, DRFT_MAGIC, DRFT_VERSION_MAJOR, DrftError, HEADER_BYTES, CHUNK_MATL, CHUNK_TEXS, KNOWN_CHUNKS, MATERIAL_ENTRY_BYTES, align, fourCCName, CHUNK_ANIM, CHUNK_NODE, CHUNK_SKIN, CHUNK_MORP, CHUNK_NNET, CHUNK_NGRF, CHUNK_SDFV, CHUNK_SUBS, CHUNK_COLL, } from './drftFormat.js';
 import { readSubs } from './drftSubs.js';
+import { readSdfv } from './sdfv.js';
+import { readDtex } from './dtex.js';
+import { readEnts } from './ents.js';
+import { readNavm } from './navm.js';
+import { readNnet } from './nnet.js';
+import { readNgrf } from './ngrf.js';
 import { readColliders } from './drftColliders.js';
 const decoder = new TextDecoder();
 function readString(view, buffer, at, limit) {
@@ -153,11 +159,17 @@ export function readDrft(buffer) {
     const textures = [];
     let materials = [];
     const splatBlocks = [];
+    const dtex = [];
+    let navigation = null;
+    let entities = null;
     let nodes = [];
     const skins = [];
     const clips = [];
     const morphs = [];
     let subs = null;
+    let fields = null;
+    let nnet = null;
+    let graphs = [];
     let colliders = [];
     const skipped = [];
     let head = null;
@@ -207,6 +219,12 @@ export function readDrft(buffer) {
             materials = readMaterials(buffer, chunk);
         else if (chunk.code === CHUNK_SPLT)
             splatBlocks.push({ block: readSplatBlock(buffer, chunk), at: chunk.index });
+        else if (chunk.code === CHUNK_DTEX)
+            dtex.push(readDtex(buffer, chunk.offset, chunk.byteLength));
+        else if (chunk.code === CHUNK_NAVM)
+            navigation = readNavm(buffer, chunk.offset, chunk.byteLength);
+        else if (chunk.code === CHUNK_ENTS)
+            entities = readEnts(buffer, chunk.offset, chunk.byteLength);
         else if (chunk.code === CHUNK_NODE)
             nodes = readNodes(buffer, chunk.offset, chunk.byteLength);
         else if (chunk.code === CHUNK_SKIN)
@@ -217,6 +235,12 @@ export function readDrft(buffer) {
             morphs.push(readMorph(buffer, chunk.offset, chunk.byteLength));
         else if (chunk.code === CHUNK_SUBS)
             subs = readSubs(buffer, chunk.offset, chunk.byteLength);
+        else if (chunk.code === CHUNK_SDFV)
+            fields = readSdfv(buffer, chunk.offset, chunk.byteLength);
+        else if (chunk.code === CHUNK_NNET)
+            nnet = readNnet(buffer, chunk.offset, chunk.byteLength);
+        else if (chunk.code === CHUNK_NGRF)
+            graphs = readNgrf(buffer, chunk.offset, chunk.byteLength);
         else if (chunk.code === CHUNK_COLL)
             colliders = readColliders(buffer, chunk.offset, chunk.byteLength);
         /* Every other known chunk is defined but not yet carried; see docs/FORMAT.md phase table. */
@@ -229,8 +253,12 @@ export function readDrft(buffer) {
      * for the absence of a chunk kind it never needed would be the format telling a consumer what
      * its scene may be made of.
      */
-    if (meshes.length === 0 && splatBlocks.length === 0) {
-        throw new DrftError('no MESH and no SPLT chunk — an asset with neither geometry nor a capture');
+    /* And networks, since 1.15: a converted model is weights and nothing else. */
+    if (meshes.length === 0 &&
+        splatBlocks.length === 0 &&
+        (nnet?.networks.length ?? 0) === 0 &&
+        graphs.length === 0) {
+        throw new DrftError('no MESH, SPLT, NNET or NGRF chunk — an asset with no geometry, capture or network');
     }
     /*
      * Checked here rather than trusted, because the pairing is by ordinal and a mismatch is
@@ -292,7 +320,13 @@ export function readDrft(buffer) {
         materials,
         textures,
         substances: subs?.entries ?? [],
+        fields: fields?.entries ?? [],
+        networks: nnet?.networks ?? [],
+        graphs,
         colliders,
+        dtex,
+        navigation,
+        entities,
         splats: joinSplatBlocks(splatBlocks),
         skipped,
         versionMajor,

package/dist/drftWrite.d.ts

@@ -13,6 +13,12 @@ import type { DrftNode } from './drftSkin.ts';
 import type { MeshData } from './meshData.ts';
 import type { DrftHead, DrftMaterial, DrftSplats } from './drftFormat.ts';
 import { type DrftSubstanceEntry } from './drftSubs.ts';
+import { type DrftSdfvEntry } from './sdfv.ts';
+import { type DrftNetwork } from './nnet.ts';
+import { type DtexEntry } from './dtex.ts';
+import { type EntsScene } from './ents.ts';
+import { type NavPolyMesh } from './navm.ts';
+import { type DrftGraph } from './ngrf.ts';
 /** An image to embed, already compressed, with what its own header said about it. */
 export interface DrftTextureSource {
     /**
@@ -48,6 +54,25 @@ export interface DrftSource {
      * than by position, so a file labelling only its fourth material says so.
      */
     readonly substances?: readonly DrftSubstanceEntry[];
+    /**
+     * The signed distance field of each mesh that has one, or absent for a file carrying none.
+     *
+     * Written as one `SDFV` chunk at 1.13. It pairs by the mesh ordinal carried per entry rather
+     * than by position, so a file with a field for only its fourth mesh says so — `SUBS`'s rule,
+     * and `MORP` is the chunk that found out why it is a rule.
+     */
+    readonly fields?: readonly DrftSdfvEntry[];
+    /**
+     * The networks this file carries, or absent for a file carrying none.
+     *
+     * Written as one `NNET` chunk at 1.14, each network found by its role rather than by position.
+     */
+    readonly networks?: readonly DrftNetwork[];
+    /**
+     * The graphs this file carries — networks built from operators rather than dense layers — or
+     * absent for a file carrying none. Written as one `NGRF` chunk at 1.15, each found by its role.
+     */
+    readonly graphs?: readonly DrftGraph[];
     /**
      * The convex hulls this asset collides as, or absent for a file that carries none.
      *
@@ -93,6 +118,29 @@ export interface DrftSource {
      * `CHUNK_SPLT` for why it is several chunks rather than one.
      */
     readonly splats?: DrftSplats;
+    /**
+     * A decode program per material, or absent for a file whose materials are ordinary.
+     *
+     * One `DTEX` chunk each, **paired to a `MATL` entry by the index inside the chunk** rather than
+     * by the order they appear. A file may carry one for some of its materials and not others — a
+     * scene where one surface came from a capture and the rest were authored — and a reader pairing
+     * by position would hand the wrong material the wrong texture with nothing to fail on.
+     */
+    readonly dtex?: readonly DtexEntry[];
+    /**
+     * A way across the scene, or absent for a file nobody navigates.
+     *
+     * The mesh carries the origin and cell size it was built at, because the numbers in it are cell
+     * indices and a reader without those has a mesh in the wrong units at the wrong place.
+     */
+    readonly navigation?: NavPolyMesh;
+    /**
+     * The things in the scene, as `serializeWorld` wrote them.
+     *
+     * A *scene*, not an asset: this is what a capture proposes or an editor saves, and a file may
+     * carry geometry with no scene at all — which is every baked model this format has ever held.
+     */
+    readonly entities?: EntsScene;
 }
 /**
  * Bake a `.drft` into one `ArrayBuffer`.