forma-dsl 0.1.1

package/src/core/digest.js

@@ -0,0 +1,232 @@
+// A 128-bit content digest, computed once per node and never recomputed.
+//
+// It must be stable across runs, machines and browsers: two structurally identical trees
+// have to produce the same digest every time, or the evaluation cache silently misses and
+// a rebuilt model recomputes everything. That rules out anything seeded per process, and
+// it rules out Web Crypto, which is async and cannot be called from a constructor.
+
+const C1 = 0x239b961b, C2 = 0xab0e9789, C3 = 0x38b34ae5, C4 = 0xa1e38b93;
+
+/**
+ * Rotates a 32-bit word left.
+ *
+ * @param {number} x The word.
+ * @param {number} r How many bits to rotate by.
+ * @returns {number} The rotated word.
+ */
+function rotl(x, r) {
+  return (x << r) | (x >>> (32 - r));
+}
+
+/**
+ * Multiplies two 32-bit words, keeping the low bits.
+ *
+ * `Math.imul`, not `*`: a 32-bit product above 2^53 loses its low bits to the double, and
+ * those low bits are most of the mixing.
+ *
+ * @param {number} a The left operand.
+ * @param {number} b The right operand.
+ * @returns {number} The low 32 bits of the product.
+ */
+function mul(a, b) {
+  return Math.imul(a, b) | 0;
+}
+
+/**
+ * The MurmurHash3 finalisation mix, which avalanches the remaining bits.
+ *
+ * @param {number} h A hash word.
+ * @returns {number} The mixed word, unsigned.
+ */
+function fmix(h) {
+  h ^= h >>> 16;
+  h = mul(h, 0x85ebca6b);
+  h ^= h >>> 13;
+  h = mul(h, 0xc2b2ae35);
+  h ^= h >>> 16;
+  return h >>> 0;
+}
+
+/**
+ * Packs the bytes after the last whole block into four words, little-endian.
+ *
+ * Byte `i` of the tail belongs to word `i >> 2` at shift `(i & 3) * 8` — which is what
+ * MurmurHash3's fallthrough spells out one case at a time. The arithmetic is identical;
+ * only the shape differs, and the digests it produces are asserted to be unchanged.
+ *
+ * @param {Uint8Array} bytes The whole input.
+ * @param {number} tail Offset of the first trailing byte.
+ * @param {number} rem How many trailing bytes there are, 0 to 15.
+ * @returns {number[]} The four words.
+ */
+function foldTail(bytes, tail, rem) {
+  const k = [0, 0, 0, 0];
+  for (let i = 0; i < rem; i++) {
+    k[i >> 2] ^= bytes[tail + i] << ((i & 3) * 8);
+  }
+  return k;
+}
+
+/**
+ * MurmurHash3 x86_128 over a byte array.
+ *
+ * Chosen because it is 32-bit throughout, so it runs identically everywhere without BigInt.
+ *
+ * @param {Uint8Array} bytes The bytes to digest.
+ * @returns {string} The digest, as 32 lowercase hex characters.
+ */
+export function digestBytes(bytes) {
+  const len = bytes.length;
+  const blocks = len >> 4;
+  let h1 = 0, h2 = 0, h3 = 0, h4 = 0;
+
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+
+  for (let i = 0; i < blocks; i++) {
+    const o = i << 4;
+    let k1 = view.getUint32(o, true);
+    let k2 = view.getUint32(o + 4, true);
+    let k3 = view.getUint32(o + 8, true);
+    let k4 = view.getUint32(o + 12, true);
+
+    k1 = mul(k1, C1); k1 = rotl(k1, 15); k1 = mul(k1, C2); h1 ^= k1;
+    h1 = rotl(h1, 19); h1 = (h1 + h2) | 0; h1 = (mul(h1, 5) + 0x561ccd1b) | 0;
+
+    k2 = mul(k2, C2); k2 = rotl(k2, 16); k2 = mul(k2, C3); h2 ^= k2;
+    h2 = rotl(h2, 17); h2 = (h2 + h3) | 0; h2 = (mul(h2, 5) + 0x0bcaa747) | 0;
+
+    k3 = mul(k3, C3); k3 = rotl(k3, 17); k3 = mul(k3, C4); h3 ^= k3;
+    h3 = rotl(h3, 15); h3 = (h3 + h4) | 0; h3 = (mul(h3, 5) + 0x96cd1c35) | 0;
+
+    k4 = mul(k4, C4); k4 = rotl(k4, 18); k4 = mul(k4, C1); h4 ^= k4;
+    h4 = rotl(h4, 13); h4 = (h4 + h1) | 0; h4 = (mul(h4, 5) + 0x32ac3b17) | 0;
+  }
+
+  // The trailing bytes that did not fill a 16-byte block, folded in a word at a time.
+  const tail = blocks << 4;
+  const rem = len & 15;
+  const k = foldTail(bytes, tail, rem);
+
+  // Each word is mixed only if the tail reached it: k1 from one byte, k2 from five, and so
+  // on. That is MurmurHash3's own fallthrough, written as the condition it encodes.
+  if (rem >= 1) { let x = mul(k[0], C1); x = rotl(x, 15); h1 ^= mul(x, C2); }
+  if (rem >= 5) { let x = mul(k[1], C2); x = rotl(x, 16); h2 ^= mul(x, C3); }
+  if (rem >= 9) { let x = mul(k[2], C3); x = rotl(x, 17); h3 ^= mul(x, C4); }
+  if (rem >= 13) { let x = mul(k[3], C4); x = rotl(x, 18); h4 ^= mul(x, C1); }
+
+  h1 ^= len; h2 ^= len; h3 ^= len; h4 ^= len;
+  h1 = (h1 + h2) | 0; h1 = (h1 + h3) | 0; h1 = (h1 + h4) | 0;
+  h2 = (h2 + h1) | 0; h3 = (h3 + h1) | 0; h4 = (h4 + h1) | 0;
+  h1 = fmix(h1); h2 = fmix(h2); h3 = fmix(h3); h4 = fmix(h4);
+  h1 = (h1 + h2) | 0; h1 = (h1 + h3) | 0; h1 = (h1 + h4) | 0;
+  h2 = (h2 + h1) | 0; h3 = (h3 + h1) | 0; h4 = (h4 + h1) | 0;
+
+  return [h1 >>> 0, h2 >>> 0, h3 >>> 0, h4 >>> 0]
+    .map((w) => w.toString(16).padStart(8, '0'))
+    .join('');
+}
+
+/**
+ * Accumulates the canonical byte encoding of a node's payload.
+ *
+ * Every method returns the writer, so an encoding reads as one chain.
+ *
+ * Numbers go in as their IEEE-754 bits rather than as text. `toString` would collapse
+ * values that are genuinely different (-0 and 0) and round others, so two distinct models
+ * could share a digest and one would be served the other's geometry from the cache.
+ */
+export class DigestWriter {
+  /** @type {Uint8Array[]} The pieces written so far, joined only at the end. */
+  #parts = [];
+
+  /** @type {number} Total length of `#parts`, tracked to size the buffer once. */
+  #length = 0;
+
+  /**
+   * @param {Uint8Array} bytes The piece to append.
+   * @returns {void}
+   */
+  #push(bytes) {
+    this.#parts.push(bytes);
+    this.#length += bytes.length;
+  }
+
+  /**
+   * Writes a length-prefixed UTF-8 string, so `"ab" + "c"` cannot encode as `"a" + "bc"`.
+   *
+   * @param {string} value The string.
+   * @returns {this} This writer.
+   */
+  string(value) {
+    const bytes = new TextEncoder().encode(value);
+    this.int(bytes.length);
+    this.#push(bytes);
+    return this;
+  }
+
+  /**
+   * @param {number} value Coerced to a 32-bit integer.
+   * @returns {this} This writer.
+   */
+  int(value) {
+    const bytes = new Uint8Array(4);
+    new DataView(bytes.buffer).setInt32(0, value | 0, true);
+    this.#push(bytes);
+    return this;
+  }
+
+  /**
+   * Writes a double as its IEEE-754 bits, normalising -0 to 0 so the two agree.
+   *
+   * @param {number} value The number.
+   * @returns {this} This writer.
+   */
+  number(value) {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setFloat64(0, value === 0 ? 0 : value, true);
+    this.#push(bytes);
+    return this;
+  }
+
+  /**
+   * @param {ReadonlyArray<number>} values The numbers, written length-prefixed.
+   * @returns {this} This writer.
+   */
+  numbers(values) {
+    this.int(values.length);
+    for (const value of values) this.number(value);
+    return this;
+  }
+
+  /**
+   * @param {boolean} value The flag.
+   * @returns {this} This writer.
+   */
+  bool(value) {
+    return this.int(value ? 1 : 0);
+  }
+
+  /**
+   * Folds in a child's digest instead of walking its subtree, which is what keeps digest
+   * computation O(1) per node rather than O(nodes) per node.
+   *
+   * @param {string} hex The child's digest.
+   * @returns {this} This writer.
+   */
+  digest(hex) {
+    return this.string(hex);
+  }
+
+  /**
+   * @returns {string} The digest of everything written, as 32 lowercase hex characters.
+   */
+  finish() {
+    const out = new Uint8Array(this.#length);
+    let offset = 0;
+    for (const part of this.#parts) {
+      out.set(part, offset);
+      offset += part.length;
+    }
+    return digestBytes(out);
+  }
+}

