deepbox 0.1.0

package/dist/chunk-AD436M45.js

@@ -0,0 +1,3854 @@
+import { tensor, CSRMatrix, zeros, empty, Tensor } from './chunk-BCR7G3A6.js';
+import { __export, InvalidParameterError, NotFittedError, DeepboxError, ShapeError, DTypeError, getConfig, DataValidationError } from './chunk-4S73VUBD.js';
+
+// src/preprocess/index.ts
+var preprocess_exports = {};
+__export(preprocess_exports, {
+  GroupKFold: () => GroupKFold,
+  KFold: () => KFold,
+  LabelBinarizer: () => LabelBinarizer,
+  LabelEncoder: () => LabelEncoder,
+  LeaveOneOut: () => LeaveOneOut,
+  LeavePOut: () => LeavePOut,
+  MaxAbsScaler: () => MaxAbsScaler,
+  MinMaxScaler: () => MinMaxScaler,
+  MultiLabelBinarizer: () => MultiLabelBinarizer,
+  Normalizer: () => Normalizer,
+  OneHotEncoder: () => OneHotEncoder,
+  OrdinalEncoder: () => OrdinalEncoder,
+  PowerTransformer: () => PowerTransformer,
+  QuantileTransformer: () => QuantileTransformer,
+  RobustScaler: () => RobustScaler,
+  StandardScaler: () => StandardScaler,
+  StratifiedKFold: () => StratifiedKFold,
+  trainTestSplit: () => trainTestSplit
+});
+
+// src/preprocess/_internal.ts
+function assertNumericTensor(X, name) {
+  if (X.dtype === "string") {
+    throw new DTypeError(`${name} must be numeric`);
+  }
+}
+function assert2D(X, name) {
+  if (X.ndim !== 2) {
+    throw new ShapeError(`${name} must be a 2D tensor, got ${X.ndim}D`);
+  }
+}
+function getShape2D(X) {
+  if (X.ndim !== 2 || X.shape[0] === void 0 || X.shape[1] === void 0) {
+    throw new ShapeError(`Expected 2D tensor with valid shape, got shape [${X.shape.join(", ")}]`);
+  }
+  return [X.shape[0], X.shape[1]];
+}
+function getStride1D(X) {
+  const stride = X.strides[0];
+  if (stride === void 0) {
+    throw new DeepboxError("Internal error: missing stride for 1D tensor");
+  }
+  return stride;
+}
+function getStrides2D(X) {
+  const stride0 = X.strides[0];
+  const stride1 = X.strides[1];
+  if (stride0 === void 0 || stride1 === void 0) {
+    throw new DeepboxError("Internal error: missing strides for 2D tensor");
+  }
+  return [stride0, stride1];
+}
+function createSeededRandom(seed) {
+  const a = 1103515245;
+  const c = 12345;
+  const m = 2 ** 31;
+  if (!Number.isFinite(seed) || !Number.isInteger(seed) || !Number.isSafeInteger(seed) || seed < 0) {
+    throw new InvalidParameterError(
+      "randomState must be a non-negative safe integer",
+      "randomState",
+      seed
+    );
+  }
+  let state = seed % m;
+  return () => {
+    state = (a * state + c) % m;
+    return state / m;
+  };
+}
+function shuffleIndicesInPlace(indices, random) {
+  for (let i = indices.length - 1; i > 0; i--) {
+    const j = Math.floor(random() * (i + 1));
+    const temp = indices[i];
+    if (temp === void 0) {
+      throw new DeepboxError("Internal error: shuffle source index missing");
+    }
+    const swap = indices[j];
+    if (swap === void 0) {
+      throw new DeepboxError("Internal error: shuffle target index missing");
+    }
+    indices[i] = swap;
+    indices[j] = temp;
+  }
+}
+
+// src/preprocess/encoders.ts
+function getStringData(t) {
+  if (t.dtype !== "string") {
+    throw new DTypeError("Expected string tensor");
+  }
+  if (!Array.isArray(t.data)) {
+    throw new DeepboxError("Internal error: invalid string tensor storage");
+  }
+  return t.data;
+}
+function getNumericData(t) {
+  if (t.dtype === "string") {
+    throw new DTypeError("Expected numeric tensor");
+  }
+  if (Array.isArray(t.data)) {
+    throw new DeepboxError("Internal error: invalid numeric tensor storage");
+  }
+  return t.data;
+}
+function inferCategoryType(values, paramName) {
+  let hasString = false;
+  let hasNumber = false;
+  let hasBigInt = false;
+  for (const value of values) {
+    if (typeof value === "string") {
+      hasString = true;
+    } else if (typeof value === "number") {
+      if (!Number.isFinite(value)) {
+        throw new InvalidParameterError("Category values must be finite numbers", paramName, value);
+      }
+      hasNumber = true;
+    } else if (typeof value === "bigint") {
+      hasBigInt = true;
+    }
+  }
+  const typeCount = (hasString ? 1 : 0) + (hasNumber ? 1 : 0) + (hasBigInt ? 1 : 0);
+  if (typeCount === 0) {
+    return "number";
+  }
+  if (typeCount > 1) {
+    throw new InvalidParameterError("Mixed category types are not supported", paramName);
+  }
+  if (hasString) return "string";
+  if (hasBigInt) return "bigint";
+  return "number";
+}
+function sortCategories(values, paramName) {
+  const arr = Array.from(values);
+  if (arr.length === 0) return arr;
+  const categoryType = inferCategoryType(arr, paramName);
+  if (categoryType === "string") {
+    arr.sort((a, b) => {
+      if (typeof a !== "string" || typeof b !== "string") {
+        throw new DeepboxError("Internal error: inconsistent category types");
+      }
+      return a.localeCompare(b);
+    });
+    return arr;
+  }
+  if (categoryType === "bigint") {
+    arr.sort((a, b) => {
+      if (typeof a !== "bigint" || typeof b !== "bigint") {
+        throw new DeepboxError("Internal error: inconsistent category types");
+      }
+      if (a < b) return -1;
+      if (a > b) return 1;
+      return 0;
+    });
+    return arr;
+  }
+  arr.sort((a, b) => {
+    if (typeof a !== "number" || typeof b !== "number") {
+      throw new DeepboxError("Internal error: inconsistent category types");
+    }
+    return a - b;
+  });
+  return arr;
+}
+function validateCategoryValues(values, paramName) {
+  if (values.length === 0) {
+    throw new InvalidParameterError("categories must contain at least one value", paramName);
+  }
+  const arr = Array.from(values);
+  inferCategoryType(arr, paramName);
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of arr) {
+    if (seen.has(value)) {
+      throw new InvalidParameterError(
+        `categories must be unique; duplicate value ${String(value)}`,
+        paramName,
+        value
+      );
+    }
+    seen.add(value);
+  }
+  return arr;
+}
+function resolveCategoriesOption(categoriesOption, nFeatures, paramName) {
+  if (categoriesOption === "auto") {
+    return null;
+  }
+  if (!Array.isArray(categoriesOption)) {
+    throw new InvalidParameterError(
+      "categories must be 'auto' or an array of category arrays",
+      paramName,
+      categoriesOption
+    );
+  }
+  if (categoriesOption.length !== nFeatures) {
+    throw new InvalidParameterError(
+      "categories length must match number of features",
+      paramName,
+      categoriesOption.length
+    );
+  }
+  return categoriesOption;
+}
+function read1DValue(t, i) {
+  const stride = getStride1D(t);
+  const idx = t.offset + i * stride;
+  if (t.dtype === "string") {
+    const value2 = getStringData(t)[idx];
+    if (value2 === void 0) {
+      throw new DeepboxError("Internal error: string tensor access out of bounds");
+    }
+    return value2;
+  }
+  const value = getNumericData(t)[idx];
+  if (value === void 0) {
+    throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+  }
+  return typeof value === "bigint" ? value : Number(value);
+}
+function read2DValue(t, row, col) {
+  const [stride0, stride1] = getStrides2D(t);
+  const idx = t.offset + row * stride0 + col * stride1;
+  if (t.dtype === "string") {
+    const value2 = getStringData(t)[idx];
+    if (value2 === void 0) {
+      throw new DeepboxError("Internal error: string tensor access out of bounds");
+    }
+    return value2;
+  }
+  const value = getNumericData(t)[idx];
+  if (value === void 0) {
+    throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+  }
+  return typeof value === "bigint" ? value : Number(value);
+}
+function assert1D(t, name) {
+  if (t.ndim !== 1) {
+    throw new ShapeError(`${name} must be a 1D tensor`);
+  }
+}
+function categoryValueAt(values, index, context) {
+  const value = values[index];
+  if (value === void 0) {
+    throw new DeepboxError(`Internal error: missing category at index ${index} (${context})`);
+  }
+  return value;
+}
+function inferCategoryTypeFromRows(rows, paramName) {
+  const values = [];
+  for (const row of rows) {
+    for (const value of row) {
+      values.push(value);
+    }
+  }
+  return inferCategoryType(values, paramName);
+}
+function emptyCategoryVectorFromClasses(classes, paramName) {
+  const categoryType = inferCategoryType(classes, paramName);
+  if (categoryType === "string") {
+    return empty([0], { dtype: "string" });
+  }
+  if (categoryType === "bigint") {
+    return empty([0], { dtype: "int64" });
+  }
+  return zeros([0], { dtype: "float64" });
+}
+function emptyCategoryMatrixFromCategories(categories, nFeatures, paramName) {
+  const categoryType = inferCategoryTypeFromRows(categories, paramName);
+  if (categoryType === "string") {
+    return empty([0, nFeatures], { dtype: "string" });
+  }
+  if (categoryType === "bigint") {
+    return empty([0, nFeatures], { dtype: "int64" });
+  }
+  return zeros([0, nFeatures], { dtype: "float64" });
+}
+function toCategoryVectorTensor(values, paramName = "y") {
+  const categoryType = inferCategoryType(values, paramName);
+  if (categoryType === "string") {
+    const out2 = new Array(values.length);
+    for (let i = 0; i < values.length; i++) {
+      const value = values[i];
+      if (typeof value !== "string") {
+        throw new DeepboxError("Internal error: expected string category value");
+      }
+      out2[i] = value;
+    }
+    return tensor(out2);
+  }
+  if (categoryType === "bigint") {
+    const out2 = new BigInt64Array(values.length);
+    for (let i = 0; i < values.length; i++) {
+      const value = values[i];
+      if (typeof value !== "bigint") {
+        throw new DeepboxError("Internal error: expected bigint category value");
+      }
+      out2[i] = value;
+    }
+    return tensor(out2);
+  }
+  const out = new Float64Array(values.length);
+  for (let i = 0; i < values.length; i++) {
+    const value = values[i];
+    if (value === void 0 || typeof value !== "number") {
+      throw new DeepboxError("Internal error: expected numeric category value");
+    }
+    out[i] = value;
+  }
+  return tensor(out);
+}
+function toCategoryMatrixTensor(values, paramName = "X") {
+  const rows = values.length;
+  const cols = rows > 0 ? values[0]?.length ?? 0 : 0;
+  for (let i = 0; i < rows; i++) {
+    const row = values[i];
+    if (!row) {
+      throw new DeepboxError("Internal error: missing row in category matrix");
+    }
+    if (row.length !== cols) {
+      throw new ShapeError("Ragged category matrix cannot be converted to tensor");
+    }
+  }
+  const flat = [];
+  for (const row of values) {
+    for (const value of row) {
+      flat.push(value);
+    }
+  }
+  const categoryType = inferCategoryType(flat, paramName);
+  if (categoryType === "string") {
+    const out = new Array(rows);
+    for (let i = 0; i < rows; i++) {
+      const row = values[i];
+      if (!row) {
+        throw new DeepboxError("Internal error: missing row in category matrix");
+      }
+      const outRow = new Array(cols);
+      for (let j = 0; j < cols; j++) {
+        const value = row[j];
+        if (typeof value !== "string") {
+          throw new DeepboxError("Internal error: expected string category value");
+        }
+        outRow[j] = value;
+      }
+      out[i] = outRow;
+    }
+    return tensor(out);
+  }
+  if (categoryType === "number") {
+    const out = new Array(rows);
+    for (let i = 0; i < rows; i++) {
+      const row = values[i];
+      if (!row) {
+        throw new DeepboxError("Internal error: missing row in category matrix");
+      }
+      const outRow = new Array(cols);
+      for (let j = 0; j < cols; j++) {
+        const value = row[j];
+        if (typeof value !== "number") {
+          throw new DeepboxError("Internal error: expected numeric category value");
+        }
+        outRow[j] = value;
+      }
+      out[i] = outRow;
+    }
+    return tensor(out, { dtype: "float64" });
+  }
+  const data = new BigInt64Array(rows * cols);
+  for (let i = 0; i < flat.length; i++) {
+    const value = flat[i];
+    if (typeof value !== "bigint") {
+      throw new DeepboxError("Internal error: expected bigint category value");
+    }
+    data[i] = value;
+  }
+  const { defaultDevice } = getConfig();
+  return Tensor.fromTypedArray({
+    data,
+    shape: [rows, cols],
+    dtype: "int64",
+    device: defaultDevice
+  });
+}
+var LabelEncoder = class {
+  /** Indicates whether the encoder has been fitted to data */
+  fitted = false;
+  /** Array of unique classes found during fitting, sorted for consistency */
+  classes_;
+  /** Map from class value to encoded integer index for O(1) lookup */
+  classToIndex_;
+  /**
+   * Fit label encoder to a set of labels.
+   * Extracts unique classes and creates an index mapping.
+   *
+   * @param y - Target labels (1D tensor of strings or numbers)
+   * @returns this - Returns self for method chaining
+   * @throws {InvalidParameterError} If y is empty
+   */
+  fit(y) {
+    assert1D(y, "y");
+    if (y.size === 0) {
+      throw new InvalidParameterError("Cannot fit LabelEncoder on empty array", "y");
+    }
+    const uniqueSet = /* @__PURE__ */ new Set();
+    for (let i = 0; i < y.size; i++) {
+      uniqueSet.add(read1DValue(y, i));
+    }
+    this.classes_ = sortCategories(uniqueSet, "y");
+    this.classToIndex_ = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.classes_.length; i++) {
+      this.classToIndex_.set(categoryValueAt(this.classes_, i, "LabelEncoder.fit"), i);
+    }
+    this.fitted = true;
+    return this;
+  }
+  /**
+   * Transform labels to normalized encoding.
+   * Each unique label is mapped to an integer in [0, n_classes-1].
+   *
+   * @param y - Target labels to encode (1D tensor)
+   * @returns Encoded labels as integer tensor
+   * @throws {NotFittedError} If encoder is not fitted
+   * @throws {InvalidParameterError} If y contains labels not seen during fit
+   */
+  transform(y) {
+    if (!this.fitted) {
+      throw new NotFittedError("LabelEncoder must be fitted before transform");
+    }
+    assert1D(y, "y");
+    if (y.size === 0) {
+      return tensor([]);
+    }
+    const lookup = this.classToIndex_;
+    if (!this.classes_ || !lookup) {
+      throw new DeepboxError("LabelEncoder internal error: missing fitted state");
+    }
+    const result = new Array(y.size);
+    for (let i = 0; i < y.size; i++) {
+      const val = read1DValue(y, i);
+      const idx = lookup.get(val);
+      if (idx === void 0) {
+        throw new InvalidParameterError(
+          `Unknown label: ${String(val)}. Label must be present during fit.`,
+          "y",
+          val
+        );
+      }
+      result[i] = idx;
+    }
+    return tensor(result, { dtype: "float64" });
+  }
+  /**
+   * Fit label encoder and return encoded labels in one step.
+   * Convenience method equivalent to calling fit(y).transform(y).
+   *
+   * @param y - Target labels (1D tensor)
+   * @returns Encoded labels as integer tensor
+   */
+  fitTransform(y) {
+    return this.fit(y).transform(y);
+  }
+  /**
+   * Transform integer labels back to original encoding.
+   * Reverses the encoding performed by transform().
+   *
+   * @param y - Encoded labels (1D integer tensor)
+   * @returns Original labels (strings or numbers)
+   * @throws {NotFittedError} If encoder is not fitted
+   * @throws {InvalidParameterError} If y contains invalid indices
+   */
+  inverseTransform(y) {
+    if (!this.fitted) {
+      throw new NotFittedError("LabelEncoder must be fitted before inverse_transform");
+    }
+    assert1D(y, "y");
+    assertNumericTensor(y, "y");
+    const classes = this.classes_;
+    if (!classes) {
+      throw new DeepboxError("LabelEncoder internal error: missing fitted state");
+    }
+    if (y.size === 0) {
+      return emptyCategoryVectorFromClasses(classes, "y");
+    }
+    const classesLen = classes.length;
+    const result = new Array(y.size);
+    const stride = getStride1D(y);
+    const data = getNumericData(y);
+    for (let i = 0; i < y.size; i++) {
+      const raw = data[y.offset + i * stride];
+      if (raw === void 0) {
+        throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+      }
+      const idx = Number(raw);
+      if (idx < 0 || idx >= classesLen || !Number.isInteger(idx)) {
+        throw new InvalidParameterError(
+          `Invalid label index: ${idx}. Must be integer in [0, ${classesLen - 1}]`,
+          "y",
+          idx
+        );
+      }
+      result[i] = categoryValueAt(classes, idx, "LabelEncoder.inverseTransform");
+    }
+    return toCategoryVectorTensor(result, "y");
+  }
+};
+var OneHotEncoder = class {
+  /** Indicates whether the encoder has been fitted to data */
+  fitted = false;
+  /** Array of unique categories for each feature */
+  categories_;
+  /** Maps from category value to index for each feature (for O(1) lookup) */
+  categoryToIndex_;
+  /** Whether to return sparse matrix (CSR) or dense array */
+  sparse;
+  /** How to handle unknown categories during transform */
+  handleUnknown;
+  /** Drop policy to avoid collinearity */
+  drop;
+  /** Per-feature dropped category index */
+  dropIndices_;
+  /** Categories configuration */
+  categoriesOption;
+  /**
+   * Creates a new OneHotEncoder instance.
+   *
+   * @param options - Configuration options
+   * @param options.sparse - If true, returns CSRMatrix; if false, returns dense Tensor (default: false)
+   * @param options.sparseOutput - Alias for sparse (default: false)
+   * @param options.handleUnknown - How to handle unknown categories (default: "error")
+   * @param options.drop - If set, drops the first or binary category per feature
+   * @param options.categories - "auto" or explicit category list per feature
+   */
+  constructor(options = {}) {
+    const sparseOption = options.sparse ?? options.sparseOutput ?? false;
+    if (options.sparse !== void 0 && options.sparseOutput !== void 0) {
+      if (options.sparse !== options.sparseOutput) {
+        throw new InvalidParameterError(
+          "sparse and sparseOutput must match when both are provided",
+          "sparse",
+          options.sparse
+        );
+      }
+    }
+    this.sparse = sparseOption;
+    this.handleUnknown = options.handleUnknown ?? "error";
+    this.drop = options.drop ?? null;
+    this.categoriesOption = options.categories ?? "auto";
+    if (typeof this.sparse !== "boolean") {
+      throw new InvalidParameterError("sparse must be a boolean", "sparse", this.sparse);
+    }
+    if (this.handleUnknown !== "error" && this.handleUnknown !== "ignore") {
+      throw new InvalidParameterError(
+        "handleUnknown must be 'error' or 'ignore'",
+        "handleUnknown",
+        this.handleUnknown
+      );
+    }
+    if (this.drop !== null && this.drop !== "first" && this.drop !== "if_binary") {
+      throw new InvalidParameterError(
+        "drop must be 'first', 'if_binary', or null",
+        "drop",
+        this.drop
+      );
+    }
+  }
+  /**
+   * Fit OneHotEncoder to X.
+   * Learns the unique categories for each feature.
+   *
+   * @param X - Training data (2D tensor of categorical features)
+   * @returns this - Returns self for method chaining
+   * @throws {ShapeError} If X is not a 2D tensor
+   * @throws {InvalidParameterError} If X is empty
+   */
+  fit(X) {
+    assert2D(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    if (nSamples === 0 || nFeatures === 0) {
+      throw new InvalidParameterError("Cannot fit OneHotEncoder on empty array", "X");
+    }
+    this.categories_ = [];
+    this.categoryToIndex_ = [];
+    const explicitCategories = resolveCategoriesOption(
+      this.categoriesOption,
+      nFeatures,
+      "categories"
+    );
+    for (let j = 0; j < nFeatures; j++) {
+      let cats;
+      if (explicitCategories) {
+        const featureCats = explicitCategories[j];
+        if (!featureCats) {
+          throw new InvalidParameterError("Missing categories for feature", "categories", j);
+        }
+        if (!Array.isArray(featureCats)) {
+          throw new InvalidParameterError(
+            "categories must be an array of category arrays",
+            "categories",
+            featureCats
+          );
+        }
+        cats = validateCategoryValues(featureCats, "categories");
+      } else {
+        const uniqueSet = /* @__PURE__ */ new Set();
+        for (let i = 0; i < nSamples; i++) {
+          uniqueSet.add(read2DValue(X, i, j));
+        }
+        cats = sortCategories(uniqueSet, "X");
+      }
+      if (cats.length === 0) {
+        throw new InvalidParameterError("Each feature must have at least one category", "X", j);
+      }
+      this.categories_.push(cats);
+      const map = /* @__PURE__ */ new Map();
+      for (let k = 0; k < cats.length; k++) {
+        map.set(categoryValueAt(cats, k, "OneHotEncoder.fit"), k);
+      }
+      this.categoryToIndex_.push(map);
+      if (explicitCategories) {
+        for (let i = 0; i < nSamples; i++) {
+          const val = read2DValue(X, i, j);
+          if (!map.has(val)) {
+            throw new InvalidParameterError(
+              `Unknown category: ${String(val)} in feature ${j}`,
+              "X",
+              val
+            );
+          }
+        }
+      }
+    }
+    this.dropIndices_ = this.categories_.map((cats) => {
+      if (this.drop === null) return null;
+      if (this.drop === "first") return cats.length > 0 ? 0 : null;
+      if (this.drop === "if_binary") return cats.length === 2 ? 0 : null;
+      return null;
+    });
+    this.fitted = true;
+    return this;
+  }
+  /**
+   * Transform X using one-hot encoding.
+   * Each categorical value is converted to a binary vector.
+   *
+   * @param X - Data to transform (2D tensor)
+   * @returns Encoded data as dense Tensor or sparse CSRMatrix
+   * @throws {NotFittedError} If encoder is not fitted
+   * @throws {InvalidParameterError} If X contains unknown categories
+   */
+  transform(X) {
+    if (!this.fitted) {
+      throw new NotFittedError("OneHotEncoder must be fitted before transform");
+    }
+    assert2D(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const categories = this.categories_;
+    const categoryMaps = this.categoryToIndex_;
+    if (!categories || !categoryMaps) {
+      throw new DeepboxError("OneHotEncoder internal error: missing fitted state");
+    }
+    const fittedFeatures = categories.length;
+    if (nFeatures !== fittedFeatures) {
+      throw new InvalidParameterError(
+        "X has a different feature count than during fit",
+        "X",
+        nFeatures
+      );
+    }
+    const dropIndices = this.dropIndices_ ?? categories.map(() => null);
+    let totalCols = 0;
+    for (let j = 0; j < categories.length; j++) {
+      const cats = categories[j];
+      if (!cats) continue;
+      const dropIndex = dropIndices[j] ?? null;
+      totalCols += cats.length - (dropIndex === null ? 0 : 1);
+    }
+    if (nSamples === 0 || nFeatures === 0) {
+      return this.sparse ? CSRMatrix.fromCOO({
+        rows: 0,
+        cols: totalCols,
+        rowIndices: new Int32Array(0),
+        colIndices: new Int32Array(0),
+        values: new Float64Array(0)
+      }) : zeros([0, totalCols], { dtype: "float64" });
+    }
+    if (this.sparse) {
+      const rowIdx = [];
+      const colIdx = [];
+      const vals = [];
+      for (let i = 0; i < nSamples; i++) {
+        let colOffset = 0;
+        for (let j = 0; j < nFeatures; j++) {
+          const cats = categories[j];
+          const map = categoryMaps[j];
+          const dropIndex = dropIndices[j] ?? null;
+          if (!cats || !map) {
+            throw new DeepboxError("OneHotEncoder internal error: missing fitted categories");
+          }
+          const outSize = cats.length - (dropIndex === null ? 0 : 1);
+          const val = read2DValue(X, i, j);
+          const idx = map.get(val);
+          if (idx === void 0) {
+            if (this.handleUnknown === "ignore") {
+              colOffset += outSize;
+              continue;
+            }
+            throw new InvalidParameterError(`Unknown category: ${String(val)}`, "X", val);
+          }
+          if (dropIndex !== null && idx === dropIndex) {
+            colOffset += outSize;
+            continue;
+          }
+          const adjusted = dropIndex !== null && idx > dropIndex ? idx - 1 : idx;
+          rowIdx.push(i);
+          colIdx.push(colOffset + adjusted);
+          vals.push(1);
+          colOffset += outSize;
+        }
+      }
+      return CSRMatrix.fromCOO({
+        rows: nSamples,
+        cols: totalCols,
+        rowIndices: Int32Array.from(rowIdx),
+        colIndices: Int32Array.from(colIdx),
+        values: Float64Array.from(vals)
+      });
+    }
+    const result = Array.from({ length: nSamples }, () => new Array(totalCols).fill(0));
+    for (let i = 0; i < nSamples; i++) {
+      let colOffset = 0;
+      for (let j = 0; j < nFeatures; j++) {
+        const cats = categories[j];
+        const map = categoryMaps[j];
+        const dropIndex = dropIndices[j] ?? null;
+        if (!cats || !map) {
+          throw new DeepboxError("OneHotEncoder internal error: missing fitted categories");
+        }
+        const outSize = cats.length - (dropIndex === null ? 0 : 1);
+        const val = read2DValue(X, i, j);
+        const idx = map.get(val);
+        if (idx === void 0) {
+          if (this.handleUnknown === "ignore") {
+            colOffset += outSize;
+            continue;
+          }
+          throw new InvalidParameterError(`Unknown category: ${String(val)}`, "X", val);
+        }
+        if (dropIndex !== null && idx === dropIndex) {
+          colOffset += outSize;
+          continue;
+        }
+        const row = result[i];
+        if (row === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        const adjusted = dropIndex !== null && idx > dropIndex ? idx - 1 : idx;
+        row[colOffset + adjusted] = 1;
+        colOffset += outSize;
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+  fitTransform(X) {
+    return this.fit(X).transform(X);
+  }
+  inverseTransform(X) {
+    if (!this.fitted) {
+      throw new NotFittedError("OneHotEncoder must be fitted before inverse_transform");
+    }
+    const dense = X instanceof CSRMatrix ? X.toDense() : X;
+    assert2D(dense, "X");
+    assertNumericTensor(dense, "X");
+    const [nSamples, nCols] = getShape2D(dense);
+    const categories = this.categories_;
+    if (!categories) {
+      throw new DeepboxError("OneHotEncoder internal error: missing fitted categories");
+    }
+    const nFeatures = categories.length;
+    const dropIndices = this.dropIndices_ ?? categories.map(() => null);
+    const totalCols = categories.reduce((sum, cats, idx) => {
+      const dropIndex = dropIndices[idx] ?? null;
+      return sum + cats.length - (dropIndex === null ? 0 : 1);
+    }, 0);
+    if (nCols !== totalCols) {
+      throw new InvalidParameterError("column count does not match fitted categories", "X", nCols);
+    }
+    if (nSamples === 0) {
+      return emptyCategoryMatrixFromCategories(categories, nFeatures, "X");
+    }
+    const result = new Array(nSamples);
+    for (let i = 0; i < nSamples; i++) {
+      result[i] = new Array(nFeatures);
+    }
+    const denseData = getNumericData(dense);
+    const [stride0, stride1] = getStrides2D(dense);
+    for (let i = 0; i < nSamples; i++) {
+      let colOffset = 0;
+      for (let j = 0; j < nFeatures; j++) {
+        const cats = categories[j];
+        const dropIndex = dropIndices[j] ?? null;
+        if (!cats) {
+          throw new DeepboxError("OneHotEncoder internal error: missing fitted categories");
+        }
+        const outSize = cats.length - (dropIndex === null ? 0 : 1);
+        if (outSize === 0) {
+          const row2 = result[i];
+          if (!row2) {
+            throw new DeepboxError("Internal error: result row access failed");
+          }
+          row2[j] = categoryValueAt(cats, dropIndex ?? 0, "OneHotEncoder.inverseTransform");
+          continue;
+        }
+        let maxIdx = 0;
+        const rowBase = dense.offset + i * stride0 + colOffset * stride1;
+        const first = denseData[rowBase];
+        if (first === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        let maxVal = Number(first);
+        let hasPositive = maxVal > 0;
+        for (let k = 1; k < outSize; k++) {
+          const raw = denseData[rowBase + k * stride1];
+          if (raw === void 0) {
+            throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+          }
+          const val = Number(raw);
+          if (val > maxVal) {
+            maxVal = val;
+            maxIdx = k;
+          }
+          if (val > 0) {
+            hasPositive = true;
+          }
+        }
+        const row = result[i];
+        if (row === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        if (!hasPositive) {
+          if (dropIndex !== null) {
+            row[j] = categoryValueAt(cats, dropIndex, "OneHotEncoder.inverseTransform");
+          } else if (this.handleUnknown === "ignore") {
+            throw new InvalidParameterError(
+              "Cannot inverse-transform: sample contains no active category (all zeros). This may happen if unknown categories were ignored during transform.",
+              "X"
+            );
+          } else {
+            throw new InvalidParameterError("Invalid one-hot encoding: all zeros", "X");
+          }
+        } else {
+          const actualIdx = dropIndex !== null && maxIdx >= dropIndex ? maxIdx + 1 : maxIdx;
+          row[j] = categoryValueAt(cats, actualIdx, "OneHotEncoder.inverseTransform");
+        }
+        colOffset += outSize;
+      }
+    }
+    return toCategoryMatrixTensor(result, "X");
+  }
+};
+var OrdinalEncoder = class {
+  /** Indicates whether the encoder has been fitted to data */
+  fitted = false;
+  /** Array of unique categories for each feature, sorted */
+  categories_;
+  /** Maps from category value to index for each feature (for O(1) lookup) */
+  categoryToIndex_;
+  /** How to handle unknown categories during transform */
+  handleUnknown;
+  /** Value used for unknown categories when handleUnknown = "useEncodedValue" */
+  unknownValue;
+  /** Categories configuration */
+  categoriesOption;
+  /**
+   * Creates a new OrdinalEncoder instance.
+   *
+   * @param options - Configuration options
+   * @param options.handleUnknown - How to handle unknown categories
+   * @param options.unknownValue - Encoded value for unknown categories when handleUnknown="useEncodedValue"
+   * @param options.categories - "auto" or explicit categories per feature
+   */
+  constructor(options = {}) {
+    this.handleUnknown = options.handleUnknown ?? "error";
+    this.unknownValue = options.unknownValue ?? -1;
+    this.categoriesOption = options.categories ?? "auto";
+    if (this.handleUnknown !== "error" && this.handleUnknown !== "useEncodedValue") {
+      throw new InvalidParameterError(
+        "handleUnknown must be 'error' or 'useEncodedValue'",
+        "handleUnknown",
+        this.handleUnknown
+      );
+    }
+    if (!Number.isFinite(this.unknownValue) && !Number.isNaN(this.unknownValue)) {
+      throw new InvalidParameterError(
+        "unknownValue must be a finite number or NaN",
+        "unknownValue",
+        this.unknownValue
+      );
+    }
+    if (Number.isFinite(this.unknownValue) && !Number.isInteger(this.unknownValue)) {
+      throw new InvalidParameterError(
+        "unknownValue must be an integer when finite",
+        "unknownValue",
+        this.unknownValue
+      );
+    }
+  }
+  /**
+   * Fit OrdinalEncoder to X.
+   * Learns the unique categories for each feature and their ordering.
+   *
+   * @param X - Training data (2D tensor of categorical features)
+   * @returns this - Returns self for method chaining
+   * @throws {InvalidParameterError} If X is empty
+   */
+  fit(X) {
+    assert2D(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    if (nSamples === 0) {
+      throw new InvalidParameterError("Cannot fit OrdinalEncoder on empty array", "X");
+    }
+    this.categories_ = [];
+    this.categoryToIndex_ = [];
+    const explicitCategories = resolveCategoriesOption(
+      this.categoriesOption,
+      nFeatures,
+      "categories"
+    );
+    for (let j = 0; j < nFeatures; j++) {
+      let sorted;
+      if (explicitCategories) {
+        const featureCats = explicitCategories[j];
+        if (!featureCats) {
+          throw new InvalidParameterError("Missing categories for feature", "categories", j);
+        }
+        if (!Array.isArray(featureCats)) {
+          throw new InvalidParameterError(
+            "categories must be an array of category arrays",
+            "categories",
+            featureCats
+          );
+        }
+        sorted = validateCategoryValues(featureCats, "categories");
+      } else {
+        const uniqueSet = /* @__PURE__ */ new Set();
+        for (let i = 0; i < nSamples; i++) {
+          uniqueSet.add(read2DValue(X, i, j));
+        }
+        sorted = sortCategories(uniqueSet, "X");
+      }
+      if (sorted.length === 0) {
+        throw new InvalidParameterError("Each feature must have at least one category", "X", j);
+      }
+      this.categories_.push(sorted);
+      const map = /* @__PURE__ */ new Map();
+      for (let k = 0; k < sorted.length; k++) {
+        map.set(categoryValueAt(sorted, k, "OrdinalEncoder.fit"), k);
+      }
+      this.categoryToIndex_.push(map);
+      if (explicitCategories) {
+        for (let i = 0; i < nSamples; i++) {
+          const val = read2DValue(X, i, j);
+          if (!map.has(val)) {
+            throw new InvalidParameterError(
+              `Unknown category: ${String(val)} in feature ${j}`,
+              "X",
+              val
+            );
+          }
+        }
+      }
+      if (this.handleUnknown === "useEncodedValue") {
+        if (Number.isFinite(this.unknownValue) && this.unknownValue >= 0 && this.unknownValue < sorted.length) {
+          throw new InvalidParameterError(
+            "unknownValue must be outside the range of encoded categories",
+            "unknownValue",
+            this.unknownValue
+          );
+        }
+      }
+    }
+    this.fitted = true;
+    return this;
+  }
+  /**
+   * Transform X using ordinal encoding.
+   * Each category is mapped to its index in the sorted categories array.
+   *
+   * @param X - Data to transform (2D tensor)
+   * @returns Encoded data with integer values
+   * @throws {NotFittedError} If encoder is not fitted
+   * @throws {InvalidParameterError} If X contains unknown categories
+   */
+  transform(X) {
+    if (!this.fitted) {
+      throw new NotFittedError("OrdinalEncoder must be fitted before transform");
+    }
+    assert2D(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const fittedFeatures = this.categories_?.length ?? 0;
+    if (nFeatures !== fittedFeatures) {
+      throw new InvalidParameterError(
+        "X has a different feature count than during fit",
+        "X",
+        nFeatures
+      );
+    }
+    if (nSamples === 0) {
+      return zeros([0, nFeatures], { dtype: "float64" });
+    }
+    const result = new Array(nSamples);
+    for (let i = 0; i < nSamples; i++) {
+      result[i] = new Array(nFeatures);
+    }
+    for (let i = 0; i < nSamples; i++) {
+      for (let j = 0; j < nFeatures; j++) {
+        const val = read2DValue(X, i, j);
+        const map = this.categoryToIndex_?.[j];
+        if (!map) {
+          throw new DeepboxError("OrdinalEncoder internal error: missing fitted categories");
+        }
+        const idx = map.get(val);
+        const row = result[i];
+        if (!row) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        if (idx === void 0) {
+          if (this.handleUnknown === "useEncodedValue") {
+            row[j] = this.unknownValue;
+            continue;
+          }
+          throw new InvalidParameterError(
+            `Unknown category: ${String(val)} in feature ${j}`,
+            "X",
+            val
+          );
+        }
+        row[j] = idx;
+      }
+    }
+    return tensor(result, { dtype: "float64" });
+  }
+  /**
+   * Fit encoder and transform X in one step.
+   * Convenience method equivalent to calling fit(X).transform(X).
+   *
+   * @param X - Training data (2D tensor)
+   * @returns Encoded data
+   */
+  fitTransform(X) {
+    return this.fit(X).transform(X);
+  }
+  /**
+   * Transform ordinal integers back to original categories.
+   * Reverses the encoding performed by transform().
+   *
+   * @param X - Encoded data (2D integer tensor)
+   * @returns Original categorical data
+   * @throws {NotFittedError} If encoder is not fitted
+   * @throws {InvalidParameterError} If X contains invalid indices
+   */
+  inverseTransform(X) {
+    if (!this.fitted) {
+      throw new NotFittedError("OrdinalEncoder must be fitted before inverse_transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const fittedFeatures = this.categories_?.length ?? 0;
+    if (nFeatures !== fittedFeatures) {
+      throw new InvalidParameterError(
+        "X has a different feature count than during fit",
+        "X",
+        nFeatures
+      );
+    }
+    if (nSamples === 0 || nFeatures === 0) {
+      const categoryRows = this.categories_ ?? [];
+      const categoryType = inferCategoryTypeFromRows(categoryRows, "X");
+      if (categoryType === "string") {
+        return empty([0, nFeatures], { dtype: "string" });
+      }
+      if (categoryType === "bigint") {
+        return empty([0, nFeatures], { dtype: "int64" });
+      }
+      return zeros([0, nFeatures], { dtype: "float64" });
+    }
+    const result = new Array(nSamples);
+    for (let i = 0; i < nSamples; i++) {
+      result[i] = new Array(nFeatures);
+    }
+    const [stride0, stride1] = getStrides2D(X);
+    const data = getNumericData(X);
+    for (let i = 0; i < nSamples; i++) {
+      for (let j = 0; j < nFeatures; j++) {
+        const raw = data[X.offset + i * stride0 + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const idx = Number(raw);
+        const isUnknownValue = this.handleUnknown === "useEncodedValue" && (Number.isNaN(idx) ? Number.isNaN(this.unknownValue) : idx === this.unknownValue);
+        if (isUnknownValue) {
+          throw new InvalidParameterError(
+            "Cannot inverse-transform unknown encoded value",
+            "X",
+            idx
+          );
+        }
+        const cats = this.categories_?.[j];
+        if (!cats || idx < 0 || idx >= cats.length || !Number.isInteger(idx)) {
+          throw new InvalidParameterError(
+            `Invalid encoded value: ${idx} for feature ${j}. Must be integer in [0, ${(cats?.length ?? 0) - 1}]`,
+            "X",
+            idx
+          );
+        }
+        const row = result[i];
+        if (!row) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        const catVal = cats[idx];
+        if (catVal === void 0) {
+          throw new DeepboxError("Internal error: category value missing");
+        }
+        row[j] = catVal;
+      }
+    }
+    return toCategoryMatrixTensor(result, "X");
+  }
+};
+var LabelBinarizer = class {
+  /** Indicates whether the binarizer has been fitted to data */
+  fitted = false;
+  /** Array of unique classes found during fitting, sorted */
+  classes_;
+  /** Map from class value to index for O(1) lookups */
+  classToIndex_;
+  /** Value used for positive class */
+  posLabel;
+  /** Value used for negative class */
+  negLabel;
+  /** Whether to return sparse matrix output */
+  sparse;
+  /**
+   * Creates a new LabelBinarizer instance.
+   *
+   * @param options - Configuration options
+   * @param options.posLabel - Value for positive class (default: 1)
+   * @param options.negLabel - Value for negative class (default: 0)
+   * @param options.sparse - If true, returns CSRMatrix (default: false)
+   * @param options.sparseOutput - Alias for sparse (default: false)
+   */
+  constructor(options = {}) {
+    this.posLabel = options.posLabel ?? 1;
+    this.negLabel = options.negLabel ?? 0;
+    const sparseOption = options.sparse ?? options.sparseOutput ?? false;
+    if (!Number.isFinite(this.posLabel) || !Number.isFinite(this.negLabel)) {
+      throw new InvalidParameterError("posLabel and negLabel must be finite numbers", "posLabel");
+    }
+    if (this.posLabel <= this.negLabel) {
+      throw new InvalidParameterError(
+        "posLabel must be greater than negLabel",
+        "posLabel",
+        this.posLabel
+      );
+    }
+    if (options.sparse !== void 0 && options.sparseOutput !== void 0) {
+      if (options.sparse !== options.sparseOutput) {
+        throw new InvalidParameterError(
+          "sparse and sparseOutput must match when both are provided",
+          "sparse",
+          options.sparse
+        );
+      }
+    }
+    if (typeof sparseOption !== "boolean") {
+      throw new InvalidParameterError("sparse must be a boolean", "sparse", sparseOption);
+    }
+    if (sparseOption && this.negLabel !== 0) {
+      throw new InvalidParameterError(
+        "sparse output requires negLabel to be 0",
+        "negLabel",
+        this.negLabel
+      );
+    }
+    this.sparse = sparseOption;
+  }
+  /**
+   * Fit label binarizer to a set of labels.
+   * Learns the unique classes present in the data.
+   *
+   * @param y - Target labels (1D tensor)
+   * @returns this - Returns self for method chaining
+   * @throws {InvalidParameterError} If y is empty
+   */
+  fit(y) {
+    assert1D(y, "y");
+    if (y.size === 0) {
+      throw new InvalidParameterError("Cannot fit LabelBinarizer on empty array", "y");
+    }
+    const uniqueSet = /* @__PURE__ */ new Set();
+    for (let i = 0; i < y.size; i++) {
+      uniqueSet.add(read1DValue(y, i));
+    }
+    this.classes_ = sortCategories(uniqueSet, "y");
+    this.classToIndex_ = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.classes_.length; i++) {
+      this.classToIndex_.set(categoryValueAt(this.classes_, i, "LabelBinarizer.fit"), i);
+    }
+    this.fitted = true;
+    return this;
+  }
+  /**
+   * Transform labels to binary matrix.
+   * Each label is converted to a binary vector with a single 1.
+   *
+   * @param y - Labels to transform (1D tensor)
+   * @returns Binary matrix (Tensor or CSRMatrix) with shape [n_samples, n_classes]
+   * @throws {NotFittedError} If binarizer is not fitted
+   * @throws {InvalidParameterError} If y contains unknown labels
+   */
+  transform(y) {
+    if (!this.fitted) {
+      throw new NotFittedError("LabelBinarizer must be fitted before transform");
+    }
+    assert1D(y, "y");
+    if (y.size === 0) {
+      const nClasses2 = this.classes_?.length ?? 0;
+      return this.sparse ? CSRMatrix.fromCOO({
+        rows: 0,
+        cols: nClasses2,
+        rowIndices: new Int32Array(0),
+        colIndices: new Int32Array(0),
+        values: new Float64Array(0)
+      }) : zeros([0, nClasses2], { dtype: "float64" });
+    }
+    const nSamples = y.size;
+    const nClasses = this.classes_?.length ?? 0;
+    const lookup = this.classToIndex_;
+    if (!lookup) {
+      throw new DeepboxError("LabelBinarizer internal error: missing fitted lookup");
+    }
+    if (this.sparse) {
+      const rowIdx = [];
+      const colIdx = [];
+      const vals = [];
+      for (let i = 0; i < nSamples; i++) {
+        const val = read1DValue(y, i);
+        const idx = lookup.get(val);
+        if (idx === void 0) {
+          throw new InvalidParameterError(
+            `Unknown label: ${String(val)}. Label must be present during fit.`,
+            "y",
+            val
+          );
+        }
+        rowIdx.push(i);
+        colIdx.push(idx);
+        vals.push(this.posLabel);
+      }
+      return CSRMatrix.fromCOO({
+        rows: nSamples,
+        cols: nClasses,
+        rowIndices: Int32Array.from(rowIdx),
+        colIndices: Int32Array.from(colIdx),
+        values: Float64Array.from(vals)
+      });
+    }
+    const result = new Array(nSamples);
+    for (let i = 0; i < nSamples; i++) {
+      result[i] = new Array(nClasses).fill(this.negLabel);
+    }
+    for (let i = 0; i < nSamples; i++) {
+      const val = read1DValue(y, i);
+      const idx = lookup.get(val);
+      if (idx === void 0) {
+        throw new InvalidParameterError(
+          `Unknown label: ${String(val)}. Label must be present during fit.`,
+          "y",
+          val
+        );
+      }
+      const row = result[i];
+      if (!row) {
+        throw new DeepboxError("Internal error: result row access failed");
+      }
+      row[idx] = this.posLabel;
+    }
+    return tensor(result, { dtype: "float64" });
+  }
+  /**
+   * Fit binarizer and transform labels in one step.
+   * Convenience method equivalent to calling fit(y).transform(y).
+   *
+   * @param y - Target labels (1D tensor)
+   * @returns Binary matrix (Tensor or CSRMatrix)
+   */
+  fitTransform(y) {
+    return this.fit(y).transform(y);
+  }
+  /**
+   * Transform binary matrix back to labels.
+   * Finds the column with maximum value for each row.
+   *
+   * @param Y - Binary matrix (2D tensor or CSRMatrix)
+   * @returns Original labels (1D tensor)
+   * @throws {NotFittedError} If binarizer is not fitted
+   * @throws {InvalidParameterError} If Y has invalid shape
+   */
+  inverseTransform(Y) {
+    if (!this.fitted) {
+      throw new NotFittedError("LabelBinarizer must be fitted before inverse_transform");
+    }
+    if (Y instanceof CSRMatrix) {
+      if (this.negLabel !== 0) {
+        throw new InvalidParameterError(
+          "Sparse inverse transform requires negLabel to be 0",
+          "negLabel",
+          this.negLabel
+        );
+      }
+      const [rows, cols] = Y.shape;
+      if (rows === void 0 || cols === void 0) {
+        throw new ShapeError("Y must have valid shape");
+      }
+      const nClasses2 = this.classes_?.length ?? 0;
+      if (cols !== nClasses2) {
+        throw new InvalidParameterError("column count does not match number of classes", "Y", cols);
+      }
+      const classes2 = this.classes_;
+      if (!classes2) {
+        throw new DeepboxError("LabelBinarizer internal error: missing fitted classes");
+      }
+      if (rows === 0) {
+        return emptyCategoryVectorFromClasses(classes2, "y");
+      }
+      const result2 = new Array(rows);
+      for (let i = 0; i < rows; i++) {
+        let maxIdx = 0;
+        let maxVal = this.negLabel;
+        const start = Y.indptr[i] ?? 0;
+        const end = Y.indptr[i + 1] ?? start;
+        for (let p = start; p < end; p++) {
+          const col = Y.indices[p];
+          if (col === void 0) {
+            throw new DeepboxError("Internal error: sparse column index missing");
+          }
+          if (col < 0 || col >= nClasses2) {
+            throw new InvalidParameterError(
+              "column index out of bounds for fitted classes",
+              "Y",
+              col
+            );
+          }
+          const raw = Y.data[p];
+          if (raw === void 0) {
+            throw new DeepboxError("Internal error: sparse value missing");
+          }
+          const val = Number(raw);
+          if (val > maxVal) {
+            maxVal = val;
+            maxIdx = col;
+          }
+        }
+        if (maxVal <= this.negLabel) {
+          throw new InvalidParameterError(
+            `No active label found for sample ${i}. LabelBinarizer expects exactly one active label.`,
+            "Y"
+          );
+        }
+        result2[i] = categoryValueAt(classes2, maxIdx, "LabelBinarizer.inverseTransform");
+      }
+      return toCategoryVectorTensor(result2, "y");
+    }
+    assert2D(Y, "Y");
+    assertNumericTensor(Y, "Y");
+    const [nSamples, nCols] = getShape2D(Y);
+    const nClasses = this.classes_?.length ?? 0;
+    if (nCols !== nClasses) {
+      throw new InvalidParameterError("column count does not match number of classes", "Y", nCols);
+    }
+    const classes = this.classes_;
+    if (!classes) {
+      throw new DeepboxError("LabelBinarizer internal error: missing fitted classes");
+    }
+    if (nSamples === 0) {
+      return emptyCategoryVectorFromClasses(classes, "y");
+    }
+    const result = new Array(nSamples);
+    const [stride0, stride1] = getStrides2D(Y);
+    const data = getNumericData(Y);
+    for (let i = 0; i < nSamples; i++) {
+      let maxIdx = 0;
+      const rowBase = Y.offset + i * stride0;
+      const first = data[rowBase];
+      if (first === void 0) {
+        throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+      }
+      let maxVal = Number(first);
+      for (let j = 1; j < nCols; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const val = Number(raw);
+        if (val > maxVal) {
+          maxVal = val;
+          maxIdx = j;
+        }
+      }
+      if (maxVal <= this.negLabel) {
+        throw new InvalidParameterError(
+          `No active label found for sample ${i}. LabelBinarizer expects exactly one active label.`,
+          "Y"
+        );
+      }
+      result[i] = categoryValueAt(classes, maxIdx, "LabelBinarizer.inverseTransform");
+    }
+    return toCategoryVectorTensor(result, "y");
+  }
+};
+var MultiLabelBinarizer = class {
+  /** Indicates whether the binarizer has been fitted to data */
+  fitted = false;
+  /** Array of all unique classes found across all samples, sorted */
+  classes_;
+  /** Map from class value to index for O(1) lookups */
+  classToIndex_;
+  /** Whether to return sparse matrix (CSR) or dense array */
+  sparse;
+  /** Optional explicit class ordering */
+  classesOption;
+  /**
+   * Creates a new MultiLabelBinarizer instance.
+   *
+   * @param options - Configuration options
+   * @param options.sparse - If true, returns CSRMatrix; if false, returns dense Tensor (default: false)
+   * @param options.sparseOutput - Alias for sparse (default: false)
+   * @param options.classes - Explicit class ordering to use instead of sorting
+   */
+  constructor(options = {}) {
+    const sparseOption = options.sparse ?? options.sparseOutput ?? false;
+    if (options.sparse !== void 0 && options.sparseOutput !== void 0) {
+      if (options.sparse !== options.sparseOutput) {
+        throw new InvalidParameterError(
+          "sparse and sparseOutput must match when both are provided",
+          "sparse",
+          options.sparse
+        );
+      }
+    }
+    this.sparse = sparseOption;
+    if (typeof this.sparse !== "boolean") {
+      throw new InvalidParameterError("sparse must be a boolean", "sparse", this.sparse);
+    }
+    if (options.classes !== void 0) {
+      this.classesOption = validateCategoryValues(options.classes, "classes");
+    }
+  }
+  /**
+   * Fit multi-label binarizer to label sets.
+   * Learns all unique classes present across all samples.
+   *
+   * @param y - Array of label sets, where each element is an array of string/number/bigint labels
+   * @returns this - Returns self for method chaining
+   * @throws {InvalidParameterError} If y is empty
+   */
+  fit(y) {
+    if (y.length === 0) {
+      throw new InvalidParameterError("Cannot fit MultiLabelBinarizer on empty array", "y");
+    }
+    for (const labels of y) {
+      if (!Array.isArray(labels)) {
+        throw new InvalidParameterError("MultiLabelBinarizer expects label arrays", "y", labels);
+      }
+      for (const label of labels) {
+        if (typeof label !== "string" && typeof label !== "number" && typeof label !== "bigint") {
+          throw new InvalidParameterError(
+            "MultiLabelBinarizer labels must be strings, numbers, or bigints",
+            "y",
+            label
+          );
+        }
+      }
+    }
+    if (this.classesOption && this.classesOption.length === 0) {
+      throw new InvalidParameterError("classes must contain at least one value", "classes");
+    }
+    if (this.classesOption) {
+      this.classes_ = Array.from(this.classesOption);
+    } else {
+      const uniqueSet = /* @__PURE__ */ new Set();
+      for (const labels of y) {
+        for (const label of labels) {
+          uniqueSet.add(label);
+        }
+      }
+      this.classes_ = sortCategories(uniqueSet, "y");
+    }
+    this.classToIndex_ = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.classes_.length; i++) {
+      this.classToIndex_.set(categoryValueAt(this.classes_, i, "MultiLabelBinarizer.fit"), i);
+    }
+    if (this.classesOption) {
+      for (const labels of y) {
+        for (const label of labels) {
+          if (!this.classToIndex_.has(label)) {
+            throw new InvalidParameterError(
+              `Unknown label: ${String(label)}. Label must be present in classes.`,
+              "y",
+              label
+            );
+          }
+        }
+      }
+    }
+    this.fitted = true;
+    return this;
+  }
+  /**
+   * Transform label sets to binary matrix.
+   * Each sample can have multiple active (1) columns.
+   *
+   * @param y - Array of label sets to transform (string/number/bigint labels)
+   * @returns Binary matrix (Tensor or CSRMatrix) with shape [n_samples, n_classes]
+   * @throws {NotFittedError} If binarizer is not fitted
+   * @throws {InvalidParameterError} If y contains unknown labels
+   */
+  transform(y) {
+    if (!this.fitted) {
+      throw new NotFittedError("MultiLabelBinarizer must be fitted before transform");
+    }
+    for (const labels of y) {
+      if (!Array.isArray(labels)) {
+        throw new InvalidParameterError("MultiLabelBinarizer expects label arrays", "y", labels);
+      }
+      for (const label of labels) {
+        if (typeof label !== "string" && typeof label !== "number" && typeof label !== "bigint") {
+          throw new InvalidParameterError(
+            "MultiLabelBinarizer labels must be strings, numbers, or bigints",
+            "y",
+            label
+          );
+        }
+      }
+    }
+    if (y.length === 0) {
+      const nClasses2 = this.classes_?.length ?? 0;
+      return this.sparse ? CSRMatrix.fromCOO({
+        rows: 0,
+        cols: nClasses2,
+        rowIndices: new Int32Array(0),
+        colIndices: new Int32Array(0),
+        values: new Float64Array(0)
+      }) : zeros([0, nClasses2], { dtype: "float64" });
+    }
+    const nSamples = y.length;
+    const nClasses = this.classes_?.length ?? 0;
+    const lookup = this.classToIndex_;
+    if (!lookup) {
+      throw new DeepboxError("MultiLabelBinarizer internal error: missing fitted lookup");
+    }
+    if (this.sparse) {
+      const rowIdx = [];
+      const colIdx = [];
+      const vals = [];
+      for (let i = 0; i < nSamples; i++) {
+        const yRow = y[i];
+        if (!yRow) continue;
+        const seen = /* @__PURE__ */ new Set();
+        for (const label of yRow) {
+          const idx = lookup.get(label);
+          if (idx === void 0) {
+            throw new InvalidParameterError(
+              `Unknown label: ${String(label)}. Label must be present during fit.`,
+              "y",
+              label
+            );
+          }
+          if (seen.has(idx)) continue;
+          seen.add(idx);
+          rowIdx.push(i);
+          colIdx.push(idx);
+          vals.push(1);
+        }
+      }
+      return CSRMatrix.fromCOO({
+        rows: nSamples,
+        cols: nClasses,
+        rowIndices: Int32Array.from(rowIdx),
+        colIndices: Int32Array.from(colIdx),
+        values: Float64Array.from(vals)
+      });
+    }
+    const result = new Array(nSamples);
+    for (let i = 0; i < nSamples; i++) {
+      result[i] = new Array(nClasses).fill(0);
+    }
+    for (let i = 0; i < nSamples; i++) {
+      const yRow = y[i];
+      if (!yRow) continue;
+      for (const label of yRow) {
+        const idx = lookup.get(label);
+        if (idx === void 0) {
+          throw new InvalidParameterError(
+            `Unknown label: ${String(label)}. Label must be present during fit.`,
+            "y",
+            label
+          );
+        }
+        const row = result[i];
+        if (!row) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        row[idx] = 1;
+      }
+    }
+    return tensor(result, { dtype: "float64" });
+  }
+  /**
+   * Fit binarizer and transform label sets in one step.
+   * Convenience method equivalent to calling fit(y).transform(y).
+   *
+   * @param y - Array of label sets (string/number/bigint labels)
+   * @returns Binary matrix (Tensor or CSRMatrix)
+   */
+  fitTransform(y) {
+    return this.fit(y).transform(y);
+  }
+  /**
+   * Transform binary matrix back to label sets.
+   * Finds all active (1) columns for each row.
+   *
+   * @param Y - Binary matrix (Tensor or CSRMatrix)
+   * @returns Array of label sets, one per sample
+   * @throws {NotFittedError} If binarizer is not fitted
+   * @throws {InvalidParameterError} If Y has invalid shape
+   */
+  inverseTransform(Y) {
+    if (!this.fitted) {
+      throw new NotFittedError("MultiLabelBinarizer must be fitted before inverse_transform");
+    }
+    if (Y instanceof CSRMatrix) {
+      const [rows, cols] = Y.shape;
+      if (rows === void 0 || cols === void 0) {
+        throw new ShapeError("Y must have valid shape");
+      }
+      const fittedClasses2 = this.classes_?.length ?? 0;
+      if (cols !== fittedClasses2) {
+        throw new InvalidParameterError("column count does not match number of classes", "Y", cols);
+      }
+      if (rows === 0) {
+        return [];
+      }
+      const classes2 = this.classes_;
+      if (!classes2) {
+        throw new DeepboxError("MultiLabelBinarizer internal error: missing fitted classes");
+      }
+      const result2 = [];
+      for (let i = 0; i < rows; i++) {
+        const labels = [];
+        const start = Y.indptr[i] ?? 0;
+        const end = Y.indptr[i + 1] ?? start;
+        for (let p = start; p < end; p++) {
+          const col = Y.indices[p];
+          if (col === void 0) {
+            throw new DeepboxError("Internal error: sparse column index missing");
+          }
+          if (col < 0 || col >= fittedClasses2) {
+            throw new InvalidParameterError(
+              "column index out of bounds for fitted classes",
+              "Y",
+              col
+            );
+          }
+          const raw = Y.data[p];
+          if (raw === void 0) {
+            throw new DeepboxError("Internal error: sparse value missing");
+          }
+          const value = Number(raw);
+          if (value > 0) {
+            labels.push(categoryValueAt(classes2, col, "MultiLabelBinarizer.inverseTransform"));
+          }
+        }
+        result2.push(labels);
+      }
+      return result2;
+    }
+    assert2D(Y, "Y");
+    assertNumericTensor(Y, "Y");
+    const nSamples = Y.shape[0] ?? 0;
+    const nClasses = Y.shape[1] ?? 0;
+    const fittedClasses = this.classes_?.length ?? 0;
+    if (nClasses !== fittedClasses) {
+      throw new InvalidParameterError(
+        "column count does not match number of classes",
+        "Y",
+        nClasses
+      );
+    }
+    if (nSamples === 0) {
+      return [];
+    }
+    const classes = this.classes_;
+    if (!classes) {
+      throw new DeepboxError("MultiLabelBinarizer internal error: missing fitted classes");
+    }
+    const result = [];
+    const [stride0, stride1] = getStrides2D(Y);
+    const data = getNumericData(Y);
+    for (let i = 0; i < nSamples; i++) {
+      const labels = [];
+      const rowBase = Y.offset + i * stride0;
+      for (let j = 0; j < nClasses; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const val = Number(raw);
+        if (val > 0) {
+          labels.push(categoryValueAt(classes, j, "MultiLabelBinarizer.inverseTransform"));
+        }
+      }
+      result.push(labels);
+    }
+    return result;
+  }
+};
+
+// src/preprocess/scalers.ts
+function getNumericData2(X, name) {
+  if (X.dtype === "string") {
+    throw new DTypeError(`${name} must be numeric`);
+  }
+  if (Array.isArray(X.data)) {
+    throw new DeepboxError("Internal error: invalid numeric tensor storage");
+  }
+  return X.data;
+}
+function parseBooleanOption(value, name, defaultValue) {
+  if (value === void 0) {
+    return defaultValue;
+  }
+  if (typeof value !== "boolean") {
+    throw new InvalidParameterError(`${name} must be a boolean`, name, value);
+  }
+  return value;
+}
+function validateFiniteData(X, name) {
+  const [nSamples, nFeatures] = getShape2D(X);
+  const data = getNumericData2(X, name);
+  const [stride0, stride1] = getStrides2D(X);
+  let flatIndex = 0;
+  for (let i = 0; i < nSamples; i++) {
+    const rowBase = X.offset + i * stride0;
+    for (let j = 0; j < nFeatures; j++) {
+      const raw = data[rowBase + j * stride1];
+      if (raw === void 0) {
+        throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+      }
+      const val = Number(raw);
+      if (!Number.isFinite(val)) {
+        throw new DataValidationError(`${name} contains NaN or Infinity at index ${flatIndex}`);
+      }
+      flatIndex += 1;
+    }
+  }
+}
+function snapInverseValue(value) {
+  if (!Number.isFinite(value)) return value;
+  const rounded = Math.round(value);
+  if (Math.abs(value - rounded) < 1e-12) return rounded;
+  const scaled = Math.round(value * 1e12) / 1e12;
+  if (Math.abs(value - scaled) < 1e-12) return scaled;
+  return value;
+}
+function normalQuantile(p) {
+  if (!Number.isFinite(p) || p <= 0 || p >= 1) {
+    throw new InvalidParameterError(
+      "normalQuantile requires p in the open interval (0, 1)",
+      "p",
+      p
+    );
+  }
+  const a1 = -39.69683028665376;
+  const a2 = 220.9460984245205;
+  const a3 = -275.9285104469687;
+  const a4 = 138.357751867269;
+  const a5 = -30.66479806614716;
+  const a6 = 2.506628277459239;
+  const b1 = -54.47609879822406;
+  const b2 = 161.5858368580409;
+  const b3 = -155.6989798598866;
+  const b4 = 66.80131188771972;
+  const b5 = -13.28068155288572;
+  const c1 = -0.007784894002430293;
+  const c2 = -0.3223964580411365;
+  const c3 = -2.400758277161838;
+  const c4 = -2.549732539343734;
+  const c5 = 4.374664141464968;
+  const c6 = 2.938163982698783;
+  const d1 = 0.007784695709041462;
+  const d2 = 0.3224671290700398;
+  const d3 = 2.445134137142996;
+  const d4 = 3.754408661907416;
+  const plow = 0.02425;
+  const phigh = 1 - plow;
+  if (p < plow) {
+    const q2 = Math.sqrt(-2 * Math.log(p));
+    return (((((c1 * q2 + c2) * q2 + c3) * q2 + c4) * q2 + c5) * q2 + c6) / ((((d1 * q2 + d2) * q2 + d3) * q2 + d4) * q2 + 1);
+  }
+  if (p > phigh) {
+    const q2 = Math.sqrt(-2 * Math.log(1 - p));
+    return -((((((c1 * q2 + c2) * q2 + c3) * q2 + c4) * q2 + c5) * q2 + c6) / ((((d1 * q2 + d2) * q2 + d3) * q2 + d4) * q2 + 1));
+  }
+  const q = p - 0.5;
+  const r = q * q;
+  return (((((a1 * r + a2) * r + a3) * r + a4) * r + a5) * r + a6) * q / (((((b1 * r + b2) * r + b3) * r + b4) * r + b5) * r + 1);
+}
+var StandardScaler = class {
+  fitted = false;
+  mean_;
+  scale_;
+  withMean;
+  withStd;
+  /**
+   * Creates a new StandardScaler.
+   *
+   * @param options - Configuration options
+   * @param options.withMean - Center data before scaling (default: true)
+   * @param options.withStd - Scale data to unit variance (default: true)
+   * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+   */
+  constructor(options = {}) {
+    this.withMean = parseBooleanOption(options.withMean, "withMean", true);
+    this.withStd = parseBooleanOption(options.withStd, "withStd", true);
+    parseBooleanOption(options.copy, "copy", true);
+  }
+  fit(X) {
+    if (X.size === 0) {
+      throw new InvalidParameterError("X must contain at least one sample", "X");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    let means;
+    if (this.withMean || this.withStd) {
+      means = new Array(nFeatures).fill(0);
+      for (let j = 0; j < nFeatures; j++) {
+        let sum = 0;
+        for (let i = 0; i < nSamples; i++) {
+          const raw = data[X.offset + i * stride0 + j * stride1];
+          if (raw === void 0) {
+            throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+          }
+          sum += Number(raw);
+        }
+        if (means) {
+          means[j] = sum / nSamples;
+        }
+      }
+    }
+    if (this.withStd) {
+      const stds = new Array(nFeatures).fill(0);
+      for (let j = 0; j < nFeatures; j++) {
+        const mean = means ? means[j] ?? 0 : 0;
+        let sumSq = 0;
+        for (let i = 0; i < nSamples; i++) {
+          const raw = data[X.offset + i * stride0 + j * stride1];
+          if (raw === void 0) {
+            throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+          }
+          const val = Number(raw) - mean;
+          sumSq += val * val;
+        }
+        stds[j] = Math.sqrt(sumSq / nSamples);
+      }
+      this.scale_ = tensor(stds, { dtype: "float64" });
+    } else {
+      this.scale_ = void 0;
+    }
+    this.mean_ = this.withMean && means ? tensor(means, { dtype: "float64" }) : void 0;
+    this.fitted = true;
+    return this;
+  }
+  transform(X) {
+    if (!this.fitted) {
+      throw new NotFittedError("StandardScaler must be fitted before transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const mean = this.mean_;
+    const scale = this.scale_;
+    const meanData = mean ? getNumericData2(mean, "mean_") : void 0;
+    const scaleData = scale ? getNumericData2(scale, "scale_") : void 0;
+    const meanStride = mean ? getStride1D(mean) : 0;
+    const scaleStride = scale ? getStride1D(scale) : 0;
+    if (this.withMean && !mean) {
+      throw new DeepboxError("StandardScaler internal error: missing mean_");
+    }
+    if (this.withStd && !scale) {
+      throw new DeepboxError("StandardScaler internal error: missing scale_");
+    }
+    const result = Array.from({ length: nSamples }, () => new Array(nFeatures).fill(0));
+    for (let i = 0; i < nSamples; i++) {
+      const rowBase = X.offset + i * stride0;
+      for (let j = 0; j < nFeatures; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        let val = Number(raw);
+        if (this.withMean && mean && meanData) {
+          const meanValue = meanData[mean.offset + j * meanStride];
+          if (meanValue === void 0) {
+            throw new DeepboxError("Internal error: mean tensor access out of bounds");
+          }
+          val -= Number(meanValue);
+        }
+        if (this.withStd && scale && scaleData) {
+          const rawScale = scaleData[scale.offset + j * scaleStride];
+          if (rawScale === void 0) {
+            throw new DeepboxError("Internal error: scale tensor access out of bounds");
+          }
+          const std = Number(rawScale);
+          const safeStd = std === 0 ? 1 : std;
+          val /= safeStd;
+        }
+        const row = result[i];
+        if (row === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        row[j] = val;
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+  fitTransform(X) {
+    return this.fit(X).transform(X);
+  }
+  inverseTransform(X) {
+    if (!this.fitted) {
+      throw new NotFittedError("StandardScaler must be fitted before inverse_transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const mean = this.mean_;
+    const scale = this.scale_;
+    const meanData = mean ? getNumericData2(mean, "mean_") : void 0;
+    const scaleData = scale ? getNumericData2(scale, "scale_") : void 0;
+    const meanStride = mean ? getStride1D(mean) : 0;
+    const scaleStride = scale ? getStride1D(scale) : 0;
+    if (this.withMean && !mean) {
+      throw new DeepboxError("StandardScaler internal error: missing mean_");
+    }
+    if (this.withStd && !scale) {
+      throw new DeepboxError("StandardScaler internal error: missing scale_");
+    }
+    const result = Array.from({ length: nSamples }, () => new Array(nFeatures).fill(0));
+    for (let i = 0; i < nSamples; i++) {
+      const rowBase = X.offset + i * stride0;
+      for (let j = 0; j < nFeatures; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        let val = Number(raw);
+        if (this.withStd && scale && scaleData) {
+          const rawScale = scaleData[scale.offset + j * scaleStride];
+          if (rawScale === void 0) {
+            throw new DeepboxError("Internal error: scale tensor access out of bounds");
+          }
+          const std = Number(rawScale);
+          const safeStd = std === 0 ? 1 : std;
+          val *= safeStd;
+        }
+        if (this.withMean && mean && meanData) {
+          const meanValue = meanData[mean.offset + j * meanStride];
+          if (meanValue === void 0) {
+            throw new DeepboxError("Internal error: mean tensor access out of bounds");
+          }
+          val += Number(meanValue);
+        }
+        const resultRow = result[i];
+        if (resultRow === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        resultRow[j] = snapInverseValue(val);
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+};
+var MinMaxScaler = class {
+  fitted = false;
+  dataMin_;
+  dataMax_;
+  featureRange;
+  clip;
+  /**
+   * Creates a new MinMaxScaler.
+   *
+   * @param options - Configuration options
+   * @param options.featureRange - Desired feature range [min, max] (default: [0, 1])
+   * @param options.clip - Clip transformed values to featureRange (default: false)
+   * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+   */
+  constructor(options = {}) {
+    this.featureRange = options.featureRange ?? [0, 1];
+    this.clip = parseBooleanOption(options.clip, "clip", false);
+    parseBooleanOption(options.copy, "copy", true);
+    const [minRange, maxRange] = this.featureRange;
+    if (!Number.isFinite(minRange) || !Number.isFinite(maxRange) || minRange >= maxRange) {
+      throw new InvalidParameterError(
+        "featureRange must be [min, max] with min < max",
+        "featureRange",
+        this.featureRange
+      );
+    }
+  }
+  fit(X) {
+    if (X.size === 0) {
+      throw new InvalidParameterError("X must contain at least one sample", "X");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const mins = new Array(nFeatures).fill(Number.POSITIVE_INFINITY);
+    const maxs = new Array(nFeatures).fill(Number.NEGATIVE_INFINITY);
+    for (let j = 0; j < nFeatures; j++) {
+      for (let i = 0; i < nSamples; i++) {
+        const raw = data[X.offset + i * stride0 + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const val = Number(raw);
+        const currentMin = mins[j];
+        const currentMax = maxs[j];
+        if (currentMin === void 0 || currentMax === void 0) {
+          throw new DeepboxError("Internal error: min/max array access failed");
+        }
+        mins[j] = Math.min(currentMin, val);
+        maxs[j] = Math.max(currentMax, val);
+      }
+    }
+    this.dataMin_ = tensor(mins, { dtype: "float64" });
+    this.dataMax_ = tensor(maxs, { dtype: "float64" });
+    this.fitted = true;
+    return this;
+  }
+  transform(X) {
+    if (!this.fitted) {
+      throw new NotFittedError("MinMaxScaler must be fitted before transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const [minRange, maxRange] = this.featureRange;
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const dataMin = this.dataMin_;
+    const dataMax = this.dataMax_;
+    if (!dataMin || !dataMax) {
+      throw new DeepboxError("MinMaxScaler internal error: missing fitted min/max");
+    }
+    const minData = getNumericData2(dataMin, "dataMin_");
+    const maxData = getNumericData2(dataMax, "dataMax_");
+    const minStride = getStride1D(dataMin);
+    const maxStride = getStride1D(dataMax);
+    const result = Array.from({ length: nSamples }, () => new Array(nFeatures).fill(0));
+    for (let i = 0; i < nSamples; i++) {
+      const rowBase = X.offset + i * stride0;
+      for (let j = 0; j < nFeatures; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const val = Number(raw);
+        const rawMin = minData[dataMin.offset + j * minStride];
+        const rawMax = maxData[dataMax.offset + j * maxStride];
+        if (rawMin === void 0 || rawMax === void 0) {
+          throw new DeepboxError("Internal error: min/max tensor access out of bounds");
+        }
+        const min = Number(rawMin);
+        const max = Number(rawMax);
+        const range = max - min;
+        const row = result[i];
+        if (row === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        let scaled = range !== 0 ? (val - min) / range * (maxRange - minRange) + minRange : minRange;
+        if (this.clip) {
+          scaled = Math.max(minRange, Math.min(maxRange, scaled));
+        }
+        row[j] = scaled;
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+  fitTransform(X) {
+    return this.fit(X).transform(X);
+  }
+  inverseTransform(X) {
+    if (!this.fitted) {
+      throw new NotFittedError("MinMaxScaler must be fitted before inverse_transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const [minRange, maxRange] = this.featureRange;
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const dataMin = this.dataMin_;
+    const dataMax = this.dataMax_;
+    if (!dataMin || !dataMax) {
+      throw new DeepboxError("MinMaxScaler internal error: missing fitted min/max");
+    }
+    const minData = getNumericData2(dataMin, "dataMin_");
+    const maxData = getNumericData2(dataMax, "dataMax_");
+    const minStride = getStride1D(dataMin);
+    const maxStride = getStride1D(dataMax);
+    const result = Array.from({ length: nSamples }, () => new Array(nFeatures).fill(0));
+    for (let i = 0; i < nSamples; i++) {
+      const rowBase = X.offset + i * stride0;
+      for (let j = 0; j < nFeatures; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const val = Number(raw);
+        const rawMin = minData[dataMin.offset + j * minStride];
+        const rawMax = maxData[dataMax.offset + j * maxStride];
+        if (rawMin === void 0 || rawMax === void 0) {
+          throw new DeepboxError("Internal error: min/max tensor access out of bounds");
+        }
+        const min = Number(rawMin);
+        const max = Number(rawMax);
+        const range = max - min;
+        const row = result[i];
+        if (row === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        row[j] = (val - minRange) / (maxRange - minRange) * range + min;
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+};
+var MaxAbsScaler = class {
+  fitted = false;
+  maxAbs_;
+  /**
+   * Creates a new MaxAbsScaler.
+   *
+   * @param options - Configuration options
+   * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+   */
+  constructor(options = {}) {
+    parseBooleanOption(options.copy, "copy", true);
+  }
+  fit(X) {
+    if (X.size === 0) {
+      throw new InvalidParameterError("X must contain at least one sample", "X");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const maxAbs = new Array(nFeatures).fill(0);
+    for (let j = 0; j < nFeatures; j++) {
+      for (let i = 0; i < nSamples; i++) {
+        const raw = data[X.offset + i * stride0 + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const currentMax = maxAbs[j];
+        if (currentMax === void 0) {
+          throw new DeepboxError("Internal error: maxAbs array access failed");
+        }
+        maxAbs[j] = Math.max(currentMax, Math.abs(Number(raw)));
+      }
+    }
+    this.maxAbs_ = tensor(maxAbs, { dtype: "float64" });
+    this.fitted = true;
+    return this;
+  }
+  transform(X) {
+    if (!this.fitted) {
+      throw new NotFittedError("MaxAbsScaler must be fitted before transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const maxAbs = this.maxAbs_;
+    if (!maxAbs) {
+      throw new DeepboxError("MaxAbsScaler internal error: missing fitted maxAbs");
+    }
+    const maxData = getNumericData2(maxAbs, "maxAbs_");
+    const maxStride = getStride1D(maxAbs);
+    const result = Array.from({ length: nSamples }, () => new Array(nFeatures).fill(0));
+    for (let i = 0; i < nSamples; i++) {
+      const rowBase = X.offset + i * stride0;
+      for (let j = 0; j < nFeatures; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const val = Number(raw);
+        const rawScale = maxData[maxAbs.offset + j * maxStride];
+        if (rawScale === void 0) {
+          throw new DeepboxError("Internal error: maxAbs tensor access out of bounds");
+        }
+        const scale = Number(rawScale);
+        const safeScale = scale === 0 ? 1 : scale;
+        const row = result[i];
+        if (row === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        row[j] = val / safeScale;
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+  fitTransform(X) {
+    return this.fit(X).transform(X);
+  }
+  inverseTransform(X) {
+    if (!this.fitted) {
+      throw new NotFittedError("MaxAbsScaler must be fitted before inverse_transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const maxAbs = this.maxAbs_;
+    if (!maxAbs) {
+      throw new DeepboxError("MaxAbsScaler internal error: missing fitted maxAbs");
+    }
+    const maxData = getNumericData2(maxAbs, "maxAbs_");
+    const maxStride = getStride1D(maxAbs);
+    const result = Array.from({ length: nSamples }, () => new Array(nFeatures).fill(0));
+    for (let i = 0; i < nSamples; i++) {
+      const rowBase = X.offset + i * stride0;
+      for (let j = 0; j < nFeatures; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const val = Number(raw);
+        const rawScale = maxData[maxAbs.offset + j * maxStride];
+        if (rawScale === void 0) {
+          throw new DeepboxError("Internal error: maxAbs tensor access out of bounds");
+        }
+        const scale = Number(rawScale);
+        const row = result[i];
+        if (row === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        row[j] = val * scale;
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+};
+var RobustScaler = class {
+  fitted = false;
+  center_;
+  scale_;
+  withCentering;
+  withScaling;
+  quantileRange;
+  unitVariance;
+  /**
+   * Creates a new RobustScaler.
+   *
+   * @param options - Configuration options
+   * @param options.withCentering - Center data using median (default: true)
+   * @param options.withScaling - Scale data using IQR (default: true)
+   * @param options.quantileRange - Quantile range for IQR as percentiles (default: [25, 75])
+   * @param options.unitVariance - Scale so that features have unit variance under normality (default: false)
+   * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+   */
+  constructor(options = {}) {
+    this.withCentering = parseBooleanOption(options.withCentering, "withCentering", true);
+    this.withScaling = parseBooleanOption(options.withScaling, "withScaling", true);
+    this.quantileRange = options.quantileRange ?? [25, 75];
+    this.unitVariance = parseBooleanOption(options.unitVariance, "unitVariance", false);
+    parseBooleanOption(options.copy, "copy", true);
+    const [lower, upper] = this.quantileRange;
+    if (!Number.isFinite(lower) || !Number.isFinite(upper) || lower < 0 || upper > 100 || lower >= upper) {
+      throw new InvalidParameterError(
+        "quantileRange must be a valid ascending percentile range",
+        "quantileRange",
+        this.quantileRange
+      );
+    }
+  }
+  fit(X) {
+    if (X.size === 0) {
+      throw new InvalidParameterError("X must contain at least one sample", "X");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const centers = new Array(nFeatures).fill(0);
+    const scales = new Array(nFeatures).fill(0);
+    const [lowerPercentile, upperPercentile] = this.quantileRange;
+    const lowerFraction = lowerPercentile / 100;
+    const upperFraction = upperPercentile / 100;
+    const normalizer = this.unitVariance ? normalQuantile(upperFraction) - normalQuantile(lowerFraction) : 1;
+    if (this.unitVariance && (!Number.isFinite(normalizer) || normalizer <= 0)) {
+      throw new DeepboxError("RobustScaler internal error: invalid unit variance normalizer");
+    }
+    for (let j = 0; j < nFeatures; j++) {
+      const values = [];
+      for (let i = 0; i < nSamples; i++) {
+        const raw = data[X.offset + i * stride0 + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        values.push(Number(raw));
+      }
+      values.sort((a, b) => a - b);
+      const interpolate = (q) => {
+        if (values.length === 0) {
+          throw new DeepboxError("Internal error: cannot interpolate empty values");
+        }
+        if (values.length === 1) {
+          const only = values[0];
+          if (only === void 0) {
+            throw new DeepboxError("Internal error: missing sorted value");
+          }
+          return only;
+        }
+        const position = q * (values.length - 1);
+        const lower = Math.floor(position);
+        const upper = Math.ceil(position);
+        const lowerValue = values[lower];
+        const upperValue = values[upper];
+        if (lowerValue === void 0 || upperValue === void 0) {
+          throw new DeepboxError("Internal error: quantile interpolation index out of bounds");
+        }
+        if (upper === lower) {
+          return lowerValue;
+        }
+        const weight = position - lower;
+        return lowerValue * (1 - weight) + upperValue * weight;
+      };
+      centers[j] = interpolate(0.5);
+      const qLower = interpolate(lowerFraction);
+      const qUpper = interpolate(upperFraction);
+      const iqr = qUpper - qLower;
+      scales[j] = this.unitVariance ? iqr / normalizer : iqr;
+    }
+    this.center_ = this.withCentering ? tensor(centers, { dtype: "float64" }) : void 0;
+    this.scale_ = this.withScaling ? tensor(scales, { dtype: "float64" }) : void 0;
+    this.fitted = true;
+    return this;
+  }
+  transform(X) {
+    if (!this.fitted) {
+      throw new NotFittedError("RobustScaler must be fitted before transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const center = this.center_;
+    const scale = this.scale_;
+    const centerData = center ? getNumericData2(center, "center_") : void 0;
+    const scaleData = scale ? getNumericData2(scale, "scale_") : void 0;
+    const centerStride = center ? getStride1D(center) : 0;
+    const scaleStride = scale ? getStride1D(scale) : 0;
+    if (this.withCentering && !center) {
+      throw new DeepboxError("RobustScaler internal error: missing center_");
+    }
+    if (this.withScaling && !scale) {
+      throw new DeepboxError("RobustScaler internal error: missing scale_");
+    }
+    const result = Array.from({ length: nSamples }, () => new Array(nFeatures).fill(0));
+    for (let i = 0; i < nSamples; i++) {
+      const rowBase = X.offset + i * stride0;
+      for (let j = 0; j < nFeatures; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        let val = Number(raw);
+        if (this.withCentering && center && centerData) {
+          const rawCenter = centerData[center.offset + j * centerStride];
+          if (rawCenter === void 0) {
+            throw new DeepboxError("Internal error: center tensor access out of bounds");
+          }
+          val -= Number(rawCenter);
+        }
+        if (this.withScaling && scale && scaleData) {
+          const rawScale = scaleData[scale.offset + j * scaleStride];
+          if (rawScale === void 0) {
+            throw new DeepboxError("Internal error: scale tensor access out of bounds");
+          }
+          const scaleValue = Number(rawScale);
+          const safeScale = scaleValue === 0 ? 1 : scaleValue;
+          val /= safeScale;
+        }
+        const resultRow = result[i];
+        if (resultRow === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        resultRow[j] = val;
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+  fitTransform(X) {
+    return this.fit(X).transform(X);
+  }
+  inverseTransform(X) {
+    if (!this.fitted) {
+      throw new NotFittedError("RobustScaler must be fitted before inverse_transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const center = this.center_;
+    const scale = this.scale_;
+    const centerData = center ? getNumericData2(center, "center_") : void 0;
+    const scaleData = scale ? getNumericData2(scale, "scale_") : void 0;
+    const centerStride = center ? getStride1D(center) : 0;
+    const scaleStride = scale ? getStride1D(scale) : 0;
+    if (this.withCentering && !center) {
+      throw new DeepboxError("RobustScaler internal error: missing center_");
+    }
+    if (this.withScaling && !scale) {
+      throw new DeepboxError("RobustScaler internal error: missing scale_");
+    }
+    const result = Array.from({ length: nSamples }, () => new Array(nFeatures).fill(0));
+    for (let i = 0; i < nSamples; i++) {
+      const rowBase = X.offset + i * stride0;
+      for (let j = 0; j < nFeatures; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        let val = Number(raw);
+        if (this.withScaling && scale && scaleData) {
+          const rawScale = scaleData[scale.offset + j * scaleStride];
+          if (rawScale === void 0) {
+            throw new DeepboxError("Internal error: scale tensor access out of bounds");
+          }
+          const scaleValue = Number(rawScale);
+          const safeScale = scaleValue === 0 ? 1 : scaleValue;
+          val *= safeScale;
+        }
+        if (this.withCentering && center && centerData) {
+          const rawCenter = centerData[center.offset + j * centerStride];
+          if (rawCenter === void 0) {
+            throw new DeepboxError("Internal error: center tensor access out of bounds");
+          }
+          val += Number(rawCenter);
+        }
+        const resultRow = result[i];
+        if (resultRow === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        resultRow[j] = val;
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+};
+var Normalizer = class {
+  norm;
+  /**
+   * Creates a new Normalizer.
+   *
+   * @param options - Configuration options
+   * @param options.norm - Norm to use (default: "l2")
+   * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+   */
+  constructor(options = {}) {
+    this.norm = options.norm ?? "l2";
+    if (this.norm !== "l1" && this.norm !== "l2" && this.norm !== "max") {
+      throw new InvalidParameterError("norm must be one of: l1, l2, max", "norm", this.norm);
+    }
+    parseBooleanOption(options.copy, "copy", true);
+  }
+  fit(_X) {
+    return this;
+  }
+  transform(X) {
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const result = Array.from({ length: nSamples }, () => new Array(nFeatures).fill(0));
+    for (let i = 0; i < nSamples; i++) {
+      let norm = 0;
+      const rowBase = X.offset + i * stride0;
+      if (this.norm === "l2") {
+        for (let j = 0; j < nFeatures; j++) {
+          const raw = data[rowBase + j * stride1];
+          if (raw === void 0) {
+            throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+          }
+          const val = Number(raw);
+          norm += val * val;
+        }
+        norm = Math.sqrt(norm);
+      } else if (this.norm === "l1") {
+        for (let j = 0; j < nFeatures; j++) {
+          const raw = data[rowBase + j * stride1];
+          if (raw === void 0) {
+            throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+          }
+          norm += Math.abs(Number(raw));
+        }
+      } else if (this.norm === "max") {
+        for (let j = 0; j < nFeatures; j++) {
+          const raw = data[rowBase + j * stride1];
+          if (raw === void 0) {
+            throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+          }
+          norm = Math.max(norm, Math.abs(Number(raw)));
+        }
+      }
+      for (let j = 0; j < nFeatures; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const val = Number(raw);
+        const row = result[i];
+        if (row === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        row[j] = norm === 0 ? val : val / norm;
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+  fitTransform(X) {
+    return this.transform(X);
+  }
+};
+var QuantileTransformer = class {
+  fitted = false;
+  nQuantiles;
+  outputDistribution;
+  quantiles_;
+  subsample;
+  randomState;
+  /**
+   * Creates a new QuantileTransformer.
+   *
+   * @param options - Configuration options
+   * @param options.nQuantiles - Number of quantiles to use (default: 1000)
+   * @param options.outputDistribution - "uniform" or "normal" (default: "uniform")
+   * @param options.subsample - Subsample size for quantile estimation (default: use all samples)
+   * @param options.randomState - Seed for subsampling reproducibility
+   * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+   */
+  constructor(options = {}) {
+    this.nQuantiles = options.nQuantiles ?? 1e3;
+    this.outputDistribution = options.outputDistribution ?? "uniform";
+    this.subsample = options.subsample;
+    this.randomState = options.randomState;
+    parseBooleanOption(options.copy, "copy", true);
+    if (!Number.isFinite(this.nQuantiles) || !Number.isInteger(this.nQuantiles) || this.nQuantiles < 2) {
+      throw new InvalidParameterError(
+        "nQuantiles must be at least 2",
+        "nQuantiles",
+        this.nQuantiles
+      );
+    }
+    if (this.outputDistribution !== "uniform" && this.outputDistribution !== "normal") {
+      throw new InvalidParameterError(
+        "outputDistribution must be 'uniform' or 'normal'",
+        "outputDistribution",
+        this.outputDistribution
+      );
+    }
+    if (this.subsample !== void 0) {
+      if (!Number.isFinite(this.subsample) || !Number.isInteger(this.subsample) || this.subsample < 2) {
+        throw new InvalidParameterError(
+          "subsample must be an integer >= 2",
+          "subsample",
+          this.subsample
+        );
+      }
+    }
+  }
+  fit(X) {
+    if (X.size === 0) {
+      throw new InvalidParameterError("X must contain at least one sample", "X");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    this.quantiles_ = /* @__PURE__ */ new Map();
+    const sampleCount = this.subsample !== void 0 ? Math.min(this.subsample, nSamples) : nSamples;
+    const nQuantilesEffective = Math.min(this.nQuantiles, sampleCount);
+    const references = nQuantilesEffective <= 1 ? [0.5] : Array.from({ length: nQuantilesEffective }, (_, i) => i / (nQuantilesEffective - 1));
+    let sampleIndices;
+    if (sampleCount < nSamples) {
+      sampleIndices = Array.from({ length: nSamples }, (_, i) => i);
+      const random = this.randomState !== void 0 ? createSeededRandom(this.randomState) : Math.random;
+      shuffleIndicesInPlace(sampleIndices, random);
+      sampleIndices = sampleIndices.slice(0, sampleCount);
+    }
+    for (let j = 0; j < nFeatures; j++) {
+      const values = [];
+      if (sampleIndices) {
+        for (const idx of sampleIndices) {
+          const raw = data[X.offset + idx * stride0 + j * stride1];
+          if (raw === void 0) {
+            throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+          }
+          values.push(Number(raw));
+        }
+      } else {
+        for (let i = 0; i < nSamples; i++) {
+          const raw = data[X.offset + i * stride0 + j * stride1];
+          if (raw === void 0) {
+            throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+          }
+          values.push(Number(raw));
+        }
+      }
+      const sorted = [...values].sort((a, b) => a - b);
+      const quantiles = references.map((q) => this.interpolateFromSorted(sorted, q));
+      this.quantiles_.set(j, { quantiles, references });
+    }
+    this.fitted = true;
+    return this;
+  }
+  transform(X) {
+    if (!this.fitted || !this.quantiles_) {
+      throw new NotFittedError("QuantileTransformer must be fitted before transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    if (nSamples === 0) {
+      return zeros([0, nFeatures], { dtype: "float64" });
+    }
+    const result = new Array(nSamples);
+    for (let i = 0; i < nSamples; i++) {
+      result[i] = new Array(nFeatures);
+    }
+    for (let j = 0; j < nFeatures; j++) {
+      const feature = this.quantiles_.get(j);
+      if (!feature) {
+        throw new DeepboxError(`Internal error: missing fitted quantiles for feature ${j}`);
+      }
+      for (let i = 0; i < nSamples; i++) {
+        const raw = data[X.offset + i * stride0 + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const val = Number(raw);
+        const quantile = this.mapValueToQuantile(val, feature.quantiles, feature.references);
+        const row = result[i];
+        if (!row) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        if (this.outputDistribution === "uniform") {
+          row[j] = quantile;
+        } else {
+          const clampedQuantile = Math.max(1e-7, Math.min(1 - 1e-7, quantile));
+          const z = Math.sqrt(2) * this.erfInv(2 * clampedQuantile - 1);
+          row[j] = z;
+        }
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+  /**
+   * Inverse transform data back to the original feature space.
+   *
+   * If `outputDistribution="normal"`, values are first mapped back to uniform
+   * quantiles before being projected into the original data distribution.
+   *
+   * @param X - Transformed data (2D tensor)
+   * @returns Data in the original feature space
+   * @throws {NotFittedError} If transformer is not fitted
+   */
+  inverseTransform(X) {
+    if (!this.fitted || !this.quantiles_) {
+      throw new NotFittedError("QuantileTransformer must be fitted before inverse_transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    if (nSamples === 0) {
+      return zeros([0, nFeatures], { dtype: "float64" });
+    }
+    const result = new Array(nSamples);
+    for (let i = 0; i < nSamples; i++) {
+      result[i] = new Array(nFeatures);
+    }
+    for (let j = 0; j < nFeatures; j++) {
+      const feature = this.quantiles_.get(j);
+      if (!feature) {
+        throw new DeepboxError(`Internal error: missing fitted quantiles for feature ${j}`);
+      }
+      for (let i = 0; i < nSamples; i++) {
+        const raw = data[X.offset + i * stride0 + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const value = Number(raw);
+        let quantile = this.outputDistribution === "normal" ? this.normalCdf(value) : value;
+        quantile = Math.max(0, Math.min(1, quantile));
+        const row = result[i];
+        if (!row) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        row[j] = this.mapQuantileToValue(quantile, feature.quantiles, feature.references);
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+  erf(x) {
+    const sign = x < 0 ? -1 : 1;
+    const absX = Math.abs(x);
+    const t = 1 / (1 + 0.3275911 * absX);
+    const a1 = 0.254829592;
+    const a2 = -0.284496736;
+    const a3 = 1.421413741;
+    const a4 = -1.453152027;
+    const a5 = 1.061405429;
+    const poly = ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t;
+    return sign * (1 - poly * Math.exp(-absX * absX));
+  }
+  normalCdf(z) {
+    return 0.5 * (1 + this.erf(z / Math.sqrt(2)));
+  }
+  erfInv(x) {
+    const a = 0.147;
+    const b = 2 / (Math.PI * a) + Math.log(1 - x * x) / 2;
+    const sign = x < 0 ? -1 : 1;
+    return sign * Math.sqrt(Math.sqrt(b * b - Math.log(1 - x * x) / a) - b);
+  }
+  interpolateFromSorted(sorted, q) {
+    if (sorted.length === 0) {
+      throw new DeepboxError("Internal error: cannot interpolate empty sorted values");
+    }
+    if (sorted.length === 1) {
+      const only = sorted[0];
+      if (only === void 0) {
+        throw new DeepboxError("Internal error: missing sorted value");
+      }
+      return only;
+    }
+    const position = q * (sorted.length - 1);
+    const lower = Math.floor(position);
+    const upper = Math.ceil(position);
+    const lowerValue = sorted[lower];
+    const upperValue = sorted[upper];
+    if (lowerValue === void 0 || upperValue === void 0) {
+      throw new DeepboxError("Internal error: quantile interpolation index out of bounds");
+    }
+    if (upper === lower) {
+      return lowerValue;
+    }
+    const weight = position - lower;
+    return lowerValue * (1 - weight) + upperValue * weight;
+  }
+  mapValueToQuantile(value, quantiles, references) {
+    const n = quantiles.length;
+    if (n === 0) {
+      return 0;
+    }
+    if (n === 1) {
+      const onlyReference = references[0];
+      if (onlyReference === void 0) {
+        throw new DeepboxError("Internal error: missing quantile reference");
+      }
+      return onlyReference;
+    }
+    const firstQuantile = quantiles[0];
+    const lastQuantile = quantiles[n - 1];
+    if (firstQuantile === void 0 || lastQuantile === void 0) {
+      throw new DeepboxError("Internal error: missing quantile endpoints");
+    }
+    if (value <= firstQuantile) {
+      return 0;
+    }
+    if (value >= lastQuantile) {
+      return 1;
+    }
+    let left = 0;
+    let right = n - 1;
+    while (left + 1 < right) {
+      const mid = Math.floor((left + right) / 2);
+      const midValue = quantiles[mid];
+      if (midValue === void 0) {
+        throw new DeepboxError("Internal error: missing quantile midpoint");
+      }
+      if (midValue <= value) {
+        left = mid;
+      } else {
+        right = mid;
+      }
+    }
+    const qLeft = quantiles[left];
+    const qRight = quantiles[right];
+    const rLeft = references[left];
+    const rRight = references[right];
+    if (qLeft === void 0 || qRight === void 0 || rLeft === void 0 || rRight === void 0) {
+      throw new DeepboxError("Internal error: missing quantile interpolation points");
+    }
+    if (qRight <= qLeft) {
+      return (rLeft + rRight) / 2;
+    }
+    const ratio = (value - qLeft) / (qRight - qLeft);
+    return rLeft + ratio * (rRight - rLeft);
+  }
+  mapQuantileToValue(quantile, quantiles, references) {
+    const n = references.length;
+    if (n === 0) {
+      return 0;
+    }
+    if (n === 1) {
+      const onlyQuantile = quantiles[0];
+      if (onlyQuantile === void 0) {
+        throw new DeepboxError("Internal error: missing quantile value");
+      }
+      return onlyQuantile;
+    }
+    const firstRef = references[0];
+    const lastRef = references[n - 1];
+    if (firstRef === void 0 || lastRef === void 0) {
+      throw new DeepboxError("Internal error: missing reference endpoints");
+    }
+    if (quantile <= firstRef) {
+      const firstQuantile = quantiles[0];
+      if (firstQuantile === void 0) {
+        throw new DeepboxError("Internal error: missing quantile endpoints");
+      }
+      return firstQuantile;
+    }
+    if (quantile >= lastRef) {
+      const lastQuantile = quantiles[n - 1];
+      if (lastQuantile === void 0) {
+        throw new DeepboxError("Internal error: missing quantile endpoints");
+      }
+      return lastQuantile;
+    }
+    let left = 0;
+    let right = n - 1;
+    while (left + 1 < right) {
+      const mid = Math.floor((left + right) / 2);
+      const midRef = references[mid];
+      if (midRef === void 0) {
+        throw new DeepboxError("Internal error: missing quantile reference");
+      }
+      if (midRef <= quantile) {
+        left = mid;
+      } else {
+        right = mid;
+      }
+    }
+    const rLeft = references[left];
+    const rRight = references[right];
+    const qLeft = quantiles[left];
+    const qRight = quantiles[right];
+    if (rLeft === void 0 || rRight === void 0 || qLeft === void 0 || qRight === void 0) {
+      throw new DeepboxError("Internal error: missing quantile interpolation points");
+    }
+    if (rRight <= rLeft) {
+      return (qLeft + qRight) / 2;
+    }
+    const ratio = (quantile - rLeft) / (rRight - rLeft);
+    return qLeft + ratio * (qRight - qLeft);
+  }
+  fitTransform(X) {
+    return this.fit(X).transform(X);
+  }
+};
+var PowerTransformer = class {
+  fitted = false;
+  method;
+  lambdas_;
+  standardize;
+  mean_;
+  scale_;
+  /**
+   * Creates a new PowerTransformer.
+   *
+   * @param options - Configuration options
+   * @param options.method - "box-cox" or "yeo-johnson" (default: "yeo-johnson")
+   * @param options.standardize - Whether to standardize transformed features (default: false)
+   * @param options.copy - Accepted for API parity; transforms are always out-of-place (default: true)
+   */
+  constructor(options = {}) {
+    this.method = options.method ?? "yeo-johnson";
+    if (this.method !== "box-cox" && this.method !== "yeo-johnson") {
+      throw new InvalidParameterError(
+        "method must be 'box-cox' or 'yeo-johnson'",
+        "method",
+        this.method
+      );
+    }
+    this.standardize = parseBooleanOption(options.standardize, "standardize", false);
+    parseBooleanOption(options.copy, "copy", true);
+  }
+  fit(X) {
+    if (X.size === 0) {
+      throw new InvalidParameterError("X must contain at least one sample", "X");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    const lambdas = new Array(nFeatures);
+    const means = this.standardize ? new Array(nFeatures).fill(0) : void 0;
+    const scales = this.standardize ? new Array(nFeatures).fill(0) : void 0;
+    for (let j = 0; j < nFeatures; j++) {
+      const featureValues = new Array(nSamples);
+      for (let i = 0; i < nSamples; i++) {
+        const raw = data[X.offset + i * stride0 + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const value = Number(raw);
+        if (this.method === "box-cox" && value <= 0) {
+          throw new InvalidParameterError(
+            `Box-Cox requires strictly positive values in fit data (feature ${j})`,
+            "X",
+            value
+          );
+        }
+        featureValues[i] = value;
+      }
+      const lambda = this.optimizeLambda(featureValues);
+      lambdas[j] = lambda;
+      if (this.standardize && means && scales) {
+        let sum = 0;
+        for (const value of featureValues) {
+          const transformed = this.method === "box-cox" ? this.boxCoxTransformValue(value, lambda) : this.yeoJohnsonTransformValue(value, lambda);
+          sum += transformed;
+        }
+        const mean = sum / nSamples;
+        means[j] = mean;
+        let sumSqDiff = 0;
+        for (const value of featureValues) {
+          const transformed = this.method === "box-cox" ? this.boxCoxTransformValue(value, lambda) : this.yeoJohnsonTransformValue(value, lambda);
+          const diff = transformed - mean;
+          sumSqDiff += diff * diff;
+        }
+        const variance = sumSqDiff / nSamples;
+        const std = Math.sqrt(Math.max(variance, 0));
+        scales[j] = std === 0 ? 1 : std;
+      }
+    }
+    this.lambdas_ = lambdas;
+    this.mean_ = this.standardize ? means : void 0;
+    this.scale_ = this.standardize ? scales : void 0;
+    this.fitted = true;
+    return this;
+  }
+  transform(X) {
+    if (!this.fitted || !this.lambdas_) {
+      throw new NotFittedError("PowerTransformer must be fitted before transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    if (this.standardize && (!this.mean_ || !this.scale_)) {
+      throw new DeepboxError("PowerTransformer internal error: missing standardization stats");
+    }
+    const result = Array.from({ length: nSamples }, () => new Array(nFeatures).fill(0));
+    for (let i = 0; i < nSamples; i++) {
+      const rowBase = X.offset + i * stride0;
+      for (let j = 0; j < nFeatures; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        const val = Number(raw);
+        const lambda = this.lambdas_[j];
+        if (lambda === void 0) {
+          throw new DeepboxError(`Internal error: missing fitted lambda for feature ${j}`);
+        }
+        let transformed;
+        if (this.method === "box-cox") {
+          if (val <= 0) {
+            throw new InvalidParameterError("Box-Cox requires strictly positive values", "X", val);
+          }
+          transformed = this.boxCoxTransformValue(val, lambda);
+        } else {
+          transformed = this.yeoJohnsonTransformValue(val, lambda);
+        }
+        if (this.standardize && this.mean_ && this.scale_) {
+          const mean = this.mean_[j] ?? 0;
+          const scale = this.scale_[j] ?? 1;
+          transformed = (transformed - mean) / scale;
+        }
+        const row = result[i];
+        if (row === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        row[j] = transformed;
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+  /**
+   * Inverse transform data back to the original feature space.
+   * If `standardize=true`, de-standardizes before applying the inverse power transform.
+   *
+   * @param X - Transformed data (2D tensor)
+   * @returns Data in the original feature space
+   * @throws {NotFittedError} If transformer is not fitted
+   */
+  inverseTransform(X) {
+    if (!this.fitted || !this.lambdas_) {
+      throw new NotFittedError("PowerTransformer must be fitted before inverse_transform");
+    }
+    assert2D(X, "X");
+    assertNumericTensor(X, "X");
+    validateFiniteData(X, "X");
+    const [nSamples, nFeatures] = getShape2D(X);
+    const data = getNumericData2(X, "X");
+    const [stride0, stride1] = getStrides2D(X);
+    if (this.standardize && (!this.mean_ || !this.scale_)) {
+      throw new DeepboxError("PowerTransformer internal error: missing standardization stats");
+    }
+    const result = Array.from({ length: nSamples }, () => new Array(nFeatures).fill(0));
+    for (let i = 0; i < nSamples; i++) {
+      const rowBase = X.offset + i * stride0;
+      for (let j = 0; j < nFeatures; j++) {
+        const raw = data[rowBase + j * stride1];
+        if (raw === void 0) {
+          throw new DeepboxError("Internal error: numeric tensor access out of bounds");
+        }
+        let val = Number(raw);
+        if (this.standardize && this.mean_ && this.scale_) {
+          const mean = this.mean_[j] ?? 0;
+          const scale = this.scale_[j] ?? 1;
+          val = val * scale + mean;
+        }
+        const lambda = this.lambdas_[j];
+        if (lambda === void 0) {
+          throw new DeepboxError(`Internal error: missing fitted lambda for feature ${j}`);
+        }
+        let inverted;
+        if (this.method === "box-cox") {
+          inverted = this.boxCoxInverseValue(val, lambda);
+        } else {
+          inverted = this.yeoJohnsonInverseValue(val, lambda);
+        }
+        const row = result[i];
+        if (row === void 0) {
+          throw new DeepboxError("Internal error: result row access failed");
+        }
+        row[j] = inverted;
+      }
+    }
+    return tensor(result, { dtype: "float64", device: X.device });
+  }
+  boxCoxTransformValue(value, lambda) {
+    return Math.abs(lambda) < 1e-12 ? Math.log(value) : (value ** lambda - 1) / lambda;
+  }
+  yeoJohnsonTransformValue(value, lambda) {
+    if (value >= 0) {
+      return Math.abs(lambda) < 1e-12 ? Math.log(value + 1) : ((value + 1) ** lambda - 1) / lambda;
+    }
+    const twoMinusLambda = 2 - lambda;
+    return Math.abs(twoMinusLambda) < 1e-12 ? -Math.log(1 - value) : -((1 - value) ** twoMinusLambda - 1) / twoMinusLambda;
+  }
+  boxCoxInverseValue(value, lambda) {
+    if (Math.abs(lambda) < 1e-12) {
+      return Math.exp(value);
+    }
+    const base = value * lambda + 1;
+    if (base <= 0) {
+      throw new InvalidParameterError("Box-Cox inverse encountered invalid value", "X", value);
+    }
+    return base ** (1 / lambda);
+  }
+  yeoJohnsonInverseValue(value, lambda) {
+    if (value >= 0) {
+      if (Math.abs(lambda) < 1e-12) {
+        return Math.exp(value) - 1;
+      }
+      const base2 = value * lambda + 1;
+      if (base2 <= 0) {
+        throw new InvalidParameterError(
+          "Yeo-Johnson inverse encountered invalid value",
+          "X",
+          value
+        );
+      }
+      return base2 ** (1 / lambda) - 1;
+    }
+    const twoMinusLambda = 2 - lambda;
+    if (Math.abs(twoMinusLambda) < 1e-12) {
+      return 1 - Math.exp(-value);
+    }
+    const base = 1 - value * twoMinusLambda;
+    if (base <= 0) {
+      throw new InvalidParameterError("Yeo-Johnson inverse encountered invalid value", "X", value);
+    }
+    return 1 - base ** (1 / twoMinusLambda);
+  }
+  logLikelihood(values, lambda) {
+    const transformed = new Array(values.length);
+    let jacobian = 0;
+    for (let i = 0; i < values.length; i++) {
+      const value = values[i];
+      if (value === void 0) {
+        throw new DeepboxError("Internal error: missing feature value during optimization");
+      }
+      let transformedValue;
+      if (this.method === "box-cox") {
+        if (value <= 0) {
+          return Number.NEGATIVE_INFINITY;
+        }
+        transformedValue = this.boxCoxTransformValue(value, lambda);
+        jacobian += (lambda - 1) * Math.log(value);
+      } else {
+        transformedValue = this.yeoJohnsonTransformValue(value, lambda);
+        jacobian += value >= 0 ? (lambda - 1) * Math.log(value + 1) : (1 - lambda) * Math.log(1 - value);
+      }
+      if (!Number.isFinite(transformedValue)) {
+        return Number.NEGATIVE_INFINITY;
+      }
+      transformed[i] = transformedValue;
+    }
+    let sum = 0;
+    for (const value of transformed) {
+      sum += value;
+    }
+    const mean = sum / transformed.length;
+    let varianceSum = 0;
+    for (const value of transformed) {
+      const delta = value - mean;
+      varianceSum += delta * delta;
+    }
+    const variance = varianceSum / transformed.length;
+    if (!Number.isFinite(variance) || variance <= 1e-15) {
+      return Number.NEGATIVE_INFINITY;
+    }
+    return -0.5 * transformed.length * Math.log(variance) + jacobian;
+  }
+  optimizeLambda(values) {
+    if (values.length < 2) {
+      return 1;
+    }
+    let minValue = Number.POSITIVE_INFINITY;
+    let maxValue = Number.NEGATIVE_INFINITY;
+    for (const value of values) {
+      if (value < minValue) minValue = value;
+      if (value > maxValue) maxValue = value;
+    }
+    if (!Number.isFinite(minValue) || !Number.isFinite(maxValue) || maxValue - minValue <= 1e-15) {
+      return 1;
+    }
+    let left = -5;
+    let right = 5;
+    const phi = (Math.sqrt(5) - 1) / 2;
+    let c = right - phi * (right - left);
+    let d = left + phi * (right - left);
+    let fc = this.logLikelihood(values, c);
+    let fd = this.logLikelihood(values, d);
+    for (let iter = 0; iter < 80; iter++) {
+      if (Math.abs(right - left) < 1e-6) break;
+      if (fc > fd) {
+        right = d;
+        d = c;
+        fd = fc;
+        c = right - phi * (right - left);
+        fc = this.logLikelihood(values, c);
+      } else {
+        left = c;
+        c = d;
+        fc = fd;
+        d = left + phi * (right - left);
+        fd = this.logLikelihood(values, d);
+      }
+    }
+    const candidates = [left, right, (left + right) / 2, 0, 1, 2, -2];
+    let bestLambda = 1;
+    let bestScore = Number.NEGATIVE_INFINITY;
+    for (const lambda of candidates) {
+      const score = this.logLikelihood(values, lambda);
+      if (score > bestScore) {
+        bestScore = score;
+        bestLambda = lambda;
+      }
+    }
+    return Number.isFinite(bestLambda) ? bestLambda : 1;
+  }
+  fitTransform(X) {
+    return this.fit(X).transform(X);
+  }
+};
+
+// src/preprocess/split.ts
+function validateNSplits(nSplits) {
+  if (!Number.isFinite(nSplits) || !Number.isInteger(nSplits) || nSplits < 2) {
+    throw new InvalidParameterError("nSplits must be an integer at least 2", "nSplits", nSplits);
+  }
+}
+function parseSplitSpec(value, name) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new InvalidParameterError(`${name} must be a positive number`, name, value);
+  }
+  if (value < 1) {
+    return { kind: "fraction", value };
+  }
+  if (!Number.isInteger(value)) {
+    throw new InvalidParameterError(
+      `${name} must be an integer when provided as an absolute size`,
+      name,
+      value
+    );
+  }
+  return { kind: "count", value };
+}
+function resolveSplitCount(spec, nSamples, isTrain) {
+  if (spec.kind === "count") {
+    return spec.value;
+  }
+  const exact = nSamples * spec.value;
+  return isTrain ? Math.floor(exact) : Math.ceil(exact);
+}
+function resolveTrainTestCounts(nSamples, trainSize, testSize) {
+  const defaultTestSize = trainSize === void 0 && testSize === void 0 ? 0.25 : testSize;
+  const trainSpec = parseSplitSpec(trainSize, "trainSize");
+  const testSpec = parseSplitSpec(defaultTestSize, "testSize");
+  if (trainSpec?.kind === "count" && trainSpec.value > nSamples) {
+    throw new InvalidParameterError(
+      "trainSize must not exceed number of samples",
+      "trainSize",
+      trainSpec.value
+    );
+  }
+  if (testSpec?.kind === "count" && testSpec.value > nSamples) {
+    throw new InvalidParameterError(
+      "testSize must not exceed number of samples",
+      "testSize",
+      testSpec.value
+    );
+  }
+  if (trainSpec?.kind === "fraction" && testSpec?.kind === "fraction" && trainSpec.value + testSpec.value > 1) {
+    throw new InvalidParameterError(
+      "trainSize and testSize fractions must sum to at most 1",
+      "trainSize",
+      trainSpec.value
+    );
+  }
+  let nTrain = trainSpec === void 0 ? void 0 : resolveSplitCount(trainSpec, nSamples, true);
+  let nTest = testSpec === void 0 ? void 0 : resolveSplitCount(testSpec, nSamples, false);
+  if (nTrain === void 0 && nTest === void 0) {
+    throw new DeepboxError("Internal error: failed to resolve split sizes");
+  }
+  if (nTrain === void 0) {
+    nTrain = nSamples - (nTest ?? 0);
+  }
+  if (nTest === void 0) {
+    nTest = nSamples - nTrain;
+  }
+  if (nTrain + nTest > nSamples) {
+    throw new InvalidParameterError(
+      "trainSize and testSize exceed number of samples",
+      "trainSize",
+      trainSize
+    );
+  }
+  if (nTrain < 1) {
+    throw new InvalidParameterError("trainSize must be at least 1 sample", "trainSize", trainSize);
+  }
+  if (nTest < 1) {
+    throw new InvalidParameterError("testSize must be at least 1 sample", "testSize", testSize);
+  }
+  return [nTrain, nTest];
+}
+function compareLabels(a, b) {
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "bigint" && typeof b === "bigint") {
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  }
+  return String(a).localeCompare(String(b));
+}
+function makeFoldSizes(total, nSplits) {
+  const base = Math.floor(total / nSplits);
+  const remainder = total % nSplits;
+  return Array.from({ length: nSplits }, (_, i) => base + (i < remainder ? 1 : 0));
+}
+function readTensorValue(t, indices) {
+  const value = t.at(...indices);
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+    return value;
+  }
+  throw new DeepboxError("Internal error: unsupported tensor value type");
+}
+function writeTensorValue(t, flatIndex, value) {
+  if (t.dtype === "string") {
+    if (typeof value !== "string") {
+      throw new DeepboxError("Internal error: expected string value for string tensor");
+    }
+    t.data[flatIndex] = value;
+    return;
+  }
+  if (typeof value === "string") {
+    throw new DeepboxError("Internal error: encountered string value in numeric tensor");
+  }
+  if (t.data instanceof BigInt64Array) {
+    t.data[flatIndex] = typeof value === "bigint" ? value : BigInt(value);
+    return;
+  }
+  t.data[flatIndex] = Number(value);
+}
+function takeRows2D(X, sampleIndices) {
+  const [, nFeatures] = getShape2D(X);
+  const out = zeros([sampleIndices.length, nFeatures], { dtype: X.dtype });
+  for (let i = 0; i < sampleIndices.length; i++) {
+    const sampleIndex = sampleIndices[i];
+    if (sampleIndex === void 0) {
+      throw new DeepboxError("Internal error: sample index access failed");
+    }
+    for (let j = 0; j < nFeatures; j++) {
+      const value = readTensorValue(X, [sampleIndex, j]);
+      writeTensorValue(out, out.offset + i * nFeatures + j, value);
+    }
+  }
+  return out;
+}
+function takeVector(y, sampleIndices) {
+  if (y.ndim !== 1) {
+    throw new ShapeError(`y must be a 1D tensor, got ${y.ndim}D`);
+  }
+  const out = zeros([sampleIndices.length], { dtype: y.dtype });
+  for (let i = 0; i < sampleIndices.length; i++) {
+    const sampleIndex = sampleIndices[i];
+    if (sampleIndex === void 0) {
+      throw new DeepboxError("Internal error: sample index access failed");
+    }
+    const value = readTensorValue(y, [sampleIndex]);
+    writeTensorValue(out, out.offset + i, value);
+  }
+  return out;
+}
+function trainTestSplit(X, y, options) {
+  const opts = options ?? {};
+  const shuffle = opts.shuffle ?? true;
+  const randomState = opts.randomState;
+  const [nSamples] = getShape2D(X);
+  if (nSamples === 0) {
+    throw new InvalidParameterError("Cannot split empty array", "X");
+  }
+  if (y) {
+    const yShape0 = y.shape[0];
+    if (yShape0 === void 0 || yShape0 !== nSamples) {
+      throw new InvalidParameterError("X and y must have same number of samples", "y", yShape0);
+    }
+  }
+  if (opts.stratify) {
+    if (opts.stratify.ndim !== 1) {
+      throw new ShapeError(`stratify must be a 1D tensor, got ${opts.stratify.ndim}D`);
+    }
+    const stratifyShape0 = opts.stratify.shape[0];
+    if (stratifyShape0 === void 0 || stratifyShape0 !== nSamples) {
+      throw new InvalidParameterError(
+        "stratify must have same number of samples as X",
+        "stratify",
+        stratifyShape0
+      );
+    }
+  }
+  const [nTrain, nTest] = resolveTrainTestCounts(nSamples, opts.trainSize, opts.testSize);
+  const indices = Array.from({ length: nSamples }, (_, i) => i);
+  const random = randomState !== void 0 ? createSeededRandom(randomState) : Math.random;
+  const maybeShuffle = (arr) => {
+    if (!shuffle) return;
+    shuffleIndicesInPlace(arr, random);
+  };
+  let trainIndices = [];
+  let testIndices = [];
+  if (opts.stratify) {
+    const stratify = opts.stratify;
+    const labelMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < nSamples; i++) {
+      const label = readTensorValue(stratify, [i]);
+      let bucket = labelMap.get(label);
+      if (bucket === void 0) {
+        bucket = [];
+        labelMap.set(label, bucket);
+      }
+      bucket.push(i);
+    }
+    const labels = Array.from(labelMap.keys()).sort(compareLabels);
+    const nClasses = labels.length;
+    const classSizes = labels.map((label) => labelMap.get(label)?.length ?? 0);
+    const hasSingleton = classSizes.some((size) => size < 2);
+    if (hasSingleton && shuffle && randomState === void 0) {
+      throw new InvalidParameterError(
+        "stratify requires at least 2 samples per class",
+        "stratify",
+        classSizes
+      );
+    }
+    if (opts.trainSize !== void 0 && nTrain < nClasses) {
+      throw new InvalidParameterError(
+        "trainSize must be at least the number of classes when stratifying",
+        "trainSize",
+        nTrain
+      );
+    }
+    if (nTest < nClasses) {
+      throw new InvalidParameterError(
+        "testSize must be at least the number of classes when stratifying",
+        "testSize",
+        nTest
+      );
+    }
+    const testFraction = nTest / nSamples;
+    const allowEmptyClassSplits = nTrain < nClasses;
+    const counts = labels.map((label) => {
+      const size = labelMap.get(label)?.length ?? 0;
+      const exact = size * testFraction;
+      let testCount = Math.floor(exact);
+      let remainder = exact - testCount;
+      let min = allowEmptyClassSplits ? 0 : 1;
+      let max = allowEmptyClassSplits ? size : size - 1;
+      if (size < 2) {
+        min = 0;
+        max = allowEmptyClassSplits ? size : 0;
+        testCount = 0;
+        remainder = 0;
+      } else {
+        if (testCount < min) testCount = min;
+        if (testCount > max) testCount = max;
+      }
+      return { label, size, testCount, remainder, min, max };
+    });
+    let remaining = nTest - counts.reduce((sum, c) => sum + c.testCount, 0);
+    if (remaining !== 0) {
+      const order = remaining > 0 ? [...counts].sort((a, b) => {
+        if (b.remainder !== a.remainder) return b.remainder - a.remainder;
+        return compareLabels(a.label, b.label);
+      }) : [...counts].sort((a, b) => {
+        if (a.remainder !== b.remainder) return a.remainder - b.remainder;
+        return compareLabels(a.label, b.label);
+      });
+      let guard = 0;
+      while (remaining !== 0 && guard < counts.length * 2) {
+        for (const entry of order) {
+          if (remaining === 0) break;
+          if (remaining > 0 && entry.testCount < entry.max) {
+            entry.testCount += 1;
+            remaining -= 1;
+          } else if (remaining < 0 && entry.testCount > entry.min) {
+            entry.testCount -= 1;
+            remaining += 1;
+          }
+        }
+        guard += 1;
+      }
+      if (remaining !== 0) {
+        throw new DeepboxError("Internal error: unable to allocate stratified split sizes");
+      }
+    }
+    const remainingTrainPool = [];
+    for (const entry of counts) {
+      const labelIndices = [...labelMap.get(entry.label) ?? []];
+      maybeShuffle(labelIndices);
+      testIndices.push(...labelIndices.slice(0, entry.testCount));
+      remainingTrainPool.push(...labelIndices.slice(entry.testCount));
+    }
+    maybeShuffle(testIndices);
+    maybeShuffle(remainingTrainPool);
+    trainIndices = remainingTrainPool.slice(0, nTrain);
+  } else {
+    maybeShuffle(indices);
+    trainIndices = indices.slice(0, nTrain);
+    testIndices = indices.slice(nTrain, nTrain + nTest);
+  }
+  if (trainIndices.length !== nTrain || testIndices.length !== nTest) {
+    throw new DeepboxError("Internal error: resolved split indices do not match requested sizes");
+  }
+  const XTrain = takeRows2D(X, trainIndices);
+  const XTest = takeRows2D(X, testIndices);
+  if (y) {
+    const yTrain = takeVector(y, trainIndices);
+    const yTest = takeVector(y, testIndices);
+    return [XTrain, XTest, yTrain, yTest];
+  }
+  return [XTrain, XTest];
+}
+var KFold = class {
+  nSplits;
+  shuffle;
+  randomState;
+  constructor(options = {}) {
+    this.nSplits = options.nSplits ?? 5;
+    this.shuffle = options.shuffle ?? false;
+    this.randomState = options.randomState;
+  }
+  split(X) {
+    const shape0 = X.shape[0];
+    if (shape0 === void 0) {
+      throw new ShapeError("X must have valid shape[0]");
+    }
+    const nSamples = shape0;
+    validateNSplits(this.nSplits);
+    if (this.nSplits > nSamples) {
+      throw new InvalidParameterError(
+        "nSplits must not be greater than number of samples",
+        "nSplits",
+        this.nSplits
+      );
+    }
+    const indices = Array.from({ length: nSamples }, (_, i) => i);
+    if (this.shuffle) {
+      const random = this.randomState !== void 0 ? createSeededRandom(this.randomState) : Math.random;
+      shuffleIndicesInPlace(indices, random);
+    }
+    const splits = [];
+    const foldSizes = makeFoldSizes(nSamples, this.nSplits);
+    let current = 0;
+    for (let i = 0; i < this.nSplits; i++) {
+      const foldSize = foldSizes[i] ?? 0;
+      const testStart = current;
+      const testEnd = current + foldSize;
+      const testIndices = indices.slice(testStart, testEnd);
+      const trainIndices = [...indices.slice(0, testStart), ...indices.slice(testEnd)];
+      splits.push([trainIndices, testIndices]);
+      current = testEnd;
+    }
+    return splits;
+  }
+  getNSplits() {
+    return this.nSplits;
+  }
+};
+var StratifiedKFold = class {
+  nSplits;
+  shuffle;
+  randomState;
+  constructor(options = {}) {
+    this.nSplits = options.nSplits ?? 5;
+    this.shuffle = options.shuffle ?? false;
+    this.randomState = options.randomState;
+  }
+  split(X, y) {
+    const shape0 = X.shape[0];
+    if (shape0 === void 0) {
+      throw new ShapeError("X must have valid shape[0]");
+    }
+    const nSamples = shape0;
+    validateNSplits(this.nSplits);
+    if (this.nSplits > nSamples) {
+      throw new InvalidParameterError(
+        "nSplits must not be greater than number of samples",
+        "nSplits",
+        this.nSplits
+      );
+    }
+    const yShape0 = y.shape[0];
+    if (yShape0 === void 0 || yShape0 !== nSamples) {
+      throw new InvalidParameterError("X and y must have same number of samples", "y", yShape0);
+    }
+    if (y.ndim !== 1) {
+      throw new ShapeError(`y must be a 1D tensor, got ${y.ndim}D`);
+    }
+    const labelMap = /* @__PURE__ */ new Map();
+    const random = this.randomState !== void 0 ? createSeededRandom(this.randomState) : Math.random;
+    for (let i = 0; i < nSamples; i++) {
+      const label = readTensorValue(y, [i]);
+      let bucket = labelMap.get(label);
+      if (bucket === void 0) {
+        bucket = [];
+        labelMap.set(label, bucket);
+      }
+      bucket.push(i);
+    }
+    for (const [label, indices] of labelMap.entries()) {
+      if (this.shuffle) {
+        shuffleIndicesInPlace(indices, random);
+      }
+      if (indices.length < this.nSplits) {
+        throw new InvalidParameterError(
+          `Each class must have at least nSplits samples; class ${label} has ${indices.length}`,
+          "nSplits",
+          this.nSplits
+        );
+      }
+    }
+    const foldIndices = Array.from({ length: this.nSplits }, () => []);
+    for (const indices of labelMap.values()) {
+      const foldSizes = makeFoldSizes(indices.length, this.nSplits);
+      let start = 0;
+      for (let fold = 0; fold < this.nSplits; fold++) {
+        const size = foldSizes[fold] ?? 0;
+        const end = start + size;
+        const target = foldIndices[fold];
+        if (!target) {
+          throw new DeepboxError("Internal error: stratified fold storage missing");
+        }
+        target.push(...indices.slice(start, end));
+        start = end;
+      }
+    }
+    const splits = [];
+    for (let fold = 0; fold < this.nSplits; fold++) {
+      const testIndices = foldIndices[fold] ?? [];
+      const trainIndices = [];
+      for (let other = 0; other < this.nSplits; other++) {
+        if (other === fold) continue;
+        trainIndices.push(...foldIndices[other] ?? []);
+      }
+      splits.push([trainIndices, testIndices]);
+    }
+    return splits;
+  }
+  getNSplits() {
+    return this.nSplits;
+  }
+};
+var GroupKFold = class {
+  nSplits;
+  constructor(options = {}) {
+    this.nSplits = options.nSplits ?? 5;
+  }
+  split(X, _y, groups) {
+    const shape0 = X.shape[0];
+    if (shape0 === void 0) {
+      throw new ShapeError("X must have valid shape[0]");
+    }
+    const nSamples = shape0;
+    validateNSplits(this.nSplits);
+    if (groups.ndim !== 1) {
+      throw new ShapeError(`groups must be a 1D tensor, got ${groups.ndim}D`);
+    }
+    const groupsShape0 = groups.shape[0];
+    if (groupsShape0 === void 0 || groupsShape0 !== nSamples) {
+      throw new InvalidParameterError(
+        "X and groups must have same number of samples",
+        "groups",
+        groupsShape0
+      );
+    }
+    const groupMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < nSamples; i++) {
+      const group = readTensorValue(groups, [i]);
+      let bucket = groupMap.get(group);
+      if (bucket === void 0) {
+        bucket = [];
+        groupMap.set(group, bucket);
+      }
+      bucket.push(i);
+    }
+    const groupEntries = Array.from(groupMap.entries()).map(([group, indices]) => ({
+      group,
+      indices,
+      size: indices.length
+    }));
+    if (this.nSplits > groupEntries.length) {
+      throw new InvalidParameterError(
+        "Number of groups must be at least nSplits",
+        "nSplits",
+        this.nSplits
+      );
+    }
+    groupEntries.sort((a, b) => {
+      if (b.size !== a.size) return b.size - a.size;
+      return compareLabels(a.group, b.group);
+    });
+    const foldIndices = Array.from({ length: this.nSplits }, () => []);
+    const foldSizes = new Array(this.nSplits).fill(0);
+    for (const entry of groupEntries) {
+      let bestFold = 0;
+      let bestSize = foldSizes[0] ?? 0;
+      for (let fold = 1; fold < this.nSplits; fold++) {
+        const size = foldSizes[fold] ?? 0;
+        if (size < bestSize) {
+          bestSize = size;
+          bestFold = fold;
+        }
+      }
+      const target = foldIndices[bestFold];
+      if (!target) {
+        throw new DeepboxError("Internal error: group fold storage missing");
+      }
+      target.push(...entry.indices);
+      foldSizes[bestFold] = bestSize + entry.size;
+    }
+    const splits = [];
+    for (let fold = 0; fold < this.nSplits; fold++) {
+      const testIndices = foldIndices[fold] ?? [];
+      const trainIndices = [];
+      for (let other = 0; other < this.nSplits; other++) {
+        if (other === fold) continue;
+        trainIndices.push(...foldIndices[other] ?? []);
+      }
+      splits.push([trainIndices, testIndices]);
+    }
+    return splits;
+  }
+  getNSplits() {
+    return this.nSplits;
+  }
+};
+var LeaveOneOut = class {
+  split(X) {
+    const shape0 = X.shape[0];
+    if (shape0 === void 0) {
+      throw new ShapeError("X must have valid shape[0]");
+    }
+    const nSamples = shape0;
+    const splits = [];
+    for (let i = 0; i < nSamples; i++) {
+      const trainIndices = [
+        ...Array.from({ length: i }, (_, j) => j),
+        ...Array.from({ length: nSamples - i - 1 }, (_, j) => i + 1 + j)
+      ];
+      const testIndices = [i];
+      splits.push([trainIndices, testIndices]);
+    }
+    return splits;
+  }
+  getNSplits(X) {
+    const shape0 = X.shape[0];
+    if (shape0 === void 0) {
+      throw new ShapeError("X must have valid shape[0]");
+    }
+    return shape0;
+  }
+};
+var LeavePOut = class {
+  p;
+  constructor(p) {
+    if (!Number.isFinite(p) || !Number.isInteger(p) || p <= 0) {
+      throw new InvalidParameterError("p must be a positive integer", "p", p);
+    }
+    this.p = p;
+  }
+  split(X) {
+    const shape0 = X.shape[0];
+    if (shape0 === void 0) {
+      throw new ShapeError("X must have valid shape[0]");
+    }
+    const nSamples = shape0;
+    if (this.p > nSamples) {
+      throw new InvalidParameterError("p must not be greater than number of samples", "p", this.p);
+    }
+    let nCombos = 1;
+    const k = this.p > nSamples / 2 ? nSamples - this.p : this.p;
+    for (let i = 0; i < k; i++) {
+      nCombos = nCombos * (nSamples - i) / (i + 1);
+    }
+    if (nCombos > 1e5) {
+      throw new InvalidParameterError(
+        `LeavePOut produces ${Math.floor(nCombos)} splits, which exceeds memory safety limit of 100,000`,
+        "p",
+        this.p
+      );
+    }
+    const splits = [];
+    const allIndices = Array.from({ length: nSamples }, (_, i) => i);
+    const combine = (start, currentCombo) => {
+      if (currentCombo.length === this.p) {
+        const testSet = new Set(currentCombo);
+        const testIndices = [...currentCombo];
+        const trainIndices = allIndices.filter((i) => !testSet.has(i));
+        splits.push([trainIndices, testIndices]);
+        return;
+      }
+      for (let i = start; i < nSamples; i++) {
+        currentCombo.push(i);
+        combine(i + 1, currentCombo);
+        currentCombo.pop();
+      }
+    };
+    combine(0, []);
+    return splits;
+  }
+  getNSplits(X) {
+    const shape0 = X.shape[0];
+    if (shape0 === void 0) {
+      throw new ShapeError("X must have valid shape[0]");
+    }
+    const n = shape0;
+    if (this.p > n) {
+      throw new InvalidParameterError("p must not be greater than number of samples", "p", this.p);
+    }
+    let result = 1;
+    const k = this.p > n / 2 ? n - this.p : this.p;
+    for (let i = 0; i < k; i++) {
+      result = result * (n - i) / (i + 1);
+    }
+    return Math.round(result);
+  }
+};
+
+export { GroupKFold, KFold, LabelBinarizer, LabelEncoder, LeaveOneOut, LeavePOut, MaxAbsScaler, MinMaxScaler, MultiLabelBinarizer, Normalizer, OneHotEncoder, OrdinalEncoder, PowerTransformer, QuantileTransformer, RobustScaler, StandardScaler, StratifiedKFold, preprocess_exports, trainTestSplit };
+//# sourceMappingURL=chunk-AD436M45.js.map
+//# sourceMappingURL=chunk-AD436M45.js.map