fix delta corruption. removed dead code. added delta for --multi tensor cast.

voice.py

@@ -1929,6 +1929,15 @@ def cmd_cast(args):
     target_format = "gguf" if _is_gguf_file(target) else "safetensors"
     out_path = _out_path(args, target, voice_arg)
     _check_overwrite(out_path, args)
+    # Voicepack in the registry (or a pack path): cast every tensor, not just the first.
+    try:
+        _probe = open_source(str(voice_path))
+        _pack_names = [n for n in _probe.names() if n != "delta.voice.marker"]
+    except Exception:
+        _pack_names = []
+    if len(_pack_names) > 1:
+        _cast_pack(target, str(voice_path), out_path, args, op="cast", meta=voice_meta)
+        return
 
     # auto-detect delta file via marker even without voice.json (e.g. shipped style.safetensors)
     # do this after _check_overwrite so prompt and Detected don't interleave
@@ -2161,63 +2170,11 @@ def _quantize_to_Q(fused, req_q):
     return quantize(fused, req_q), req_q
 
 
-def _cast_gguf(target, out_path, vf32, vref, meta, args, op, vraw=None, vqtype=None, strict_target=False):
+def _gguf_fuse_one(target, target_tensor, tname, logical, vf32, vref, meta, args, op, vraw=None, vqtype=None):
+    """Fuse one voice tensor into its target GGUF tensor form. Returns (q_head, out_qtype)."""
     import numpy as np
-    from gguf import GGUFReader, GGUFWriter
-    from gguf.gguf_writer import GGUFValue
     from gguf.constants import GGMLQuantizationType as Q
     from gguf.quants import quantize
-
-    reader = GGUFReader(target)
-    arch = None
-    for field in reader.fields.values():
-        if field.name == "general.architecture":
-            try:
-                raw = field.parts[field.data[0]]
-                arch = raw.tobytes().decode() if isinstance(raw, np.ndarray) else str(raw)
-            except Exception:
-                arch = None
-            break
-
-    target_tensor = None
-    if vref.name:
-        for t in reader.tensors:
-            if t.name == vref.name:
-                target_tensor = t
-                break
-    if target_tensor is None and strict_target:
-        _fail(f"  ✗ Tensor '{vref.name}' not found in target {target}. Voicepack requires exact match (not mapping to another tensor).")
-    if target_tensor is None:
-        for preferred in ("output.weight", "token_embd.weight"):
-            for t in reader.tensors:
-                if t.name == preferred:
-                    target_tensor = t
-                    break
-            if target_tensor is not None:
-                break
-    if target_tensor is None:
-        # largest 2-D
-        best, best_n = None, 0
-        for t in reader.tensors:
-            if len(t.shape) == 2:
-                n = int(t.shape[0]) * int(t.shape[1])
-                if n > best_n:
-                    best, best_n = t, n
-        target_tensor = best
-    if target_tensor is None:
-        _fail("  ✗ Could not find an output tensor in the GGUF file.")
-
-    tname = target_tensor.name
-    logical = tuple(reversed(tuple(int(x) for x in target_tensor.shape)))
-
-    # arch mismatch warning
-    varch = (meta or {}).get("architecture")
-    if varch and arch and varch.lower() != arch.lower():
-        _warn(f"This voice was trained for a {varch} model, but the target is {arch}. It may not sound right.")
-        if not _confirm("  Continue anyway? [y/N]: ", args):
-            _note("Cancelled.")
-            sys.exit(0)
-
     # Philosophy: preserve quality, avoid dequant->quant cycles.
     # - GGUF quant voice (vraw) is kept at its obtained quant (never upscale Q2->Q6, no inventing data).
     # - Safetensors high-fidelity lm_head (voice) is quantized once to Q8_0.
