gaussian-splat-lite 1.5.1 → 1.5.2

package/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.5.2] - 2026-10-29
+
+### Changed
+
+- `gsl-build-lod` reduces temporary-file reads for models larger than `--memory-budget`.
+
+### Fixed
+
+- Neural denoising no longer lets a still view turn grainy again when it keeps rendering for many seconds.
+- `gsl-build-lod` limits pending disk writes within `--memory-budget` to prevent excessive memory use on slow disks.
+
 ## [1.5.1] - 2026-10-27
 
 ### Changed
@@ -709,7 +720,8 @@ and this project follows [Semantic Versioning](https://semver.org/).
 
 - Initial public release of the Three.js Gaussian Splatting renderer.
 
-[Unreleased]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.5.1...HEAD
+[Unreleased]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.5.2...HEAD
+[1.5.2]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.5.1...v1.5.2
 [1.5.1]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.5.0...v1.5.1
 [1.5.0]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.4.3...v1.5.0
 [1.4.3]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v1.4.2...v1.4.3

package/bin/build-lod.js

@@ -13,6 +13,7 @@ import { buildLod } from "./rad/lod.js";
 import { Pool } from "./rad/parallel.js";
 import { checkOutput, writeRad } from "./rad/rad.js";
 import { GIB, Workspace } from "./rad/storage.js";
+import { syncFiles } from "./rad/writeback.js";
 
 const help = `Convert PLY or SPZ files to RAD with levels of detail (LOD).
 
@@ -37,7 +38,7 @@ Options:
   -h, --help             Show this help
 
 SH4 inputs are accepted; coefficients above --max-sh are discarded.
-The memory target covers the whole conversion, worker threads included.
+The memory target covers the conversion, worker threads and pending disk writes included.
 Requires Node.js 22.12 or later. No compilation is required.`;
 
 function parse(args) {
@@ -139,7 +140,13 @@ async function convert(input, options, kernel, cancelled) {
       `${path.basename(input, path.extname(input))}-lod.rad`,
     );
   checkOutput(output, options.chunked);
-  const workspace = new Workspace(options.budget, options.tempDir, cancelled);
+  const workspace = new Workspace(
+    options.budget,
+    (files, state) =>
+      parentPort.postMessage({ method: "writeback", args: [files, state] }),
+    options.tempDir,
+    cancelled,
+  );
   const start = performance.now();
   console.log(
     `${input} -> ${output}\nMemory target: ${(options.budget / GIB).toFixed(3)} GiB`,
@@ -222,6 +229,7 @@ async function run(options, cancelled) {
 
 // Keep signal handling responsive while the conversion runs synchronous code.
 // The worker observes cancellation and unwinds its existing catch/finally blocks.
+// Cleanup finishes submitted writeback before closing files and exiting.
 async function start(options) {
   const cancelled = new Int32Array(new SharedArrayBuffer(4));
   let progressLine = "";
@@ -230,6 +238,7 @@ async function start(options) {
     progressLine = "";
   };
   const print = ({ method, args }) => {
+    if (method === "writeback") return syncFiles(...args, cancelled);
     if (method === "progress") {
       const [line, done] = args;
       if (process.stdout.isTTY) {
@@ -249,7 +258,9 @@ async function start(options) {
     const code = signal === "SIGINT" ? 130 : 143;
     if (Atomics.compareExchange(cancelled, 0, 0, code) === 0) {
       endProgress();
-      console.error(`${signal}: cancelling conversion and cleaning up...`);
+      console.error(
+        `${signal}: cancelling conversion; waiting for active disk I/O before cleanup...`,
+      );
     }
   };
   process.on("SIGINT", interrupt);

package/bin/decoder/decoder.js

@@ -78,10 +78,6 @@ function __wbg_get_imports() {
             const ret = new Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_new_from_slice_d85ad974cf8f6f35: function(arg0, arg1) {
-            const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
-            return ret;
-        },
         __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
             const ret = arg1.stack;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -95,6 +91,11 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(F32)) -> NamedExternref("Float32Array")`.
+            const ret = getArrayF32FromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;

package/bin/rad/cluster.js

@@ -6,7 +6,7 @@ import { HALF } from "./math.js";
 import { WorkerGroup, clusterers } from "./parallel.js";
 import { Progress } from "./progress.js";
 import { SH_DIMS } from "./splats.js";
-import { PagedArray } from "./storage.js";
+import { PAGE_BYTES, PagedArray } from "./storage.js";
 
 // Codebook entries at most: RAD labels are 16-bit.
 const MAX_CODES = 65536;
@@ -323,6 +323,13 @@ class Assigner extends WorkerGroup {
   }
 }
 
+// Rows that fit in the cache, allowing a partial page per column. Repeated
+// scans cache this prefix and bypass the rest to avoid evicting it.
+function fitting(bytes, row, columns) {
+  const pages = Math.floor(bytes / PAGE_BYTES) - columns;
+  return Math.max(0, Math.floor((pages * PAGE_BYTES) / row));
+}
+
 // Reads splats' SH as rows of half bits, the bands one after another, with
 // their weights, area × opacity as merging weighs them.
 class Rows {
@@ -330,16 +337,21 @@ class Rows {
     this.splats = splats;
     this.dims = dims;
     this.length = splats.length;
+    this.kept = Number.POSITIVE_INFINITY;
     this.column = new Uint16Array(JOB * SH_DIMS[SH_DIMS.length - 1]);
     this.records = new Float32Array(JOB * 16);
   }
 
+  keep(bytes) {
+    this.kept = fitting(bytes, this.dims * 2 + 64, this.splats.maxSh + 1);
+  }
+
   read(base, count, bits, weights) {
-    const { splats, dims, column } = this;
+    const { splats, dims, column, kept } = this;
     let offset = 0;
     for (let band = 0; band < splats.maxSh; band++) {
       const size = SH_DIMS[band];
-      splats.sh[band].read(base * size, column, count * size);
+      splats.sh[band].scan(base * size, column, count * size, kept * size);
       for (let i = 0; i < count; i++)
         for (let d = 0; d < size; d++)
           bits[i * dims + offset + d] = column[i * size + d];
@@ -349,10 +361,11 @@ class Rows {
   }
 
   weigh(base, count, weights) {
-    const records = this.splats.records.read(
+    const records = this.splats.records.scan(
       base * 16,
       this.records,
       count * 16,
+      this.kept * 16,
     );
     for (let i = 0; i < count; i++)
       weights[i] = records[i * 16 + 15] * records[i * 16 + 3];
@@ -364,13 +377,19 @@ class Sample {
   constructor(workspace, dims) {
     this.dims = dims;
     this.length = 0;
+    this.kept = Number.POSITIVE_INFINITY;
     this.bits = new PagedArray(workspace, Uint16Array);
     this.weights = new PagedArray(workspace, Float64Array);
   }
 
+  keep(bytes) {
+    this.kept = fitting(bytes, this.dims * 2 + 8, 2);
+  }
+
   read(base, count, bits, weights) {
-    this.bits.read(base * this.dims, bits, count * this.dims);
-    this.weights.read(base, weights, count);
+    const { dims, kept } = this;
+    this.bits.scan(base * dims, bits, count * dims, kept * dims);
+    this.weights.scan(base, weights, count, kept);
   }
 
   dispose() {
@@ -653,11 +672,21 @@ export async function clusterSh(splats, iterations, module) {
       extra,
       Math.ceil(training.length / size),
     );
+    // Measure worker growth between passes: bypass reads do not allocate
+    // pages or trigger measurements. Leave room for labels when the final
+    // pass shares the training cache.
+    const labelPages = sampled ? 0 : Math.ceil((length * 2) / PAGE_BYTES);
+    const keep = () => {
+      workspace.adjust();
+      training.keep(workspace.capacity - labelPages * PAGE_BYTES);
+    };
+    keep();
     const codes = new Float64Array(count * dims);
     const sums = new Float64Array(count * dims);
     const totals = new Float64Array(count);
     const bits = new Uint16Array(dims);
     const weight = new Float64Array(1);
+    // Read seeds past the cached prefix directly, preserving training rows.
     for (let c = 0; c < count; c++) {
       // Spark computes the seed rows in single precision.
       const row = Math.floor(
@@ -705,6 +734,7 @@ export async function clusterSh(splats, iterations, module) {
         layout(codes, order, dims, center, blocked, norms);
         await assigner.use("codes", { codes: blocked, norms, center });
       }
+      keep();
       if (!last) {
         sums.fill(0);
         totals.fill(0);

package/bin/rad/heap.js

@@ -247,7 +247,7 @@ export function sortSplats(splats, pool) {
   // rank alone keeps splats of equal size in index order.
   const items = new IndexArray(workspace);
   for (let i = 0; i < count; i++) {
-    const key = rank(-splats.feature(i));
+    const key = rank(-splats.sizes.get(i));
     const words = items.page(i * 2, true);
     const offset = (i * 2) & items.mask;
     words[offset] = key;
@@ -266,5 +266,4 @@ export function sortSplats(splats, pool) {
   sorted.dispose();
   ordering.finish();
   splats.reorder(order, pool);
-  order.dispose();
 }

package/bin/rad/lod.js

@@ -49,21 +49,17 @@ export function buildLod(splats, lodBase, pool) {
   splats.weight.dispose();
   selection.finish(`${retainedCount} nodes retained`);
 
-  // Ordering reads sizes at random; a copy without the rest of each record
-  // stays cached.
-  const sizes = new PagedArray(workspace, Float32Array);
-  const sizing = new Progress("Reading LOD sizes", splats.length);
-  for (let index = 0; index < splats.length; index++) {
-    sizes.set(index, splats.feature(index));
-    if ((index & 4095) === 0) sizing.update(index);
-  }
-  sizing.finish();
+  // Ordering reads sizes at random, from a column without the rest of each
+  // record, and lists them in logical order for chunkTree().
+  const sizes = splats.sizes;
   // A splat's logical index is its position in `order`. Its children get
   // consecutive logical indices: `first` and the `counts` - 1 after it.
   const order = new IndexArray(workspace);
   const first = new IndexArray(workspace);
   const counts = new IndexArray(workspace);
+  const ordered = new PagedArray(workspace, Float32Array);
   order.push(root);
+  ordered.push(sizes.get(root));
   // The splats to visit, by logical index, splat and size: the frontier of a
   // pass as triples of words, and a stack within it.
   let frontier = new IndexArray(workspace);
@@ -120,17 +116,22 @@ export function buildLod(splats, lodBase, pool) {
         const start = order.length;
         first.set(logical, start);
         counts.set(logical, count);
-        for (let c = 0; c < count; c++) order.push(list[c]);
         if (top + count > logicals.length) {
           logicals = grow(logicals, top, top + count);
           indices = grow(indices, top, top + count);
           lengths = grow(lengths, top, top + count);
         }
-        for (let c = count - 1; c >= 0; c--) {
-          logicals[top] = start + c;
-          indices[top] = list[c];
-          lengths[top++] = sizes.get(list[c]);
+        // Each child's size is read once, at random, for both uses.
+        for (let c = 0; c < count; c++) {
+          const length = sizes.get(list[c]);
+          order.push(list[c]);
+          ordered.push(length);
+          const at = top + count - 1 - c;
+          logicals[at] = start + c;
+          indices[at] = list[c];
+          lengths[at] = length;
         }
+        top += count;
       }
     }
     frontier.dispose();
@@ -143,7 +144,7 @@ export function buildLod(splats, lodBase, pool) {
   sizes.dispose();
   kept.dispose();
   ordering.finish();
-  chunkTree(splats, order, first, counts, pool);
+  chunkTree(splats, order, first, counts, ordered, pool);
   order.dispose();
 }
 
@@ -152,24 +153,8 @@ export function buildLod(splats, lodBase, pool) {
 function mergeLevels(splats, pool) {
   const initial = splats.length;
   const workspace = splats.workspace;
-  // Merged splats lie within the leaves' bounds. merge() reads the leaves'
-  // weights.
-  const bounds = {
-    min: [0, 1, 2].map(() => Number.POSITIVE_INFINITY),
-    max: [0, 1, 2].map(() => Number.NEGATIVE_INFINITY),
-  };
-  const record = new Float64Array(16);
-  const preparing = new Progress("Preparing LOD bounds", initial);
-  for (let i = 0; i < initial; i++) {
-    splats.read(i, record);
-    for (let d = 0; d < 3; d++) {
-      bounds.min[d] = Math.min(bounds.min[d], record[d]);
-      bounds.max[d] = Math.max(bounds.max[d], record[d]);
-    }
-    splats.weight.set(i, record[15] * record[3]);
-    if ((i & 4095) === 0) preparing.update(i);
-  }
-  preparing.finish();
+  // Merged splats lie within the leaves' bounds.
+  const { bounds, sizes } = splats;
   const removed = new PagedArray(workspace, Uint8Array);
   const similarities = new Similarities(splats);
   let active = new Heap(workspace);
@@ -187,7 +172,7 @@ function mergeLevels(splats, pool) {
   const added = new Cells(18);
   const near = new Cells(20);
   for (
-    let level = Math.ceil(Math.log2(Math.max(splats.feature(0), 0.000001)));
+    let level = Math.ceil(Math.log2(Math.max(sizes.get(0), 0.000001)));
     ;
     level++
   ) {
@@ -199,14 +184,14 @@ function mergeLevels(splats, pool) {
     let high = initial;
     while (low < high) {
       const middle = Math.floor((low + high) / 2);
-      if (splats.feature(middle) <= step) low = middle + 1;
+      if (sizes.get(middle) <= step) low = middle + 1;
       else high = middle;
     }
     const { grid, queue } = Progress.inline(() => {
       const adding = new Progress(`Preparing level ${level}`, low - frontier);
       const previous = frontier;
       while (frontier < low) {
-        active.push(frontier, -splats.feature(frontier));
+        active.push(frontier, -sizes.get(frontier));
         frontier++;
         if ((frontier & 4095) === 0) adding.update(frontier - previous);
       }
@@ -323,7 +308,7 @@ function mergeLevels(splats, pool) {
         removed.set(other, 1);
         grid.remove(self);
         grid.remove(best);
-        const feature = splats.feature(merged);
+        const feature = sizes.get(merged);
         if (feature > step) next.push(merged, -feature);
         else {
           const terms =
@@ -404,8 +389,8 @@ function sort(values, count) {
 
 // Lays out the tree in chunks of 65536 splats and moves every column into
 // that order. Children become consecutive rows: childStart is then the row of
-// a splat's first child.
-function chunkTree(splats, order, first, counts, pool) {
+// a splat's first child. `sizes` are the splats' sizes in logical order.
+function chunkTree(splats, order, first, counts, sizes, pool) {
   const workspace = splats.workspace;
   const nodes = splats.length;
   for (const column of [splats.childStart, splats.childCount, splats.children])
@@ -426,13 +411,6 @@ function chunkTree(splats, order, first, counts, pool) {
     "Reordering LOD nodes",
   );
   logical.dispose();
-  const sizes = new PagedArray(workspace, Float32Array);
-  const sizing = new Progress("Reading chunk sizes", order.length);
-  for (let index = 0; index < order.length; index++) {
-    sizes.set(index, splats.feature(index));
-    if ((index & 4095) === 0) sizing.update(index);
-  }
-  sizing.finish();
   // The row of each splat's first child.
   const starts = new PagedArray(workspace, Float64Array);
   const indices = new IndexArray(workspace);
@@ -629,28 +607,31 @@ function chunkTree(splats, order, first, counts, pool) {
     "Reordering child offsets",
   );
   chunked.dispose();
-  // The SH coefficients are still in node order.
-  const shOrder = new Progress("Collecting LOD SH order", indices.length);
-  for (let i = 0; i < indices.length; i++) {
-    indices.set(i, order.get(indices.get(i)));
-    if ((i & 4095) === 0) shOrder.update(i);
-  }
-  shOrder.finish();
-  const nodeOrder = new Permutation(
-    workspace,
-    indices,
-    nodes,
-    "Preparing LOD SH order",
-  );
-  for (let band = 0; band < splats.maxSh; band++)
-    splats.sh[band] = nodeOrder.apply(
-      splats.sh[band],
-      SH_DIMS[band],
-      pool,
-      false,
-      `Reordering LOD SH${band + 1}`,
+  // The SH coefficients are still in the order of mergeSh().
+  if (splats.maxSh) {
+    const shOrder = new Progress("Collecting LOD SH order", indices.length);
+    for (let i = 0; i < indices.length; i++) {
+      indices.set(i, splats.shRow(order.get(indices.get(i))));
+      if ((i & 4095) === 0) shOrder.update(i);
+    }
+    shOrder.finish();
+    splats.shOrder.dispose();
+    const nodeOrder = new Permutation(
+      workspace,
+      indices,
+      nodes,
+      "Preparing LOD SH order",
     );
-  nodeOrder.dispose();
+    for (let band = 0; band < splats.maxSh; band++)
+      splats.sh[band] = nodeOrder.apply(
+        splats.sh[band],
+        SH_DIMS[band],
+        pool,
+        false,
+        `Reordering LOD SH${band + 1}`,
+      );
+    nodeOrder.dispose();
+  }
   first.dispose();
   splats.length = indices.length;
   indices.dispose();

package/bin/rad/rad.js

@@ -16,7 +16,7 @@ import { HALF, half, halfBits, opacityRadius } from "./math.js";
 import { WorkerGroup, encoders } from "./parallel.js";
 import { Progress } from "./progress.js";
 import { SH_DIMS } from "./splats.js";
-import { readAll, removePath, writeAll } from "./storage.js";
+import { PAGE_BYTES, readAll, removePath } from "./storage.js";
 
 const CHUNK = 65536;
 // Fixed s8 range with SPZ's 1/128 SH step; -1 clips to -127/128.
@@ -158,27 +158,34 @@ const unorm = (value, min, max) =>
   Math.round(Math.max(0, Math.min(255, ((value - min) / (max - min)) * 255)));
 
 // The columns encodeChunk() reads. With a codebook, labels replace the SH.
-function gather(splats, base, count, codebook) {
+// The records before `kept` come through the cache, where counting left
+// them; the rest of them and the other columns, read once, pass it by.
+function gather(splats, base, count, codebook, kept) {
   return {
     base,
     count,
     maxSh: splats.maxSh,
-    records: splats.records.read(base * 16, new Float32Array(count * 16)),
+    records: splats.records.scan(
+      base * 16,
+      new Float32Array(count * 16),
+      count * 16,
+      kept * 16,
+    ),
     sh: codebook
       ? []
       : splats.sh
           .slice(0, splats.maxSh)
           .map((column, band) =>
-            column.read(
+            column.stream(
               base * SH_DIMS[band],
               new Uint16Array(count * SH_DIMS[band]),
             ),
           ),
     ...(codebook && {
-      labels: codebook.labels.read(base, new Uint16Array(count)),
+      labels: codebook.labels.stream(base, new Uint16Array(count)),
     }),
-    counts: splats.childCount.read(base, new Uint32Array(count)),
-    starts: splats.childStart.read(base, new Float64Array(count)),
+    counts: splats.childCount.stream(base, new Uint32Array(count)),
+    starts: splats.childStart.stream(base, new Float64Array(count)),
   };
 }
 
@@ -447,15 +454,16 @@ if (!isMainThread && workerData?.coder) {
 
 // With a codebook from clusterSh(), splats store SH as its labels.
 export async function writeRad(splats, output, chunked, lodBase, codebook) {
+  const { workspace } = splats;
   const chunks = [];
   const stem = chunkStem(output);
-  const spool = chunked ? undefined : splats.workspace.file();
+  const spool = chunked ? undefined : workspace.file();
   // Write every file completely before publishing chunks, then the header.
   // Track published names too, so cancellation rolls back this conversion.
   const staged = [];
   const created = [];
   const stage = (file, write) => {
-    splats.workspace.check();
+    workspace.check();
     const temporary = path.join(
       path.dirname(file),
       `.${path.basename(file)}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`,
@@ -464,14 +472,15 @@ export async function writeRad(splats, output, chunked, lodBase, codebook) {
     staged.push({ temporary, file });
     try {
       write(fd);
+      workspace.check();
       fsyncSync(fd);
-    } catch (error) {
+    } finally {
       try {
+        workspace.writeback.synced(fd);
+      } finally {
         closeSync(fd);
-      } catch {}
-      throw error;
+      }
     }
-    closeSync(fd);
   };
   let total = 0;
   let progress;
@@ -479,11 +488,11 @@ export async function writeRad(splats, output, chunked, lodBase, codebook) {
     if (chunked) {
       const filename = `${stem}-${chunks.length}.radc`;
       stage(path.join(path.dirname(output), filename), (fd) =>
-        writeAll(fd, bytes, 0),
+        workspace.write(fd, bytes, 0),
       );
       chunks.push({ offset: 0, bytes: bytes.length, filename });
     } else {
-      writeAll(spool, bytes, total);
+      workspace.write(spool, bytes, total);
       chunks.push({ offset: total, bytes: bytes.length });
     }
     total += bytes.length;
@@ -493,21 +502,29 @@ export async function writeRad(splats, output, chunked, lodBase, codebook) {
   // order. A chunk's failure is thrown when its turn comes, not as an
   // unhandled rejection while an earlier chunk is awaited.
   const pending = [];
-  const encoder = new Encoder(
-    splats.workspace,
-    Math.ceil(splats.length / CHUNK),
-  );
+  const encoder = new Encoder(workspace, Math.ceil(splats.length / CHUNK));
   try {
-    // Count the encoding ranges in a first pass.
+    // Count the encoding ranges in a first pass. The records that the cache
+    // holds stay there for encoding; see gather(). Recompute the prefix
+    // after measuring worker growth so it fits a cache that has shrunk.
+    const keep = () => {
+      workspace.adjust();
+      return Math.floor(Math.max(0, workspace.capacity - PAGE_BYTES) / 64);
+    };
     const chunkCount = Math.ceil(splats.length / CHUNK);
     progress = new Progress("Analyzing RAD encoding", chunkCount);
     let countedChunks = 0;
     for (let base = 0; base < splats.length; base += CHUNK) {
-      splats.workspace.check();
+      workspace.check();
+      // The encoders grow as they work, and reading past the cache loads
+      // no pages, which would measure them.
+      const kept = keep();
       const count = Math.min(CHUNK, splats.length - base);
-      const records = splats.records.read(
+      const records = splats.records.scan(
         base * 16,
         new Float32Array(count * 16),
+        count * 16,
+        kept * 16,
       );
       const counted = encoder
         .count(records)
@@ -522,12 +539,14 @@ export async function writeRad(splats, output, chunked, lodBase, codebook) {
     progress.finish();
     progress = new Progress("Encoding RAD chunks", chunkCount);
     for (let base = 0; base < splats.length; base += CHUNK) {
-      splats.workspace.check();
+      workspace.check();
+      const kept = keep();
       const chunk = gather(
         splats,
         base,
         Math.min(CHUNK, splats.length - base),
         codebook,
+        kept,
       );
       if (codebook && base === 0)
         chunk.codes = encodeCodes(codebook, splats.maxSh);
@@ -556,25 +575,28 @@ export async function writeRad(splats, output, chunked, lodBase, codebook) {
       meta.length + (spool === undefined ? 0 : total),
     );
     stage(output, (fd) => {
-      writeAll(fd, meta, 0);
+      workspace.write(fd, meta, 0);
       if (spool !== undefined) {
         const buffer = Buffer.allocUnsafe(1024 * 1024);
         for (let offset = 0; offset < total; offset += buffer.length) {
-          splats.workspace.check();
+          workspace.check();
           const bytes = buffer.subarray(
             0,
             Math.min(buffer.length, total - offset),
           );
           readAll(spool, bytes, offset);
-          writeAll(fd, bytes, meta.length + offset);
+          workspace.write(fd, bytes, meta.length + offset);
           writing.update(meta.length + offset + bytes.length);
         }
       }
     });
     writing.finish();
+    // Closing an output waits only for a sync that includes it; a temporary
+    // file's failed writeback must surface before anything is published.
+    workspace.writeback.wait();
     const publishing = new Progress("Publishing RAD files", staged.length);
     for (const { temporary, file } of staged) {
-      splats.workspace.check();
+      workspace.check();
       // rename can replace an existing file, so reserve the name exclusively.
       const fd = openSync(file, "wx");
       created.push(file);
@@ -582,7 +604,7 @@ export async function writeRad(splats, output, chunked, lodBase, codebook) {
       renameSync(temporary, file);
       publishing.update(created.length);
     }
-    splats.workspace.check();
+    workspace.check();
     publishing.finish();
     return meta.length + total;
   } catch (error) {