package/src/core/kernel.js

@@ -0,0 +1,67 @@
+/** @import { Kernel, QualityOptions } from '../index.js' */
+
+import ManifoldModule from 'manifold-3d';
+
+/**
+ * The single in-flight or settled load of the WASM module.
+ *
+ * @type {Promise<Kernel> | null}
+ */
+let modulePromise = null;
+
+/**
+ * Loads and sets up the Manifold WASM module, once per page or process.
+ *
+ * Every geometry call needs it, so this is memoized on the promise rather than the result:
+ * two models evaluating concurrently at startup must not each start an instantiation.
+ *
+ * Only the first call's options take effect, since later calls get the memoized promise.
+ *
+ * @param {{ locateFile: () => string }} [options] Passed to the module factory. A bundler
+ *   that fingerprints the `.wasm` file needs `locateFile` to point at the built URL,
+ *   because the module cannot find it by its own relative path.
+ * @returns {Promise<Kernel>} The set-up module.
+ */
+export function loadKernel(options) {
+  if (!modulePromise) {
+    modulePromise = ManifoldModule(options).then((wasm) => {
+      wasm.setup();
+      return wasm;
+    }, (error) => {
+      // A rejected promise would be memoized along with everything else, so a transient
+      // failure — a WASM fetch that lost the network — would be permanent for the page.
+      modulePromise = null;
+      throw error;
+    });
+  }
+  return modulePromise;
+}
+
+/**
+ * Sets the resolution used for curved surfaces.
+ *
+ * These are global to the kernel rather than per-model, so a viewer that renders a draft
+ * preview and then a final pass has to set them around each evaluation, not once at load.
+ *
+ * Each option is left alone when omitted.
+ *
+ * @param {QualityOptions} [options] The resolution controls.
+ * @returns {Promise<void>} Resolves once the kernel has been loaded and configured.
+ */
+export async function setQuality(options = {}) {
+  const { minAngle, minEdgeLength, segments } = options;
+  const wasm = await loadKernel();
+  if (minAngle !== undefined) wasm.setMinCircularAngle(minAngle);
+  if (minEdgeLength !== undefined) wasm.setMinCircularEdgeLength(minEdgeLength);
+  if (segments !== undefined) wasm.setCircularSegments(segments);
+}
+
+/**
+ * Restores the kernel's own curve resolution defaults.
+ *
+ * @returns {Promise<void>} Resolves once the kernel has been loaded and reset.
+ */
+export async function resetQuality() {
+  const wasm = await loadKernel();
+  wasm.resetToCircularDefaults();
+}

