datareader-spss 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 everydaydesign
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,311 @@
+# datareader-spss
+
+**Correct, zero-dependency SPSS `.sav`/`.zsav` reader for the browser and Node — validated against R [`haven`](https://haven.tidyverse.org/).**
+
+`datareader-spss` parses IBM SPSS system files (`.sav`) and their compressed variant (`.zsav`) into plain
+JavaScript values: numbers, strings, `Date`s, variable metadata, value labels, and declared missing
+values. It is written in pure TypeScript against Web platform APIs (`ArrayBuffer`, `DataView`,
+`TextDecoder`, `DecompressionStream`) — **no runtime dependencies**, and the same build runs in the
+browser and in Node.
+
+## Why
+
+SPSS `.sav` files are everywhere in the social sciences, market research, and public data, but the
+JavaScript ecosystem lacked a reader that decodes *real* files correctly — most tools stumble on RLE
+compression, ZSAV (zlib) blocks, very-long strings, encodings, or the exact bit-level meaning of
+system- vs. user-missing values. Getting any of those wrong silently corrupts data.
+
+`datareader-spss` was built to be correct first: every construct is validated value-for-value against R's
+`haven`/`ReadStat`, the de-facto reference implementation. It uses only Web APIs, so it ships as a
+single ESM module with zero dependencies and no native addons — drop it into a browser upload flow
+or a Node script alike.
+
+## Install
+
+```bash
+npm i datareader-spss
+```
+
+```bash
+bun add datareader-spss
+pnpm add datareader-spss
+yarn add datareader-spss
+```
+
+## Usage
+
+### Browser — a picked/dropped `File`
+
+```ts
+import { readSav, applyUserMissing } from "datareader-spss";
+
+const input = document.querySelector<HTMLInputElement>("#file");
+input.addEventListener("change", async () => {
+  const file = input.files?.[0];
+  if (!file) return;
+
+  const parsed = await readSav(await file.arrayBuffer());
+  const sheet = parsed.sheets[0];
+
+  console.log(sheet.variables.map((v) => v.name)); // column names
+  console.log(sheet.rows.length); // row count
+
+  // Replace every declared user-missing cell with null before analysis:
+  const clean = applyUserMissing(sheet);
+  console.log(clean.rows[0]);
+});
+```
+
+### React — a file input
+
+```tsx
+import { useState } from "react";
+import { readSav, applyUserMissing, type Sheet } from "datareader-spss";
+
+export function SavImporter() {
+  const [sheet, setSheet] = useState<Sheet | null>(null);
+
+  async function onFile(e: React.ChangeEvent<HTMLInputElement>) {
+    const file = e.target.files?.[0];
+    if (!file) return;
+    const { sheets } = await readSav(await file.arrayBuffer());
+    setSheet(applyUserMissing(sheets[0]));
+  }
+
+  return (
+    <>
+      <input type="file" accept=".sav" onChange={onFile} />
+      {sheet && (
+        <p>
+          {sheet.rows.length} rows × {sheet.variables.length} variables
+        </p>
+      )}
+    </>
+  );
+}
+```
+
+### Node — a file on disk
+
+```ts
+import { readFile } from "node:fs/promises";
+import { readSav } from "datareader-spss";
+
+const nodeBuf = await readFile("survey.sav");
+
+// Slice an exact ArrayBuffer (Node pools Buffers behind a shared store):
+const bytes = nodeBuf.buffer.slice(
+  nodeBuf.byteOffset,
+  nodeBuf.byteOffset + nodeBuf.byteLength,
+);
+
+const parsed = await readSav(bytes);
+for (const v of parsed.sheets[0].variables) {
+  console.log(v.name, v.type, v.label ?? "");
+}
+```
+
+### Reading variables and rows
+
+```ts
+import { readSav, type CellValue } from "datareader-spss";
+
+const { sheets, encoding } = await readSav(buffer);
+const { variables, rows } = sheets[0];
+
+// `rows` is CellValue[][], column-aligned to `variables` by index.
+const genderCol = variables.findIndex((v) => v.name === "gender");
+const genderValues: CellValue[] = rows.map((row) => row[genderCol]);
+
+// A variable's value labels (e.g. 1 -> "Male", 2 -> "Female"):
+const gender = variables[genderCol];
+console.log(gender.valueLabels); // [{ value: 1, label: "Male" }, ...]
+console.log(encoding); // e.g. "utf-8" or "windows-1252"
+```
+
+## API
+
+### `readSav(buf, opts?)`
+
+```ts
+function readSav(
+  buf: ArrayBuffer,
+  opts?: Partial<SavLimits>,
+): Promise<ParsedFile>;
+```
+
+Reads a `.sav`/`.zsav` file end-to-end (header → dictionary → extensions → variables → data cases,
+inflating ZSAV blocks as needed) and resolves to a `ParsedFile`. `opts` tightens the resource
+ceilings (see [Security & limits](#security--limits)). Rejects with a `SavError` on malformed or
+hostile input.
+
+### `applyUserMissing(sheet)`
+
+```ts
+function applyUserMissing(sheet: Sheet): Sheet;
+```
+
+Returns a **new** `Sheet` in which every cell matching its variable's declared `MissingSpec` is
+replaced by `null` (user-missing → system-missing). Non-mutating — the input sheet is untouched. Use
+it when you want declared missing codes treated as missing; skip it when you need the literal codes.
+
+### `SavError`
+
+```ts
+class SavError extends Error {}
+```
+
+Thrown when a resource bound rejects a malformed or hostile file (a bad file, not a reader bug).
+Because it extends `Error`, a plain `catch` still catches it; check `err instanceof SavError` to
+distinguish a rejected/hostile file from a genuinely unsupported-but-valid construct (which throws a
+plain `Error`).
+
+### `DEFAULT_LIMITS`
+
+```ts
+const DEFAULT_LIMITS: SavLimits = {
+  // ncases × nvars ceiling (~500k rows × 100 vars)
+  maxCells: 50_000_000,
+  // ZSAV inflate output ceiling (512 MiB)
+  maxInflatedBytes: 512 * 1024 * 1024,
+};
+```
+
+The generous defaults that `readSav` merges your `opts` over. No well-formed file is affected.
+
+### Types
+
+```ts
+// null = system-missing
+type CellValue = string | number | Date | null;
+
+type Measure = "nominal" | "ordinal" | "scale" | "unknown";
+
+type MissingSpec =
+  | { kind: "none" }
+  | { kind: "discrete"; values: number[] }
+  | { kind: "range"; lo: number; hi: number }
+  | { kind: "range+discrete"; lo: number; hi: number; value: number }
+  | { kind: "strings"; values: string[] };
+
+type SpssFormat = {
+  type: number;
+  width: number;
+  decimals: number;
+  isDate: boolean;
+};
+
+type Variable = {
+  name: string;
+  label?: string;
+  type: "numeric" | "string";
+  // string byte width, or the merged width for very-long strings
+  width?: number;
+  missing: MissingSpec;
+  valueLabels?: Array<{ value: CellValue; label: string }>;
+  format: SpssFormat;
+  measure: Measure;
+};
+
+type Sheet = {
+  name: string;
+  variables: Variable[];
+  rows: CellValue[][];
+};
+
+type ParsedFile = {
+  format: "sav";
+  encoding?: string;
+  sheets: Sheet[];
+};
+
+type SavLimits = {
+  maxCells: number;
+  maxInflatedBytes: number;
+};
+```
+
+For a `.sav` file, `sheets` always contains exactly one sheet (named `"data"`); `rows` is row-major
+and column-aligned to `variables`.
+
+**Missing values.** `null` in a cell is always **system-missing**. Declared **user-missing** values
+(a survey's `99 = "no answer"`, or a range) are kept as their literal number/string so you can see
+them — call `applyUserMissing(sheet)` to fold them to `null`. A variable's declaration is on
+`variable.missing`:
+
+- `{ kind: "none" }` — no declared missing values.
+- `{ kind: "discrete", values }` — up to three discrete codes.
+- `{ kind: "range", lo, hi }` — a missing range `[lo, hi]`.
+- `{ kind: "range+discrete", lo, hi, value }` — a range plus one discrete code.
+- `{ kind: "strings", values }` — discrete codes for a string variable.
+
+## Format coverage
+
+| Area           | Supported                                                            |
+| -------------- | ------------------------------------------------------------------- |
+| Magic          | `$FL2` (uncompressed / RLE) and `$FL3` (ZSAV)                        |
+| Compression    | uncompressed, RLE (SPSS bytecode), ZSAV (zlib `deflate` blocks)      |
+| Variables      | numeric, string, and very-long strings (> 255 bytes, segment-merged) |
+| Dates          | SPSS date/time formats decoded to JavaScript `Date`                 |
+| Value labels   | numeric and string value-label sets, resolved per variable          |
+| Missing values | discrete, range, range + discrete, and string missing specs         |
+| Encodings      | file-declared encoding via `TextDecoder` (UTF-8, windows-125x, …)   |
+| Endianness     | little-endian                                                       |
+
+## Correctness
+
+Every supported construct is validated **value-for-value against R `haven`** (which wraps the
+`ReadStat` C library) across a fixture matrix covering compression modes, numeric/string/very-long
+variables, dates, value labels, each missing-value kind, and encodings — plus a real-world 2.78 MB
+survey file. The oracle fixtures live alongside the source and are asserted on every test run.
+
+## Security & limits
+
+`datareader-spss` is designed to parse **untrusted** files safely. A hostile `.sav` cannot make it OOM or
+hang: every attacker-controlled allocation and loop is bounded, and any bound violation throws a
+catchable `SavError` rather than exhausting memory or spinning.
+
+- Reads never allocate beyond the remaining file bytes.
+- The data-cell budget (`maxCells`) and the ZSAV inflate budget (`maxInflatedBytes`) are enforced
+  while streaming, so a decompression bomb aborts before it materializes.
+- Malformed dictionaries, out-of-spec record counts, and truncated headers are rejected up front.
+
+Tune the ceilings for memory-constrained environments:
+
+```ts
+await readSav(buf, {
+  maxCells: 5_000_000,
+  maxInflatedBytes: 64 * 1024 * 1024,
+});
+```
+
+Recommendations for consumers:
+
+- Still bound the **input** size before you hand a buffer to `readSav` (reject files larger than you
+  expect for your use case).
+- Treat `Variable.name` (and other file-derived strings) as **untrusted** — don't use a variable
+  name as a plain-object key without care; prefer a `Map` or a `null`-prototype object to avoid
+  prototype-pollution surprises from adversarial names.
+
+## Roadmap
+
+`datareader-spss` reads modern little-endian `.sav`/`.zsav` files correctly today, and is intentionally
+read-only. On the map for future releases:
+
+- **Big-endian system files** — the header already detects byte order; big-endian *data* reading and
+  `haven` validation are not yet implemented.
+- **Portable `.por` format** — the older text-based SPSS portable format.
+- **Writing `.sav` files** — the reader is read-only; a writer is a possible future addition.
+
+Issues and contributions are welcome.
+
+## License
+
+MIT © 2026 everydaydesign
+
+## Credits
+
+- The [PSPP System File Format](https://www.gnu.org/software/pspp/pspp-dev/html_node/System-File-Format.html)
+  documentation — the specification this reader implements.
+- R [`haven`](https://haven.tidyverse.org/) and [`ReadStat`](https://github.com/WizardMac/ReadStat) —
+  the validation oracle every fixture is checked against.

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+type CellValue = string | number | Date | null;
+type Measure = "nominal" | "ordinal" | "scale" | "unknown";
+type MissingSpec = {
+    kind: "none";
+} | {
+    kind: "discrete";
+    values: number[];
+} | {
+    kind: "range";
+    lo: number;
+    hi: number;
+} | {
+    kind: "range+discrete";
+    lo: number;
+    hi: number;
+    value: number;
+} | {
+    kind: "strings";
+    values: string[];
+};
+type SpssFormat = {
+    type: number;
+    width: number;
+    decimals: number;
+    isDate: boolean;
+};
+type Variable = {
+    name: string;
+    label?: string;
+    type: "numeric" | "string";
+    width?: number;
+    missing: MissingSpec;
+    valueLabels?: Array<{
+        value: CellValue;
+        label: string;
+    }>;
+    format: SpssFormat;
+    measure: Measure;
+};
+type Format = "csv" | "tsv" | "txt" | "xlsx" | "sav";
+type Sheet = {
+    name: string;
+    variables: Variable[];
+    rows: CellValue[][];
+};
+type ParsedFile = {
+    format: Format;
+    encoding?: string;
+    sheets: Sheet[];
+};
+
+/** Thrown for any malformed or hostile `.sav` input that a resource bound rejects — a bad file, not
+ * a reader bug. Distinct from the plain `Error`s raised for unsupported-but-valid constructs so a
+ * caller can `catch` an attack (OOM/hang avoidance) separately if it wants to. */
+declare class SavError extends Error {
+}
+/** Resource ceilings that keep a hostile `.sav` from exhausting memory or looping unboundedly. The
+ * defaults are generous, so no well-formed file is affected; pass a stricter `readSav(buf, opts)` in
+ * memory-constrained environments. */
+type SavLimits = {
+    /** Maximum `ncases × nvars` data cells the reader will materialize (~500k rows × 100 vars). */
+    maxCells: number;
+    /** Cumulative inflate output ceiling: total bytes a ZSAV may inflate to before the reader aborts (512 MiB). */
+    maxInflatedBytes: number;
+};
+declare const DEFAULT_LIMITS: SavLimits;
+
+/**
+ * Return a new {@link Sheet} in which every cell matching its variable's
+ * declared {@link MissingSpec} is replaced by `null` (user-missing → system-missing).
+ * Non-mutating: fresh `rows` and fresh inner arrays; the input is left untouched.
+ */
+declare function applyUserMissing(sheet: Sheet): Sheet;
+
+/** Read an SPSS `.sav`/`.zsav` system file end-to-end: header → dictionary → extensions → variables
+ * → (inflate if ZSAV) → data cases. Matches R `haven` on the committed golden fixtures. `opts`
+ * tightens the resource ceilings (see `SavLimits`); a hostile file is rejected with a `SavError`. */
+declare function readSav(buf: ArrayBuffer, opts?: Partial<SavLimits>): Promise<ParsedFile>;
+
+export { type CellValue, DEFAULT_LIMITS, type Format, type Measure, type MissingSpec, type ParsedFile, SavError, type SavLimits, type Sheet, type SpssFormat, type Variable, applyUserMissing, readSav };

package/dist/index.js

@@ -0,0 +1,597 @@
+// src/limits.ts
+var SavError = class extends Error {
+};
+var DEFAULT_LIMITS = {
+  maxCells: 5e7,
+  maxInflatedBytes: 512 * 1024 * 1024
+};
+
+// src/missing.ts
+function numberMatches(cell, spec) {
+  switch (spec.kind) {
+    case "discrete":
+      return spec.values.includes(cell);
+    case "range":
+      return cell >= spec.lo && cell <= spec.hi;
+    case "range+discrete":
+      return cell >= spec.lo && cell <= spec.hi || cell === spec.value;
+    default:
+      return false;
+  }
+}
+function isMissing(cell, spec) {
+  if (typeof cell === "number") return numberMatches(cell, spec);
+  if (typeof cell === "string") return spec.kind === "strings" && spec.values.includes(cell);
+  return false;
+}
+function applyUserMissing(sheet) {
+  const specs = sheet.variables.map((v) => v.missing);
+  const rows = sheet.rows.map(
+    (row) => row.map((cell, col) => isMissing(cell, specs[col]) ? null : cell)
+  );
+  return { ...sheet, rows };
+}
+
+// src/sav/binary.ts
+var Cursor = class {
+  view;
+  pos = 0;
+  little = true;
+  constructor(buf) {
+    this.view = new DataView(buf);
+  }
+  get length() {
+    return this.view.byteLength;
+  }
+  seek(p) {
+    this.pos = p;
+  }
+  skip(n) {
+    this.pos += n;
+  }
+  readI32() {
+    const v = this.view.getInt32(this.pos, this.little);
+    this.pos += 4;
+    return v;
+  }
+  readF64() {
+    const v = this.view.getFloat64(this.pos, this.little);
+    this.pos += 8;
+    return v;
+  }
+  readBytes(n) {
+    if (n < 0 || this.pos + n > this.length) {
+      throw new SavError(`read of ${n} bytes exceeds the file`);
+    }
+    const out = new Uint8Array(n);
+    out.set(new Uint8Array(this.view.buffer, this.view.byteOffset + this.pos, n));
+    this.pos += n;
+    return out;
+  }
+  readStr(n, dec) {
+    return dec.decode(this.readBytes(n));
+  }
+};
+
+// src/sav/dates.ts
+var DATE_FORMAT_TYPES = /* @__PURE__ */ new Set([20, 22, 23, 24, 28, 29, 30, 38, 39]);
+var SPSS_EPOCH_OFFSET_SECONDS = 12219379200;
+function isDateFormat(type) {
+  return DATE_FORMAT_TYPES.has(type);
+}
+function spssToDate(seconds) {
+  return new Date((seconds - SPSS_EPOCH_OFFSET_SECONDS) * 1e3);
+}
+
+// src/sav/cases.ts
+function toBunEncoding(enc) {
+  const e = enc.toLowerCase();
+  if (e.includes("1252") || e.includes("ansi") || e.includes("8859") || e.includes("latin")) {
+    return "windows-1252";
+  }
+  if (e.includes("16")) return "utf-16";
+  return "utf-8";
+}
+function readSegment(alloc, source) {
+  const chunks = Math.max(1, Math.ceil(alloc / 8));
+  const raw = new Uint8Array(chunks * 8);
+  for (let c = 0; c < chunks; c++) raw.set(source.nextString8(), c * 8);
+  return raw.subarray(0, alloc);
+}
+function readStringValue(segments, source, dec) {
+  const parts = [];
+  for (const alloc of segments) parts.push(readSegment(alloc, source));
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const all = new Uint8Array(total);
+  let ofs = 0;
+  for (const p of parts) {
+    all.set(p, ofs);
+    ofs += p.length;
+  }
+  return dec.decode(all).replace(/ +$/, "");
+}
+function readNumericCell(variable, source) {
+  const v = source.nextNumeric();
+  if (v !== null && variable.format.isDate) return spssToDate(v);
+  return v;
+}
+function readCell(plan, source, dec) {
+  if (plan.segments.length > 0) return readStringValue(plan.segments, source, dec);
+  return readNumericCell(plan.variable, source);
+}
+function readCases(header, plans, dictInfo, source, limits) {
+  const dec = new TextDecoder(toBunEncoding(dictInfo.encoding));
+  const rows = [];
+  if (header.ncases >= 0) {
+    for (let i = 0; i < header.ncases; i++) {
+      rows.push(plans.map((plan) => readCell(plan, source, dec)));
+    }
+    return rows;
+  }
+  while (!source.atEnd()) {
+    rows.push(plans.map((plan) => readCell(plan, source, dec)));
+    if (rows.length * plans.length > limits.maxCells) {
+      throw new SavError("case count exceeds cell limit");
+    }
+  }
+  return rows;
+}
+
+// src/sav/variable.ts
+var VALID_NMISSING = /* @__PURE__ */ new Set([-3, -2, 0, 1, 2, 3]);
+function decodeFormat(packed, isDate = () => false) {
+  const decimals = packed & 255;
+  const width = packed >> 8 & 255;
+  const type = packed >> 16 & 255;
+  return { type, width, decimals, isDate: isDate(type) };
+}
+function decodeMissing(n, values) {
+  if (n === 0) return { kind: "none" };
+  if (n > 0) return { kind: "discrete", values };
+  if (n === -2) return { kind: "range", lo: values[0], hi: values[1] };
+  return { kind: "range+discrete", lo: values[0], hi: values[1], value: values[2] };
+}
+function readMissing(cur, nMissing, type, dec) {
+  const count = Math.abs(nMissing);
+  if (type > 0) {
+    const values = [];
+    for (let i = 0; i < count; i++) values.push(cur.readStr(8, dec).replace(/ +$/, ""));
+    return count > 0 ? { kind: "strings", values } : { kind: "none" };
+  }
+  const nums = [];
+  for (let i = 0; i < count; i++) nums.push(cur.readF64());
+  return decodeMissing(nMissing, nums);
+}
+function readVariableRecord(cur, dec) {
+  const type = cur.readI32();
+  if (type === -1) {
+    cur.skip(24);
+    return "continuation";
+  }
+  const hasLabel = cur.readI32();
+  const nMissing = cur.readI32();
+  if (!VALID_NMISSING.has(nMissing)) throw new SavError("invalid missing-value count");
+  const print = decodeFormat(cur.readI32());
+  const write = decodeFormat(cur.readI32());
+  const name = cur.readStr(8, dec).replace(/[\s\0]+$/, "");
+  let label;
+  if (hasLabel) {
+    const labelLen = cur.readI32();
+    label = cur.readStr(labelLen, dec);
+    cur.skip((4 - labelLen % 4) % 4);
+  }
+  const missing = readMissing(cur, nMissing, type, dec);
+  return { name, type, label, missing, print, write };
+}
+
+// src/sav/dictionary.ts
+var MAX_DICT_RECORDS = 1e7;
+var MAX_DOC_LINES = 1e5;
+var PROVISIONAL = new TextDecoder("utf-8");
+function readValueLabelSet(cur) {
+  const count = cur.readI32();
+  const labels = [];
+  for (let i = 0; i < count; i++) {
+    const raw = cur.readBytes(8);
+    const labelLen = cur.readBytes(1)[0];
+    const labelRaw = cur.readBytes(labelLen);
+    cur.skip((8 - (1 + labelLen) % 8) % 8);
+    labels.push({ raw, labelRaw });
+  }
+  return { labels, varIndexes: [] };
+}
+function readExtension(cur) {
+  const subtype = cur.readI32();
+  const size = cur.readI32();
+  const count = cur.readI32();
+  return { subtype, size, count, bytes: cur.readBytes(size * count) };
+}
+function handleVariable(cur, state) {
+  const physIdx = state.physicalPos;
+  state.physicalPos += 1;
+  const v = readVariableRecord(cur, PROVISIONAL);
+  if (v !== "continuation") {
+    state.variables.push(v);
+    state.physicalIndexes.push(physIdx);
+  }
+}
+function handleValueLabels(cur, state) {
+  state.pending = readValueLabelSet(cur);
+  state.valueLabelSets.push(state.pending);
+}
+function handleVarIndexes(cur, state) {
+  const count = cur.readI32();
+  const idx = [];
+  for (let i = 0; i < count; i++) idx.push(cur.readI32());
+  if (state.pending) state.pending.varIndexes = idx;
+}
+function handleDocument(cur) {
+  const nLines = cur.readI32();
+  if (nLines < 0 || nLines > MAX_DOC_LINES) throw new SavError("invalid document record");
+  cur.skip(nLines * 80);
+}
+function handleExtension(cur, state) {
+  state.extensions.push(readExtension(cur));
+}
+var HANDLERS = {
+  2: handleVariable,
+  3: handleValueLabels,
+  4: handleVarIndexes,
+  6: handleDocument,
+  7: handleExtension
+};
+function readDictionary(cur) {
+  const state = {
+    variables: [],
+    physicalIndexes: [],
+    physicalPos: 1,
+    valueLabelSets: [],
+    extensions: []
+  };
+  for (let records = 0; ; records++) {
+    if (records > MAX_DICT_RECORDS) throw new SavError("too many dictionary records");
+    const prev = cur.pos;
+    const recType = cur.readI32();
+    if (recType === 999) {
+      cur.readI32();
+      break;
+    }
+    const handler = HANDLERS[recType];
+    if (!handler) throw new Error(`Unknown SPSS dictionary record type: ${recType}`);
+    handler(cur, state);
+    if (cur.pos <= prev) throw new SavError("dictionary made no progress");
+  }
+  return {
+    variables: state.variables,
+    physicalIndexes: state.physicalIndexes,
+    valueLabelSets: state.valueLabelSets,
+    extensions: state.extensions
+  };
+}
+
+// src/sav/extensions.ts
+var UTF8 = new TextDecoder("utf-8");
+function viewOf(bytes) {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function eachPair(tokens, apply) {
+  for (const token of tokens) {
+    const eq = token.indexOf("=");
+    if (eq > 0) apply(token.slice(0, eq), token.slice(eq + 1));
+  }
+}
+function parseLongNames(bytes, out) {
+  eachPair(UTF8.decode(bytes).split("	"), (key, value) => out.set(key, value));
+}
+function parseVeryLong(bytes, out) {
+  const tokens = UTF8.decode(bytes).split("\0").flatMap((chunk) => chunk.split("	"));
+  eachPair(tokens, (key, value) => out.set(key, Number(value)));
+}
+function measureName(code) {
+  if (code === 1) return "nominal";
+  if (code === 2) return "ordinal";
+  if (code === 3) return "scale";
+  return "unknown";
+}
+function parseMeasures(record, little) {
+  const view = viewOf(record.bytes);
+  const measures = [];
+  const triples = Math.floor(record.count / 3);
+  for (let t = 0; t < triples; t++) {
+    if (t * 12 + 12 > record.bytes.length) break;
+    measures.push(measureName(view.getInt32(t * 12, little)));
+  }
+  return measures;
+}
+function applyRecord(record, little, info) {
+  switch (record.subtype) {
+    case 20:
+      info.encoding = UTF8.decode(record.bytes).trim();
+      break;
+    case 4:
+      info.sysmis = viewOf(record.bytes).getFloat64(0, little);
+      break;
+    case 13:
+      parseLongNames(record.bytes, info.longNames);
+      break;
+    case 14:
+      parseVeryLong(record.bytes, info.veryLong);
+      break;
+    case 11:
+      info.measures = parseMeasures(record, little);
+      break;
+  }
+}
+function applyExtensions(raw, little) {
+  const info = {
+    encoding: "utf-8",
+    sysmis: -Number.MAX_VALUE,
+    longNames: /* @__PURE__ */ new Map(),
+    veryLong: /* @__PURE__ */ new Map(),
+    measures: []
+  };
+  for (const record of raw.extensions) applyRecord(record, little, info);
+  return info;
+}
+
+// src/sav/header.ts
+var ASCII = new TextDecoder("windows-1252");
+function asCompression(v) {
+  if (v === 0 || v === 1 || v === 2) return v;
+  throw new Error(`Unsupported SPSS compression flag: ${v}`);
+}
+function readHeader(cur) {
+  if (cur.length < 176) throw new SavError("file too small to be a .sav");
+  const magic = cur.readStr(4, ASCII);
+  if (magic !== "$FL2" && magic !== "$FL3") throw new Error("Not an SPSS system file (bad magic)");
+  cur.little = cur.view.getInt32(64, true) === 2 || cur.view.getInt32(64, true) === 3;
+  cur.seek(64);
+  cur.readI32();
+  cur.readI32();
+  const compression = asCompression(cur.readI32());
+  cur.readI32();
+  const ncases = cur.readI32();
+  const bias = cur.readF64();
+  cur.skip(9 + 8);
+  const fileLabel = cur.readStr(64, ASCII).replace(/[\s\0]+$/, "");
+  cur.skip(3);
+  return { zlib: magic === "$FL3", compression, bias, ncases, fileLabel };
+}
+
+// src/sav/source.ts
+function filled(byte) {
+  return new Uint8Array(8).fill(byte);
+}
+var UncompressedSource = class {
+  constructor(cur, sysmis) {
+    this.cur = cur;
+    this.sysmis = sysmis;
+  }
+  cur;
+  sysmis;
+  nextNumeric() {
+    const v = this.cur.readF64();
+    return v === this.sysmis ? null : v;
+  }
+  nextString8() {
+    return this.cur.readBytes(8);
+  }
+  atEnd() {
+    return this.cur.pos + 8 > this.cur.length;
+  }
+};
+var RleSource = class {
+  // a control code peeked by atEnd(), not yet spent on a cell
+  constructor(cur, bias) {
+    this.cur = cur;
+    this.bias = bias;
+  }
+  cur;
+  bias;
+  codes = new Uint8Array(8);
+  idx = 8;
+  // ≥ 8 forces an octet refill on the first pull
+  lookahead = null;
+  /** Pull the next raw octet code. Synthesizes 252 (end-of-data) once the stream is exhausted, so an
+   * unknown-case-count read (`ncases = -1`) terminates on atEnd() instead of over-reading past EOF. */
+  rawCode() {
+    if (this.idx >= 8) {
+      if (this.cur.pos >= this.cur.length) return 252;
+      this.codes = this.cur.readBytes(8);
+      this.idx = 0;
+    }
+    return this.codes[this.idx++];
+  }
+  /** Next cell-bearing control code: drains any peeked code, then skips 0 fillers (they encode no
+   * cell — proven by the labels_order oracle fixture's inter-row octet padding). */
+  nextCode() {
+    if (this.lookahead !== null) {
+      const code = this.lookahead;
+      this.lookahead = null;
+      return code;
+    }
+    for (; ; ) {
+      const code = this.rawCode();
+      if (code !== 0) return code;
+    }
+  }
+  atEnd() {
+    if (this.lookahead === null) this.lookahead = this.nextCode();
+    return this.lookahead === 252;
+  }
+  nextNumeric() {
+    const code = this.nextCode();
+    if (code === 252 || code === 255) return null;
+    if (code === 253) return this.cur.readF64();
+    return code - this.bias;
+  }
+  nextString8() {
+    const code = this.nextCode();
+    if (code === 254) return filled(32);
+    if (code === 253) return this.cur.readBytes(8);
+    return filled(32);
+  }
+};
+function readI64(cur) {
+  const v = cur.view.getBigInt64(cur.pos, cur.little);
+  cur.pos += 8;
+  return Number(v);
+}
+function concatToBuffer(parts) {
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const buf = new ArrayBuffer(total);
+  const out = new Uint8Array(buf);
+  let ofs = 0;
+  for (const p of parts) {
+    out.set(p, ofs);
+    ofs += p.length;
+  }
+  return buf;
+}
+async function inflateDeflate(compressed, maxBytes) {
+  const bytes = new Uint8Array(compressed.length);
+  bytes.set(compressed);
+  const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream("deflate"));
+  const reader = stream.getReader();
+  const parts = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel();
+      throw new SavError("ZSAV inflated output exceeds limit");
+    }
+    parts.push(value);
+  }
+  return new Uint8Array(concatToBuffer(parts));
+}
+function readTrailerBlocks(cur, ztrailerOfs) {
+  cur.seek(ztrailerOfs);
+  readI64(cur);
+  readI64(cur);
+  cur.readI32();
+  const nBlocks = cur.readI32();
+  if (nBlocks < 0 || nBlocks > 1e6) throw new SavError("ZSAV block count out of range");
+  const blocks = [];
+  for (let i = 0; i < nBlocks; i++) {
+    readI64(cur);
+    const compressedOfs = readI64(cur);
+    cur.readI32();
+    blocks.push({ compressedOfs, compressedSize: cur.readI32() });
+  }
+  return blocks;
+}
+function makeSource(cur, header, sysmis) {
+  if (header.compression === 0) return new UncompressedSource(cur, sysmis);
+  return new RleSource(cur, header.bias);
+}
+async function inflateZsav(cur, maxInflatedBytes) {
+  readI64(cur);
+  const ztrailerOfs = readI64(cur);
+  readI64(cur);
+  const blocks = readTrailerBlocks(cur, ztrailerOfs);
+  const parts = [];
+  let total = 0;
+  for (const block of blocks) {
+    cur.seek(block.compressedOfs);
+    const inflated = await inflateDeflate(
+      cur.readBytes(block.compressedSize),
+      maxInflatedBytes - total
+    );
+    total += inflated.length;
+    parts.push(inflated);
+  }
+  return concatToBuffer(parts);
+}
+
+// src/sav/reader.ts
+function rawToF64(raw, little) {
+  return new DataView(raw.buffer, raw.byteOffset, 8).getFloat64(0, little);
+}
+function valueLabelsFor(physicalIndex, isString, sets, little, dec) {
+  const out = [];
+  for (const set of sets) {
+    if (!set.varIndexes.includes(physicalIndex)) continue;
+    for (const entry of set.labels) {
+      const value = isString ? dec.decode(entry.raw).replace(/ +$/, "") : rawToF64(entry.raw, little);
+      out.push({ value, label: dec.decode(entry.labelRaw).replace(/\0+$/, "") });
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
+function baseVariable(rawVar, index, info) {
+  return {
+    name: info.longNames.get(rawVar.name) ?? rawVar.name,
+    type: rawVar.type > 0 ? "string" : "numeric",
+    missing: rawVar.missing,
+    format: { ...rawVar.print, isDate: isDateFormat(rawVar.print.type) },
+    measure: info.measures[index] ?? "unknown"
+  };
+}
+function buildVariable(rawVar, index, physicalIndex, ctx) {
+  const isString = rawVar.type > 0;
+  const variable = baseVariable(rawVar, index, ctx.info);
+  if (rawVar.label !== void 0) variable.label = rawVar.label;
+  if (isString) variable.width = rawVar.type;
+  const valueLabels = valueLabelsFor(physicalIndex, isString, ctx.sets, ctx.little, ctx.dec);
+  if (valueLabels) variable.valueLabels = valueLabels;
+  return variable;
+}
+function segmentWidths(raw, start, realWidth) {
+  const n = Math.ceil(realWidth / 252);
+  const widths = [];
+  for (let s = 0; s < n && start + s < raw.variables.length; s++) {
+    widths.push(raw.variables[start + s].type);
+  }
+  return widths;
+}
+function buildPlans(raw, ctx) {
+  const plans = [];
+  let i = 0;
+  while (i < raw.variables.length) {
+    const rawVar = raw.variables[i];
+    const variable = buildVariable(rawVar, i, raw.physicalIndexes[i], ctx);
+    const realWidth = rawVar.type > 0 ? ctx.info.veryLong.get(rawVar.name) : void 0;
+    if (realWidth === void 0) {
+      plans.push({ variable, segments: rawVar.type > 0 ? [rawVar.type] : [] });
+      i += 1;
+      continue;
+    }
+    const segments = segmentWidths(raw, i, realWidth);
+    variable.width = realWidth;
+    plans.push({ variable, segments });
+    i += segments.length;
+  }
+  return plans;
+}
+async function readSav(buf, opts) {
+  const limits = { ...DEFAULT_LIMITS, ...opts };
+  let cur = new Cursor(buf);
+  const header = readHeader(cur);
+  const raw = readDictionary(cur);
+  const info = applyExtensions(raw, cur.little);
+  const little = cur.little;
+  const dec = new TextDecoder(toBunEncoding(info.encoding));
+  const plans = buildPlans(raw, { info, sets: raw.valueLabelSets, little, dec });
+  const variables = plans.map((plan) => plan.variable);
+  if (variables.length === 0) throw new SavError("file has no variables");
+  if (header.ncases >= 0 && header.ncases * variables.length > limits.maxCells) {
+    throw new SavError(
+      `case count ${header.ncases} \xD7 ${variables.length} vars exceeds cell limit ${limits.maxCells}`
+    );
+  }
+  if (header.zlib) {
+    const data = await inflateZsav(cur, limits.maxInflatedBytes);
+    cur = new Cursor(data);
+    cur.little = little;
+  }
+  const source = makeSource(cur, header, info.sysmis);
+  const rows = readCases(header, plans, info, source, limits);
+  return { format: "sav", encoding: info.encoding, sheets: [{ name: "data", variables, rows }] };
+}
+
+export { DEFAULT_LIMITS, SavError, applyUserMissing, readSav };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/limits.ts","../src/missing.ts","../src/sav/binary.ts","../src/sav/dates.ts","../src/sav/cases.ts","../src/sav/variable.ts","../src/sav/dictionary.ts","../src/sav/extensions.ts","../src/sav/header.ts","../src/sav/source.ts","../src/sav/reader.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/** Thrown for any malformed or hostile `.sav` input that a resource bound rejects — a bad file, not\n * a reader bug. Distinct from the plain `Error`s raised for unsupported-but-valid constructs so a\n * caller can `catch` an attack (OOM/hang avoidance) separately if it wants to. */\nexport class SavError extends Error {}\n\n/** Resource ceilings that keep a hostile `.sav` from exhausting memory or looping unboundedly. The\n * defaults are generous, so no well-formed file is affected; pass a stricter `readSav(buf, opts)` in\n * memory-constrained environments. */\nexport type SavLimits = {\n  /** Maximum `ncases × nvars` data cells the reader will materialize (~500k rows × 100 vars). */\n  maxCells: number;\n  /** Cumulative inflate output ceiling: total bytes a ZSAV may inflate to before the reader aborts (512 MiB). */\n  maxInflatedBytes: number;\n};\n\nexport const DEFAULT_LIMITS: SavLimits = {\n  maxCells: 50_000_000,\n  maxInflatedBytes: 512 * 1024 * 1024,\n};\n","import type { CellValue, MissingSpec, Sheet } from \"./types\";\n\n/** True when the numeric `cell` matches a numeric `spec` (discrete / range / range+discrete). */\nfunction numberMatches(cell: number, spec: MissingSpec): boolean {\n  switch (spec.kind) {\n    case \"discrete\":\n      return spec.values.includes(cell);\n    case \"range\":\n      return cell >= spec.lo && cell <= spec.hi;\n    case \"range+discrete\":\n      return (cell >= spec.lo && cell <= spec.hi) || cell === spec.value;\n    default:\n      return false; // \"none\" | \"strings\" never match a number\n  }\n}\n\n/**\n * True when `cell` matches the variable's declared user-missing `spec`.\n * Only plain numbers/strings can match; a `Date` or already-`null` cell never does.\n */\nfunction isMissing(cell: CellValue, spec: MissingSpec): boolean {\n  if (typeof cell === \"number\") return numberMatches(cell, spec);\n  if (typeof cell === \"string\") return spec.kind === \"strings\" && spec.values.includes(cell);\n  return false;\n}\n\n/**\n * Return a new {@link Sheet} in which every cell matching its variable's\n * declared {@link MissingSpec} is replaced by `null` (user-missing → system-missing).\n * Non-mutating: fresh `rows` and fresh inner arrays; the input is left untouched.\n */\nexport function applyUserMissing(sheet: Sheet): Sheet {\n  const specs = sheet.variables.map((v) => v.missing);\n  const rows = sheet.rows.map((row) =>\n    row.map((cell, col) => (isMissing(cell, specs[col]) ? null : cell)),\n  );\n  return { ...sheet, rows };\n}\n","import { SavError } from \"../limits\";\n\n/** Endian-aware sequential reader over a DataView. `little` is set by the header's layout-code probe. */\nexport class Cursor {\n  readonly view: DataView;\n  pos = 0;\n  little = true;\n\n  constructor(buf: ArrayBuffer) {\n    this.view = new DataView(buf);\n  }\n\n  get length(): number {\n    return this.view.byteLength;\n  }\n\n  seek(p: number): void {\n    this.pos = p;\n  }\n\n  skip(n: number): void {\n    this.pos += n;\n  }\n\n  readI32(): number {\n    const v = this.view.getInt32(this.pos, this.little);\n    this.pos += 4;\n    return v;\n  }\n\n  readF64(): number {\n    const v = this.view.getFloat64(this.pos, this.little);\n    this.pos += 8;\n    return v;\n  }\n\n  readBytes(n: number): Uint8Array {\n    // Bound every allocation to the bytes actually remaining: a hostile length field (`size*count`,\n    // `labelLen`, `compressedSize`, …) can claim gigabytes, so refuse BEFORE `new Uint8Array(n)`.\n    if (n < 0 || this.pos + n > this.length) {\n      throw new SavError(`read of ${n} bytes exceeds the file`);\n    }\n    const out = new Uint8Array(n);\n    out.set(new Uint8Array(this.view.buffer, this.view.byteOffset + this.pos, n));\n    this.pos += n;\n    return out;\n  }\n\n  readStr(n: number, dec: TextDecoder): string {\n    return dec.decode(this.readBytes(n));\n  }\n}\n","// SPSS format-type codes whose stored seconds-since-epoch map to a CALENDAR date/datetime:\n// DATE 20, DATETIME 22, ADATE 23, JDATE 24, MOYR 28, QYR 29, WKYR 30, EDATE 38, SDATE 39.\n// Deliberately EXCLUDED (they store seconds/counts but are not calendar dates, and haven decodes\n// them as durations / labelled numerics, not dates): TIME 21, DTIME 25, WKDAY 26, MONTH 27.\n// haven writes as.Date → 20 and as.POSIXct → 22 (verified against the dates fixture).\nconst DATE_FORMAT_TYPES = new Set([20, 22, 23, 24, 28, 29, 30, 38, 39]);\n\n// Seconds between the SPSS epoch (1582-10-14 00:00, the Gregorian calendar reform) and the Unix epoch.\nconst SPSS_EPOCH_OFFSET_SECONDS = 12219379200;\n\n/** True for the SPSS date/datetime format types whose stored seconds map to a calendar date. */\nexport function isDateFormat(type: number): boolean {\n  return DATE_FORMAT_TYPES.has(type);\n}\n\n/** Convert an SPSS date value (seconds since 1582-10-14) to a JS `Date`. */\nexport function spssToDate(seconds: number): Date {\n  return new Date((seconds - SPSS_EPOCH_OFFSET_SECONDS) * 1000);\n}\n","import type { SavLimits } from \"../limits\";\nimport type { CellValue, Variable } from \"../types\";\nimport type { DictInfo } from \"./extensions\";\nimport type { SavHeader } from \"./header\";\nimport type { ValueSource } from \"./source\";\n\nimport { SavError } from \"../limits\";\nimport { spssToDate } from \"./dates\";\n\n/** A variable paired with the physical segment layout the case reader needs. `segments` holds the\n * allocated byte widths of the string segments to read and concatenate — one entry for a normal\n * string (≤ 255), N entries for a very-long string reassembled from N segments; empty for numerics. */\nexport type VariablePlan = {\n  variable: Variable;\n  segments: number[];\n};\n\n/** Map the file's declared charset name onto the three TextDecoder labels Bun's types accept\n * (`Bun.Encoding`): a plain `string` isn't assignable, so collapse it here without an `as` cast.\n * (The three-way mapping is validated by Task 9's encoding fixtures.) */\nexport function toBunEncoding(enc: string): \"utf-8\" | \"windows-1252\" | \"utf-16\" {\n  const e = enc.toLowerCase();\n  if (e.includes(\"1252\") || e.includes(\"ansi\") || e.includes(\"8859\") || e.includes(\"latin\")) {\n    return \"windows-1252\";\n  }\n  if (e.includes(\"16\")) return \"utf-16\";\n  return \"utf-8\";\n}\n\n/** Read one string segment: `ceil(alloc/8)` 8-byte chunks, keeping only the segment's first `alloc`\n * content bytes. The chunk padding past `alloc` is inter-segment filler (a partial trailing 8-byte\n * unit) that must NOT survive into the concatenation of a very-long string's segments. */\nfunction readSegment(alloc: number, source: ValueSource): Uint8Array {\n  const chunks = Math.max(1, Math.ceil(alloc / 8));\n  const raw = new Uint8Array(chunks * 8);\n  for (let c = 0; c < chunks; c++) raw.set(source.nextString8(), c * 8);\n  return raw.subarray(0, alloc);\n}\n\n/** A string cell is one or more segments concatenated at the BYTE level (very-long strings span\n * several), decoded once with the file encoding (so a multi-byte char split across a segment\n * boundary survives), then stripped of SPSS's trailing-space padding. */\nfunction readStringValue(segments: number[], source: ValueSource, dec: TextDecoder): string {\n  const parts: Uint8Array[] = [];\n  for (const alloc of segments) parts.push(readSegment(alloc, source));\n  const total = parts.reduce((n, p) => n + p.length, 0);\n  const all = new Uint8Array(total);\n  let ofs = 0;\n  for (const p of parts) {\n    all.set(p, ofs);\n    ofs += p.length;\n  }\n  return dec.decode(all).replace(/ +$/, \"\");\n}\n\n/** A numeric cell is one f64; system-missing stays `null`, a date format maps its seconds to a Date. */\nfunction readNumericCell(variable: Variable, source: ValueSource): CellValue {\n  const v = source.nextNumeric();\n  if (v !== null && variable.format.isDate) return spssToDate(v);\n  return v;\n}\n\nfunction readCell(plan: VariablePlan, source: ValueSource, dec: TextDecoder): CellValue {\n  if (plan.segments.length > 0) return readStringValue(plan.segments, source, dec);\n  return readNumericCell(plan.variable, source);\n}\n\n/** Read the flat data section into rows, one cell per plan in dictionary order. When the header\n * carries a real case count (`ncases >= 0`) exactly that many rows are read; when it is unknown\n * (`ncases = -1`, which real SPSS writes — e.g. the user's GenAI.sav — even though haven never does)\n * rows are read until the source reaches the end-of-data marker. */\nexport function readCases(\n  header: SavHeader,\n  plans: VariablePlan[],\n  dictInfo: DictInfo,\n  source: ValueSource,\n  limits: SavLimits,\n): CellValue[][] {\n  const dec = new TextDecoder(toBunEncoding(dictInfo.encoding));\n  const rows: CellValue[][] = [];\n  if (header.ncases >= 0) {\n    // Bounded upfront by readSav's `ncases × nvars ≤ maxCells` check before we get here.\n    for (let i = 0; i < header.ncases; i++) {\n      rows.push(plans.map((plan) => readCell(plan, source, dec)));\n    }\n    return rows;\n  }\n  while (!source.atEnd()) {\n    rows.push(plans.map((plan) => readCell(plan, source, dec)));\n    // The unknown-count path has no header ceiling — cap materialized cells so a crafted\n    // never-ending stream can't grow `rows` without bound.\n    if (rows.length * plans.length > limits.maxCells) {\n      throw new SavError(\"case count exceeds cell limit\");\n    }\n  }\n  return rows;\n}\n","import type { MissingSpec, SpssFormat } from \"../types\";\nimport type { Cursor } from \"./binary\";\n\nimport { SavError } from \"../limits\";\n\n// The only n_missing_values SPSS emits: 0 none · 1..3 discrete · -2 range · -3 range+one discrete.\n// Anything else (a bogus 1000, or Math.abs(-2147483648) staying hugely negative) would drive\n// readMissing to read count-many slots past the buffer, so it is rejected outright.\nconst VALID_NMISSING = new Set([-3, -2, 0, 1, 2, 3]);\n\nexport type RawVariable = {\n  name: string;\n  type: number;\n  label?: string;\n  missing: MissingSpec;\n  print: SpssFormat;\n  write: SpssFormat;\n};\n\n/** Unpack SPSS's 3-byte format code: byte0 decimals, byte1 width, byte2 type. `isDate` stays a\n * defaulted pure predicate so this module needs no forward dep on date detection (wired in Task 8). */\nexport function decodeFormat(\n  packed: number,\n  isDate: (t: number) => boolean = () => false,\n): SpssFormat {\n  const decimals = packed & 0xff;\n  const width = (packed >> 8) & 0xff;\n  const type = (packed >> 16) & 0xff;\n  return { type, width, decimals, isDate: isDate(type) };\n}\n\n/** Map n_missing_values to a MissingSpec: 0 none · >0 discrete · -2 range · -3 range+one discrete. */\nexport function decodeMissing(n: number, values: number[]): MissingSpec {\n  if (n === 0) return { kind: \"none\" };\n  if (n > 0) return { kind: \"discrete\", values };\n  if (n === -2) return { kind: \"range\", lo: values[0], hi: values[1] };\n  return { kind: \"range+discrete\", lo: values[0], hi: values[1], value: values[2] };\n}\n\n/** Read a variable's `|n_missing|` trailing missing-value slots. A string variable (width > 0) stores\n * each as an 8-byte right-space-padded string; a numeric variable stores each as an f64 (and negative\n * counts select range / range+discrete). String missing counts are always positive (no ranges).\n * String slots are decoded with `dec` (the dictionary-time provisional decoder — ASCII-safe for the\n * short sentinels SPSS allows here; a non-ASCII string sentinel would need the file encoding). */\nfunction readMissing(cur: Cursor, nMissing: number, type: number, dec: TextDecoder): MissingSpec {\n  const count = Math.abs(nMissing);\n  if (type > 0) {\n    const values: string[] = [];\n    for (let i = 0; i < count; i++) values.push(cur.readStr(8, dec).replace(/ +$/, \"\"));\n    return count > 0 ? { kind: \"strings\", values } : { kind: \"none\" };\n  }\n  const nums: number[] = [];\n  for (let i = 0; i < count; i++) nums.push(cur.readF64());\n  return decodeMissing(nMissing, nums);\n}\n\n/** Read one type-2 variable record. The cursor starts at the `type` field (the leading rec_type=2\n * int is consumed by the dictionary loop). Returns `\"continuation\"` for a long-string overflow\n * segment (type === -1): its body (has_label, n_missing, print, write, name — all zero/blank per\n * spec) still occupies the fixed 24 trailing bytes, which MUST be consumed or the loop desyncs. */\nexport function readVariableRecord(cur: Cursor, dec: TextDecoder): RawVariable | \"continuation\" {\n  const type = cur.readI32();\n  if (type === -1) {\n    cur.skip(24); // has_label(4) + n_missing(4) + print(4) + write(4) + name(8), all ignored\n    return \"continuation\";\n  }\n  const hasLabel = cur.readI32();\n  const nMissing = cur.readI32();\n  if (!VALID_NMISSING.has(nMissing)) throw new SavError(\"invalid missing-value count\");\n  const print = decodeFormat(cur.readI32());\n  const write = decodeFormat(cur.readI32());\n  const name = cur.readStr(8, dec).replace(/[\\s\\0]+$/, \"\"); // SPSS pads short names with NUL or space\n  let label: string | undefined;\n  if (hasLabel) {\n    const labelLen = cur.readI32();\n    label = cur.readStr(labelLen, dec);\n    cur.skip((4 - (labelLen % 4)) % 4);\n  }\n  const missing = readMissing(cur, nMissing, type, dec);\n  return { name, type, label, missing, print, write };\n}\n","import type { Cursor } from \"./binary\";\nimport type { RawVariable } from \"./variable\";\n\nimport { SavError } from \"../limits\";\nimport { readVariableRecord } from \"./variable\";\n\n// A dictionary record is at least the 4-byte rec_type, so a well-formed file never approaches this;\n// the backstop only fires on a hostile stream that never reaches the type-999 terminator.\nconst MAX_DICT_RECORDS = 10_000_000;\n// SPSS documents are a handful of 80-char lines; a negative or absurd count is a malformed record and\n// (negative) would make `skip` — the one cursor primitive that can move backward — rewind the loop.\nconst MAX_DOC_LINES = 100_000;\n\nexport type RawValueLabel = { raw: Uint8Array; labelRaw: Uint8Array };\nexport type RawValueLabelSet = { labels: RawValueLabel[]; varIndexes: number[] };\nexport type RawExtension = { subtype: number; size: number; count: number; bytes: Uint8Array };\n\nexport type RawDict = {\n  variables: RawVariable[];\n  /** For each kept variable (same order as `variables`), its 1-based PHYSICAL dictionary position —\n   * i.e. counting the type=-1 string-continuation records that `variables` drops. Type-4 value-label\n   * variable indexes are physical, so labels must be matched against this, not the logical index. */\n  physicalIndexes: number[];\n  valueLabelSets: RawValueLabelSet[];\n  extensions: RawExtension[];\n};\n\ntype DictState = {\n  variables: RawVariable[];\n  physicalIndexes: number[];\n  physicalPos: number; // 1-based position of the NEXT variable record (real or continuation)\n  valueLabelSets: RawValueLabelSet[];\n  extensions: RawExtension[];\n  pending?: RawValueLabelSet;\n};\n\n// The file's true encoding isn't known until the extension records are parsed (Task 6). Variable\n// names are ASCII, so this provisional UTF-8 decoder is enough here; value bytes AND label bytes are\n// kept raw and decoded downstream with the real file encoding (reader.ts).\nconst PROVISIONAL = new TextDecoder(\"utf-8\");\n\n/** Read one type-3 value-label record: an i32 count then `count` × (8 raw value bytes + a u8 label\n * length + label bytes), each entry padded so `(1 + label_len)` rounds up to a multiple of 8. The\n * raw value AND label bytes are kept undecoded — the value's numeric-vs-string kind is resolved by\n * the owning variable, and both are decoded with the file encoding in reader.ts. */\nfunction readValueLabelSet(cur: Cursor): RawValueLabelSet {\n  const count = cur.readI32();\n  const labels: RawValueLabel[] = [];\n  for (let i = 0; i < count; i++) {\n    const raw = cur.readBytes(8);\n    const labelLen = cur.readBytes(1)[0];\n    const labelRaw = cur.readBytes(labelLen);\n    cur.skip((8 - ((1 + labelLen) % 8)) % 8);\n    labels.push({ raw, labelRaw });\n  }\n  return { labels, varIndexes: [] };\n}\n\n/** Read one type-7 extension record's header (subtype, element size, count) and capture its\n * `size*count`-byte payload verbatim for Task 6 to interpret by subtype. */\nfunction readExtension(cur: Cursor): RawExtension {\n  const subtype = cur.readI32();\n  const size = cur.readI32();\n  const count = cur.readI32();\n  return { subtype, size, count, bytes: cur.readBytes(size * count) };\n}\n\nfunction handleVariable(cur: Cursor, state: DictState): void {\n  const physIdx = state.physicalPos;\n  state.physicalPos += 1; // both real records and continuations advance the physical position\n  const v = readVariableRecord(cur, PROVISIONAL);\n  if (v !== \"continuation\") {\n    state.variables.push(v);\n    state.physicalIndexes.push(physIdx);\n  }\n}\n\nfunction handleValueLabels(cur: Cursor, state: DictState): void {\n  state.pending = readValueLabelSet(cur);\n  state.valueLabelSets.push(state.pending);\n}\n\n/** Type-4 record: an i32 count of 1-based variable indexes, attached to the preceding type-3 set. */\nfunction handleVarIndexes(cur: Cursor, state: DictState): void {\n  const count = cur.readI32();\n  const idx: number[] = [];\n  for (let i = 0; i < count; i++) idx.push(cur.readI32());\n  if (state.pending) state.pending.varIndexes = idx;\n}\n\n/** Type-6 document record: an i32 line count then `n_lines` × 80 bytes we discard. */\nfunction handleDocument(cur: Cursor): void {\n  const nLines = cur.readI32();\n  if (nLines < 0 || nLines > MAX_DOC_LINES) throw new SavError(\"invalid document record\");\n  cur.skip(nLines * 80);\n}\n\nfunction handleExtension(cur: Cursor, state: DictState): void {\n  state.extensions.push(readExtension(cur));\n}\n\nconst HANDLERS: Record<number, (cur: Cursor, state: DictState) => void> = {\n  2: handleVariable,\n  3: handleValueLabels,\n  4: handleVarIndexes,\n  6: handleDocument,\n  7: handleExtension,\n};\n\n/** Walk the SPSS dictionary from the cursor's position (byte 176) until the type-999 terminator,\n * collecting variables in order, value-label sets (each type-3 record plus its trailing type-4\n * index record), and raw type-7 extension records for Task 6; type-6 document records are skipped. */\nexport function readDictionary(cur: Cursor): RawDict {\n  const state: DictState = {\n    variables: [],\n    physicalIndexes: [],\n    physicalPos: 1,\n    valueLabelSets: [],\n    extensions: [],\n  };\n  for (let records = 0; ; records++) {\n    if (records > MAX_DICT_RECORDS) throw new SavError(\"too many dictionary records\");\n    const prev = cur.pos; // net cursor progress per record is the monotonic-advance guard below\n    const recType = cur.readI32();\n    if (recType === 999) {\n      cur.readI32(); // terminator filler\n      break;\n    }\n    const handler = HANDLERS[recType];\n    if (!handler) throw new Error(`Unknown SPSS dictionary record type: ${recType}`);\n    handler(cur, state);\n    // A handler that left the cursor at or behind where the record began (e.g. a backward `skip`)\n    // would spin the loop forever — reject the malformed record instead.\n    if (cur.pos <= prev) throw new SavError(\"dictionary made no progress\");\n  }\n  return {\n    variables: state.variables,\n    physicalIndexes: state.physicalIndexes,\n    valueLabelSets: state.valueLabelSets,\n    extensions: state.extensions,\n  };\n}\n","import type { Measure } from \"../types\";\nimport type { RawDict, RawExtension } from \"./dictionary\";\n\n/** The subset of the SPSS dictionary recovered from the type-7 extension records: the true text\n * encoding, the system-missing sentinel, the short→long variable-name map, the short→char-width map\n * for very-long strings, and the per-variable measurement level (positional, dictionary order). */\nexport type DictInfo = {\n  encoding: string;\n  sysmis: number;\n  longNames: Map<string, string>;\n  veryLong: Map<string, number>;\n  measures: Measure[];\n};\n\n// Every extension payload we read here is ASCII/UTF-8 (charset names, `SHORT=LongName` tokens). The\n// file's declared charset (subtype 20) is only READ as a name — never used to decode data yet.\nconst UTF8 = new TextDecoder(\"utf-8\");\n\n/** Wrap a record payload in an endian-aware DataView (the ints/floats use the file's byte order). */\nfunction viewOf(bytes: Uint8Array): DataView {\n  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n}\n\n/** Split `bytes` into `KEY=VALUE` tokens and hand each key/value to `apply`; empty/keyless skipped. */\nfunction eachPair(tokens: string[], apply: (key: string, value: string) => void): void {\n  for (const token of tokens) {\n    const eq = token.indexOf(\"=\");\n    if (eq > 0) apply(token.slice(0, eq), token.slice(eq + 1));\n  }\n}\n\n/** Subtype 13: tab-separated `SHORT=LongName` pairs. */\nfunction parseLongNames(bytes: Uint8Array, out: Map<string, string>): void {\n  eachPair(UTF8.decode(bytes).split(\"\\t\"), (key, value) => out.set(key, value));\n}\n\n/** Subtype 14: `SHORT=width` pairs delimited by NUL and/or tab. */\nfunction parseVeryLong(bytes: Uint8Array, out: Map<string, number>): void {\n  const tokens = UTF8.decode(bytes)\n    .split(\"\\0\")\n    .flatMap((chunk) => chunk.split(\"\\t\"));\n  eachPair(tokens, (key, value) => out.set(key, Number(value)));\n}\n\nfunction measureName(code: number): Measure {\n  if (code === 1) return \"nominal\";\n  if (code === 2) return \"ordinal\";\n  if (code === 3) return \"scale\";\n  return \"unknown\";\n}\n\n/** Subtype 11: `count/3` × (measure, width, alignment) i32 triples — keep the measure of each. The\n * triples are one per REAL variable record (they skip type=-1 continuations but DO include very-long\n * string segment sub-vars), so positional indexing against `raw.variables` aligns — verified in\n * Task 9 against the longstring + wide fixtures; the value-label physical-index remap (reader.ts) is\n * NOT applied here. */\nfunction parseMeasures(record: RawExtension, little: boolean): Measure[] {\n  const view = viewOf(record.bytes);\n  const measures: Measure[] = [];\n  const triples = Math.floor(record.count / 3);\n  for (let t = 0; t < triples; t++) {\n    // A well-formed subtype-11 has size=4, so `bytes` holds 12 per triple; a hostile size<4 shrinks\n    // `bytes` below the count-derived triple stride, so stop before getInt32 reads past the payload.\n    if (t * 12 + 12 > record.bytes.length) break;\n    measures.push(measureName(view.getInt32(t * 12, little)));\n  }\n  return measures;\n}\n\nfunction applyRecord(record: RawExtension, little: boolean, info: DictInfo): void {\n  switch (record.subtype) {\n    case 20: // character encoding: the whole payload is the charset name\n      info.encoding = UTF8.decode(record.bytes).trim();\n      break;\n    case 4: // machine floating-point info: sysmis, highest, lowest — keep sysmis\n      info.sysmis = viewOf(record.bytes).getFloat64(0, little);\n      break;\n    case 13:\n      parseLongNames(record.bytes, info.longNames);\n      break;\n    case 14:\n      parseVeryLong(record.bytes, info.veryLong);\n      break;\n    case 11:\n      info.measures = parseMeasures(record, little);\n      break;\n    default: // 3/17/18/21/22 and any unknown subtype: enrichments handled later, or unneeded\n      break;\n  }\n}\n\n/** Interpret the captured type-7 extension records into a `DictInfo`, reading each record's ints and\n * floats with the file's byte order (`little`). Unhandled subtypes are ignored, never thrown. */\nexport function applyExtensions(raw: RawDict, little: boolean): DictInfo {\n  const info: DictInfo = {\n    encoding: \"utf-8\",\n    sysmis: -Number.MAX_VALUE,\n    longNames: new Map(),\n    veryLong: new Map(),\n    measures: [],\n  };\n  for (const record of raw.extensions) applyRecord(record, little, info);\n  return info;\n}\n","import type { Cursor } from \"./binary\";\n\nimport { SavError } from \"../limits\";\n\nexport type SavHeader = {\n  zlib: boolean;\n  compression: 0 | 1 | 2;\n  bias: number;\n  ncases: number;\n  fileLabel: string;\n};\n\n// \"windows-1252\" is the WHATWG decoder that \"ascii\" aliases to; Bun.Encoding lacks the \"ascii\" label.\nconst ASCII = new TextDecoder(\"windows-1252\");\n\nfunction asCompression(v: number): 0 | 1 | 2 {\n  if (v === 0 || v === 1 || v === 2) return v;\n  throw new Error(`Unsupported SPSS compression flag: ${v}`);\n}\n\n/** Read the 176-byte file header. Detects byte order from layout_code (must read as 2 or 3), sets\n * `cur.little`, and leaves the cursor at byte 176 (start of the dictionary). */\nexport function readHeader(cur: Cursor): SavHeader {\n  // Every field below lives within the fixed 176-byte header; a shorter buffer would surface as a\n  // raw RangeError from a DataView read, so reject it up front as a clean SavError.\n  if (cur.length < 176) throw new SavError(\"file too small to be a .sav\");\n  const magic = cur.readStr(4, ASCII);\n  if (magic !== \"$FL2\" && magic !== \"$FL3\") throw new Error(\"Not an SPSS system file (bad magic)\");\n  cur.little = cur.view.getInt32(64, true) === 2 || cur.view.getInt32(64, true) === 3;\n  cur.seek(64);\n  cur.readI32(); // layout_code\n  cur.readI32(); // nominal_case_size (unreliable — recomputed from variables)\n  const compression = asCompression(cur.readI32());\n  cur.readI32(); // weight_index\n  const ncases = cur.readI32();\n  const bias = cur.readF64();\n  cur.skip(9 + 8); // creation_date + creation_time\n  const fileLabel = cur.readStr(64, ASCII).replace(/[\\s\\0]+$/, \"\");\n  cur.skip(3); // padding → byte 176\n  return { zlib: magic === \"$FL3\", compression, bias, ncases, fileLabel };\n}\n","import type { Cursor } from \"./binary\";\nimport type { SavHeader } from \"./header\";\n\nimport { SavError } from \"../limits\";\n\n/** A compression-agnostic reader over a .sav data section: sequential numeric cells and 8-byte\n * string chunks. `nextNumeric` returns `null` for a system-missing (or end-of-data) value. */\nexport interface ValueSource {\n  nextNumeric(): number | null;\n  nextString8(): Uint8Array;\n  /** True when the next cell boundary is the end-of-data marker (or the stream is exhausted) — the\n   * termination signal a reader uses when the header's case count is unknown (`ncases = -1`). */\n  atEnd(): boolean;\n}\n\n/** One ZSAV compressed block descriptor: where its deflate stream sits in the file and its length. */\ntype ZBlock = { compressedOfs: number; compressedSize: number };\n\n/** A fresh 8-byte run filled with a single value (0x20 spaces or 0x00 NULs for string cells). */\nfunction filled(byte: number): Uint8Array {\n  return new Uint8Array(8).fill(byte);\n}\n\n/** Compression flag 0: numeric = raw f64 (equal to sysmis → null); string = raw 8 bytes. */\nclass UncompressedSource implements ValueSource {\n  constructor(\n    private readonly cur: Cursor,\n    private readonly sysmis: number,\n  ) {}\n\n  nextNumeric(): number | null {\n    const v = this.cur.readF64();\n    return v === this.sysmis ? null : v;\n  }\n\n  nextString8(): Uint8Array {\n    return this.cur.readBytes(8);\n  }\n\n  atEnd(): boolean {\n    return this.cur.pos + 8 > this.cur.length; // no full 8-byte cell remains → data section done\n  }\n}\n\n/** Compression flag 1 (and the inflated ZSAV stream): an 8-code control octet drives each cell.\n * Codes — 0 pad · 1..251 numeric `code − bias` · 252 end-of-data · 253 literal (the next 8 bytes\n * of the stream) · 254 eight spaces (strings) · 255 system-missing. Literals for a given octet\n * follow it in the stream, in code order, which is why we read them from the cursor as encountered. */\nclass RleSource implements ValueSource {\n  private codes: Uint8Array = new Uint8Array(8);\n  private idx = 8; // ≥ 8 forces an octet refill on the first pull\n  private lookahead: number | null = null; // a control code peeked by atEnd(), not yet spent on a cell\n\n  constructor(\n    private readonly cur: Cursor,\n    private readonly bias: number,\n  ) {}\n\n  /** Pull the next raw octet code. Synthesizes 252 (end-of-data) once the stream is exhausted, so an\n   * unknown-case-count read (`ncases = -1`) terminates on atEnd() instead of over-reading past EOF. */\n  private rawCode(): number {\n    if (this.idx >= 8) {\n      if (this.cur.pos >= this.cur.length) return 252;\n      this.codes = this.cur.readBytes(8);\n      this.idx = 0;\n    }\n    return this.codes[this.idx++];\n  }\n\n  /** Next cell-bearing control code: drains any peeked code, then skips 0 fillers (they encode no\n   * cell — proven by the labels_order oracle fixture's inter-row octet padding). */\n  private nextCode(): number {\n    if (this.lookahead !== null) {\n      const code = this.lookahead;\n      this.lookahead = null;\n      return code;\n    }\n    for (;;) {\n      const code = this.rawCode();\n      if (code !== 0) return code;\n    }\n  }\n\n  atEnd(): boolean {\n    if (this.lookahead === null) this.lookahead = this.nextCode();\n    return this.lookahead === 252;\n  }\n\n  nextNumeric(): number | null {\n    const code = this.nextCode();\n    if (code === 252 || code === 255) return null; // end-of-data / system-missing\n    if (code === 253) return this.cur.readF64(); // literal double follows the octet\n    return code - this.bias;\n  }\n\n  nextString8(): Uint8Array {\n    const code = this.nextCode();\n    if (code === 254) return filled(0x20); // eight spaces\n    if (code === 253) return this.cur.readBytes(8); // literal 8 bytes\n    return filled(0x20); // 252 end-of-data / 255 / other → space-filled (SPSS pads strings with 0x20)\n  }\n}\n\n/** Read a byte-order-aware 64-bit signed int; file offsets/lengths fit in a JS number. */\nfunction readI64(cur: Cursor): number {\n  const v = cur.view.getBigInt64(cur.pos, cur.little);\n  cur.pos += 8;\n  return Number(v);\n}\n\n/** Copy the parts into one contiguous ArrayBuffer sized to their total length. */\nfunction concatToBuffer(parts: Uint8Array[]): ArrayBuffer {\n  const total = parts.reduce((n, p) => n + p.length, 0);\n  const buf = new ArrayBuffer(total);\n  const out = new Uint8Array(buf);\n  let ofs = 0;\n  for (const p of parts) {\n    out.set(p, ofs);\n    ofs += p.length;\n  }\n  return buf;\n}\n\n/** Inflate one zlib (\"deflate\") block through the platform DecompressionStream, streaming the output\n * chunk-by-chunk and aborting the moment it exceeds `maxBytes` — a few-KB block can inflate to\n * gigabytes (a decompression bomb), so we never materialize the whole output before checking. */\nasync function inflateDeflate(compressed: Uint8Array, maxBytes: number): Promise<Uint8Array> {\n  // Copy into a fresh ArrayBuffer-backed view: a generic Uint8Array<ArrayBufferLike> isn't a valid\n  // BlobPart under the DOM lib (the consumer app typechecks this source).\n  const bytes = new Uint8Array(compressed.length);\n  bytes.set(compressed);\n  const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream(\"deflate\"));\n  const reader = stream.getReader();\n  const parts: Uint8Array[] = [];\n  let total = 0;\n  for (;;) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    total += value.byteLength;\n    if (total > maxBytes) {\n      await reader.cancel();\n      throw new SavError(\"ZSAV inflated output exceeds limit\");\n    }\n    parts.push(value);\n  }\n  return new Uint8Array(concatToBuffer(parts));\n}\n\n/** Read the ZTRAILER at `ztrailerOfs` and return its per-block compressed descriptors. */\nfunction readTrailerBlocks(cur: Cursor, ztrailerOfs: number): ZBlock[] {\n  cur.seek(ztrailerOfs);\n  readI64(cur); // bias\n  readI64(cur); // zero\n  cur.readI32(); // block_size\n  const nBlocks = cur.readI32();\n  if (nBlocks < 0 || nBlocks > 1_000_000) throw new SavError(\"ZSAV block count out of range\");\n  const blocks: ZBlock[] = [];\n  for (let i = 0; i < nBlocks; i++) {\n    readI64(cur); // uncompressed_ofs\n    const compressedOfs = readI64(cur);\n    cur.readI32(); // uncompressed_size\n    blocks.push({ compressedOfs, compressedSize: cur.readI32() });\n  }\n  return blocks;\n}\n\n/** Pick the value source for a data section by its header compression flag. Flag 0 = raw f64/bytes;\n * flags 1 and 2 (2 = the already-inflated ZSAV stream) share the RLE control-octet decoding. */\nexport function makeSource(cur: Cursor, header: SavHeader, sysmis: number): ValueSource {\n  if (header.compression === 0) return new UncompressedSource(cur, sysmis);\n  return new RleSource(cur, header.bias);\n}\n\n/** Inflate a ZSAV ($FL3) data section into the RLE bytecode stream: read the ZHEADER offsets, walk\n * the ZTRAILER block descriptors, deflate-inflate each block, and concatenate. Offsets are absolute\n * file offsets, so `cur` must span the whole file.\n * Field framing (ZHEADER 3×i64; ZTRAILER bias/zero/block_size/n_blocks + per-block descriptors) and\n * the zlib-wrapped \"deflate\" (not \"deflate-raw\") stream are verified against the haven\n * `compress=\"zsav\"` fixture in Task 9's oracle matrix. `maxInflatedBytes` caps the TOTAL inflated\n * output across all blocks (a streaming budget) so a decompression bomb throws instead of OOMing. */\nexport async function inflateZsav(cur: Cursor, maxInflatedBytes: number): Promise<ArrayBuffer> {\n  readI64(cur); // zheader_ofs\n  const ztrailerOfs = readI64(cur);\n  readI64(cur); // ztrailer_len\n  const blocks = readTrailerBlocks(cur, ztrailerOfs);\n  const parts: Uint8Array[] = [];\n  let total = 0;\n  for (const block of blocks) {\n    cur.seek(block.compressedOfs);\n    const inflated = await inflateDeflate(\n      cur.readBytes(block.compressedSize),\n      maxInflatedBytes - total,\n    );\n    total += inflated.length;\n    parts.push(inflated);\n  }\n  return concatToBuffer(parts);\n}\n","import type { SavLimits } from \"../limits\";\nimport type { CellValue, ParsedFile, Variable } from \"../types\";\nimport type { VariablePlan } from \"./cases\";\nimport type { RawDict, RawValueLabelSet } from \"./dictionary\";\nimport type { DictInfo } from \"./extensions\";\nimport type { RawVariable } from \"./variable\";\n\nimport { DEFAULT_LIMITS, SavError } from \"../limits\";\nimport { Cursor } from \"./binary\";\nimport { readCases, toBunEncoding } from \"./cases\";\nimport { isDateFormat } from \"./dates\";\nimport { readDictionary } from \"./dictionary\";\nimport { applyExtensions } from \"./extensions\";\nimport { readHeader } from \"./header\";\nimport { inflateZsav, makeSource } from \"./source\";\n\ntype ValueLabel = { value: CellValue; label: string };\n\n/** Everything `buildVariable`/`buildPlans` need beyond the raw variable itself, bundled so the\n * builders stay within the parameter budget. */\ntype BuildContext = { info: DictInfo; sets: RawValueLabelSet[]; little: boolean; dec: TextDecoder };\n\n/** Read 8 raw value-label bytes as a numeric f64 key, in the file's byte order. */\nfunction rawToF64(raw: Uint8Array, little: boolean): number {\n  return new DataView(raw.buffer, raw.byteOffset, 8).getFloat64(0, little);\n}\n\n/** Collect the value labels attached to the variable at 1-based PHYSICAL dictionary index\n * `physicalIndex` (type-4 var indexes count string continuations, which `raw.variables` drops),\n * decoding each key by the owning variable's kind: numeric → f64, string → trimmed decoded bytes,\n * and the label text with the file encoding. */\nfunction valueLabelsFor(\n  physicalIndex: number,\n  isString: boolean,\n  sets: RawValueLabelSet[],\n  little: boolean,\n  dec: TextDecoder,\n): ValueLabel[] | undefined {\n  const out: ValueLabel[] = [];\n  for (const set of sets) {\n    if (!set.varIndexes.includes(physicalIndex)) continue;\n    for (const entry of set.labels) {\n      const value = isString\n        ? dec.decode(entry.raw).replace(/ +$/, \"\")\n        : rawToF64(entry.raw, little);\n      out.push({ value, label: dec.decode(entry.labelRaw).replace(/\\0+$/, \"\") });\n    }\n  }\n  return out.length > 0 ? out : undefined;\n}\n\n/** The name/type/format/measure common to every variable, before optional fields are attached. */\nfunction baseVariable(rawVar: RawVariable, index: number, info: DictInfo): Variable {\n  return {\n    name: info.longNames.get(rawVar.name) ?? rawVar.name,\n    type: rawVar.type > 0 ? \"string\" : \"numeric\",\n    missing: rawVar.missing,\n    format: { ...rawVar.print, isDate: isDateFormat(rawVar.print.type) },\n    measure: info.measures[index] ?? \"unknown\",\n  };\n}\n\n/** Assemble one `Variable` from its raw record plus the extension-derived long name, measure, real\n * date-format flag, and any value labels resolved against the owning variable's numeric/string kind.\n * `physicalIndex` is the variable's 1-based position INCLUDING continuations (value-label indexing). */\nfunction buildVariable(\n  rawVar: RawVariable,\n  index: number,\n  physicalIndex: number,\n  ctx: BuildContext,\n): Variable {\n  const isString = rawVar.type > 0;\n  const variable = baseVariable(rawVar, index, ctx.info);\n  if (rawVar.label !== undefined) variable.label = rawVar.label;\n  if (isString) variable.width = rawVar.type;\n  const valueLabels = valueLabelsFor(physicalIndex, isString, ctx.sets, ctx.little, ctx.dec);\n  if (valueLabels) variable.valueLabels = valueLabels;\n  return variable;\n}\n\n/** The `ceil(realWidth/252)` segment allocated-widths of a very-long string, read from the segment\n * sub-variables that immediately follow it in the dictionary (SPSS packs one string variable per\n * segment: first segments alloc 255, the last alloc `realWidth − 252·(n−1)`). */\nfunction segmentWidths(raw: RawDict, start: number, realWidth: number): number[] {\n  const n = Math.ceil(realWidth / 252);\n  const widths: number[] = [];\n  for (let s = 0; s < n && start + s < raw.variables.length; s++) {\n    widths.push(raw.variables[start + s].type);\n  }\n  return widths;\n}\n\n/** Turn the raw variable list into read plans, merging each very-long string's N segment\n * sub-variables (identified by its short name in `info.veryLong`) into ONE logical string variable\n * of the real width. Normal strings get a single-segment plan; numerics get an empty plan. */\nfunction buildPlans(raw: RawDict, ctx: BuildContext): VariablePlan[] {\n  const plans: VariablePlan[] = [];\n  let i = 0;\n  while (i < raw.variables.length) {\n    const rawVar = raw.variables[i];\n    const variable = buildVariable(rawVar, i, raw.physicalIndexes[i], ctx);\n    const realWidth = rawVar.type > 0 ? ctx.info.veryLong.get(rawVar.name) : undefined;\n    if (realWidth === undefined) {\n      plans.push({ variable, segments: rawVar.type > 0 ? [rawVar.type] : [] });\n      i += 1;\n      continue;\n    }\n    const segments = segmentWidths(raw, i, realWidth);\n    variable.width = realWidth;\n    plans.push({ variable, segments });\n    i += segments.length;\n  }\n  return plans;\n}\n\n/** Read an SPSS `.sav`/`.zsav` system file end-to-end: header → dictionary → extensions → variables\n * → (inflate if ZSAV) → data cases. Matches R `haven` on the committed golden fixtures. `opts`\n * tightens the resource ceilings (see `SavLimits`); a hostile file is rejected with a `SavError`. */\nexport async function readSav(buf: ArrayBuffer, opts?: Partial<SavLimits>): Promise<ParsedFile> {\n  const limits = { ...DEFAULT_LIMITS, ...opts };\n  let cur = new Cursor(buf);\n  const header = readHeader(cur);\n  const raw = readDictionary(cur);\n  const info = applyExtensions(raw, cur.little);\n  const little = cur.little; // capture before a ZSAV swap: the bytecode literals keep the file's order\n  const dec = new TextDecoder(toBunEncoding(info.encoding));\n  const plans = buildPlans(raw, { info, sets: raw.valueLabelSets, little, dec });\n  const variables = plans.map((plan) => plan.variable);\n  // No variables ⇒ every row consumes 0 cells, so the unknown-count (`ncases = -1`) loop can never\n  // advance — reject instead of spinning forever.\n  if (variables.length === 0) throw new SavError(\"file has no variables\");\n  if (header.ncases >= 0 && header.ncases * variables.length > limits.maxCells) {\n    throw new SavError(\n      `case count ${header.ncases} × ${variables.length} vars exceeds cell limit ${limits.maxCells}`,\n    );\n  }\n  if (header.zlib) {\n    const data = await inflateZsav(cur, limits.maxInflatedBytes);\n    cur = new Cursor(data);\n    cur.little = little;\n  }\n  const source = makeSource(cur, header, info.sysmis);\n  const rows = readCases(header, plans, info, source, limits);\n  return { format: \"sav\", encoding: info.encoding, sheets: [{ name: \"data\", variables, rows }] };\n}\n"]}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "datareader-spss",
+  "version": "0.1.2",
+  "description": "Correct, zero-dependency SPSS .sav/.zsav reader for the browser and Node — validated against R haven.",
+  "license": "MIT",
+  "author": "everydaydesign",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "spss",
+    "sav",
+    "zsav",
+    "parser",
+    "reader",
+    "browser",
+    "statistics",
+    "haven",
+    "pspp",
+    "data",
+    "datareader"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/everydaydesign/datareader-spss.git"
+  },
+  "homepage": "https://github.com/everydaydesign/datareader-spss#readme",
+  "bugs": "https://github.com/everydaydesign/datareader-spss/issues",
+  "scripts": {
+    "build": "tsup",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "fixtures": "Rscript oracle/generate-fixtures.R",
+    "prepublishOnly": "tsup && bun test"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.14",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.2"
+  }
+}