@@ -2527,7 +2484,14 @@ def _cast_gguf(target, out_path, vf32, vref, meta, args, op, vraw=None, vqtype=N
         except Exception:
             t_fuse0 = time.time()
         _note(f"Fusing done in {time.time()-t_fuse0:.1f}s")
+    return q_head, out_qtype
 
+def _gguf_write_repl(target, reader, arch, repl, out_path, args, op, detail=None):
+    """Single-pass GGUF write. repl maps tensor name -> (array, ggml_type).
+    detail (single-tensor callers): (tname, logical, vref, vraw, vqtype, meta) for rich messages."""
+    from gguf import GGUFWriter
+    from gguf.gguf_writer import GGUFValue
+    from gguf.constants import GGMLQuantizationType as Q
     if not arch:
         _warn("  Target architecture unknown — labeling output 'llama' (GGUF requires an arch).")
     writer = GGUFWriter(out_path, arch or "llama", use_temp_file=True)
@@ -2552,8 +2516,9 @@ def _cast_gguf(target, out_path, vf32, vref, meta, args, op, vraw=None, vqtype=N
                     _warn(f"Could not copy field {field.name}")
 
     for t in reader.tensors:
-        if t.name == tname:
-            writer.add_tensor(t.name, q_head, raw_dtype=out_qtype)
+        if t.name in repl:
+            _qh, _qt = repl[t.name]
+            writer.add_tensor(t.name, _qh, raw_dtype=_qt)
         elif t.tensor_type in (Q.F32, Q.F16):
             writer.add_tensor(t.name, t.data)
         else:
@@ -2565,7 +2530,7 @@ def _cast_gguf(target, out_path, vf32, vref, meta, args, op, vraw=None, vqtype=N
     try:
         total_write = 8192
         for t in reader.tensors:
-            if t.name == tname:
+            if t.name in repl:
                 continue
             try:
                 total_write += int(t.data.nbytes)
@@ -2573,26 +2538,31 @@ def _cast_gguf(target, out_path, vf32, vref, meta, args, op, vraw=None, vqtype=N
                 if VERBOSE:
                     _warn(f"progress estimate for {t.name} failed: {e}")
         try:
-            total_write += int(q_head.nbytes)
-        except Exception as e:
-            if VERBOSE:
-                _warn(f"progress estimate for q_head failed: {e}")
+            for _qh, _qt in repl.values():
+                total_write += int(_qh.nbytes)
+        except Exception:
             try:
-                total_write += int(q_head.size * q_head.itemsize)
+                for _qh, _qt in repl.values():
+                    total_write += int(_qh.size * _qh.itemsize)
             except Exception:
                 pass
         if VERBOSE:
-            _note(f"Estimated write {total_write/1e6:.1f} MB (q_head {q_head.nbytes/1e6:.1f} MB + {len([t for t in reader.tensors if t.name != tname])} tensors)")
+            _note(f"Estimated write {total_write/1e6:.1f} MB ({len(repl)} replaced + {len([t for t in reader.tensors if t.name not in repl])} copied)")
     except Exception as e:
         if VERBOSE:
             _warn(f"progress estimate failed: {e}")
         total_write = 0
-    # ensure total_write is at least header + q_head for small models, never 0 for progress
+    # ensure total_write is at least header + heads for small models, never 0 for progress
     if total_write < 1000:
         try:
-            total_write = int(q_head.nbytes) + 8192
+            total_write = 8192
+            for _qh, _qt in repl.values():
+                try:
+                    total_write += int(_qh.nbytes)
+                except Exception:
+                    pass
             for t in reader.tensors:
-                if t.name != tname:
+                if t.name not in repl:
                     try:
                         total_write += int(t.data.nbytes)
                     except Exception:
@@ -2673,6 +2643,17 @@ def _cast_gguf(target, out_path, vf32, vref, meta, args, op, vraw=None, vqtype=N
         pass
 
     file_size = os.path.getsize(out_path)
+    if detail is None:
+        summed = [(n, _qt.name if hasattr(_qt, "name") else str(_qt)) for n, (_qh, _qt) in repl.items()]
+        log_operation({"op": op, "target": target, "format": "gguf", "tensors": summed,
+                       "output": out_path, "status": "ok"})
+        _ok(f"Done → {out_path}")
+        for n, _qt in summed:
+            _say(f"  Cast '{n}' → {_qt} ({file_size/1e6:.1f} MB total).")
+        _say(f"  Load it: llama serve -m {out_path}")
+        return
+    tname, logical, vref, vraw, vqtype, meta = detail
+    _qh0, out_qtype = repl[tname]
     log_operation({"op": op, "target": target, "format": "gguf", "tensor": tname,
                    "dtype": out_qtype.name, "shape": list(logical), "output": out_path, "status": "ok"})
     _ok(f"Done → {out_path}")
@@ -2690,7 +2671,8 @@ def _cast_gguf(target, out_path, vf32, vref, meta, args, op, vraw=None, vqtype=N
     elif is_fallback:
         _say(f"  Head kept as F16 (Q8_0 needs last dim %32, fallback) ({file_size/1e6:.1f} MB).")
     elif out_qtype == Q.Q8_0 and _is_head_msg:
-        _kept_q8 = (vraw is not None and isinstance(vqtype, str) and vqtype == Q.Q8_0.name and _quant_override in ("keep",))
+        _qo = _parse_quant_override(getattr(args, "quant", None) or "keep")
+        _kept_q8 = (vraw is not None and isinstance(vqtype, str) and vqtype == Q.Q8_0.name and _qo in ("keep",))
         if _kept_q8:
             _say(f"  Head kept as Q8_0 (from {vqtype}, {file_size/1e6:.1f} MB).")
         else:
@@ -2700,6 +2682,154 @@ def _cast_gguf(target, out_path, vf32, vref, meta, args, op, vraw=None, vqtype=N
         _say(f"  {_label} '{tname}' kept as {out_qtype.name} (from {_from}, {file_size/1e6:.1f} MB).")
     _say(f"  Load it: llama serve -m {out_path}")
 
+def _cast_gguf(target, out_path, vf32, vref, meta, args, op, vraw=None, vqtype=None, strict_target=False):
+    import numpy as np
+    from gguf import GGUFReader
+
+    reader = GGUFReader(target)
+    arch = None
+    for field in reader.fields.values():
+        if field.name == "general.architecture":
+            try:
+                raw = field.parts[field.data[0]]
+                arch = raw.tobytes().decode() if isinstance(raw, np.ndarray) else str(raw)
+            except Exception:
+                arch = None
+            break
+
+    target_tensor = None
+    if vref.name:
+        for t in reader.tensors:
+            if t.name == vref.name:
+                target_tensor = t
+                break
+    if target_tensor is None and strict_target:
+        _fail(f"  ✗ Tensor '{vref.name}' not found in target {target}. Voicepack requires exact match (not mapping to another tensor).")
+    if target_tensor is None:
+        for preferred in ("output.weight", "token_embd.weight"):
+            for t in reader.tensors:
+                if t.name == preferred:
+                    target_tensor = t
+                    break
+            if target_tensor is not None:
+                break
+    if target_tensor is None:
+        # largest 2-D
+        best, best_n = None, 0
+        for t in reader.tensors:
+            if len(t.shape) == 2:
+                n = int(t.shape[0]) * int(t.shape[1])
+                if n > best_n:
+                    best, best_n = t, n
+        target_tensor = best
+    if target_tensor is None:
+        _fail("  ✗ Could not find an output tensor in the GGUF file.")
+
+    tname = target_tensor.name
+    logical = tuple(reversed(tuple(int(x) for x in target_tensor.shape)))
+
+    # arch mismatch warning
+    varch = (meta or {}).get("architecture")
+    if varch and arch and varch.lower() != arch.lower():
+        _warn(f"This voice was trained for a {varch} model, but the target is {arch}. It may not sound right.")
+        if not _confirm("  Continue anyway? [y/N]: ", args):
+            _note("Cancelled.")
+            sys.exit(0)
+
+    q_head, out_qtype = _gguf_fuse_one(target, target_tensor, tname, logical, vf32, vref, meta, args, op, vraw=vraw, vqtype=vqtype)
+    _gguf_write_repl(target, reader, arch, {tname: (q_head, out_qtype)}, out_path, args, op,
+                      detail=(tname, logical, vref, vraw, vqtype, meta))
+
+
+
+def _cast_gguf_pack(target, out_path, items, args, op):
+    """Single-pass pack cast onto GGUF. items: [(vf32, vref, meta, vraw, vqtype)]."""
+    import numpy as np
+    from gguf import GGUFReader
+    reader = GGUFReader(target)
+    arch = None
+    for field in reader.fields.values():
+        if field.name == "general.architecture":
+            try:
+                raw = field.parts[field.data[0]]
+                arch = raw.tobytes().decode() if isinstance(raw, np.ndarray) else str(raw)
+            except Exception:
+                arch = None
+            break
+    varch = (items[0][2] or {}).get("architecture") if items else None
+    if varch and arch and varch.lower() != arch.lower():
+        _warn(f"This voice was trained for a {varch} model, but the target is {arch}. It may not sound right.")
+        if not _confirm("  Continue anyway? [y/N]: ", args):
+            _note("Cancelled.")
+            sys.exit(0)
+    repl = {}
+    for vf32, vref, meta, vraw, vqtype in items:
+        target_tensor = None
+        if vref.name:
+            for t in reader.tensors:
+                if t.name == vref.name:
+                    target_tensor = t
+                    break
+        if target_tensor is None:
+            _fail(f"  ✗ Tensor '{vref.name}' not found in target {target}. Voicepack requires exact match (not mapping to another tensor).")
+        tname = target_tensor.name
+        logical = tuple(reversed(tuple(int(x) for x in target_tensor.shape)))
+        q_head, out_qtype = _gguf_fuse_one(target, target_tensor, tname, logical, vf32, vref, meta, args, op, vraw=vraw, vqtype=vqtype)
+        repl[tname] = (q_head, out_qtype)
+    _gguf_write_repl(target, reader, arch, repl, out_path, args, op)
+
+
+def _cast_pack(target, src_path, out_path, args, op, excludes=(), meta=None):
+    """Cast every tensor in a pack file onto target (minus excludes).
+    GGUF targets get one write pass; safetensors targets chain per-tensor.
+    Delta marker on the pack is detected once and threaded into every tensor."""
+    src = open_source(str(src_path))
+    all_names = [n for n in src.names() if n != "delta.voice.marker"]
+    for e in excludes:
+        if e not in all_names and not any(e in n for n in all_names):
+            _warn(f"  --exclude '{e}' not in pack (has {len(all_names)} tensors). Ignoring.")
+    resolved_ex = set()
+    for e in excludes:
+        if e in all_names:
+            resolved_ex.add(e)
+        else:
+            _m = [n for n in all_names if e in n]
+            if len(_m) == 1:
+                resolved_ex.add(_m[0])
+    to_cast = [n for n in all_names if n not in resolved_ex]
+    if not to_cast:
+        _fail("  ✗ --exclude removes all tensors. Nothing to cast.")
+    _step(f"Casting {len(to_cast)} tensors from {Path(src_path).name} onto {Path(target).name}…")
+    if resolved_ex:
+        _note(f"Excluding {len(resolved_ex)}: {', '.join(sorted(resolved_ex))}")
+    is_delta_file = str(src_path).endswith(".safetensors") and _is_delta_safetensors(str(src_path))
+    if is_delta_file:
+        _note("Detected delta voice — fusing style (delta + head)…")
+    if meta is None and is_delta_file:
+        meta = {"type": "delta", "source": str(src_path)}
+    items = []
+    for i, tname in enumerate(to_cast):
+        f32, ref, raw, qtype = _load_tensor(src_path, tname)
+        _step(f"[{i+1}/{len(to_cast)}] {tname} ({ref.dtype} {tuple(ref.shape)})…")
+        items.append((f32, ref, meta, raw, qtype))
+    if _is_gguf_file(target):
+        _cast_gguf_pack(target, out_path, items, args, op)
+        return
+    import tempfile, shutil
+    cur_in = target
+    tmpdir = Path(tempfile.mkdtemp(prefix="voicepack-cast-"))
+    try:
+        for i, (f32, ref, meta, raw, qtype) in enumerate(items):
+            is_last = (i == len(items) - 1)
+            _out = out_path if is_last else str(tmpdir / f"step{i}.tmp")
+            _cast_core(cur_in, "safetensors", _out, f32, ref, meta, args, op="tensor_cast",
+                       vraw=raw, vqtype=qtype, strict_target=True)
+            cur_in = _out
+    finally:
+        try:
+            shutil.rmtree(tmpdir, ignore_errors=True)
+        except Exception:
+            pass
 
 def _write_fetched(fetched, tensor_name, out_path):
     """Write a fetched tensor to a standalone artifact (gguf when quantized)."""
@@ -2891,6 +3021,17 @@ def cmd_tensor_get(args):
 #  CMD: tensor cast — cast any named tensor onto a file
 # ---------------------------------------------------------------------------
 
+def _tensor_src_meta(src_path):
+    """File-level delta detection for the tensor path (the marker lives in the file; no voice.json)."""
+    if str(src_path).endswith(".safetensors"):
+        try:
+            if _is_delta_safetensors(str(src_path)):
+                return {"type": "delta", "source": str(src_path)}
+        except Exception:
+            pass
+    return None
+
+
 def cmd_tensor_cast(args):
     target = args.target
     if not os.path.exists(target):
@@ -2917,52 +3058,13 @@ def cmd_tensor_cast(args):
         target_format = "gguf" if _is_gguf_file(target) else "safetensors"
         out_path = _out_path(args, target, src_path)
         _check_overwrite(out_path, args)
-        _cast_core(target, target_format, out_path, f32, ref, None, args, op="tensor_cast", vraw=raw, vqtype=qtype)
+        _cast_core(target, target_format, out_path, f32, ref, _tensor_src_meta(src_path), args, op="tensor_cast", vraw=raw, vqtype=qtype)
         return
     if len(_all_names) > 1:
-        # Voicepack multi-cast: replace all (minus excluded) in one output, with progress.
-        # Validate excludes exist (warn on unknown, fail on all-excluded).
-        for e in excludes:
-            if e not in _all_names and not any(e in n for n in _all_names):
-                _warn(f"  --exclude '{e}' not in pack (has {len(_all_names)} tensors). Ignoring.")
-        # Resolve excludes via substring single-match like get (exact first).
-        _resolved_ex = set()
-        for e in excludes:
-            if e in _all_names:
-                _resolved_ex.add(e)
-            else:
-                _m = [n for n in _all_names if e in n]
-                if len(_m) == 1:
-                    _resolved_ex.add(_m[0])
-        to_cast = [n for n in _all_names if n not in _resolved_ex]
-        if not to_cast:
-            _fail("  ✗ --exclude removes all tensors. Nothing to cast.")
-        _step(f"Casting {len(to_cast)} tensors from {Path(src_path).name} onto {Path(target).name}…")
-        if excludes:
-            _note(f"Excluding {len(_resolved_ex)}: {', '.join(sorted(_resolved_ex))}")
-        target_format = "gguf" if _is_gguf_file(target) else "safetensors"
+        # Voicepack: one pass for GGUF, chained for safetensors (see _cast_pack).
         out_path = _out_path(args, target, src_path)
         _check_overwrite(out_path, args)
-        # Chain single casts via temp files (efficient for <50MB tests; single-pass for GGUF would be N rewrites anyway).
-        # For correctness with philosophy (keep target quant per tensor), reuse _cast_core per tensor.
-        import tempfile, shutil
-        _cur_in = target
-        _tmpdir = Path(tempfile.mkdtemp(prefix="voicepack-cast-"))
-        try:
-            for i, tname in enumerate(to_cast):
-                is_last = (i == len(to_cast) - 1)
-                _out = out_path if is_last else str(_tmpdir / f"step{i}.tmp")
-                f32, ref, raw, qtype = _load_tensor(src_path, tname)
-                _step(f"[{i+1}/{len(to_cast)}] {tname} ({ref.dtype} {tuple(ref.shape)})…")
-                _cast_core(_cur_in, "gguf" if _is_gguf_file(_cur_in) else "safetensors",
-                           _out, f32, ref, None, args, op="tensor_cast", vraw=raw, vqtype=qtype,
-                           strict_target=True)
-                _cur_in = _out
-        finally:
-            try:
-                shutil.rmtree(_tmpdir, ignore_errors=True)
-            except Exception:
-                pass
+        _cast_pack(target, src_path, out_path, args, op="tensor_cast", excludes=excludes)
         return
     # Single-tensor pack (or single file) without --tensor flag: original behavior.
     f32, ref, raw, qtype = _load_tensor(src_path, None)
@@ -2971,7 +3073,7 @@ def cmd_tensor_cast(args):
     target_format = "gguf" if _is_gguf_file(target) else "safetensors"
     out_path = _out_path(args, target, src_path)
     _check_overwrite(out_path, args)
-    _cast_core(target, target_format, out_path, f32, ref, None, args, op="tensor_cast", vraw=raw, vqtype=qtype)
+    _cast_core(target, target_format, out_path, f32, ref, _tensor_src_meta(src_path), args, op="tensor_cast", vraw=raw, vqtype=qtype)
 
 
 def _load_tensor(path, name=None):
@@ -3167,14 +3269,18 @@ def cmd_delta(args):
         "dtype": "F16",
         "downloaded_at": _now_iso(),
     }
-    # enrich with shape/dtype from the delta file
+    # enrich with shape/dtype from the delta file (all tensors, not just the first)
     try:
         hdr, tens = read_safetensors(str(delta_folder / "voice.safetensors"))
-        k = list(tens.keys())[0]
-        meta["tensor_name"] = k
-        meta["shape"] = list(tens[k]["shape"])
-        meta["dtype"] = tens[k]["dtype"]
-        meta["bytes"] = tens[k]["data_offsets"][1]
+        keys = [k for k in tens.keys() if k != "delta.voice.marker"]
+        meta["tensors"] = [{"name": k, "shape": list(tens[k]["shape"]), "dtype": tens[k]["dtype"],
+                            "bytes": tens[k]["data_offsets"][1] - tens[k]["data_offsets"][0]} for k in keys]
+        if len(keys) == 1:
+            # backward compat: single-tensor voices keep flat fields
+            meta["tensor_name"] = keys[0]
+            meta["shape"] = list(tens[keys[0]]["shape"])
+            meta["dtype"] = tens[keys[0]]["dtype"]
+            meta["bytes"] = tens[keys[0]]["data_offsets"][1]
     except Exception:
         pass
     jtmp = delta_folder / "voice.json.tmp"
@@ -3381,20 +3487,19 @@ def _compute_delta(voice_path, base_path, delta_folder, delta_name, args=None):
         b_names = [n for n in b_src.names() if n != "delta.voice.marker"]
         if not v_names or not b_names:
             _fail("  ✗ No tensors found for delta.")
-        # Prefer same name if possible, else first.
-        vname = v_names[0]
-        # Try to match voice name in base.
+        # Match by exact name: every voice tensor needs a same-named base tensor.
+        # Output head first for deterministic order, then voice order.
         try:
             arch, cfg = _source_arch(v_src)
             _cand = _resolve_output_name(v_src, cfg, v_names)
-            if _cand in v_names:
-                vname = _cand
         except Exception:
-            pass
-        bname = vname if vname in b_names else b_names[0]
-        vref, bref = v_src.ref(vname), b_src.ref(bname)
-        if tuple(vref.shape) != tuple(bref.shape):
-            _fail(f"  ✗ Voice shape {tuple(vref.shape)} doesn't fit base {tuple(bref.shape)}.")
+            _cand = None
+        ordered = ([_cand] if _cand in v_names else []) + [n for n in v_names if n != _cand]
+        missing = [n for n in ordered if n not in b_names]
+        if missing:
+            shown = ", ".join(missing[:5]) + ("…" if len(missing) > 5 else "")
+            _fail(f"  ✗ {len(missing)} voice tensor(s) have no match in base: {shown}. Delta needs same names on both sides.")
+        pairs = [(n, n) for n in ordered]
         # Gates (marker check works for both safetensors header and GGUF? GGUF has no marker, so False unless safetensors delta).
         is_voice_delta = _is_delta_safetensors(str(voice_path)) if str(voice_path).endswith(".safetensors") else False
         is_base_delta = _is_delta_safetensors(str(base_path)) if str(base_path).endswith(".safetensors") else False
@@ -3413,11 +3518,6 @@ def _compute_delta(voice_path, base_path, delta_folder, delta_name, args=None):
                                "     The voice and base are both delta-voices.",
                                "     delta − delta = style difference of style differences."],
                         "BIG BRAIN", "delta-on-delta needs explicit confirmation")
-        _warn(f"  Dequanting {vname} ({vref.dtype}) and {bname} ({bref.dtype}) once to F32 for delta math (unavoidable for GGUF quant).")
-        v_f32, b_f32 = v_src.read_f32(vname), b_src.read_f32(bname)
-        if v_f32.shape != b_f32.shape:
-            _fail(f"  ✗ Shape mismatch after dequant: {v_f32.shape} vs {b_f32.shape}.")
-        delta_f16 = (v_f32.astype(np.float32) - b_f32.astype(np.float32)).astype("float16")
         _assert_not_symlink(delta_folder)
         delta_folder.mkdir(parents=True, exist_ok=True)
         try:
@@ -3426,17 +3526,32 @@ def _compute_delta(voice_path, base_path, delta_folder, delta_name, args=None):
             pass
         out_path = delta_folder / "voice.safetensors"
         tmp_out = delta_folder / "voice.safetensors.tmp"
-        total_elems = int(delta_f16.size)
-        header = {
-            vname: {"dtype": "F16", "shape": list(delta_f16.shape), "data_offsets": [0, total_elems * 2]},
-            "delta.voice.marker": {"dtype": "U8", "shape": [1], "data_offsets": [total_elems * 2, total_elems * 2 + 1]},
-            "__metadata__": {"type": "delta", "base": _public_source(str(base_path)), "voice": _public_source(str(voice_path))},
-        }
+        # Header first (offsets need shapes only), then stream one pair at a
+        # time so packs never hold every tensor in RAM at once.
+        header, off = {}, 0
+        for vname, bname in pairs:
+            vref, bref = v_src.ref(vname), b_src.ref(bname)
+            if tuple(vref.shape) != tuple(bref.shape):
+                _fail(f"  ✗ Voice tensor '{vname}' shape {tuple(vref.shape)} doesn't fit base {tuple(bref.shape)}.")
+            nbytes = 2
+            for d in vref.shape:
+                nbytes *= int(d)
+            header[vname] = {"dtype": "F16", "shape": [int(x) for x in vref.shape], "data_offsets": [off, off + nbytes]}
+            off += nbytes
+        header["delta.voice.marker"] = {"dtype": "U8", "shape": [1], "data_offsets": [off, off + 1]}
+        header["__metadata__"] = {"type": "delta", "base": _public_source(str(base_path)), "voice": _public_source(str(voice_path))}
         hj = json.dumps(header).encode("utf-8")
         with open(tmp_out, "wb") as out:
             out.write(struct.pack("<Q", len(hj)))
             out.write(hj)
-            out.write(delta_f16.tobytes())
+            for vname, bname in pairs:
+                vref, bref = v_src.ref(vname), b_src.ref(bname)
+                _warn(f"  Dequanting {vname} ({vref.dtype}) and base ({bref.dtype}) once to F32 for delta math (unavoidable for GGUF quant).")
+                v_f32, b_f32 = v_src.read_f32(vname), b_src.read_f32(bname)
+                if v_f32.shape != b_f32.shape:
+                    sys.stdout.write("\n")
+                    _fail(f"  ✗ Shape mismatch after dequant for '{vname}': {v_f32.shape} vs {b_f32.shape}.")
+                out.write((v_f32.astype(np.float32) - b_f32.astype(np.float32)).astype("float16").tobytes())
             out.write(b"\x01")
             out.flush()
             try:
@@ -3446,13 +3561,15 @@ def _compute_delta(voice_path, base_path, delta_folder, delta_name, args=None):
         tmp_out.replace(out_path)
         return out_path
     # Original chunked safetensors-safetensors path below (no dequant beyond F32 math per chunk).
-    # filter marker for tensor selection (marker is not a real tensor)
+    # Match by exact name: every voice tensor needs a same-named base tensor.
     v_keys = [k for k in v_tensors.keys() if k != "delta.voice.marker"]
-    b_keys = [k for k in b_tensors.keys() if k != "delta.voice.marker"]
-    vname = v_keys[0] if v_keys else list(v_tensors.keys())[0]
-    bname = b_keys[0] if b_keys else list(b_tensors.keys())[0]
-    vinfo, binfo = v_tensors[vname], b_tensors[bname]
-    vshape, bshape = tuple(vinfo["shape"]), tuple(binfo["shape"])
+    if not v_keys:
+        _fail("  ✗ No tensors found for delta.")
+    missing = [k for k in v_keys if k not in b_tensors]
+    if missing:
+        shown = ", ".join(missing[:5]) + ("…" if len(missing) > 5 else "")
+        _fail(f"  ✗ {len(missing)} voice tensor(s) have no match in base: {shown}. Delta needs same names on both sides.")
+    pairs = [(k, k) for k in v_keys]
     # gates for delta-on-delta niche cases (marker indicates delta file)
     is_voice_delta = _is_delta_safetensors(str(voice_path))
     is_base_delta = _is_delta_safetensors(str(base_path))
@@ -3470,21 +3587,33 @@ def _compute_delta(voice_path, base_path, delta_folder, delta_name, args=None):
                            "     The voice and base are both delta-voices.",
                            "     delta − delta = style difference of style differences."],
                     "BIG BRAIN", "delta-on-delta needs explicit confirmation")
-    if vshape != bshape:
-        _fail(f"  ✗ Voice shape {vshape} doesn't fit base {bshape}.")
-    total_elems = 1
-    for d in vshape:
-        total_elems *= int(d)
-
     with open(voice_path, "rb") as f:
         v_hs = struct.unpack("<Q", f.read(8))[0]
     with open(base_path, "rb") as f:
         b_hs = struct.unpack("<Q", f.read(8))[0]
-    v_start = 8 + v_hs + vinfo["data_offsets"][0]
-    b_start = 8 + b_hs + binfo["data_offsets"][0]
-    v_bpe = dtype_bytes(vinfo["dtype"])
-    b_bpe = dtype_bytes(binfo["dtype"])
-
+    specs = []
+    header, off = {}, 0
+    for vname, bname in pairs:
+        vinfo, binfo = v_tensors[vname], b_tensors[bname]
+        vshape, bshape = tuple(vinfo["shape"]), tuple(binfo["shape"])
+        if vshape != bshape:
+            _fail(f"  ✗ Voice tensor '{vname}' shape {vshape} doesn't fit base {bshape}.")
+        elems = 1
+        for d in vshape:
+            elems *= int(d)
+        nbytes = elems * 2
+        header[vname] = {"dtype": "F16", "shape": list(vshape), "data_offsets": [off, off + nbytes]}
+        off += nbytes
+        specs.append({"name": vname, "vinfo": vinfo, "binfo": binfo,
+                      "v_start": 8 + v_hs + vinfo["data_offsets"][0],
+                      "b_start": 8 + b_hs + binfo["data_offsets"][0],
+                      "v_bpe": dtype_bytes(vinfo["dtype"]), "b_bpe": dtype_bytes(binfo["dtype"]),
+                      "elems": elems})
+    total_elems = off // 2
+    marker_name = "delta.voice.marker"
+    header[marker_name] = {"dtype": "U8", "shape": [1], "data_offsets": [off, off + 1]}
+    header["__metadata__"] = {"type": "delta", "base": _public_source(str(base_path)), "voice": _public_source(str(voice_path))}
+    hj = json.dumps(header).encode("utf-8")
     _assert_not_symlink(delta_folder)
     delta_folder.mkdir(parents=True, exist_ok=True)
     try:
@@ -3493,14 +3622,6 @@ def _compute_delta(voice_path, base_path, delta_folder, delta_name, args=None):
         pass
     out_path = delta_folder / "voice.safetensors"
     tmp_out = delta_folder / "voice.safetensors.tmp"
-    marker_name = "delta.voice.marker"
-    header = {
-        vname: {"dtype": "F16", "shape": list(vshape), "data_offsets": [0, total_elems * 2]},
-        marker_name: {"dtype": "U8", "shape": [1], "data_offsets": [total_elems * 2, total_elems * 2 + 1]},
-        "__metadata__": {"type": "delta", "base": _public_source(str(base_path)), "voice": _public_source(str(voice_path))},
-    }
-    hj = json.dumps(header).encode("utf-8")
-
     chunk = 1 << 20
     total_bytes = total_elems * 2
     t0 = time.time()
@@ -3521,23 +3642,28 @@ def _compute_delta(voice_path, base_path, delta_folder, delta_name, args=None):
     with open(voice_path, "rb") as fv, open(base_path, "rb") as fb, open(tmp_out, "wb") as out:
         out.write(struct.pack("<Q", len(hj)))
         out.write(hj)
-        fv.seek(v_start)
-        fb.seek(b_start)
         processed = 0
         _delta_progress(force=True)
-        while processed < total_elems:
-            cur = min(chunk, total_elems - processed)
-            v_raw = fv.read(cur * v_bpe)
-            b_raw = fb.read(cur * b_bpe)
-            if len(v_raw) != cur * v_bpe or len(b_raw) != cur * b_bpe:
-                sys.stdout.write("\n")
-                _fail("  ✗ Short read during delta compute.")
-            v_f32 = decode_to_f32(v_raw, vinfo["dtype"], (cur,))
-            b_f32 = decode_to_f32(b_raw, binfo["dtype"], (cur,))
-            delta_f16 = (v_f32 - b_f32).astype("float16")
-            out.write(delta_f16.tobytes())
-            processed += cur
-            _delta_progress()
+        for spec in specs:
+            fv.seek(spec["v_start"])
+            fb.seek(spec["b_start"])
+            vinfo, binfo = spec["vinfo"], spec["binfo"]
+            v_bpe, b_bpe = spec["v_bpe"], spec["b_bpe"]
+            done = 0
+            while done < spec["elems"]:
+                cur = min(chunk, spec["elems"] - done)
+                v_raw = fv.read(cur * v_bpe)
+                b_raw = fb.read(cur * b_bpe)
+                if len(v_raw) != cur * v_bpe or len(b_raw) != cur * b_bpe:
+                    sys.stdout.write("\n")
+                    _fail(f"  ✗ Short read during delta compute ({spec['name']}).")
+                v_f32 = decode_to_f32(v_raw, vinfo["dtype"], (cur,))
+                b_f32 = decode_to_f32(b_raw, binfo["dtype"], (cur,))
+                delta_f16 = (v_f32 - b_f32).astype("float16")
+                out.write(delta_f16.tobytes())
+                done += cur
+                processed += cur
+                _delta_progress()
         _delta_progress(force=True)
         sys.stdout.write("\n")
         # marker byte for auto-detect (delta.voice.marker)
@@ -3782,6 +3908,33 @@ def _verify_voice_file(path, meta):
     except Exception:
         return ["  ? Could not read the artifact header; showing voice.json as-is."]
     names = [k for k in tens if k != "delta.voice.marker"]
+    claims = meta.get("tensors")
+    if isinstance(claims, list) and claims:
+        for entry in claims:
+            tname = entry.get("name")
+            if tname not in tens:
+                out.append(f"  ! MISMATCH tensor: voice.json lists '{tname}', file doesn't hold it.")
+                continue
+            info = tens[tname]
+            if list(entry.get("shape", [])) != list(info["shape"]):
+                out.append(f"  ! MISMATCH shape '{tname}': voice.json says {list(entry.get('shape', []))}, "
+                           f"file holds {list(info['shape'])} — file wins.")
+            if (entry.get("dtype") or "").upper() != str(info["dtype"]).upper():
+                out.append(f"  ! MISMATCH dtype '{tname}': voice.json says {entry.get('dtype')}, "
+                           f"file holds {info['dtype']} — file wins.")
+        claimed_names = {e.get("name") for e in claims}
+        for extra in names:
+            if extra not in claimed_names:
+                out.append(f"  ! File holds '{extra}' which voice.json doesn't list.")
+        if not names:
+            out.append("  ? No tensors found in the artifact.")
+        has_marker = "delta.voice.marker" in tens
+        if meta.get("type") == "delta" and not has_marker:
+            out.append("  ! voice.json claims delta but the file has no delta marker.")
+        if meta.get("type") != "delta" and has_marker:
+            out.append("  ! File carries a delta marker but voice.json type is "
+                       f"'{meta.get('type', 'voice')}'.")
+        return out
     tname = meta.get("tensor_name")
     if tname not in tens and names:
         tname = names[0]
@@ -3834,6 +3987,9 @@ def cmd_info(args):
     _say(f"  Tensor:  {meta.get('tensor_name', '—')}")
     _say(f"  Shape:   {meta.get('shape', '—')}")
     _say(f"  Dtype:   {meta.get('dtype', '—')}")
+    if isinstance(meta.get("tensors"), list) and len(meta["tensors"]) != 1:
+        for entry in meta["tensors"]:
+            _say(f"    - {entry.get('name')}: {entry.get('shape')} · {entry.get('dtype')}")
     b = meta.get("bytes")
     if isinstance(b, int):
         _say(f"  Bytes:   {b} ({b/1e6:.1f} MB)")