package/src/core/node.js

@@ -0,0 +1,187 @@
+/** @import { BooleanOp, Dimensionality } from '../index.js' */
+
+import { DigestWriter } from './digest.js';
+import { Transform } from '../values/transform.js';
+
+/**
+ * Canonically encodes an attribute value into the digest.
+ *
+ * Object keys are sorted, so two nodes built from the same attributes in a different source
+ * order share a digest and therefore a cache entry. Each branch writes a distinct tag byte
+ * first, so a string `"1"` and a number `1` cannot encode alike.
+ *
+ * @param {DigestWriter} writer The writer to append to.
+ * @param {unknown} value The value to encode.
+ * @returns {void}
+ */
+function writeValue(writer, value) {
+  if (value === null || value === undefined) {
+    writer.string('nil');
+  } else if (typeof value === 'number') {
+    writer.string('n').number(value);
+  } else if (typeof value === 'boolean') {
+    writer.string('b').bool(value);
+  } else if (typeof value === 'string') {
+    writer.string('s').string(value);
+  } else if (Array.isArray(value)) {
+    writer.string('a').int(value.length);
+    for (const item of value) writeValue(writer, item);
+  } else if (value instanceof Transform) {
+    writer.string('t').numbers(value.toArray());
+  } else {
+    const keys = Object.keys(value).sort();
+    writer.string('o').int(keys.length);
+    for (const key of keys) {
+      writer.string(key);
+      writeValue(writer, value[key]);
+    }
+  }
+}
+
+/**
+ * An immutable node in the geometry tree, identified by its content.
+ *
+ * Identity is digest identity: two structurally identical subtrees are the same node, so a
+ * model that uses one component twenty times evaluates it once. The digest is computed in
+ * the constructor from the children's digests, never from a live walk of the subtree.
+ */
+export class GeometryNode {
+  /**
+   * Prefer the factories below, which apply the algebraic simplifications; this is the raw
+   * constructor they all end at.
+   *
+   * @param {Dimensionality} dim Whether this node is 2D or 3D.
+   * @param {string} kind What the node does, such as `boolean` or `extrude`.
+   * @param {Record<string, unknown>} [props] The node's own parameters.
+   * @param {ReadonlyArray<GeometryNode>} [children] The operands.
+   * @throws {TypeError} If `dim` is neither 2 nor 3.
+   */
+  constructor(dim, kind, props = {}, children = []) {
+    if (dim !== 2 && dim !== 3) throw new TypeError(`bad dimensionality ${dim}`);
+
+    /** @type {Dimensionality} Whether this node is 2D or 3D. */
+    this.dim = dim;
+    /** @type {string} What the node does. */
+    this.kind = kind;
+    /** @type {Record<string, unknown>} The node's own parameters. */
+    this.props = props;
+    /** @type {ReadonlyArray<GeometryNode>} The operands. */
+    this.children = children;
+
+    const writer = new DigestWriter().int(dim).string(kind);
+    writeValue(writer, props);
+    writer.int(children.length);
+    for (const child of children) writer.digest(child.digest).int(child.dim);
+
+    /** @type {string} The 128-bit content digest, as 32 lowercase hex characters. */
+    this.digest = writer.finish();
+
+    /** @type {number} How many nodes this subtree contains, counting itself. */
+    this.subtreeSize = 1 + children.reduce((n, c) => n + c.subtreeSize, 0);
+
+    Object.freeze(this);
+  }
+
+  /** @returns {boolean} Whether this node stands for no geometry at all. */
+  get isEmpty() { return this.kind === 'empty'; }
+
+  /**
+   * @param {Dimensionality} dim Whether the empty node is 2D or 3D.
+   * @returns {GeometryNode} A node standing for no geometry.
+   */
+  static empty(dim) { return new GeometryNode(dim, 'empty'); }
+
+  /**
+   * Combines children with a boolean operation, dropping empties and collapsing the
+   * one-child case to that child.
+   *
+   * Union members are ordered by subtree size so that two unions written in a different
+   * order still share a digest. Difference is not reordered: its first child is the one
+   * everything else is cut from.
+   *
+   * @param {BooleanOp} op Which operation to apply.
+   * @param {ReadonlyArray<GeometryNode>} children The operands.
+   * @returns {GeometryNode} The combined node.
+   * @throws {TypeError} If the surviving children are not all the same dimensionality.
+   */
+  static boolean(op, children) {
+    const live = children.filter((c) => !c.isEmpty);
+    if (live.length === 0) return GeometryNode.empty(children[0]?.dim ?? 3);
+    if (live.length === 1) return live[0];
+    const dim = live[0].dim;
+    if (live.some((c) => c.dim !== dim)) {
+      throw new TypeError(`cannot combine 2D and 3D geometry in a ${op}`);
+    }
+    const ordered = op === 'union'
+      ? [...live].sort((a, b) => a.subtreeSize - b.subtreeSize || a.digest.localeCompare(b.digest))
+      : live;
+    return new GeometryNode(dim, 'boolean', { op }, ordered);
+  }
+
+  /**
+   * @param {ReadonlyArray<GeometryNode>} children The operands.
+   * @returns {GeometryNode} Everything added together.
+   */
+  static union(children) { return GeometryNode.boolean('union', children); }
+
+  /**
+   * @param {ReadonlyArray<GeometryNode>} children The first operand, then what to cut from it.
+   * @returns {GeometryNode} The first child with the rest removed.
+   */
+  static difference(children) { return GeometryNode.boolean('difference', children); }
+
+  /**
+   * @param {ReadonlyArray<GeometryNode>} children The operands.
+   * @returns {GeometryNode} Only what every child shares.
+   */
+  static intersection(children) { return GeometryNode.boolean('intersection', children); }
+
+  /**
+   * Applies a transform, collapsing a transform applied to a transform into a single matrix.
+   *
+   * A deep chain of translate blocks would otherwise be one kernel call and one cache entry
+   * per level.
+   *
+   * @param {GeometryNode} child What to transform.
+   * @param {Transform} transform The transform to apply.
+   * @returns {GeometryNode} The transformed node.
+   */
+  static transformed(child, transform) {
+    if (child.isEmpty) return child;
+    if (child.kind === 'transform') {
+      return new GeometryNode(child.dim, 'transform',
+        { transform: transform.concat(/** @type {Transform} */ (child.props.transform)) }, child.children);
+    }
+    return new GeometryNode(child.dim, 'transform', { transform }, [child]);
+  }
+
+  /**
+   * Wraps a single child, short-circuiting on empty geometry.
+   *
+   * @param {string} kind What the node does.
+   * @param {GeometryNode} child The operand.
+   * @param {Record<string, unknown>} [props] The operation's parameters.
+   * @param {Dimensionality} [dim] The result's dimensionality; defaults to the child's,
+   *   which is wrong only for the operations that change it, such as `extrude`.
+   * @returns {GeometryNode} The wrapped node.
+   */
+  static unary(kind, child, props = {}, dim = child.dim) {
+    if (child.isEmpty) return GeometryNode.empty(dim);
+    return new GeometryNode(dim, kind, props, [child]);
+  }
+
+  /**
+   * @param {Dimensionality} dim Whether the shape is 2D or 3D.
+   * @param {string} shape Which primitive, such as `box` or `circle`.
+   * @param {Record<string, unknown>} params The primitive's parameters.
+   * @returns {GeometryNode} A leaf node.
+   */
+  static shape(dim, shape, params) {
+    return new GeometryNode(dim, dim === 2 ? 'shape2d' : 'shape3d', { shape, ...params });
+  }
+
+  /** @returns {string} A short identification, for diagnostics. */
+  toString() {
+    return `${this.kind}<${this.dim}D>#${this.digest.slice(0, 8)}`;
+  }
+}

