deepbox 0.1.0

package/dist/chunk-4S73VUBD.js

@@ -0,0 +1,677 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/index.ts
+var core_exports = {};
+__export(core_exports, {
+  BroadcastError: () => BroadcastError,
+  ConvergenceError: () => ConvergenceError,
+  DEVICES: () => DEVICES,
+  DTYPES: () => DTYPES,
+  DTypeError: () => DTypeError,
+  DataValidationError: () => DataValidationError,
+  DeepboxError: () => DeepboxError,
+  DeviceError: () => DeviceError,
+  IndexError: () => IndexError,
+  InvalidParameterError: () => InvalidParameterError,
+  MemoryError: () => MemoryError,
+  NotFittedError: () => NotFittedError,
+  NotImplementedError: () => NotImplementedError,
+  ShapeError: () => ShapeError,
+  asReadonlyArray: () => asReadonlyArray,
+  dtypeToTypedArrayCtor: () => dtypeToTypedArrayCtor,
+  ensureNumericDType: () => ensureNumericDType,
+  getArrayElement: () => getArrayElement,
+  getBigIntElement: () => getBigIntElement,
+  getConfig: () => getConfig,
+  getDevice: () => getDevice,
+  getDtype: () => getDtype,
+  getElementAsNumber: () => getElementAsNumber,
+  getNumericElement: () => getNumericElement,
+  getSeed: () => getSeed,
+  getShapeDim: () => getShapeDim,
+  getStringElement: () => getStringElement,
+  isBigInt64Array: () => isBigInt64Array,
+  isDType: () => isDType,
+  isDevice: () => isDevice,
+  isNumericTypedArray: () => isNumericTypedArray,
+  isTypedArray: () => isTypedArray,
+  normalizeAxes: () => normalizeAxes,
+  normalizeAxis: () => normalizeAxis,
+  resetConfig: () => resetConfig,
+  setConfig: () => setConfig,
+  setDevice: () => setDevice,
+  setDtype: () => setDtype,
+  setSeed: () => setSeed,
+  shapeToSize: () => shapeToSize,
+  validateArray: () => validateArray,
+  validateDevice: () => validateDevice,
+  validateDtype: () => validateDtype,
+  validateInteger: () => validateInteger,
+  validateNonNegative: () => validateNonNegative,
+  validateOneOf: () => validateOneOf,
+  validatePositive: () => validatePositive,
+  validateRange: () => validateRange,
+  validateShape: () => validateShape
+});
+
+// src/core/errors/base.ts
+var DeepboxError = class extends Error {
+  name = "DeepboxError";
+  cause;
+  constructor(message, options) {
+    super(message);
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/core/errors/validation.ts
+var DataValidationError = class extends DeepboxError {
+  name = "DataValidationError";
+};
+
+// src/core/types/device.ts
+var DEVICES = ["cpu", "webgpu", "wasm"];
+function isDevice(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  for (const d of DEVICES) {
+    if (d === value) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/core/types/dtype.ts
+var DTYPES = [
+  "float32",
+  "float64",
+  "int32",
+  "int64",
+  "uint8",
+  "bool",
+  "string"
+];
+function isDType(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  for (const d of DTYPES) {
+    if (d === value) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/core/utils/validation.ts
+function shapeToSize(shape, name = "shape") {
+  const validated = validateShape(shape, name);
+  let size = 1;
+  for (const dim of validated) {
+    if (dim === 0) return 0;
+    if (size > Number.MAX_SAFE_INTEGER / dim) {
+      throw new DataValidationError(
+        `${name} is too large; total size exceeds ${Number.MAX_SAFE_INTEGER}`
+      );
+    }
+    size *= dim;
+  }
+  return size;
+}
+function validateShape(shape, name = "shape") {
+  if (!Array.isArray(shape)) {
+    throw new DataValidationError(`${name} must be an array of integers`);
+  }
+  const validated = [];
+  for (let i = 0; i < shape.length; i++) {
+    const dim = shape[i];
+    if (typeof dim !== "number" || !Number.isFinite(dim) || !Number.isInteger(dim)) {
+      throw new DataValidationError(
+        `${name}[${i}] must be a finite integer; received ${String(dim)}`
+      );
+    }
+    if (dim < 0) {
+      throw new DataValidationError(`${name}[${i}] must be >= 0; received ${dim}`);
+    }
+    if (!Number.isSafeInteger(dim)) {
+      throw new DataValidationError(
+        `${name}[${i}] must be a safe integer (<= ${Number.MAX_SAFE_INTEGER}); received ${dim}`
+      );
+    }
+    validated.push(dim);
+  }
+  return validated;
+}
+function validateDtype(dtype, name = "dtype") {
+  if (!isDType(dtype)) {
+    throw new DataValidationError(
+      `${name} must be one of [${DTYPES.join(", ")}]; received ${String(dtype)}`
+    );
+  }
+  return dtype;
+}
+function validateDevice(device, name = "device") {
+  if (!isDevice(device)) {
+    throw new DataValidationError(
+      `${name} must be one of [${DEVICES.join(", ")}]; received ${String(device)}`
+    );
+  }
+  return device;
+}
+function validatePositive(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new DataValidationError(`${name} must be a finite number; received ${String(value)}`);
+  }
+  if (value <= 0) {
+    throw new DataValidationError(`${name} must be positive (> 0); received ${value}`);
+  }
+}
+function validateNonNegative(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new DataValidationError(`${name} must be a finite number; received ${String(value)}`);
+  }
+  if (value < 0) {
+    throw new DataValidationError(`${name} must be non-negative (>= 0); received ${value}`);
+  }
+}
+function validateRange(value, min, max, name) {
+  if (typeof min !== "number" || !Number.isFinite(min)) {
+    throw new DataValidationError(`${name} min must be a finite number; received ${String(min)}`);
+  }
+  if (typeof max !== "number" || !Number.isFinite(max)) {
+    throw new DataValidationError(`${name} max must be a finite number; received ${String(max)}`);
+  }
+  if (min > max) {
+    throw new DataValidationError(`${name} min must be <= max; received min=${min}, max=${max}`);
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new DataValidationError(`${name} must be a finite number; received ${String(value)}`);
+  }
+  if (value < min || value > max) {
+    throw new DataValidationError(`${name} must be in range [${min}, ${max}]; received ${value}`);
+  }
+}
+function validateInteger(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new DataValidationError(`${name} must be a finite number; received ${String(value)}`);
+  }
+  if (!Number.isInteger(value)) {
+    throw new DataValidationError(`${name} must be an integer; received ${value}`);
+  }
+  if (!Number.isSafeInteger(value)) {
+    throw new DataValidationError(
+      `${name} must be a safe integer (<= ${Number.MAX_SAFE_INTEGER}); received ${value}`
+    );
+  }
+}
+function validateOneOf(value, options, name) {
+  if (typeof value !== "string") {
+    throw new DataValidationError(`${name} must be a string; received ${typeof value}`);
+  }
+  let found = false;
+  for (const opt of options) {
+    if (opt === value) {
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    throw new DataValidationError(
+      `${name} must be one of [${options.join(", ")}]; received ${String(value)}`
+    );
+  }
+}
+function validateArray(arr, name) {
+  if (!Array.isArray(arr)) {
+    throw new DataValidationError(`${name} must be an array; received ${typeof arr}`);
+  }
+}
+
+// src/core/config/global.ts
+var DEFAULT_CONFIG = {
+  defaultDtype: "float32",
+  defaultDevice: "cpu",
+  seed: null
+};
+var CONFIG_KEYS = ["defaultDtype", "defaultDevice", "seed"];
+var config = { ...DEFAULT_CONFIG };
+function isPlainConfigObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function hasOwnConfigKey(source, key) {
+  return Object.hasOwn(source, key);
+}
+function normalizeSeed(value, name, allowNull) {
+  if (value === null) {
+    if (allowNull) {
+      return null;
+    }
+    throw new DataValidationError(`${name} must be a safe integer; received null`);
+  }
+  if (typeof value !== "number") {
+    throw new DataValidationError(`${name} must be a finite number; received ${String(value)}`);
+  }
+  validateInteger(value, name);
+  return value;
+}
+function getConfig() {
+  return { ...config };
+}
+function setConfig(next) {
+  if (next === null || typeof next !== "object" || Array.isArray(next)) {
+    throw new DataValidationError(`config must be an object with keys [${CONFIG_KEYS.join(", ")}]`);
+  }
+  if (!isPlainConfigObject(next)) {
+    throw new DataValidationError(
+      `config must be a plain object with keys [${CONFIG_KEYS.join(", ")}]`
+    );
+  }
+  const keys = Object.keys(next);
+  const unknownKeys = [];
+  for (const key of keys) {
+    let isKnown = false;
+    for (const allowed of CONFIG_KEYS) {
+      if (allowed === key) {
+        isKnown = true;
+        break;
+      }
+    }
+    if (!isKnown) {
+      unknownKeys.push(key);
+    }
+  }
+  if (unknownKeys.length > 0) {
+    throw new DataValidationError(
+      `config contains unsupported keys: ${unknownKeys.join(", ")}. Allowed keys are [${CONFIG_KEYS.join(
+        ", "
+      )}]`
+    );
+  }
+  const nextDefaultDtype = hasOwnConfigKey(next, "defaultDtype") ? validateDtype(next.defaultDtype, "defaultDtype") : config.defaultDtype;
+  const nextDefaultDevice = hasOwnConfigKey(next, "defaultDevice") ? validateDevice(next.defaultDevice, "defaultDevice") : config.defaultDevice;
+  const nextSeed = hasOwnConfigKey(next, "seed") ? normalizeSeed(next.seed, "seed", true) : config.seed;
+  config = {
+    defaultDtype: nextDefaultDtype,
+    defaultDevice: nextDefaultDevice,
+    seed: nextSeed
+  };
+}
+function resetConfig() {
+  config = { ...DEFAULT_CONFIG };
+}
+function setSeed(seed) {
+  const normalized = normalizeSeed(seed, "seed", false);
+  config = { ...config, seed: normalized };
+}
+function getSeed() {
+  return config.seed;
+}
+function setDevice(device) {
+  const normalized = validateDevice(device, "device");
+  config = { ...config, defaultDevice: normalized };
+}
+function getDevice() {
+  return config.defaultDevice;
+}
+function setDtype(dtype) {
+  const normalized = validateDtype(dtype, "dtype");
+  config = { ...config, defaultDtype: normalized };
+}
+function getDtype() {
+  return config.defaultDtype;
+}
+
+// src/core/errors/broadcast.ts
+function cloneShape(shape) {
+  return Object.freeze([...shape]);
+}
+var BroadcastError = class extends DeepboxError {
+  name = "BroadcastError";
+  /** The first shape involved in the broadcast operation */
+  shape1;
+  /** The second shape involved in the broadcast operation */
+  shape2;
+  constructor(shape1, shape2, context) {
+    const ctx = context ? ` (${context})` : "";
+    super(`Shapes [${shape1}] and [${shape2}] cannot be broadcast together${ctx}`);
+    this.shape1 = cloneShape(shape1);
+    this.shape2 = cloneShape(shape2);
+  }
+};
+
+// src/core/errors/convergence.ts
+var ConvergenceError = class extends DeepboxError {
+  name = "ConvergenceError";
+  /** Number of iterations completed before convergence failure */
+  iterations;
+  /** Tolerance value used for convergence check */
+  tolerance;
+  constructor(message, details) {
+    super(message);
+    if (details?.iterations !== void 0) {
+      this.iterations = details.iterations;
+    }
+    if (details?.tolerance !== void 0) {
+      this.tolerance = details.tolerance;
+    }
+  }
+};
+
+// src/core/errors/device.ts
+var DeviceError = class extends DeepboxError {
+  /**
+   * Discriminator name for this error type.
+   */
+  name = "DeviceError";
+};
+
+// src/core/errors/dtype.ts
+var DTypeError = class extends DeepboxError {
+  /**
+   * Discriminator name for this error type.
+   */
+  name = "DTypeError";
+};
+
+// src/core/errors/indexError.ts
+var IndexError = class extends DeepboxError {
+  name = "IndexError";
+  /** The invalid index value */
+  index;
+  /** The valid range for the index */
+  validRange;
+  constructor(message, details) {
+    super(message);
+    if (details?.index !== void 0) {
+      this.index = details.index;
+    }
+    if (details?.validRange !== void 0) {
+      this.validRange = details.validRange;
+    }
+  }
+};
+
+// src/core/errors/invalidParameter.ts
+var InvalidParameterError = class extends DeepboxError {
+  name = "InvalidParameterError";
+  /** The name of the invalid parameter */
+  parameterName;
+  /** The invalid value that was provided */
+  value;
+  constructor(message, parameterName, value) {
+    super(message);
+    if (parameterName !== void 0) {
+      this.parameterName = parameterName;
+    }
+    if (value !== void 0) {
+      this.value = value;
+    }
+  }
+};
+
+// src/core/errors/memory.ts
+var MemoryError = class extends DeepboxError {
+  name = "MemoryError";
+  /** The amount of memory requested in bytes */
+  requestedBytes;
+  /** The amount of memory available in bytes */
+  availableBytes;
+  constructor(message, details) {
+    super(message);
+    if (details?.requestedBytes !== void 0) {
+      this.requestedBytes = details.requestedBytes;
+    }
+    if (details?.availableBytes !== void 0) {
+      this.availableBytes = details.availableBytes;
+    }
+  }
+};
+
+// src/core/errors/notFitted.ts
+var NotFittedError = class extends DeepboxError {
+  name = "NotFittedError";
+  /** The name of the model or estimator that was not fitted */
+  modelName;
+  constructor(message, modelName) {
+    super(message);
+    if (modelName !== void 0) {
+      this.modelName = modelName;
+    }
+  }
+};
+
+// src/core/errors/notImplemented.ts
+var NotImplementedError = class extends DeepboxError {
+  /**
+   * Discriminator name for this error type.
+   */
+  name = "NotImplementedError";
+  /**
+   * Create a new NotImplementedError.
+   *
+   * @param message - Optional error message.
+   */
+  constructor(message = "Not implemented") {
+    super(message);
+  }
+};
+
+// src/core/errors/shape.ts
+function cloneShape2(shape) {
+  return Object.freeze([...shape]);
+}
+var ShapeError = class _ShapeError extends DeepboxError {
+  name = "ShapeError";
+  expected;
+  received;
+  context;
+  constructor(message, details = {}) {
+    super(message);
+    this.expected = details.expected === void 0 ? void 0 : cloneShape2(details.expected);
+    this.received = details.received === void 0 ? void 0 : cloneShape2(details.received);
+    this.context = details.context;
+  }
+  /**
+   * Create a ShapeError for a shape mismatch.
+   *
+   * Convenience factory method for the common case of shape mismatches.
+   *
+   * @param expected - The expected shape
+   * @param received - The actual shape that was received
+   * @param context - Optional context about where the mismatch occurred
+   * @returns A new ShapeError with formatted message and details
+   *
+   * @example
+   * ```ts
+   * throw ShapeError.mismatch([3, 4], [3, 5], 'matrix multiplication');
+   * // Error: Shape mismatch (matrix multiplication): expected [3,4], received [3,5]
+   * ```
+   */
+  static mismatch(expected, received, context) {
+    const ctx = context ? ` (${context})` : "";
+    const details = {
+      expected,
+      received,
+      ...context !== void 0 ? { context } : {}
+    };
+    return new _ShapeError(
+      `Shape mismatch${ctx}: expected [${expected}], received [${received}]`,
+      details
+    );
+  }
+};
+
+// src/core/utils/axis.ts
+function normalizeAxis(axis, ndim) {
+  if (!Number.isInteger(ndim) || ndim < 0) {
+    throw new InvalidParameterError(
+      `ndim must be a non-negative integer; received ${ndim}`,
+      "ndim",
+      ndim
+    );
+  }
+  let ax;
+  if (typeof axis === "string") {
+    if (axis === "index" || axis === "rows") {
+      ax = 0;
+    } else if (axis === "columns") {
+      ax = 1;
+    } else {
+      throw new InvalidParameterError(
+        `Invalid axis: '${axis}'. Must be 'index', 'rows', or 'columns'`,
+        "axis",
+        axis
+      );
+    }
+  } else {
+    if (!Number.isInteger(axis)) {
+      throw new InvalidParameterError(`axis must be an integer; received ${axis}`, "axis", axis);
+    }
+    ax = axis;
+  }
+  const normalized = ax < 0 ? ndim + ax : ax;
+  if (normalized < 0 || normalized >= ndim) {
+    throw new InvalidParameterError(`axis ${axis} is out of bounds for ndim=${ndim}`, "axis", axis);
+  }
+  return normalized;
+}
+function normalizeAxes(axis, ndim) {
+  if (!Number.isInteger(ndim) || ndim < 0) {
+    throw new InvalidParameterError(
+      `ndim must be a non-negative integer; received ${ndim}`,
+      "ndim",
+      ndim
+    );
+  }
+  const axes = Array.isArray(axis) ? axis : [axis];
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const ax of axes) {
+    const norm = normalizeAxis(ax, ndim);
+    if (seen.has(norm)) {
+      throw new InvalidParameterError("duplicate axis", "axis", axis);
+    }
+    seen.add(norm);
+    normalized.push(norm);
+  }
+  return normalized;
+}
+
+// src/core/utils/dtypeUtils.ts
+function ensureNumericDType(dtype, context) {
+  if (dtype === "string") {
+    throw new DTypeError(`${context} does not support string dtype`);
+  }
+  return dtype;
+}
+function dtypeToTypedArrayCtor(dtype) {
+  switch (dtype) {
+    case "float32":
+      return Float32Array;
+    case "float64":
+      return Float64Array;
+    case "int32":
+      return Int32Array;
+    case "int64":
+      return BigInt64Array;
+    case "uint8":
+      return Uint8Array;
+    case "bool":
+      return Uint8Array;
+    case "string":
+      throw new DTypeError("string dtype is not supported for TypedArray storage");
+    default: {
+      const _exhaustive = dtype;
+      throw new DTypeError(`Unsupported dtype: ${String(_exhaustive)}`);
+    }
+  }
+}
+
+// src/core/utils/typedArrayAccess.ts
+var MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+var MIN_SAFE_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+function getNumericElement(arr, index) {
+  const value = arr[index];
+  if (value === void 0) {
+    throw new IndexError(
+      `Index ${index} is out of bounds for typed array of length ${arr.length}`,
+      { index, validRange: [0, arr.length - 1] }
+    );
+  }
+  return value;
+}
+function getBigIntElement(arr, index) {
+  const value = arr[index];
+  if (value === void 0) {
+    throw new IndexError(
+      `Index ${index} is out of bounds for BigInt64Array of length ${arr.length}`,
+      { index, validRange: [0, arr.length - 1] }
+    );
+  }
+  return value;
+}
+function getElementAsNumber(arr, index) {
+  if (arr instanceof BigInt64Array) {
+    const value2 = arr[index];
+    if (value2 === void 0) {
+      throw new IndexError(
+        `Index ${index} is out of bounds for BigInt64Array of length ${arr.length}`,
+        { index, validRange: [0, arr.length - 1] }
+      );
+    }
+    if (value2 > MAX_SAFE_BIGINT || value2 < MIN_SAFE_BIGINT) {
+      throw new DataValidationError(
+        `BigInt value at index ${index} exceeds safe integer range; received ${value2.toString()}`
+      );
+    }
+    return Number(value2);
+  }
+  const value = arr[index];
+  if (value === void 0) {
+    throw new IndexError(
+      `Index ${index} is out of bounds for typed array of length ${arr.length}`,
+      { index, validRange: [0, arr.length - 1] }
+    );
+  }
+  return value;
+}
+function getShapeDim(shape, index) {
+  const value = shape[index];
+  return value !== void 0 ? value : 1;
+}
+function getArrayElement(arr, index, defaultValue = 0) {
+  const value = arr[index];
+  return value !== void 0 ? value : defaultValue;
+}
+function getStringElement(arr, index) {
+  const value = arr[index];
+  return value !== void 0 ? value : "";
+}
+function asReadonlyArray(arr) {
+  return arr;
+}
+function isBigInt64Array(arr) {
+  return arr instanceof BigInt64Array;
+}
+function isNumericTypedArray(arr) {
+  return !(arr instanceof BigInt64Array);
+}
+
+// src/core/utils/typeGuards.ts
+function isTypedArray(value) {
+  return value instanceof Float32Array || value instanceof Float64Array || value instanceof Int32Array || value instanceof BigInt64Array || value instanceof Uint8Array;
+}
+
+export { BroadcastError, ConvergenceError, DEVICES, DTYPES, DTypeError, DataValidationError, DeepboxError, DeviceError, IndexError, InvalidParameterError, MemoryError, NotFittedError, NotImplementedError, ShapeError, __export, asReadonlyArray, core_exports, dtypeToTypedArrayCtor, ensureNumericDType, getArrayElement, getBigIntElement, getConfig, getDevice, getDtype, getElementAsNumber, getNumericElement, getSeed, getShapeDim, getStringElement, isBigInt64Array, isDType, isDevice, isNumericTypedArray, isTypedArray, normalizeAxes, normalizeAxis, resetConfig, setConfig, setDevice, setDtype, setSeed, shapeToSize, validateArray, validateDevice, validateDtype, validateInteger, validateNonNegative, validateOneOf, validatePositive, validateRange, validateShape };
+//# sourceMappingURL=chunk-4S73VUBD.js.map
+//# sourceMappingURL=chunk-4S73VUBD.js.map