mlx-bun 0.5.0 → 1.0.0

package/src/model/glm52-config.ts

@@ -1,262 +0,0 @@
-// Dedicated GLM-5.2 / glm_moe_dsa configuration.
-//
-// This intentionally does not extend the universal dense descriptor. GLM-5.2
-// has a different attention state (compressed MLA + DSA), a correction-biased
-// sigmoid router, a native MTP row, and a converted Colibri container whose
-// quantization metadata is carried by tensor byte geometry rather than the
-// source checkpoint's FP8 quantization_config.
-
-export type Glm52IndexerType = "full" | "shared";
-
-export interface Glm52Config {
-  readonly modelDir: string;
-  readonly modelType: "glm_moe_dsa";
-  readonly architectures: string[];
-  readonly hiddenSize: number;
-  readonly numHiddenLayers: number;
-  readonly numAttentionHeads: number;
-  readonly numKeyValueHeads: number;
-  readonly qLoraRank: number;
-  readonly kvLoraRank: number;
-  readonly qkNopeHeadDim: number;
-  readonly qkRopeHeadDim: number;
-  readonly qkHeadDim: number;
-  readonly vHeadDim: number;
-  readonly firstKDenseReplace: number;
-  readonly intermediateSize: number;
-  readonly moeIntermediateSize: number;
-  readonly numRoutedExperts: number;
-  readonly numExpertsPerToken: number;
-  readonly numSharedExperts: number;
-  readonly nGroup: number;
-  readonly topkGroup: number;
-  readonly normTopkProb: boolean;
-  readonly routedScalingFactor: number;
-  readonly rmsNormEps: number;
-  readonly ropeTheta: number;
-  readonly ropeInterleave: boolean;
-  readonly vocabSize: number;
-  readonly maxPositionEmbeddings: number;
-  readonly indexTopk: number;
-  readonly indexNumHeads: number;
-  readonly indexHeadDim: number;
-  readonly indexerRopeInterleave: boolean;
-  readonly indexerTypes: Glm52IndexerType[];
-  readonly numNextnPredictLayers: number;
-  readonly indexShareForMtpIteration: boolean;
-  readonly eosTokenIds: number[];
-  readonly padTokenId: number;
-  readonly raw: Record<string, unknown>;
-}
-
-function integer(
-  raw: Record<string, any>,
-  key: string,
-  options: { min?: number; max?: number; fallback?: number } = {},
-): number {
-  const value = raw[key] ?? options.fallback;
-  if (!Number.isInteger(value))
-    throw new Error(`GLM-5.2 config: ${key} must be an integer (got ${String(value)})`);
-  if (options.min !== undefined && value < options.min)
-    throw new Error(`GLM-5.2 config: ${key}=${value} is below ${options.min}`);
-  if (options.max !== undefined && value > options.max)
-    throw new Error(`GLM-5.2 config: ${key}=${value} exceeds ${options.max}`);
-  return value;
-}
-
-function finite(
-  raw: Record<string, any>,
-  key: string,
-  options: { min?: number; fallback?: number } = {},
-): number {
-  const value = raw[key] ?? options.fallback;
-  if (typeof value !== "number" || !Number.isFinite(value))
-    throw new Error(`GLM-5.2 config: ${key} must be finite (got ${String(value)})`);
-  if (options.min !== undefined && value < options.min)
-    throw new Error(`GLM-5.2 config: ${key}=${value} is below ${options.min}`);
-  return value;
-}
-
-function boolean(raw: Record<string, any>, key: string, fallback = false): boolean {
-  const value = raw[key] ?? fallback;
-  if (typeof value !== "boolean")
-    throw new Error(`GLM-5.2 config: ${key} must be boolean (got ${String(value)})`);
-  return value;
-}
-
-function tokenIds(value: unknown, source: string): number[] {
-  if (value === undefined || value === null) return [];
-  const values = Array.isArray(value) ? value : [value];
-  return values.map((id) => {
-    if (!Number.isInteger(id) || id < 0)
-      throw new Error(`GLM-5.2 config: ${source} contains invalid token id ${String(id)}`);
-    return id as number;
-  });
-}
-
-function unionTokenIds(...groups: number[][]): number[] {
-  const seen = new Set<number>();
-  const out: number[] = [];
-  for (const group of groups) {
-    for (const id of group) {
-      if (seen.has(id)) continue;
-      seen.add(id);
-      out.push(id);
-    }
-  }
-  return out;
-}
-
-function indexerSchedule(raw: Record<string, any>, layers: number): Glm52IndexerType[] {
-  const explicit = raw.indexer_types;
-  if (explicit !== undefined) {
-    if (!Array.isArray(explicit) || explicit.length !== layers)
-      throw new Error(
-        `GLM-5.2 config: indexer_types must have ${layers} entries ` +
-        `(got ${Array.isArray(explicit) ? explicit.length : typeof explicit})`,
-      );
-    return explicit.map((entry, layer) => {
-      if (entry !== "full" && entry !== "shared")
-        throw new Error(`GLM-5.2 config: indexer_types[${layer}]=${String(entry)}`);
-      return entry;
-    });
-  }
-
-  const frequency = integer(raw, "index_topk_freq", { min: 1, fallback: 1 });
-  const offset = integer(raw, "index_skip_topk_offset", { min: 0, fallback: 2 });
-  // Exact pinned-Colibri fallback:
-  //   v = max(layer - offset + 1, 0); full iff v % frequency == 0.
-  return Array.from({ length: layers }, (_, layer) => {
-    const v = Math.max(layer - offset + 1, 0);
-    return v % frequency === 0 ? "full" : "shared";
-  });
-}
-
-export function parseGlm52Config(
-  modelDir: string,
-  raw: Record<string, any>,
-  generation: Record<string, any> | null = null,
-): Glm52Config {
-  if (raw.model_type !== "glm_moe_dsa")
-    throw new Error(`expected model_type "glm_moe_dsa" (got ${String(raw.model_type)})`);
-
-  const hiddenSize = integer(raw, "hidden_size", { min: 1, max: 1 << 20 });
-  const numHiddenLayers = integer(raw, "num_hidden_layers", { min: 1, max: 128 });
-  const numAttentionHeads = integer(raw, "num_attention_heads", { min: 1, max: 1024 });
-  const numKeyValueHeads = integer(raw, "num_key_value_heads", {
-    min: 1,
-    max: 1024,
-    fallback: numAttentionHeads,
-  });
-  const qLoraRank = integer(raw, "q_lora_rank", { min: 1, max: 1 << 20 });
-  const kvLoraRank = integer(raw, "kv_lora_rank", { min: 1, max: 1 << 20 });
-  const qkNopeHeadDim = integer(raw, "qk_nope_head_dim", { min: 1, max: 1 << 16 });
-  const qkRopeHeadDim = integer(raw, "qk_rope_head_dim", { min: 1, max: 1 << 16 });
-  const qkHeadDim = integer(raw, "qk_head_dim", {
-    min: 1,
-    max: 1 << 16,
-    fallback: qkNopeHeadDim + qkRopeHeadDim,
-  });
-  if (qkHeadDim !== qkNopeHeadDim + qkRopeHeadDim)
-    throw new Error(
-      `GLM-5.2 config: qk_head_dim=${qkHeadDim} != qk_nope_head_dim + ` +
-      `qk_rope_head_dim (${qkNopeHeadDim + qkRopeHeadDim})`,
-    );
-
-  const numRoutedExperts = integer(raw, "n_routed_experts", { min: 1, max: 4096 });
-  const numExpertsPerToken = integer(raw, "num_experts_per_tok", {
-    min: 1,
-    max: numRoutedExperts,
-  });
-  const nGroup = integer(raw, "n_group", { min: 1 });
-  const topkGroup = integer(raw, "topk_group", { min: 1 });
-  // The pinned GLM engine implements the n_group=1 noaux_tc router exactly.
-  // Refuse a future grouped-router architecture instead of silently selecting
-  // from the wrong candidate set.
-  if (nGroup !== 1 || topkGroup !== 1)
-    throw new Error(`GLM-5.2 config: only n_group=1/topk_group=1 is supported`);
-
-  const indexTopk = integer(raw, "index_topk", { min: 0, max: 1 << 20, fallback: 0 });
-  const indexNumHeads = integer(raw, "index_n_heads", { min: 0, max: 1024, fallback: 0 });
-  const indexHeadDim = integer(raw, "index_head_dim", { min: 0, max: 1 << 16, fallback: 0 });
-  if ((indexTopk === 0) !== (indexNumHeads === 0 || indexHeadDim === 0))
-    throw new Error(
-      `GLM-5.2 config: incomplete DSA geometry ` +
-      `(topk=${indexTopk}, heads=${indexNumHeads}, head_dim=${indexHeadDim})`,
-    );
-
-  const eosTokenIds = unionTokenIds(
-    tokenIds(raw.eos_token_id, "config.json:eos_token_id"),
-    tokenIds(generation?.eos_token_id, "generation_config.json:eos_token_id"),
-  );
-  if (eosTokenIds.length === 0)
-    throw new Error("GLM-5.2 config: no EOS token ids in config or generation config");
-
-  return {
-    modelDir,
-    modelType: "glm_moe_dsa",
-    architectures: Array.isArray(raw.architectures)
-      ? raw.architectures.map((entry: unknown) => String(entry))
-      : [],
-    hiddenSize,
-    numHiddenLayers,
-    numAttentionHeads,
-    numKeyValueHeads,
-    qLoraRank,
-    kvLoraRank,
-    qkNopeHeadDim,
-    qkRopeHeadDim,
-    qkHeadDim,
-    vHeadDim: integer(raw, "v_head_dim", { min: 1, max: 1 << 16 }),
-    firstKDenseReplace: integer(raw, "first_k_dense_replace", {
-      min: 0,
-      max: numHiddenLayers,
-    }),
-    intermediateSize: integer(raw, "intermediate_size", { min: 1, max: 1 << 24 }),
-    moeIntermediateSize: integer(raw, "moe_intermediate_size", { min: 1, max: 1 << 20 }),
-    numRoutedExperts,
-    numExpertsPerToken,
-    numSharedExperts: integer(raw, "n_shared_experts", { min: 0, max: 64, fallback: 0 }),
-    nGroup,
-    topkGroup,
-    normTopkProb: boolean(raw, "norm_topk_prob", false),
-    routedScalingFactor: finite(raw, "routed_scaling_factor", { min: 0, fallback: 1 }),
-    rmsNormEps: finite(raw, "rms_norm_eps", { min: 0, fallback: 1e-5 }),
-    ropeTheta: finite(raw.rope_parameters ?? raw, "rope_theta", {
-      min: Number.MIN_VALUE,
-      fallback: 10000,
-    }),
-    ropeInterleave: boolean(raw, "rope_interleave", true),
-    vocabSize: integer(raw, "vocab_size", { min: 1, max: 1 << 24 }),
-    maxPositionEmbeddings: integer(raw, "max_position_embeddings", {
-      min: 1,
-      max: 1 << 30,
-    }),
-    indexTopk,
-    indexNumHeads,
-    indexHeadDim,
-    indexerRopeInterleave: boolean(raw, "indexer_rope_interleave", true),
-    indexerTypes: indexerSchedule(raw, numHiddenLayers),
-    numNextnPredictLayers: integer(raw, "num_nextn_predict_layers", {
-      min: 0,
-      max: 8,
-      fallback: 0,
-    }),
-    indexShareForMtpIteration: boolean(raw, "index_share_for_mtp_iteration", false),
-    eosTokenIds,
-    padTokenId: integer(raw, "pad_token_id", { min: 0, fallback: eosTokenIds[0] }),
-    raw,
-  };
-}
-
-export async function loadGlm52Config(modelDir: string): Promise<Glm52Config> {
-  const configFile = Bun.file(`${modelDir}/config.json`);
-  if (!(await configFile.exists()))
-    throw new Error(`${modelDir}: missing config.json`);
-  const raw = (await configFile.json()) as Record<string, any>;
-  const generationFile = Bun.file(`${modelDir}/generation_config.json`);
-  const generation = await generationFile.exists()
-    ? await generationFile.json() as Record<string, any>
-    : null;
-  return parseGlm52Config(modelDir, raw, generation);
-}