package/src/export/mesh.js

@@ -0,0 +1,83 @@
+/** @import { IndexedMesh, RenderMesh, Solid } from '../index.js' */
+
+/**
+ * A point in space, as three numbers.
+ *
+ * @typedef {[number, number, number]} Triple
+ */
+
+/**
+ * Reads one vertex position out of the kernel's flat property array.
+ *
+ * `vertProperties` interleaves whatever properties the mesh carries, so the position is the
+ * first three of every `stride`, not every third entry.
+ *
+ * @param {IndexedMesh} mesh The kernel mesh.
+ * @param {number} index Which vertex.
+ * @param {number} stride How many properties each vertex carries.
+ * @returns {Triple} The position.
+ */
+function vertexAt(mesh, index, stride) {
+  const o = index * stride;
+  return [mesh.vertProperties[o], mesh.vertProperties[o + 1], mesh.vertProperties[o + 2]];
+}
+
+/**
+ * The unit normal of a triangle, wound counter-clockwise.
+ *
+ * A degenerate triangle has no direction to point in, so it keeps the zero vector rather
+ * than dividing by zero and poisoning the buffer with NaN.
+ *
+ * @param {Triple} a First corner.
+ * @param {Triple} b Second corner.
+ * @param {Triple} c Third corner.
+ * @returns {Triple} The normal.
+ */
+function faceNormal(a, b, c) {
+  const u = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+  const v = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+  const n = /** @type {Triple} */ ([
+    u[1] * v[2] - u[2] * v[1],
+    u[2] * v[0] - u[0] * v[2],
+    u[0] * v[1] - u[1] * v[0],
+  ]);
+  const length = Math.hypot(n[0], n[1], n[2]);
+  return length > 0 ? [n[0] / length, n[1] / length, n[2] / length] : n;
+}
+
+/**
+ * Converts an evaluated Manifold into flat typed arrays for a renderer.
+ *
+ * `getMesh()` returns indexed triangles sharing vertices, which is what a viewer wants for
+ * upload size, but shared vertices across a hard edge would be smooth-shaded. Normals are
+ * therefore computed per face and the vertices expanded, so a cube reads as a cube.
+ *
+ * @param {Solid} manifold The solid to convert.
+ * @returns {RenderMesh} Expanded positions and normals, three vertices per triangle.
+ */
+export function toRenderMesh(manifold) {
+  const mesh = manifold.getMesh();
+  const stride = mesh.numProp;
+  const triangles = mesh.triVerts.length / 3;
+
+  const positions = new Float32Array(triangles * 9);
+  const normals = new Float32Array(triangles * 9);
+
+  for (let t = 0; t < triangles; t++) {
+    const corners = [
+      vertexAt(mesh, mesh.triVerts[t * 3], stride),
+      vertexAt(mesh, mesh.triVerts[t * 3 + 1], stride),
+      vertexAt(mesh, mesh.triVerts[t * 3 + 2], stride),
+    ];
+    const normal = faceNormal(corners[0], corners[1], corners[2]);
+
+    // All three corners carry the same normal; that repetition is what keeps the edge hard.
+    for (const [i, corner] of corners.entries()) {
+      const o = t * 9 + i * 3;
+      positions[o] = corner[0]; positions[o + 1] = corner[1]; positions[o + 2] = corner[2];
+      normals[o] = normal[0]; normals[o + 1] = normal[1]; normals[o + 2] = normal[2];
+    }
+  }
+
+  return { positions, normals, triangleCount: triangles, vertexCount: mesh.numVert };
+}

