qvdjs 2.0.5 → 2.1.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import fs2 from 'fs';
 import path2 from 'path';
-import assert3 from 'assert';
+import assert4 from 'assert';
 import crypto2 from 'crypto';
 import { setTimeout } from 'timers/promises';
 import xml from 'xml2js';
@@ -441,7 +441,9 @@ var init_optionTypes = __esm({
 function requireRowCount(value, name, filePath) {
   if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
     throw new QvdValidationError(`${name} must be a non-negative integer`, {
+      reason: "option",
       option: name,
+      value,
       provided: value,
       type: typeof value,
       file: filePath
@@ -458,6 +460,9 @@ function normaliseWindow(window, filePath) {
   }
   if (typeof window !== "object" || Array.isArray(window)) {
     throw new QvdValidationError("The row window must be a number, null, or an {offset, limit} object", {
+      reason: "option",
+      option: "limit",
+      value: window,
       provided: window,
       type: typeof window,
       file: filePath
@@ -468,6 +473,9 @@ function normaliseWindow(window, filePath) {
   const maxRowsGiven = maxRows !== void 0 && maxRows !== null;
   if (limitGiven && maxRowsGiven) {
     throw new QvdValidationError("maxRows and limit are two names for the same option; pass one of them, not both", {
+      reason: "option",
+      option: "limit",
+      value: limit,
       maxRows,
       limit,
       file: filePath
@@ -478,6 +486,19 @@ function normaliseWindow(window, filePath) {
     limit: limitGiven ? requireRowCount(limit, "limit", filePath) : maxRowsGiven ? requireRowCount(maxRows, "maxRows", filePath) : null
   };
 }
+function requireChunkSize(chunkSize, filePath) {
+  if (typeof chunkSize !== "number" || !Number.isInteger(chunkSize) || chunkSize <= 0) {
+    throw new QvdValidationError("chunkSize must be a positive integer", {
+      reason: "option",
+      option: "chunkSize",
+      value: chunkSize,
+      provided: chunkSize,
+      type: typeof chunkSize,
+      file: filePath
+    });
+  }
+  return chunkSize;
+}
 function resolveWindow(window, totalRows) {
   const rows = Number.isSafeInteger(totalRows) && totalRows > 0 ? totalRows : 0;
   const offset = Math.min(window.offset, rows);
@@ -492,6 +513,9 @@ function selectFields(fields, requested, filePath) {
   }
   if (!Array.isArray(requested)) {
     throw new QvdValidationError("fields must be an array of field names", {
+      reason: "option",
+      option: "fields",
+      value: requested,
       provided: requested,
       type: typeof requested,
       file: filePath
@@ -500,6 +524,9 @@ function selectFields(fields, requested, filePath) {
   const available = fields.map((field) => field["FieldName"]);
   if (requested.length === 0) {
     throw new QvdValidationError("fields must name at least one field", {
+      reason: "option",
+      option: "fields",
+      value: requested,
       availableColumns: available,
       file: filePath
     });
@@ -508,6 +535,9 @@ function selectFields(fields, requested, filePath) {
   return requested.map((name) => {
     if (typeof name !== "string") {
       throw new QvdValidationError("Field names must be strings", {
+        reason: "option",
+        option: "fields",
+        value: name,
         provided: name,
         type: typeof name,
         availableColumns: available,
@@ -516,6 +546,9 @@ function selectFields(fields, requested, filePath) {
     }
     if (seen.has(name)) {
       throw new QvdValidationError(`Field '${name}' is listed twice`, {
+        reason: "option",
+        option: "fields",
+        value: name,
         column: name,
         fields: requested,
         file: filePath
@@ -525,6 +558,9 @@ function selectFields(fields, requested, filePath) {
     const index = available.indexOf(name);
     if (index === -1) {
       throw new QvdValidationError(`Column '${name}' does not exist`, {
+        reason: "option",
+        option: "fields",
+        value: name,
         column: name,
         availableColumns: available,
         file: filePath
@@ -539,7 +575,9 @@ function normaliseDuals(value, filePath) {
   }
   if (!DUAL_MODES.includes(value)) {
     throw new QvdValidationError(`duals must be one of ${DUAL_MODES.map((mode) => `'${mode}'`).join(", ")}`, {
+      reason: "option",
       option: "duals",
+      value,
       provided: value,
       file: filePath
     });
@@ -578,6 +616,7 @@ var init_readOptions = __esm({
     init_optionTypes();
     __name(requireRowCount, "requireRowCount");
     __name(normaliseWindow, "normaliseWindow");
+    __name(requireChunkSize, "requireChunkSize");
     __name(resolveWindow, "resolveWindow");
     __name(selectFields, "selectFields");
     DUAL_MODES = Object.freeze(["number", "text", "both"]);
@@ -959,7 +998,7 @@ function changedAfterCheck(checked, change) {
   });
 }
 async function openChecked(checked, purpose, failed, { nofollow = NOFOLLOW } = {}) {
-  assert3(purpose === "read" || checked.stats !== null, "A rewrite in place is of a file that exists.");
+  assert4(purpose === "read" || checked.stats !== null, "A rewrite in place is of a file that exists.");
   const noFollow = checked.onDisk ? nofollow : 0;
   const flags = (purpose === "rewrite" ? O_WRONLY : O_RDONLY) | noFollow;
   let handle;
@@ -1535,9 +1574,9 @@ var init_QvdFileWriter = __esm({
        * Writes the data to the QVD file.
        */
       async _writeData() {
-        assert3(this._header, "The QVD file header has not been parsed.");
-        assert3(this._symbolBuffer, "The QVD file symbol table has not been parsed.");
-        assert3(this._indexBuffer, "The QVD file index table has not been parsed.");
+        assert4(this._header, "The QVD file header has not been parsed.");
+        assert4(this._symbolBuffer, "The QVD file symbol table has not been parsed.");
+        assert4(this._indexBuffer, "The QVD file index table has not been parsed.");
         this._emitProgress("write", 0, 1);
         const headerBuffer = Buffer.concat([Buffer.from(this._header, "utf-8"), Buffer.from([0])]);
         const failed = rethrowAsIoError(this._path, "write");
@@ -1985,7 +2024,7 @@ var init_QvdFileWriter = __esm({
             const key = keys[slot];
             offset = typeof key === "number" ? writeSymbol(columnBuffer, offset, kinds[slot], key, texts[slot]) : writeSymbol(columnBuffer, offset, kinds[slot], null, key);
           }
-          assert3(offset === byteLength, "A column was encoded into a different number of bytes than it was sized for.");
+          assert4(offset === byteLength, "A column was encoded into a different number of bytes than it was sized for.");
           columnBuffers.push(columnBuffer);
           this._symbolTableMetadata?.push([symbolsOffset, byteLength, containsNull[column]]);
           this._symbolCounts?.push(keys.length);
@@ -2024,9 +2063,9 @@ var init_QvdFileWriter = __esm({
        * @private
        */
       _buildIndexTable() {
-        assert3(this._symbolCounts, "The QVD file symbol table has not been built.");
-        assert3(this._symbolTableMetadata, "The QVD file symbol table metadata has not been built.");
-        assert3(this._symbolIndexByValue, "The QVD file symbol index has not been built.");
+        assert4(this._symbolCounts, "The QVD file symbol table has not been built.");
+        assert4(this._symbolTableMetadata, "The QVD file symbol table metadata has not been built.");
+        assert4(this._symbolIndexByValue, "The QVD file symbol index has not been built.");
         this._indexTableMetadata = [];
         const columns = this._df.columns;
         const data = this._df.data;
@@ -2206,20 +2245,57 @@ function recommendedChunkFor(budget, symbolTableSize, windowRows, totalRows, col
   }
   return low;
 }
-function validateMemoryAvailability(symbolTableSize, maxRows, totalRows, filePath, safetyFactor = 0.8, columnCount = 0, materialisesRows = true, live = null) {
-  if (typeof safetyFactor !== "number" || safetyFactor < 0 || safetyFactor > 1) {
-    throw new QvdValidationError("safetyFactor must be a number between 0.0 and 1.0", { safetyFactor });
-  }
-  if (safetyFactor === 0) {
+function validateMemoryAvailability(symbolTableSize, maxRows, totalRows, filePath, safetyFactor = 0.8, columnCount = 0, materialisesRows = true, live = null, bytesHeld = null, readBytes = null) {
+  const answer = checkMemory({
+    symbolTableSize,
+    maxRows,
+    totalRows,
+    safetyFactor,
+    columnCount,
+    materialisesRows,
+    live,
+    bytesHeld,
+    readBytes
+  });
+  if (answer.fits) {
     return;
   }
-  const budget = getMemoryBudget();
+  const { message, context } = answer.refusal;
+  throw new QvdValidationError(message, {
+    file: filePath,
+    ...context,
+    reason: "memory",
+    check: answerOf(answer)
+  });
+}
+function checkMemory({
+  symbolTableSize,
+  maxRows,
+  totalRows,
+  safetyFactor = 0.8,
+  columnCount = 0,
+  materialisesRows = true,
+  live = null,
+  bytesHeld = null,
+  readBytes = null,
+  measured = null
+}) {
+  if (typeof safetyFactor !== "number" || safetyFactor < 0 || safetyFactor > 1) {
+    throw new QvdValidationError("safetyFactor must be a number between 0.0 and 1.0", {
+      safetyFactor,
+      reason: "option",
+      option: "memorySafetyFactor",
+      value: safetyFactor
+    });
+  }
+  const budget = measured ?? getMemoryBudget();
   const rowsToLoad = maxRows === null || maxRows >= totalRows ? totalRows : maxRows;
   const rowsLive = live === null ? null : live.rows;
   const liveRowsPerChunk = live === null ? 1 : live.perChunk;
   const liveRows = rowsLive === null ? rowsToLoad : Math.min(rowsLive, rowsToLoad);
   const heapMemory = estimateMemoryUsage(symbolTableSize, maxRows, totalRows, columnCount, materialisesRows, rowsLive);
-  const externalMemory = estimateExternalMemory(liveRows, columnCount);
+  const { held, forRows: heldForRows, forChunk: heldForChunk } = bytesHeld ?? noBytesHeld;
+  const externalMemory = estimateExternalMemory(liveRows, columnCount) + held;
   const bounded = budget.candidates.map((candidate) => {
     const heapOnly = candidate.source === "V8 heap limit";
     return {
@@ -2230,25 +2306,45 @@ function validateMemoryAvailability(symbolTableSize, maxRows, totalRows, filePat
       bounds: heapOnly ? "the V8 heap" : "the whole process"
     };
   });
-  const exceeded = bounded.filter((candidate) => candidate.needs > candidate.allowed);
-  const binding = exceeded.reduce(
-    (worst, candidate) => candidate.needs / candidate.allowed > worst.needs / worst.allowed ? candidate : worst,
-    exceeded[0]
+  if (safetyFactor === 0) {
+    const lowest = budget.candidates.reduce((least, candidate) => candidate.bytes < least.bytes ? candidate : least);
+    return {
+      fits: true,
+      estimate: { heapBytes: heapMemory, externalBytes: externalMemory, readBytes },
+      // The ceilings are still there and still named - what is missing is any measurement against them.
+      // An earlier version reported `bound: 'none'` here, a third value in a two-value vocabulary that a
+      // caller switching on the documented two would fall straight through.
+      budget: {
+        ...budgetOf(budget, { ...lowest, heapOnly: lowest.source === "V8 heap limit" }, 0),
+        allowedBytes: Infinity
+      },
+      exact: symbolTableSize === 0,
+      suggestions: []
+    };
+  }
+  const tightest = bounded.reduce(
+    (worst, candidate) => candidate.needs / candidate.allowed > worst.needs / worst.allowed ? candidate : worst
   );
+  const binding = tightest.needs > tightest.allowed ? tightest : null;
   const heapLimit = getHeapLimit();
   const availableMemory = binding ? binding.bytes : budget.bytes;
   const estimatedMemory = binding ? binding.needs : heapMemory;
   const maxAllowedMemory = binding ? binding.allowed : budget.bytes * safetyFactor;
   if (binding) {
     const includeExternal = !binding.heapOnly;
-    const recommendedMaxRows = recommendedRowsFor(
-      maxAllowedMemory,
+    const rowsHeldBudget = /* @__PURE__ */ __name((rows) => maxAllowedMemory - (includeExternal ? heldForRows(rows) : 0), "rowsHeldBudget");
+    const fitting = /* @__PURE__ */ __name((rows) => recommendedRowsFor(
+      rowsHeldBudget(rows),
       symbolTableSize,
       totalRows,
       columnCount,
       materialisesRows,
       includeExternal
-    );
+    ), "fitting");
+    const firstGuess = fitting(liveRows);
+    const over = fitting(firstGuess);
+    const under = fitting(over);
+    const recommendedMaxRows = Math.max(firstGuess, under);
     const sizeMB = Math.round(symbolTableSize / 1024 / 1024);
     const estimatedMB = Math.round(estimatedMemory / 1024 / 1024);
     const availableMB = Math.round(maxAllowedMemory / 1024 / 1024);
@@ -2261,15 +2357,20 @@ function validateMemoryAvailability(symbolTableSize, maxRows, totalRows, filePat
     const observedBreakdown = budget.observed.map((entry) => `${entry.source} ${Math.round(entry.bytes / 1024 / 1024)}MB`).join(", ");
     const containerBound = binding.source === "container memory limit";
     const chunked = rowsLive !== null;
-    const recommendedChunk = chunked ? recommendedChunkFor(
-      maxAllowedMemory,
+    const chunkHeldBudget = /* @__PURE__ */ __name((rows) => maxAllowedMemory - (includeExternal ? heldForChunk(rows) : 0), "chunkHeldBudget");
+    const chunkFitting = /* @__PURE__ */ __name((rows) => recommendedChunkFor(
+      chunkHeldBudget(rows),
       symbolTableSize,
       maxRows,
       totalRows,
       columnCount,
       liveRowsPerChunk,
       includeExternal
-    ) : 0;
+    ), "chunkFitting");
+    const callersChunk = chunked ? Math.max(1, Math.floor(rowsLive / Math.max(1, liveRowsPerChunk))) : 0;
+    const firstChunk = chunked ? chunkFitting(callersChunk) : 0;
+    const overChunk = chunked ? chunkFitting(firstChunk) : 0;
+    const recommendedChunk = chunked ? Math.max(firstChunk, chunkFitting(overChunk)) : 0;
     const knob = chunked ? "chunkSize" : "limit";
     const recommendedValue = chunked ? recommendedChunk : recommendedMaxRows;
     const nothingFits = recommendedValue === 0;
@@ -2281,31 +2382,75 @@ function validateMemoryAvailability(symbolTableSize, maxRows, totalRows, filePat
     } else {
       advice = `Try holding fewer rows using the ${knob} parameter (recommended: ${formatCount(recommendedValue)} rows or less), or raise the heap with --max-old-space-size.`;
     }
-    throw new QvdValidationError(
-      `Insufficient memory to load file safely. Symbol table: ${sizeMB}MB, Estimated memory needed: ${estimatedMB}MB, Available: ${availableMB}MB (limited by ${limitingFactor}, which bounds ${limitingScope}; considered: ${budgetBreakdown}; observed but not used: ${observedBreakdown}). ` + advice,
-      {
-        file: filePath,
-        symbolTableSize,
-        symbolTableSizeMB: sizeMB,
-        estimatedMemoryMB: estimatedMB,
-        availableMemoryMB: availableMB,
-        heapLimitMB,
-        reportedHeapLimitMB,
-        availableRamMB,
-        limitingFactor,
-        limitingScope,
-        memoryBudget: budget.candidates,
-        memoryObserved: budget.observed,
-        columnCount,
-        totalRows,
-        maxRows,
-        recommendedMaxRows,
-        // Only present when a chunk size is what overflowed, so a caller cannot mistake one
-        // recommendation for the other.
-        ...chunked ? { rowsLive, recommendedChunkSize: recommendedChunk } : {}
+    const suggestions = [];
+    if (!nothingFits) {
+      suggestions.push({ option: knob, value: recommendedValue });
+    }
+    if (!containerBound) {
+      let needed = Math.ceil(estimatedMemory / safetyFactor / (1024 * 1024));
+      while (Math.max(needed * 1024 * 1024, MINIMUM_BUDGET_BYTES) * safetyFactor < estimatedMemory) {
+        needed += 1;
       }
-    );
+      suggestions.push({ nodeOption: "--max-old-space-size", value: needed });
+    }
+    return {
+      fits: false,
+      reason: "memory",
+      estimate: { heapBytes: heapMemory, externalBytes: externalMemory, readBytes },
+      budget: budgetOf(budget, tightest, safetyFactor),
+      // The symbol term is six times the bytes on disk, an overhead measured across files rather than
+      // derived, so any read with symbols in it is an estimate and says so. Only a read that decodes
+      // nothing can be exact.
+      exact: symbolTableSize === 0,
+      suggestions,
+      refusal: {
+        message: `Insufficient memory to load file safely. Symbol table: ${sizeMB}MB, Estimated memory needed: ${estimatedMB}MB, Available: ${availableMB}MB (limited by ${limitingFactor}, which bounds ${limitingScope}; considered: ${budgetBreakdown}; observed but not used: ${observedBreakdown}). ` + advice,
+        context: {
+          symbolTableSize,
+          symbolTableSizeMB: sizeMB,
+          estimatedMemoryMB: estimatedMB,
+          availableMemoryMB: availableMB,
+          heapLimitMB,
+          reportedHeapLimitMB,
+          availableRamMB,
+          limitingFactor,
+          limitingScope,
+          memoryBudget: budget.candidates,
+          memoryObserved: budget.observed,
+          columnCount,
+          totalRows,
+          maxRows,
+          recommendedMaxRows,
+          // Only present when a chunk size is what overflowed, so a caller cannot mistake one
+          // recommendation for the other.
+          ...chunked ? { rowsLive, recommendedChunkSize: recommendedChunk } : {}
+        }
+      }
+    };
   }
+  return {
+    fits: true,
+    estimate: { heapBytes: heapMemory, externalBytes: externalMemory, readBytes },
+    budget: budgetOf(budget, tightest, safetyFactor),
+    exact: symbolTableSize === 0,
+    suggestions: []
+  };
+}
+function answerOf(answer) {
+  const { refusal, ...rest } = answer;
+  return rest;
+}
+function budgetOf(budget, tightest, safetyFactor) {
+  const processLimit = budget.candidates.find((candidate) => candidate.source !== "V8 heap limit");
+  return {
+    heapBytes: usableOldSpaceLimit(),
+    processBytes: processLimit ? processLimit.bytes : null,
+    bound: tightest.heapOnly ? "heap" : "process",
+    safetyFactor,
+    allowedBytes: tightest.allowed ?? tightest.bytes * safetyFactor,
+    candidates: budget.candidates,
+    observed: budget.observed
+  };
 }
 function formatCount(value) {
   return value.toLocaleString("en-US");
@@ -2327,7 +2472,7 @@ function warnLargeSymbolTable(symbolTableSize, maxRows, totalRows, columnCount =
     `\u26A0\uFE0F  Large symbol table detected (${sizeMB}MB > ${warnMB}MB threshold). This read materialises ${formatCount(rowsToLoad)} of ${formatCount(totalRows)} rows and will use ~${estimatedMB}MB RAM. Reading fewer rows - with limit, maxRows, or a narrower offset window - lowers the row cost, though the symbol table is read in full either way.`
   );
 }
-var HEAP_LIMIT_OVERSTATEMENT_BYTES, MINIMUM_BUDGET_BYTES, BASE_BYTES, ROW_BASE_BYTES, PER_CELL_BYTES;
+var HEAP_LIMIT_OVERSTATEMENT_BYTES, MINIMUM_BUDGET_BYTES, BASE_BYTES, ROW_BASE_BYTES, PER_CELL_BYTES, noBytesHeld;
 var init_memoryUtils = __esm({
   "src/util/memoryUtils.js"() {
     init_QvdErrors();
@@ -2345,7 +2490,11 @@ var init_memoryUtils = __esm({
     __name(estimateMemoryUsage, "estimateMemoryUsage");
     __name(recommendedRowsFor, "recommendedRowsFor");
     __name(recommendedChunkFor, "recommendedChunkFor");
+    noBytesHeld = Object.freeze({ held: 0, forRows: /* @__PURE__ */ __name(() => 0, "forRows"), forChunk: /* @__PURE__ */ __name(() => 0, "forChunk") });
     __name(validateMemoryAvailability, "validateMemoryAvailability");
+    __name(checkMemory, "checkMemory");
+    __name(answerOf, "answerOf");
+    __name(budgetOf, "budgetOf");
     __name(formatCount, "formatCount");
     __name(warnLargeSymbolTable, "warnLargeSymbolTable");
   }
@@ -2464,6 +2613,7 @@ function validateSymbolTableSize(symbolTableLength, filePath, totalRows) {
 function validateFieldMetadata(field, symbolBufferLength, filePath) {
   const symbolsOffset = headerInteger(field["Offset"]);
   const symbolsLength = headerInteger(field["Length"]);
+  const symbolCount = headerInteger(field["NoOfSymbols"]);
   if (isNaN(symbolsOffset) || !Number.isSafeInteger(symbolsOffset) || symbolsOffset < 0) {
     throw new QvdCorruptedError("Invalid symbol offset", {
       field: field["FieldName"],
@@ -2480,6 +2630,14 @@ function validateFieldMetadata(field, symbolBufferLength, filePath) {
       stage: "parseSymbolTable"
     });
   }
+  if (isNaN(symbolCount) || !Number.isSafeInteger(symbolCount) || symbolCount < 0) {
+    throw new QvdCorruptedError("Invalid symbol count", {
+      field: field["FieldName"],
+      noOfSymbols: symbolCount,
+      file: filePath,
+      stage: "parseSymbolTable"
+    });
+  }
   if (symbolsOffset + symbolsLength > symbolBufferLength) {
     throw new QvdCorruptedError("Symbol data extends beyond buffer", {
       field: field["FieldName"],
@@ -2735,12 +2893,25 @@ var init_validationUtils = __esm({
     __name(validateFieldBitMetadata, "validateFieldBitMetadata");
   }
 });
-
-// src/util/symbolParser.js
-function textEnd(symbolBuffer, from, kind, fieldName, filePath) {
-  const bufferLength = symbolBuffer.length;
-  const found = symbolBuffer.indexOf(0, from);
-  if ((found === -1 ? bufferLength : found) - from > MAX_TEXT_BYTES) {
+function nulFinder(area, { reach, rebaseAfter }) {
+  assert4(reach - rebaseAfter > MAX_TEXT_BYTES, "A text search view must hold the longest text a symbol may have.");
+  if (area.length <= reach) {
+    return (from) => area.indexOf(0, from);
+  }
+  let base = 0;
+  let view = area.subarray(0, reach);
+  return (from) => {
+    if (from - base > rebaseAfter) {
+      base = from;
+      view = area.subarray(base, Math.min(area.length, base + reach));
+    }
+    const found = view.indexOf(0, from - base);
+    return found === -1 ? -1 : base + found;
+  };
+}
+function textEnd(findNul, areaEnd, from, kind, fieldName, filePath, base) {
+  const found = findNul(from);
+  if ((found === -1 ? areaEnd : found) - from > MAX_TEXT_BYTES) {
     throw new QvdCorruptedError(`${kind} exceeds maximum length`, {
       field: fieldName,
       maxLength: MAX_TEXT_BYTES,
@@ -2751,58 +2922,59 @@ function textEnd(symbolBuffer, from, kind, fieldName, filePath) {
   if (found === -1) {
     throw new QvdCorruptedError(`${kind} not null-terminated`, {
       field: fieldName,
-      pointer: bufferLength,
-      bufferSize: bufferLength,
+      pointer: base + from,
+      areaEnd: base + areaEnd,
       file: filePath,
       stage: "parseSymbolTable"
     });
   }
   return found;
 }
-function overflow(message, pointer, bufferLength, fieldName, filePath) {
+function overflow(message, pointer, areaEnd, fieldName, filePath, base) {
   throw new QvdCorruptedError(message, {
     field: fieldName,
-    pointer,
-    bufferSize: bufferLength,
+    pointer: base + pointer,
+    areaEnd: base + areaEnd,
     file: filePath,
     stage: "parseSymbolTable"
   });
 }
-function parseFieldSymbols(symbolBuffer, start, end, keep, fieldName, filePath) {
-  const bufferLength = symbolBuffer.length;
+function parseFieldSymbols(symbolBuffer, start, end, symbolCount, keep, fieldName, filePath, search = TEXT_SEARCH, base = 0) {
+  const area = symbolBuffer.subarray(0, end);
+  const findNul = nulFinder(area, search);
   const numbers = [];
   const texts = [];
   let pointer = start;
   while (pointer < end) {
-    const typeByte = symbolBuffer[pointer++];
+    const typeByte = area[pointer++];
     const decode = keep === null || keep.has(numbers.length);
     let number = null;
     let text = null;
     switch (typeByte) {
       case 1: {
+        if (pointer + 4 > end) {
+          overflow("Buffer overflow reading integer symbol", pointer, end, fieldName, filePath, base);
+        }
         if (decode) {
-          if (pointer + 4 > bufferLength) {
-            overflow("Buffer overflow reading integer symbol", pointer, bufferLength, fieldName, filePath);
-          }
-          number = symbolBuffer.readInt32LE(pointer);
+          number = area.readInt32LE(pointer);
         }
         pointer += 4;
         break;
       }
       case 2: {
+        if (pointer + 8 > end) {
+          overflow("Buffer overflow reading double symbol", pointer, end, fieldName, filePath, base);
+        }
         if (decode) {
-          if (pointer + 8 > bufferLength) {
-            overflow("Buffer overflow reading double symbol", pointer, bufferLength, fieldName, filePath);
-          }
-          number = symbolBuffer.readDoubleLE(pointer);
+          number = area.readDoubleLE(pointer);
         }
         pointer += 8;
         break;
       }
       case 4: {
-        const terminator = textEnd(symbolBuffer, pointer, "String symbol", fieldName, filePath);
+        const terminator = textEnd(findNul, end, pointer, "String symbol", fieldName, filePath, base);
         if (decode) {
-          text = symbolBuffer.toString("utf8", pointer, terminator);
+          text = area.toString("utf8", pointer, terminator);
         }
         pointer = terminator + 1;
         break;
@@ -2810,14 +2982,22 @@ function parseFieldSymbols(symbolBuffer, start, end, keep, fieldName, filePath)
       case 5:
       case 6: {
         const numberBytes = typeByte === 5 ? 4 : 8;
-        if (pointer + numberBytes > bufferLength) {
-          const read = !decode ? "dual symbol" : typeByte === 5 ? "dual integer symbol" : "dual double symbol";
-          overflow(`Buffer overflow reading ${read}`, pointer, bufferLength, fieldName, filePath);
+        if (pointer + numberBytes > end) {
+          const read = typeByte === 5 ? "dual integer symbol" : "dual double symbol";
+          overflow(`Buffer overflow reading ${read}`, pointer, end, fieldName, filePath, base);
         }
-        const terminator = textEnd(symbolBuffer, pointer + numberBytes, "Dual string symbol", fieldName, filePath);
+        const terminator = textEnd(
+          findNul,
+          end,
+          pointer + numberBytes,
+          "Dual string symbol",
+          fieldName,
+          filePath,
+          base
+        );
         if (decode) {
-          number = typeByte === 5 ? symbolBuffer.readInt32LE(pointer) : symbolBuffer.readDoubleLE(pointer);
-          text = symbolBuffer.toString("utf8", pointer + numberBytes, terminator);
+          number = typeByte === 5 ? area.readInt32LE(pointer) : area.readDoubleLE(pointer);
+          text = area.toString("utf8", pointer + numberBytes, terminator);
         }
         pointer = terminator + 1;
         break;
@@ -2825,7 +3005,7 @@ function parseFieldSymbols(symbolBuffer, start, end, keep, fieldName, filePath)
       default: {
         throw new QvdParseError("Unknown symbol type byte", {
           typeByte: typeByte.toString(16),
-          offset: pointer - 1,
+          offset: base + pointer - 1,
           file: filePath,
           stage: "parseSymbolTable"
         });
@@ -2834,16 +3014,28 @@ function parseFieldSymbols(symbolBuffer, start, end, keep, fieldName, filePath)
     numbers.push(number);
     texts.push(text);
   }
+  assert4(pointer === end, `The symbols of ${fieldName} were walked to byte ${pointer} of an area ending at ${end}.`);
+  if (numbers.length !== symbolCount) {
+    throw new QvdCorruptedError("Symbol count mismatch", {
+      field: fieldName,
+      symbolCount: numbers.length,
+      noOfSymbols: symbolCount,
+      file: filePath,
+      stage: "parseSymbolTable"
+    });
+  }
   return { numbers, texts };
 }
-function countFieldSymbols(symbolBuffer, start, end, fieldName, filePath) {
-  return parseFieldSymbols(symbolBuffer, start, end, DECODE_NOTHING, fieldName, filePath).numbers.length;
+function countFieldSymbols(symbolBuffer, start, end, symbolCount, fieldName, filePath, base = 0) {
+  return parseFieldSymbols(symbolBuffer, start, end, symbolCount, DECODE_NOTHING, fieldName, filePath, void 0, base).numbers.length;
 }
-var MAX_TEXT_BYTES, DECODE_NOTHING;
+var MAX_TEXT_BYTES, TEXT_SEARCH, DECODE_NOTHING;
 var init_symbolParser = __esm({
   "src/util/symbolParser.js"() {
     init_QvdErrors();
     MAX_TEXT_BYTES = 1048576;
+    TEXT_SEARCH = Object.freeze({ reach: 2 ** 31 - 1, rebaseAfter: 2 ** 30 });
+    __name(nulFinder, "nulFinder");
     __name(textEnd, "textEnd");
     __name(overflow, "overflow");
     __name(parseFieldSymbols, "parseFieldSymbols");
@@ -3387,7 +3579,17 @@ async function parseHeaderXml(text, file, stage) {
   }
   return parsed;
 }
-var MAX_HEADER_SIZE, READ_CHUNK_SIZE, ANALYSIS_SLICE_ROWS, COUNT_SYMBOLS_PAST, QvdFileReader;
+function symbolBytesOf(selected, symbolTableLength) {
+  const areaBytes = selected.map((field) => headerInteger(field["Length"]));
+  return areaBytes.every((bytes) => Number.isSafeInteger(bytes) && bytes >= 0) ? Math.min(
+    symbolTableLength,
+    areaBytes.reduce((sum, bytes) => sum + bytes, 0)
+  ) : symbolTableLength;
+}
+function readPasses(analysisAhead) {
+  return analysisAhead ? 2 : 1;
+}
+var MAX_HEADER_SIZE, READ_CHUNK_SIZE, ANALYSIS_SLICE_ROWS, SLICE_BYTES, COUNT_SYMBOLS_PAST, QvdFileReader;
 var init_QvdFileReader = __esm({
   "src/QvdFileReader.js"() {
     init_QvdDataFrame();
@@ -3405,9 +3607,12 @@ var init_QvdFileReader = __esm({
     MAX_HEADER_SIZE = 16 * 1024 * 1024;
     READ_CHUNK_SIZE = 512 * 1024 * 1024;
     ANALYSIS_SLICE_ROWS = 65536;
+    SLICE_BYTES = 16 * 1024 * 1024;
     COUNT_SYMBOLS_PAST = 65536;
     __name(chunksFrom, "chunksFrom");
     __name(parseHeaderXml, "parseHeaderXml");
+    __name(symbolBytesOf, "symbolBytesOf");
+    __name(readPasses, "readPasses");
     QvdFileReader = class {
       static {
         __name(this, "QvdFileReader");
@@ -3436,6 +3641,10 @@ var init_QvdFileReader = __esm({
        *   above which a lazy load switches to the two-pass filtering path. The default of 50MB is
        *   the point where the extra analysis pass pays for itself; lower it to use filtering on
        *   smaller files, raise it to keep the simpler single-pass read for longer.
+       * @param {number} [options.sliceBytes=16777216] The most bytes of records a read holds at a time. An
+       *   option rather than a constant for the reason `symbolFilteringThreshold` is one: so that a test can
+       *   cross the boundaries between slices in a small file. There is no other reason to change it, and it
+       *   is not one of the options a read through `QvdDataFrame` or `QvdColumnTable` passes on.
        * @param {Array<string>|null} [options.fields] Field names to read, in the order they should
        *   appear. Null reads every field, in file order. An unknown or repeated name is refused.
        * @param {'number'|'text'|'both'} [options.duals='number'] What a dual symbol - a number with the
@@ -3460,6 +3669,7 @@ var init_QvdFileReader = __esm({
           allowedDir,
           memorySafetyFactor = 0.8,
           symbolFilteringThreshold = 50 * 1024 * 1024,
+          sliceBytes = SLICE_BYTES,
           materialisesRows = true,
           fields = null,
           duals,
@@ -3475,6 +3685,14 @@ var init_QvdFileReader = __esm({
         this._coerceNumericStrings = normaliseCoerceNumericStrings(coerceNumericStrings, this._path);
         this._memorySafetyFactor = memorySafetyFactor;
         this._symbolFilteringThreshold = symbolFilteringThreshold;
+        if (!Number.isSafeInteger(sliceBytes) || sliceBytes <= 0) {
+          throw new QvdValidationError("sliceBytes must be a positive integer", {
+            provided: sliceBytes,
+            type: typeof sliceBytes,
+            file: this._path
+          });
+        }
+        this._sliceBytes = sliceBytes;
         if (onProgress !== void 0 && typeof onProgress !== "function") {
           throw new QvdValidationError("onProgress must be a function", {
             provided: onProgress,
@@ -3492,7 +3710,11 @@ var init_QvdFileReader = __esm({
         this._requestedFields = fields === void 0 ? null : fields;
         this._onProgress = onProgress;
         this._signal = signal;
-        this._buffer = null;
+        this._headerBuffer = null;
+        this._handle = null;
+        this._failed = null;
+        this._reading = false;
+        this._symbolAreas = null;
         this._headerOffset = null;
         this._symbolTableOffset = null;
         this._indexTableOffset = null;
@@ -3503,7 +3725,6 @@ var init_QvdFileReader = __esm({
         this._symbolTable = null;
         this._indexColumns = null;
         this._rowsDecoded = 0;
-        this._bufferFirstRow = 0;
         this._fileSize = null;
         this._headerMatchesFile = false;
       }
@@ -3542,54 +3763,137 @@ var init_QvdFileReader = __esm({
         }
       }
       /**
-       * Reads the binary data of the QVD file.
-       *
-       * A windowed read - anything with `offset`, `limit` or `maxRows` - reads only the bytes it
-       * needs, rather than the file. Measured on `chicago_taxi_rides_2016_01.qvd`, 1,705,805 rows
-       * over 20 fields: the last thousand rows take 19 ms against 636 ms for the whole file.
-       *
-       * The saving is in the index table and the rows, not in the symbol table, which is read in
-       * full whatever the window because a stored index in any row can address any symbol. So the
-       * gain scales with how much of the file is rows: on a file whose bytes are mostly distinct
-       * values there is very little to save, which is what `symbolFilteringThreshold` and the
-       * two-pass path exist for.
-       *
-       * Algorithm for a windowed read:
-       * 1. Read the file a chunk at a time until the XML header delimiter is found
-       * 2. Parse header to determine symbol table and index table locations
-       * 3. Calculate bytes needed: header + full symbol table + partial index table
-       * 4. Read only those calculated bytes, by position
-       * 5. Rest of parsing proceeds normally with limited data
-       *
-       * WHY THIS APPROACH:
-       * - Symbol table must be fully loaded (contains all unique values)
-       * - Index table can be partially loaded (only rows we need)
-       * - Reading chunks to find the header is efficient for unknown header sizes
-       * - Direct byte-range reading for remaining data is fastest
+       * Opens the file and reads its header, and for a read of rows checks that the read can be made.
+       *
+       * Nothing past the header is read here. The selected fields' symbols and the records are read by position
+       * as they are parsed - see `_symbolAreaOf` and `_forEachSlice` - so no read holds the file in one buffer
+       * (#122). A read of rows therefore leaves the file open, and whatever started the read closes it with
+       * `_closeFile` once the last record it needs is decoded; a header-only read closes it here.
+       *
+       * A windowed read - anything with `offset`, `limit` or `maxRows` - reads the header, the symbols of the
+       * fields it selects, and the window's records, and no byte between. Measured on
+       * `chicago_taxi_rides_2016_01.qvd`, 1,705,805 rows over 20 fields: the last thousand rows take 19 ms
+       * against 636 ms for the whole file. A selected field's area is read in full whatever the window,
+       * because a stored index in any row can address any of that field's symbols; the areas of the fields
+       * `fields` leaves out are not read at all. So a window's gain scales with how much of the file is
+       * rows: on a file whose bytes are mostly distinct values of the fields it reads there is very little
+       * to save, which is what `symbolFilteringThreshold` and the two-pass path exist for.
        *
        * All of it goes through one handle, opened once, on the file the containment check approved. See
        * `chunksFrom` and `openChecked` for why a read no longer opens the path more than once.
        *
-       * A window with a non-zero `offset` reads two ranges rather than one: the header and symbol
-       * table from the front of the file, and the window's records from wherever they sit. The bytes
-       * between are never read, which is what makes `{offset: 1_700_000, limit: 100}` on the taxi
-       * fixture a 0.4MB read rather than a 38MB one.
-       *
        * @param {QvdRowWindow} window The rows to read.
-       * @param {boolean} [headerOnly=false] Stop once the XML header has been read, leaving the
-       *   symbol and index tables on disk. This is the metadata-only path: the header is a few
-       *   kilobytes whatever the file's size, so reading a schema costs the same for a 40MB file as
-       *   for a 40GB one.
+       * @param {boolean} [headerOnly=false] Stop once the XML header has been read, and close the file. This
+       *   is the metadata-only path: the header is a few kilobytes whatever the file's size, so reading a
+       *   schema costs the same for a 40MB file as for a 40GB one.
        * @param {{rows: number, perChunk: number}|null} [liveRows=null] Rows held at one instant when
        *   that is fewer than the window covers - see `_prepare`.
        * @private
        */
       async _readData(window = { offset: 0, limit: null }, headerOnly = false, liveRows = null) {
+        assert4(this._reading, "A read opens the QVD file only once it has started, through _startRead.");
+        this._symbolTable = null;
+        this._indexColumns = null;
+        this._rowsDecoded = 0;
         this._throwIfAborted();
         this._emitProgress("read", 0, 1);
         const failed = rethrowAsIoError(this._path, "read");
         const handle = await openChecked(checkPath(this._path, this._allowedDir), "read", failed);
-        await closeAfter(handle, failed, () => this._readFrom(handle, window, headerOnly, liveRows, failed));
+        if (headerOnly) {
+          await closeAfter(handle, failed, () => this._readFrom(handle, window, true, liveRows, failed));
+          return;
+        }
+        this._handle = handle;
+        this._failed = failed;
+        try {
+          await this._readFrom(handle, window, false, liveRows, failed);
+        } catch (error) {
+          await this._closeFile(true);
+          throw error;
+        }
+      }
+      /**
+       * Starts a read on this reader, refusing it while another is under way.
+       *
+       * A read of rows holds the file, and what it has read of it, on the reader until it ends. A second read
+       * started meanwhile - `load()` while an iteration is suspended, say - would take over that state and
+       * leave the first read's file open. Reads one after another are fine. Called before a read takes charge
+       * of closing the file, so that refusing the second read cannot close the first one's.
+       *
+       * The first thing every read does, and synchronous: the flag is set before the read's first `await`, so
+       * two reads started together - `Promise.all([reader.load(), reader.load()])` - cannot both pass. The check
+       * used to be of the handle, which is set only once the file has opened, and both did: the second read's
+       * handle replaced the first's, which was never closed, and the first read to finish closed the file the
+       * other was still reading.
+       *
+       * @throws {QvdValidationError} If a read is under way.
+       * @private
+       */
+      _startRead() {
+        if (this._reading) {
+          throw new QvdValidationError("The reader is already reading this file: finish that read first", {
+            file: this._path
+          });
+        }
+        this._reading = true;
+      }
+      /**
+       * Ends the read `_startRead` began: closes its file, if it still holds one, and lets the next read start.
+       *
+       * @param {boolean} failing Whether the read is already throwing - see `_closeFile`.
+       * @private
+       */
+      async _endRead(failing) {
+        try {
+          await this._closeFile(failing);
+        } finally {
+          this._reading = false;
+        }
+      }
+      /**
+       * Closes the file a read of rows opened, and drops what it had read of it.
+       *
+       * The rule `closeAfter` follows: a close that fails is reported only when the read succeeded, so it can
+       * never replace the error that says what went wrong. After a successful read it is the only news.
+       *
+       * @param {boolean} failing Whether the read is already throwing.
+       * @private
+       */
+      async _closeFile(failing) {
+        const handle = this._handle;
+        const failed = this._failed;
+        this._handle = null;
+        this._failed = null;
+        this._symbolAreas = null;
+        if (handle === null || failed === null) {
+          return;
+        }
+        if (failing) {
+          await handle.close().catch(() => {
+          });
+          return;
+        }
+        await handle.close().catch(failed);
+      }
+      /**
+       * Runs a read, the only one under way on this reader, and closes its file when it ends, however it ends.
+       *
+       * @template T
+       * @param {() => Promise<T>} read The read, from opening the file to its last record.
+       * @return {Promise<T>} What it returned.
+       * @private
+       */
+      async _closingAfter(read) {
+        this._startRead();
+        let result;
+        try {
+          result = await read();
+        } catch (error) {
+          await this._endRead(true);
+          throw error;
+        }
+        await this._endRead(false);
+        return result;
       }
       /**
        * Reads what `_readData` was asked for, through the handle it opened.
@@ -3650,51 +3954,61 @@ var init_QvdFileReader = __esm({
         const indexTableOffset = symbolTableOffset + symbolTableLength;
         const recordSize = headerInteger(headerObj["QvdTableHeader"]["RecordByteSize"]);
         const totalRows = headerInteger(headerObj["QvdTableHeader"]["NoOfRecords"]);
-        if (headerOnly) {
-          this._buffer = headerBuffer.subarray(0, headerEndIndex);
-          this._emitProgress("read", 1, 1);
-          return;
-        }
-        const columnCount = selectFields(headerFields, this._requestedFields, this._path).length;
+        const { size: fileSize } = await handle.stat().catch(failed);
+        this._fileSize = fileSize;
+        this._headerMatchesFile = false;
         const headerNumbersUsable = [symbolTableLength, recordSize, totalRows].every(
           (value) => Number.isSafeInteger(value) && value >= 0
         );
         if (headerNumbersUsable) {
-          const { size: fileSize2 } = await handle.stat().catch(failed);
-          this._fileSize = fileSize2;
-          this._headerMatchesFile = headerEndIndex + symbolTableLength + totalRows * recordSize <= fileSize2;
+          this._headerMatchesFile = headerEndIndex + symbolTableLength + totalRows * recordSize <= fileSize;
+        }
+        if (headerOnly) {
+          this._headerBuffer = headerBuffer.subarray(0, headerEndIndex);
+          this._emitProgress("read", 1, 1);
+          return;
         }
+        this._headerBuffer = headerBuffer.subarray(0, headerEndIndex);
+        const selected = selectFields(headerFields, this._requestedFields, this._path);
+        const columnCount = selected.length;
+        const symbolBytes = symbolBytesOf(selected, symbolTableLength);
         const resolved = headerNumbersUsable ? resolveWindow(window, totalRows) : { offset: 0, limit: 0 };
         const windowRows = resolved.limit;
         if (headerNumbersUsable && this._headerMatchesFile) {
           validateMemoryAvailability(
-            symbolTableLength,
+            symbolBytes,
             windowRows,
             totalRows,
             this._path,
             this._memorySafetyFactor,
             columnCount,
             this._materialisesRows,
-            liveRows
+            liveRows,
+            this._bytesHeld(
+              symbolBytes,
+              windowRows,
+              recordSize,
+              liveRows,
+              this._analysisWouldRun(window, resolved, totalRows, symbolTableLength)
+            ),
+            // What it reads, which is not what it holds - the records go through one buffer and are not
+            // kept. Carried so that a refusal's `check` says everything the pre-flight would have said.
+            //
+            // Twice over where the symbol-usage pass is still ahead of it: that pass reads the window's
+            // records to find which symbols the rows use, and the decode then reads them again. Counted
+            // once, the figure understated the I/O of exactly the reads that do the most of it.
+            symbolBytes + readPasses(this._analysisWouldRun(window, resolved, totalRows, symbolTableLength)) * windowRows * recordSize
           );
         }
         if (window.offset === 0 && window.limit === null) {
-          this._buffer = await handle.readFile().catch(failed);
-          this._fileSize = this._buffer.length;
-          this._bufferFirstRow = 0;
           this._emitProgress("read", 1, 1);
           return;
         }
         const rowsToLoad = windowRows;
-        validateSymbolTableSizeEarly(symbolTableLength, this._path);
+        validateSymbolTableSizeEarly(symbolBytes, this._path);
         validateRecordSize(recordSize, this._path, "readData");
         validateRecordCount(totalRows, this._path, "readData");
-        const skippedIndexBytes = resolved.offset * recordSize;
-        const indexTableBytesToRead = rowsToLoad * recordSize;
-        const totalBytesToRead = indexTableOffset + indexTableBytesToRead;
-        const fileBytesRequired = indexTableOffset + skippedIndexBytes + indexTableBytesToRead;
-        const { size: fileSize } = await handle.stat().catch(failed);
-        this._fileSize = fileSize;
+        const fileBytesRequired = indexTableOffset + (resolved.offset + rowsToLoad) * recordSize;
         if (fileBytesRequired > fileSize) {
           throw new QvdCorruptedError("The file is shorter than its header claims.", {
             file: this._path,
@@ -3703,47 +4017,35 @@ var init_QvdFileReader = __esm({
             stage: "readData"
           });
         }
-        this._buffer = Buffer.alloc(totalBytesToRead);
-        await this._readRange(handle, 0, indexTableOffset, 0, fileSize, totalBytesToRead);
-        if (indexTableBytesToRead > 0) {
-          await this._readRange(
-            handle,
-            indexTableOffset,
-            indexTableBytesToRead,
-            indexTableOffset + skippedIndexBytes,
-            fileSize,
-            fileBytesRequired
-          );
-        }
-        this._bufferFirstRow = resolved.offset;
         this._emitProgress("read", 1, 1);
       }
       /**
-       * Reads one byte range of the file into the buffer.
+       * Reads one byte range of the open file into a buffer.
        *
        * Read in bounded chunks, checking bytesRead each time. A single fs.read call with a length of
        * 2^31 or more does not throw - it trips a C++ assertion and aborts the whole process, which no
        * try/catch can intercept.
        *
-       * @param {import('fs/promises').FileHandle} fd The open file.
-       * @param {number} bufferOffset Where in the buffer to write.
+       * @param {Buffer} target The buffer to read into.
+       * @param {number} targetOffset Where in it to write.
        * @param {number} byteCount How many bytes to read.
        * @param {number} filePosition Where in the file to read from.
-       * @param {number} fileSize The file's size, for the error.
-       * @param {number} requiredBytes Bytes the whole read needs, for the error.
+       * @param {number} requiredBytes How far into the file the read has to reach, for the error.
+       * @throws {QvdCorruptedError} If the file ends before the range does.
        * @private
        */
-      async _readRange(fd, bufferOffset, byteCount, filePosition, fileSize, requiredBytes) {
-        assert3(this._buffer, "The read buffer has not been allocated.");
-        const failed = rethrowAsIoError(this._path, "read");
+      async _readAt(target, targetOffset, byteCount, filePosition, requiredBytes) {
+        assert4(this._handle && this._failed, "The QVD file is not open.");
+        const handle = this._handle;
+        const failed = this._failed;
         let done = 0;
         while (done < byteCount) {
           const length = Math.min(READ_CHUNK_SIZE, byteCount - done);
-          const { bytesRead } = await fd.read(this._buffer, bufferOffset + done, length, filePosition + done).catch(failed);
+          const { bytesRead } = await handle.read(target, targetOffset + done, length, filePosition + done).catch(failed);
           if (bytesRead === 0) {
             throw new QvdCorruptedError("Unexpected end of file while reading QVD data.", {
               file: this._path,
-              fileSize,
+              fileSize: this._fileSize,
               // Two numbers, because they stopped being the same one when a window began reading two
               // ranges: `bytesRead` is how much of this range arrived, `filePosition` is where in the
               // file it gave up. Reporting the position under the name of the count made a windowed
@@ -3758,12 +4060,279 @@ var init_QvdFileReader = __esm({
           done += bytesRead;
         }
       }
+      /**
+       * Bytes of the file a read holds outside the heap while it works, beside the codes the guard counts for
+       * itself: the symbol areas it reads, and the one buffer its records come through.
+       *
+       * The areas are counted whole, although the read lets each range go once its fields are parsed, because
+       * two ranges are both live when a field of one is parsed between two fields of the other - the order the
+       * caller asked for the fields decides it, so the sum is what holds in every order. The slice is the
+       * buffer `_forEachSlice` will allocate, sized by `_sliceRowsFor` so that the charge and the allocation
+       * are one expression rather than two that agree today.
+       *
+       * @param {number} symbolBytes Bytes of symbols the read will read.
+       * @param {number} rows Records it will read.
+       * @param {number} recordSize Bytes per record.
+       * @return {number} Bytes.
+       * @private
+       */
+      _bytesHeldBy(symbolBytes, rows, recordSize) {
+        const usable = Number.isSafeInteger(rows) && Number.isSafeInteger(recordSize) && rows > 0 && recordSize > 0;
+        return symbolBytes + (usable ? this._sliceRowsFor(rows, recordSize) * recordSize : 0);
+      }
+      /**
+       * Records the one buffer holds while a read of `rowCount` records goes through it.
+       *
+       * A slice is `sliceBytes` of records, rounded down to a whole record, or every record the read has left
+       * when that is fewer - and at least one, since a read of a record wider than `sliceBytes` still has to
+       * hold that record. The single definition: `_forEachSlice` allocates from it and the memory guard is
+       * charged from it, so a change to how a read slices cannot leave the guard pricing the old rule.
+       *
+       * @param {number} rowCount Records the read will read.
+       * @param {number} recordSize Bytes per record.
+       * @return {number} Records in one slice.
+       * @private
+       */
+      _sliceRowsFor(rowCount, recordSize) {
+        return Math.max(1, Math.min(rowCount, Math.floor(this._sliceBytes / Math.max(1, recordSize))));
+      }
+      /**
+       * What a read holds in bytes of the file, for the memory guard: what it holds now, and what a read
+       * following either piece of advice a refusal can carry would hold instead.
+       *
+       * The two knobs are not the same knob, which is why there are two functions rather than one. A smaller
+       * `limit` is a smaller window, so every record the read touches is one of fewer - the symbol-usage pass
+       * included, since it reads the window. A smaller `chunkSize` leaves the window exactly where it is and
+       * only changes how much of it is decoded at a time, so a read with that pass still ahead of it holds the
+       * window's slice however small the chunk. Priced with `forRows`, such a chunk was charged for the records
+       * of one chunk and then held sixteen megabytes more than that.
+       *
+       * @param {number} symbolBytes Bytes of symbols the read will read.
+       * @param {number} windowRows Rows the read covers.
+       * @param {number} recordSize Bytes per record.
+       * @param {{rows: number, perChunk: number}|null} liveRows Rows held at one instant - see `_prepare`.
+       * @param {boolean} analysisAhead Whether the symbol-usage pass has still to run.
+       * @return {{held: number, forRows: (rows: number) => number, forChunk: (rows: number) => number}} What
+       *   this read holds, what a read of so many rows would hold, and what one reading so many rows a chunk
+       *   would hold.
+       * @private
+       */
+      _bytesHeld(symbolBytes, windowRows, recordSize, liveRows, analysisAhead) {
+        return {
+          held: this._bytesHeldBy(symbolBytes, this._recordsAtOnce(windowRows, liveRows, analysisAhead), recordSize),
+          // A window of so many rows reads so many records at a time, and the pass that reads it ahead of the
+          // decode reads the same rows, so the buffer is sized from the rows either way.
+          forRows: /* @__PURE__ */ __name((rows) => this._bytesHeldBy(symbolBytes, rows, recordSize), "forRows"),
+          // A chunk of so many rows, over this read's window - which is what `chunkSize` changes and what it
+          // leaves alone. `_recordsAtOnce` is what answers that, given a chunk size as the rows held at once.
+          forChunk: /* @__PURE__ */ __name((rows) => this._bytesHeldBy(symbolBytes, this._recordsAtOnce(windowRows, { rows, perChunk: 1 }, analysisAhead), recordSize), "forChunk")
+        };
+      }
+      /**
+       * Whether a read takes the symbol-usage pass, which reads the window's records before the symbol table
+       * is parsed and so before the first chunk is built.
+       *
+       * The one statement of the condition. `_prepare` asks it to decide, and `_readData` asks it before the
+       * header has been parsed, to know what to charge the memory guard: a read with the pass ahead of it
+       * holds a whole slice of records, and a read without it holds only what it reads at a time. Said in two
+       * places, the two would drift and a read would be charged for one path and take the other - which fails
+       * open for a chunked read, and that is the direction the guard exists to prevent.
+       *
+       * Any window that does not cover the whole file is a candidate, which includes one bounded by its offset
+       * rather than by its limit. Covering every row rules it out, however the window was spelled -
+       * `{offset: 0, limit: n}` over all n rows, or an `iterate` of them. Such a read needs every symbol any
+       * row uses, which is what `estimateMemoryUsage` assumes for a full read as well, so the pass has nothing
+       * to filter. It is not free: since the records are read as they are decoded rather than held in one
+       * buffer, the pass reads the window's records and the decode then reads them again. A window that really
+       * is a window pays that for the symbols it saves parsing; a window that is a full read in disguise paid
+       * it for nothing.
+       *
+       * The threshold is an option rather than a constant so this path can be exercised with a small fixture:
+       * it is the most intricate code in the reader, and the only files large enough to reach the 50MB default
+       * are ones no repository should be carrying around. It measures the whole table rather than the areas a
+       * read selects, because what the pass saves is parsing work across the table.
+       *
+       * @param {QvdRowWindow} window The window as the caller spelled it.
+       * @param {{offset: number, limit: number}} resolved Where it lands in this file.
+       * @param {number} totalRows Rows the file declares.
+       * @param {number} symbolTableLength The symbol table's declared length.
+       * @return {boolean} Whether the pass will run.
+       * @private
+       */
+      _analysisWouldRun(window, resolved, totalRows, symbolTableLength) {
+        return resolved.limit < totalRows && (window.limit !== null || window.offset > 0) && symbolTableLength > this._symbolFilteringThreshold;
+      }
+      /**
+       * Records a read holds at one time, which is what its record buffer is sized from.
+       *
+       * A slice holds `sliceBytes` of records, or every record the read has left to read when that is fewer -
+       * so what it costs depends on how many a read asks for at a time, not on how many it covers. An
+       * iteration asks for a chunk: `iterate({limit: 20_000_000, chunkSize: 1000})` reads a thousand records at
+       * a time however many its window covers, and charging it a full slice would refuse it for 16 MiB it never
+       * allocates. The symbol-usage pass is the exception, because it reads the whole window in slices of its
+       * own before the first chunk is built, so a read that still has that pass ahead of it is charged for it.
+       *
+       * @param {number} windowRows Rows the read covers.
+       * @param {{rows: number, perChunk: number}|null} liveRows Rows held at one instant - see `_prepare`.
+       * @param {boolean} analysisAhead Whether the symbol-usage pass has still to run.
+       * @return {number} Records read at one time.
+       * @private
+       */
+      _recordsAtOnce(windowRows, liveRows, analysisAhead) {
+        const chunkRows = liveRows === null ? windowRows : Math.max(1, Math.floor(liveRows.rows / Math.max(1, liveRows.perChunk)));
+        return analysisAhead ? Math.max(windowRows, chunkRows) : chunkRows;
+      }
+      /**
+       * The symbol table's length, as much of it as the file holds: what the header declares, cut short where
+       * the file ends. Known before a byte of the table is read, so everything that can refuse the table is
+       * checked on this, before the table is allocated.
+       *
+       * A file that ends inside its symbol table is measured to where it ends, and the fields whose areas it cut
+       * short are refused as `Symbol data extends beyond buffer` when their metadata is checked - what a
+       * whole-file read has always said of such a file. A window has refused it already, before reading anything.
+       *
+       * @return {number} Bytes.
+       * @private
+       */
+      _symbolTableLength() {
+        assert4(
+          this._symbolTableOffset !== null && this._indexTableOffset !== null && this._fileSize !== null,
+          "The QVD file header has not been parsed before its symbol table was measured."
+        );
+        const declared = this._indexTableOffset - this._symbolTableOffset;
+        return Math.max(0, Math.min(declared, this._fileSize - this._symbolTableOffset));
+      }
+      /**
+       * Where each selected field's symbols are, as ranges of the symbol table this read will read.
+       *
+       * A field's `Offset` and `Length` say exactly where its symbols are, so a read of some of a file's fields
+       * has no reason to read the areas of the rest (#122). Qlik writes the areas one after another in field
+       * order, so ranges that touch are merged: a read of every field is one range, and so is a read of fields
+       * that happen to be neighbours. A read of one field of twenty reads that field's area alone.
+       *
+       * Built once per read, from the fields the read selected, and each field's metadata is checked as it is
+       * added - a range is arithmetic on `Offset` and `Length`, and those have to be inside the table first.
+       * `_parseSymbolTable` checks every field of the file, selected or not, before it parses any.
+       *
+       * @return {{ranges: Array<{start: number, end: number, fields: number, buffer: Buffer|null}>,
+       *   byField: Map<any, {range: {start: number, end: number, fields: number, buffer: Buffer|null},
+       *   start: number, end: number}>}} The ranges, and where in its range each field's area sits.
+       * @private
+       */
+      _symbolAreaPlan() {
+        if (this._symbolAreas !== null) {
+          return this._symbolAreas;
+        }
+        assert4(this._selectedFields, "The QVD file fields have not been resolved before their symbols were read.");
+        const tableLength = this._symbolTableLength();
+        const areas = this._selectedFields.map((field) => {
+          validateFieldMetadata(field, tableLength, this._path);
+          const start = headerInteger(field["Offset"]);
+          return { field, start, end: start + headerInteger(field["Length"]) };
+        });
+        const ranges = [];
+        const byField = /* @__PURE__ */ new Map();
+        for (const area of [...areas].sort((a, b) => a.start - b.start)) {
+          const last = ranges.at(-1);
+          const range = last !== void 0 && area.start <= last.end ? last : { start: area.start, end: area.end, fields: 0, buffer: null };
+          if (range !== last) {
+            ranges.push(range);
+          }
+          range.end = Math.max(range.end, area.end);
+          range.fields += 1;
+          byField.set(area.field, { range, start: area.start, end: area.end });
+        }
+        this._symbolAreas = { ranges, byField };
+        return this._symbolAreas;
+      }
+      /**
+       * One field's symbols, as bytes: the range that holds them, read from the open file the first time a field
+       * of that range needs it.
+       *
+       * @param {any} field The field, one this read selected.
+       * @return {Promise<{buffer: Buffer, start: number, end: number, base: number}>} Its area, as a range of
+       *   `buffer`, with where that buffer starts in the symbol table - what an error adds back to say where a
+       *   damaged symbol is in the file, rather than where it is in the bytes this read happened to read.
+       * @throws {QvdValidationError} If the range is larger than half the heap.
+       * @private
+       */
+      async _symbolAreaOf(field) {
+        assert4(
+          this._header && this._symbolTableOffset !== null,
+          "The QVD file header has not been parsed before its symbols were read."
+        );
+        const area = this._symbolAreaPlan().byField.get(field);
+        assert4(area, "A field this read did not select has no symbol area.");
+        const { range } = area;
+        if (range.buffer === null) {
+          const length = range.end - range.start;
+          validateSymbolTableSize(length, this._path, headerInteger(this._header["QvdTableHeader"]["NoOfRecords"]));
+          const buffer = Buffer.alloc(length);
+          const from = this._symbolTableOffset + range.start;
+          await this._readAt(buffer, 0, length, from, from + length);
+          range.buffer = buffer;
+        }
+        return { buffer: range.buffer, start: area.start - range.start, end: area.end - range.start, base: range.start };
+      }
+      /**
+       * Lets go of a field's symbols once they are parsed, and of the bytes of its range once every field in it
+       * has been.
+       *
+       * Every text is copied out of the bytes as it is decoded, so what the read keeps is the values. A read of
+       * one field of a file whose other fields are large therefore holds that field's bytes and no others.
+       *
+       * @param {any} field The field whose symbols are parsed.
+       * @private
+       */
+      _releaseSymbolArea(field) {
+        const area = this._symbolAreaPlan().byField.get(field);
+        assert4(area, "A field this read did not select has no symbol area.");
+        area.range.fields -= 1;
+        if (area.range.fields === 0) {
+          area.range.buffer = null;
+        }
+      }
+      /**
+       * Reads records from the open file a slice at a time, and hands each slice to `visit`.
+       *
+       * One buffer of at most `sliceBytes` holds a slice, and is reused for the next one, so a read of any
+       * number of records holds that much of them and no more. Cancellation is checked before each slice.
+       *
+       * @param {number} firstRow The file row of the first record.
+       * @param {number} rowCount How many records.
+       * @param {number} recordSize Bytes per record.
+       * @param {(slice: Buffer, done: number, count: number) => void|Promise<void>} visit Called with each
+       *   slice's records, how many records came before it, and how many it holds.
+       * @private
+       */
+      async _forEachSlice(firstRow, rowCount, recordSize, visit) {
+        if (rowCount === 0) {
+          return;
+        }
+        assert4(this._indexTableOffset !== null, "The QVD file header has not been parsed before its records were read.");
+        const sliceRows = this._sliceRowsFor(rowCount, recordSize);
+        const slice = Buffer.alloc(sliceRows * recordSize);
+        const requiredBytes = this._indexTableOffset + (firstRow + rowCount) * recordSize;
+        for (let done = 0; done < rowCount; done += sliceRows) {
+          this._throwIfAborted();
+          const count = Math.min(sliceRows, rowCount - done);
+          const records = slice.subarray(0, count * recordSize);
+          await this._readAt(
+            records,
+            0,
+            records.length,
+            this._indexTableOffset + (firstRow + done) * recordSize,
+            requiredBytes
+          );
+          await visit(records, done, count);
+        }
+      }
       /**
        * Parses the XML header of the QVD file. This method is part of the parsing process
        * and should not be called directly.
        */
       async _parseHeader() {
-        if (!this._buffer) {
+        if (!this._headerBuffer) {
           throw new QvdCorruptedError(
             "The QVD file has not been loaded in the proper order or has not been loaded at all.",
             {
@@ -3774,7 +4343,7 @@ var init_QvdFileReader = __esm({
         }
         const HEADER_DELIMITER = "\r\n\0";
         const headerBeginIndex = 0;
-        const headerDelimiterIndex = this._buffer.indexOf(HEADER_DELIMITER, headerBeginIndex);
+        const headerDelimiterIndex = this._headerBuffer.indexOf(HEADER_DELIMITER, headerBeginIndex);
         if (headerDelimiterIndex === -1) {
           throw new QvdCorruptedError(
             "The XML header section does not exist or is not properly delimited from the binary data.",
@@ -3785,7 +4354,7 @@ var init_QvdFileReader = __esm({
           );
         }
         const headerEndIndex = headerDelimiterIndex + HEADER_DELIMITER.length;
-        const headerBuffer = this._buffer.subarray(headerBeginIndex, headerEndIndex);
+        const headerBuffer = this._headerBuffer.subarray(headerBeginIndex, headerEndIndex);
         this._fieldBitMetadataValidated = false;
         this._header = await parseHeaderXml(headerBuffer.toString(), this._path, "parseHeader");
         const fieldList = validateHeaderStructure(this._header, this._path, "parseHeader");
@@ -3807,12 +4376,12 @@ var init_QvdFileReader = __esm({
        * @param {QvdRowWindow} window The rows of interest, as file row indices.
        * @param {string} stage Stage name for any error raised here.
        * @return {{fields: Array<any>, recordSize: number, totalRows: number, rowsToLoad: number,
-       *   indexBuffer: Buffer, firstRow: number}} The record geometry. `indexBuffer` starts at the
-       *   window's first record, file row `firstRow`, so the decoder always counts from zero.
+       *   firstRow: number}} The record geometry: the window's `rowsToLoad` records start at file row
+       *   `firstRow`, and `_forEachSlice` reads them.
        * @private
        */
       _planIndexTable(window, stage) {
-        if (!this._buffer || !this._header || !this._indexTableOffset || !this._selectedFields || !this._allFields) {
+        if (!this._handle || !this._header || !this._indexTableOffset || !this._selectedFields || !this._allFields) {
           throw new QvdCorruptedError(
             "The QVD file has not been loaded in the proper order or has not been loaded at all.",
             {
@@ -3827,22 +4396,18 @@ var init_QvdFileReader = __esm({
         const totalRows = headerInteger(this._header["QvdTableHeader"]["NoOfRecords"]);
         const indexTableLength = headerInteger(this._header["QvdTableHeader"]["Length"]);
         const { offset: firstRow, limit: rowsToLoad } = resolveWindow(window, totalRows);
+        assert4(this._fileSize !== null, "The QVD file has not been measured before its records were planned.");
         validateIndexTableMetadata(
           recordSize,
           totalRows,
           indexTableLength,
           this._indexTableOffset,
-          this._buffer.length,
+          this._fileSize,
           rowsToLoad,
           this._path,
           this._fileSize,
           firstRow,
-          this._bufferFirstRow
-        );
-        const bufferRecordStart = (firstRow - this._bufferFirstRow) * recordSize;
-        const indexBuffer = this._buffer.subarray(
-          this._indexTableOffset + bufferRecordStart,
-          this._indexTableOffset + bufferRecordStart + rowsToLoad * recordSize
+          0
         );
         if (!this._fieldBitMetadataValidated) {
           for (const field of allFields) {
@@ -3851,11 +4416,12 @@ var init_QvdFileReader = __esm({
           validateBitFields(allFields, this._path);
           this._fieldBitMetadataValidated = true;
         }
-        assert3(
-          rowsToLoad === 0 || recordSize === 0 || Math.floor(indexBuffer.length / recordSize) >= rowsToLoad,
-          `The index table holds ${Math.floor(indexBuffer.length / (recordSize || 1))} whole records but ${rowsToLoad} were validated as present.`
+        const windowEnd = this._indexTableOffset + (firstRow + rowsToLoad) * recordSize;
+        assert4(
+          rowsToLoad === 0 || recordSize === 0 || windowEnd <= this._fileSize,
+          `The window's records end at byte ${windowEnd} of a file of ${this._fileSize}, but ${rowsToLoad} were validated as present.`
         );
-        return { fields, recordSize, totalRows, rowsToLoad, indexBuffer, firstRow };
+        return { fields, recordSize, totalRows, rowsToLoad, firstRow };
       }
       /**
        * Analyzes the index table to determine which symbols are actually needed.
@@ -3871,48 +4437,58 @@ var init_QvdFileReader = __esm({
        * @private
        */
       async _analyzeIndexTableSymbolUsage(window) {
-        const { fields, recordSize, rowsToLoad, indexBuffer } = this._planIndexTable(window, "analyzeIndexTableSymbolUsage");
+        const { fields, recordSize, rowsToLoad, firstRow } = this._planIndexTable(window, "analyzeIndexTableSymbolUsage");
         const symbolUsage = [];
         const sliceRows = Math.min(rowsToLoad, ANALYSIS_SLICE_ROWS);
         const column = new Int32Array(sliceRows);
-        fields.forEach((field, position) => {
-          this._throwIfAborted();
+        const state = fields.map((field) => {
           const needed = /* @__PURE__ */ new Set();
-          symbolUsage[position] = needed;
-          const bitOffset = headerInteger(field["BitOffset"]);
-          const bitWidth = headerInteger(field["BitWidth"]);
-          const bias = headerInteger(field["Bias"]);
+          symbolUsage.push(needed);
           const length = headerInteger(field["Length"]);
-          let indexLimit = Number.isSafeInteger(length) && length >= 0 ? Math.ceil(length / 2) : Infinity;
-          let counted = false;
-          for (let first = 0; first < rowsToLoad; first += sliceRows) {
-            const count = Math.min(sliceRows, rowsToLoad - first);
-            decodeIndexColumn(
-              first === 0 ? indexBuffer : indexBuffer.subarray(first * recordSize),
-              recordSize,
-              count,
-              bitOffset,
-              bitWidth,
-              bias,
-              column
-            );
-            for (let row = 0; row < count; row++) {
-              if (column[row] >= 0 && column[row] < indexLimit) {
-                needed.add(column[row]);
+          return {
+            field,
+            needed,
+            bitOffset: headerInteger(field["BitOffset"]),
+            bitWidth: headerInteger(field["BitWidth"]),
+            bias: headerInteger(field["Bias"]),
+            indexLimit: Number.isSafeInteger(length) && length >= 0 ? Math.ceil(length / 2) : Infinity,
+            counted: false
+          };
+        });
+        await this._forEachSlice(firstRow, rowsToLoad, recordSize, async (records, done, recordCount) => {
+          for (let first = 0; first < recordCount; first += sliceRows) {
+            const count = Math.min(sliceRows, recordCount - first);
+            for (const field of state) {
+              decodeIndexColumn(
+                first === 0 ? records : records.subarray(first * recordSize),
+                recordSize,
+                count,
+                field.bitOffset,
+                field.bitWidth,
+                field.bias,
+                column
+              );
+              for (let row = 0; row < count; row++) {
+                if (column[row] >= 0 && column[row] < field.indexLimit) {
+                  field.needed.add(column[row]);
+                }
               }
-            }
-            if (!counted && needed.size > COUNT_SYMBOLS_PAST) {
-              counted = true;
-              indexLimit = Math.min(indexLimit, this._countFieldSymbols(field));
-              for (const index of needed) {
-                if (index >= indexLimit) {
-                  needed.delete(index);
+              if (!field.counted && field.needed.size > COUNT_SYMBOLS_PAST) {
+                field.counted = true;
+                field.indexLimit = Math.min(field.indexLimit, await this._countFieldSymbols(field.field));
+                for (const index of field.needed) {
+                  if (index >= field.indexLimit) {
+                    field.needed.delete(index);
+                  }
                 }
               }
             }
           }
-          this._emitProgress("symbol-analysis", position + 1, fields.length);
+          this._emitProgress("symbol-analysis", done + recordCount, rowsToLoad);
         });
+        if (rowsToLoad === 0) {
+          this._emitProgress("symbol-analysis", 0, 0);
+        }
         return symbolUsage;
       }
       /**
@@ -3920,28 +4496,27 @@ var init_QvdFileReader = __esm({
        *
        * The count is `countFieldSymbols`, the parse itself told to decode nothing, so it is the count
        * `_parseSymbolTable` will produce and `_parseIndexTable` will check against. The field's area is
-       * validated first, as `_parseSymbolTable` would, so a damaged `Offset` or `Length` is reported the
-       * same way wherever it is met.
+       * validated before it is read, by `_symbolAreaPlan`, so a damaged `Offset`, `Length` or `NoOfSymbols` is
+       * reported the same way wherever it is met. Its bytes are kept for the parse that follows. The walk checks the count against `NoOfSymbols` as the
+       * parse does, so a field whose count is wrong is refused here, before the pass keeps anything on the
+       * strength of it.
        *
        * @param {any} field The field's header.
-       * @return {number} Its symbols.
-       * @throws {QvdCorruptedError} If the area is not inside the symbol table, or a symbol runs past it.
+       * @return {Promise<number>} Its symbols.
+       * @throws {QvdCorruptedError} If the area is not inside the symbol table, a symbol runs past it, or it
+       *   holds a different number of symbols from its `NoOfSymbols`.
        * @private
        */
-      _countFieldSymbols(field) {
-        assert3(
-          this._buffer && this._symbolTableOffset && this._indexTableOffset,
-          "The QVD file has not been read before its symbols were counted."
-        );
-        const symbolBuffer = this._buffer.subarray(this._symbolTableOffset, this._indexTableOffset);
-        validateFieldMetadata(field, symbolBuffer.length, this._path);
-        const offset = headerInteger(field["Offset"]);
+      async _countFieldSymbols(field) {
+        const area = await this._symbolAreaOf(field);
         return countFieldSymbols(
-          symbolBuffer,
-          offset,
-          offset + headerInteger(field["Length"]),
+          area.buffer,
+          area.start,
+          area.end,
+          headerInteger(field["NoOfSymbols"]),
           field["FieldName"],
-          this._path
+          this._path,
+          area.base
         );
       }
       /**
@@ -3961,7 +4536,7 @@ var init_QvdFileReader = __esm({
        *   that is fewer than the window covers - see `_prepare`.
        */
       async _parseSymbolTable(symbolsToKeep = null, rowsToLoad = 0, liveRows = null) {
-        if (!this._buffer || !this._header || !this._symbolTableOffset || !this._indexTableOffset || !this._selectedFields || !this._allFields) {
+        if (!this._handle || !this._header || !this._symbolTableOffset || !this._indexTableOffset || !this._selectedFields || !this._allFields) {
           throw new QvdCorruptedError(
             "The QVD file has not been loaded in the proper order or has not been loaded at all.",
             {
@@ -3972,44 +4547,58 @@ var init_QvdFileReader = __esm({
         }
         const allFields = this._allFields;
         const fields = this._selectedFields;
-        const symbolBuffer = this._buffer.subarray(this._symbolTableOffset, this._indexTableOffset);
-        const symbolTableSize = symbolBuffer.length;
+        const symbolTableSize = this._symbolTableLength();
+        const plan = this._symbolAreaPlan();
+        const symbolBytes = plan.ranges.reduce((sum, range) => sum + (range.end - range.start), 0);
         const totalRows = headerInteger(this._header["QvdTableHeader"]["NoOfRecords"]);
-        validateSymbolTableSize(symbolTableSize, this._path, totalRows);
+        const recordSize = headerInteger(this._header["QvdTableHeader"]["RecordByteSize"]);
+        validateSymbolTableSize(symbolBytes, this._path, totalRows);
         if (this._headerMatchesFile) {
           validateMemoryAvailability(
-            symbolTableSize,
+            symbolBytes,
             rowsToLoad,
             totalRows,
             this._path,
             this._memorySafetyFactor,
             fields.length,
             this._materialisesRows,
-            liveRows
+            liveRows,
+            this._bytesHeld(symbolBytes, rowsToLoad, recordSize, liveRows, false),
+            // `symbolsToKeep` is non-null exactly when the symbol-usage pass has run, and a pass that has
+            // run has read the window's records once already - so the read's total is two passes over them.
+            symbolBytes + readPasses(symbolsToKeep !== null) * rowsToLoad * recordSize
           );
         }
-        warnLargeSymbolTable(symbolTableSize, rowsToLoad, totalRows, fields.length, this._materialisesRows);
+        warnLargeSymbolTable(symbolBytes, rowsToLoad, totalRows, fields.length, this._materialisesRows);
         for (const field of allFields) {
-          validateFieldMetadata(field, symbolBuffer.length, this._path);
+          validateFieldMetadata(field, symbolTableSize, this._path);
         }
         validateSymbolAreas(allFields, this._path);
-        this._symbolTable = fields.map((field, position) => {
+        const symbolTable = [];
+        for (const [position, field] of fields.entries()) {
           this._throwIfAborted();
-          const symbolsOffset = headerInteger(field["Offset"]);
-          const symbolsLength = headerInteger(field["Length"]);
-          const symbols = parseFieldSymbols(
-            symbolBuffer,
-            symbolsOffset,
-            symbolsOffset + symbolsLength,
-            // By position, matching how `_analyzeIndexTableSymbolUsage` built it. Both walk
-            // `this._selectedFields`, so position is the one key that cannot collide.
-            symbolsToKeep ? symbolsToKeep[position] : null,
-            field["FieldName"],
-            this._path
+          const area = await this._symbolAreaOf(field);
+          symbolTable.push(
+            parseFieldSymbols(
+              area.buffer,
+              area.start,
+              area.end,
+              // Checked against the symbols the area holds, which is the one check that sees a terminator
+              // damaged in the middle of it (#124).
+              headerInteger(field["NoOfSymbols"]),
+              // By position, matching how `_analyzeIndexTableSymbolUsage` built it. Both walk
+              // `this._selectedFields`, so position is the one key that cannot collide.
+              symbolsToKeep ? symbolsToKeep[position] : null,
+              field["FieldName"],
+              this._path,
+              void 0,
+              area.base
+            )
           );
+          this._releaseSymbolArea(field);
           this._emitProgress("symbol-table", position + 1, fields.length);
-          return symbols;
-        });
+        }
+        this._symbolTable = symbolTable;
       }
       /**
        * Parses the bit stuffed index table of the QVD file. This method is part of the parsing process
@@ -4036,27 +4625,46 @@ var init_QvdFileReader = __esm({
        * straight to the caller. Rows outside the window are not decoded, so they are not checked.
        *
        * @param {QvdRowWindow} window The rows to decode.
+       * @param {number} [progressBase=0] Rows decoded before this call, so that progress over a chunked
+       *   iteration counts the whole window rather than restarting at every chunk - what `_buildRows` takes
+       *   for the same reason.
+       * @param {number|null} [progressTotal=null] Rows the whole window covers, or null for this call's own.
+       * @param {Array<Int32Array>|null} [into=null] Arrays to decode into, one per selected field and at least
+       *   `limit` long, for a caller that decodes chunk after chunk and keeps none of them. Null allocates.
        * @throws {QvdCorruptedError} If an index in the window addresses neither a symbol nor NULL.
        */
-      async _parseIndexTable(window) {
-        const { fields, recordSize, rowsToLoad, indexBuffer, firstRow } = this._planIndexTable(window, "parseIndexTable");
-        assert3(this._symbolTable, "The QVD file symbol table has not been parsed.");
+      async _parseIndexTable(window, progressBase = 0, progressTotal = null, into = null) {
+        const { fields, recordSize, rowsToLoad, firstRow } = this._planIndexTable(window, "parseIndexTable");
+        const decodedBefore = progressBase;
+        const decodedTotal = progressTotal === null ? rowsToLoad : progressTotal;
+        assert4(this._symbolTable, "The QVD file symbol table has not been parsed.");
         const symbolTable = this._symbolTable;
-        const columns = fields.map((field, position) => {
-          this._throwIfAborted();
-          const column = decodeIndexColumn(
-            indexBuffer,
-            recordSize,
-            rowsToLoad,
-            headerInteger(field["BitOffset"]),
-            headerInteger(field["BitWidth"]),
-            headerInteger(field["Bias"]),
-            new Int32Array(rowsToLoad),
-            { symbolCount: symbolTable[position].numbers.length, field: field["FieldName"], file: this._path, firstRow }
-          );
-          this._emitProgress("index-table", position + 1, fields.length);
-          return column;
+        const decoders = fields.map((field, position) => ({
+          bitOffset: headerInteger(field["BitOffset"]),
+          bitWidth: headerInteger(field["BitWidth"]),
+          bias: headerInteger(field["Bias"]),
+          symbolCount: symbolTable[position].numbers.length,
+          name: field["FieldName"]
+        }));
+        const columns = into === null ? fields.map(() => new Int32Array(rowsToLoad)) : into.map((codes) => codes.subarray(0, rowsToLoad));
+        await this._forEachSlice(firstRow, rowsToLoad, recordSize, (records, done, count) => {
+          decoders.forEach((decoder, position) => {
+            decodeIndexColumn(
+              records,
+              recordSize,
+              count,
+              decoder.bitOffset,
+              decoder.bitWidth,
+              decoder.bias,
+              columns[position].subarray(done, done + count),
+              { symbolCount: decoder.symbolCount, field: decoder.name, file: this._path, firstRow: firstRow + done }
+            );
+          });
+          this._emitProgress("index-table", decodedBefore + done + count, decodedTotal);
         });
+        if (rowsToLoad === 0) {
+          this._emitProgress("index-table", decodedBefore, decodedTotal);
+        }
         this._indexColumns = columns;
         this._rowsDecoded = rowsToLoad;
       }
@@ -4075,31 +4683,122 @@ var init_QvdFileReader = __esm({
        * @return {Promise<import('./QvdDataFrame.js').QvdFileMetadata>} The file's schema and header.
        */
       async loadMetadata() {
-        await this._readData({ offset: 0, limit: null }, true);
-        this._emitProgress("header", 0, 1);
-        await this._parseHeader();
-        this._emitProgress("header", 1, 1);
-        this._throwIfAborted();
-        assert3(this._header && this._allFields, "The QVD file header has not been parsed.");
-        const header = this._header["QvdTableHeader"];
-        const columns = this._allFields.map((field) => field["FieldName"]);
-        const rowCount = headerInteger(header["NoOfRecords"]);
-        validateRecordCount(rowCount, this._path, "readMetadata");
-        const shape = new QvdDataFrame([], columns, header, {
-          symbolTableBytes: headerInteger(header["Offset"]),
-          totalRows: rowCount,
-          rowsLoaded: 0,
-          symbolFiltering: false,
-          symbolsKept: null
+        return await this._closingAfter(async () => {
+          await this._readData({ offset: 0, limit: null }, true);
+          this._emitProgress("header", 0, 1);
+          await this._parseHeader();
+          this._emitProgress("header", 1, 1);
+          this._throwIfAborted();
+          assert4(this._header && this._allFields, "The QVD file header has not been parsed.");
+          const header = this._header["QvdTableHeader"];
+          const columns = this._allFields.map((field) => field["FieldName"]);
+          const rowCount = headerInteger(header["NoOfRecords"]);
+          validateRecordCount(rowCount, this._path, "readMetadata");
+          const shape = new QvdDataFrame([], columns, header, {
+            symbolTableBytes: headerInteger(header["Offset"]),
+            totalRows: rowCount,
+            rowsLoaded: 0,
+            symbolFiltering: false,
+            symbolsKept: null
+          });
+          return {
+            columns,
+            rowCount,
+            columnCount: columns.length,
+            fields: columns.map((name) => shape.getFieldMetadata(name)),
+            fileMetadata: shape.fileMetadata,
+            metadata: header
+          };
+        });
+      }
+      /**
+       * What a read of this file would cost, and whether it fits, without reading it.
+       *
+       * Reads the header and the file's size and nothing else, at the constant cost of `loadMetadata()`,
+       * then asks the same question a read asks before it allocates anything - through the same function,
+       * from the same numbers. That is the whole point: an answer computed a second way would be a second
+       * opinion, and a read this approves would still be refused.
+       *
+       * @param {number|null|{offset?: number, limit?: number|null, maxRows?: number|null}} [rawWindow]
+       *   The rows the read would cover, spelled any of the ways a read accepts.
+       * @param {{chunkSize?: number|null}} [options] `chunkSize` when the read would be an `iterate()`,
+       *   which holds two chunks of rows rather than the window.
+       * @return {Promise<any>} The answer - see `checkMemory`.
+       */
+      async checkRead(rawWindow, { chunkSize = null } = {}) {
+        const window = normaliseWindow(rawWindow, this._path);
+        return await this._closingAfter(async () => {
+          await this._readData({ offset: 0, limit: null }, true);
+          this._emitProgress("header", 0, 1);
+          await this._parseHeader();
+          this._emitProgress("header", 1, 1);
+          this._throwIfAborted();
+          assert4(
+            this._header && this._selectedFields && this._allFields && this._symbolTableOffset !== null,
+            "The QVD file header has not been parsed."
+          );
+          const header = this._header["QvdTableHeader"];
+          const totalRows = headerInteger(header["NoOfRecords"]);
+          const recordSize = headerInteger(header["RecordByteSize"]);
+          const symbolTableLength = headerInteger(header["Offset"]);
+          const selected = this._selectedFields;
+          validateRecordSize(recordSize, this._path, "checkRead");
+          validateRecordCount(totalRows, this._path, "checkRead");
+          if (!this._headerMatchesFile) {
+            throw new QvdCorruptedError("The file is shorter than its header claims.", {
+              file: this._path,
+              fileSize: this._fileSize,
+              requiredBytes: this._symbolTableOffset + symbolTableLength + totalRows * recordSize,
+              stage: "checkRead"
+            });
+          }
+          const tableLength = this._symbolTableLength();
+          for (const field of this._allFields) {
+            validateFieldMetadata(field, tableLength, this._path);
+            validateFieldBitMetadata(field, recordSize, this._path);
+          }
+          validateSymbolAreas(this._allFields, this._path);
+          const resolved = resolveWindow(window, totalRows);
+          const windowRows = resolved.limit;
+          const liveRows = chunkSize === null ? null : { rows: chunkSize * 2, perChunk: 2 };
+          const analysisAhead = this._analysisWouldRun(window, resolved, totalRows, symbolTableLength);
+          const measured = getMemoryBudget();
+          const ask = /* @__PURE__ */ __name((fields, rows) => {
+            const bytes = symbolBytesOf(fields, symbolTableLength);
+            return checkMemory({
+              measured,
+              symbolTableSize: bytes,
+              maxRows: rows,
+              totalRows,
+              safetyFactor: this._memorySafetyFactor,
+              columnCount: fields.length,
+              materialisesRows: this._materialisesRows,
+              live: liveRows,
+              bytesHeld: this._bytesHeld(bytes, rows, recordSize, liveRows, analysisAhead),
+              // What it reads from the file, which is not what it holds: the symbol areas, and every record
+              // the window covers, read a slice at a time and not kept - twice over where the symbol-usage
+              // pass will run, since it reads them before the decode reads them again.
+              readBytes: bytes + readPasses(analysisAhead) * windowRows * recordSize
+            });
+          }, "ask");
+          const answer = ask(selected, windowRows);
+          if (!answer.fits && selected.length > 1) {
+            const bySize = [...selected].sort(
+              (a, b) => headerInteger(a["Length"]) - headerInteger(b["Length"])
+            );
+            for (let take = selected.length - 1; take >= 1; take -= 1) {
+              const fewer = bySize.slice(0, take);
+              if (ask(fewer, windowRows).fits) {
+                answer.suggestions.push({
+                  option: "fields",
+                  value: fewer.map((field) => field["FieldName"])
+                });
+                break;
+              }
+            }
+          }
+          return answer;
         });
-        return {
-          columns,
-          rowCount,
-          columnCount: columns.length,
-          fields: columns.map((name) => shape.getFieldMetadata(name)),
-          fileMetadata: shape.fileMetadata,
-          metadata: header
-        };
       }
       /**
        * Loads the QVD file into memory and parses it.
@@ -4114,19 +4813,21 @@ var init_QvdFileReader = __esm({
        */
       async load(window = null) {
         const rows = normaliseWindow(window, this._path);
-        const prepared = await this._prepare(rows);
-        await this._parseIndexTable({ offset: prepared.offset, limit: prepared.rowsAvailable });
-        const data = this._buildRows(prepared.resolvedByField, 0, prepared.rowsAvailable);
-        return new QvdDataFrame(
-          data,
-          prepared.columns,
-          prepared.metadata,
-          {
-            ...prepared.loadStats,
-            rowsLoaded: data.length
-          },
-          prepared.storedSymbols
-        );
+        return await this._closingAfter(async () => {
+          const prepared = await this._prepare(rows);
+          await this._parseIndexTable({ offset: prepared.offset, limit: prepared.rowsAvailable });
+          const data = this._buildRows(prepared.resolvedByField, 0, prepared.rowsAvailable);
+          return new QvdDataFrame(
+            data,
+            prepared.columns,
+            prepared.metadata,
+            {
+              ...prepared.loadStats,
+              rowsLoaded: data.length
+            },
+            prepared.storedSymbols
+          );
+        });
       }
       /**
        * Reads the file as columns, without ever materialising rows.
@@ -4145,19 +4846,21 @@ var init_QvdFileReader = __esm({
        */
       async loadColumnar(window = null) {
         const rows = normaliseWindow(window, this._path);
-        const prepared = await this._prepare(rows, null, true);
-        await this._parseIndexTable({ offset: prepared.offset, limit: prepared.rowsAvailable });
-        const { QvdColumnTable: QvdColumnTable2 } = await Promise.resolve().then(() => (init_QvdColumnTable(), QvdColumnTable_exports));
-        assert3(this._indexColumns, "The QVD file index table has not been parsed.");
-        return new QvdColumnTable2({
-          columns: prepared.columns,
-          codesByField: this._indexColumns,
-          symbolsByField: prepared.resolvedByField,
-          halvesByField: prepared.halvesByField,
-          rowCount: this._rowsDecoded,
-          metadata: prepared.metadata,
-          storedSymbols: prepared.storedSymbols,
-          loadStats: { ...prepared.loadStats, rowsLoaded: this._rowsDecoded }
+        return await this._closingAfter(async () => {
+          const prepared = await this._prepare(rows, null, true);
+          await this._parseIndexTable({ offset: prepared.offset, limit: prepared.rowsAvailable });
+          const { QvdColumnTable: QvdColumnTable2 } = await Promise.resolve().then(() => (init_QvdColumnTable(), QvdColumnTable_exports));
+          assert4(this._indexColumns, "The QVD file index table has not been parsed.");
+          return new QvdColumnTable2({
+            columns: prepared.columns,
+            codesByField: this._indexColumns,
+            symbolsByField: prepared.resolvedByField,
+            halvesByField: prepared.halvesByField,
+            rowCount: this._rowsDecoded,
+            metadata: prepared.metadata,
+            storedSymbols: prepared.storedSymbols,
+            loadStats: { ...prepared.loadStats, rowsLoaded: this._rowsDecoded }
+          });
         });
       }
       /**
@@ -4186,37 +4889,41 @@ var init_QvdFileReader = __esm({
        * @return {AsyncGenerator<QvdDataFrame>} The chunks, in order.
        */
       async *iterateRows(window, chunkSize) {
-        if (typeof chunkSize !== "number" || !Number.isInteger(chunkSize) || chunkSize <= 0) {
-          throw new QvdValidationError("chunkSize must be a positive integer", {
-            provided: chunkSize,
-            type: typeof chunkSize,
-            file: this._path
-          });
-        }
+        requireChunkSize(chunkSize, this._path);
         const liveRows = { rows: chunkSize * 2, perChunk: 2 };
         const rows = normaliseWindow(window, this._path);
-        const prepared = await this._prepare(rows, liveRows);
-        if (prepared.rowsAvailable === 0) {
-          this._planIndexTable({ offset: prepared.offset, limit: 0 }, "parseIndexTable");
-          return;
-        }
-        for (let done = 0; done < prepared.rowsAvailable; done += chunkSize) {
-          this._throwIfAborted();
-          const count = Math.min(chunkSize, prepared.rowsAvailable - done);
-          const offset = prepared.offset + done;
-          await this._parseIndexTable({ offset, limit: count });
-          const data = this._buildRows(prepared.resolvedByField, done, prepared.rowsAvailable);
-          yield new QvdDataFrame(
-            data,
-            prepared.columns,
-            prepared.metadata,
-            {
-              ...prepared.loadStats,
-              offset,
-              rowsLoaded: data.length
-            },
-            prepared.storedSymbols
-          );
+        this._startRead();
+        let failing = false;
+        try {
+          const prepared = await this._prepare(rows, liveRows);
+          if (prepared.rowsAvailable === 0) {
+            this._planIndexTable({ offset: prepared.offset, limit: 0 }, "parseIndexTable");
+            return;
+          }
+          const codes = prepared.columns.map(() => new Int32Array(Math.min(chunkSize, prepared.rowsAvailable)));
+          for (let done = 0; done < prepared.rowsAvailable; done += chunkSize) {
+            this._throwIfAborted();
+            const count = Math.min(chunkSize, prepared.rowsAvailable - done);
+            const offset = prepared.offset + done;
+            await this._parseIndexTable({ offset, limit: count }, done, prepared.rowsAvailable, codes);
+            const data = this._buildRows(prepared.resolvedByField, done, prepared.rowsAvailable);
+            yield new QvdDataFrame(
+              data,
+              prepared.columns,
+              prepared.metadata,
+              {
+                ...prepared.loadStats,
+                offset,
+                rowsLoaded: data.length
+              },
+              prepared.storedSymbols
+            );
+          }
+        } catch (error) {
+          failing = true;
+          throw error;
+        } finally {
+          await this._endRead(failing);
         }
       }
       /**
@@ -4250,23 +4957,21 @@ var init_QvdFileReader = __esm({
         await this._parseHeader();
         this._emitProgress("header", 1, 1);
         this._throwIfAborted();
-        assert3(this._header, "The QVD file header has not been parsed.");
+        assert4(this._header, "The QVD file header has not been parsed.");
         const totalRows = headerInteger(this._header["QvdTableHeader"]["NoOfRecords"]);
         const symbolTableLength = headerInteger(this._header["QvdTableHeader"]["Offset"]);
         const resolved = resolveWindow(window, totalRows);
         const rowsAvailable = resolved.limit;
         let symbolsToKeep = null;
         let symbolsKept = null;
-        if (window.limit !== null || window.offset > 0) {
-          if (symbolTableLength > this._symbolFilteringThreshold) {
-            symbolsToKeep = await this._analyzeIndexTableSymbolUsage({ offset: resolved.offset, limit: rowsAvailable });
-            symbolsKept = symbolsToKeep.reduce((sum, set) => sum + set.size, 0);
-          }
+        if (this._analysisWouldRun(window, resolved, totalRows, symbolTableLength)) {
+          symbolsToKeep = await this._analyzeIndexTableSymbolUsage({ offset: resolved.offset, limit: rowsAvailable });
+          symbolsKept = symbolsToKeep.reduce((sum, set) => sum + set.size, 0);
         }
         await this._parseSymbolTable(symbolsToKeep, rowsAvailable, liveRows);
-        assert3(this._symbolTable, "The QVD file symbol table has not been parsed.");
+        assert4(this._symbolTable, "The QVD file symbol table has not been parsed.");
         this._throwIfAborted();
-        assert3(this._selectedFields, "The QVD file fields have not been resolved.");
+        assert4(this._selectedFields, "The QVD file fields have not been resolved.");
         const resolvedByField = [];
         const halvesByField = [];
         const entries = [];
@@ -4327,7 +5032,7 @@ var init_QvdFileReader = __esm({
        * @private
        */
       _buildRows(resolvedByField, progressBase, progressTotal) {
-        assert3(this._indexColumns, "The QVD file index table has not been parsed.");
+        assert4(this._indexColumns, "The QVD file index table has not been parsed.");
         const indexColumns = this._indexColumns;
         const fieldCount = indexColumns.length;
         const rowCount = this._rowsDecoded;
@@ -5016,12 +5721,16 @@ var init_QvdDataFrame = __esm({
       /**
        * Reads a QVD file in chunks, as an async generator of data frames.
        *
-       * The file is opened, read and parsed once; only the index decode and the row building happen
-       * per chunk, so what this bounds is row materialisation - the part that actually dominates a
-       * large read's heap. It is **not** constant-memory reading of an arbitrarily large file: the
-       * symbol table is parsed in full whatever the chunk size, because a stored index in the last
-       * chunk can address the first symbol. On a high-cardinality file that table is the bulk of the
-       * cost, and `readMetadata` is the only read that avoids it.
+       * The file is opened once and its symbol table parsed once. Each chunk's records are read from the
+       * file when that chunk is built, so what this holds is the symbol table and two chunks of rows,
+       * whatever the size of the file: a 20 GB QVD iterates in the memory its symbol table needs. That
+       * table is still parsed in full whatever the chunk size, because a stored index in the last chunk
+       * can address the first symbol. On a high-cardinality file that table is the bulk of the cost, and
+       * `readMetadata` is the only read that avoids it.
+       *
+       * The file stays open until the iteration ends. Running it to the end closes it, and so do
+       * `break` or a throw inside `for await` and a call to `return()` on the iterator; an iterator
+       * abandoned part-way without any of those holds the file until it is garbage-collected.
        *
        * ```js
        * for await (const chunk of QvdDataFrame.iterate('big.qvd', {chunkSize: 50_000})) {
@@ -5095,6 +5804,68 @@ var init_QvdDataFrame = __esm({
         const { QvdFileReader: QvdFileReader2 } = await Promise.resolve().then(() => (init_QvdFileReader(), QvdFileReader_exports));
         return await new QvdFileReader2(path5, metadataOptionsFrom(options)).loadMetadata();
       }
+      /**
+       * Answers what a read would cost, and whether it fits, without doing it.
+       *
+       * Takes the options `fromQvd()` takes, plus `as` and `chunkSize` to say which read is being asked
+       * about. Reads the header and the file's size and nothing else, at a cost that does not grow with
+       * the file.
+       *
+       * The answer comes from the same function a read consults before it allocates anything, from the
+       * same numbers, so **a read this approves is not refused later for memory** - and every suggestion
+       * it carries has been read back through the check, so following one gives a read that fits.
+       *
+       * It answers about resources, so it answers only for a header it can trust. A header whose numbers
+       * are not usable, or that claims more than the file holds, is refused as a `QvdCorruptedError` rather
+       * than answered: sizing a read from numbers the file contradicts produced a memory verdict about a
+       * file whose real problem was structural, and it was wrong in both directions - approving a read the
+       * library then refused, and refusing another with advice that was refused too.
+       *
+       * That covers everything a reader can tell from the header: a field area past the end of the symbol
+       * table, two fields claiming one area, a `Bias` that is neither 0 nor -2, a `BitWidth` past 31. Damage
+       * that is not in the header - a value or an index the file has spoiled - is still found only by
+       * reading, and still refused as a `QvdCorruptedError` after this has said the read fits.
+       *
+       * ```js
+       * const answer = await QvdDataFrame.checkRead('huge.qvd', {as: 'columns', fields: ['Amount']});
+       *
+       * if (!answer.fits) {
+       *   console.log(answer.reason); // 'memory'
+       *   console.log(answer.suggestions); // [{option: 'limit', value: 1250000}, ...]
+       * }
+       * ```
+       *
+       * @param {string} path The QVD file.
+       * @param {object} [options] What `fromQvd()` takes, plus the two below.
+       * @param {'rows'|'columns'} [options.as='rows'] Which read is being asked about: `rows` builds row
+       *   arrays and `columns` does not, which is most of what a read costs.
+       * @param {number|null} [options.chunkSize=null] The chunk an `iterate()` would use, which holds two
+       *   chunks of rows rather than the whole window.
+       * @return {Promise<any>} The answer: `fits`, `reason` when it does not, `estimate`, `budget`,
+       *   `exact` and `suggestions`.
+       * @throws {QvdValidationError} If an option's value is not valid, with `context.reason` of `option`.
+       * @throws {QvdCorruptedError} If the header cannot be read, its numbers are not usable, or it claims
+       *   more than the file holds. The read refuses such a file too, though it may name the fault
+       *   differently - it gets there by planning the index table, where this gets there from the size.
+       */
+      static async checkRead(path5, options = {}) {
+        const { QvdFileReader: QvdFileReader2 } = await Promise.resolve().then(() => (init_QvdFileReader(), QvdFileReader_exports));
+        const { as = "rows", chunkSize = null } = options;
+        if (as !== "rows" && as !== "columns") {
+          throw new QvdValidationError("as must be 'rows' or 'columns'", {
+            provided: as,
+            reason: "option",
+            option: "as",
+            value: as,
+            file: path5
+          });
+        }
+        if (chunkSize !== null) {
+          requireChunkSize(chunkSize, path5);
+        }
+        const reader = new QvdFileReader2(path5, { ...readerOptionsFrom(options), materialisesRows: as === "rows" });
+        return await reader.checkRead(windowFrom(options), { chunkSize });
+      }
       /**
        * Constructs a data frame from a dictionary.
        *