package/src/model/glm52-container.ts

@@ -1,305 +0,0 @@
-// Header-only reader and validator for Colibri's converted GLM-5.2 artifact.
-//
-// Colibri emits ordinary safetensors shards named out-*, out-mtp-* and
-// optionally out-idx-*. There is no model.safetensors.index.json. Tensor byte
-// geometry is authoritative: converted 2-D tensors are flattened U8 payloads
-// with companion F32 `<name>.qs` scales. Reading only the headers avoids
-// mapping hundreds of GiB merely to validate the artifact.
-
-import { closeSync, fstatSync, openSync, readSync, readdirSync } from "node:fs";
-import { basename, join } from "node:path";
-import type { Glm52Config } from "./glm52-config";
-
-export type ColibriShardFamily = "main" | "mtp" | "indexer";
-export type ColibriDtype =
-  | "BOOL" | "U8" | "I8" | "U16" | "I16" | "U32" | "I32" | "U64" | "I64"
-  | "F16" | "BF16" | "F32" | "F64";
-
-const DTYPE_BYTES: Record<ColibriDtype, number> = {
-  BOOL: 1, U8: 1, I8: 1, U16: 2, I16: 2, U32: 4, I32: 4,
-  U64: 8, I64: 8, F16: 2, BF16: 2, F32: 4, F64: 8,
-};
-
-const GROUP_SIZES = [16, 32, 48, 64, 96, 128, 192, 256] as const;
-// Match safetensors' own defensive ceiling: headers are metadata, never model
-// payload. This prevents a corrupt multi-GiB shard from becoming a matching
-// multi-GiB Bun allocation before JSON validation.
-const MAX_SAFETENSORS_HEADER_BYTES = 100_000_000n;
-
-interface HeaderTensor {
-  dtype: ColibriDtype;
-  shape: number[];
-  data_offsets: [number, number];
-}
-
-export interface ColibriTensorInfo {
-  readonly name: string;
-  readonly dtype: ColibriDtype;
-  readonly shape: number[];
-  readonly file: string;
-  readonly family: ColibriShardFamily;
-  readonly begin: number;
-  readonly end: number;
-  readonly absoluteBegin: number;
-  readonly absoluteEnd: number;
-  readonly byteLength: number;
-}
-
-export interface ColibriQuantTensorInfo {
-  readonly name: string;
-  readonly outputRows: number;
-  readonly inputColumns: number;
-  readonly bits: 4 | 8;
-  readonly groupSize: number | null;
-  readonly weight: ColibriTensorInfo;
-  readonly scales: ColibriTensorInfo;
-  readonly coalescedNextWeight: string | null;
-}
-
-export interface Glm52ContainerCapabilities {
-  readonly hasMtp: boolean;
-  readonly hasDsa: boolean;
-  readonly missingMtpTensors: string[];
-  readonly missingDsaTensors: string[];
-}
-
-function product(shape: number[], label: string): number {
-  let value = 1;
-  for (const dim of shape) {
-    if (!Number.isSafeInteger(dim) || dim < 0)
-      throw new Error(`${label}: invalid shape ${JSON.stringify(shape)}`);
-    value *= dim;
-    if (!Number.isSafeInteger(value))
-      throw new Error(`${label}: shape product exceeds safe integer range`);
-  }
-  return value;
-}
-
-function readFully(fd: number, buffer: Uint8Array, position: number, label: string): void {
-  let offset = 0;
-  while (offset < buffer.byteLength) {
-    const got = readSync(fd, buffer, offset, buffer.byteLength - offset, position + offset);
-    if (got === 0)
-      throw new Error(`${label}: short read at ${position + offset}`);
-    offset += got;
-  }
-}
-
-function familyFor(filename: string): ColibriShardFamily | null {
-  if (/^out-mtp-\d+\.safetensors$/.test(filename)) return "mtp";
-  if (/^out-idx-\d+\.safetensors$/.test(filename)) return "indexer";
-  if (/^out-\d+\.safetensors$/.test(filename)) return "main";
-  return null;
-}
-
-function parseHeader(path: string, family: ColibriShardFamily): ColibriTensorInfo[] {
-  const fd = openSync(path, "r");
-  try {
-    const stat = fstatSync(fd);
-    if (stat.size < 8) throw new Error(`${path}: too small for safetensors`);
-    const prefix = Buffer.allocUnsafe(8);
-    readFully(fd, prefix, 0, path);
-    const headerBig = prefix.readBigUInt64LE(0);
-    if (headerBig > MAX_SAFETENSORS_HEADER_BYTES) {
-      throw new Error(
-        `${path}: safetensors header ${headerBig} exceeds ` +
-        `${MAX_SAFETENSORS_HEADER_BYTES} byte limit`,
-      );
-    }
-    if (headerBig > BigInt(Number.MAX_SAFE_INTEGER))
-      throw new Error(`${path}: safetensors header is too large`);
-    const headerLength = Number(headerBig);
-    const dataStart = 8 + headerLength;
-    if (headerLength < 2 || dataStart > stat.size)
-      throw new Error(`${path}: invalid safetensors header length ${headerLength}`);
-    const bytes = Buffer.allocUnsafe(headerLength);
-    readFully(fd, bytes, 8, path);
-    let parsed: Record<string, HeaderTensor | Record<string, string>>;
-    try {
-      parsed = JSON.parse(bytes.toString("utf8"));
-    } catch (error) {
-      throw new Error(`${path}: invalid safetensors JSON: ${String(error)}`);
-    }
-
-    const out: ColibriTensorInfo[] = [];
-    for (const [name, raw] of Object.entries(parsed)) {
-      if (name === "__metadata__") continue;
-      const entry = raw as HeaderTensor;
-      if (!entry || !(entry.dtype in DTYPE_BYTES) || !Array.isArray(entry.shape) ||
-          !Array.isArray(entry.data_offsets) || entry.data_offsets.length !== 2)
-        throw new Error(`${path}: malformed tensor entry ${name}`);
-      const [begin, end] = entry.data_offsets;
-      if (!Number.isSafeInteger(begin) || !Number.isSafeInteger(end) || begin < 0 || end < begin)
-        throw new Error(`${path}: tensor ${name} has invalid offsets ${String(entry.data_offsets)}`);
-      const elements = product(entry.shape, `${path}:${name}`);
-      const expected = elements * DTYPE_BYTES[entry.dtype];
-      if (end - begin !== expected)
-        throw new Error(
-          `${path}: tensor ${name} byte range ${end - begin} != ` +
-          `${JSON.stringify(entry.shape)} × ${entry.dtype}`,
-        );
-      if (dataStart + end > stat.size)
-        throw new Error(`${path}: tensor ${name} extends past end of shard`);
-      out.push({
-        name,
-        dtype: entry.dtype,
-        shape: [...entry.shape],
-        file: path,
-        family,
-        begin,
-        end,
-        absoluteBegin: dataStart + begin,
-        absoluteEnd: dataStart + end,
-        byteLength: end - begin,
-      });
-    }
-    return out;
-  } finally {
-    closeSync(fd);
-  }
-}
-
-export class ColibriGlm52Container {
-  readonly tensors = new Map<string, ColibriTensorInfo>();
-  readonly files: ReadonlyArray<{ path: string; family: ColibriShardFamily }>;
-
-  private constructor(files: Array<{ path: string; family: ColibriShardFamily }>) {
-    this.files = files;
-    for (const { path, family } of files) {
-      for (const tensor of parseHeader(path, family)) {
-        const prior = this.tensors.get(tensor.name);
-        if (prior)
-          throw new Error(
-            `duplicate Colibri tensor ${tensor.name} in ${basename(prior.file)} ` +
-            `and ${basename(tensor.file)}`,
-          );
-        this.tensors.set(tensor.name, tensor);
-      }
-    }
-    if (this.tensors.size === 0)
-      throw new Error("Colibri container has no tensors");
-  }
-
-  static open(modelDir: string): ColibriGlm52Container {
-    const files = readdirSync(modelDir)
-      .map((name) => ({ name, family: familyFor(name) }))
-      .filter((entry): entry is { name: string; family: ColibriShardFamily } =>
-        entry.family !== null)
-      .sort((a, b) => a.name.localeCompare(b.name))
-      .map(({ name, family }) => ({ path: join(modelDir, name), family }));
-    if (!files.some((entry) => entry.family === "main"))
-      throw new Error(`${modelDir}: no out-NNNNN.safetensors Colibri shards`);
-    return new ColibriGlm52Container(files);
-  }
-
-  has(name: string): boolean {
-    return this.tensors.has(name);
-  }
-
-  info(name: string): ColibriTensorInfo {
-    const info = this.tensors.get(name);
-    if (!info) throw new Error(`Colibri container: missing tensor ${name}`);
-    return info;
-  }
-
-  /** Validate a converted 2-D tensor and infer int4 group geometry from scales. */
-  quantized(name: string, outputRows: number, inputColumns: number): ColibriQuantTensorInfo {
-    if (!Number.isSafeInteger(outputRows) || outputRows <= 0 ||
-        !Number.isSafeInteger(inputColumns) || inputColumns <= 0)
-      throw new Error(`${name}: invalid logical shape [${outputRows},${inputColumns}]`);
-    const weight = this.info(name);
-    const scales = this.info(`${name}.qs`);
-    if (weight.dtype !== "U8")
-      throw new Error(`${name}: converted weight must be U8 (got ${weight.dtype})`);
-    if (scales.dtype !== "F32")
-      throw new Error(`${name}.qs: scales must be F32 (got ${scales.dtype})`);
-
-    const int8Bytes = outputRows * inputColumns;
-    const int4Bytes = outputRows * Math.ceil(inputColumns / 2);
-    let bits: 4 | 8;
-    if (weight.byteLength === int8Bytes) bits = 8;
-    else if (weight.byteLength === int4Bytes) bits = 4;
-    else {
-      throw new Error(
-        `${name}: ${weight.byteLength} bytes do not encode logical ` +
-        `[${outputRows},${inputColumns}] as int8 (${int8Bytes}) or int4 (${int4Bytes})`,
-      );
-    }
-
-    const scaleCount = scales.byteLength / 4;
-    let groupSize: number | null = null;
-    if (scaleCount !== outputRows) {
-      if (bits !== 4)
-        throw new Error(`${name}.qs: grouped scales are only valid for int4`);
-      groupSize = GROUP_SIZES.find(
-        (candidate) => scaleCount === outputRows * Math.ceil(inputColumns / candidate),
-      ) ?? null;
-      if (groupSize === null)
-        throw new Error(
-          `${name}.qs: ${scaleCount} scales do not match per-row or a supported ` +
-          `group size for [${outputRows},${inputColumns}]`,
-        );
-    }
-
-    let coalescedNextWeight: string | null = null;
-    for (const other of this.tensors.values()) {
-      if (other.dtype === "U8" && other.file === weight.file &&
-          other.absoluteBegin === weight.absoluteEnd) {
-        coalescedNextWeight = other.name;
-        break;
-      }
-    }
-    return {
-      name,
-      outputRows,
-      inputColumns,
-      bits,
-      groupSize,
-      weight,
-      scales,
-      coalescedNextWeight,
-    };
-  }
-
-  capabilities(config: Glm52Config): Glm52ContainerCapabilities {
-    const mtpLayer = config.numHiddenLayers;
-    const mtpPrefix = `model.layers.${mtpLayer}`;
-    // G4 validates the full MTP family before enabling drafting. G2 records the
-    // architectural sentinels so a partial sidecar cannot masquerade as MTP.
-    const mtpRequired = config.numNextnPredictLayers > 0 ? [
-      `${mtpPrefix}.eh_proj.weight`,
-      `${mtpPrefix}.enorm.weight`,
-      `${mtpPrefix}.hnorm.weight`,
-      `${mtpPrefix}.shared_head.norm.weight`,
-      `${mtpPrefix}.input_layernorm.weight`,
-      `${mtpPrefix}.post_attention_layernorm.weight`,
-      `${mtpPrefix}.self_attn.q_a_proj.weight`,
-      `${mtpPrefix}.self_attn.kv_a_proj_with_mqa.weight`,
-      `${mtpPrefix}.mlp.gate.weight`,
-      `${mtpPrefix}.mlp.gate.e_score_correction_bias`,
-    ] : [];
-    const missingMtpTensors = mtpRequired.filter((name) => !this.has(name));
-
-    const dsaRequired: string[] = [];
-    if (config.indexTopk > 0) {
-      for (let layer = 0; layer < config.numHiddenLayers; layer++) {
-        if (config.indexerTypes[layer] !== "full") continue;
-        const prefix = `model.layers.${layer}.self_attn.indexer`;
-        dsaRequired.push(
-          `${prefix}.wq_b.weight`,
-          `${prefix}.wk.weight`,
-          `${prefix}.weights_proj.weight`,
-          `${prefix}.k_norm.weight`,
-          `${prefix}.k_norm.bias`,
-        );
-      }
-    }
-    const missingDsaTensors = dsaRequired.filter((name) => !this.has(name));
-    return {
-      hasMtp: mtpRequired.length > 0 && missingMtpTensors.length === 0,
-      hasDsa: dsaRequired.length > 0 && missingDsaTensors.length === 0,
-      missingMtpTensors,
-      missingDsaTensors,
-    };
-  }
-}