package/src/export/stl.js

@@ -0,0 +1,49 @@
+/** @import { Solid } from '../index.js' */
+
+import { toRenderMesh } from './mesh.js';
+
+// The binary STL layout, named rather than spelled as arithmetic at every offset.
+const HEADER_BYTES = 80;
+const COUNT_BYTES = 4;
+const BODY_START = HEADER_BYTES + COUNT_BYTES;
+/** A normal, three vertices, and a trailing attribute count: 12 floats and a uint16. */
+const TRIANGLE_BYTES = 50;
+
+/**
+ * Encodes a solid as binary STL.
+ *
+ * Binary rather than ASCII because a model of any size is several times smaller and every
+ * slicer reads it.
+ *
+ * @param {Solid} manifold The solid to encode.
+ * @param {string} [header] Free text for the 80-byte header; truncated to fit, so it cannot
+ *   run into the triangle count that follows it.
+ * @returns {Uint8Array} The STL file.
+ */
+export function toBinarySTL(manifold, header = 'forma-dsl') {
+  const { positions, normals, triangleCount } = toRenderMesh(manifold);
+  const buffer = new ArrayBuffer(BODY_START + triangleCount * TRIANGLE_BYTES);
+  const view = new DataView(buffer);
+  const bytes = new Uint8Array(buffer);
+
+  bytes.set(new TextEncoder().encode(header.slice(0, HEADER_BYTES - 1)), 0);
+  view.setUint32(HEADER_BYTES, triangleCount, true);
+
+  for (let t = 0; t < triangleCount; t++) {
+    const o = BODY_START + t * TRIANGLE_BYTES;
+
+    for (let axis = 0; axis < 3; axis++) {
+      view.setFloat32(o + axis * 4, normals[t * 9 + axis], true);
+    }
+    for (let v = 0; v < 3; v++) {
+      for (let axis = 0; axis < 3; axis++) {
+        view.setFloat32(o + 12 + v * 12 + axis * 4, positions[t * 9 + v * 3 + axis], true);
+      }
+    }
+
+    // The attribute byte count. Nothing reads it, and slicers dislike it being anything else.
+    view.setUint16(o + 48, 0, true);
+  }
+
+  return new Uint8Array(buffer);
+}