You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pinot.apache.org by xi...@apache.org on 2026/07/05 18:48:02 UTC

(pinot) branch master updated: Consolidate IVF and HNSW vector indexes into segment columns.psf (opt-in via storeInSegmentFile) (#18852)

This is an automated email from the ASF dual-hosted git repository.

xiangfu0 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/pinot.git


The following commit(s) were added to refs/heads/master by this push:
     new f9647dabd44 Consolidate IVF and HNSW vector indexes into segment columns.psf (opt-in via storeInSegmentFile) (#18852)
f9647dabd44 is described below

commit f9647dabd4483f1dc539e08d40e639755ea912b3
Author: RAGHVENDRA KUMAR YADAV <ra...@gmail.com>
AuthorDate: Sun Jul 5 11:47:55 2026 -0700

    Consolidate IVF and HNSW vector indexes into segment columns.psf (opt-in via storeInSegmentFile) (#18852)
    
    * Refactor IVF vector index readers to consume PinotDataBuffer
    
    IVF readers previously took a File indexDir and resolved the sidecar
    themselves. This change converts all three readers (IVF_FLAT, IVF_PQ,
    IVF_ON_DISK) to accept a PinotDataBuffer at construction time so the
    storage tier (local mmap, future tiered storage, future external-table
    sidecar slice) lives entirely behind the buffer.
    
    Highlights:
    - Reader signature: (column, File dir, VectorIndexConfig) ->
      (column, PinotDataBuffer buffer, VectorIndexConfig).
    - IvfPqIndexFormat.read() gains a PinotDataBuffer overload that shares
      parsing with the legacy file path via a private readFromStream.
    - IvfOnDiskVectorIndexReader drops RandomAccessFile + FileChannel in
      favour of positional PinotDataBuffer.getInt/getFloat/getLong/copyTo.
    - New IvfSidecarBuffers helper centralises sidecar resolution,
      BIG_ENDIAN mmap, and a closeQuietly used by all three readers for
      constructor-failure cleanup.
    - VectorIndexType.ReaderFactory routes through IvfSidecarBuffers; HNSW
      unchanged (continues using its Lucene sidecar directory).
    
    On-disk format unchanged. Verified byte-by-byte by a new
    IvfDiskFormatInspectionTest that builds segments via the unchanged
    creators, dumps the raw bytes, and asserts the layout matches the
    documented headers (magic 0x49564646 BE for IVF_FLAT/ON_DISK,
    'IVPQ' + LE version 2 for IVF_PQ).
    
    Resource safety: reader constructors take buffer ownership and close
    on failure via IvfSidecarBuffers.closeQuietly so the mmap doesn't leak
    when the caller never sees a reader. New IvfReaderFailurePathTest
    proves this by tracking PinotDataBuffer.getMmapBufferCount() across
    success and failure paths for all three readers.
    
    Tests: 75 pre-existing IVF tests still pass, plus 3 new disk-format
    inspection tests and 6 new failure-path tests. Broader
    pinot-segment-local suite (4778 tests) also passes.
    
    * Add storeInSegmentFile flag for IVF vector index consolidation
    
    Builds on the previous reader-on-PinotBuffer commit. Adds end-to-end
    consolidation: when a column declares storeInSegmentFile=true in its
    VectorIndexConfig.properties, the IVF payload is absorbed into the
    segment's combined index file (columns.psf) as a typed entry instead
    of remaining as a sibling sidecar file. Mirrors the text-index
    storeInSegmentFile pattern.
    
    Flow:
    
    - Offline segment build still writes the IVF sidecar via the existing
      creator path (no change to the creator).
    - On first server load, VectorIndexHandler detects sidecar + flag-on
      + V3 segment, calls LoaderUtils.writeIndexToV3Format to copy the
      bytes into columns.psf, and deletes the sibling.
    - Subsequent reads go through VectorIndexType.ReaderFactory, which
      branches on the flag: ON reads via segmentReader.getIndexFor(col,
      StandardIndexes.vector()); OFF reads the legacy sidecar mmap.
    - Flag defaults to false; existing segments keep their sidecar
      layout. Active migration of segments built before the flag was
      enabled is deferred to a follow-up.
    
    Changes:
    
    - VectorIndexConfig: STORE_IN_SEGMENT_FILE property key + @JsonIgnore
      isStoreInSegmentFile() accessor. The flag is carried inside the
      properties map; the accessor is intentionally not a JSON property
      so the on-wire shape of VectorIndexConfig is unchanged.
    - VectorIndexType.ReaderFactory: flag-aware dispatch; HNSW unchanged.
    - IvfFlat/IvfPq/IvfOnDiskVectorIndexReader: new (col, buffer, config,
      boolean ownsBuffer) constructor overload. close() releases the
      buffer only when the reader owns it; borrowed buffers (segment
      directory owned in the consolidated path) outlive the reader.
      Constructor-failure cleanup symmetric.
    - VectorIndexHandler: needUpdateIndices detects sidecar+flag mismatch
      on V3 segments. updateIndices absorbs sidecar -> columns.psf
      without rebuilding the index when only the layout changed. The
      freshly-built-index path consolidates when the flag is on. Shared
      absorb helper includes crash-recovery: if a previous absorb run
      committed bytes into columns.psf but died before deleting the
      sidecar, the duplicate-key error is caught and the orphan sidecar
      is cleaned up instead of failing the segment load.
    - SingleFileIndexDirectory: fix three symmetry bugs in the vector
      handling — hasIndexFor, getColumnsWithIndex, and removeIndex now
      treat vector as 'sidecar OR _columnEntries', not just sidecar.
    
    Tests:
    
    - VectorIndexHandlerTest: 4 new tests covering sidecar+flag-on
      trigger, sidecar+flag-off no-op, the absorb path not calling
      removeIndex, and the crash-recovery path that cleans the orphan
      sidecar without re-creating the consolidated entry.
    - IvfReaderFailurePathTest: 4 new tests proving borrowed buffers
      (ownsBuffer=false) are not closed by the reader on success or on
      constructor failure, asserted via
      PinotDataBuffer.getMmapBufferCount().
    - IvfFlatConsolidatedVectorTest: new cluster integration test that
      declares storeInSegmentFile=true, builds a real segment, and runs
      a vectorSimilarity query asserting ordered ANN results — proves
      end-to-end (write -> consolidate -> read -> query) on a live
      cluster.
    
    * Add bidirectional migration for storeInSegmentFile flag toggle
    
    Phase 2 already handled the sidecar -> columns.psf direction (any flag
    OFF -> ON transition triggers absorb at the next load). This commit adds
    the reverse: columns.psf -> sidecar when the flag flips from ON to OFF.
    
    Without this, flipping the flag back to OFF leaves the segment with the
    consolidated entry only. The reader factory (with flag off) tries to
    find a sidecar that doesn't exist, returns null, and the vector index
    becomes silently invisible to queries — a foot-gun for operators rolling
    back the flag.
    
    Detection (VectorIndexHandler.needUpdateIndices):
    
    - Sidecar -> columns.psf: existing sidecar + flag on (already in place;
      comment updated to reflect that it covers both new-build and flag-flip
      cases).
    - columns.psf -> sidecar: existingBackend == null (sidecar absent) AND
      hasIvfSidecar == false AND column reported by getColumnsWithIndex (so
      bytes live inside _columnEntries) AND flag off.
    
    Extraction (VectorIndexHandler.extractConsolidatedIntoSidecar):
    
    1. Read the consolidated buffer via segmentWriter.getIndexFor.
    2. Stream bytes (1 MiB chunks) to a temp file with a non-recognised
       extension (.vector.extract-tmp) so that the subsequent removeIndex's
       sidecar cleanup does not accidentally delete the bytes we just wrote.
    3. Call segmentWriter.removeIndex(col, vector()) to drop the columns.psf
       entry.
    4. Rename the temp file to the final IVF sidecar path. Falls back to
       copy+delete if rename fails (cross-FS in tests).
    
    Tests:
    
    - testNeedUpdateIndicesReturnsTrueWhenConsolidatedExistsButFlagWantsSidecar:
      asserts the handler detects the consolidated+flag-off mismatch.
    - testUpdateIndicesExtractsConsolidatedBytesIntoSidecar: end-to-end
      execution of the extract path. Asserts the sidecar exists, holds the
      exact bytes from the mocked consolidated buffer, removeIndex was called,
      and the temp file was cleaned up.
    
    * Build-time IVF consolidation via V2→V3 converter (text-index pattern)
    
    Builds on the prior commits. Adds a parallel storage path that mirrors
    how text-index lands inside columns.psf at offline-build time, so
    segments built with storeInSegmentFile=true arrive on servers already
    consolidated and don't have to be migrated at first load.
    
    Pattern (same as text):
    
    - IVF creator decides which on-disk file format to write based on the
      flag — legacy single-file sidecar (.vector.ivfflat.index /
      .vector.ivfpq.index) when off, combined-form single file
      (.vector.ivfflat.combined.index / .vector.ivfpq.combined.index) when
      on. Bytes are byte-identical in both forms; only the file name
      differs, and the name acts as the signal for the converter.
    - SegmentV1V2ToV3FormatConverter mirrors its existing text branch for
      vector: if VectorIndexUtils.hasVectorIndex returns true (legacy
      sidecar / HNSW directory present) it skips the standard copy and
      leaves the file as a v3 sibling (copyVectorIndexIfExists handles it).
      If hasVectorIndex returns false but a combined-form file exists,
      v2DataReader.getIndexFor finds it via VectorIndexType.getFileExtensions
      and the standard copyIndexIfExists loop packs the bytes into
      columns.psf as a typed entry.
    - VectorIndexHandler's reload-time absorb/extract paths from the
      previous commit remain in place as a fallback for flag toggles
      without rebuild and for segments built before the flag was added.
    
    Files:
    
    - V1Constants.Indexes: add VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION
      and VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION constants.
    - VectorIndexType.getFileExtensions: include the new combined
      extensions so FilePerIndexDirectory.getFileFor can mmap them.
    - VectorIndexUtils: getIndexFileExtension(backend, combined) overload;
      cleanupVectorIndex also removes combined-form transient files;
      hasVectorIndex stays legacy-only (mirrors text's hasTextIndex which
      only detects the legacy directory form) and is now public so the
      converter can call it.
    - IvfFlatVectorIndexCreator / IvfPqVectorIndexCreator: thread
      storeInSegmentFile from VectorIndexConfig and pick the output
      extension at seal() time.
    - SegmentV1V2ToV3FormatConverter: replace the vector-exclusion at line
      156 with the text-pattern branch (skip standard copy when legacy
      present; pack via standard copy when only combined present).
    - VectorIndexHandler: createVectorIndexForColumn picks the right
      extension via VectorIndexUtils.getIndexFileExtension(backend,
      writeCombined); absorbSidecarIntoColumnsPsf prefers the combined
      file (just-written by the creator) and falls back to legacy;
      hasIvfSidecar detects either form so flag-on migration triggers
      whichever the writer left behind.
    
    Tests:
    
    - IvfDiskFormatInspectionTest: 2 new tests
      (testIvfFlatCreatorWritesCombinedExtensionWhenFlagOn and the IVF_PQ
      analog) lock in that flag-on creators emit the combined extension
      and that the header bytes are byte-identical to the legacy form.
    - 111 pre-existing IVF + handler + SingleFileIndexDirectory tests
      still pass — no behavior regression for the flag-off path.
    
    Total: 113/113 targeted tests green. HNSW consolidation still
    deferred (its consolidation path is a separate refactor that mirrors
    LuceneTextIndexCreator.combineAndCleanupTextIndexFiles).
    
    * Rename Sidecar → Combined for the IVF helper class and methods
    
    User-requested terminology change. The helper class that opens a
    single-file IVF index from disk as a PinotDataBuffer is now
    IvfCombinedBuffers (was IvfSidecarBuffers). Methods renamed to match:
    
    - mapSidecar / mapSidecarFile → mapCombined / mapCombinedFile
    - hasIvfSidecar → hasIvfCombinedFile
    - absorbSidecarIntoColumnsPsf → absorbCombinedIntoColumnsPsf
    - extractConsolidatedIntoSidecar → extractConsolidatedToLegacyFile
      (renamed for accuracy — the method writes back to the legacy
      on-disk extension when the flag flips from on to off)
    
    Comments and string literals were updated case-by-case: identifiers
    referring to the combined-form file format use "combined"; prose
    that previously read "sidecar file" is preserved where it described
    the concept of a single-file index on disk alongside columns.psf.
    
    No functional change. 113/113 targeted tests still pass. Spotless,
    checkstyle, and license check all clean.
    
    * Harden IVF consolidation edges: combined-extension lookup, mixed-state convert, crash-recovery
    
    Cross-cutting fixes after audit of the storeInSegmentFile path. All five address edges
    that only surface on crash, manual edit, or a flag toggle; the happy path is unchanged.
    
    - SegmentDirectoryPaths.findVectorIndexIndexFile now also probes the .combined.index
      extension. Previously a segment built with flag=true that had not yet been absorbed
      into columns.psf was invisible to the reader factory on a flag rollback, so ANN
      queries silently degraded to brute-force scan.
    - V2->V3 converter resolves mixed state (both legacy and combined files present)
      deterministically: combined wins, legacy sibling is dropped. Previously the combined
      bytes were silently lost.
    - VectorIndexHandler.createVectorIndexForColumn now sweeps orphans from the OTHER
      extension before starting. A crash with flag=true followed by a retry with flag=off
      used to leak a partial .combined.index + .inprogress marker that a later flag flip
      could pick up as if it were a complete index. Extracted to a package-private static
      helper for direct unit testing.
    - absorbCombinedIntoColumnsPsf now detects the previously-crashed-absorb state via
      hasIndexFor + size check on the typed entry, instead of string-matching the
      duplicate-key RuntimeException message. Size mismatch now refuses with IOException
      instead of guessing which copy is authoritative.
    - extractConsolidatedToLegacyFile now refuses (IOException) if a sidecar already
      exists for either extension. removeIndex would otherwise destroy it via
      cleanupVectorIndex's side effect.
    
    New tests (12): VectorIndexHandlerTest covers the new crash-recovery hasIndexFor path,
    the size-mismatch refusal, the extract-refusal-when-sidecar-exists path, and the
    orphan sweep in both directions plus an HNSW no-op assertion. VectorIndexUtilsTest
    covers hasVectorIndex excluding the combined form and the new hasCombinedFormVectorIndex
    predicate. SegmentDirectoryPathsTest covers combined-form lookup when only combined
    exists and the legacy-wins rule in mixed state.
    
    118 unit tests + 2 integration tests green. Spotless / checkstyle / license clean.
    
    * Extend storeInSegmentFile consolidation to HNSW vector index
    
    Mirrors the text-index pattern: pack the Lucene HNSW directory into a single
    .vector.hnsw.combined.index file using the same LUCENE_V2 layout, then absorb
    into columns.psf via the V2->V3 converter. At read time the bytes are exposed
    as a Lucene Directory backed by a PinotDataBuffer slice, so KnnVectorsReader
    works against the consolidated entry without re-extracting to disk.
    
    - HnswVectorIndexCombined: packs and (for the extract path) unpacks the Lucene
      HNSW directory using LuceneCombinedTextIndexConstants. Includes the docId
      mapping file when present so the consolidated form is self-contained.
    - HnswVectorIndexBufferReader: parses the combined buffer and returns a
      Directory built on PinotBufferLuceneDirectory + PinotBufferIndexInput
      (reused from the text-index package). Also exposes the mapping bytes via
      extractDocIdMappingBuffer.
    - HnswVectorIndexCreator gains a storeInSegmentFile flag; close() packs the
      Lucene directory into the combined file and deletes the original directory
      when the flag is on.
    - HnswVectorIndexReader gains a PinotDataBuffer-based constructor that opens
      the buffer-backed Directory and builds the DocIdTranslator from the mapping
      bytes embedded in the combined buffer (or rebuilds in heap if absent). The
      buffer-backed reader honours the borrowed-buffer contract IVF readers use
      (close() does not close the buffer).
    - VectorIndexType.ReaderFactory branches on isStoreInSegmentFile for HNSW
      too, mirroring the IVF branch already in place.
    - VectorIndexHandler removes the HNSW short-circuits in needUpdateIndices,
      updateIndices, absorb, extract, and cleanOrphansFromOtherExtension. Absorb
      for HNSW first packs the legacy Lucene directory into a transient combined
      file, then absorbs and deletes it (and the directory). Extract for HNSW
      unpacks the combined entry into a Lucene directory before removeIndex runs.
    
    Tests: HnswVectorIndexCombinedTest covers pack/unpack round-trip plus a real
    HNSW build read via the buffer-backed Directory. VectorIndexHandlerTest adds
    HNSW-side migration and orphan-cleanup tests. VectorIndexUtilsTest and
    SegmentDirectoryPathsTest cover the HNSW combined extension lookup.
    
    125 unit tests green, IvfFlatConsolidatedVectorTest (2 tests) still green.
    Spotless / checkstyle / license clean.
    
    * HNSW extract: unpack before removeIndex; drop dead createdTransient flag
    
    Two pre-PR hardening fixes:
    
    extractHnswConsolidatedToDirectory now unpacks the combined buffer back into a
    Lucene directory BEFORE removing the consolidated entry. The previous order
    left a crash window in which removeIndex succeeded but the unpack threw — the
    typed entry was gone and the Lucene directory did not yet exist, so the
    segment permanently lost its HNSW index until a full rebuild. With the new
    order a crash mid-unpack leaves the typed entry in columns.psf, the next load
    retries the extract, and no data is lost. The new code also best-effort
    cleans up a half-unpacked directory on failure so the retry's defensive
    pre-flight check still fires.
    
    If removeIndex throws AFTER unpack succeeded, the segment ends up with both
    forms on disk. The reader factory's file-backed path (flag=false) uses the
    Lucene directory and ignores the orphan typed entry until a subsequent
    handler run cleans it up — no data loss, no behaviour regression.
    
    Also drops the unused createdTransient local in absorbHnswIntoColumnsPsf
    (set but never read; cleanup of hnswDir is already conditioned on
    hnswDir.exists()).
    
    130 unit tests still green, spotless/checkstyle/license clean.
    
    * Fix spotless import ordering in pinot-perf vector benchmarks
    
    * Address review comments: precise columns.psf typed-entry detection; /// docs
    
    Resolve the SingleFileIndexDirectory.hasIndexFor contract concern from review
    without breaking the generic load path:
    
    - hasIndexFor(col, vector()) stays "legacy sidecar OR typed entry": the generic
      PhysicalColumnIndexContainer load gate relies on it, so a legacy sidecar must
      report true or it would never build a reader. Callers that specifically need
      to know whether the payload is already packed into columns.psf now probe the
      typed entry directly via VectorIndexUtils.getConsolidatedVectorEntry():
      - VectorIndexHandler absorb crash-recovery (IVF + HNSW): a normal first absorb
        of an existing legacy segment no longer mis-detects "already absorbed" and
        throws on getIndexFor().size(). Regression test added.
      - VectorIndexType reader factory: a not-yet-migrated HNSW segment falls back
        to the legacy Lucene directory instead of failing the whole segment load.
    - SegmentV1V2ToV3FormatConverter: pack the combined form into columns.psf only
      when the resolved on-disk artifact is a regular file. A legacy HNSW Lucene
      *directory* (which getIndexFor resolves before the combined file) is deferred
      to the sibling copy to avoid a directory-as-buffer mapping failure, while a
      legacy IVF *file* still packs so the index is never lost in a mixed state.
    - HnswVectorIndexCombined: open the combined output with TRUNCATE_EXISTING.
    - VectorIndexConfig: document that storeInSegmentFile covers IVF and HNSW.
    
    Convert the touched/new vector-index Javadoc to /// markdown doc comments.
    
    * Fix consolidated-HNSW docId mapping byte order
    
    extractDocIdMappingBuffer returned a view that inherited the big-endian order of
    the enclosing columns.psf buffer, but the docId mapping is packed verbatim from
    the little-endian file-backed sidecar that DocIdTranslator writes/reads. getInt()
    therefore byte-swapped every Lucene->Pinot doc id for consolidated HNSW segments
    whenever the mapping was packed, corrupting ANN result translation and pre-filter
    matching. Force a LITTLE_ENDIAN view. Adds a regression test that packs a known
    mapping and reads it back through a big-endian columns.psf-style buffer.
    
    * Address re-review nits: doc/comment and redundant-cleanup cleanups
    
    - VectorIndexType: drop {@code} tags from a // line comment (they only render in Javadoc)
    - HnswVectorIndexReader: drop redundant self-qualified DocIdTranslator reference
    - VectorIndexHandler: remove no-op deleteQuietly(combinedFile) in the HNSW absorb path
      (writeIndexToV3Format already force-deletes the source) and note the IVF/HNSW asymmetry
    
    * Add HNSW storeInSegmentFile end-to-end integration test
    
    Sibling of IvfFlatConsolidatedVectorTest for the HNSW backend, which had no
    coverage on the consolidated read path. Exercises the buffer-backed
    HnswVectorIndexReader (Lucene directory rebuilt from the packed columns.psf
    entry) and the little-endian docId mapping consumed by DocIdTranslator, asserting
    a vectorSimilarity ANN query returns L2-ascending top-K candidates.
    
    * Address PR review comments on vector storeInSegmentFile consolidation
    
    - HNSW extract (columns.psf -> Lucene directory): unpack into a temp
      directory and move it into place AFTER removeIndex, so the
      cleanupVectorIndex sibling sweep run by removeIndex can no longer delete
      the freshly-unpacked legacy .vector.v912.hnsw.index directory.
    - IVF reader factory: fall back to the on-disk sidecar when
      storeInSegmentFile=true but no consolidated columns.psf entry exists yet
      (mirrors the HNSW fallback) instead of returning null and forcing an
      exact scan; derive buffer ownership from the buffer source rather than
      the config flag, fixing a latent sidecar mmap leak.
    - HnswVectorIndexCombined.extractHnswIndexFiles: throw on a zero-progress
      transferTo instead of spinning forever on a corrupt/truncated file.
    - getConsolidatedVectorEntry: map only the shared "index not found" signal
      to null and rethrow any other RuntimeException so corruption is not
      masked as "absent". Hoist the message prefix into a single shared
      constant in SingleFileIndexDirectory, referenced by FilePerIndexDirectory
      and VectorIndexUtils so the produce/match sides cannot drift.
    - HnswVectorIndexReader buffer-backed ctor: log the throwable, not just
      its message.
    - Tests: HNSW extract directory-preservation, truncated-combined-file
      guard, IVF sidecar fallback, getConsolidatedVectorEntry null/rethrow,
      and the cleanupVectorIndex temp-name invariant.
    
    * Vector index utils: payload backend sniffing and consolidated-probe hardening
    
    - sniffVectorPayloadBackend / detectConsolidatedVectorBackend classify a
      consolidated columns.psf payload by its leading magic bytes (LUCENE_V2 /
      IVFF / IVPQ), so backend drift can be detected for columns whose payload
      no longer has an on-disk sidecar.
    - storageFormatOf normalizes IVF_ON_DISK to IVF_FLAT: the two backends
      share one file format (only the reader differs), so drift comparisons
      must compare storage formats or a healthy IVF_ON_DISK column would
      report perpetual drift and be destroyed and rebuilt on every load.
    - getConsolidatedVectorEntry now maps FilePerIndexDirectory's
      "not a regular file" IllegalArgumentException (a still-present legacy
      Lucene DIRECTORY resolved as the vector artifact on V1/V2 segments) to
      "no consolidated entry" instead of failing the caller's segment load;
      the message suffix is a shared constant so producer and matcher cannot
      drift. Contract Javadoc rewritten to state the per-store behavior
      honestly (V1/V2 may return an IVF sidecar's bytes; callers gate on
      version or on-disk artifacts).
    
    * Detect vector backend drift for consolidated-only columns
    
    A column whose vector payload lives solely in columns.psf has no sidecar
    for detectVectorIndexBackend to see, so existingBackend == null and a
    config backend flip slipped past the drift check: the extract path would
    stream the OLD backend's bytes out under the NEW backend's extension
    (e.g. HNSW pack bytes as .vector.ivfpq.index) and the next load parsed
    them with the wrong reader.
    
    needUpdateIndices and updateIndices now share getDriftedConsolidatedBackend,
    which sniffs the typed entry's magic (V3 only) and reports a rebuild when
    the payload's storage format differs from the configured backend's. All
    four drift comparisons (sidecar and consolidated, check and act) compare
    via storageFormatOf so a valid IVF_ON_DISK column (whose payload sniffs
    as the shared IVF_FLAT format) is not flagged as drifted and rebuilt on
    every segment load.
    
    * Read legacy HNSW directory without probing columns.psf when it exists
    
    With storeInSegmentFile=true, the HNSW reader factory probed the
    consolidated columns.psf entry first. On a V1/V2 segment backed by
    FilePerIndexDirectory, getIndexFor resolves the still-present legacy
    Lucene DIRECTORY and mapForReads rejects it (not a regular file), killing
    the segment load before the legacy fallback could run — making the flag
    non-rolling-upgrade-safe for existing HNSW segments.
    
    The factory now checks the on-disk artifact first: if it is a Lucene
    directory (unmigrated V3, or any V1/V2 segment), read it directly and
    skip the probe entirely. The fallback warn now describes the actual
    state (neither form found) instead of promising a directory read that
    cannot succeed. Tests cover both the V1 root layout and the v3/
    subdirectory layout, asserting the probe never runs.
    
    ---------
    
    Co-authored-by: Xiang Fu <xi...@gmail.com>
---
 .../tests/custom/HnswConsolidatedVectorTest.java   | 187 +++++
 .../custom/IvfFlatConsolidatedVectorTest.java      | 185 +++++
 .../perf/BenchmarkVectorFeatureWorkloads.java      |   7 +-
 .../pinot/perf/BenchmarkVectorFilterWorkloads.java |  17 +-
 .../apache/pinot/perf/BenchmarkVectorIndex.java    |   7 +-
 .../impl/vector/HnswVectorIndexCreator.java        |  23 +
 .../vector/lucene99/HnswVectorIndexCombined.java   | 354 ++++++++++
 .../converter/SegmentV1V2ToV3FormatConverter.java  |  52 +-
 .../loader/invertedindex/VectorIndexHandler.java   | 482 ++++++++++++-
 .../vector/HnswVectorIndexBufferReader.java        | 119 ++++
 .../readers/vector/HnswVectorIndexReader.java      | 104 ++-
 .../readers/vector/IvfFlatVectorIndexReader.java   |  72 +-
 .../readers/vector/IvfOnDiskVectorIndexReader.java | 218 +++---
 .../readers/vector/IvfPqVectorIndexReader.java     |  62 +-
 .../segment/index/vector/IvfCombinedBuffers.java   | 116 ++++
 .../index/vector/IvfFlatVectorIndexCreator.java    |  18 +-
 .../segment/index/vector/IvfPqIndexFormat.java     |  65 +-
 .../index/vector/IvfPqVectorIndexCreator.java      |  28 +-
 .../segment/index/vector/VectorIndexType.java      | 134 +++-
 .../local/segment/store/FilePerIndexDirectory.java |  15 +-
 .../segment/store/SingleFileIndexDirectory.java    |  25 +-
 .../local/segment/store/VectorIndexUtils.java      | 175 ++++-
 .../lucene99/HnswVectorIndexCombinedTest.java      | 268 ++++++++
 .../invertedindex/VectorIndexHandlerTest.java      | 764 +++++++++++++++++++++
 .../readers/vector/IvfFlatFilterAwareTest.java     |  22 +-
 .../readers/vector/IvfOnDiskFilterAwareTest.java   |  21 +-
 .../index/vector/IvfDiskFormatInspectionTest.java  | 400 +++++++++++
 .../index/vector/IvfFlatVectorIndexTest.java       |  54 +-
 .../segment/index/vector/IvfPqVectorIndexTest.java |  60 +-
 .../index/vector/IvfReaderFailurePathTest.java     | 410 +++++++++++
 .../segment/index/vector/VectorIndexTypeTest.java  | 199 ++++++
 .../index/vector/VectorSearchBenchmark.java        |   3 +-
 .../segment/store/SegmentDirectoryPathsTest.java   |  97 +++
 .../local/segment/store/VectorIndexUtilsTest.java  | 199 ++++++
 .../org/apache/pinot/segment/spi/V1Constants.java  |  18 +
 .../spi/index/creator/VectorIndexConfig.java       |  88 ++-
 .../segment/spi/store/SegmentDirectoryPaths.java   |  45 +-
 37 files changed, 4736 insertions(+), 377 deletions(-)

diff --git a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/custom/HnswConsolidatedVectorTest.java b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/custom/HnswConsolidatedVectorTest.java
new file mode 100644
index 00000000000..f89e030db12
--- /dev/null
+++ b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/custom/HnswConsolidatedVectorTest.java
@@ -0,0 +1,187 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.integration.tests.custom;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import org.apache.avro.file.DataFileWriter;
+import org.apache.avro.generic.GenericData;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.pinot.spi.config.table.FieldConfig;
+import org.apache.pinot.spi.config.table.TableConfig;
+import org.apache.pinot.spi.config.table.TableType;
+import org.apache.pinot.spi.data.FieldSpec;
+import org.apache.pinot.spi.data.Schema;
+import org.apache.pinot.spi.utils.builder.TableConfigBuilder;
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertTrue;
+
+
+/**
+ * End-to-end integration test for HNSW with {@code storeInSegmentFile=true}.
+ *
+ * <p>Sibling of {@link IvfFlatConsolidatedVectorTest} for the HNSW backend. The first server load
+ * packs the offline-built Lucene HNSW directory into a combined file and absorbs it into {@code
+ * columns.psf}; subsequent queries read the typed entry directly via the buffer-backed
+ * {@code HnswVectorIndexReader} (including the little-endian docId mapping consumed by
+ * {@code DocIdTranslator}). The single test method asserts that a {@code vectorSimilarity} query
+ * returns sensible top-K ANN candidates — i.e. the consolidated HNSW read path executes and the
+ * Lucene-to-Pinot doc id translation is not byte-swapped.</p>
+ */
+@Test(suiteName = "CustomClusterIntegrationTest")
+public class HnswConsolidatedVectorTest extends CustomDataQueryClusterIntegrationTest {
+
+  private static final String DEFAULT_TABLE_NAME = "HnswConsolidatedVectorTest";
+  private static final String VECTOR_COL = "embedding";
+  private static final String CATEGORY = "category";
+  private static final int VECTOR_DIM_SIZE = 32;
+  private static final int NUM_CATEGORIES = 3;
+
+  @Override
+  protected long getCountStarResult() {
+    return 200;
+  }
+
+  @Override
+  public String getTableName() {
+    return DEFAULT_TABLE_NAME;
+  }
+
+  @Override
+  public TableConfig createOfflineTableConfig() {
+    return new TableConfigBuilder(TableType.OFFLINE)
+        .setTableName(getTableName())
+        .setFieldConfigList(List.of(
+            new FieldConfig.Builder(VECTOR_COL)
+                .withIndexTypes(List.of(FieldConfig.IndexType.VECTOR))
+                .withEncodingType(FieldConfig.EncodingType.RAW)
+                .withProperties(Map.of(
+                    "vectorIndexType", "HNSW",
+                    "vectorDimension", String.valueOf(VECTOR_DIM_SIZE),
+                    "vectorDistanceFunction", "EUCLIDEAN",
+                    "version", "1",
+                    // Consolidation: the Lucene HNSW directory is packed into a combined file and
+                    // moved into columns.psf as a typed entry after the offline build, instead of
+                    // remaining as a sibling directory.
+                    "storeInSegmentFile", "true"))
+                .build()
+        ))
+        .build();
+  }
+
+  @Override
+  public Schema createSchema() {
+    return new Schema.SchemaBuilder().setSchemaName(getTableName())
+        .addMultiValueDimension(VECTOR_COL, FieldSpec.DataType.FLOAT)
+        .addSingleValueDimension(CATEGORY, FieldSpec.DataType.STRING)
+        .build();
+  }
+
+  @Override
+  public List<File> createAvroFiles()
+      throws Exception {
+    org.apache.avro.Schema avroSchema = org.apache.avro.Schema.createRecord("myRecord", null, null, false);
+    org.apache.avro.Schema floatArraySchema =
+        org.apache.avro.Schema.createArray(org.apache.avro.Schema.create(org.apache.avro.Schema.Type.FLOAT));
+    avroSchema.setFields(List.of(
+        new org.apache.avro.Schema.Field(VECTOR_COL, floatArraySchema, null, null),
+        new org.apache.avro.Schema.Field(CATEGORY,
+            org.apache.avro.Schema.create(org.apache.avro.Schema.Type.STRING), null, null)
+    ));
+
+    try (AvroFilesAndWriters avroFilesAndWriters = createAvroFilesAndWriters(avroSchema)) {
+      List<DataFileWriter<GenericData.Record>> writers = avroFilesAndWriters.getWriters();
+      for (int i = 0; i < getCountStarResult(); i++) {
+        GenericData.Record record = new GenericData.Record(avroSchema);
+        float[] vector = createRandomVector(VECTOR_DIM_SIZE);
+        record.put(VECTOR_COL, convertToFloatCollection(vector));
+        record.put(CATEGORY, "cat_" + (i % NUM_CATEGORIES));
+        writers.get(i % getNumAvroFiles()).append(record);
+      }
+      return avroFilesAndWriters.getAvroFiles();
+    }
+  }
+
+  /**
+   * End-to-end: writes a segment with {@code storeInSegmentFile=true}, loads it onto a server,
+   * and runs an ANN query. Passes iff (a) the server can load the segment without error (proves
+   * the consolidated HNSW reader path resolves the typed entry from {@code columns.psf} and
+   * rebuilds the Lucene directory + docId mapping from the packed buffer), and (b) the query
+   * returns rows ordered by L2 distance ascending (proves the Lucene-to-Pinot doc id translation
+   * is read little-endian rather than byte-swapped by the big-endian columns.psf view).
+   */
+  @Test(dataProvider = "useBothQueryEngines")
+  public void testConsolidatedHnswVectorSimilarity(boolean useMultiStageQueryEngine)
+      throws Exception {
+    setUseMultiStageQueryEngine(useMultiStageQueryEngine);
+    int topK = 5;
+    String queryVector = "ARRAY[1.1" + StringUtils.repeat(", 1.1", VECTOR_DIM_SIZE - 1) + "]";
+
+    String annQuery = String.format(
+        "SELECT l2Distance(%s, %s) AS dist FROM %s "
+            + "WHERE vectorSimilarity(%s, %s, %d) "
+            + "ORDER BY dist ASC LIMIT %d",
+        VECTOR_COL, queryVector, getTableName(),
+        VECTOR_COL, queryVector, topK * 10, topK);
+
+    JsonNode annResult = postQuery(annQuery);
+    assertNotNull(annResult.get("resultTable"),
+        "Consolidated HNSW ANN query must return a resultTable; got: " + annResult);
+
+    JsonNode rows = annResult.get("resultTable").get("rows");
+    assertTrue(rows.size() > 0, "Consolidated HNSW ANN query should return at least 1 row");
+
+    // Distances must be monotonically non-decreasing — proves the consolidated reader returned
+    // valid scored candidates with correct doc id translation rather than scrambled bytes.
+    double prevDist = -1;
+    for (int i = 0; i < rows.size(); i++) {
+      double dist = rows.get(i).get(0).asDouble();
+      assertTrue(dist >= 0, "L2 distance must be non-negative (row " + i + " = " + dist + ")");
+      assertTrue(dist >= prevDist,
+          "Rows must be ordered ascending by L2 distance; row " + i + " = " + dist
+              + " < prev = " + prevDist);
+      prevDist = dist;
+    }
+  }
+
+  private static final Random RANDOM = new Random(42L);
+
+  private float[] createRandomVector(int vectorDimSize) {
+    float[] vector = new float[vectorDimSize];
+    for (int i = 0; i < vectorDimSize; i++) {
+      vector[i] = RANDOM.nextFloat();
+    }
+    return vector;
+  }
+
+  private Collection<Float> convertToFloatCollection(float[] vector) {
+    Collection<Float> vectorCollection = new ArrayList<>();
+    for (float v : vector) {
+      vectorCollection.add(v);
+    }
+    return vectorCollection;
+  }
+}
diff --git a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/custom/IvfFlatConsolidatedVectorTest.java b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/custom/IvfFlatConsolidatedVectorTest.java
new file mode 100644
index 00000000000..15aaf561f85
--- /dev/null
+++ b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/custom/IvfFlatConsolidatedVectorTest.java
@@ -0,0 +1,185 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.integration.tests.custom;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import org.apache.avro.file.DataFileWriter;
+import org.apache.avro.generic.GenericData;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.pinot.spi.config.table.FieldConfig;
+import org.apache.pinot.spi.config.table.TableConfig;
+import org.apache.pinot.spi.config.table.TableType;
+import org.apache.pinot.spi.data.FieldSpec;
+import org.apache.pinot.spi.data.Schema;
+import org.apache.pinot.spi.utils.builder.TableConfigBuilder;
+import org.testng.annotations.Test;
+
+import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertTrue;
+
+
+/**
+ * End-to-end integration test for IVF_FLAT with {@code storeInSegmentFile=true}.
+ *
+ * <p>Mirrors the table-config layout in {@link IvfFlatVectorTest} but with the consolidation
+ * flag turned on. The first server load absorbs the offline-built combined into {@code
+ * columns.psf}; subsequent queries read the typed entry directly from the segment's combined
+ * index file. The single test method asserts that a {@code vectorSimilarity} query returns
+ * sensible top-K ANN candidates — i.e. the consolidated read path actually executes.</p>
+ */
+@Test(suiteName = "CustomClusterIntegrationTest")
+public class IvfFlatConsolidatedVectorTest extends CustomDataQueryClusterIntegrationTest {
+
+  private static final String DEFAULT_TABLE_NAME = "IvfFlatConsolidatedVectorTest";
+  private static final String VECTOR_COL = "embedding";
+  private static final String CATEGORY = "category";
+  private static final int VECTOR_DIM_SIZE = 32;
+  private static final int NLIST = 4;
+  private static final int NUM_CATEGORIES = 3;
+
+  @Override
+  protected long getCountStarResult() {
+    return 200;
+  }
+
+  @Override
+  public String getTableName() {
+    return DEFAULT_TABLE_NAME;
+  }
+
+  @Override
+  public TableConfig createOfflineTableConfig() {
+    return new TableConfigBuilder(TableType.OFFLINE)
+        .setTableName(getTableName())
+        .setFieldConfigList(List.of(
+            new FieldConfig.Builder(VECTOR_COL)
+                .withIndexTypes(List.of(FieldConfig.IndexType.VECTOR))
+                .withEncodingType(FieldConfig.EncodingType.RAW)
+                .withProperties(Map.of(
+                    "vectorIndexType", "IVF_FLAT",
+                    "vectorDimension", String.valueOf(VECTOR_DIM_SIZE),
+                    "vectorDistanceFunction", "EUCLIDEAN",
+                    "nlist", String.valueOf(NLIST),
+                    "version", "1",
+                    // Consolidation: the IVF payload is moved into columns.psf as a typed entry
+                    // after the offline build, instead of remaining as a sibling combined file.
+                    "storeInSegmentFile", "true"))
+                .build()
+        ))
+        .build();
+  }
+
+  @Override
+  public Schema createSchema() {
+    return new Schema.SchemaBuilder().setSchemaName(getTableName())
+        .addMultiValueDimension(VECTOR_COL, FieldSpec.DataType.FLOAT)
+        .addSingleValueDimension(CATEGORY, FieldSpec.DataType.STRING)
+        .build();
+  }
+
+  @Override
+  public List<File> createAvroFiles()
+      throws Exception {
+    org.apache.avro.Schema avroSchema = org.apache.avro.Schema.createRecord("myRecord", null, null, false);
+    org.apache.avro.Schema floatArraySchema =
+        org.apache.avro.Schema.createArray(org.apache.avro.Schema.create(org.apache.avro.Schema.Type.FLOAT));
+    avroSchema.setFields(List.of(
+        new org.apache.avro.Schema.Field(VECTOR_COL, floatArraySchema, null, null),
+        new org.apache.avro.Schema.Field(CATEGORY,
+            org.apache.avro.Schema.create(org.apache.avro.Schema.Type.STRING), null, null)
+    ));
+
+    try (AvroFilesAndWriters avroFilesAndWriters = createAvroFilesAndWriters(avroSchema)) {
+      List<DataFileWriter<GenericData.Record>> writers = avroFilesAndWriters.getWriters();
+      for (int i = 0; i < getCountStarResult(); i++) {
+        GenericData.Record record = new GenericData.Record(avroSchema);
+        float[] vector = createRandomVector(VECTOR_DIM_SIZE);
+        record.put(VECTOR_COL, convertToFloatCollection(vector));
+        record.put(CATEGORY, "cat_" + (i % NUM_CATEGORIES));
+        writers.get(i % getNumAvroFiles()).append(record);
+      }
+      return avroFilesAndWriters.getAvroFiles();
+    }
+  }
+
+  /**
+   * End-to-end: writes a segment with {@code storeInSegmentFile=true}, loads it onto a server,
+   * and runs an ANN query. Passes iff (a) the server can load the segment without error (proves
+   * the consolidated reader path resolves and reads the typed entry from {@code columns.psf}),
+   * and (b) the query returns rows ordered by L2 distance ascending (proves the consolidated
+   * IVF payload is interpreted correctly).
+   */
+  @Test(dataProvider = "useBothQueryEngines")
+  public void testConsolidatedIvfFlatVectorSimilarity(boolean useMultiStageQueryEngine)
+      throws Exception {
+    setUseMultiStageQueryEngine(useMultiStageQueryEngine);
+    int topK = 5;
+    String queryVector = "ARRAY[1.1" + StringUtils.repeat(", 1.1", VECTOR_DIM_SIZE - 1) + "]";
+
+    String annQuery = String.format(
+        "SELECT l2Distance(%s, %s) AS dist FROM %s "
+            + "WHERE vectorSimilarity(%s, %s, %d) "
+            + "ORDER BY dist ASC LIMIT %d",
+        VECTOR_COL, queryVector, getTableName(),
+        VECTOR_COL, queryVector, topK * 10, topK);
+
+    JsonNode annResult = postQuery(annQuery);
+    assertNotNull(annResult.get("resultTable"),
+        "Consolidated IVF_FLAT ANN query must return a resultTable; got: " + annResult);
+
+    JsonNode rows = annResult.get("resultTable").get("rows");
+    assertTrue(rows.size() > 0, "Consolidated IVF_FLAT ANN query should return at least 1 row");
+
+    // Distances must be monotonically non-decreasing — proves the consolidated reader returned
+    // valid scored candidates rather than scrambled bytes.
+    double prevDist = -1;
+    for (int i = 0; i < rows.size(); i++) {
+      double dist = rows.get(i).get(0).asDouble();
+      assertTrue(dist >= 0, "L2 distance must be non-negative (row " + i + " = " + dist + ")");
+      assertTrue(dist >= prevDist,
+          "Rows must be ordered ascending by L2 distance; row " + i + " = " + dist
+              + " < prev = " + prevDist);
+      prevDist = dist;
+    }
+  }
+
+  private static final Random RANDOM = new Random(42L);
+
+  private float[] createRandomVector(int vectorDimSize) {
+    float[] vector = new float[vectorDimSize];
+    for (int i = 0; i < vectorDimSize; i++) {
+      vector[i] = RANDOM.nextFloat();
+    }
+    return vector;
+  }
+
+  private Collection<Float> convertToFloatCollection(float[] vector) {
+    Collection<Float> vectorCollection = new ArrayList<>();
+    for (float v : vector) {
+      vectorCollection.add(v);
+    }
+    return vectorCollection;
+  }
+}
diff --git a/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkVectorFeatureWorkloads.java b/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkVectorFeatureWorkloads.java
index ef54b641fd5..2096f0f2ab3 100644
--- a/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkVectorFeatureWorkloads.java
+++ b/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkVectorFeatureWorkloads.java
@@ -34,6 +34,7 @@ import org.apache.pinot.segment.local.realtime.impl.vector.MutableVectorIndex;
 import org.apache.pinot.segment.local.segment.index.readers.vector.HnswVectorIndexReader;
 import org.apache.pinot.segment.local.segment.index.readers.vector.IvfFlatVectorIndexReader;
 import org.apache.pinot.segment.local.segment.index.readers.vector.IvfPqVectorIndexReader;
+import org.apache.pinot.segment.local.segment.index.vector.IvfCombinedBuffers;
 import org.apache.pinot.segment.local.segment.index.vector.IvfFlatVectorIndexCreator;
 import org.apache.pinot.segment.local.segment.index.vector.IvfPqVectorIndexCreator;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
@@ -124,7 +125,8 @@ public final class BenchmarkVectorFeatureWorkloads {
         BenchmarkVectorIndex.BuildMetrics buildMetrics =
             BenchmarkVectorIndex.measureBuild(corpus.length, () -> buildIvfFlatIndex(indexDir, corpus, config));
         long sizeBytes = BenchmarkVectorIndex.ivfIndexSize(indexDir);
-        try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, indexDir, config)) {
+        try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+            IvfCombinedBuffers.mapCombined(indexDir, COLUMN_NAME, config, "bench-vector"), config)) {
           reader.setNprobe(NPROBE);
           long[] latencies = measureLatencies(queries, query -> reader.getDocIds(query, TOP_K));
           double recall10 = measureRecall(truth, queries, query -> BenchmarkVectorIndex.bitmapToSet(reader.getDocIds(
@@ -145,7 +147,8 @@ public final class BenchmarkVectorFeatureWorkloads {
         BenchmarkVectorIndex.BuildMetrics buildMetrics =
             BenchmarkVectorIndex.measureBuild(corpus.length, () -> buildIvfPqIndex(indexDir, corpus, config));
         long sizeBytes = FileUtils.sizeOfDirectory(indexDir);
-        try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, indexDir, config)) {
+        try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+            IvfCombinedBuffers.mapCombined(indexDir, COLUMN_NAME, config, "bench-vector"), config)) {
           reader.setNprobe(NPROBE);
           long[] latencies = measureLatencies(queries, query -> reader.getDocIds(query, TOP_K));
           double recall10 = measureRecall(truth, queries, query -> BenchmarkVectorIndex.bitmapToSet(reader.getDocIds(
diff --git a/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkVectorFilterWorkloads.java b/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkVectorFilterWorkloads.java
index 2a757b284d3..48d482760dd 100644
--- a/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkVectorFilterWorkloads.java
+++ b/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkVectorFilterWorkloads.java
@@ -29,6 +29,7 @@ import java.util.Set;
 import org.apache.commons.io.FileUtils;
 import org.apache.pinot.segment.local.segment.index.readers.vector.IvfFlatVectorIndexReader;
 import org.apache.pinot.segment.local.segment.index.readers.vector.IvfOnDiskVectorIndexReader;
+import org.apache.pinot.segment.local.segment.index.vector.IvfCombinedBuffers;
 import org.apache.pinot.segment.local.segment.index.vector.IvfFlatVectorIndexCreator;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
 import org.apache.pinot.segment.spi.index.creator.VectorQuantizerType;
@@ -141,10 +142,12 @@ public final class BenchmarkVectorFilterWorkloads {
           createIvfConfig("IVF_FLAT", DIMENSION, NLIST, distanceFunction, FILTER_QUANTIZER);
       buildIvfFlatIndex(indexDir, corpus, creatorConfig);
 
-      try (IvfFlatVectorIndexReader ivfFlatReader = new IvfFlatVectorIndexReader(COLUMN_NAME, indexDir, creatorConfig);
-          IvfOnDiskVectorIndexReader ivfOnDiskReader =
-              new IvfOnDiskVectorIndexReader(COLUMN_NAME, indexDir,
-                  createIvfConfig("IVF_ON_DISK", DIMENSION, NLIST, distanceFunction, FILTER_QUANTIZER))) {
+      VectorIndexConfig onDiskConfig =
+          createIvfConfig("IVF_ON_DISK", DIMENSION, NLIST, distanceFunction, FILTER_QUANTIZER);
+      try (IvfFlatVectorIndexReader ivfFlatReader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+          IvfCombinedBuffers.mapCombined(indexDir, COLUMN_NAME, creatorConfig, "bench-vector"), creatorConfig);
+          IvfOnDiskVectorIndexReader ivfOnDiskReader = new IvfOnDiskVectorIndexReader(COLUMN_NAME,
+              IvfCombinedBuffers.mapCombined(indexDir, COLUMN_NAME, onDiskConfig, "bench-vector"), onDiskConfig)) {
         ivfFlatReader.setNprobe(NPROBE);
         ivfOnDiskReader.setNprobe(NPROBE);
 
@@ -299,7 +302,8 @@ public final class BenchmarkVectorFilterWorkloads {
           createIvfConfig("IVF_FLAT", DIMENSION, NLIST, distanceFunction, FILTER_QUANTIZER);
       buildIvfFlatIndex(indexDir, corpus, creatorConfig);
       if ("IVF_FLAT".equals(backend)) {
-        try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, indexDir, creatorConfig)) {
+        try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+            IvfCombinedBuffers.mapCombined(indexDir, COLUMN_NAME, creatorConfig, "bench-vector"), creatorConfig)) {
           reader.setNprobe(NPROBE);
           printRadiusResults(out, backend, distanceFunction, corpus, queries,
               (query, ignoredThreshold) -> reader.getDocIds(query, RADIUS_MAX_CANDIDATES),
@@ -308,7 +312,8 @@ public final class BenchmarkVectorFilterWorkloads {
       } else {
         VectorIndexConfig readerConfig =
             createIvfConfig("IVF_ON_DISK", DIMENSION, NLIST, distanceFunction, FILTER_QUANTIZER);
-        try (IvfOnDiskVectorIndexReader reader = new IvfOnDiskVectorIndexReader(COLUMN_NAME, indexDir, readerConfig)) {
+        try (IvfOnDiskVectorIndexReader reader = new IvfOnDiskVectorIndexReader(COLUMN_NAME,
+            IvfCombinedBuffers.mapCombined(indexDir, COLUMN_NAME, readerConfig, "bench-vector"), readerConfig)) {
           reader.setNprobe(NPROBE);
           printRadiusResults(out, backend, distanceFunction, corpus, queries,
               (query, ignoredThreshold) -> reader.getDocIds(query, RADIUS_MAX_CANDIDATES),
diff --git a/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkVectorIndex.java b/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkVectorIndex.java
index 422942d786a..b5461cce233 100644
--- a/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkVectorIndex.java
+++ b/pinot-perf/src/main/java/org/apache/pinot/perf/BenchmarkVectorIndex.java
@@ -39,6 +39,7 @@ import org.apache.pinot.common.function.scalar.VectorFunctions;
 import org.apache.pinot.segment.local.segment.creator.impl.vector.HnswVectorIndexCreator;
 import org.apache.pinot.segment.local.segment.index.readers.vector.HnswVectorIndexReader;
 import org.apache.pinot.segment.local.segment.index.readers.vector.IvfFlatVectorIndexReader;
+import org.apache.pinot.segment.local.segment.index.vector.IvfCombinedBuffers;
 import org.apache.pinot.segment.local.segment.index.vector.IvfFlatVectorIndexCreator;
 import org.apache.pinot.segment.spi.V1Constants;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
@@ -253,7 +254,8 @@ public class BenchmarkVectorIndex {
   static IvfFlatVectorIndexReader openIvfReader(File indexDir, int dimension, int nlist, int nprobe,
       VectorIndexConfig.VectorDistanceFunction distFunc) {
     VectorIndexConfig config = createIvfConfig(dimension, nlist, distFunc);
-    IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, indexDir, config);
+    IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(indexDir, COLUMN_NAME, config, "bench-vector"), config);
     reader.setNprobe(nprobe);
     return reader;
   }
@@ -765,7 +767,8 @@ public class BenchmarkVectorIndex {
             if (nprobe > nlist) {
               continue;
             }
-            try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, ivfDir, config)) {
+            try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+                IvfCombinedBuffers.mapCombined(ivfDir, COLUMN_NAME, config, "bench-vector"), config)) {
               reader.setNprobe(nprobe);
 
               double recall10 = 0;
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/creator/impl/vector/HnswVectorIndexCreator.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/creator/impl/vector/HnswVectorIndexCreator.java
index b4926fb478b..9c34995060e 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/creator/impl/vector/HnswVectorIndexCreator.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/creator/impl/vector/HnswVectorIndexCreator.java
@@ -21,6 +21,7 @@ package org.apache.pinot.segment.local.segment.creator.impl.vector;
 import java.io.File;
 import java.io.IOException;
 import javax.annotation.Nullable;
+import org.apache.commons.io.FileUtils;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.StoredField;
 import org.apache.lucene.index.IndexWriter;
@@ -28,6 +29,7 @@ import org.apache.lucene.index.VectorSimilarityFunction;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.FSDirectory;
 import org.apache.pinot.segment.local.segment.creator.impl.SegmentColumnarIndexCreator;
+import org.apache.pinot.segment.local.segment.creator.impl.vector.lucene99.HnswVectorIndexCombined;
 import org.apache.pinot.segment.local.segment.store.VectorIndexUtils;
 import org.apache.pinot.segment.spi.V1Constants;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
@@ -50,6 +52,10 @@ public class HnswVectorIndexCreator implements VectorIndexCreator {
   private final String _vectorColumn;
   private final VectorSimilarityFunction _vectorSimilarityFunction;
   private final int _vectorDimension;
+  // When true, close() packs the Lucene directory into a single combined file and removes the dir.
+  private final boolean _storeInSegmentFile;
+  private final File _segmentIndexDir;
+  private final File _hnswIndexDir;
 
   private int _nextDocId = 0;
 
@@ -57,11 +63,14 @@ public class HnswVectorIndexCreator implements VectorIndexCreator {
     _vectorColumn = column;
     _vectorDimension = vectorIndexConfig.getVectorDimension();
     _vectorSimilarityFunction = VectorIndexUtils.toSimilarityFunction(vectorIndexConfig.getVectorDistanceFunction());
+    _storeInSegmentFile = vectorIndexConfig.isStoreInSegmentFile();
+    _segmentIndexDir = segmentIndexDir;
     try {
       // segment generation is always in V1 and later we convert (as part of post creation processing)
       // to V3 if segmentVersion is set to V3 in SegmentGeneratorConfig.
       File indexFile = new File(segmentIndexDir, _vectorColumn
           + V1Constants.Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION);
+      _hnswIndexDir = indexFile;
       _indexDirectory = FSDirectory.open(indexFile.toPath());
       LOGGER.info("Creating HNSW index for column: {} at path: {} with {} for segment: {}", column,
           indexFile.getAbsolutePath(), vectorIndexConfig.getProperties(), segmentIndexDir.getAbsolutePath());
@@ -116,5 +125,19 @@ public class HnswVectorIndexCreator implements VectorIndexCreator {
     } catch (Exception e) {
       throw new RuntimeException("Caught exception while closing the HNSW index for column: " + _vectorColumn, e);
     }
+    if (_storeInSegmentFile) {
+      // Pack the Lucene directory into a single combined file so the V2→V3 converter can absorb it
+      // into columns.psf as a typed entry (same pattern as LuceneTextIndexCreator).
+      String combinedPath = new File(_segmentIndexDir,
+          _vectorColumn + V1Constants.Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION).getAbsolutePath();
+      try {
+        HnswVectorIndexCombined.combineHnswIndexFiles(_hnswIndexDir, combinedPath, _segmentIndexDir, _vectorColumn);
+        FileUtils.deleteDirectory(_hnswIndexDir);
+        LOGGER.info("Packed HNSW index for column {} into combined file and removed Lucene directory", _vectorColumn);
+      } catch (IOException e) {
+        LOGGER.error("Failed to combine HNSW index for column: {}", _vectorColumn, e);
+        throw e;
+      }
+    }
   }
 }
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/creator/impl/vector/lucene99/HnswVectorIndexCombined.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/creator/impl/vector/lucene99/HnswVectorIndexCombined.java
new file mode 100644
index 00000000000..e7e807fbad9
--- /dev/null
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/creator/impl/vector/lucene99/HnswVectorIndexCombined.java
@@ -0,0 +1,354 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.segment.local.segment.creator.impl.vector.lucene99;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.FileChannel;
+import java.nio.file.StandardOpenOption;
+import java.util.Map;
+import java.util.TreeMap;
+import javax.annotation.Nullable;
+import org.apache.commons.io.FileUtils;
+import org.apache.pinot.segment.local.segment.creator.impl.text.LuceneCombinedTextIndexConstants;
+import org.apache.pinot.segment.spi.V1Constants;
+import org.apache.pinot.segment.spi.store.SegmentDirectoryPaths;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+/// Utility class to pack a Lucene HNSW index directory (and its optional docId mapping file) into
+/// a single combined file using the {@link LuceneCombinedTextIndexConstants#MAGIC_NUMBER LUCENE_V2}
+/// layout. Mirrors {@code LuceneTextIndexCombined} — reuses the same format constants to keep a
+/// single on-disk format shared across text and HNSW vector indexes.
+///
+/// Layout (identical to the text-index LUCENE_V2 format):
+/// ```
+/// [Header]
+///   Magic "LUCENE_V2"   9 bytes
+///   Version             4 bytes (little-endian int)
+///   Total buffer size   8 bytes (little-endian long)
+///   File count          4 bytes (little-endian int)
+///   Reserved            4 bytes
+///
+/// [File metadata, one entry per file]
+///   Name length         2 bytes (little-endian short)
+///   Name                variable
+///   File offset         8 bytes (little-endian long)
+///   File size           8 bytes (little-endian long)
+///
+/// [File data]
+///   Raw bytes of each file concatenated in metadata order
+/// ```
+public final class HnswVectorIndexCombined {
+  private static final Logger LOGGER = LoggerFactory.getLogger(HnswVectorIndexCombined.class);
+
+  private HnswVectorIndexCombined() {
+  }
+
+  /// Packs all files in {@code hnswIndexDir} (plus the optional docId mapping file) into a single
+  /// combined file at {@code outputFilePath}.
+  ///
+  /// @param hnswIndexDir     the Lucene HNSW index directory to pack
+  /// @param outputFilePath   destination path for the combined file
+  /// @param segmentIndexDir  when non-null, the segment's top-level index directory; used to
+  ///                         locate the docId mapping file for inclusion in the packed output
+  /// @param column           column name; used to locate the docId mapping file when
+  ///                         {@code segmentIndexDir} is provided
+  /// @throws IOException if any file operations fail
+  public static void combineHnswIndexFiles(File hnswIndexDir, String outputFilePath,
+      @Nullable File segmentIndexDir, @Nullable String column)
+      throws IOException {
+    if (!hnswIndexDir.exists() || !hnswIndexDir.isDirectory()) {
+      throw new IllegalArgumentException(
+          "HNSW index directory does not exist or is not a directory: " + hnswIndexDir);
+    }
+
+    LOGGER.info("Combining HNSW index files from directory: {}", hnswIndexDir.getAbsolutePath());
+
+    Map<String, FileInfo> fileInfoMap = collectFiles(hnswIndexDir, segmentIndexDir, column);
+    int fileCount = fileInfoMap.size();
+
+    if (fileCount == 0) {
+      throw new IOException("No files found in HNSW index directory: " + hnswIndexDir);
+    }
+
+    long totalSize = calculateTotalBufferSize(fileInfoMap);
+    if (totalSize > Integer.MAX_VALUE) {
+      throw new IOException("Combined HNSW index size too large: " + totalSize + " bytes");
+    }
+
+    File outputFile = new File(outputFilePath);
+    // TRUNCATE_EXISTING so a leftover (larger) file from a previously-crashed pack does not leave
+    // stale trailing bytes past the new payload — that would inflate the file length and break the
+    // size-based crash-recovery check in VectorIndexHandler that compares the combined file length
+    // to the columns.psf typed-entry size.
+    try (FileChannel outputChannel = FileChannel.open(outputFile.toPath(), StandardOpenOption.CREATE,
+        StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING)) {
+      writeHeader(outputChannel, fileCount, (int) totalSize);
+      long dataOffset = LuceneCombinedTextIndexConstants.getHeaderSize() + calculateMetadataSize(fileInfoMap);
+      writeFileMetadata(outputChannel, fileInfoMap, dataOffset);
+      writeFileData(outputChannel, fileInfoMap);
+    }
+
+    LOGGER.info("Combined {} HNSW index files into: {} ({} bytes)", fileCount, outputFilePath, totalSize);
+  }
+
+  /// Collects all regular files from {@code hnswIndexDir} and optionally the docId mapping file
+  /// from the segment's flat directory. Uses a {@link TreeMap} for deterministic ordering.
+  private static Map<String, FileInfo> collectFiles(File hnswIndexDir, @Nullable File segmentIndexDir,
+      @Nullable String column)
+      throws IOException {
+    Map<String, FileInfo> fileInfoMap = new TreeMap<>();
+
+    File[] files = hnswIndexDir.listFiles();
+    if (files != null) {
+      for (File file : files) {
+        if (file.isFile()) {
+          fileInfoMap.put(file.getName(), new FileInfo(file, file.getName(), file.length()));
+        }
+      }
+    }
+
+    // Include the docId mapping file when available. It lives beside the HNSW directory, not
+    // inside it (same convention as text-index).
+    if (segmentIndexDir != null && column != null) {
+      File segmentDir = SegmentDirectoryPaths.findSegmentDirectory(segmentIndexDir);
+      File mappingFile = new File(segmentDir,
+          column + V1Constants.Indexes.VECTOR_HNSW_INDEX_DOCID_MAPPING_FILE_EXTENSION);
+      if (mappingFile.exists() && mappingFile.isFile()) {
+        fileInfoMap.put(mappingFile.getName(), new FileInfo(mappingFile, mappingFile.getName(), mappingFile.length()));
+        LOGGER.info("Including docId mapping file: {} ({} bytes)", mappingFile.getName(), mappingFile.length());
+      }
+    }
+
+    return fileInfoMap;
+  }
+
+  /// Extracts files packed inside a combined HNSW file back into a Lucene directory.
+  ///
+  /// This is the inverse of {@link #combineHnswIndexFiles}. The docId mapping file (if present)
+  /// is extracted into {@code targetDir} alongside the Lucene index files; the caller is
+  /// responsible for moving it to its canonical location if needed.
+  ///
+  /// @param combinedFile source combined file (LUCENE_V2 layout)
+  /// @param targetDir    destination directory; created if absent
+  /// @throws IOException if any file operations fail
+  public static void extractHnswIndexFiles(File combinedFile, File targetDir)
+      throws IOException {
+    if (!combinedFile.exists() || !combinedFile.isFile()) {
+      throw new IllegalArgumentException("Combined file does not exist or is not a file: " + combinedFile);
+    }
+    FileUtils.forceMkdir(targetDir);
+
+    try (FileChannel inputChannel = FileChannel.open(combinedFile.toPath(), StandardOpenOption.READ)) {
+      // Parse header
+      byte[] magicBytes = new byte[LuceneCombinedTextIndexConstants.MAGIC_NUMBER_LENGTH];
+      readFully(inputChannel, ByteBuffer.wrap(magicBytes));
+      String magic = new String(magicBytes);
+      if (!LuceneCombinedTextIndexConstants.MAGIC_NUMBER.equals(magic)) {
+        throw new IOException("Invalid magic number in combined HNSW file: " + magic);
+      }
+
+      ByteBuffer intBuf = ByteBuffer.allocate(Integer.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+      readFully(inputChannel, intBuf);
+      intBuf.flip();
+      int version = intBuf.getInt();
+      if (version != LuceneCombinedTextIndexConstants.VERSION) {
+        throw new IOException("Unsupported version in combined HNSW file: " + version);
+      }
+
+      // Skip total size (8 bytes) and file count (4 bytes) header fields
+      ByteBuffer longBuf = ByteBuffer.allocate(Long.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+      readFully(inputChannel, longBuf); // totalSize
+      longBuf.flip();
+      // (unused, but we advance the channel position past it)
+
+      intBuf = ByteBuffer.allocate(Integer.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+      readFully(inputChannel, intBuf);
+      intBuf.flip();
+      int fileCount = intBuf.getInt();
+
+      // Skip reserved field
+      intBuf = ByteBuffer.allocate(Integer.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+      readFully(inputChannel, intBuf);
+
+      // Parse file metadata
+      String[] fileNames = new String[fileCount];
+      long[] fileOffsets = new long[fileCount];
+      long[] fileSizes = new long[fileCount];
+      for (int i = 0; i < fileCount; i++) {
+        ByteBuffer shortBuf = ByteBuffer.allocate(Short.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+        readFully(inputChannel, shortBuf);
+        shortBuf.flip();
+        short nameLength = shortBuf.getShort();
+
+        byte[] nameBytes = new byte[nameLength];
+        readFully(inputChannel, ByteBuffer.wrap(nameBytes));
+        fileNames[i] = new String(nameBytes);
+
+        longBuf = ByteBuffer.allocate(Long.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+        readFully(inputChannel, longBuf);
+        longBuf.flip();
+        fileOffsets[i] = longBuf.getLong();
+
+        longBuf = ByteBuffer.allocate(Long.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+        readFully(inputChannel, longBuf);
+        longBuf.flip();
+        fileSizes[i] = longBuf.getLong();
+      }
+
+      // Extract each file by seeking to its offset and copying bytes
+      for (int i = 0; i < fileCount; i++) {
+        File outFile = new File(targetDir, fileNames[i]);
+        long fileSize = fileSizes[i];
+        try (FileChannel outChannel = FileChannel.open(outFile.toPath(), StandardOpenOption.CREATE,
+            StandardOpenOption.WRITE)) {
+          long remaining = fileSize;
+          long srcOffset = fileOffsets[i];
+          while (remaining > 0) {
+            long transferred = inputChannel.transferTo(srcOffset, remaining, outChannel);
+            if (transferred <= 0) {
+              // transferTo returns 0 when srcOffset is at/after EOF (corrupt offsets/sizes in the
+              // header). Bail out instead of spinning forever on a malformed combined file.
+              throw new IOException("Truncated or corrupt combined HNSW file: expected " + fileSize
+                  + " bytes for " + fileNames[i] + " at offset " + fileOffsets[i] + " but " + remaining
+                  + " bytes remain unreadable in " + combinedFile);
+            }
+            srcOffset += transferred;
+            remaining -= transferred;
+          }
+        }
+        LOGGER.debug("Extracted {} ({} bytes) from combined HNSW file", fileNames[i], fileSize);
+      }
+    }
+    LOGGER.info("Extracted {} files from combined HNSW file: {} into: {}", targetDir.listFiles() == null ? 0
+        : targetDir.listFiles().length, combinedFile.getAbsolutePath(), targetDir.getAbsolutePath());
+  }
+
+  // ---- header / metadata write helpers ----
+
+  private static void writeHeader(FileChannel outputChannel, int fileCount, int totalSize)
+      throws IOException {
+    outputChannel.write(ByteBuffer.wrap(LuceneCombinedTextIndexConstants.MAGIC_NUMBER.getBytes()));
+
+    ByteBuffer versionBuf = ByteBuffer.allocate(Integer.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+    versionBuf.putInt(LuceneCombinedTextIndexConstants.VERSION);
+    versionBuf.flip();
+    outputChannel.write(versionBuf);
+
+    ByteBuffer totalSizeBuf = ByteBuffer.allocate(Long.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+    totalSizeBuf.putLong(totalSize);
+    totalSizeBuf.flip();
+    outputChannel.write(totalSizeBuf);
+
+    ByteBuffer fileCountBuf = ByteBuffer.allocate(Integer.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+    fileCountBuf.putInt(fileCount);
+    fileCountBuf.flip();
+    outputChannel.write(fileCountBuf);
+
+    // Reserved field — zero for now
+    ByteBuffer reservedBuf = ByteBuffer.allocate(Integer.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+    reservedBuf.putInt(0);
+    reservedBuf.flip();
+    outputChannel.write(reservedBuf);
+  }
+
+  private static void writeFileMetadata(FileChannel outputChannel, Map<String, FileInfo> fileInfoMap, long dataOffset)
+      throws IOException {
+    for (FileInfo fileInfo : fileInfoMap.values()) {
+      ByteBuffer nameLengthBuf = ByteBuffer.allocate(Short.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+      nameLengthBuf.putShort((short) fileInfo._name.length());
+      nameLengthBuf.flip();
+      outputChannel.write(nameLengthBuf);
+
+      outputChannel.write(ByteBuffer.wrap(fileInfo._name.getBytes()));
+
+      ByteBuffer fileOffsetBuf = ByteBuffer.allocate(Long.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+      fileOffsetBuf.putLong(dataOffset);
+      fileOffsetBuf.flip();
+      outputChannel.write(fileOffsetBuf);
+
+      ByteBuffer fileSizeBuf = ByteBuffer.allocate(Long.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+      fileSizeBuf.putLong(fileInfo._size);
+      fileSizeBuf.flip();
+      outputChannel.write(fileSizeBuf);
+
+      dataOffset += fileInfo._size;
+    }
+  }
+
+  private static void writeFileData(FileChannel outputChannel, Map<String, FileInfo> fileInfoMap)
+      throws IOException {
+    for (FileInfo fileInfo : fileInfoMap.values()) {
+      try (FileChannel sourceChannel = FileChannel.open(fileInfo._file.toPath(), StandardOpenOption.READ)) {
+        long transferred = 0;
+        long fileSize = fileInfo._size;
+        while (transferred < fileSize) {
+          transferred += sourceChannel.transferTo(transferred, fileSize - transferred, outputChannel);
+        }
+        LOGGER.debug("Wrote {} ({} bytes) into combined HNSW file", fileInfo._name, fileSize);
+      } catch (IOException e) {
+        throw new IOException("Failed to read file: " + fileInfo._file.getAbsolutePath(), e);
+      }
+    }
+  }
+
+  private static long calculateTotalBufferSize(Map<String, FileInfo> fileInfoMap) {
+    long total = LuceneCombinedTextIndexConstants.getHeaderSize();
+    total += calculateMetadataSize(fileInfoMap);
+    for (FileInfo fi : fileInfoMap.values()) {
+      total += fi._size;
+    }
+    return total;
+  }
+
+  private static long calculateMetadataSize(Map<String, FileInfo> fileInfoMap) {
+    long size = 0;
+    for (FileInfo fi : fileInfoMap.values()) {
+      size += LuceneCombinedTextIndexConstants.getFileMetadataEntrySizeWithFilename(fi._name);
+    }
+    return size;
+  }
+
+  /// Reads a buffer fully from the channel, throwing if EOF is reached prematurely.
+  private static void readFully(FileChannel channel, ByteBuffer buf)
+      throws IOException {
+    while (buf.hasRemaining()) {
+      int n = channel.read(buf);
+      if (n < 0) {
+        throw new IOException("Unexpected end-of-file in combined HNSW index");
+      }
+    }
+  }
+
+  private static final class FileInfo {
+    final File _file;
+    final String _name;
+    final long _size;
+
+    FileInfo(File file, String name, long size) {
+      _file = file;
+      _name = name;
+      _size = size;
+    }
+  }
+}
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/converter/SegmentV1V2ToV3FormatConverter.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/converter/SegmentV1V2ToV3FormatConverter.java
index 597f7d947e0..af86b2f5116 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/converter/SegmentV1V2ToV3FormatConverter.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/converter/SegmentV1V2ToV3FormatConverter.java
@@ -30,6 +30,7 @@ import org.apache.commons.configuration2.PropertiesConfiguration;
 import org.apache.commons.configuration2.ex.ConfigurationException;
 import org.apache.commons.io.FileUtils;
 import org.apache.pinot.segment.local.segment.store.TextIndexUtils;
+import org.apache.pinot.segment.local.segment.store.VectorIndexUtils;
 import org.apache.pinot.segment.spi.V1Constants;
 import org.apache.pinot.segment.spi.converter.SegmentFormatConverter;
 import org.apache.pinot.segment.spi.creator.SegmentVersion;
@@ -147,16 +148,39 @@ public class SegmentV1V2ToV3FormatConverter implements SegmentFormatConverter {
           SegmentDirectory.Writer v3DataWriter = v3Segment.createWriter()) {
         for (String column : v2Metadata.getAllColumns()) {
           for (IndexType<?, ?, ?> indexType : IndexService.getInstance().getAllIndexes()) {
-            //If Text index files are combined merge into columns.psf else no-op
+            // Text index: skip the standard copy when a legacy Lucene directory is present
+            // ({@code copyLuceneTextIndexIfExists} below handles that as a sibling copy).
+            // Combined .text.index files fall through to the standard path and get packed.
             if (indexType == StandardIndexes.text()) {
               if (!TextIndexUtils.hasTextIndex(v2Directory, column)) {
                 copyIndexIfExists(v2DataReader, v3DataWriter, column, indexType);
               }
-            } else {
-              if (indexType != StandardIndexes.vector()) {
+              continue;
+            }
+            // Vector index mirrors text: skip the standard copy when a legacy IVF sidecar (or
+            // HNSW directory) is present ({@code copyVectorIndexIfExists} handles those as
+            // sibling copies). Combined .vector.ivfflat.combined.index / .ivfpq.combined.index
+            // files fall through to the standard path and get packed into columns.psf.
+            // Mixed state: if both legacy and combined exist (e.g. operator toggled the flag
+            // and rebuilt without cleaning the old file), combined normally wins — pack it and let
+            // copyVectorIndexIfExists drop the legacy sibling so the operator gets exactly one
+            // copy of the bytes in the V3 segment. The one exception is a legacy HNSW Lucene
+            // *directory*: getIndexFor() resolves to it before the combined file (see
+            // findHnswVectorIndexFile), and a directory cannot be mapped as a columns.psf buffer.
+            // For that case we defer entirely to the sibling copy (which preserves the Lucene
+            // directory); the transient combined file is dropped and re-absorbed later by
+            // VectorIndexHandler if storeInSegmentFile stays on. IVF legacy+combined still packs
+            // because the legacy sidecar is a regular file sharing the same on-disk format.
+            if (indexType == StandardIndexes.vector()) {
+              boolean hasCombined = VectorIndexUtils.hasCombinedFormVectorIndex(v2Directory, column);
+              File resolved = SegmentDirectoryPaths.findVectorIndexIndexFile(v2Directory, column);
+              boolean resolvesToDirectory = resolved != null && resolved.isDirectory();
+              if ((hasCombined && !resolvesToDirectory) || !VectorIndexUtils.hasVectorIndex(v2Directory, column)) {
                 copyIndexIfExists(v2DataReader, v3DataWriter, column, indexType);
               }
+              continue;
             }
+            copyIndexIfExists(v2DataReader, v3DataWriter, column, indexType);
           }
         }
         v3DataWriter.save();
@@ -275,19 +299,35 @@ public class SegmentV1V2ToV3FormatConverter implements SegmentFormatConverter {
       }
     }
 
-    // Copy IVF_FLAT index files (single flat files, not directories)
+    // Copy IVF_FLAT index files (single flat files, not directories). Skip legacy sidecars whose
+    // matching combined-form file also exists — the combined file was already packed into
+    // columns.psf by the main loop, and copying the legacy sibling would leave two copies.
     String ivfFlatSuffix = V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION;
-    File[] ivfFlatIndexFiles = segmentDirectory.listFiles((dir, name) -> name.endsWith(ivfFlatSuffix));
+    String ivfFlatCombinedSuffix = V1Constants.Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION;
+    File[] ivfFlatIndexFiles = segmentDirectory.listFiles(
+        (dir, name) -> name.endsWith(ivfFlatSuffix) && !name.endsWith(ivfFlatCombinedSuffix));
     if (ivfFlatIndexFiles != null) {
       for (File ivfFlatFile : ivfFlatIndexFiles) {
+        String column = ivfFlatFile.getName().substring(0,
+            ivfFlatFile.getName().length() - ivfFlatSuffix.length());
+        if (new File(segmentDirectory, column + ivfFlatCombinedSuffix).exists()) {
+          continue;
+        }
         Files.copy(ivfFlatFile.toPath(), new File(v3Dir, ivfFlatFile.getName()).toPath());
       }
     }
 
     String ivfPqSuffix = V1Constants.Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION;
-    File[] ivfPqIndexFiles = segmentDirectory.listFiles((dir, name) -> name.endsWith(ivfPqSuffix));
+    String ivfPqCombinedSuffix = V1Constants.Indexes.VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION;
+    File[] ivfPqIndexFiles = segmentDirectory.listFiles(
+        (dir, name) -> name.endsWith(ivfPqSuffix) && !name.endsWith(ivfPqCombinedSuffix));
     if (ivfPqIndexFiles != null) {
       for (File ivfPqFile : ivfPqIndexFiles) {
+        String column = ivfPqFile.getName().substring(0,
+            ivfPqFile.getName().length() - ivfPqSuffix.length());
+        if (new File(segmentDirectory, column + ivfPqCombinedSuffix).exists()) {
+          continue;
+        }
         Files.copy(ivfPqFile.toPath(), new File(v3Dir, ivfPqFile.getName()).toPath());
       }
     }
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/loader/invertedindex/VectorIndexHandler.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/loader/invertedindex/VectorIndexHandler.java
index 7da94d5cecb..64b036c08d5 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/loader/invertedindex/VectorIndexHandler.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/loader/invertedindex/VectorIndexHandler.java
@@ -18,16 +18,23 @@
  */
 package org.apache.pinot.segment.local.segment.index.loader.invertedindex;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
 import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
+import javax.annotation.Nullable;
 import org.apache.commons.io.FileUtils;
+import org.apache.pinot.segment.local.segment.creator.impl.vector.lucene99.HnswVectorIndexCombined;
 import org.apache.pinot.segment.local.segment.index.loader.BaseIndexHandler;
+import org.apache.pinot.segment.local.segment.index.loader.LoaderUtils;
 import org.apache.pinot.segment.local.segment.store.VectorIndexUtils;
 import org.apache.pinot.segment.spi.ColumnMetadata;
 import org.apache.pinot.segment.spi.creator.IndexCreationContext;
+import org.apache.pinot.segment.spi.creator.SegmentVersion;
 import org.apache.pinot.segment.spi.index.FieldIndexConfigs;
 import org.apache.pinot.segment.spi.index.FieldIndexConfigsUtil;
 import org.apache.pinot.segment.spi.index.IndexReaderFactory;
@@ -38,6 +45,7 @@ import org.apache.pinot.segment.spi.index.creator.VectorIndexCreator;
 import org.apache.pinot.segment.spi.index.reader.Dictionary;
 import org.apache.pinot.segment.spi.index.reader.ForwardIndexReader;
 import org.apache.pinot.segment.spi.index.reader.ForwardIndexReaderContext;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
 import org.apache.pinot.segment.spi.store.SegmentDirectory;
 import org.apache.pinot.segment.spi.store.SegmentDirectoryPaths;
 import org.apache.pinot.spi.config.table.TableConfig;
@@ -59,7 +67,8 @@ public class VectorIndexHandler extends BaseIndexHandler {
   }
 
   @Override
-  public boolean needUpdateIndices(SegmentDirectory.Reader segmentReader) {
+  public boolean needUpdateIndices(SegmentDirectory.Reader segmentReader)
+      throws Exception {
     String segmentName = _segmentDirectory.getSegmentMetadata().getName();
     Set<String> columnsToAddIdx = new HashSet<>(_vectorConfigs.keySet());
     Set<String> existingColumns = segmentReader.toSegmentDirectory().getColumnsWithIndex(StandardIndexes.vector());
@@ -73,11 +82,48 @@ public class VectorIndexHandler extends BaseIndexHandler {
       VectorIndexConfig desiredConfig = _vectorConfigs.get(column);
       VectorBackendType desiredBackend = desiredConfig.resolveBackendType();
       VectorBackendType existingBackend = VectorIndexUtils.detectVectorIndexBackend(indexDir, column);
-      if (existingBackend != null && existingBackend != desiredBackend) {
+      // Both detectVectorIndexBackend and the consolidated sniff report the STORAGE format
+      // (IVF_ON_DISK payloads/files register as IVF_FLAT), so compare against the desired
+      // backend's storage format — a raw enum comparison would flag a valid IVF_ON_DISK column
+      // as drifted on every load and rebuild it forever.
+      if (existingBackend != null && existingBackend != VectorIndexUtils.storageFormatOf(desiredBackend)) {
         LOGGER.info("Need to rebuild Vector index for segment: {}, column: {} (backend changed from {} to {})",
             segmentName, column, existingBackend, desiredBackend);
         return true;
       }
+      VectorBackendType driftedConsolidatedBackend =
+          getDriftedConsolidatedBackend(segmentReader, column, existingBackend, desiredBackend);
+      if (driftedConsolidatedBackend != null) {
+        LOGGER.info("Need to rebuild Vector index for segment: {}, column: {} "
+            + "(consolidated backend changed from {} to {})", segmentName, column, driftedConsolidatedBackend,
+            desiredBackend);
+        return true;
+      }
+      // Migration: sidecar -> columns.psf. Fires either when the offline writer just wrote a
+      // sidecar (build with flag on) or when the operator just flipped the flag from off to on
+      // for an existing legacy segment. Same handler step covers both.
+      // For HNSW the "sidecar" is the combined packed file (.vector.hnsw.combined.index);
+      // for IVF it is the legacy combined extension.
+      if (desiredConfig.isStoreInSegmentFile()
+          && _segmentDirectory.getSegmentMetadata().getVersion() == SegmentVersion.v3
+          && existingBackend != null
+          && hasCombinedFile(indexDir, column, desiredBackend)) {
+        LOGGER.info("Need to consolidate Vector sidecar file into columns.psf for segment: {}, column: {}",
+            segmentName, column);
+        return true;
+      }
+      // Migration: columns.psf -> sidecar. Fires when the operator flipped the flag from on to
+      // off for a segment whose vector payload was previously absorbed. We detect this from the
+      // SegmentDirectory: the column has a vector index ({@code existingColumns} contains it via
+      // {@code SingleFileIndexDirectory._columnEntries}) but no sidecar file is on disk.
+      if (!desiredConfig.isStoreInSegmentFile()
+          && _segmentDirectory.getSegmentMetadata().getVersion() == SegmentVersion.v3
+          && existingBackend == null
+          && !hasCombinedFile(indexDir, column, desiredBackend)) {
+        LOGGER.info("Need to extract Vector consolidated entry to sidecar file for segment: {}, column: {}",
+            segmentName, column);
+        return true;
+      }
     }
     // Check if any new index need to be added.
     for (String column : columnsToAddIdx) {
@@ -90,6 +136,347 @@ public class VectorIndexHandler extends BaseIndexHandler {
     return false;
   }
 
+  /// Returns the consolidated payload's backend when it drifts from the desired backend's storage
+  /// format, or {@code null} when the column has an on-disk sidecar (the sidecar drift check owns
+  /// that case), the segment is not V3 (consolidated entries only exist in {@code columns.psf}),
+  /// there is no consolidated entry, the payload magic is unknown, or the formats match.
+  ///
+  /// Shared by {@code needUpdateIndices} and {@code updateIndices} so the check-and-act pair cannot
+  /// drift apart. Comparison is by storage format ({@link VectorIndexUtils#storageFormatOf}):
+  /// {@code IVF_ON_DISK} payloads sniff as {@code IVF_FLAT} because they share the file format, and
+  /// a raw enum comparison would flag a healthy IVF_ON_DISK column as drifted on every load,
+  /// rebuilding it forever.
+  @Nullable
+  private VectorBackendType getDriftedConsolidatedBackend(SegmentDirectory.Reader reader, String column,
+      @Nullable VectorBackendType existingBackend, VectorBackendType desiredBackend)
+      throws IOException {
+    if (existingBackend != null || _segmentDirectory.getSegmentMetadata().getVersion() != SegmentVersion.v3) {
+      return null;
+    }
+    VectorBackendType consolidatedBackend = VectorIndexUtils.detectConsolidatedVectorBackend(reader, column);
+    if (consolidatedBackend != null && consolidatedBackend != VectorIndexUtils.storageFormatOf(desiredBackend)) {
+      return consolidatedBackend;
+    }
+    return null;
+  }
+
+  /// Absorbs a vector index sidecar into {@code columns.psf} as a typed entry, then deletes the
+  /// sibling. For IVF backends the bytes are copied verbatim; the on-disk IVF header is the
+  /// contract and the reader handles version dispatch. For HNSW, if a combined-form file already
+  /// exists (written by a creator run with the flag on), it is absorbed directly; if only the
+  /// Lucene directory remains (operator just flipped the flag on an existing segment), it is first
+  /// packed into a transient combined file, which is then absorbed and removed.
+  ///
+  /// **Crash recovery:** if a prior absorb crashed between {@code newIndexFor} (which committed
+  /// bytes into {@code columns.psf} and added a {@code _columnEntries} entry) and the sidecar file
+  /// deletion, the next load will see both forms. We detect that state upfront via the columns.psf
+  /// typed entry ({@link VectorIndexUtils#getConsolidatedVectorEntry}), NOT via {@code hasIndexFor}
+  /// — which for vector also reports the on-disk sidecar and would therefore flag a normal
+  /// first-absorb as already-absorbed. We then verify the typed entry's size matches the sidecar's
+  /// length (so we do not delete a sidecar that happens to coexist with an unrelated typed entry),
+  /// and clean up the orphan sidecar instead of re-running the absorb.
+  private void absorbCombinedIntoColumnsPsf(SegmentDirectory.Writer segmentWriter, String column,
+      VectorBackendType backendType, File indexDir)
+      throws Exception {
+    File v3Dir = SegmentDirectoryPaths.segmentDirectoryFor(indexDir,
+        _segmentDirectory.getSegmentMetadata().getVersion());
+    String segmentName = _segmentDirectory.getSegmentMetadata().getName();
+
+    if (backendType == VectorBackendType.HNSW) {
+      absorbHnswIntoColumnsPsf(segmentWriter, column, v3Dir, segmentName);
+      return;
+    }
+
+    // IVF path: prefer the combined-form file (freshly-written by a creator run with flag=on);
+    // fall back to the legacy sidecar (segments built with flag=off that the operator now wants
+    // consolidated).
+    File combinedFile = new File(v3Dir,
+        column + VectorIndexUtils.getIndexFileExtension(backendType, /* combined */ true));
+    File legacyFile = new File(v3Dir,
+        column + VectorIndexUtils.getIndexFileExtension(backendType, /* combined */ false));
+    File picked = combinedFile.exists() ? combinedFile : legacyFile;
+    if (!picked.exists()) {
+      LOGGER.warn("Expected vector index file {} not found during vector consolidation; skipping", picked);
+      return;
+    }
+    // Crash-recovery: if a prior absorb committed bytes to columns.psf but crashed before
+    // deleting the sidecar, the typed entry is already present. Detect that via the columns.psf
+    // typed entry directly — NOT hasIndexFor, which for vector also reports the on-disk sidecar we
+    // are about to absorb. Using hasIndexFor here would make a normal first-absorb look
+    // already-absorbed and the subsequent getIndexFor().size() would throw.
+    PinotDataBuffer existingEntry = VectorIndexUtils.getConsolidatedVectorEntry(segmentWriter, column);
+    if (existingEntry != null) {
+      long existingSize = existingEntry.size();
+      if (existingSize == picked.length()) {
+        LOGGER.warn("Vector index already present in columns.psf for segment: {}, column: {}; "
+            + "deleting orphan sidecar file from a previously-crashed absorb run", segmentName, column);
+        FileUtils.deleteQuietly(picked);
+        return;
+      }
+      // Size mismatch — the typed entry is from a different build than the sidecar. Refuse to
+      // proceed; an operator must reconcile manually rather than have us guess.
+      throw new IOException("Vector index already present in columns.psf for column: " + column
+          + " (size=" + existingSize + ") but sidecar file " + picked.getName()
+          + " has different size " + picked.length() + ". Refusing to overwrite — please remove "
+          + "the conflicting sidecar or rebuild the segment.");
+    }
+    LOGGER.info("Absorbing vector sidecar file into columns.psf for segment: {}, column: {} (backend={})",
+        segmentName, column, backendType);
+    LoaderUtils.writeIndexToV3Format(segmentWriter, column, picked, StandardIndexes.vector());
+  }
+
+  /// HNSW-specific absorb: packs the Lucene directory (or uses an existing combined-form file) into
+  /// a single combined file and absorbs it into {@code columns.psf}.
+  ///
+  /// If the combined-form file already exists (creator ran with the flag on and produced it),
+  /// it is absorbed directly. If only the Lucene directory exists (operator just flipped the flag
+  /// on an existing segment), the directory is first packed into a transient combined file, which is
+  /// then absorbed and cleaned up.
+  private void absorbHnswIntoColumnsPsf(SegmentDirectory.Writer segmentWriter, String column, File v3Dir,
+      String segmentName)
+      throws Exception {
+    File combinedFile = new File(v3Dir,
+        column + VectorIndexUtils.getIndexFileExtension(VectorBackendType.HNSW, /* combined */ true));
+    File hnswDir = new File(v3Dir,
+        column + VectorIndexUtils.getIndexFileExtension(VectorBackendType.HNSW, /* combined */ false));
+    if (!combinedFile.exists()) {
+      if (!hnswDir.exists() || !hnswDir.isDirectory()) {
+        LOGGER.warn("Expected HNSW directory or combined file for column {} not found; skipping absorb", column);
+        return;
+      }
+      // Pack the Lucene directory into a transient combined file for absorption. The directory
+      // and the combined file are both cleaned up below after a successful absorb (or by the
+      // crash-recovery branch above on a subsequent retry).
+      HnswVectorIndexCombined.combineHnswIndexFiles(hnswDir, combinedFile.getAbsolutePath(), v3Dir.getParentFile(),
+          column);
+    }
+
+    // Crash-recovery: check whether the typed entry already exists. Detect it via the columns.psf
+    // typed entry directly — NOT hasIndexFor, which for vector also reports the still-present
+    // legacy Lucene directory (we pack but do not delete it above), so hasIndexFor would be true on
+    // a normal first-absorb and the subsequent getIndexFor().size() would throw.
+    PinotDataBuffer existingEntry = VectorIndexUtils.getConsolidatedVectorEntry(segmentWriter, column);
+    if (existingEntry != null) {
+      long existingSize = existingEntry.size();
+      if (existingSize == combinedFile.length()) {
+        LOGGER.warn("HNSW vector index already present in columns.psf for segment: {}, column: {}; "
+            + "deleting orphan files from a previously-crashed absorb run", segmentName, column);
+        FileUtils.deleteQuietly(combinedFile);
+        // Clean up the Lucene directory regardless of createdTransient: if we packed the directory
+        // into a transient combined file in this very run, the directory still exists and must be
+        // removed to prevent hasCombinedFile from re-triggering on the next segment load.
+        if (hnswDir.exists()) {
+          FileUtils.deleteDirectory(hnswDir);
+        }
+        return;
+      }
+      throw new IOException("HNSW vector index already present in columns.psf for column: " + column
+          + " (size=" + existingSize + ") but combined file " + combinedFile.getName()
+          + " has different size " + combinedFile.length() + ". Refusing to overwrite — please remove "
+          + "the conflicting sidecar or rebuild the segment.");
+    }
+
+    LOGGER.info("Absorbing HNSW combined file into columns.psf for segment: {}, column: {}", segmentName, column);
+    LoaderUtils.writeIndexToV3Format(segmentWriter, column, combinedFile, StandardIndexes.vector());
+    // writeIndexToV3Format already force-deletes the absorbed combined file (like the IVF path above),
+    // so only the Lucene directory needs explicit cleanup here.
+    if (hnswDir.exists()) {
+      FileUtils.deleteDirectory(hnswDir);
+    }
+  }
+
+  /// Extracts the consolidated vector payload from {@code columns.psf} back into the legacy on-disk
+  /// form and drops the typed entry. Used when the operator flips {@code storeInSegmentFile} from
+  /// {@code true} to {@code false}.
+  ///
+  /// For IVF backends the bytes are streamed verbatim to a sidecar file. For HNSW, the packed
+  /// combined file is streamed out first, then unpacked into a Lucene directory — the inverse of
+  /// the absorb path.
+  ///
+  /// **Ordering:** bytes are streamed to a temp file *before* {@code removeIndex}
+  /// is called, because {@code SingleFileIndexDirectory.removeIndex} for vector also runs
+  /// {@link VectorIndexUtils#cleanupVectorIndex(File, String)}, which deletes any file with a
+  /// recognised extension. The temp extension ({@code .vector.extract-tmp}) is not in that list,
+  /// so the bytes survive until the consolidated entry is safely removed.
+  private void extractConsolidatedToLegacyFile(SegmentDirectory.Writer segmentWriter, String column,
+      VectorBackendType backendType, File indexDir)
+      throws IOException {
+    File v3Dir = SegmentDirectoryPaths.segmentDirectoryFor(indexDir,
+        _segmentDirectory.getSegmentMetadata().getVersion());
+    String segmentName = _segmentDirectory.getSegmentMetadata().getName();
+
+    if (backendType == VectorBackendType.HNSW) {
+      extractHnswConsolidatedToDirectory(segmentWriter, column, v3Dir, segmentName);
+      return;
+    }
+
+    // IVF path: stream bytes to the legacy combined extension.
+    File finalCombined = new File(v3Dir, column + VectorIndexUtils.getIndexFileExtension(backendType));
+    File combinedFormFile = new File(v3Dir,
+        column + VectorIndexUtils.getIndexFileExtension(backendType, /* combined */ true));
+    // Defensive: extract is destructive (removeIndex calls cleanupVectorIndex, which deletes any
+    // sidecar with a recognised IVF extension). If a sidecar already exists on disk we'd silently
+    // clobber it. Refuse to proceed and force the operator to reconcile — this state should not
+    // arise from the handler's own paths (see hasCombinedFile in needUpdateIndices) but a
+    // manually-edited segment dir or a half-completed migration could produce it.
+    if (finalCombined.exists()) {
+      throw new IOException("Extract path expected no on-disk sidecar but found: " + finalCombined
+          + ". Refusing to proceed — please remove the conflicting file manually.");
+    }
+    if (combinedFormFile.exists()) {
+      throw new IOException("Extract path expected no on-disk sidecar but found: " + combinedFormFile
+          + ". Refusing to proceed — please remove the conflicting file manually.");
+    }
+    File tempCombined = new File(v3Dir, column + ".vector.extract-tmp");
+    // Clean any leftover from a previously-crashed extract.
+    FileUtils.deleteQuietly(tempCombined);
+
+    LOGGER.info("Extracting vector consolidated entry to sidecar file for segment: {}, column: {} (backend={})",
+        segmentName, column, backendType);
+    PinotDataBuffer buffer = segmentWriter.getIndexFor(column, StandardIndexes.vector());
+    long size = buffer.size();
+    streamBufferToFile(buffer, size, tempCombined);
+
+    // Remove the consolidated entry. {@code cleanupVectorIndex} runs as a side effect; it will
+    // not touch our temp file because the temp extension is not in its recognised list.
+    segmentWriter.removeIndex(column, StandardIndexes.vector());
+
+    if (!tempCombined.renameTo(finalCombined)) {
+      // Best-effort copy-and-delete fallback if rename fails (e.g. cross-FS in tests).
+      FileUtils.copyFile(tempCombined, finalCombined);
+      FileUtils.deleteQuietly(tempCombined);
+    }
+  }
+
+  /// HNSW-specific extract: streams the combined HNSW payload from {@code columns.psf} to a temp
+  /// file, unpacks it into a Lucene directory, and only then removes the consolidated typed entry.
+  ///
+  /// **Ordering rationale:** the bytes are unpacked *before* {@code removeIndex}. If the unpack
+  /// fails mid-way, the typed entry is still present in {@code columns.psf} and the next load
+  /// retries the extract — the operator does not lose the index. The reverse order would leave a
+  /// crash window in which the typed entry is gone but the Lucene directory does not yet exist,
+  /// leaving the segment permanently without its HNSW index until a full rebuild.
+  ///
+  /// **Why unpack into a temp directory, then move:** {@code SingleFileIndexDirectory.removeIndex}
+  /// for vector runs {@link VectorIndexUtils#cleanupVectorIndex(File, String)} as a side effect,
+  /// which {@code deleteQuietly}s a fixed list of exact {@code column + <extension>} paths — one of
+  /// which is the legacy {@code .vector.v912.hnsw.index} directory we are recreating. Unpacking
+  /// straight into that final directory would let the {@code removeIndex} below wipe the bytes we
+  /// just wrote. So we unpack into a temp directory and move it into place after cleanup. This is
+  /// the same temp-then-rename shape the IVF extract path ({@link #extractConsolidatedToLegacyFile})
+  /// uses for the same reason. **Invariant:** the temp name must never equal any
+  /// {@code column + <extension>} that {@code cleanupVectorIndex} deletes — keep the
+  /// {@code .extract-tmp*} suffixes out of {@link VectorIndexUtils#cleanupVectorIndex} if extensions
+  /// are ever added there.
+  ///
+  /// **Crash windows:** the typed entry's removal is only persisted on {@code close()}, so a crash
+  /// between {@code removeIndex} and the move still leaves the entry in {@code columns.psf} and the
+  /// next load retries the extract. A crash *after* the move but before {@code close()} leaves the
+  /// Lucene directory in place (usable) plus an orphan typed entry in {@code columns.psf}; the
+  /// {@code storeInSegmentFile=false} reader path uses the directory and ignores the orphan, so this
+  /// is a harmless leak of consolidated bytes, not data loss or a wrong result.
+  private void extractHnswConsolidatedToDirectory(SegmentDirectory.Writer segmentWriter, String column,
+      File v3Dir, String segmentName)
+      throws IOException {
+    File hnswDir = new File(v3Dir,
+        column + VectorIndexUtils.getIndexFileExtension(VectorBackendType.HNSW, /* combined */ false));
+    File combinedFormFile = new File(v3Dir,
+        column + VectorIndexUtils.getIndexFileExtension(VectorBackendType.HNSW, /* combined */ true));
+    if (hnswDir.exists()) {
+      throw new IOException("Extract path expected no on-disk HNSW directory but found: " + hnswDir
+          + ". Refusing to proceed — please remove the conflicting directory manually.");
+    }
+    if (combinedFormFile.exists()) {
+      throw new IOException("Extract path expected no on-disk combined HNSW file but found: " + combinedFormFile
+          + ". Refusing to proceed — please remove the conflicting file manually.");
+    }
+    File tempCombined = new File(v3Dir, column + ".vector.extract-tmp");
+    // Temp unpack directory; this exact name is deliberately not one of the column+extension paths
+    // cleanupVectorIndex (run by removeIndex below) deletes, so it is left untouched.
+    File tempHnswDir = new File(v3Dir, column + ".vector.hnsw.extract-tmp-dir");
+    // Clean leftovers from a previously-crashed extract (deleteQuietly recurses into directories).
+    FileUtils.deleteQuietly(tempCombined);
+    FileUtils.deleteQuietly(tempHnswDir);
+
+    LOGGER.info(
+        "Extracting HNSW consolidated entry to Lucene directory for segment: {}, column: {}", segmentName, column);
+    PinotDataBuffer buffer = segmentWriter.getIndexFor(column, StandardIndexes.vector());
+    streamBufferToFile(buffer, buffer.size(), tempCombined);
+
+    // Unpack the combined file into the TEMP directory BEFORE removing the typed entry. If unpack
+    // throws, the typed entry remains in columns.psf and the next handler run retries — no
+    // permanent loss. Best-effort clean up the half-unpacked temp directory.
+    try {
+      HnswVectorIndexCombined.extractHnswIndexFiles(tempCombined, tempHnswDir);
+    } catch (IOException | RuntimeException e) {
+      FileUtils.deleteQuietly(tempHnswDir);
+      FileUtils.deleteQuietly(tempCombined);
+      throw e;
+    }
+
+    // Drop the consolidated entry. cleanupVectorIndex runs as a side effect but only deletes the
+    // fixed column+extension paths, not our temp directory, so the unpacked bytes survive.
+    segmentWriter.removeIndex(column, StandardIndexes.vector());
+
+    // Move the unpacked Lucene directory into its final legacy location AFTER cleanup so it is not
+    // deleted. tempHnswDir and hnswDir share v3Dir, so this is an in-directory rename; the
+    // copy-and-delete fallback covers the rare case where rename fails.
+    try {
+      FileUtils.moveDirectory(tempHnswDir, hnswDir);
+    } catch (IOException e) {
+      try {
+        FileUtils.copyDirectory(tempHnswDir, hnswDir);
+      } catch (IOException copyError) {
+        // Clean the partial copy so the retry's pre-flight directory-exists check is not tripped.
+        FileUtils.deleteQuietly(hnswDir);
+        copyError.addSuppressed(e);
+        throw copyError;
+      }
+      FileUtils.deleteQuietly(tempHnswDir);
+    }
+    FileUtils.deleteQuietly(tempCombined);
+  }
+
+  /// Streams {@code size} bytes from a {@link PinotDataBuffer} into a regular file, chunked to
+  /// keep heap usage bounded for large IVF payloads.
+  private static void streamBufferToFile(PinotDataBuffer buffer, long size, File dest)
+      throws IOException {
+    final int chunkSize = 1 << 20; // 1 MiB
+    byte[] chunk = new byte[chunkSize];
+    try (FileOutputStream fos = new FileOutputStream(dest)) {
+      long offset = 0;
+      long remaining = size;
+      while (remaining > 0) {
+        int toCopy = (int) Math.min(remaining, chunkSize);
+        buffer.copyTo(offset, chunk, 0, toCopy);
+        fos.write(chunk, 0, toCopy);
+        offset += toCopy;
+        remaining -= toCopy;
+      }
+    }
+  }
+
+  /// Returns {@code true} when the column has an on-disk sidecar in the V3 segment directory that
+  /// can be absorbed into (or was extracted from) {@code columns.psf}. Covers both the legacy form
+  /// (segments built with the flag off) and the combined form (built with the flag on).
+  ///
+  /// For HNSW, the "sidecar" is either a Lucene directory ({@code .vector.v912.hnsw.index/})
+  /// or the combined packed file ({@code .vector.hnsw.combined.index}). Either form is absorb-able.
+  /// For IVF, the legacy or combined-extension single files are checked.
+  private boolean hasCombinedFile(File indexDir, String column, VectorBackendType backendType) {
+    File v3Dir = SegmentDirectoryPaths.segmentDirectoryFor(indexDir,
+        _segmentDirectory.getSegmentMetadata().getVersion());
+    if (backendType == VectorBackendType.HNSW) {
+      // Either the packed combined file or the Lucene directory is absorb-able.
+      return new File(v3Dir,
+          column + VectorIndexUtils.getIndexFileExtension(VectorBackendType.HNSW, /* combined */ true)).exists()
+          || new File(v3Dir,
+          column + VectorIndexUtils.getIndexFileExtension(VectorBackendType.HNSW, /* combined */ false)).exists();
+    }
+    return new File(v3Dir, column + VectorIndexUtils.getIndexFileExtension(backendType)).exists()
+        || new File(v3Dir, column + VectorIndexUtils.getIndexFileExtension(backendType, /* combined */ true)).exists();
+  }
+
   @Override
   public void updateIndices(SegmentDirectory.Writer segmentWriter)
       throws Exception {
@@ -108,11 +495,46 @@ public class VectorIndexHandler extends BaseIndexHandler {
       VectorIndexConfig desiredConfig = _vectorConfigs.get(column);
       VectorBackendType desiredBackend = desiredConfig.resolveBackendType();
       VectorBackendType existingBackend = VectorIndexUtils.detectVectorIndexBackend(indexDir, column);
-      if (existingBackend != null && existingBackend != desiredBackend) {
+      // Storage-format comparison — see the twin check in needUpdateIndices.
+      if (existingBackend != null && existingBackend != VectorIndexUtils.storageFormatOf(desiredBackend)) {
         LOGGER.info("Rebuilding Vector index for segment: {}, column: {} (backend changed from {} to {})",
             segmentName, column, existingBackend, desiredBackend);
         segmentWriter.removeIndex(column, StandardIndexes.vector());
         columnsToAddIdx.add(column);
+        continue;
+      }
+      // Consolidated-only backend drift (see needUpdateIndices): the old payload lives solely in
+      // columns.psf, so sniff its magic. On a mismatch, rebuild — running the absorb/extract
+      // migrations below would carry the OLD backend's bytes under the NEW backend's slot or
+      // extension, and the next load would parse them with the wrong reader.
+      VectorBackendType driftedConsolidatedBackend =
+          getDriftedConsolidatedBackend(segmentWriter, column, existingBackend, desiredBackend);
+      if (driftedConsolidatedBackend != null) {
+        LOGGER.info("Rebuilding Vector index for segment: {}, column: {} "
+            + "(consolidated backend changed from {} to {})", segmentName, column, driftedConsolidatedBackend,
+            desiredBackend);
+        segmentWriter.removeIndex(column, StandardIndexes.vector());
+        columnsToAddIdx.add(column);
+        continue;
+      }
+      // Backend matches, but the table now wants the vector payload consolidated into columns.psf
+      // and a sidecar file still exists. Absorb the sidecar without rebuilding — preserves the bytes
+      // the offline build produced. Works for both IVF and HNSW backends.
+      if (desiredConfig.isStoreInSegmentFile()
+          && _segmentDirectory.getSegmentMetadata().getVersion() == SegmentVersion.v3
+          && existingBackend != null
+          && hasCombinedFile(indexDir, column, desiredBackend)) {
+        absorbCombinedIntoColumnsPsf(segmentWriter, column, desiredBackend, indexDir);
+        continue;
+      }
+      // Backend matches, but the table now wants the vector payload back in the sidecar layout and
+      // the segment currently has the consolidated entry only. Extract bytes from columns.psf
+      // into a sidecar file, then drop the consolidated entry. Preserves the bytes (no rebuild).
+      if (!desiredConfig.isStoreInSegmentFile()
+          && _segmentDirectory.getSegmentMetadata().getVersion() == SegmentVersion.v3
+          && existingBackend == null
+          && !hasCombinedFile(indexDir, column, desiredBackend)) {
+        extractConsolidatedToLegacyFile(segmentWriter, column, desiredBackend, indexDir);
       }
     }
     for (String column : columnsToAddIdx) {
@@ -127,6 +549,38 @@ public class VectorIndexHandler extends BaseIndexHandler {
     return columnMetadata != null;
   }
 
+  /// Sweeps orphans left over from a prior build that targeted the OTHER extension (e.g. a crash
+  /// with {@code storeInSegmentFile=true} followed by a retry with the flag off). Removes the
+  /// other-extension {@code .inprogress} marker and any partial index file with that extension,
+  /// so a later flag-flip cannot pick the residue up as if it were a complete index.
+  ///
+  /// For HNSW the two forms are the Lucene directory ({@code .vector.v912.hnsw.index/}) and
+  /// the combined packed file ({@code .vector.hnsw.combined.index}). The "other" form when writing
+  /// combined is the legacy Lucene directory; when writing legacy it is the combined file.
+  @VisibleForTesting
+  static void cleanOrphansFromOtherExtension(File segmentDirectory, String columnName,
+      VectorBackendType backendType, boolean currentWriteCombined) {
+    String currentExt = VectorIndexUtils.getIndexFileExtension(backendType, currentWriteCombined);
+    String otherExt = VectorIndexUtils.getIndexFileExtension(backendType, !currentWriteCombined);
+    if (otherExt.equals(currentExt)) {
+      return;
+    }
+    // For HNSW the legacy form is a Lucene directory (non-empty); use deleteDirectory for recursive
+    // deletion. The combined file and .inprogress markers are always plain files.
+    FileUtils.deleteQuietly(new File(segmentDirectory, columnName + otherExt + ".inprogress"));
+    File otherFile = new File(segmentDirectory, columnName + otherExt);
+    if (otherFile.isDirectory()) {
+      // Recursively delete the Lucene directory (deleteQuietly silently fails on non-empty dirs).
+      try {
+        FileUtils.deleteDirectory(otherFile);
+      } catch (IOException e) {
+        LOGGER.warn("Failed to delete orphan HNSW directory: {}", otherFile, e);
+      }
+    } else {
+      FileUtils.deleteQuietly(otherFile);
+    }
+  }
+
   private void createVectorIndexForColumn(SegmentDirectory.Writer segmentWriter, ColumnMetadata columnMetadata)
       throws Exception {
     File indexDir = _segmentDirectory.getSegmentMetadata().getIndexDir();
@@ -137,10 +591,17 @@ public class VectorIndexHandler extends BaseIndexHandler {
     String columnName = columnMetadata.getColumnName();
     VectorIndexConfig config = _fieldIndexConfigs.get(columnName).getConfig(StandardIndexes.vector());
     VectorBackendType backendType = config.resolveBackendType();
-    String vectorIndexFileExtension = VectorIndexUtils.getIndexFileExtension(backendType);
+    // Resolve the on-disk extension (or directory name) that the creator writes to. When
+    // storeInSegmentFile=true the creator produces the combined-form directly; when false it writes
+    // the legacy form (a Lucene directory for HNSW, a flat file for IVF). The .inprogress marker
+    // tracks the same path, and the absorb step picks whichever form actually exists on disk.
+    boolean writeCombined = config.isStoreInSegmentFile();
+    String vectorIndexFileExtension = VectorIndexUtils.getIndexFileExtension(backendType, writeCombined);
     File inProgress = new File(segmentDirectory, columnName + vectorIndexFileExtension + ".inprogress");
     File vectorIndexFile = new File(segmentDirectory, columnName + vectorIndexFileExtension);
 
+    cleanOrphansFromOtherExtension(segmentDirectory, columnName, backendType, writeCombined);
+
     if (!inProgress.exists()) {
       // Marker file does not exist, which means last run ended normally.
       // Create a marker file.
@@ -165,10 +626,15 @@ public class VectorIndexHandler extends BaseIndexHandler {
       handleNonDictionaryBasedColumn(segmentWriter, columnMetadata);
     }
 
-//    // For v3, write the generated Vector index file into the single file and remove it.
-//    if (_segmentDirectory.getSegmentMetadata().getVersion() == SegmentVersion.v3) {
-//      LoaderUtils.writeIndexToV3Format(segmentWriter, columnName, vectorIndexFile, StandardIndexes.vector());
-//    }
+    // For v3 segments with storeInSegmentFile=true, absorb the freshly-written sidecar into
+    // columns.psf as a typed entry and delete the sibling file. Mirrors the text-index path
+    // (TextIndexHandler.convertTextIndexToV3Format). The shared helper handles crash recovery.
+    // For HNSW, close() already produced the combined file; hasCombinedFile detects it.
+    if (config.isStoreInSegmentFile()
+        && _segmentDirectory.getSegmentMetadata().getVersion() == SegmentVersion.v3
+        && hasCombinedFile(indexDir, columnName, backendType)) {
+      absorbCombinedIntoColumnsPsf(segmentWriter, columnName, backendType, indexDir);
+    }
 
     // Delete the marker file.
     FileUtils.deleteQuietly(inProgress);
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/HnswVectorIndexBufferReader.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/HnswVectorIndexBufferReader.java
new file mode 100644
index 00000000000..61292d72f2a
--- /dev/null
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/HnswVectorIndexBufferReader.java
@@ -0,0 +1,119 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.segment.local.segment.index.readers.vector;
+
+import java.io.IOException;
+import java.nio.ByteOrder;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+import org.apache.lucene.store.Directory;
+import org.apache.pinot.segment.local.segment.index.readers.text.LuceneTextIndexBufferReader;
+import org.apache.pinot.segment.local.segment.index.readers.text.LuceneTextIndexHeader;
+import org.apache.pinot.segment.local.segment.index.readers.text.PinotBufferLuceneDirectory;
+import org.apache.pinot.segment.spi.V1Constants;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+/// Utility for reading an HNSW vector index from a combined buffer ({@link PinotDataBuffer}).
+///
+/// The combined buffer uses the same {@code LUCENE_V2} layout as the text index (written by
+/// {@code HnswVectorIndexCombined}). This class delegates header and metadata parsing to
+/// {@link LuceneTextIndexBufferReader}, then constructs a {@link PinotBufferLuceneDirectory} that
+/// Lucene's {@code DirectoryReader} can open without any filesystem access.
+///
+/// Two entry-points are provided:
+///   - {@link #createLuceneDirectory} — a read-only {@link Directory} over the Lucene index
+///     files embedded in the buffer.
+///   - {@link #extractDocIdMappingBuffer} — a sub-buffer view covering just the docId mapping
+///     bytes, or {@code null} if the mapping was not packed.
+public final class HnswVectorIndexBufferReader {
+  private static final Logger LOGGER = LoggerFactory.getLogger(HnswVectorIndexBufferReader.class);
+
+  private HnswVectorIndexBufferReader() {
+  }
+
+  /// Creates a Lucene {@link Directory} that reads all Lucene index files from a combined HNSW
+  /// buffer. The docId mapping file (a Pinot-only artifact with the
+  /// {@link V1Constants.Indexes#VECTOR_HNSW_INDEX_DOCID_MAPPING_FILE_EXTENSION} suffix) is
+  /// excluded from the directory view so that {@code DirectoryReader} does not see an unknown file.
+  ///
+  /// The directory does *not* own the buffer — closing it is a no-op. The caller must
+  /// keep the buffer alive for as long as the directory (and any reader opened on it) is in use.
+  ///
+  /// @param indexBuffer combined buffer in LUCENE_V2 format
+  /// @param column      column name; used to identify and exclude the mapping file
+  /// @return a read-only {@link Directory} backed by the buffer
+  /// @throws IOException if the buffer is malformed or the magic/version check fails
+  public static Directory createLuceneDirectory(PinotDataBuffer indexBuffer, String column)
+      throws IOException {
+    List<String> fileNames = LuceneTextIndexBufferReader.listFiles(indexBuffer);
+    Map<String, LuceneTextIndexHeader.FileInfo> fileMap = new HashMap<>(fileNames.size());
+
+    String mappingFileName = column + V1Constants.Indexes.VECTOR_HNSW_INDEX_DOCID_MAPPING_FILE_EXTENSION;
+    for (String name : fileNames) {
+      if (name.equals(mappingFileName)) {
+        // Skip: not a Lucene index file; presenting it to DirectoryReader triggers an error.
+        continue;
+      }
+      LuceneTextIndexHeader.FileInfo info = LuceneTextIndexBufferReader.getFileInfo(indexBuffer, name);
+      if (info != null) {
+        fileMap.put(name, info);
+      }
+    }
+
+    LOGGER.debug("Creating buffer-backed Lucene directory for HNSW column '{}' with {} file(s)", column,
+        fileMap.size());
+    return new PinotBufferLuceneDirectory(indexBuffer, fileMap, column);
+  }
+
+  /// Extracts a sub-buffer covering the docId mapping bytes packed inside the combined buffer.
+  ///
+  /// Returns {@code null} when the mapping was not included (e.g. the index was built from an
+  /// in-memory segment that had not yet materialised a mapping file). The caller must build the
+  /// mapping from the Lucene index in that case.
+  ///
+  /// The returned sub-buffer is a {@link PinotDataBuffer#view view} of the original buffer and
+  /// shares its lifetime. The caller must not close it independently.
+  ///
+  /// The view is forced to {@link ByteOrder#LITTLE_ENDIAN} regardless of the combined buffer's
+  /// order. The docId mapping is packed verbatim from the file-backed sidecar, which
+  /// {@code DocIdTranslator} always writes/reads little-endian; the enclosing {@code columns.psf}
+  /// buffer is big-endian, so an inherited-order view would byte-swap every Lucene→Pinot doc id and
+  /// corrupt ANN result translation and pre-filter matching.
+  ///
+  /// @param indexBuffer combined buffer in LUCENE_V2 format
+  /// @param column      column name; used to identify the mapping file entry
+  /// @return little-endian sub-buffer for the mapping bytes, or {@code null} if not present
+  /// @throws IOException if header parsing fails
+  @Nullable
+  public static PinotDataBuffer extractDocIdMappingBuffer(PinotDataBuffer indexBuffer, String column)
+      throws IOException {
+    String mappingFileName = column + V1Constants.Indexes.VECTOR_HNSW_INDEX_DOCID_MAPPING_FILE_EXTENSION;
+    LuceneTextIndexHeader.FileInfo fileInfo = LuceneTextIndexBufferReader.getFileInfo(indexBuffer, mappingFileName);
+    if (fileInfo == null) {
+      return null;
+    }
+    return indexBuffer.view(fileInfo.getOffset(), fileInfo.getOffset() + fileInfo.getSize(),
+        ByteOrder.LITTLE_ENDIAN);
+  }
+}
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/HnswVectorIndexReader.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/HnswVectorIndexReader.java
index bc36af593d2..95ad76cd3fd 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/HnswVectorIndexReader.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/HnswVectorIndexReader.java
@@ -25,6 +25,7 @@ import java.nio.ByteOrder;
 import java.util.Arrays;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import javax.annotation.Nullable;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.index.DirectoryReader;
 import org.apache.lucene.index.IndexReader;
@@ -68,6 +69,10 @@ public class HnswVectorIndexReader implements FilterAwareVectorIndexReader, EfSe
   private final ThreadLocal<Boolean> _useRelativeDistanceOverride = new ThreadLocal<>();
   private final ThreadLocal<Boolean> _useBoundedQueueOverride = new ThreadLocal<>();
 
+  /**
+   * File-backed constructor: opens a {@link FSDirectory} from the Lucene HNSW index directory
+   * found under {@code indexDir}.
+   */
   public HnswVectorIndexReader(String column, File indexDir, int numDocs, VectorIndexConfig config) {
     _column = column;
     try {
@@ -86,6 +91,35 @@ public class HnswVectorIndexReader implements FilterAwareVectorIndexReader, EfSe
     }
   }
 
+  /**
+   * Buffer-backed constructor: reads the HNSW index from a combined {@link PinotDataBuffer}
+   * (the {@code LUCENE_V2} packed form produced by {@code HnswVectorIndexCombined}).
+   *
+   * <p>The buffer is <em>not</em> owned by this reader — closing this reader does not close the
+   * buffer. The buffer's lifetime must exceed this reader's lifetime; the segment directory is
+   * responsible for closing it.</p>
+   *
+   * @param column      column name
+   * @param indexBuffer combined buffer in LUCENE_V2 format; not owned by this reader
+   * @param numDocs     number of documents in the segment
+   * @param config      vector index configuration
+   */
+  public HnswVectorIndexReader(String column, PinotDataBuffer indexBuffer, int numDocs, VectorIndexConfig config) {
+    _column = column;
+    try {
+      _indexDirectory = HnswVectorIndexBufferReader.createLuceneDirectory(indexBuffer, column);
+      _indexReader = DirectoryReader.open(_indexDirectory);
+      _indexSearcher = new IndexSearcher(_indexReader);
+
+      // Try to extract the mapping from the packed buffer first; build from the Lucene index if absent.
+      PinotDataBuffer mappingBuffer = HnswVectorIndexBufferReader.extractDocIdMappingBuffer(indexBuffer, column);
+      _docIdTranslator = new DocIdTranslator(mappingBuffer, numDocs, _indexSearcher);
+    } catch (Exception e) {
+      LOGGER.error("Failed to instantiate buffer-backed HNSW index reader for column {}", column, e);
+      throw new RuntimeException(e);
+    }
+  }
+
   /**
    * CASE 1: If IndexLoadingConfig specifies a segment version to load and if it is different then
    * the on-disk version of the segment, then {@link ImmutableSegmentLoader}
@@ -237,12 +271,33 @@ public class HnswVectorIndexReader implements FilterAwareVectorIndexReader, EfSe
    * are ingested during segment/index creation.
    * This class is used to map the luceneDocId (returned by the search query
    * to the collector) to corresponding pinotDocId.
+   *
+   * <p>Supports two modes:</p>
+   * <ul>
+   *   <li><b>File-backed:</b> the mapping is read from (or written to) a memory-mapped file on
+   *       disk. The buffer is owned by this translator and closed on {@link #close()}.</li>
+   *   <li><b>Buffer-backed:</b> the mapping is a view into a combined index buffer owned by the
+   *       segment directory. The translator does <em>not</em> close it on {@link #close()}, since
+   *       the caller must not close a buffer it does not own.</li>
+   *   <li><b>Heap-backed:</b> when the mapping is absent from a combined buffer, it is built in
+   *       heap memory by scanning the Lucene index. No file is created, and {@link #close()} is
+   *       a no-op for the mapping portion.</li>
+   * </ul>
    */
   static class DocIdTranslator implements Closeable {
-    final PinotDataBuffer _buffer;
-
+    // Non-null for file-backed mode (owned); non-null for buffer-backed mode (borrowed, not closed).
+    private final PinotDataBuffer _buffer;
+    // Non-null for heap-backed mode (built from Lucene index in buffer-backed path when no mapping
+    // was packed into the combined file).
+    private final int[] _heapMapping;
+    // True when _buffer is borrowed (from a combined index buffer); must not be closed by us.
+    private final boolean _borrowedBuffer;
+
+    /** File-backed: mapping is read from (or created at) a file beside the HNSW directory. */
     DocIdTranslator(File segmentIndexDir, String column, int numDocs, IndexSearcher indexSearcher)
         throws Exception {
+      _heapMapping = null;
+      _borrowedBuffer = false;
       int length = Integer.BYTES * numDocs;
       File docIdMappingFile = new File(SegmentDirectoryPaths.findSegmentDirectory(segmentIndexDir),
           column + V1Constants.Indexes.VECTOR_HNSW_INDEX_DOCID_MAPPING_FILE_EXTENSION);
@@ -272,14 +327,57 @@ public class HnswVectorIndexReader implements FilterAwareVectorIndexReader, EfSe
       }
     }
 
+    /**
+     * Buffer-backed: the mapping is either a view into the combined index buffer, or built in heap
+     * memory by scanning the Lucene index (when the mapping was not packed into the combined file).
+     *
+     * @param mappingBuffer sub-buffer view covering the packed mapping, or {@code null} to build
+     *                      in heap by scanning the Lucene index
+     * @param numDocs       number of documents
+     * @param indexSearcher searcher over the already-opened Lucene index
+     */
+    DocIdTranslator(@Nullable PinotDataBuffer mappingBuffer, int numDocs,
+        IndexSearcher indexSearcher)
+        throws Exception {
+      if (mappingBuffer != null) {
+        // Mapping was packed: use it as a borrowed view. Do not close it on our close().
+        _buffer = mappingBuffer;
+        _heapMapping = null;
+        _borrowedBuffer = true;
+      } else {
+        // Mapping absent from combined buffer: build in heap from the Lucene index.
+        _buffer = null;
+        _borrowedBuffer = false;
+        int[] heapMapping = new int[numDocs];
+        for (int i = 0; i < numDocs; i++) {
+          try {
+            Document document = indexSearcher.doc(i);
+            heapMapping[i] =
+                Integer.parseInt(document.get(HnswVectorIndexCreator.VECTOR_INDEX_DOC_ID_COLUMN_NAME));
+          } catch (Exception e) {
+            throw new RuntimeException(
+                "Caught exception while building in-heap docId mapping for HNSW index", e);
+          }
+        }
+        _heapMapping = heapMapping;
+      }
+    }
+
     int getPinotDocId(int luceneDocId) {
+      if (_heapMapping != null) {
+        return _heapMapping[luceneDocId];
+      }
       return _buffer.getInt(luceneDocId * Integer.BYTES);
     }
 
     @Override
     public void close()
         throws IOException {
-      _buffer.close();
+      // Only close the buffer when we own it (file-backed mode). Borrowed buffers are owned by the
+      // segment directory; heap mappings need no cleanup.
+      if (_buffer != null && !_borrowedBuffer) {
+        _buffer.close();
+      }
     }
   }
 
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfFlatVectorIndexReader.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfFlatVectorIndexReader.java
index 972556b3334..2fbbe15228d 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfFlatVectorIndexReader.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfFlatVectorIndexReader.java
@@ -20,24 +20,22 @@ package org.apache.pinot.segment.local.segment.index.readers.vector;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
-import java.io.DataInputStream;
-import java.io.File;
-import java.io.FileInputStream;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.PriorityQueue;
+import org.apache.pinot.segment.local.segment.index.vector.IvfCombinedBuffers;
 import org.apache.pinot.segment.local.segment.index.vector.IvfFlatVectorIndexCreator;
 import org.apache.pinot.segment.local.segment.index.vector.VectorQuantizationUtils;
-import org.apache.pinot.segment.spi.V1Constants;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
 import org.apache.pinot.segment.spi.index.creator.VectorQuantizerType;
 import org.apache.pinot.segment.spi.index.reader.ApproximateRadiusVectorIndexReader;
 import org.apache.pinot.segment.spi.index.reader.FilterAwareVectorIndexReader;
 import org.apache.pinot.segment.spi.index.reader.NprobeAware;
 import org.apache.pinot.segment.spi.index.reader.VectorQuantizer;
-import org.apache.pinot.segment.spi.store.SegmentDirectoryPaths;
+import org.apache.pinot.segment.spi.memory.DataBufferPinotInputStream;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
 import org.roaringbitmap.buffer.ImmutableRoaringBitmap;
 import org.roaringbitmap.buffer.MutableRoaringBitmap;
 import org.slf4j.Logger;
@@ -68,6 +66,10 @@ public class IvfFlatVectorIndexReader
   /** Default nprobe value when not explicitly set. */
   static final int DEFAULT_NPROBE = 4;
 
+  // Backing buffer. Closed by this reader only when {@code _ownsBuffer} is true. Contents are
+  // heap-loaded at construction, so it is safe for the caller to retain ownership of the buffer.
+  private final PinotDataBuffer _buffer;
+  private final boolean _ownsBuffer;
   // Index data loaded from file
   private final int _dimension;
   private final int _numVectors;
@@ -86,27 +88,42 @@ public class IvfFlatVectorIndexReader
   private final ThreadLocal<Integer> _nprobeOverride = new ThreadLocal<>();
 
   /**
-   * Opens and loads an IVF_FLAT index from disk.
+   * Opens and loads an IVF_FLAT index from the given buffer. The reader takes ownership of the
+   * buffer and closes it in {@link #close()}; use the four-arg overload to pass a borrowed
+   * buffer (e.g. one owned by the segment directory).
+   */
+  public IvfFlatVectorIndexReader(String column, PinotDataBuffer buffer, VectorIndexConfig config) {
+    this(column, buffer, config, /* ownsBuffer */ true);
+  }
+
+  /**
+   * Opens and loads an IVF_FLAT index from the given buffer.
+   *
+   * <p>The buffer holds the full IVF_FLAT file contents. The reader heap-loads centroids and
+   * inverted lists at construction time, so the buffer can be released once the constructor
+   * returns.</p>
    *
-   * @param column    the column name
-   * @param indexDir  the segment index directory
-   * @param config    the vector index configuration
-   * @throws RuntimeException if the index file cannot be read or is corrupt
+   * @param column      the column name
+   * @param buffer      the IVF_FLAT index buffer (mapped or in-memory)
+   * @param config      the vector index configuration
+   * @param ownsBuffer  when {@code true}, the reader closes the buffer in {@link #close()} (or
+   *                    on constructor failure). Pass {@code false} when the buffer is owned by
+   *                    the segment directory (typed entry inside {@code columns.psf}).
+   * @throws RuntimeException if the index buffer cannot be read or is corrupt
    */
-  public IvfFlatVectorIndexReader(String column, File indexDir, VectorIndexConfig config) {
+  public IvfFlatVectorIndexReader(String column, PinotDataBuffer buffer, VectorIndexConfig config,
+      boolean ownsBuffer) {
     _column = column;
+    _buffer = buffer;
+    _ownsBuffer = ownsBuffer;
 
     // Initialize nprobe to the default; query-time tuning should use NprobeAware#setNprobe.
     int configuredNprobe = DEFAULT_NPROBE;
 
-    File indexFile = SegmentDirectoryPaths.findVectorIndexIndexFile(indexDir, column, config);
-    if (indexFile == null || !indexFile.exists()) {
-      throw new IllegalStateException(
-          "Failed to find IVF_FLAT index file for column: " + column + " in dir: " + indexDir
-              + ". Expected file: " + column + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
-    }
-
-    try (DataInputStream in = new DataInputStream(new FileInputStream(indexFile))) {
+    // The reader takes ownership of the buffer. If construction throws (header decode failure,
+    // bad magic, EOF, etc.), release the buffer here so the mmap doesn't leak — the caller never
+    // sees a reader instance to close.
+    try (DataBufferPinotInputStream in = new DataBufferPinotInputStream(buffer)) {
       // --- Header ---
       int magic = in.readInt();
       Preconditions.checkState(magic == IvfFlatVectorIndexCreator.MAGIC,
@@ -180,9 +197,17 @@ public class IvfFlatVectorIndexReader
               + "formatVersion={}, quantizer={}",
           column, _numVectors, _nlist, _dimension, getNprobe(), _distanceFunction, _indexFormatVersion,
           _quantizerType);
-    } catch (IOException e) {
-      throw new RuntimeException(
-          "Failed to load IVF_FLAT index for column: " + column + " from file: " + indexFile, e);
+    } catch (Exception e) {
+      // Close the buffer to avoid leaking the mmap when the caller never receives a reader to
+      // close — but only if we own it. Borrowed buffers (segment-directory owned) are released
+      // by their owner.
+      if (_ownsBuffer) {
+        IvfCombinedBuffers.closeQuietly(_buffer);
+      }
+      if (e instanceof RuntimeException) {
+        throw (RuntimeException) e;
+      }
+      throw new RuntimeException("Failed to load IVF_FLAT index for column: " + column, e);
     }
   }
 
@@ -344,6 +369,9 @@ public class IvfFlatVectorIndexReader
   public void close()
       throws IOException {
     clearNprobe();
+    if (_ownsBuffer && _buffer != null) {
+      _buffer.close();
+    }
   }
 
   // -----------------------------------------------------------------------
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfOnDiskVectorIndexReader.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfOnDiskVectorIndexReader.java
index 62d3bc207aa..64f9bf07fdd 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfOnDiskVectorIndexReader.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfOnDiskVectorIndexReader.java
@@ -20,17 +20,16 @@ package org.apache.pinot.segment.local.segment.index.readers.vector;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
-import java.io.File;
 import java.io.IOException;
-import java.io.RandomAccessFile;
 import java.nio.ByteBuffer;
-import java.nio.channels.FileChannel;
+import java.nio.ByteOrder;
 import java.util.Arrays;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.PriorityQueue;
 import java.util.concurrent.atomic.AtomicLong;
 import org.apache.pinot.common.function.scalar.VectorFunctions;
+import org.apache.pinot.segment.local.segment.index.vector.IvfCombinedBuffers;
 import org.apache.pinot.segment.local.segment.index.vector.IvfFlatVectorIndexCreator;
 import org.apache.pinot.segment.local.segment.index.vector.VectorQuantizationUtils;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
@@ -39,7 +38,7 @@ import org.apache.pinot.segment.spi.index.reader.ApproximateRadiusVectorIndexRea
 import org.apache.pinot.segment.spi.index.reader.FilterAwareVectorIndexReader;
 import org.apache.pinot.segment.spi.index.reader.NprobeAware;
 import org.apache.pinot.segment.spi.index.reader.VectorQuantizer;
-import org.apache.pinot.segment.spi.store.SegmentDirectoryPaths;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
 import org.roaringbitmap.buffer.ImmutableRoaringBitmap;
 import org.roaringbitmap.buffer.MutableRoaringBitmap;
 import org.slf4j.Logger;
@@ -47,19 +46,19 @@ import org.slf4j.LoggerFactory;
 
 
 /**
- * Disk-backed reader for IVF_FLAT index files using FileChannel-based random-access I/O.
+ * Disk-backed reader for IVF_FLAT index files using positional buffer reads.
  *
  * <p>Unlike {@link IvfFlatVectorIndexReader} which loads all data into heap, this reader
- * keeps the index file open and performs positional reads via {@link FileChannel}.
+ * keeps the backing {@link PinotDataBuffer} open and performs positional reads on demand.
  * Centroids are always loaded into heap for fast probe selection; inverted list data
- * (doc IDs and vectors) is read on demand from the file.</p>
+ * (doc IDs and vectors) is read on demand from the buffer.</p>
  *
  * <p>This reader can read standard IVF_FLAT index files (magic 0x49564646). The on-disk
  * format is identical — only the runtime access pattern differs.</p>
  *
  * <h3>Thread safety</h3>
  * <p>Thread-safe for concurrent reads. Query-scoped nprobe overrides use ThreadLocal.
- * FileChannel positional reads are thread-safe; each read specifies an absolute offset.</p>
+ * Positional buffer reads are thread-safe; each read specifies an absolute offset.</p>
  */
 public class IvfOnDiskVectorIndexReader
     implements FilterAwareVectorIndexReader, ApproximateRadiusVectorIndexReader, NprobeAware {
@@ -82,13 +81,15 @@ public class IvfOnDiskVectorIndexReader
   // Centroids in heap for fast probe selection
   private final float[][] _centroids;
 
-  // FileChannel for random-access reads of inverted list data (avoids MappedByteBuffer 2GB limit)
-  private final RandomAccessFile _raf;
-  private final FileChannel _channel;
+  // Backing buffer for random-access reads of inverted list data. Closed by this reader only
+  // when {@code _ownsBuffer} is true (combined mmap); borrowed buffers (segment-directory owned)
+  // outlive the reader. The buffer is mapped BIG_ENDIAN to match the IVF_FLAT on-disk format.
+  private final PinotDataBuffer _buffer;
+  private final boolean _ownsBuffer;
 
   // Offsets to each inverted list in the file
   private final long[] _listOffsets;
-  // Cached list sizes (loaded at init to avoid repeated mmap reads for sizes)
+  // Cached list sizes (loaded at init to avoid repeated buffer reads for sizes)
   private final int[] _listSizes;
 
   // Observability: per-centroid access count
@@ -100,113 +101,100 @@ public class IvfOnDiskVectorIndexReader
   private final ThreadLocal<Integer> _nprobeOverride = new ThreadLocal<>();
 
   /**
-   * Opens an IVF_FLAT index file for FileChannel-based random-access reading.
+   * Opens an IVF_FLAT index from the given buffer for on-demand positional reads. The reader
+   * takes ownership of the buffer and closes it in {@link #close()}; use the four-arg overload
+   * to pass a borrowed buffer (e.g. one owned by the segment directory).
+   */
+  public IvfOnDiskVectorIndexReader(String column, PinotDataBuffer buffer, VectorIndexConfig config) {
+    this(column, buffer, config, /* ownsBuffer */ true);
+  }
+
+  /**
+   * Opens an IVF_FLAT index from the given buffer for on-demand positional reads.
+   *
+   * <p>The buffer must be mapped {@link ByteOrder#BIG_ENDIAN} (the IVF_FLAT on-disk byte order)
+   * and must remain valid for the lifetime of the reader (positional reads at query time).</p>
    *
-   * @param column   the column name
-   * @param indexDir the segment index directory
-   * @param config   the vector index configuration
+   * @param column      the column name
+   * @param buffer      the IVF_FLAT index buffer (BIG_ENDIAN)
+   * @param config      the vector index configuration
+   * @param ownsBuffer  when {@code true}, the reader closes the buffer in {@link #close()} (or
+   *                    on constructor failure). Pass {@code false} when the buffer is owned by
+   *                    the segment directory.
    */
-  public IvfOnDiskVectorIndexReader(String column, File indexDir, VectorIndexConfig config) {
+  public IvfOnDiskVectorIndexReader(String column, PinotDataBuffer buffer, VectorIndexConfig config,
+      boolean ownsBuffer) {
     _column = column;
-
-    File indexFile = SegmentDirectoryPaths.findVectorIndexIndexFile(indexDir, column, config);
-    if (indexFile == null || !indexFile.exists()) {
-      throw new IllegalStateException(
-          "Failed to find IVF index file for column: " + column + " in dir: " + indexDir);
-    }
+    _buffer = buffer;
+    _ownsBuffer = ownsBuffer;
 
     try {
-      _raf = new RandomAccessFile(indexFile, "r");
-      _channel = _raf.getChannel();
-
-      // --- Read Header via FileChannel (6 ints = 24 bytes) ---
-      ByteBuffer headerBuf = ByteBuffer.allocate(24);
-      readFully(_channel, headerBuf, 0);
-      headerBuf.flip();
-
-      int magic = headerBuf.getInt();
+      // --- Read Header (6 ints = 24 bytes) ---
+      int magic = _buffer.getInt(0);
       Preconditions.checkState(magic == IvfFlatVectorIndexCreator.MAGIC,
           "Invalid IVF magic: 0x%s, expected 0x%s",
           Integer.toHexString(magic), Integer.toHexString(IvfFlatVectorIndexCreator.MAGIC));
 
-      int version = headerBuf.getInt();
+      int version = _buffer.getInt(4);
       Preconditions.checkState(version == IvfFlatVectorIndexCreator.FORMAT_VERSION,
           "Unsupported IVF format version: %s, expected: %s",
           version, IvfFlatVectorIndexCreator.FORMAT_VERSION);
       _indexFormatVersion = version;
 
-      _dimension = headerBuf.getInt();
-      _numVectors = headerBuf.getInt();
-      _nlist = headerBuf.getInt();
-      int distanceFunctionOrdinal = headerBuf.getInt();
+      _dimension = _buffer.getInt(8);
+      _numVectors = _buffer.getInt(12);
+      _nlist = _buffer.getInt(16);
+      int distanceFunctionOrdinal = _buffer.getInt(20);
       VectorIndexConfig.VectorDistanceFunction[] allFunctions = VectorIndexConfig.VectorDistanceFunction.values();
       Preconditions.checkState(distanceFunctionOrdinal >= 0 && distanceFunctionOrdinal < allFunctions.length,
           "Invalid distance function ordinal: %s", distanceFunctionOrdinal);
       _distanceFunction = allFunctions[distanceFunctionOrdinal];
 
-      long centroidsOffset = 24;
-      ByteBuffer quantizerHeader = ByteBuffer.allocate(8);
-      readFully(_channel, quantizerHeader, 24);
-      quantizerHeader.flip();
-
-      int quantizerTypeOrdinal = quantizerHeader.getInt();
+      int quantizerTypeOrdinal = _buffer.getInt(24);
       VectorQuantizerType[] allQuantizerTypes = VectorQuantizerType.values();
       Preconditions.checkState(quantizerTypeOrdinal >= 0 && quantizerTypeOrdinal < allQuantizerTypes.length,
           "Invalid quantizer type ordinal: %s", quantizerTypeOrdinal);
       _quantizerType = allQuantizerTypes[quantizerTypeOrdinal];
 
-      int quantizerParamsLength = quantizerHeader.getInt();
+      int quantizerParamsLength = _buffer.getInt(28);
       Preconditions.checkState(quantizerParamsLength >= 0,
           "Invalid quantizer params length: %s", quantizerParamsLength);
       byte[] quantizerParams = new byte[quantizerParamsLength];
       if (quantizerParamsLength > 0) {
-        ByteBuffer quantizerParamsBuf = ByteBuffer.wrap(quantizerParams);
-        readFully(_channel, quantizerParamsBuf, 32);
+        _buffer.copyTo(32L, quantizerParams, 0, quantizerParamsLength);
       }
       _quantizer = VectorQuantizationUtils.createReadQuantizer(_quantizerType, _dimension, quantizerParams);
       _encodedBytesPerVector = _quantizer.getEncodedBytesPerVector();
-      centroidsOffset = 32L + quantizerParamsLength;
+      long centroidsOffset = 32L + quantizerParamsLength;
 
       _defaultNprobe = Math.min(DEFAULT_NPROBE, _nlist);
 
-      // --- Read Centroids into heap via FileChannel ---
-      int centroidsBytesTotal = _nlist * _dimension * Float.BYTES;
-      ByteBuffer centroidsBuf = ByteBuffer.allocate(centroidsBytesTotal);
-      readFully(_channel, centroidsBuf, centroidsOffset);
-      centroidsBuf.flip();
-
+      // --- Read Centroids into heap ---
       _centroids = new float[_nlist][_dimension];
+      long centroidPos = centroidsOffset;
       for (int c = 0; c < _nlist; c++) {
         for (int d = 0; d < _dimension; d++) {
-          _centroids[c][d] = centroidsBuf.getFloat();
+          _centroids[c][d] = _buffer.getFloat(centroidPos);
+          centroidPos += Float.BYTES;
         }
       }
 
-      // --- Read inverted list offsets from footer via FileChannel ---
+      // --- Read inverted list offsets from footer ---
       // Footer: last 8 bytes = offsetToOffsets
-      long fileSize = _channel.size();
-      ByteBuffer footerBuf = ByteBuffer.allocate(8);
-      readFully(_channel, footerBuf, fileSize - 8);
-      footerBuf.flip();
-      long offsetToOffsets = footerBuf.getLong();
-
-      ByteBuffer offsetsBuf = ByteBuffer.allocate(_nlist * Long.BYTES);
-      readFully(_channel, offsetsBuf, offsetToOffsets);
-      offsetsBuf.flip();
+      long fileSize = _buffer.size();
+      long offsetToOffsets = _buffer.getLong(fileSize - 8);
 
       _listOffsets = new long[_nlist];
+      long offsetsCursor = offsetToOffsets;
       for (int c = 0; c < _nlist; c++) {
-        _listOffsets[c] = offsetsBuf.getLong();
+        _listOffsets[c] = _buffer.getLong(offsetsCursor);
+        offsetsCursor += Long.BYTES;
       }
 
-      // --- Pre-read list sizes via FileChannel ---
+      // --- Pre-read list sizes ---
       _listSizes = new int[_nlist];
-      ByteBuffer sizeBuf = ByteBuffer.allocate(4);
       for (int c = 0; c < _nlist; c++) {
-        sizeBuf.clear();
-        readFully(_channel, sizeBuf, _listOffsets[c]);
-        sizeBuf.flip();
-        _listSizes[c] = sizeBuf.getInt();
+        _listSizes[c] = _buffer.getInt(_listOffsets[c]);
       }
 
       // --- Init observability ---
@@ -215,18 +203,18 @@ public class IvfOnDiskVectorIndexReader
         _centroidAccessCounts[c] = new AtomicLong(0);
       }
 
-      LOGGER.info("Opened IVF_ON_DISK index for column: {}: {} vectors, {} centroids, dim={}, file={}, "
+      LOGGER.info("Opened IVF_ON_DISK index for column: {}: {} vectors, {} centroids, dim={}, "
               + "formatVersion={}, quantizer={}",
-          column, _numVectors, _nlist, _dimension, indexFile.getAbsolutePath(), _indexFormatVersion, _quantizerType);
+          column, _numVectors, _nlist, _dimension, _indexFormatVersion, _quantizerType);
     } catch (Exception e) {
-      // Close resources if construction fails partway through (e.g., IllegalStateException
-      // from Preconditions.checkState is not caught by IOException alone)
-      closeQuietly();
-      if (e instanceof IOException) {
-        throw new RuntimeException(
-            "Failed to open IVF index for column: " + column + " from dir: " + indexDir, e);
+      // Close the buffer to avoid leaking the mmap when the caller never receives a reader to
+      // close — but only if we own it. Borrowed buffers (segment-directory owned) are released
+      // by their owner.
+      if (_ownsBuffer) {
+        IvfCombinedBuffers.closeQuietly(_buffer);
       }
-      throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
+      throw e instanceof RuntimeException ? (RuntimeException) e
+          : new RuntimeException("Failed to open IVF index for column: " + column, e);
     }
   }
 
@@ -309,7 +297,7 @@ public class IvfOnDiskVectorIndexReader
   }
 
   /**
-   * Reads and scans an inverted list from the file via FileChannel.
+   * Reads and scans an inverted list from the backing buffer.
    *
    * <p>Uses a ThreadLocal ByteBuffer to avoid per-call heap allocation for the list data,
    * and reuses a single float[] for reading each document vector.</p>
@@ -330,16 +318,12 @@ public class IvfOnDiskVectorIndexReader
     // Position after the listSize int
     long dataOffset = _listOffsets[centroidIdx] + 4;
 
-    // Read entire inverted list data via FileChannel: docIds (int[]) + encoded vectors
+    // Read entire inverted list data into a thread-local heap buffer: docIds (int[]) + encoded vectors
     int listBytes = listSize * (Integer.BYTES + _encodedBytesPerVector);
     ByteBuffer buf = getOrResizeThreadLocalBuffer(listBytes);
-    try {
-      readFully(_channel, buf, dataOffset);
-    } catch (IOException e) {
-      throw new RuntimeException(
-          "Failed to read inverted list for centroid " + centroidIdx + " in column: " + _column, e);
-    }
-    buf.flip();
+    _buffer.copyTo(dataOffset, buf.array(), 0, listBytes);
+    buf.position(0);
+    buf.limit(listBytes);
 
     // Read doc IDs
     int[] docIds = new int[listSize];
@@ -375,13 +359,9 @@ public class IvfOnDiskVectorIndexReader
     long dataOffset = _listOffsets[centroidIdx] + 4;
     int listBytes = listSize * (Integer.BYTES + _encodedBytesPerVector);
     ByteBuffer buf = getOrResizeThreadLocalBuffer(listBytes);
-    try {
-      readFully(_channel, buf, dataOffset);
-    } catch (IOException e) {
-      throw new RuntimeException(
-          "Failed to read inverted list for centroid " + centroidIdx + " in column: " + _column, e);
-    }
-    buf.flip();
+    _buffer.copyTo(dataOffset, buf.array(), 0, listBytes);
+    buf.position(0);
+    buf.limit(listBytes);
 
     int[] docIds = new int[listSize];
     for (int i = 0; i < listSize; i++) {
@@ -458,27 +438,6 @@ public class IvfOnDiskVectorIndexReader
     return override != null ? override : _defaultNprobe;
   }
 
-  // -----------------------------------------------------------------------
-  // I/O helpers
-  // -----------------------------------------------------------------------
-
-  /**
-   * Reads a ByteBuffer fully from the FileChannel at the given position.
-   * Unlike {@link FileChannel#read(ByteBuffer, long)}, this method retries until
-   * the buffer is completely filled or EOF is reached.
-   */
-  private static void readFully(FileChannel channel, ByteBuffer buf, long position)
-      throws IOException {
-    long pos = position;
-    while (buf.hasRemaining()) {
-      int bytesRead = channel.read(buf, pos);
-      if (bytesRead < 0) {
-        throw new IOException("Unexpected end of file at position " + pos);
-      }
-      pos += bytesRead;
-    }
-  }
-
   // -----------------------------------------------------------------------
   // Distance / centroid helpers
   // -----------------------------------------------------------------------
@@ -550,7 +509,7 @@ public class IvfOnDiskVectorIndexReader
     info.put("filteredSearches", _filteredSearches.get());
     info.put("unfilteredSearches", _unfilteredSearches.get());
     info.put("supportsPreFilter", true);
-    info.put("storageMode", "fileChannel");
+    info.put("storageMode", "pinotDataBuffer");
 
     // Compute cache warmth estimate: fraction of centroids accessed at least once
     long accessedCentroids = 0;
@@ -584,27 +543,8 @@ public class IvfOnDiskVectorIndexReader
   @Override
   public void close() throws IOException {
     clearNprobe();
-    _channel.close();
-    _raf.close();
-  }
-
-  /**
-   * Best-effort cleanup of I/O resources. Used during constructor failure to prevent resource leaks.
-   */
-  private void closeQuietly() {
-    try {
-      if (_channel != null) {
-        _channel.close();
-      }
-    } catch (Exception ignored) {
-      // best-effort
-    }
-    try {
-      if (_raf != null) {
-        _raf.close();
-      }
-    } catch (Exception ignored) {
-      // best-effort
+    if (_ownsBuffer && _buffer != null) {
+      _buffer.close();
     }
   }
 
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfPqVectorIndexReader.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfPqVectorIndexReader.java
index cb3f6473bd8..f5f7d4d8b95 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfPqVectorIndexReader.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfPqVectorIndexReader.java
@@ -20,21 +20,20 @@ package org.apache.pinot.segment.local.segment.index.readers.vector;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
-import java.io.File;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.PriorityQueue;
+import org.apache.pinot.segment.local.segment.index.vector.IvfCombinedBuffers;
 import org.apache.pinot.segment.local.segment.index.vector.IvfPqIndexFormat;
-import org.apache.pinot.segment.local.segment.index.vector.IvfPqVectorIndexCreator;
 import org.apache.pinot.segment.local.segment.index.vector.ProductQuantizer;
 import org.apache.pinot.segment.local.segment.index.vector.VectorQuantizationUtils;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
 import org.apache.pinot.segment.spi.index.reader.ApproximateRadiusVectorIndexReader;
 import org.apache.pinot.segment.spi.index.reader.FilterAwareVectorIndexReader;
 import org.apache.pinot.segment.spi.index.reader.NprobeAware;
-import org.apache.pinot.segment.spi.store.SegmentDirectoryPaths;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
 import org.roaringbitmap.buffer.ImmutableRoaringBitmap;
 import org.roaringbitmap.buffer.MutableRoaringBitmap;
 import org.slf4j.Logger;
@@ -74,26 +73,41 @@ public class IvfPqVectorIndexReader
   private final String _column;
   private final int _defaultNprobe;
   private final ThreadLocal<Integer> _nprobeOverride = new ThreadLocal<>();
+  // Backing buffer. Closed by this reader only when {@code _ownsBuffer} is true. Contents are
+  // heap-loaded at construction, so it is safe for the caller to retain ownership.
+  private final PinotDataBuffer _buffer;
+  private final boolean _ownsBuffer;
 
   /**
-   * Opens and loads an IVF_PQ index from disk.
+   * Opens and loads an IVF_PQ index from the given buffer. The reader takes ownership of the
+   * buffer and closes it in {@link #close()}; use the four-arg overload to pass a borrowed
+   * buffer (e.g. one owned by the segment directory).
+   */
+  public IvfPqVectorIndexReader(String column, PinotDataBuffer buffer, VectorIndexConfig config) {
+    this(column, buffer, config, /* ownsBuffer */ true);
+  }
+
+  /**
+   * Opens and loads an IVF_PQ index from the given buffer.
    *
-   * @param column the column name
-   * @param indexDir the segment index directory
-   * @param config vector index configuration
+   * @param column      the column name
+   * @param buffer      the IVF_PQ index buffer (mapped or in-memory)
+   * @param config      vector index configuration
+   * @param ownsBuffer  when {@code true}, the reader closes the buffer in {@link #close()} (or
+   *                    on constructor failure). Pass {@code false} when the buffer is owned by
+   *                    the segment directory (typed entry inside {@code columns.psf}).
    */
-  public IvfPqVectorIndexReader(String column, File indexDir, VectorIndexConfig config) {
+  public IvfPqVectorIndexReader(String column, PinotDataBuffer buffer, VectorIndexConfig config,
+      boolean ownsBuffer) {
     _column = column;
+    _buffer = buffer;
+    _ownsBuffer = ownsBuffer;
 
-    File indexFile = SegmentDirectoryPaths.findVectorIndexIndexFile(indexDir, column, config);
-    if (indexFile == null || !indexFile.exists()) {
-      throw new IllegalStateException(
-          "Failed to find IVF_PQ index file for column: " + column + " in dir: " + indexDir
-              + ". Expected file: " + column + IvfPqVectorIndexCreator.INDEX_FILE_EXTENSION);
-    }
-
+    // The reader takes ownership of the buffer. If construction throws (bad magic, EOF,
+    // unsupported format version, etc.), release the buffer here so the mmap doesn't leak —
+    // the caller never sees a reader instance to close.
     try {
-      IvfPqIndexFormat.IndexData indexData = IvfPqIndexFormat.read(indexFile);
+      IvfPqIndexFormat.IndexData indexData = IvfPqIndexFormat.read(buffer);
       _dimension = indexData.getDimension();
       _numVectors = indexData.getNumVectors();
       _nlist = indexData.getNlist();
@@ -135,8 +149,17 @@ public class IvfPqVectorIndexReader
       LOGGER.info("Loaded IVF_PQ index for column: {}: {} vectors, {} centroids, dim={}, pqM={}, pqNbits={}, "
               + "nprobe={}, distance={}", column, _numVectors, _nlist, _dimension, _pqM, _pqNbits, _defaultNprobe,
           _distanceFunction);
-    } catch (IOException e) {
-      throw new RuntimeException("Failed to load IVF_PQ index for column: " + column + " from file: " + indexFile, e);
+    } catch (Exception e) {
+      // Close the buffer to avoid leaking the mmap when the caller never receives a reader to
+      // close — but only if we own it. Borrowed buffers (segment-directory owned) are released
+      // by their owner.
+      if (_ownsBuffer) {
+        IvfCombinedBuffers.closeQuietly(_buffer);
+      }
+      if (e instanceof RuntimeException) {
+        throw (RuntimeException) e;
+      }
+      throw new RuntimeException("Failed to load IVF_PQ index for column: " + column, e);
     }
   }
 
@@ -358,6 +381,9 @@ public class IvfPqVectorIndexReader
   public void close()
       throws IOException {
     clearNprobe();
+    if (_ownsBuffer && _buffer != null) {
+      _buffer.close();
+    }
   }
 
   private int[] findClosestCentroids(float[] query, int n) {
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfCombinedBuffers.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfCombinedBuffers.java
new file mode 100644
index 00000000000..855b9a44454
--- /dev/null
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfCombinedBuffers.java
@@ -0,0 +1,116 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.segment.local.segment.index.vector;
+
+import com.google.common.base.Preconditions;
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteOrder;
+import javax.annotation.Nullable;
+import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
+import org.apache.pinot.segment.spi.store.SegmentDirectoryPaths;
+
+
+/// Canonical helper for opening an IVF combined index file as a {@link PinotDataBuffer}.
+///
+/// Used by the production reader factory ({@code VectorIndexType.ReaderFactory}) and by tests
+/// and benchmarks that instantiate IVF readers directly against a temp directory. Keeping one
+/// implementation guarantees identical file resolution, byte order, mmap mode, and ownership
+/// semantics across all callers, and makes a future consolidation (when IVF moves into the
+/// combined-form segment index file) a single point of change.
+///
+/// **Ownership:** the returned buffer is owned by the caller (typically the IVF reader,
+/// which closes it in its own {@code close()}).
+///
+/// **Byte order:** the buffer is mapped {@link ByteOrder#BIG_ENDIAN} to match the IVF_FLAT
+/// on-disk format. IVF_PQ handles its own little-endian payload via stream wrappers inside
+/// {@link IvfPqIndexFormat}, so the buffer-level order is irrelevant for IVF_PQ but is consistent
+/// with IVF_FLAT for symmetry.
+public final class IvfCombinedBuffers {
+
+  private IvfCombinedBuffers() {
+  }
+
+  /// Resolves the IVF index sidecar file for {@code column} under {@code segmentDir} and maps
+  /// the full file as a read-only {@link PinotDataBuffer}.
+  ///
+  /// @param segmentDir segment directory containing the sidecar file
+  /// @param column     column name; used to locate the sidecar file
+  /// @param config     vector index configuration; used to determine the file extension
+  /// @param ownerLabel short owner label included in {@code PinotDataBuffer} accounting
+  ///                   (e.g. {@code "vector-ivf_flat"}, {@code "test-vector"}, {@code "bench-vector"});
+  ///                   used only for diagnostics
+  /// @return a {@code PinotDataBuffer} holding the full sidecar file contents; the caller takes ownership
+  ///         and is responsible for closing it
+  /// @throws IllegalStateException if the sidecar file is missing
+  /// @throws RuntimeException       if mmap fails
+  public static PinotDataBuffer mapCombined(File segmentDir, String column, VectorIndexConfig config,
+      String ownerLabel) {
+    Preconditions.checkArgument(segmentDir != null, "segmentDir must not be null");
+    Preconditions.checkArgument(column != null && !column.isEmpty(), "column must be non-empty");
+    Preconditions.checkArgument(config != null, "config must not be null");
+    Preconditions.checkArgument(ownerLabel != null && !ownerLabel.isEmpty(), "ownerLabel must be non-empty");
+
+    File indexFile = SegmentDirectoryPaths.findVectorIndexIndexFile(segmentDir, column, config);
+    if (indexFile == null || !indexFile.exists()) {
+      throw new IllegalStateException(
+          "Vector index sidecar file not found under " + segmentDir + " for column " + column);
+    }
+    try {
+      return PinotDataBuffer.mapFile(indexFile, /* readOnly */ true, 0, indexFile.length(),
+          ByteOrder.BIG_ENDIAN, ownerLabel + "-" + column);
+    } catch (IOException e) {
+      throw new RuntimeException(
+          "Failed to map vector index sidecar file " + indexFile + " for column " + column, e);
+    }
+  }
+
+  /// Convenience overload for callers that already hold the resolved {@link File} (e.g. the
+  /// production reader factory). Maps the given file directly.
+  public static PinotDataBuffer mapCombinedFile(File indexFile, String column, String ownerLabel) {
+    Preconditions.checkArgument(indexFile != null, "indexFile must not be null");
+    Preconditions.checkArgument(column != null && !column.isEmpty(), "column must be non-empty");
+    Preconditions.checkArgument(ownerLabel != null && !ownerLabel.isEmpty(), "ownerLabel must be non-empty");
+    if (!indexFile.exists()) {
+      throw new IllegalStateException("Vector index sidecar file does not exist: " + indexFile);
+    }
+    try {
+      return PinotDataBuffer.mapFile(indexFile, /* readOnly */ true, 0, indexFile.length(),
+          ByteOrder.BIG_ENDIAN, ownerLabel + "-" + column);
+    } catch (IOException e) {
+      throw new RuntimeException(
+          "Failed to map vector index sidecar file " + indexFile + " for column " + column, e);
+    }
+  }
+
+  /// Best-effort close of a {@link PinotDataBuffer}. Used by IVF readers during constructor
+  /// failure to release the mmap when the caller never sees a reader instance to close. Swallows
+  /// any close-time exception so the original cause propagates unmasked.
+  public static void closeQuietly(@Nullable PinotDataBuffer buffer) {
+    if (buffer == null) {
+      return;
+    }
+    try {
+      buffer.close();
+    } catch (Exception ignored) {
+      // best-effort
+    }
+  }
+}
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfFlatVectorIndexCreator.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfFlatVectorIndexCreator.java
index 2613186b6b8..b78b47ebb61 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfFlatVectorIndexCreator.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfFlatVectorIndexCreator.java
@@ -116,6 +116,13 @@ public class IvfFlatVectorIndexCreator implements VectorIndexCreator {
   private final long _trainingSeed;
   private final VectorIndexConfig.VectorDistanceFunction _distanceFunction;
   private final VectorQuantizerType _quantizerType;
+  /**
+   * When {@code true}, {@link #seal()} writes to the combined-form extension
+   * ({@code .vector.ivfflat.combined.index}) instead of the legacy file extension. The V2→V3
+   * format converter recognises the combined extension and packs the bytes into {@code
+   * columns.psf} via the standard {@code copyIndexIfExists} path.
+   */
+  private final boolean _storeInSegmentFile;
 
   /** All vectors collected during add(), indexed by docId (ordinal). */
   private final List<float[]> _vectors = new ArrayList<>();
@@ -146,13 +153,15 @@ public class IvfFlatVectorIndexCreator implements VectorIndexCreator {
         ? Long.parseLong(properties.get("trainingSeed"))
         : System.nanoTime();
     _quantizerType = VectorQuantizationUtils.resolveQuantizerType(properties);
+    _storeInSegmentFile = config.isStoreInSegmentFile();
 
     Preconditions.checkArgument(_dimension > 0, "Vector dimension must be positive, got: %s", _dimension);
     Preconditions.checkArgument(_nlist > 0, "nlist must be positive, got: %s", _nlist);
 
     LOGGER.info("Creating IVF_FLAT index for column: {} in dir: {}, dimension={}, nlist={}, distance={}, "
-            + "quantizer={}",
-        column, indexDir.getAbsolutePath(), _dimension, _nlist, _distanceFunction, _quantizerType);
+            + "quantizer={}, storeInSegmentFile={}",
+        column, indexDir.getAbsolutePath(), _dimension, _nlist, _distanceFunction, _quantizerType,
+        _storeInSegmentFile);
   }
 
   @Override
@@ -493,7 +502,10 @@ public class IvfFlatVectorIndexCreator implements VectorIndexCreator {
   private void writeIndex(float[][] centroids, int[] assignments, List<Integer>[] invertedLists, int effectiveNlist,
       VectorQuantizer quantizer)
       throws IOException {
-    File indexFile = new File(_indexDir, _column + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+    String extension = _storeInSegmentFile
+        ? V1Constants.Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION
+        : V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION;
+    File indexFile = new File(_indexDir, _column + extension);
     int numVectors = _vectors.size();
     byte[] quantizerParams = VectorQuantizationUtils.serializeQuantizerParams(quantizer);
     int encodedBytesPerVector = quantizer.getEncodedBytesPerVector();
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfPqIndexFormat.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfPqIndexFormat.java
index 762f4e3d9a5..0e75c977a68 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfPqIndexFormat.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfPqIndexFormat.java
@@ -31,12 +31,15 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.Arrays;
 import java.util.List;
 import org.apache.pinot.segment.spi.V1Constants;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
+import org.apache.pinot.segment.spi.memory.DataBufferPinotInputStream;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
 
 
 /**
@@ -93,28 +96,46 @@ public final class IvfPqIndexFormat {
   public static IndexData read(File indexFile)
       throws IOException {
     try (BufferedInputStream bufferedIn = new BufferedInputStream(new FileInputStream(indexFile), 1 << 16)) {
-      byte[] magicBytes = readRequiredBytes(bufferedIn, MAGIC_BYTES.length, "magic");
-      Preconditions.checkState(Arrays.equals(magicBytes, MAGIC_BYTES), "Invalid IVF_PQ magic: %s, expected %s",
-          Arrays.toString(magicBytes), Arrays.toString(MAGIC_BYTES));
-
-      byte[] versionBytes = readRequiredBytes(bufferedIn, Integer.BYTES, "format version");
-      int legacyBigEndianVersion = ByteBuffer.wrap(versionBytes).order(ByteOrder.BIG_ENDIAN).getInt();
-      int littleEndianVersion = ByteBuffer.wrap(versionBytes).order(ByteOrder.LITTLE_ENDIAN).getInt();
-      if (legacyBigEndianVersion == LEGACY_BIG_ENDIAN_FORMAT_VERSION) {
-        try (DataInputStream in = new DataInputStream(bufferedIn)) {
-          return readPayload(in, LEGACY_BIG_ENDIAN_FORMAT_VERSION);
-        }
-      }
-      if (littleEndianVersion == FORMAT_VERSION) {
-        try (LittleEndianDataInputStream in = new LittleEndianDataInputStream(bufferedIn)) {
-          return readPayload(in, FORMAT_VERSION);
-        }
-      }
-      throw new IllegalStateException(String.format(
-          "Unsupported IVF_PQ format version: headerBytes=%s, legacyBigEndian=%s, littleEndian=%s, supported=[%s,%s]",
-          Arrays.toString(versionBytes), legacyBigEndianVersion, littleEndianVersion,
-          LEGACY_BIG_ENDIAN_FORMAT_VERSION, FORMAT_VERSION));
+      return readFromStream(bufferedIn);
+    }
+  }
+
+  /**
+   * Reads an IVF_PQ index from a {@link PinotDataBuffer}. Used by the buffer-based reader factory
+   * (combined mmap today; column-buffer in tiered/storeInSegment scenarios).
+   *
+   * <p>The caller retains ownership of {@code buffer}; this method does not close it.</p>
+   */
+  public static IndexData read(PinotDataBuffer buffer)
+      throws IOException {
+    try (DataBufferPinotInputStream pinotIn = new DataBufferPinotInputStream(buffer)) {
+      return readFromStream(pinotIn);
+    }
+  }
+
+  private static IndexData readFromStream(InputStream in)
+      throws IOException {
+    byte[] magicBytes = readRequiredBytes(in, MAGIC_BYTES.length, "magic");
+    Preconditions.checkState(Arrays.equals(magicBytes, MAGIC_BYTES), "Invalid IVF_PQ magic: %s, expected %s",
+        Arrays.toString(magicBytes), Arrays.toString(MAGIC_BYTES));
+
+    byte[] versionBytes = readRequiredBytes(in, Integer.BYTES, "format version");
+    int legacyBigEndianVersion = ByteBuffer.wrap(versionBytes).order(ByteOrder.BIG_ENDIAN).getInt();
+    int littleEndianVersion = ByteBuffer.wrap(versionBytes).order(ByteOrder.LITTLE_ENDIAN).getInt();
+    if (legacyBigEndianVersion == LEGACY_BIG_ENDIAN_FORMAT_VERSION) {
+      // Do not close the DataInputStream wrapper: it would close the underlying stream, which the
+      // caller owns (BufferedInputStream over the file, or DataBufferPinotInputStream over the buffer).
+      DataInputStream dataIn = new DataInputStream(in);
+      return readPayload(dataIn, LEGACY_BIG_ENDIAN_FORMAT_VERSION);
+    }
+    if (littleEndianVersion == FORMAT_VERSION) {
+      LittleEndianDataInputStream dataIn = new LittleEndianDataInputStream(in);
+      return readPayload(dataIn, FORMAT_VERSION);
     }
+    throw new IllegalStateException(String.format(
+        "Unsupported IVF_PQ format version: headerBytes=%s, legacyBigEndian=%s, littleEndian=%s, supported=[%s,%s]",
+        Arrays.toString(versionBytes), legacyBigEndianVersion, littleEndianVersion,
+        LEGACY_BIG_ENDIAN_FORMAT_VERSION, FORMAT_VERSION));
   }
 
   private static void writePayload(DataOutput out, int dimension, int numVectors, int effectiveNlist, int pqM,
@@ -280,7 +301,7 @@ public final class IvfPqIndexFormat {
         distanceFunction, centroids, codebooks, listDocIds, listCodes, subvectorLengths);
   }
 
-  private static byte[] readRequiredBytes(BufferedInputStream in, int length, String description)
+  private static byte[] readRequiredBytes(InputStream in, int length, String description)
       throws IOException {
     byte[] bytes = in.readNBytes(length);
     if (bytes.length != length) {
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfPqVectorIndexCreator.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfPqVectorIndexCreator.java
index 60609ac53ca..7fcb090d3ae 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfPqVectorIndexCreator.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/IvfPqVectorIndexCreator.java
@@ -31,6 +31,7 @@ import java.util.Map;
 import java.util.Random;
 import javax.annotation.Nullable;
 import org.apache.commons.io.FileUtils;
+import org.apache.pinot.segment.spi.V1Constants;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexCreator;
 import org.slf4j.Logger;
@@ -59,9 +60,19 @@ public class IvfPqVectorIndexCreator implements VectorIndexCreator {
   /** Current file format version. */
   public static final int FORMAT_VERSION = IvfPqIndexFormat.FORMAT_VERSION;
 
-  /** On-disk file extension for the IVF_PQ index. */
+  /**
+   * On-disk file extension for the legacy IVF_PQ sidecar file (when {@code storeInSegmentFile=false}).
+   */
   public static final String INDEX_FILE_EXTENSION = IvfPqIndexFormat.INDEX_FILE_EXTENSION;
 
+  /**
+   * On-disk file extension for the combined-form IVF_PQ sidecar file produced when
+   * {@code storeInSegmentFile=true}. The V2→V3 converter packs the bytes into {@code columns.psf}
+   * via the standard {@code copyIndexIfExists} path and removes the file.
+   */
+  public static final String COMBINED_INDEX_FILE_EXTENSION =
+      V1Constants.Indexes.VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION;
+
   private final String _column;
   private final File _indexDir;
   private final int _dimension;
@@ -71,6 +82,7 @@ public class IvfPqVectorIndexCreator implements VectorIndexCreator {
   private final int _trainSampleSize;
   private final long _trainingSeed;
   private final VectorIndexConfig.VectorDistanceFunction _distanceFunction;
+  private final boolean _storeInSegmentFile;
 
   // Spill file for raw vectors: sequential float arrays, _dimension floats per vector.
   private final File _spillFile;
@@ -122,13 +134,19 @@ public class IvfPqVectorIndexCreator implements VectorIndexCreator {
     _reservoirRng = new Random(_trainingSeed);
     _numVectors = 0;
     _spillOutClosed = false;
+    _storeInSegmentFile = config.isStoreInSegmentFile();
 
     _spillFile = new File(indexDir, column + INDEX_FILE_EXTENSION + ".spill");
     _spillOut = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(_spillFile), 1 << 16));
 
     LOGGER.info("Creating IVF_PQ index for column: {} in dir: {}, dimension={}, nlist={}, pqM={}, pqNbits={}, "
-            + "distance={}", column, indexDir.getAbsolutePath(), _dimension, _nlist, _pqM, _pqNbits,
-        _distanceFunction);
+            + "distance={}, storeInSegmentFile={}", column, indexDir.getAbsolutePath(), _dimension, _nlist, _pqM,
+        _pqNbits, _distanceFunction, _storeInSegmentFile);
+  }
+
+  /** Returns the on-disk extension this creator will write to, based on the flag. */
+  private String outputExtension() {
+    return _storeInSegmentFile ? COMBINED_INDEX_FILE_EXTENSION : INDEX_FILE_EXTENSION;
   }
 
   @Override
@@ -186,7 +204,7 @@ public class IvfPqVectorIndexCreator implements VectorIndexCreator {
         for (int m = 0; m < _pqM; m++) {
           emptyCodebooks[m] = new float[0][subvectorLengths[m]];
         }
-        IvfPqIndexFormat.write(new File(_indexDir, _column + INDEX_FILE_EXTENSION), _dimension, 0, _pqM, _pqNbits,
+        IvfPqIndexFormat.write(new File(_indexDir, _column + outputExtension()), _dimension, 0, _pqM, _pqNbits,
             _trainSampleSize, _trainingSeed, _distanceFunction, new float[0][0], emptyCodebooks, subvectorLengths,
             new int[0][], new byte[0][]);
         success = true;
@@ -266,7 +284,7 @@ public class IvfPqVectorIndexCreator implements VectorIndexCreator {
         }
       }
 
-      IvfPqIndexFormat.write(new File(_indexDir, _column + INDEX_FILE_EXTENSION), _dimension, _numVectors, _pqM,
+      IvfPqIndexFormat.write(new File(_indexDir, _column + outputExtension()), _dimension, _numVectors, _pqM,
           _pqNbits, _trainSampleSize, _trainingSeed, _distanceFunction, centroids, codebooks, subvectorLengths,
           listDocIds, listCodes);
       LOGGER.info("IVF_PQ index sealed for column: {}. {} vectors across {} centroids.", _column, _numVectors,
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/VectorIndexType.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/VectorIndexType.java
index f518f417523..eb27c0e63a2 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/VectorIndexType.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/index/vector/VectorIndexType.java
@@ -31,6 +31,7 @@ import org.apache.pinot.segment.local.segment.index.readers.vector.HnswVectorInd
 import org.apache.pinot.segment.local.segment.index.readers.vector.IvfFlatVectorIndexReader;
 import org.apache.pinot.segment.local.segment.index.readers.vector.IvfOnDiskVectorIndexReader;
 import org.apache.pinot.segment.local.segment.index.readers.vector.IvfPqVectorIndexReader;
+import org.apache.pinot.segment.local.segment.store.VectorIndexUtils;
 import org.apache.pinot.segment.spi.ColumnMetadata;
 import org.apache.pinot.segment.spi.V1Constants;
 import org.apache.pinot.segment.spi.creator.IndexCreationContext;
@@ -49,6 +50,7 @@ import org.apache.pinot.segment.spi.index.creator.VectorIndexCreator;
 import org.apache.pinot.segment.spi.index.mutable.MutableIndex;
 import org.apache.pinot.segment.spi.index.mutable.provider.MutableIndexContext;
 import org.apache.pinot.segment.spi.index.reader.VectorIndexReader;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
 import org.apache.pinot.segment.spi.store.SegmentDirectory;
 import org.apache.pinot.segment.spi.store.SegmentDirectoryPaths;
 import org.apache.pinot.spi.config.table.FieldConfig;
@@ -59,20 +61,16 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 
-/**
- * Index type for vector columns.
- *
- * <p>Supports multiple vector index backends via the {@link VectorBackendType} enum.
- * Currently supported backends:
- * <ul>
- *   <li>{@link VectorBackendType#HNSW} - Lucene-based HNSW graph index (mutable and immutable segments)</li>
- *   <li>{@link VectorBackendType#IVF_FLAT} - Inverted file with flat vectors (immutable segments only)</li>
- *   <li>{@link VectorBackendType#IVF_PQ} - Inverted file with residual product quantization (immutable only)</li>
- * </ul>
- *
- * <p>If the {@code vectorIndexType} field is absent in the config, it defaults to HNSW for
- * backward compatibility with existing table configurations.</p>
- */
+/// Index type for vector columns.
+///
+/// Supports multiple vector index backends via the {@link VectorBackendType} enum.
+/// Currently supported backends:
+///   - {@link VectorBackendType#HNSW} - Lucene-based HNSW graph index (mutable and immutable segments)
+///   - {@link VectorBackendType#IVF_FLAT} - Inverted file with flat vectors (immutable segments only)
+///   - {@link VectorBackendType#IVF_PQ} - Inverted file with residual product quantization (immutable only)
+///
+/// If the {@code vectorIndexType} field is absent in the config, it defaults to HNSW for
+/// backward compatibility with existing table configurations.
 public class VectorIndexType extends AbstractIndexType<VectorIndexConfig, VectorIndexReader, VectorIndexCreator> {
   private static final Logger LOGGER = LoggerFactory.getLogger(VectorIndexType.class);
   public static final String INDEX_DISPLAY_NAME = "vector";
@@ -175,7 +173,9 @@ public class VectorIndexType extends AbstractIndexType<VectorIndexConfig, Vector
   @Override
   public List<String> getFileExtensions(@Nullable ColumnMetadata columnMetadata) {
     // NOTE: IVF_ON_DISK intentionally reuses the IVF_FLAT file extension since it reads the
-    // same on-disk format via FileChannel rather than memory-mapped I/O.
+    // same on-disk format. The `*.combined.index` entries are the transient single-file
+    // form written by the IVF creator when storeInSegmentFile=true; the V2→V3 converter
+    // consumes them via the standard copyIndexIfExists loop and packs the bytes into columns.psf.
     return List.of(V1Constants.Indexes.VECTOR_INDEX_FILE_EXTENSION,
         V1Constants.Indexes.VECTOR_HNSW_INDEX_FILE_EXTENSION,
         V1Constants.Indexes.VECTOR_V99_INDEX_FILE_EXTENSION,
@@ -183,12 +183,13 @@ public class VectorIndexType extends AbstractIndexType<VectorIndexConfig, Vector
         V1Constants.Indexes.VECTOR_V912_INDEX_FILE_EXTENSION,
         V1Constants.Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION,
         V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION,
-        V1Constants.Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION);
+        V1Constants.Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION,
+        V1Constants.Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION,
+        V1Constants.Indexes.VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION,
+        V1Constants.Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION);
   }
 
-  /**
-   * Reader factory that dispatches to the correct vector index reader based on backend type.
-   */
+  /// Reader factory that dispatches to the correct vector index reader based on backend type.
   private static class ReaderFactory implements IndexReaderFactory<VectorIndexReader> {
 
     public static final VectorIndexType.ReaderFactory INSTANCE = new VectorIndexType.ReaderFactory();
@@ -210,25 +211,96 @@ public class VectorIndexType extends AbstractIndexType<VectorIndexConfig, Vector
         return null;
       }
       VectorBackendType backendType = indexConfig.resolveBackendType();
-      File configuredIndexFile =
-          SegmentDirectoryPaths.findVectorIndexIndexFile(segmentDir, metadata.getColumnName(), indexConfig);
-      if (configuredIndexFile == null || !configuredIndexFile.exists()) {
-        LOGGER.warn("Skipping vector index reader for column: {} because configured backend {} does not have a "
-                + "matching on-disk artifact in segment: {}",
-            metadata.getColumnName(), backendType, segmentDir);
-        return null;
+      String column = metadata.getColumnName();
+
+      if (backendType == VectorBackendType.HNSW) {
+        // Combined form: load the HNSW index from the typed entry inside columns.psf when one
+        // actually exists. Legacy-directory-first: if the on-disk HNSW artifact is still the Lucene
+        // directory (a V3 segment the handler has not migrated yet, or a V1/V2 segment backed by
+        // FilePerIndexDirectory), read it directly and skip the columns.psf probe entirely —
+        // FilePerIndexDirectory would resolve getIndexFor to that directory and fail to map it
+        // (not a regular file), killing the load before any fallback could run. This keeps
+        // storeInSegmentFile=true rolling-upgrade-safe for existing HNSW segments. The probed
+        // buffer is owned by the segment directory — this reader must not close it.
+        if (indexConfig.isStoreInSegmentFile()) {
+          File onDiskHnsw = SegmentDirectoryPaths.findVectorIndexIndexFile(segmentDir, column,
+              VectorBackendType.HNSW);
+          if (onDiskHnsw == null || !onDiskHnsw.isDirectory()) {
+            PinotDataBuffer buffer;
+            try {
+              buffer = VectorIndexUtils.getConsolidatedVectorEntry(segmentReader, column);
+            } catch (IOException e) {
+              throw new RuntimeException(
+                  "Failed to read consolidated HNSW vector index from columns.psf for column: " + column, e);
+            }
+            if (buffer != null) {
+              return new HnswVectorIndexReader(column, buffer, metadata.getTotalDocs(), indexConfig);
+            }
+            // This branch is only reachable when no legacy Lucene directory exists either (the
+            // gate above short-circuits to the directory when one is present), so the legacy read
+            // below is expected to fail — surface the real state to the operator.
+            LOGGER.warn("storeInSegmentFile=true but neither a consolidated HNSW entry in columns.psf nor a legacy "
+                + "Lucene directory was found for column: {} in segment: {} (on-disk artifact: {}); attempting the "
+                + "legacy directory read path", column, segmentDir, onDiskHnsw);
+          }
+        }
+        // Legacy path: load the HNSW index from the Lucene directory on disk.
+        return new HnswVectorIndexReader(column, segmentDir, metadata.getTotalDocs(), indexConfig);
+      }
+
+      // IVF backends accept a PinotDataBuffer that comes from one of two places:
+      //   - the consolidated typed entry inside columns.psf (storeInSegmentFile=true, post-absorb);
+      //   - an on-disk sidecar/combined file (storeInSegmentFile=false, OR =true before the handler
+      //     has absorbed a pre-existing legacy sidecar into columns.psf).
+      // Ownership follows the source: a columns.psf buffer is owned by the segment directory and the
+      // reader must NOT close it; a sidecar mmap buffer is owned by the reader.
+      PinotDataBuffer buffer = null;
+      if (indexConfig.isStoreInSegmentFile()) {
+        try {
+          buffer = VectorIndexUtils.getConsolidatedVectorEntry(segmentReader, column);
+        } catch (IOException e) {
+          throw new RuntimeException(
+              "Failed to read consolidated vector index from columns.psf for column: " + column, e);
+        }
+      }
+      boolean ownsBuffer;
+      if (buffer != null) {
+        // Consolidated entry inside columns.psf — owned by the segment directory.
+        ownsBuffer = false;
+      } else {
+        // Fall back to the on-disk artifact. For storeInSegmentFile=true this keeps the index usable
+        // while a legacy sidecar still awaits absorption (mirrors the HNSW path above, which falls
+        // back to its Lucene directory) instead of silently disabling the index and forcing an exact
+        // scan until migration completes.
+        File configuredIndexFile = SegmentDirectoryPaths.findVectorIndexIndexFile(segmentDir, column, indexConfig);
+        if (configuredIndexFile == null || !configuredIndexFile.exists()) {
+          LOGGER.warn("Skipping vector index reader for column: {} because backend {} has neither a consolidated "
+              + "columns.psf entry nor a matching on-disk artifact in segment: {}", column, backendType, segmentDir);
+          return null;
+        }
+        buffer = IvfCombinedBuffers.mapCombinedFile(configuredIndexFile, column,
+            "vector-" + backendType.name().toLowerCase());
+        // Sidecar mmap buffer — owned by the reader.
+        ownsBuffer = true;
       }
 
       switch (backendType) {
-        case HNSW:
-          return new HnswVectorIndexReader(metadata.getColumnName(), segmentDir, metadata.getTotalDocs(), indexConfig);
         case IVF_FLAT:
-          return new IvfFlatVectorIndexReader(metadata.getColumnName(), segmentDir, indexConfig);
+          return new IvfFlatVectorIndexReader(column, buffer, indexConfig, ownsBuffer);
         case IVF_PQ:
-          return new IvfPqVectorIndexReader(metadata.getColumnName(), segmentDir, indexConfig);
+          return new IvfPqVectorIndexReader(column, buffer, indexConfig, ownsBuffer);
         case IVF_ON_DISK:
-          return new IvfOnDiskVectorIndexReader(metadata.getColumnName(), segmentDir, indexConfig);
+          return new IvfOnDiskVectorIndexReader(column, buffer, indexConfig, ownsBuffer);
         default:
+          // Close the buffer only if we own it (a sidecar mmap). A columns.psf buffer is owned by the
+          // segment directory and must not be closed here.
+          if (ownsBuffer) {
+            try {
+              buffer.close();
+            } catch (IOException ignored) {
+              // best-effort cleanup; surface the original "unsupported" error.
+            }
+          }
           throw new IllegalStateException("Unsupported vector backend type: " + backendType);
       }
     }
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/store/FilePerIndexDirectory.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/store/FilePerIndexDirectory.java
index a597ef1aabc..5cc984bcec7 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/store/FilePerIndexDirectory.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/store/FilePerIndexDirectory.java
@@ -39,6 +39,13 @@ import org.apache.pinot.spi.utils.ReadMode;
 
 
 class FilePerIndexDirectory extends ColumnIndexDirectory {
+  /// Suffix of the {@link IllegalArgumentException} message thrown when {@code getIndexFor} resolves
+  /// an on-disk artifact that is a directory (e.g. a legacy HNSW/text Lucene directory) rather than
+  /// a mappable regular file. {@code VectorIndexUtils#getConsolidatedVectorEntry} matches against
+  /// this constant (same package) to treat that case as "no consolidated entry" instead of failing
+  /// the caller — keep the precondition message wired to it so the two sides cannot drift.
+  static final String NOT_A_REGULAR_FILE_MESSAGE_SUFFIX = " must be a regular file";
+
   private final File _segmentDirectory;
   private SegmentMetadataImpl _segmentMetadata;
   private final ReadMode _readMode;
@@ -144,9 +151,11 @@ class FilePerIndexDirectory extends ColumnIndexDirectory {
 
     File file = getFileFor(key._name, key._type);
     if (!file.exists()) {
+      // Same "absent index" signal as SingleFileIndexDirectory; share its prefix so the
+      // VectorIndexUtils#getConsolidatedVectorEntry match stays valid for V1/V2-backed readers too.
       throw new RuntimeException(
-          "Could not find index for column: " + key._name + ", type: " + key._type + ", segment: " + _segmentDirectory
-              .toString());
+          SingleFileIndexDirectory.INDEX_NOT_FOUND_MESSAGE_PREFIX + ": " + key._name + ", type: " + key._type
+              + ", segment: " + _segmentDirectory.toString());
     }
     PinotDataBuffer buffer = mapForReads(file, key._type.getId() + ".reader");
     _indexBuffers.put(key, buffer);
@@ -201,7 +210,7 @@ class FilePerIndexDirectory extends ColumnIndexDirectory {
     Preconditions.checkNotNull(file);
     Preconditions.checkNotNull(context);
     Preconditions.checkArgument(file.exists(), "File: " + file + " must exist");
-    Preconditions.checkArgument(file.isFile(), "File: " + file + " must be a regular file");
+    Preconditions.checkArgument(file.isFile(), "File: " + file + NOT_A_REGULAR_FILE_MESSAGE_SUFFIX);
     String allocationContext = allocationContext(file, context);
 
     // Backward-compatible: index file is always big-endian
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/store/SingleFileIndexDirectory.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/store/SingleFileIndexDirectory.java
index 19119bcc940..998a3ac2cdd 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/store/SingleFileIndexDirectory.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/store/SingleFileIndexDirectory.java
@@ -79,6 +79,13 @@ class SingleFileIndexDirectory extends ColumnIndexDirectory {
   private static final long MAGIC_MARKER = 0xdeadbeefdeafbeadL;
   private static final int MAGIC_MARKER_SIZE_BYTES = 8;
 
+  /// Prefix of the {@link RuntimeException} message thrown when a requested index is absent from the
+  /// segment directory. Single source of truth: {@link FilePerIndexDirectory} reuses it for the same
+  /// signal, and {@code VectorIndexUtils#getConsolidatedVectorEntry} matches against it (in the same
+  /// package) to distinguish "no consolidated entry yet" from a genuine failure. Keep them wired to
+  /// this constant rather than re-typing the literal so the produce/match sides cannot drift apart.
+  static final String INDEX_NOT_FOUND_MESSAGE_PREFIX = "Could not find index for column";
+
   // Max size of buffer we want to allocate
   // ByteBuffer limits the size to 2GB - (some platform dependent size)
   // This breaks the abstraction with PinotDataBuffer....a workaround for
@@ -160,8 +167,11 @@ class SingleFileIndexDirectory extends ColumnIndexDirectory {
     if (type == StandardIndexes.text() && TextIndexUtils.hasTextIndex(_segmentDirectory, column)) {
       return true;
     }
-    if (type == StandardIndexes.vector()) {
-      return VectorIndexUtils.hasVectorIndex(_segmentDirectory, column);
+    // Vector index may live either as a combined file (legacy / storeInSegmentFile=false) or as
+    // a typed entry inside columns.psf (storeInSegmentFile=true). Check both — mirror the text
+    // pattern of "combined OR _columnEntries".
+    if (type == StandardIndexes.vector() && VectorIndexUtils.hasVectorIndex(_segmentDirectory, column)) {
+      return true;
     }
     IndexKey key = new IndexKey(column, type);
     return _columnEntries.containsKey(key);
@@ -172,7 +182,7 @@ class SingleFileIndexDirectory extends ColumnIndexDirectory {
     IndexEntry entry = _columnEntries.get(key);
     if (entry == null || entry._buffer == null) {
       throw new RuntimeException(
-          "Could not find index for column: " + column + ", type: " + type + ", segment: " + _segmentDirectory
+          INDEX_NOT_FOUND_MESSAGE_PREFIX + ": " + column + ", type: " + type + ", segment: " + _segmentDirectory
               .toString());
     }
     return entry._buffer;
@@ -502,9 +512,12 @@ class SingleFileIndexDirectory extends ColumnIndexDirectory {
     if (indexType == StandardIndexes.text()) {
       TextIndexUtils.cleanupTextIndex(_segmentDirectory, columnName);
     }
+    // Vector index can live as a combined file and / or as a typed entry in columns.psf;
+    // clean both. The early-return that was here previously left the columns.psf entry
+    // dangling whenever a consolidated vector index needed to be removed (e.g. rebuild on
+    // backend-type change).
     if (indexType == StandardIndexes.vector()) {
       VectorIndexUtils.cleanupVectorIndex(_segmentDirectory, columnName);
-      return;
     }
     // Only remember to cleanup indices upon close(), if any existing
     // index gets marked for removal.
@@ -525,12 +538,14 @@ class SingleFileIndexDirectory extends ColumnIndexDirectory {
       }
     }
     if (type == StandardIndexes.vector()) {
+      // Vector may live as a combined file (legacy / storeInSegmentFile=false) or as a typed
+      // entry in columns.psf (storeInSegmentFile=true). Collect both. Removed the early-return
+      // that previously hid consolidated entries from this view.
       for (String column : _segmentMetadata.getAllColumns()) {
         if (VectorIndexUtils.hasVectorIndex(_segmentDirectory, column)) {
           columns.add(column);
         }
       }
-      return columns;
     }
     for (IndexKey indexKey : _columnEntries.keySet()) {
       if (indexKey._type == type) {
diff --git a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/store/VectorIndexUtils.java b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/store/VectorIndexUtils.java
index 5b757842ef6..bebb1a03f1c 100644
--- a/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/store/VectorIndexUtils.java
+++ b/pinot-segment-local/src/main/java/org/apache/pinot/segment/local/segment/store/VectorIndexUtils.java
@@ -18,18 +18,27 @@
  */
 package org.apache.pinot.segment.local.segment.store;
 
+import com.google.common.annotations.VisibleForTesting;
 import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import javax.annotation.Nullable;
 import org.apache.commons.io.FileUtils;
 import org.apache.lucene.codecs.lucene912.Lucene912Codec;
 import org.apache.lucene.codecs.lucene99.Lucene99HnswVectorsFormat;
 import org.apache.lucene.index.IndexWriterConfig;
 import org.apache.lucene.index.VectorSimilarityFunction;
+import org.apache.pinot.segment.local.segment.creator.impl.text.LuceneCombinedTextIndexConstants;
 import org.apache.pinot.segment.local.segment.creator.impl.vector.lucene99.HnswCodec;
 import org.apache.pinot.segment.local.segment.creator.impl.vector.lucene99.HnswVectorsFormat;
+import org.apache.pinot.segment.local.segment.index.vector.IvfFlatVectorIndexCreator;
+import org.apache.pinot.segment.local.segment.index.vector.IvfPqIndexFormat;
 import org.apache.pinot.segment.spi.V1Constants.Indexes;
+import org.apache.pinot.segment.spi.index.StandardIndexes;
 import org.apache.pinot.segment.spi.index.creator.VectorBackendType;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
+import org.apache.pinot.segment.spi.store.SegmentDirectory;
 import org.apache.pinot.segment.spi.store.SegmentDirectoryPaths;
 
 
@@ -56,16 +65,31 @@ public class VectorIndexUtils {
     File nativeV912IndexFile = new File(segDir, column + Indexes.VECTOR_V912_INDEX_FILE_EXTENSION);
     FileUtils.deleteQuietly(nativeV912IndexFile);
 
-    // Remove the IVF_FLAT index file
+    // Remove the IVF_FLAT index file (legacy and combined-form transient siblings)
     File ivfFlatIndexFile = new File(segDir, column + Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
     FileUtils.deleteQuietly(ivfFlatIndexFile);
+    File ivfFlatCombinedFile = new File(segDir, column + Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION);
+    FileUtils.deleteQuietly(ivfFlatCombinedFile);
 
-    // Remove the IVF_PQ index file
+    // Remove the IVF_PQ index file (legacy and combined-form transient siblings)
     File ivfPqIndexFile = new File(segDir, column + Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION);
     FileUtils.deleteQuietly(ivfPqIndexFile);
+    File ivfPqCombinedFile = new File(segDir, column + Indexes.VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION);
+    FileUtils.deleteQuietly(ivfPqCombinedFile);
+
+    // Remove the HNSW combined-form transient sibling (the Lucene HNSW directories themselves are
+    // handled above via the per-version VECTOR_HNSW_INDEX_FILE_EXTENSION entries).
+    File hnswCombinedFile = new File(segDir, column + Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION);
+    FileUtils.deleteQuietly(hnswCombinedFile);
   }
 
-  static boolean hasVectorIndex(File segDir, String column) {
+  /// Returns {@code true} when the V1/V2 segment directory holds a vector index file that should
+  /// be preserved as a sibling during V2→V3 conversion (the converter's "skip standard copy" gate).
+  /// Deliberately excludes the IVF {@code *.combined.index} extensions — those are the transient
+  /// consolidated form that the converter is supposed to pack into {@code columns.psf} via the
+  /// standard copy path, not sibling-copy. Callers that need to know about the combined form too
+  /// should use {@link #hasCombinedFormVectorIndex} alongside this.
+  public static boolean hasVectorIndex(File segDir, String column) {
     return new File(segDir, column + Indexes.VECTOR_HNSW_INDEX_FILE_EXTENSION).exists()
         || new File(segDir, column + Indexes.VECTOR_V99_HNSW_INDEX_FILE_EXTENSION).exists()
         || new File(segDir, column + Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION).exists()
@@ -76,6 +100,119 @@ public class VectorIndexUtils {
         || new File(segDir, column + Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION).exists();
   }
 
+  /// Returns {@code true} when the V1/V2 segment directory holds an IVF vector index in the
+  /// combined-form extension ({@code .vector.ivfflat.combined.index} or
+  /// {@code .vector.ivfpq.combined.index}). The combined form is written by an IVF creator run
+  /// with {@code storeInSegmentFile=true} and is meant to be packed into {@code columns.psf} by
+  /// the V2→V3 converter, not preserved as a sibling.
+  public static boolean hasCombinedFormVectorIndex(File segDir, String column) {
+    return new File(segDir, column + Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION).exists()
+        || new File(segDir, column + Indexes.VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION).exists()
+        || new File(segDir, column + Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION).exists();
+  }
+
+  /// Returns the {@code columns.psf} typed-entry buffer holding the column's consolidated vector
+  /// index, or {@code null} when no such entry has been packed into {@code columns.psf} yet.
+  ///
+  /// **Contract per store implementation.** On a V3 {@link SingleFileIndexDirectory}, unlike
+  /// {@link SegmentDirectory.Reader#hasIndexFor}, this does NOT report a legacy on-disk sidecar (an
+  /// IVF flat file or an HNSW Lucene directory) as a match — only a real packed `_columnEntries`
+  /// slot counts; an absent slot (signalled by an unchecked exception whose message starts with
+  /// {@link SingleFileIndexDirectory#INDEX_NOT_FOUND_MESSAGE_PREFIX}) maps to {@code null}. On a
+  /// V1/V2 {@link FilePerIndexDirectory} there is no {@code columns.psf}: a still-present legacy
+  /// HNSW Lucene *directory* fails to map (message ending with
+  /// {@link FilePerIndexDirectory#NOT_A_REGULAR_FILE_MESSAGE_SUFFIX}) and also maps to {@code null}
+  /// here — a directory can never be a packed typed entry — but a legacy IVF sidecar *file* IS
+  /// mapped and returned as if it were a consolidated entry (same bytes, directory-owned buffer).
+  /// Callers that must distinguish "truly consolidated" from "V1/V2 sidecar" must gate on the
+  /// segment version or on-disk artifacts first, as the {@code VectorIndexHandler} (v3 gate) and
+  /// the HNSW reader factory (legacy-directory-first) call sites do.
+  ///
+  /// Any other {@code RuntimeException} (e.g. a corruption marker) is rethrown rather than masked
+  /// as "absent", so the migration / crash-recovery paths do not proceed on a broken segment.
+  /// Genuine {@link IOException}s also propagate.
+  ///
+  /// Callers use this to tell "a prior absorb already committed bytes" (crash recovery) apart from
+  /// "first absorb of an existing sidecar", and to select the {@code columns.psf} read path only
+  /// when the consolidated entry truly exists.
+  ///
+  /// The returned buffer is owned by the segment directory and must NOT be closed by the caller.
+  @Nullable
+  public static PinotDataBuffer getConsolidatedVectorEntry(SegmentDirectory.Reader reader, String column)
+      throws IOException {
+    try {
+      return reader.getIndexFor(column, StandardIndexes.vector());
+    } catch (RuntimeException e) {
+      String message = e.getMessage();
+      if (message != null && message.startsWith(SingleFileIndexDirectory.INDEX_NOT_FOUND_MESSAGE_PREFIX)) {
+        // No typed entry in columns.psf yet — the expected "not consolidated" case.
+        return null;
+      }
+      // FilePerIndexDirectory (V1/V2) resolves a still-present legacy Lucene DIRECTORY as the
+      // vector artifact and fails to map it. A directory can never be a packed typed entry, so
+      // treat it as "no consolidated entry" rather than killing the caller's segment load.
+      if (e instanceof IllegalArgumentException && message != null
+          && message.endsWith(FilePerIndexDirectory.NOT_A_REGULAR_FILE_MESSAGE_SUFFIX)) {
+        return null;
+      }
+      // Anything else (corruption, unexpected state) must not be silently treated as "absent".
+      throw e;
+    }
+  }
+
+  /// Sniffs the vector backend that produced a consolidated {@code columns.psf} payload from its
+  /// leading magic bytes, or {@code null} when the column has no consolidated entry or the payload
+  /// starts with an unknown magic. Complements {@link #detectVectorIndexBackend}, which only sees
+  /// on-disk sidecar files — a consolidated-only column is invisible to it, so backend-drift
+  /// detection must use this probe instead.
+  ///
+  /// {@code IVF_ON_DISK} shares the IVF_FLAT file format, so its payloads report
+  /// {@link VectorBackendType#IVF_FLAT} — mirroring what {@link #detectVectorIndexBackend} reports
+  /// for the shared file extension.
+  @Nullable
+  public static VectorBackendType detectConsolidatedVectorBackend(SegmentDirectory.Reader reader, String column)
+      throws IOException {
+    PinotDataBuffer entry = getConsolidatedVectorEntry(reader, column);
+    return entry == null ? null : sniffVectorPayloadBackend(entry);
+  }
+
+  /// Maps a configured backend to the storage format it reads/writes. {@code IVF_ON_DISK} shares
+  /// the IVF_FLAT file format (only the reader class differs), so backend-drift comparisons must
+  /// normalize through this helper before comparing against a detected/sniffed backend — otherwise
+  /// a valid {@code IVF_ON_DISK} column would report perpetual drift (the payload always sniffs as
+  /// {@code IVF_FLAT}) and be destroyed and rebuilt on every segment load.
+  public static VectorBackendType storageFormatOf(VectorBackendType backendType) {
+    return backendType == VectorBackendType.IVF_ON_DISK ? VectorBackendType.IVF_FLAT : backendType;
+  }
+
+  /// Classifies a vector payload by its leading magic bytes: the HNSW combined pack starts with the
+  /// {@code LUCENE_V2} magic string, IVF payloads start with their 4-byte big-endian format magic
+  /// ({@code IVFF} / {@code IVPQ}). Returns {@code null} for anything else. Bytes are assembled
+  /// manually so the result does not depend on the buffer view's byte order.
+  @Nullable
+  @VisibleForTesting
+  static VectorBackendType sniffVectorPayloadBackend(PinotDataBuffer payload) {
+    int hnswMagicLength = LuceneCombinedTextIndexConstants.MAGIC_NUMBER_LENGTH;
+    if (payload.size() >= hnswMagicLength) {
+      byte[] head = new byte[hnswMagicLength];
+      payload.copyTo(0, head, 0, hnswMagicLength);
+      if (LuceneCombinedTextIndexConstants.MAGIC_NUMBER.equals(new String(head, StandardCharsets.US_ASCII))) {
+        return VectorBackendType.HNSW;
+      }
+    }
+    if (payload.size() >= Integer.BYTES) {
+      int magic = ((payload.getByte(0) & 0xFF) << 24) | ((payload.getByte(1) & 0xFF) << 16)
+          | ((payload.getByte(2) & 0xFF) << 8) | (payload.getByte(3) & 0xFF);
+      if (magic == IvfFlatVectorIndexCreator.MAGIC) {
+        return VectorBackendType.IVF_FLAT;
+      }
+      if (magic == IvfPqIndexFormat.MAGIC) {
+        return VectorBackendType.IVF_PQ;
+      }
+    }
+    return null;
+  }
+
   @Nullable
   public static VectorBackendType detectVectorIndexBackend(File segmentIndexDir, String column) {
     if (SegmentDirectoryPaths.findVectorIndexIndexFile(segmentIndexDir, column, VectorBackendType.IVF_PQ) != null) {
@@ -91,16 +228,38 @@ public class VectorIndexUtils {
   }
 
   public static String getIndexFileExtension(VectorBackendType backendType) {
+    return getIndexFileExtension(backendType, /* combined */ false);
+  }
+
+  /// Returns the on-disk file extension for an IVF/HNSW vector index file.
+  ///
+  /// @param combined when {@code true}, returns the combined-form extension used when
+  ///                 {@code storeInSegmentFile=true} (consumed by the V2→V3 converter, then
+  ///                 removed). When {@code false}, returns the legacy file extension that
+  ///                 remains alongside {@code columns.psf}.
+  ///                 For HNSW the combined form is a single packed file that bundles the
+  ///                 Lucene HNSW directory's contents (and the optional docId mapping file) using
+  ///                 the same {@code LUCENE_V2} layout the text index uses; the legacy form is
+  ///                 the Lucene directory itself.
+  public static String getIndexFileExtension(VectorBackendType backendType, boolean combined) {
     switch (backendType) {
       case HNSW:
-        return Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION;
+        return combined
+            ? Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION
+            : Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION;
       case IVF_FLAT:
-        return Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION;
+        return combined
+            ? Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION
+            : Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION;
       case IVF_PQ:
-        return Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION;
+        return combined
+            ? Indexes.VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION
+            : Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION;
       case IVF_ON_DISK:
-        // IVF_ON_DISK reuses the IVF_FLAT file format with FileChannel random-access reads
-        return Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION;
+        // IVF_ON_DISK reuses the IVF_FLAT file format with positional buffer reads.
+        return combined
+            ? Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION
+            : Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION;
       default:
         throw new IllegalStateException("Unsupported vector backend type: " + backendType);
     }
diff --git a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/creator/impl/vector/lucene99/HnswVectorIndexCombinedTest.java b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/creator/impl/vector/lucene99/HnswVectorIndexCombinedTest.java
new file mode 100644
index 00000000000..a258366d97d
--- /dev/null
+++ b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/creator/impl/vector/lucene99/HnswVectorIndexCombinedTest.java
@@ -0,0 +1,268 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.segment.local.segment.creator.impl.vector.lucene99;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Map;
+import org.apache.commons.io.FileUtils;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.KnnFloatVectorQuery;
+import org.apache.lucene.search.TopDocs;
+import org.apache.lucene.store.Directory;
+import org.apache.pinot.segment.local.segment.creator.impl.vector.HnswVectorIndexCreator;
+import org.apache.pinot.segment.local.segment.index.readers.vector.HnswVectorIndexBufferReader;
+import org.apache.pinot.segment.spi.V1Constants;
+import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
+import org.testng.Assert;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+
+/**
+ * Round-trip test: creates a small HNSW index via {@link HnswVectorIndexCreator} with
+ * {@code storeInSegmentFile=true}, verifies the combined file is produced, mmaps it, opens a
+ * {@link Directory} via {@link HnswVectorIndexBufferReader}, and runs a {@link KnnFloatVectorQuery}.
+ */
+public class HnswVectorIndexCombinedTest {
+
+  private static final String COLUMN = "vec";
+  private static final int DIMENSION = 4;
+  private static final int NUM_DOCS = 8;
+
+  private File _segmentDir;
+
+  @BeforeMethod
+  public void setUp()
+      throws IOException {
+    _segmentDir = new File(FileUtils.getTempDirectory(),
+        "hnsw-combined-test-" + System.nanoTime());
+    FileUtils.forceMkdir(_segmentDir);
+  }
+
+  @AfterMethod
+  public void tearDown() {
+    FileUtils.deleteQuietly(_segmentDir);
+  }
+
+  @Test
+  public void testCombineAndRead()
+      throws Exception {
+    // Build the index with storeInSegmentFile=true
+    VectorIndexConfig config = buildConfig(true);
+    float[][] vectors = buildVectors(NUM_DOCS, DIMENSION);
+    buildIndex(vectors, config);
+
+    // The combined file must exist after close(); the Lucene directory must be gone
+    File combinedFile = new File(_segmentDir,
+        COLUMN + V1Constants.Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION);
+    Assert.assertTrue(combinedFile.exists(), "Combined file must be present after creator.close()");
+    File hnswDir = new File(_segmentDir,
+        COLUMN + V1Constants.Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION);
+    Assert.assertFalse(hnswDir.exists(), "Lucene directory must be cleaned up after packing");
+
+    // Mmap the combined file and open via the buffer reader
+    PinotDataBuffer buffer = PinotDataBuffer.mapFile(combinedFile, /* readOnly */ true, 0, combinedFile.length(),
+        ByteOrder.LITTLE_ENDIAN, "hnsw-combined-test");
+    try {
+      Directory dir = HnswVectorIndexBufferReader.createLuceneDirectory(buffer, COLUMN);
+      DirectoryReader indexReader = DirectoryReader.open(dir);
+      try {
+        Assert.assertEquals(indexReader.numDocs(), NUM_DOCS);
+        IndexSearcher searcher = new IndexSearcher(indexReader);
+        // Query with the first vector; we expect at least one result
+        KnnFloatVectorQuery query = new KnnFloatVectorQuery(COLUMN, vectors[0], 3);
+        TopDocs results = searcher.search(query, 3);
+        Assert.assertTrue(results.totalHits.value > 0,
+            "KNN query on buffer-backed directory must return at least one result");
+      } finally {
+        indexReader.close();
+        dir.close();
+      }
+    } finally {
+      buffer.close();
+    }
+  }
+
+  @Test
+  public void testCombineAndExtractRoundTrip()
+      throws Exception {
+    VectorIndexConfig config = buildConfig(false);
+    float[][] vectors = buildVectors(NUM_DOCS, DIMENSION);
+    buildIndex(vectors, config);
+
+    // The Lucene directory must exist; no combined file
+    File hnswDir = new File(_segmentDir,
+        COLUMN + V1Constants.Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION);
+    Assert.assertTrue(hnswDir.exists() && hnswDir.isDirectory(),
+        "Lucene directory must be present when storeInSegmentFile=false");
+    File combinedFile = new File(_segmentDir,
+        COLUMN + V1Constants.Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION);
+    Assert.assertFalse(combinedFile.exists(),
+        "Combined file must not be present when storeInSegmentFile=false");
+
+    // Pack manually and unpack into a new directory
+    HnswVectorIndexCombined.combineHnswIndexFiles(hnswDir, combinedFile.getAbsolutePath(), null, null);
+    Assert.assertTrue(combinedFile.exists() && combinedFile.length() > 0, "Combined file must be non-empty");
+
+    File extractDir = new File(_segmentDir, "extracted-" + COLUMN);
+    HnswVectorIndexCombined.extractHnswIndexFiles(combinedFile, extractDir);
+    Assert.assertTrue(extractDir.isDirectory(), "Extract directory must be created");
+
+    // Re-open from the extracted directory and verify it's a valid Lucene index
+    org.apache.lucene.store.FSDirectory fsDir = org.apache.lucene.store.FSDirectory.open(extractDir.toPath());
+    DirectoryReader reader = DirectoryReader.open(fsDir);
+    try {
+      Assert.assertEquals(reader.numDocs(), NUM_DOCS);
+    } finally {
+      reader.close();
+      fsDir.close();
+    }
+  }
+
+  /**
+   * A truncated/corrupt combined file (whose header advertises more data than is present) must fail
+   * fast instead of spinning forever in the {@code transferTo} extraction loop. Dropping the final
+   * byte leaves the header/metadata intact but makes the last packed file one byte short, so
+   * {@code transferTo} hits EOF with bytes still outstanding.
+   */
+  @Test
+  public void testExtractThrowsOnTruncatedCombinedFile()
+      throws Exception {
+    VectorIndexConfig config = buildConfig(false);
+    buildIndex(buildVectors(NUM_DOCS, DIMENSION), config);
+    File hnswDir = new File(_segmentDir, COLUMN + V1Constants.Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION);
+    File combinedFile = new File(_segmentDir, COLUMN + V1Constants.Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION);
+    HnswVectorIndexCombined.combineHnswIndexFiles(hnswDir, combinedFile.getAbsolutePath(), null, null);
+    Assert.assertTrue(combinedFile.length() > 1, "combined file must be non-trivial");
+
+    try (RandomAccessFile raf = new RandomAccessFile(combinedFile, "rw")) {
+      raf.setLength(combinedFile.length() - 1);
+    }
+
+    File extractDir = new File(_segmentDir, "extracted-truncated-" + COLUMN);
+    try {
+      HnswVectorIndexCombined.extractHnswIndexFiles(combinedFile, extractDir);
+      Assert.fail("Expected IOException for a truncated combined HNSW file");
+    } catch (IOException expected) {
+      Assert.assertTrue(expected.getMessage().contains("Truncated or corrupt"),
+          "error must identify the corruption; got: " + expected.getMessage());
+    }
+  }
+
+  @Test
+  public void testExtractDocIdMappingBufferAbsentWhenNotPacked()
+      throws Exception {
+    VectorIndexConfig config = buildConfig(false);
+    buildIndex(buildVectors(NUM_DOCS, DIMENSION), config);
+
+    File hnswDir = new File(_segmentDir, COLUMN + V1Constants.Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION);
+    File combinedFile = new File(_segmentDir, COLUMN + V1Constants.Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION);
+    HnswVectorIndexCombined.combineHnswIndexFiles(hnswDir, combinedFile.getAbsolutePath(), null, null);
+
+    PinotDataBuffer buffer = PinotDataBuffer.mapFile(combinedFile, /* readOnly */ true, 0, combinedFile.length(),
+        ByteOrder.LITTLE_ENDIAN, "hnsw-combined-mapping-test");
+    try {
+      // No mapping was packed (segmentIndexDir=null in combineHnswIndexFiles above)
+      PinotDataBuffer mappingBuffer = HnswVectorIndexBufferReader.extractDocIdMappingBuffer(buffer, COLUMN);
+      Assert.assertNull(mappingBuffer, "Mapping buffer must be null when no mapping was packed");
+    } finally {
+      buffer.close();
+    }
+  }
+
+  /// Regression for the consolidated-HNSW docId-mapping byte order. The mapping is packed verbatim
+  /// from the little-endian file-backed sidecar, but the enclosing {@code columns.psf} buffer is
+  /// big-endian. {@code extractDocIdMappingBuffer} must hand back a LITTLE_ENDIAN view so
+  /// {@code DocIdTranslator} reads the Lucene→Pinot doc ids unswapped.
+  @Test
+  public void testExtractDocIdMappingBufferIsLittleEndian()
+      throws Exception {
+    buildIndex(buildVectors(NUM_DOCS, DIMENSION), buildConfig(false));
+    File hnswDir = new File(_segmentDir, COLUMN + V1Constants.Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION);
+
+    // Write a docId mapping file (Lucene doc id -> Pinot doc id) little-endian, the order the
+    // file-backed DocIdTranslator uses.
+    int[] expected = {5, 3, 7, 1, 6, 2, 4, 0};
+    File mappingFile =
+        new File(_segmentDir, COLUMN + V1Constants.Indexes.VECTOR_HNSW_INDEX_DOCID_MAPPING_FILE_EXTENSION);
+    ByteBuffer bb = ByteBuffer.allocate(expected.length * Integer.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+    for (int v : expected) {
+      bb.putInt(v);
+    }
+    FileUtils.writeByteArrayToFile(mappingFile, bb.array());
+
+    // Pack including the mapping file.
+    File combinedFile = new File(_segmentDir, COLUMN + V1Constants.Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION);
+    HnswVectorIndexCombined.combineHnswIndexFiles(hnswDir, combinedFile.getAbsolutePath(), _segmentDir, COLUMN);
+
+    // Mmap the combined file BIG_ENDIAN to mirror the columns.psf buffer order. Without the
+    // little-endian view in extractDocIdMappingBuffer, getInt() would byte-swap every doc id.
+    PinotDataBuffer buffer = PinotDataBuffer.mapFile(combinedFile, /* readOnly */ true, 0, combinedFile.length(),
+        ByteOrder.BIG_ENDIAN, "hnsw-combined-endianness-test");
+    try {
+      PinotDataBuffer mappingBuffer = HnswVectorIndexBufferReader.extractDocIdMappingBuffer(buffer, COLUMN);
+      Assert.assertNotNull(mappingBuffer, "Mapping buffer must be present when packed");
+      for (int i = 0; i < expected.length; i++) {
+        Assert.assertEquals(mappingBuffer.getInt(i * Integer.BYTES), expected[i],
+            "docId mapping must read little-endian regardless of the enclosing buffer order");
+      }
+    } finally {
+      buffer.close();
+    }
+  }
+
+  // ---- helpers ----
+
+  private VectorIndexConfig buildConfig(boolean storeInSegmentFile) {
+    Map<String, String> props = new java.util.HashMap<>();
+    props.put(VectorIndexConfig.STORE_IN_SEGMENT_FILE, String.valueOf(storeInSegmentFile));
+    // Commit must be true for files to land; useCompoundFile=false avoids single-file mode.
+    props.put("commit", "true");
+    props.put("useCompoundFile", "false");
+    return new VectorIndexConfig(false, null, DIMENSION, 1,
+        VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, props);
+  }
+
+  private static float[][] buildVectors(int numDocs, int dimension) {
+    float[][] vectors = new float[numDocs][dimension];
+    for (int i = 0; i < numDocs; i++) {
+      for (int j = 0; j < dimension; j++) {
+        vectors[i][j] = (i * dimension + j) * 0.1f;
+      }
+    }
+    return vectors;
+  }
+
+  private void buildIndex(float[][] vectors, VectorIndexConfig config)
+      throws IOException {
+    try (HnswVectorIndexCreator creator = new HnswVectorIndexCreator(COLUMN, _segmentDir, config)) {
+      for (float[] v : vectors) {
+        creator.add(v);
+      }
+      creator.seal();
+    }
+  }
+}
diff --git a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/loader/invertedindex/VectorIndexHandlerTest.java b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/loader/invertedindex/VectorIndexHandlerTest.java
index 5826883d9db..0fdc98f6fe6 100644
--- a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/loader/invertedindex/VectorIndexHandlerTest.java
+++ b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/loader/invertedindex/VectorIndexHandlerTest.java
@@ -19,26 +19,44 @@
 package org.apache.pinot.segment.local.segment.index.loader.invertedindex;
 
 import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.TreeSet;
 import org.apache.commons.io.FileUtils;
+import org.apache.pinot.segment.local.segment.creator.impl.vector.lucene99.HnswVectorIndexCombined;
 import org.apache.pinot.segment.spi.V1Constants;
+import org.apache.pinot.segment.spi.creator.SegmentVersion;
 import org.apache.pinot.segment.spi.index.FieldIndexConfigs;
 import org.apache.pinot.segment.spi.index.StandardIndexes;
+import org.apache.pinot.segment.spi.index.creator.VectorBackendType;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
 import org.apache.pinot.segment.spi.index.metadata.SegmentMetadataImpl;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
 import org.apache.pinot.segment.spi.store.SegmentDirectory;
 import org.apache.pinot.segment.spi.store.SegmentDirectoryPaths;
 import org.apache.pinot.spi.config.table.TableConfig;
 import org.apache.pinot.spi.data.Schema;
 import org.testng.annotations.Test;
 
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
 import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.fail;
 
 
 /**
@@ -91,12 +109,18 @@ public class VectorIndexHandlerTest {
   }
 
   private static SegmentDirectory mockSegmentDirectory(File indexDir) {
+    // Default mocked version is null (legacy callers do not exercise the version branch).
+    return mockSegmentDirectory(indexDir, null);
+  }
+
+  private static SegmentDirectory mockSegmentDirectory(File indexDir, SegmentVersion version) {
     SegmentMetadataImpl segmentMetadata = mock(SegmentMetadataImpl.class);
     when(segmentMetadata.getName()).thenReturn("testSegment");
     when(segmentMetadata.getIndexDir()).thenReturn(indexDir);
     when(segmentMetadata.getTotalDocs()).thenReturn(10);
     when(segmentMetadata.getAllColumns()).thenReturn(new TreeSet<>(Set.of(COLUMN)));
     when(segmentMetadata.getColumnMetadataMap()).thenReturn(new TreeMap<>());
+    when(segmentMetadata.getVersion()).thenReturn(version);
 
     SegmentDirectory segmentDirectory = mock(SegmentDirectory.class);
     when(segmentDirectory.getSegmentMetadata()).thenReturn(segmentMetadata);
@@ -109,6 +133,732 @@ public class VectorIndexHandlerTest {
         Map.of("nlist", "2", "pqM", "2", "pqNbits", "4", "trainSampleSize", "8"));
   }
 
+  private static VectorIndexConfig vectorIndexConfigWithConsolidation(String backend, boolean storeInSegmentFile) {
+    Map<String, String> props = new HashMap<>();
+    props.put("nlist", "2");
+    props.put("pqM", "2");
+    props.put("pqNbits", "4");
+    props.put("trainSampleSize", "8");
+    props.put(VectorIndexConfig.STORE_IN_SEGMENT_FILE, String.valueOf(storeInSegmentFile));
+    return new VectorIndexConfig(false, backend, 4, 1, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, props);
+  }
+
+  // ---------------------------------------------------------------------------
+  // storeInSegmentFile / consolidation
+  // ---------------------------------------------------------------------------
+
+  /**
+   * When the segment was built with the legacy combined layout and the table now requests
+   * {@code storeInSegmentFile=true}, the handler should detect the mismatch on the first load.
+   */
+  @Test
+  public void testNeedUpdateIndicesReturnsTrueWhenCombinedExistsButFlagWantsConsolidated()
+      throws Exception {
+    File indexDir = createSegmentDirWithVectorIndex(V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Reader reader = mock(SegmentDirectory.Reader.class);
+      when(reader.toSegmentDirectory()).thenReturn(segmentDirectory);
+
+      VectorIndexHandler handler = createHandler(segmentDirectory,
+          vectorIndexConfigWithConsolidation("IVF_FLAT", /* storeInSegmentFile */ true));
+
+      assertTrue(handler.needUpdateIndices(reader),
+          "Combined present + flag on => handler must re-run to absorb combined into columns.psf");
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * When the segment is in the legacy combined layout and the table also keeps the flag off,
+   * there is nothing to do — the segment is already in its target layout.
+   */
+  @Test
+  public void testNeedUpdateIndicesReturnsFalseWhenCombinedExistsAndFlagIsOff()
+      throws Exception {
+    File indexDir = createSegmentDirWithVectorIndex(V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Reader reader = mock(SegmentDirectory.Reader.class);
+      when(reader.toSegmentDirectory()).thenReturn(segmentDirectory);
+
+      VectorIndexHandler handler = createHandler(segmentDirectory,
+          vectorIndexConfigWithConsolidation("IVF_FLAT", /* storeInSegmentFile */ false));
+
+      assertFalse(handler.needUpdateIndices(reader),
+          "Combined present + flag off => no work required");
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * Reverse migration: segment has the vector index consolidated inside {@code columns.psf} and
+   * the table now wants the legacy combined layout ({@code storeInSegmentFile=false}). The
+   * handler must detect the mismatch on load and extract the bytes back into a sidecar file.
+   */
+  @Test
+  public void testNeedUpdateIndicesReturnsTrueWhenConsolidatedExistsButFlagWantsCombined()
+      throws Exception {
+    // Set up a V3 segment with no combined file, but report the column as having a vector index
+    // via the SegmentDirectory's getColumnsWithIndex (simulating a consolidated _columnEntries
+    // entry, since the real SingleFileIndexDirectory would surface it that way).
+    File indexDir = createEmptyV3SegmentDir();
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Reader reader = mock(SegmentDirectory.Reader.class);
+      when(reader.toSegmentDirectory()).thenReturn(segmentDirectory);
+
+      VectorIndexHandler handler = createHandler(segmentDirectory,
+          vectorIndexConfigWithConsolidation("IVF_FLAT", /* storeInSegmentFile */ false));
+
+      assertTrue(handler.needUpdateIndices(reader),
+          "Consolidated entry + flag off => handler must re-run to extract bytes back to combined");
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * Full extract path: the consolidated bytes inside {@code columns.psf} are streamed back to
+   * a combined file, the consolidated entry is dropped, and the resulting combined exists on disk
+   * with the expected extension and byte content.
+   */
+  @Test
+  public void testUpdateIndicesExtractsConsolidatedBytesIntoCombined()
+      throws Exception {
+    File indexDir = createEmptyV3SegmentDir();
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Writer writer = mock(SegmentDirectory.Writer.class);
+      when(writer.toSegmentDirectory()).thenReturn(segmentDirectory);
+
+      // Make the writer's getIndexFor return a buffer holding a known payload, then assert the
+      // combined on disk contains those exact bytes.
+      byte[] expectedPayload = new byte[] {(byte) 0xAB, (byte) 0xCD, (byte) 0xEF, 0x01, 0x02, 0x03, 0x04, 0x05};
+      PinotDataBuffer buffer = PinotDataBuffer.allocateDirect(expectedPayload.length,
+          ByteOrder.BIG_ENDIAN, "vector-extract-test");
+      try {
+        buffer.readFrom(0, expectedPayload, 0, expectedPayload.length);
+        when(writer.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(buffer);
+
+        VectorIndexHandler handler = createHandler(segmentDirectory,
+            vectorIndexConfigWithConsolidation("IVF_FLAT", /* storeInSegmentFile */ false));
+        handler.updateIndices(writer);
+
+        verify(writer).removeIndex(eq(COLUMN), eq(StandardIndexes.vector()));
+        File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+        File extracted = new File(v3Dir, COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+        assertTrue(extracted.exists(), "extracted combined must exist at the final path");
+        byte[] actual = Files.readAllBytes(extracted.toPath());
+        assertEquals(actual, expectedPayload,
+            "extracted combined bytes must match the consolidated payload exactly");
+        // Temp file must have been cleaned up by rename.
+        File temp = new File(v3Dir, COLUMN + ".vector.extract-tmp");
+        assertFalse(temp.exists(), "temp extract file must be gone after rename");
+      } finally {
+        buffer.close();
+      }
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * Regression: the HNSW extract path (columns.psf → Lucene directory, on {@code storeInSegmentFile}
+   * flip to {@code false}) must leave a usable Lucene directory behind. {@code removeIndex} for
+   * vector runs {@code VectorIndexUtils.cleanupVectorIndex} as a side effect, which recursively
+   * deletes any sibling matching a recognised vector extension — including the legacy
+   * {@code .vector.v912.hnsw.index} directory. If the unpack lands straight in that final directory,
+   * {@code removeIndex} wipes it and the migration finishes with no HNSW artifact. The handler must
+   * unpack into a temp directory and move it into place only after cleanup.
+   */
+  @Test
+  public void testUpdateIndicesExtractHnswPreservesDirectoryAfterCleanup()
+      throws Exception {
+    File indexDir = createEmptyV3SegmentDir();
+    try {
+      File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+      // Build a real combined HNSW payload from a fake source dir (the extract copies bytes; it does
+      // not need a valid Lucene index for this test). Capture the bytes, then drop the scratch files.
+      File srcDir = new File(v3Dir, "src-hnsw");
+      assertTrue(srcDir.mkdirs());
+      Files.write(new File(srcDir, "_0.cfe").toPath(), "lucene-file-one".getBytes(StandardCharsets.UTF_8));
+      Files.write(new File(srcDir, "segments_1").toPath(), "lucene-file-two".getBytes(StandardCharsets.UTF_8));
+      File scratchCombined = new File(v3Dir, COLUMN + ".vector.hnsw.scratch");
+      HnswVectorIndexCombined.combineHnswIndexFiles(srcDir, scratchCombined.getAbsolutePath(), null, null);
+      byte[] combinedBytes = Files.readAllBytes(scratchCombined.toPath());
+      FileUtils.deleteDirectory(srcDir);
+      FileUtils.deleteQuietly(scratchCombined);
+
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Writer writer = mock(SegmentDirectory.Writer.class);
+      when(writer.toSegmentDirectory()).thenReturn(segmentDirectory);
+
+      PinotDataBuffer buffer = PinotDataBuffer.allocateDirect(combinedBytes.length,
+          ByteOrder.BIG_ENDIAN, "hnsw-extract-test");
+      try {
+        buffer.readFrom(0, combinedBytes, 0, combinedBytes.length);
+        when(writer.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(buffer);
+        // Mirror the part of the real SingleFileIndexDirectory.removeIndex that bites here:
+        // cleanupVectorIndex recursively deletes the legacy .vector.v912.hnsw.index directory.
+        doAnswer(inv -> {
+          FileUtils.deleteQuietly(
+              new File(v3Dir, COLUMN + V1Constants.Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION));
+          return null;
+        }).when(writer).removeIndex(eq(COLUMN), eq(StandardIndexes.vector()));
+
+        // storeInSegmentFile flipped off, no sidecar on disk yet => the handler extracts to a dir.
+        VectorIndexHandler handler = createHandler(segmentDirectory,
+            vectorIndexConfigWithConsolidation("HNSW", /* storeInSegmentFile */ false));
+        handler.updateIndices(writer);
+
+        verify(writer).removeIndex(eq(COLUMN), eq(StandardIndexes.vector()));
+        File hnswDir = new File(v3Dir, COLUMN + V1Constants.Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION);
+        assertTrue(hnswDir.isDirectory(), "unpacked Lucene directory must survive removeIndex cleanup");
+        String[] unpacked = hnswDir.list();
+        assertTrue(unpacked != null && unpacked.length >= 2,
+            "unpacked directory must retain the packed files, found: "
+                + (unpacked == null ? "null" : unpacked.length));
+        assertFalse(new File(v3Dir, COLUMN + ".vector.hnsw.extract-tmp-dir").exists(),
+            "temp unpack directory must be moved away");
+      } finally {
+        buffer.close();
+      }
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * Backend drift on a consolidated-only column: the payload lives solely in {@code columns.psf},
+   * so {@code detectVectorIndexBackend} (sidecar files only) returns null and the plain drift check
+   * cannot fire. The handler must sniff the typed entry's magic and report an update need when the
+   * configured backend differs. Uses {@code storeInSegmentFile=true} so no other branch (absorb:
+   * needs a combined file; extract: needs flag=false) can mask a regression here.
+   */
+  @Test
+  public void testNeedUpdateIndicesReturnsTrueWhenConsolidatedBackendDiffers()
+      throws Exception {
+    File indexDir = createEmptyV3SegmentDir();
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Reader reader = mock(SegmentDirectory.Reader.class);
+      when(reader.toSegmentDirectory()).thenReturn(segmentDirectory);
+      // Consolidated HNSW payload: LUCENE_V2 pack magic.
+      byte[] payload = "LUCENE_V2-rest-of-header".getBytes(StandardCharsets.US_ASCII);
+      PinotDataBuffer buffer = PinotDataBuffer.allocateDirect(payload.length, ByteOrder.BIG_ENDIAN,
+          "consolidated-drift-test");
+      try {
+        buffer.readFrom(0, payload, 0, payload.length);
+        when(reader.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(buffer);
+
+        VectorIndexHandler handler = createHandler(segmentDirectory,
+            vectorIndexConfigWithConsolidation("IVF_PQ", /* storeInSegmentFile */ true));
+        assertTrue(handler.needUpdateIndices(reader),
+            "consolidated HNSW payload + configured IVF_PQ backend must need a rebuild");
+      } finally {
+        buffer.close();
+      }
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * Regression for the consolidated backend-drift bug: with the payload only in {@code columns.psf}
+   * ({@code existingBackend == null}) and the flag flipped off, the extract branch used to treat a
+   * backend flip as a plain columns.psf → sidecar migration and stream the OLD backend's bytes out
+   * under the NEW backend's extension (e.g. HNSW pack bytes as {@code .vector.ivfpq.index}), which
+   * the next load would parse with the wrong reader. The handler must rebuild instead.
+   */
+  @Test
+  public void testUpdateIndicesRebuildsInsteadOfExtractingWhenConsolidatedBackendDiffers()
+      throws Exception {
+    File indexDir = createEmptyV3SegmentDir();
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Writer writer = mock(SegmentDirectory.Writer.class);
+      when(writer.toSegmentDirectory()).thenReturn(segmentDirectory);
+      byte[] payload = "LUCENE_V2-rest-of-header".getBytes(StandardCharsets.US_ASCII);
+      PinotDataBuffer buffer = PinotDataBuffer.allocateDirect(payload.length, ByteOrder.BIG_ENDIAN,
+          "consolidated-drift-extract-test");
+      try {
+        buffer.readFrom(0, payload, 0, payload.length);
+        when(writer.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(buffer);
+
+        VectorIndexHandler handler = createHandler(segmentDirectory,
+            vectorIndexConfigWithConsolidation("IVF_PQ", /* storeInSegmentFile */ false));
+        handler.updateIndices(writer);
+
+        // Rebuild path: the stale consolidated entry is dropped...
+        verify(writer).removeIndex(eq(COLUMN), eq(StandardIndexes.vector()));
+        // ...the column is re-queued for a rebuild (reaches the add loop's metadata lookup)...
+        verify(segmentDirectory.getSegmentMetadata()).getColumnMetadataFor(COLUMN);
+        // ...and the HNSW bytes must NOT have been extracted under the IVF_PQ extension.
+        File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+        assertFalse(new File(v3Dir, COLUMN + V1Constants.Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION).exists(),
+            "old HNSW payload must not be written out under the new backend's extension");
+        assertFalse(new File(v3Dir, COLUMN + ".vector.extract-tmp").exists(),
+            "no extract temp file may be left behind");
+      } finally {
+        buffer.close();
+      }
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * IVF_ON_DISK shares the IVF_FLAT file format, so a consolidated IVF_ON_DISK payload sniffs as
+   * IVF_FLAT ({@code IVFF} magic). The drift check must compare storage formats — a raw enum
+   * comparison would flag a healthy IVF_ON_DISK column as drifted on EVERY load and destroy and
+   * rebuild the index forever (the rebuilt payload again carries the IVFF magic, so the check
+   * would never converge).
+   */
+  @Test
+  public void testNeedUpdateIndicesReturnsFalseForConsolidatedIvfOnDiskColumn()
+      throws Exception {
+    File indexDir = createEmptyV3SegmentDir();
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Reader reader = mock(SegmentDirectory.Reader.class);
+      when(reader.toSegmentDirectory()).thenReturn(segmentDirectory);
+      byte[] payload = {'I', 'V', 'F', 'F', 0, 0, 0, 1};
+      PinotDataBuffer buffer = PinotDataBuffer.allocateDirect(payload.length, ByteOrder.BIG_ENDIAN,
+          "ivf-on-disk-drift-test");
+      try {
+        buffer.readFrom(0, payload, 0, payload.length);
+        when(reader.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(buffer);
+
+        VectorIndexHandler handler = createHandler(segmentDirectory,
+            vectorIndexConfigWithConsolidation("IVF_ON_DISK", /* storeInSegmentFile */ true));
+        assertFalse(handler.needUpdateIndices(reader),
+            "IVF_ON_DISK shares the IVF_FLAT storage format; a consolidated IVFF payload is NOT drift");
+      } finally {
+        buffer.close();
+      }
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /** Mirror of the needUpdateIndices IVF_ON_DISK test for the act side: no destroy-and-rebuild. */
+  @Test
+  public void testUpdateIndicesDoesNotRebuildConsolidatedIvfOnDiskColumn()
+      throws Exception {
+    File indexDir = createEmptyV3SegmentDir();
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Writer writer = mock(SegmentDirectory.Writer.class);
+      when(writer.toSegmentDirectory()).thenReturn(segmentDirectory);
+      byte[] payload = {'I', 'V', 'F', 'F', 0, 0, 0, 1};
+      PinotDataBuffer buffer = PinotDataBuffer.allocateDirect(payload.length, ByteOrder.BIG_ENDIAN,
+          "ivf-on-disk-update-test");
+      try {
+        buffer.readFrom(0, payload, 0, payload.length);
+        when(writer.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(buffer);
+
+        VectorIndexHandler handler = createHandler(segmentDirectory,
+            vectorIndexConfigWithConsolidation("IVF_ON_DISK", /* storeInSegmentFile */ true));
+        handler.updateIndices(writer);
+
+        verify(writer, never()).removeIndex(eq(COLUMN), eq(StandardIndexes.vector()));
+      } finally {
+        buffer.close();
+      }
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * Sidecar flavor of the IVF_ON_DISK aliasing: an on-disk {@code .vector.ivfflat.index} sidecar
+   * detects as IVF_FLAT, which must not count as drift from a configured IVF_ON_DISK backend.
+   */
+  @Test
+  public void testNeedUpdateIndicesReturnsFalseForIvfOnDiskSidecarColumn()
+      throws Exception {
+    File indexDir = createSegmentDirWithVectorIndex(V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Reader reader = mock(SegmentDirectory.Reader.class);
+      when(reader.toSegmentDirectory()).thenReturn(segmentDirectory);
+
+      VectorIndexHandler handler = createHandler(segmentDirectory,
+          vectorIndexConfigWithConsolidation("IVF_ON_DISK", /* storeInSegmentFile */ false));
+      assertFalse(handler.needUpdateIndices(reader),
+          "an IVF_FLAT-format sidecar is the correct storage for IVF_ON_DISK; not drift");
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * Complement to the drift-rebuild test: when the consolidated payload's magic MATCHES the
+   * configured backend, the flag-off extract must still run (no false-positive rebuild from the
+   * magic sniff).
+   */
+  @Test
+  public void testUpdateIndicesExtractsWhenConsolidatedBackendMatches()
+      throws Exception {
+    File indexDir = createEmptyV3SegmentDir();
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Writer writer = mock(SegmentDirectory.Writer.class);
+      when(writer.toSegmentDirectory()).thenReturn(segmentDirectory);
+      // Payload with a real IVF_FLAT magic ("IVFF") matching the configured backend.
+      byte[] payload = {'I', 'V', 'F', 'F', 0, 0, 0, 1};
+      PinotDataBuffer buffer = PinotDataBuffer.allocateDirect(payload.length, ByteOrder.BIG_ENDIAN,
+          "consolidated-match-extract-test");
+      try {
+        buffer.readFrom(0, payload, 0, payload.length);
+        when(writer.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(buffer);
+
+        VectorIndexHandler handler = createHandler(segmentDirectory,
+            vectorIndexConfigWithConsolidation("IVF_FLAT", /* storeInSegmentFile */ false));
+        handler.updateIndices(writer);
+
+        File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+        File extracted = new File(v3Dir, COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+        assertTrue(extracted.exists(), "matching-backend payload must still be extracted to the sidecar");
+        assertEquals(Files.readAllBytes(extracted.toPath()), payload,
+            "extracted bytes must match the consolidated payload");
+      } finally {
+        buffer.close();
+      }
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * Crash-recovery: if a previous absorb run committed bytes into {@code columns.psf} but then
+   * died before deleting the sidecar, the next load should detect the duplicate via
+   * {@code hasIndexFor} + size check and clean up the orphan sidecar instead of re-running the
+   * absorb (which would otherwise hit a duplicate-key error from
+   * {@code SingleFileIndexDirectory.checkKeyNotPresent}).
+   */
+  @Test
+  public void testUpdateIndicesRecoversFromCrashedAbsorb()
+      throws Exception {
+    File indexDir = createSegmentDirWithVectorIndex(V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Writer writer = mock(SegmentDirectory.Writer.class);
+      when(writer.toSegmentDirectory()).thenReturn(segmentDirectory);
+      // Simulate the half-committed state: typed entry already exists in columns.psf (size
+      // matches the on-disk sidecar — proves the entry came from the same build).
+      File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+      File orphanCombined = new File(v3Dir, COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+      long sidecarSize = orphanCombined.length();
+      when(writer.hasIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(true);
+      PinotDataBuffer typedEntry = PinotDataBuffer.allocateDirect(sidecarSize,
+          ByteOrder.BIG_ENDIAN, "crash-recovery-test");
+      try {
+        when(writer.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(typedEntry);
+
+        VectorIndexHandler handler = createHandler(segmentDirectory,
+            vectorIndexConfigWithConsolidation("IVF_FLAT", /* storeInSegmentFile */ true));
+
+        // Must not call newIndexFor (the typed entry is already there) and must clean the orphan.
+        handler.updateIndices(writer);
+
+        verify(writer, never()).newIndexFor(eq(COLUMN), eq(StandardIndexes.vector()), any(Long.class));
+        assertFalse(orphanCombined.exists(), "orphan sidecar file must be deleted by recovery path");
+      } finally {
+        typedEntry.close();
+      }
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * Defensive: when {@code hasIndexFor} is true but the typed-entry size disagrees with the
+   * on-disk sidecar's length, the bytes are from different builds. Rather than guess which copy
+   * is authoritative and silently destroy the other, the handler must refuse and surface an
+   * {@link IOException} so an operator reconciles manually.
+   */
+  @Test
+  public void testUpdateIndicesRefusesAbsorbWhenSizesMismatch()
+      throws Exception {
+    File indexDir = createSegmentDirWithVectorIndex(V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Writer writer = mock(SegmentDirectory.Writer.class);
+      when(writer.toSegmentDirectory()).thenReturn(segmentDirectory);
+      File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+      File sidecar = new File(v3Dir, COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+      long sidecarSize = sidecar.length();
+      when(writer.hasIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(true);
+      // Typed entry size deliberately differs from sidecar size.
+      PinotDataBuffer typedEntry = PinotDataBuffer.allocateDirect(sidecarSize + 1,
+          ByteOrder.BIG_ENDIAN, "size-mismatch-test");
+      try {
+        when(writer.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(typedEntry);
+
+        VectorIndexHandler handler = createHandler(segmentDirectory,
+            vectorIndexConfigWithConsolidation("IVF_FLAT", /* storeInSegmentFile */ true));
+
+        try {
+          handler.updateIndices(writer);
+          fail("Expected IOException due to size mismatch between columns.psf entry and sidecar");
+        } catch (IOException expected) {
+          assertTrue(expected.getMessage().contains("different size"),
+              "error must explain the size mismatch; got: " + expected.getMessage());
+        }
+        // The sidecar must not be deleted — operator must reconcile manually.
+        assertTrue(sidecar.exists(), "sidecar must be preserved when sizes disagree");
+      } finally {
+        typedEntry.close();
+      }
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * Defensive: extract path (columns.psf → sidecar) must refuse if a sidecar already exists on
+   * disk for either the legacy or combined extension. {@code removeIndex} runs
+   * {@code cleanupVectorIndex} as a side effect, which would silently destroy the pre-existing
+   * file. Operator must reconcile.
+   */
+  @Test
+  public void testExtractRefusesWhenLegacySidecarExists()
+      throws Exception {
+    File indexDir = createSegmentDirWithVectorIndex(V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+    try {
+      File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+      File legacySidecar = new File(v3Dir, COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+      assertTrue(legacySidecar.exists(), "test setup: legacy sidecar must exist");
+
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Writer writer = mock(SegmentDirectory.Writer.class);
+      VectorIndexHandler handler = createHandler(segmentDirectory,
+          vectorIndexConfigWithConsolidation("IVF_FLAT", /* storeInSegmentFile */ false));
+
+      // Bypass the needUpdate gate by invoking the extract helper directly — the gate's job is
+      // to prevent reaching this branch when a sidecar exists, but the helper itself must also
+      // refuse defensively in case the gate is bypassed (manual edits, future refactors).
+      Method m = VectorIndexHandler.class.getDeclaredMethod(
+          "extractConsolidatedToLegacyFile",
+          SegmentDirectory.Writer.class, String.class, VectorBackendType.class, File.class);
+      m.setAccessible(true);
+      try {
+        m.invoke(handler, writer, COLUMN, VectorBackendType.IVF_FLAT, indexDir);
+        fail("Expected IOException because a sidecar already exists on disk");
+      } catch (InvocationTargetException ite) {
+        Throwable cause = ite.getCause();
+        assertTrue(cause instanceof IOException,
+            "Expected IOException; got: " + (cause == null ? "null" : cause.getClass().getName()));
+        assertTrue(cause.getMessage().contains("Refusing to proceed"),
+            "error must explain refusal; got: " + cause.getMessage());
+      }
+      assertTrue(legacySidecar.exists(), "pre-existing sidecar must not be touched on refusal");
+      verify(writer, never()).removeIndex(eq(COLUMN), eq(StandardIndexes.vector()));
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * Crash + flag-toggle cleanup contract: a crash with {@code storeInSegmentFile=true} leaves an
+   * orphan {@code .combined.index} + {@code .inprogress} marker. A subsequent build with
+   * {@code flag=false} must clean those orphans before starting — otherwise a later flag flip
+   * back could pick the partial file up as a complete index. Exercised via the extracted helper.
+   */
+  @Test
+  public void testCleanOrphansFromOtherExtensionRemovesCombinedRemnants()
+      throws Exception {
+    File segmentDir = new File(FileUtils.getTempDirectory(), "vector-orphan-test-" + System.nanoTime());
+    FileUtils.deleteQuietly(segmentDir);
+    assertTrue(segmentDir.mkdirs());
+    try {
+      File orphanCombined = new File(segmentDir,
+          COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION);
+      File orphanMarker = new File(segmentDir, orphanCombined.getName() + ".inprogress");
+      FileUtils.writeStringToFile(orphanCombined, "partial", java.nio.charset.StandardCharsets.UTF_8);
+      FileUtils.touch(orphanMarker);
+
+      // Current build targets the legacy extension (writeCombined=false), so the helper sweeps
+      // the combined-form orphan.
+      VectorIndexHandler.cleanOrphansFromOtherExtension(segmentDir, COLUMN, VectorBackendType.IVF_FLAT,
+          /* currentWriteCombined */ false);
+
+      assertFalse(orphanCombined.exists(),
+          "orphan combined file from prior flag=true crash must be cleaned");
+      assertFalse(orphanMarker.exists(),
+          "orphan .inprogress marker from prior flag=true crash must be cleaned");
+    } finally {
+      FileUtils.deleteQuietly(segmentDir);
+    }
+  }
+
+  /**
+   * Symmetry: crash with {@code flag=false} leaving a legacy orphan must be cleaned when a build
+   * with {@code flag=true} retries. Same helper, opposite direction.
+   */
+  @Test
+  public void testCleanOrphansFromOtherExtensionRemovesLegacyRemnants()
+      throws Exception {
+    File segmentDir = new File(FileUtils.getTempDirectory(), "vector-orphan-test-" + System.nanoTime());
+    FileUtils.deleteQuietly(segmentDir);
+    assertTrue(segmentDir.mkdirs());
+    try {
+      File orphanLegacy = new File(segmentDir,
+          COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+      File orphanMarker = new File(segmentDir, orphanLegacy.getName() + ".inprogress");
+      FileUtils.writeStringToFile(orphanLegacy, "partial", java.nio.charset.StandardCharsets.UTF_8);
+      FileUtils.touch(orphanMarker);
+
+      VectorIndexHandler.cleanOrphansFromOtherExtension(segmentDir, COLUMN, VectorBackendType.IVF_FLAT,
+          /* currentWriteCombined */ true);
+
+      assertFalse(orphanLegacy.exists(),
+          "orphan legacy file from prior flag=false crash must be cleaned");
+      assertFalse(orphanMarker.exists(),
+          "orphan .inprogress marker from prior flag=false crash must be cleaned");
+    } finally {
+      FileUtils.deleteQuietly(segmentDir);
+    }
+  }
+
+  /**
+   * HNSW now supports a combined form, so the orphan sweep must clean the combined-form file when
+   * the current build targets the legacy directory extension (writeCombined=false). Previously
+   * this method was a no-op for HNSW; it is now active.
+   */
+  @Test
+  public void testCleanOrphansFromOtherExtensionCleansHnswCombinedOrphan()
+      throws Exception {
+    File segmentDir = new File(FileUtils.getTempDirectory(), "vector-orphan-hnsw-test-" + System.nanoTime());
+    FileUtils.deleteQuietly(segmentDir);
+    assertTrue(segmentDir.mkdirs());
+    try {
+      // Simulate: a prior crash left a combined-form orphan while the current retry targets legacy.
+      File orphanCombined = new File(segmentDir,
+          COLUMN + V1Constants.Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION);
+      File orphanMarker = new File(segmentDir, orphanCombined.getName() + ".inprogress");
+      FileUtils.writeStringToFile(orphanCombined, "partial",
+          java.nio.charset.StandardCharsets.UTF_8);
+      FileUtils.touch(orphanMarker);
+
+      VectorIndexHandler.cleanOrphansFromOtherExtension(segmentDir, COLUMN, VectorBackendType.HNSW,
+          /* currentWriteCombined */ false);
+
+      assertFalse(orphanCombined.exists(),
+          "Orphan HNSW combined file from a prior flag=true crash must be cleaned");
+      assertFalse(orphanMarker.exists(),
+          "Orphan .inprogress marker from prior flag=true crash must be cleaned");
+    } finally {
+      FileUtils.deleteQuietly(segmentDir);
+    }
+  }
+
+  /**
+   * Symmetry: crash with writeCombined=false leaves a legacy orphan Lucene directory; a retry with
+   * writeCombined=true must recursively delete it (a Lucene HNSW directory is non-empty, so
+   * deleteQuietly alone would silently fail).
+   */
+  @Test
+  public void testCleanOrphansFromOtherExtensionCleansHnswLegacyOrphan()
+      throws Exception {
+    File segmentDir = new File(FileUtils.getTempDirectory(), "vector-orphan-hnsw-legacy-test-" + System.nanoTime());
+    FileUtils.deleteQuietly(segmentDir);
+    assertTrue(segmentDir.mkdirs());
+    try {
+      // Create a non-empty HNSW Lucene directory orphan (simulates a partial prior build).
+      File orphanLegacy = new File(segmentDir,
+          COLUMN + V1Constants.Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION);
+      assertTrue(orphanLegacy.mkdirs());
+      // Add some files inside to make it a non-empty directory (mirrors a real Lucene dir).
+      FileUtils.writeStringToFile(new File(orphanLegacy, "segments_1"), "data",
+          java.nio.charset.StandardCharsets.UTF_8);
+      FileUtils.writeStringToFile(new File(orphanLegacy, "_0.cfs"), "cfs-data",
+          java.nio.charset.StandardCharsets.UTF_8);
+
+      File orphanMarker = new File(segmentDir, orphanLegacy.getName() + ".inprogress");
+      FileUtils.touch(orphanMarker);
+
+      VectorIndexHandler.cleanOrphansFromOtherExtension(segmentDir, COLUMN, VectorBackendType.HNSW,
+          /* currentWriteCombined */ true);
+
+      assertFalse(orphanLegacy.exists(),
+          "Orphan non-empty HNSW Lucene directory from prior flag=false crash must be recursively deleted");
+      assertFalse(orphanMarker.exists(),
+          "Orphan .inprogress marker from prior flag=false crash must be cleaned");
+    } finally {
+      FileUtils.deleteQuietly(segmentDir);
+    }
+  }
+
+  /**
+   * The "absorb combined into columns.psf" step must not remove the column's vector entry first;
+   * doing so would discard the bytes we are about to consolidate. Verify that {@code removeIndex}
+   * is never called along the consolidation path when the backend matches.
+   */
+  @Test
+  public void testUpdateIndicesDoesNotRemoveVectorWhenAbsorbingCombined()
+      throws Exception {
+    File indexDir = createSegmentDirWithVectorIndex(V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Writer writer = mock(SegmentDirectory.Writer.class);
+      when(writer.toSegmentDirectory()).thenReturn(segmentDirectory);
+      // newIndexFor is invoked by LoaderUtils.writeIndexToV3Format under the hood; stub it to a
+      // no-op buffer so we can assert the higher-level contract (no removeIndex, combined gone).
+      when(writer.newIndexFor(eq(COLUMN), eq(StandardIndexes.vector()), any(Long.class)))
+          .thenReturn(PinotDataBuffer.empty());
+
+      VectorIndexHandler handler = createHandler(segmentDirectory,
+          vectorIndexConfigWithConsolidation("IVF_FLAT", /* storeInSegmentFile */ true));
+      handler.updateIndices(writer);
+
+      verify(writer, never()).removeIndex(eq(COLUMN), eq(StandardIndexes.vector()));
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /// Regression: the normal "operator flips storeInSegmentFile on for an existing legacy segment"
+  /// absorb must succeed. The real {@code SingleFileIndexDirectory.hasIndexFor} reports a vector
+  /// index whenever the legacy sidecar is on disk (so the generic load path can build a reader),
+  /// even though no typed {@code columns.psf} entry exists yet — in which case {@code getIndexFor}
+  /// throws. If the crash-recovery branch trusted {@code hasIndexFor} it would mis-read this first
+  /// absorb as "already absorbed" and blow up on {@code getIndexFor().size()}. Detecting the typed
+  /// entry directly (via {@code getConsolidatedVectorEntry}) must let the absorb proceed.
+  @Test
+  public void testUpdateIndicesAbsorbsLegacySidecarWhenNoTypedEntryYet()
+      throws Exception {
+    File indexDir = createSegmentDirWithVectorIndex(V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+    try {
+      SegmentDirectory segmentDirectory = mockSegmentDirectory(indexDir, SegmentVersion.v3);
+      SegmentDirectory.Writer writer = mock(SegmentDirectory.Writer.class);
+      when(writer.toSegmentDirectory()).thenReturn(segmentDirectory);
+      File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+      File sidecar = new File(v3Dir, COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+      // Mirror the real SingleFileIndexDirectory for a legacy-sidecar-only segment: hasIndexFor is
+      // true because the sidecar is on disk, but getIndexFor throws because no typed entry exists.
+      when(writer.hasIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(true);
+      when(writer.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector())))
+          .thenThrow(new RuntimeException("Could not find index for column: " + COLUMN));
+      when(writer.newIndexFor(eq(COLUMN), eq(StandardIndexes.vector()), any(Long.class)))
+          .thenReturn(PinotDataBuffer.empty());
+
+      VectorIndexHandler handler = createHandler(segmentDirectory,
+          vectorIndexConfigWithConsolidation("IVF_FLAT", /* storeInSegmentFile */ true));
+      // Must not throw: the absorb proceeds via newIndexFor and deletes the sidecar.
+      handler.updateIndices(writer);
+
+      verify(writer).newIndexFor(eq(COLUMN), eq(StandardIndexes.vector()), any(Long.class));
+      assertFalse(sidecar.exists(), "legacy sidecar must be deleted after a successful absorb");
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
   private static File createSegmentDirWithVectorIndex(String suffix)
       throws Exception {
     File indexDir = new File(FileUtils.getTempDirectory(), "vector-index-handler-test-" + System.nanoTime());
@@ -119,4 +869,18 @@ public class VectorIndexHandlerTest {
     FileUtils.touch(new File(v3Dir, COLUMN + suffix));
     return indexDir;
   }
+
+  /**
+   * V3 segment directory with no combined file. Used to simulate a segment whose vector payload
+   * is only present as a typed entry inside {@code columns.psf} (the consolidated form).
+   */
+  private static File createEmptyV3SegmentDir()
+      throws Exception {
+    File indexDir = new File(FileUtils.getTempDirectory(), "vector-index-handler-test-" + System.nanoTime());
+    FileUtils.deleteQuietly(indexDir);
+    assertTrue(indexDir.mkdirs());
+    File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+    assertTrue(v3Dir.mkdir());
+    return indexDir;
+  }
 }
diff --git a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfFlatFilterAwareTest.java b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfFlatFilterAwareTest.java
index 00e1df86aa7..85cb51a3125 100644
--- a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfFlatFilterAwareTest.java
+++ b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfFlatFilterAwareTest.java
@@ -24,6 +24,7 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.Random;
 import org.apache.commons.io.FileUtils;
+import org.apache.pinot.segment.local.segment.index.vector.IvfCombinedBuffers;
 import org.apache.pinot.segment.local.segment.index.vector.IvfFlatVectorIndexCreator;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
 import org.roaringbitmap.buffer.ImmutableRoaringBitmap;
@@ -69,7 +70,8 @@ public class IvfFlatFilterAwareTest {
     createIndex(vectors, dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
 
     VectorIndexConfig config = createConfig(dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       // Create a pre-filter that only includes even-numbered docs
       MutableRoaringBitmap preFilter = new MutableRoaringBitmap();
       for (int i = 0; i < numVectors; i += 2) {
@@ -106,7 +108,8 @@ public class IvfFlatFilterAwareTest {
     createIndex(vectors, dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
 
     VectorIndexConfig config = createConfig(dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       MutableRoaringBitmap emptyFilter = new MutableRoaringBitmap();
       float[] queryVector = vectors[0];
       ImmutableRoaringBitmap result = reader.getDocIds(queryVector, 5, emptyFilter);
@@ -125,7 +128,8 @@ public class IvfFlatFilterAwareTest {
     createIndex(vectors, dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
 
     VectorIndexConfig config = createConfig(dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       MutableRoaringBitmap singleDocFilter = new MutableRoaringBitmap();
       singleDocFilter.add(5);
 
@@ -154,7 +158,8 @@ public class IvfFlatFilterAwareTest {
     createIndex(vectors, dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
 
     VectorIndexConfig config = createConfig(dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       // Include all docs except doc 0
       MutableRoaringBitmap highSelectFilter = new MutableRoaringBitmap();
       for (int i = 1; i < numVectors; i++) {
@@ -185,7 +190,8 @@ public class IvfFlatFilterAwareTest {
     createIndex(vectors, dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
 
     VectorIndexConfig config = createConfig(dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       reader.setNprobe(nlist); // Probe all centroids to ensure we find filtered docs
 
       // Only include 3 docs
@@ -219,7 +225,8 @@ public class IvfFlatFilterAwareTest {
     createIndex(vectors, dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
 
     VectorIndexConfig config = createConfig(dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       MutableRoaringBitmap fullFilter = new MutableRoaringBitmap();
       for (int i = 0; i < numVectors; i++) {
         fullFilter.add(i);
@@ -254,7 +261,8 @@ public class IvfFlatFilterAwareTest {
     createIndex(vectors, dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
 
     VectorIndexConfig config = createConfig(dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertTrue(reader.supportsPreFilter(), "IvfFlatVectorIndexReader should support pre-filter");
     }
   }
diff --git a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfOnDiskFilterAwareTest.java b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfOnDiskFilterAwareTest.java
index b03f5791773..af706d99e8e 100644
--- a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfOnDiskFilterAwareTest.java
+++ b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/readers/vector/IvfOnDiskFilterAwareTest.java
@@ -26,9 +26,11 @@ import java.util.Map;
 import java.util.Random;
 import java.util.concurrent.atomic.AtomicInteger;
 import org.apache.commons.io.FileUtils;
+import org.apache.pinot.segment.local.segment.index.vector.IvfCombinedBuffers;
 import org.apache.pinot.segment.local.segment.index.vector.IvfFlatVectorIndexCreator;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
 import org.apache.pinot.segment.spi.index.creator.VectorQuantizerType;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
 import org.roaringbitmap.buffer.ImmutableRoaringBitmap;
 import org.roaringbitmap.buffer.MutableRoaringBitmap;
 import org.testng.Assert;
@@ -69,7 +71,8 @@ public class IvfOnDiskFilterAwareTest {
 
     VectorIndexConfig readerConfig =
         createReaderConfig(dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
-    try (IvfOnDiskVectorIndexReader reader = new IvfOnDiskVectorIndexReader(COLUMN_NAME, _tempDir, readerConfig)) {
+    try (IvfOnDiskVectorIndexReader reader = new IvfOnDiskVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, readerConfig, "test-vector"), readerConfig)) {
       Assert.assertTrue(reader.supportsPreFilter(), "IVF_ON_DISK reader should report pre-filter support");
       reader.setNprobe(nlist);
 
@@ -103,7 +106,8 @@ public class IvfOnDiskFilterAwareTest {
     VectorIndexConfig readerConfig =
         createReaderConfig(dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
     try (CountingIvfOnDiskVectorIndexReader reader =
-             new CountingIvfOnDiskVectorIndexReader(COLUMN_NAME, _tempDir, readerConfig)) {
+             new CountingIvfOnDiskVectorIndexReader(COLUMN_NAME,
+                 IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, readerConfig, "test-vector"), readerConfig)) {
       reader.setNprobe(nlist);
 
       MutableRoaringBitmap preFilter = new MutableRoaringBitmap();
@@ -128,7 +132,8 @@ public class IvfOnDiskFilterAwareTest {
 
     VectorIndexConfig readerConfig =
         createReaderConfig(dimension, nlist, VectorIndexConfig.VectorDistanceFunction.COSINE);
-    try (IvfOnDiskVectorIndexReader reader = new IvfOnDiskVectorIndexReader(COLUMN_NAME, _tempDir, readerConfig)) {
+    try (IvfOnDiskVectorIndexReader reader = new IvfOnDiskVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, readerConfig, "test-vector"), readerConfig)) {
       MutableRoaringBitmap emptyFilter = new MutableRoaringBitmap();
       ImmutableRoaringBitmap result = reader.getDocIds(vectors[0], 5, emptyFilter);
       Assert.assertEquals(result.getCardinality(), 0);
@@ -146,7 +151,8 @@ public class IvfOnDiskFilterAwareTest {
 
     VectorIndexConfig readerConfig =
         createReaderConfig(dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN);
-    try (IvfOnDiskVectorIndexReader reader = new IvfOnDiskVectorIndexReader(COLUMN_NAME, _tempDir, readerConfig)) {
+    try (IvfOnDiskVectorIndexReader reader = new IvfOnDiskVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, readerConfig, "test-vector"), readerConfig)) {
       reader.getDocIds(vectors[0], 5);
 
       MutableRoaringBitmap preFilter = new MutableRoaringBitmap();
@@ -176,7 +182,8 @@ public class IvfOnDiskFilterAwareTest {
     VectorIndexConfig readerConfig =
         createReaderConfig(dimension, nlist, VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN,
             VectorQuantizerType.SQ8);
-    try (IvfOnDiskVectorIndexReader reader = new IvfOnDiskVectorIndexReader(COLUMN_NAME, _tempDir, readerConfig)) {
+    try (IvfOnDiskVectorIndexReader reader = new IvfOnDiskVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, readerConfig, "test-vector"), readerConfig)) {
       reader.setNprobe(nlist);
       ImmutableRoaringBitmap result = reader.getDocIds(vectors[0], 5);
       Assert.assertTrue(result.contains(0), "Quantized IVF_ON_DISK search should still retrieve the stored vector");
@@ -232,8 +239,8 @@ public class IvfOnDiskFilterAwareTest {
   private static final class CountingIvfOnDiskVectorIndexReader extends IvfOnDiskVectorIndexReader {
     private final AtomicInteger _distanceComputations = new AtomicInteger();
 
-    private CountingIvfOnDiskVectorIndexReader(String column, File indexDir, VectorIndexConfig config) {
-      super(column, indexDir, config);
+    private CountingIvfOnDiskVectorIndexReader(String column, PinotDataBuffer buffer, VectorIndexConfig config) {
+      super(column, buffer, config);
     }
 
     @Override
diff --git a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfDiskFormatInspectionTest.java b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfDiskFormatInspectionTest.java
new file mode 100644
index 00000000000..d2b496c172c
--- /dev/null
+++ b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfDiskFormatInspectionTest.java
@@ -0,0 +1,400 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.segment.local.segment.index.vector;
+
+import java.io.File;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.commons.io.FileUtils;
+import org.apache.pinot.segment.local.segment.index.readers.vector.IvfFlatVectorIndexReader;
+import org.apache.pinot.segment.local.segment.index.readers.vector.IvfOnDiskVectorIndexReader;
+import org.apache.pinot.segment.local.segment.index.readers.vector.IvfPqVectorIndexReader;
+import org.apache.pinot.segment.spi.V1Constants;
+import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+
+/**
+ * Disk-format inspection for IVF index files. Builds a tiny index of each IVF variant,
+ * decodes the raw bytes header-by-header against the documented layout, and asserts that
+ * (a) the on-disk fields match the creator config, and (b) the buffer-based reader returns
+ * the same field values via its public API. This is the contract validation between
+ * creator and reader after the PinotBuffer reader rewrite.
+ *
+ * <p>Each test method prints a compact byte-level dump to stdout so disk-format regressions
+ * are visible in build logs.</p>
+ */
+public class IvfDiskFormatInspectionTest {
+
+  private static final String COLUMN = "v";
+  private static final int DIMENSION = 4;
+  private static final int NLIST = 2;
+  private static final int NUM_VECTORS = 8;
+
+  @Test
+  public void testIvfFlatOnDiskHeaderMatchesCreatorConfig()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_format_flat_").toFile();
+    try {
+      VectorIndexConfig config = ivfFlatConfig();
+      try (IvfFlatVectorIndexCreator creator = new IvfFlatVectorIndexCreator(COLUMN, tempDir, config)) {
+        for (int i = 0; i < NUM_VECTORS; i++) {
+          creator.add(makeVector(i));
+        }
+        creator.seal();
+      }
+
+      File indexFile = new File(tempDir, COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+      Assert.assertTrue(indexFile.exists(), "IVF_FLAT combined file must exist");
+      long size = indexFile.length();
+      byte[] all = Files.readAllBytes(indexFile.toPath());
+      System.out.printf("[ivf-flat] file=%s size=%d bytes%n", indexFile.getName(), size);
+      System.out.printf("[ivf-flat] first 32 bytes (hex): %s%n", hex(all, 0, 32));
+
+      // Header: 6 ints big-endian per IvfFlatVectorIndexCreator.writeIndex
+      ByteBuffer bb = ByteBuffer.wrap(all).order(ByteOrder.BIG_ENDIAN);
+      int magic = bb.getInt();
+      int version = bb.getInt();
+      int dim = bb.getInt();
+      int numVec = bb.getInt();
+      int nlist = bb.getInt();
+      int distOrd = bb.getInt();
+      System.out.printf("[ivf-flat] magic=0x%08X version=%d dim=%d numVec=%d nlist=%d distOrd=%d%n",
+          magic, version, dim, numVec, nlist, distOrd);
+
+      Assert.assertEquals(magic, IvfFlatVectorIndexCreator.MAGIC, "magic must be IVFF");
+      Assert.assertEquals(version, IvfFlatVectorIndexCreator.FORMAT_VERSION, "format version");
+      Assert.assertEquals(dim, DIMENSION, "dimension matches config");
+      Assert.assertEquals(numVec, NUM_VECTORS, "num vectors matches input");
+      Assert.assertEquals(nlist, NLIST, "nlist matches config");
+      Assert.assertEquals(VectorIndexConfig.VectorDistanceFunction.values()[distOrd],
+          VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, "distance function");
+
+      // After header: quantizer type ordinal (4 bytes BE) + quantizer params length (4 bytes BE)
+      int quantOrd = bb.getInt();
+      int quantParamLen = bb.getInt();
+      System.out.printf("[ivf-flat] quantizer ordinal=%d, paramLen=%d%n", quantOrd, quantParamLen);
+      Assert.assertEquals(quantParamLen, 0, "FLAT quantizer has no params");
+
+      // Now buffer-based reader must surface the same values via its public API.
+      try (PinotDataBuffer buffer = IvfCombinedBuffers.mapCombinedFile(indexFile, COLUMN, "inspect-flat");
+          IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN, buffer, config)) {
+        System.out.printf("[ivf-flat] reader: dim=%d numVec=%d nlist=%d quantizer=%s%n",
+            reader.getDimension(), reader.getNumVectors(), reader.getNlist(), reader.getQuantizerType());
+        Assert.assertEquals(reader.getDimension(), DIMENSION);
+        Assert.assertEquals(reader.getNumVectors(), NUM_VECTORS);
+        Assert.assertEquals(reader.getNlist(), NLIST);
+      }
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  @Test
+  public void testIvfOnDiskHeaderMatchesCreatorConfig()
+      throws Exception {
+    // IVF_ON_DISK shares the IVF_FLAT on-disk format and file extension; only the reader's runtime
+    // access pattern differs (positional buffer reads vs full heap load). We re-exercise the same
+    // header decode but via the IvfOnDiskVectorIndexReader.
+    File tempDir = Files.createTempDirectory("ivf_format_ondisk_").toFile();
+    try {
+      VectorIndexConfig config = ivfFlatConfig();
+      try (IvfFlatVectorIndexCreator creator = new IvfFlatVectorIndexCreator(COLUMN, tempDir, config)) {
+        for (int i = 0; i < NUM_VECTORS; i++) {
+          creator.add(makeVector(i));
+        }
+        creator.seal();
+      }
+
+      File indexFile = new File(tempDir, COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+      long size = indexFile.length();
+      byte[] all = Files.readAllBytes(indexFile.toPath());
+      System.out.printf("[ivf-on-disk] file=%s size=%d bytes%n", indexFile.getName(), size);
+      System.out.printf("[ivf-on-disk] header (first 24 bytes) hex: %s%n", hex(all, 0, 24));
+      System.out.printf("[ivf-on-disk] footer (last 8 bytes) hex:   %s%n", hex(all, (int) (size - 8), 8));
+
+      // Decode footer: last 8 bytes = offsetToOffsets table (BE long)
+      long offsetToOffsets = ByteBuffer.wrap(all, (int) (size - 8), 8).order(ByteOrder.BIG_ENDIAN).getLong();
+      System.out.printf("[ivf-on-disk] offsetToOffsets=%d (file size=%d)%n", offsetToOffsets, size);
+      Assert.assertTrue(offsetToOffsets > 0 && offsetToOffsets < size - 8,
+          "offsetToOffsets must point inside the file before the footer");
+
+      // Per-list offsets table: NLIST big-endian longs starting at offsetToOffsets
+      ByteBuffer offsetsBuf = ByteBuffer.wrap(all, (int) offsetToOffsets, NLIST * Long.BYTES)
+          .order(ByteOrder.BIG_ENDIAN);
+      long[] listOffsets = new long[NLIST];
+      for (int i = 0; i < NLIST; i++) {
+        listOffsets[i] = offsetsBuf.getLong();
+      }
+      System.out.printf("[ivf-on-disk] listOffsets=%s%n", Arrays.toString(listOffsets));
+      for (int i = 0; i < NLIST; i++) {
+        Assert.assertTrue(listOffsets[i] >= 24 && listOffsets[i] < offsetToOffsets,
+            "list offset " + i + " must lie between header end and offsets table");
+      }
+
+      try (PinotDataBuffer buffer = IvfCombinedBuffers.mapCombinedFile(indexFile, COLUMN, "inspect-ondisk");
+          IvfOnDiskVectorIndexReader reader = new IvfOnDiskVectorIndexReader(COLUMN, buffer, config)) {
+        System.out.printf("[ivf-on-disk] reader: dim=%d numVec=%d nlist=%d%n",
+            reader.getDimension(), reader.getNumVectors(), reader.getNlist());
+        Assert.assertEquals(reader.getDimension(), DIMENSION);
+        Assert.assertEquals(reader.getNumVectors(), NUM_VECTORS);
+        Assert.assertEquals(reader.getNlist(), NLIST);
+      }
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  @Test
+  public void testIvfPqHeaderMatchesCreatorConfig()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_format_pq_").toFile();
+    try {
+      int pqM = 2;
+      int pqNbits = 8;
+      VectorIndexConfig config = ivfPqConfig(pqM, pqNbits);
+      try (IvfPqVectorIndexCreator creator = new IvfPqVectorIndexCreator(COLUMN, tempDir, config)) {
+        for (int i = 0; i < NUM_VECTORS; i++) {
+          creator.add(makeVector(i));
+        }
+        creator.seal();
+      }
+
+      File indexFile = new File(tempDir, COLUMN + IvfPqVectorIndexCreator.INDEX_FILE_EXTENSION);
+      Assert.assertTrue(indexFile.exists(),
+          "IVF_PQ combined file must exist: " + indexFile.getAbsolutePath());
+
+      long size = indexFile.length();
+      byte[] all = Files.readAllBytes(indexFile.toPath());
+      System.out.printf("[ivf-pq] file=%s size=%d bytes%n", indexFile.getName(), size);
+      System.out.printf("[ivf-pq] first 12 bytes (hex): %s%n", hex(all, 0, 12));
+
+      // IVF_PQ magic is 4 bytes "IVPQ" then 4-byte format version little-endian
+      Assert.assertEquals(all[0], (byte) 'I', "magic byte 0");
+      Assert.assertEquals(all[1], (byte) 'V', "magic byte 1");
+      Assert.assertEquals(all[2], (byte) 'P', "magic byte 2");
+      Assert.assertEquals(all[3], (byte) 'Q', "magic byte 3");
+      int versionLe = ByteBuffer.wrap(all, 4, 4).order(ByteOrder.LITTLE_ENDIAN).getInt();
+      System.out.printf("[ivf-pq] magic=IVPQ versionLE=%d%n", versionLe);
+      Assert.assertEquals(versionLe, IvfPqIndexFormat.FORMAT_VERSION,
+          "PQ format version on disk must match constant");
+
+      // Read full payload via IvfPqIndexFormat from a file then from a buffer; both must agree.
+      IvfPqIndexFormat.IndexData fromFile = IvfPqIndexFormat.read(indexFile);
+      try (PinotDataBuffer buffer = IvfCombinedBuffers.mapCombinedFile(indexFile, COLUMN, "inspect-pq")) {
+        IvfPqIndexFormat.IndexData fromBuffer = IvfPqIndexFormat.read(buffer);
+        System.out.printf("[ivf-pq] file:   dim=%d numVec=%d nlist=%d pqM=%d pqNbits=%d%n",
+            fromFile.getDimension(), fromFile.getNumVectors(), fromFile.getNlist(),
+            fromFile.getPqM(), fromFile.getPqNbits());
+        System.out.printf("[ivf-pq] buffer: dim=%d numVec=%d nlist=%d pqM=%d pqNbits=%d%n",
+            fromBuffer.getDimension(), fromBuffer.getNumVectors(), fromBuffer.getNlist(),
+            fromBuffer.getPqM(), fromBuffer.getPqNbits());
+        Assert.assertEquals(fromBuffer.getDimension(), fromFile.getDimension(),
+            "buffer-read dimension matches file-read");
+        Assert.assertEquals(fromBuffer.getNumVectors(), fromFile.getNumVectors(),
+            "buffer-read numVec matches file-read");
+        Assert.assertEquals(fromBuffer.getNlist(), fromFile.getNlist(),
+            "buffer-read nlist matches file-read");
+        Assert.assertEquals(fromBuffer.getPqM(), fromFile.getPqM(),
+            "buffer-read pqM matches file-read");
+        Assert.assertEquals(fromBuffer.getPqNbits(), fromFile.getPqNbits(),
+            "buffer-read pqNbits matches file-read");
+        Assert.assertEquals(fromFile.getDimension(), DIMENSION);
+        Assert.assertEquals(fromFile.getNumVectors(), NUM_VECTORS);
+        Assert.assertEquals(fromFile.getNlist(), NLIST);
+        Assert.assertEquals(fromFile.getPqM(), pqM);
+        Assert.assertEquals(fromFile.getPqNbits(), pqNbits);
+      }
+
+      // And the reader itself
+      try (PinotDataBuffer buffer = IvfCombinedBuffers.mapCombinedFile(indexFile, COLUMN, "inspect-pq-reader");
+          IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN, buffer, config)) {
+        System.out.printf("[ivf-pq] reader: dim=%d numVec=%d nlist=%d pqM=%d pqNbits=%d%n",
+            reader.getDimension(), reader.getNumVectors(), reader.getNlist(),
+            reader.getPqM(), reader.getPqNbits());
+        Assert.assertEquals(reader.getDimension(), DIMENSION);
+        Assert.assertEquals(reader.getNumVectors(), NUM_VECTORS);
+        Assert.assertEquals(reader.getNlist(), NLIST);
+        Assert.assertEquals(reader.getPqM(), pqM);
+        Assert.assertEquals(reader.getPqNbits(), pqNbits);
+      }
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  // -------- helpers --------
+
+  private static VectorIndexConfig ivfFlatConfig() {
+    Map<String, String> props = new HashMap<>();
+    props.put("vectorIndexType", "IVF_FLAT");
+    props.put("vectorDimension", String.valueOf(DIMENSION));
+    props.put("vectorDistanceFunction", "EUCLIDEAN");
+    props.put("nlist", String.valueOf(NLIST));
+    props.put("quantizer", "FLAT");
+    return new VectorIndexConfig(false, "IVF_FLAT", DIMENSION, 1,
+        VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, props);
+  }
+
+  private static VectorIndexConfig ivfPqConfig(int pqM, int pqNbits) {
+    Map<String, String> props = new HashMap<>();
+    props.put("vectorIndexType", "IVF_PQ");
+    props.put("vectorDimension", String.valueOf(DIMENSION));
+    props.put("vectorDistanceFunction", "EUCLIDEAN");
+    props.put("nlist", String.valueOf(NLIST));
+    props.put("pqM", String.valueOf(pqM));
+    props.put("pqNbits", String.valueOf(pqNbits));
+    props.put("trainSampleSize", String.valueOf(NUM_VECTORS));
+    props.put("trainingSeed", "42");
+    return new VectorIndexConfig(false, "IVF_PQ", DIMENSION, 1,
+        VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, props);
+  }
+
+  private static float[] makeVector(int seed) {
+    float[] v = new float[DIMENSION];
+    for (int i = 0; i < DIMENSION; i++) {
+      v[i] = (float) ((seed + 1) * (i + 1));
+    }
+    return v;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Combined-form output (storeInSegmentFile=true)
+  // ---------------------------------------------------------------------------
+
+  /**
+   * When {@code storeInSegmentFile=true}, the IVF_FLAT creator must write to the {@code
+   * .vector.ivfflat.combined.index} extension instead of the legacy {@code .vector.ivfflat.index}
+   * combined. The on-disk bytes are byte-identical to the legacy form; only the file name differs.
+   * The V2→V3 converter picks up the combined extension via the standard {@code copyIndexIfExists}
+   * path and packs the bytes into {@code columns.psf}.
+   */
+  @Test
+  public void testIvfFlatCreatorWritesCombinedExtensionWhenFlagOn()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_flat_combined_").toFile();
+    try {
+      Map<String, String> props = new HashMap<>();
+      props.put("vectorIndexType", "IVF_FLAT");
+      props.put("vectorDimension", String.valueOf(DIMENSION));
+      props.put("vectorDistanceFunction", "EUCLIDEAN");
+      props.put("nlist", String.valueOf(NLIST));
+      props.put("quantizer", "FLAT");
+      props.put(VectorIndexConfig.STORE_IN_SEGMENT_FILE, "true");
+      VectorIndexConfig config = new VectorIndexConfig(false, "IVF_FLAT", DIMENSION, 1,
+          VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, props);
+
+      try (IvfFlatVectorIndexCreator creator = new IvfFlatVectorIndexCreator(COLUMN, tempDir, config)) {
+        for (int i = 0; i < NUM_VECTORS; i++) {
+          creator.add(makeVector(i));
+        }
+        creator.seal();
+      }
+
+      File legacyFile = new File(tempDir, COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+      File combinedFile = new File(tempDir,
+          COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION);
+      Assert.assertFalse(legacyFile.exists(),
+          "Legacy IVF_FLAT combined must NOT exist when storeInSegmentFile=true");
+      Assert.assertTrue(combinedFile.exists(),
+          "Combined IVF_FLAT file must exist when storeInSegmentFile=true: " + combinedFile);
+
+      // Header bytes are identical to the legacy form — only the file name differs.
+      byte[] all = Files.readAllBytes(combinedFile.toPath());
+      ByteBuffer bb = ByteBuffer.wrap(all).order(ByteOrder.BIG_ENDIAN);
+      Assert.assertEquals(bb.getInt(), IvfFlatVectorIndexCreator.MAGIC, "magic must be IVFF");
+      Assert.assertEquals(bb.getInt(), IvfFlatVectorIndexCreator.FORMAT_VERSION, "format version");
+      Assert.assertEquals(bb.getInt(), DIMENSION, "dimension");
+      Assert.assertEquals(bb.getInt(), NUM_VECTORS, "num vectors");
+      Assert.assertEquals(bb.getInt(), NLIST, "nlist");
+      System.out.printf("[ivf-flat-combined] file=%s size=%d bytes — header matches legacy format%n",
+          combinedFile.getName(), all.length);
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  /**
+   * Symmetric coverage for IVF_PQ — same expectations.
+   */
+  @Test
+  public void testIvfPqCreatorWritesCombinedExtensionWhenFlagOn()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_pq_combined_").toFile();
+    try {
+      int pqM = 2;
+      int pqNbits = 8;
+      Map<String, String> props = new HashMap<>();
+      props.put("vectorIndexType", "IVF_PQ");
+      props.put("vectorDimension", String.valueOf(DIMENSION));
+      props.put("vectorDistanceFunction", "EUCLIDEAN");
+      props.put("nlist", String.valueOf(NLIST));
+      props.put("pqM", String.valueOf(pqM));
+      props.put("pqNbits", String.valueOf(pqNbits));
+      props.put("trainSampleSize", String.valueOf(NUM_VECTORS));
+      props.put("trainingSeed", "42");
+      props.put(VectorIndexConfig.STORE_IN_SEGMENT_FILE, "true");
+      VectorIndexConfig config = new VectorIndexConfig(false, "IVF_PQ", DIMENSION, 1,
+          VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, props);
+
+      try (IvfPqVectorIndexCreator creator = new IvfPqVectorIndexCreator(COLUMN, tempDir, config)) {
+        for (int i = 0; i < NUM_VECTORS; i++) {
+          creator.add(makeVector(i));
+        }
+        creator.seal();
+      }
+
+      File legacyFile = new File(tempDir, COLUMN + V1Constants.Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION);
+      File combinedFile = new File(tempDir,
+          COLUMN + V1Constants.Indexes.VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION);
+      Assert.assertFalse(legacyFile.exists(),
+          "Legacy IVF_PQ combined must NOT exist when storeInSegmentFile=true");
+      Assert.assertTrue(combinedFile.exists(),
+          "Combined IVF_PQ file must exist when storeInSegmentFile=true: " + combinedFile);
+
+      // First 4 bytes are still the IVPQ magic — combined form does not change the on-disk format.
+      byte[] head = Files.readAllBytes(combinedFile.toPath());
+      Assert.assertEquals(head[0], (byte) 'I');
+      Assert.assertEquals(head[1], (byte) 'V');
+      Assert.assertEquals(head[2], (byte) 'P');
+      Assert.assertEquals(head[3], (byte) 'Q');
+      System.out.printf("[ivf-pq-combined] file=%s size=%d bytes — magic IVPQ unchanged%n",
+          combinedFile.getName(), head.length);
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  private static String hex(byte[] data, int offset, int length) {
+    StringBuilder sb = new StringBuilder(length * 3);
+    for (int i = 0; i < length; i++) {
+      if (i > 0) {
+        sb.append(' ');
+      }
+      sb.append(String.format("%02X", data[offset + i] & 0xFF));
+    }
+    return sb.toString();
+  }
+}
diff --git a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfFlatVectorIndexTest.java b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfFlatVectorIndexTest.java
index 77741f928e8..c6ba80c6f5f 100644
--- a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfFlatVectorIndexTest.java
+++ b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfFlatVectorIndexTest.java
@@ -208,7 +208,8 @@ public class IvfFlatVectorIndexTest {
     Assert.assertTrue(indexFile.length() > 0, "Index file should not be empty");
 
     // Read back and verify metadata
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertEquals(reader.getDimension(), dimension);
       Assert.assertEquals(reader.getNumVectors(), numVectors);
       Assert.assertEquals(reader.getNlist(), Math.min(nlist, numVectors));
@@ -244,7 +245,8 @@ public class IvfFlatVectorIndexTest {
     File indexFile = new File(_tempDir, COLUMN_NAME + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
     Assert.assertTrue(indexFile.exists(), "Index file should exist after quantized seal()");
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertEquals(reader.getQuantizerType(), quantizerType);
       reader.setNprobe(reader.getNlist());
       ImmutableRoaringBitmap result = reader.getDocIds(vectors[0], 5);
@@ -280,7 +282,8 @@ public class IvfFlatVectorIndexTest {
     }
 
     // Search with nprobe = nlist (exhaustive scan)
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       reader.setNprobe(nlist);
       MutableRoaringBitmap result = (MutableRoaringBitmap) reader.getDocIds(query, topK);
       Assert.assertEquals(result.getCardinality(), topK, "Should return exactly topK results");
@@ -321,7 +324,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       reader.setNprobe(nlist);
       ImmutableRoaringBitmap onlyExactMatch = reader.getDocIdsWithinApproximateRadius(vectors[0], 0.0f, 10);
       Assert.assertTrue(onlyExactMatch.contains(0), "radius 0 should include the exact vector itself");
@@ -365,7 +369,8 @@ public class IvfFlatVectorIndexTest {
     }
 
     // Search
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       // Use full scan for correctness
       reader.setNprobe(nlist);
       MutableRoaringBitmap result = (MutableRoaringBitmap) reader.getDocIds(query, topK);
@@ -403,7 +408,8 @@ public class IvfFlatVectorIndexTest {
     }
 
     // Search with nprobe=1 and nprobe=nlist
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       reader.setNprobe(1);
       MutableRoaringBitmap result1 = (MutableRoaringBitmap) reader.getDocIds(query, topK);
 
@@ -436,7 +442,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertEquals(reader.getNumVectors(), 1);
       Assert.assertEquals(reader.getNlist(), 1);
 
@@ -465,7 +472,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertEquals(reader.getNlist(), 1);
       MutableRoaringBitmap result = (MutableRoaringBitmap) reader.getDocIds(query, topK);
       Assert.assertEquals(result.getCardinality(), topK);
@@ -491,7 +499,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       // Setting nprobe > nlist should be clamped
       reader.setNprobe(100);
       Assert.assertEquals(reader.getNprobe(), nlist, "nprobe should be clamped to nlist");
@@ -518,7 +527,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       int defaultNprobe = Math.min(4, reader.getNlist());
       Assert.assertEquals(reader.getNprobe(), defaultNprobe);
       reader.setNprobe(1);
@@ -545,7 +555,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       int defaultNprobe = reader.getNprobe();
       reader.setNprobe(1);
       Assert.assertEquals(reader.getNprobe(), 1);
@@ -576,7 +587,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertEquals(reader.getDimension(), 1);
 
       // Query for value 5.0, should find docId 5 in top-1
@@ -604,7 +616,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       reader.setNprobe(nlist);
       // Ask for more results than we have vectors
       MutableRoaringBitmap result = (MutableRoaringBitmap) reader.getDocIds(vectors[0], 100);
@@ -630,7 +643,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       // nlist should be clamped to numVectors
       Assert.assertEquals(reader.getNlist(), numVectors,
           "nlist should be clamped to numVectors when nlist > numVectors");
@@ -662,7 +676,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       float[][] centroids = reader.getCentroids();
       Assert.assertEquals(centroids.length, nlist);
 
@@ -696,7 +711,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       int[][] listDocIds = reader.getListDocIds();
       int totalDocs = 0;
       int minSize = Integer.MAX_VALUE;
@@ -741,7 +757,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       reader.setNprobe(8); // Probe 8 out of 32 clusters
 
       float[][] queries = generateRandomVectors(numQueries, dimension, TEST_SEED + 1234);
@@ -811,7 +828,8 @@ public class IvfFlatVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertEquals(reader.getNumVectors(), 0);
       MutableRoaringBitmap result = (MutableRoaringBitmap) reader.getDocIds(new float[]{1, 2, 3, 4}, 5);
       Assert.assertEquals(result.getCardinality(), 0);
diff --git a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfPqVectorIndexTest.java b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfPqVectorIndexTest.java
index bf421c766a8..e7cb9c54db9 100644
--- a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfPqVectorIndexTest.java
+++ b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfPqVectorIndexTest.java
@@ -80,7 +80,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertEquals(reader.getDimension(), dimension);
       Assert.assertEquals(reader.getNumVectors(), vectors.length);
       Assert.assertEquals(reader.getNlist(), nlist);
@@ -111,7 +112,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertEquals(reader.getNumVectors(), 0);
       Assert.assertEquals(reader.getNlist(), 0);
       Assert.assertEquals(((MutableRoaringBitmap) reader.getDocIds(new float[]{1.0f, 2.0f, 3.0f, 4.0f}, 5))
@@ -147,7 +149,8 @@ public class IvfPqVectorIndexTest {
         vectors[115]
     };
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       double recallAtOneProbe = 0.0;
       double recallAtAllProbes = 0.0;
       for (float[] query : queries) {
@@ -189,7 +192,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       reader.setNprobe(nlist);
       MutableRoaringBitmap result = (MutableRoaringBitmap) reader.getDocIds(vectors[7], 5);
       Assert.assertTrue(result.contains(7), "The exact stored vector should remain in the top-K set");
@@ -217,7 +221,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       reader.setNprobe(nlist);
       MutableRoaringBitmap result = (MutableRoaringBitmap) reader.getDocIds(vectors[7], 5);
       Assert.assertTrue(result.contains(7), "The normalized stored vector should remain in the cosine top-K set");
@@ -243,7 +248,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertEquals(reader.getDistanceFunction(), VectorIndexConfig.VectorDistanceFunction.DOT_PRODUCT);
       reader.setNprobe(nlist);
       MutableRoaringBitmap result = (MutableRoaringBitmap) reader.getDocIds(vectors[0], topK);
@@ -277,7 +283,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       float[] query = vectors[0];
 
       reader.setNprobe(1);
@@ -311,7 +318,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       reader.setNprobe(100);
       Assert.assertEquals(reader.getNprobe(), nlist);
     }
@@ -335,7 +343,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       reader.setNprobe(nlist);
       ImmutableRoaringBitmap result =
           reader.getDocIdsWithinApproximateRadius(vectors[0], Float.POSITIVE_INFINITY, 5);
@@ -370,7 +379,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       int defaultNprobe = reader.getNprobe();
       reader.setNprobe(1);
       Assert.assertEquals(reader.getNprobe(), 1);
@@ -402,7 +412,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       reader.setNprobe(1);
       reader.getDocIds(vectors[0], 5);
       Assert.assertEquals(reader.getNprobe(), 1);
@@ -428,7 +439,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       int defaultNprobe = reader.getNprobe();
       reader.setNprobe(1);
       Assert.assertEquals(reader.getNprobe(), 1);
@@ -522,7 +534,8 @@ public class IvfPqVectorIndexTest {
 
     Assert.assertFalse(spillFile.exists(), "Spill file should be cleaned up");
     // Verify the index was created successfully
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertEquals(reader.getNumVectors(), 2);
     }
   }
@@ -552,7 +565,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertEquals(reader.getNumVectors(), vectors.length);
       Assert.assertEquals(reader.getNlist(), vectors.length);
       reader.setNprobe(nlist);
@@ -585,7 +599,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Map<String, Object> info = reader.getIndexDebugInfo();
       Assert.assertEquals(info.get("backend"), "IVF_PQ");
       Assert.assertEquals(info.get("column"), COLUMN_NAME);
@@ -633,7 +648,8 @@ public class IvfPqVectorIndexTest {
       creator.seal();
     }
 
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       int defaultNprobe = (int) reader.getIndexDebugInfo().get("effectiveNprobe");
       reader.setNprobe(1);
       Assert.assertEquals(reader.getIndexDebugInfo().get("effectiveNprobe"), 1);
@@ -681,7 +697,8 @@ public class IvfPqVectorIndexTest {
     creator.close();
 
     // Open reader after creator is fully closed
-    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       Assert.assertEquals(reader.getNumVectors(), vectors.length);
       MutableRoaringBitmap result = (MutableRoaringBitmap) reader.getDocIds(vectors[0], 5);
       Assert.assertTrue(result.getCardinality() > 0);
@@ -706,8 +723,10 @@ public class IvfPqVectorIndexTest {
     }
 
     // Open two readers on the same index concurrently
-    try (IvfPqVectorIndexReader reader1 = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config);
-        IvfPqVectorIndexReader reader2 = new IvfPqVectorIndexReader(COLUMN_NAME, _tempDir, config)) {
+    try (IvfPqVectorIndexReader reader1 = new IvfPqVectorIndexReader(COLUMN_NAME,
+        IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config);
+        IvfPqVectorIndexReader reader2 = new IvfPqVectorIndexReader(COLUMN_NAME,
+            IvfCombinedBuffers.mapCombined(_tempDir, COLUMN_NAME, config, "test-vector"), config)) {
       reader1.setNprobe(1);
       reader2.setNprobe(nlist);
 
@@ -755,7 +774,8 @@ public class IvfPqVectorIndexTest {
         creator.seal();
       }
 
-      try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(column, indexDir, config)) {
+      try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(column,
+          IvfCombinedBuffers.mapCombined(indexDir, column, config, "test-vector"), config)) {
         reader.setNprobe(nlist);
         MutableRoaringBitmap result = (MutableRoaringBitmap) reader.getDocIds(vectors[0], 5);
         Assert.assertEquals(reader.getPqNbits(), pqNbits);
diff --git a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfReaderFailurePathTest.java b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfReaderFailurePathTest.java
new file mode 100644
index 00000000000..1e60964bf36
--- /dev/null
+++ b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/IvfReaderFailurePathTest.java
@@ -0,0 +1,410 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.segment.local.segment.index.vector;
+
+import java.io.File;
+import java.io.RandomAccessFile;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.commons.io.FileUtils;
+import org.apache.pinot.segment.local.segment.index.readers.vector.IvfFlatVectorIndexReader;
+import org.apache.pinot.segment.local.segment.index.readers.vector.IvfOnDiskVectorIndexReader;
+import org.apache.pinot.segment.local.segment.index.readers.vector.IvfPqVectorIndexReader;
+import org.apache.pinot.segment.spi.V1Constants;
+import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+
+/**
+ * Constructor-failure path validation for the IVF buffer-based readers.
+ *
+ * <p>The reader constructors take ownership of the passed-in {@link PinotDataBuffer} and are
+ * responsible for closing it if construction throws (otherwise the caller never receives a reader
+ * to {@code close()}, and the mmap would leak). This test exercises that contract end-to-end:</p>
+ *
+ * <ol>
+ *   <li>Build a valid IVF combined via the unchanged creator.</li>
+ *   <li>Produce a copy whose magic bytes are zeroed out — guaranteed to fail the magic check.</li>
+ *   <li>Snapshot {@link PinotDataBuffer#getMmapBufferCount()} before mapping the corrupted file.</li>
+ *   <li>Map the corrupted file (count goes up by 1) and try to construct the reader (throws).</li>
+ *   <li>Assert the mmap count returns to the snapshot — i.e. the constructor's catch block closed
+ *       the buffer.</li>
+ * </ol>
+ *
+ * <p>One method per IVF variant (FLAT, ON_DISK, PQ). Each also asserts the successful-construction
+ * case is balanced: build → open → construct → close → mmap count back to baseline.</p>
+ */
+public class IvfReaderFailurePathTest {
+
+  private static final String COLUMN = "v";
+  private static final int DIMENSION = 4;
+  private static final int NLIST = 2;
+  private static final int NUM_VECTORS = 8;
+  private static final String OWNER_LABEL = "failure-path-test";
+
+  // ---------------------------------------------------------------------------
+  // IVF_FLAT
+  // ---------------------------------------------------------------------------
+
+  @Test
+  public void testIvfFlatConstructorFailureClosesBuffer()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_failure_flat_").toFile();
+    try {
+      VectorIndexConfig config = ivfFlatConfig();
+      buildIvfFlatIndex(tempDir, config);
+      File combined = new File(tempDir, COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+      File corrupted = corruptMagic(combined);
+
+      // Baseline ----------------------------------------------------------------
+      long baseline = PinotDataBuffer.getMmapBufferCount();
+
+      // Construction must throw, and must release the mmap before propagating.
+      PinotDataBuffer buffer = IvfCombinedBuffers.mapCombinedFile(corrupted, COLUMN, OWNER_LABEL);
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline + 1,
+          "mmap count should have incremented after mapping corrupted file");
+      try {
+        new IvfFlatVectorIndexReader(COLUMN, buffer, config);
+        Assert.fail("Expected RuntimeException from corrupted IVF_FLAT magic");
+      } catch (RuntimeException expected) {
+        // Expected — constructor wraps Preconditions.checkState failure.
+      }
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline,
+          "constructor failure must have closed the buffer (no mmap leak)");
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  @Test
+  public void testIvfFlatSuccessfulCloseBalancesMmapCount()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_success_flat_").toFile();
+    try {
+      VectorIndexConfig config = ivfFlatConfig();
+      buildIvfFlatIndex(tempDir, config);
+
+      long baseline = PinotDataBuffer.getMmapBufferCount();
+      PinotDataBuffer buffer = IvfCombinedBuffers.mapCombined(tempDir, COLUMN, config, OWNER_LABEL);
+      try (IvfFlatVectorIndexReader reader = new IvfFlatVectorIndexReader(COLUMN, buffer, config)) {
+        Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline + 1,
+            "successful construction must hold exactly one extra mmap");
+        Assert.assertEquals(reader.getNumVectors(), NUM_VECTORS);
+      }
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline,
+          "reader.close() must release the mmap");
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // IVF_ON_DISK (shares the IVF_FLAT on-disk format)
+  // ---------------------------------------------------------------------------
+
+  @Test
+  public void testIvfOnDiskConstructorFailureClosesBuffer()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_failure_ondisk_").toFile();
+    try {
+      VectorIndexConfig config = ivfFlatConfig();
+      buildIvfFlatIndex(tempDir, config);
+      File combined = new File(tempDir, COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+      File corrupted = corruptMagic(combined);
+
+      long baseline = PinotDataBuffer.getMmapBufferCount();
+      PinotDataBuffer buffer = IvfCombinedBuffers.mapCombinedFile(corrupted, COLUMN, OWNER_LABEL);
+      try {
+        new IvfOnDiskVectorIndexReader(COLUMN, buffer, config);
+        Assert.fail("Expected RuntimeException from corrupted IVF magic");
+      } catch (RuntimeException expected) {
+        // Expected.
+      }
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline,
+          "constructor failure must have closed the buffer (no mmap leak)");
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  @Test
+  public void testIvfOnDiskSuccessfulCloseBalancesMmapCount()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_success_ondisk_").toFile();
+    try {
+      VectorIndexConfig config = ivfFlatConfig();
+      buildIvfFlatIndex(tempDir, config);
+
+      long baseline = PinotDataBuffer.getMmapBufferCount();
+      PinotDataBuffer buffer = IvfCombinedBuffers.mapCombined(tempDir, COLUMN, config, OWNER_LABEL);
+      try (IvfOnDiskVectorIndexReader reader = new IvfOnDiskVectorIndexReader(COLUMN, buffer, config)) {
+        Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline + 1,
+            "successful construction must hold exactly one extra mmap");
+        Assert.assertEquals(reader.getNumVectors(), NUM_VECTORS);
+      }
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline,
+          "reader.close() must release the mmap");
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // IVF_PQ
+  // ---------------------------------------------------------------------------
+
+  @Test
+  public void testIvfPqConstructorFailureClosesBuffer()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_failure_pq_").toFile();
+    try {
+      VectorIndexConfig config = ivfPqConfig();
+      buildIvfPqIndex(tempDir, config);
+      File combined = new File(tempDir, COLUMN + IvfPqVectorIndexCreator.INDEX_FILE_EXTENSION);
+      File corrupted = corruptMagic(combined);
+
+      long baseline = PinotDataBuffer.getMmapBufferCount();
+      PinotDataBuffer buffer = IvfCombinedBuffers.mapCombinedFile(corrupted, COLUMN, OWNER_LABEL);
+      try {
+        new IvfPqVectorIndexReader(COLUMN, buffer, config);
+        Assert.fail("Expected RuntimeException from corrupted IVF_PQ magic");
+      } catch (RuntimeException expected) {
+        // Expected.
+      }
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline,
+          "constructor failure must have closed the buffer (no mmap leak)");
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  @Test
+  public void testIvfPqSuccessfulCloseBalancesMmapCount()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_success_pq_").toFile();
+    try {
+      VectorIndexConfig config = ivfPqConfig();
+      buildIvfPqIndex(tempDir, config);
+
+      long baseline = PinotDataBuffer.getMmapBufferCount();
+      PinotDataBuffer buffer = IvfCombinedBuffers.mapCombined(tempDir, COLUMN, config, OWNER_LABEL);
+      try (IvfPqVectorIndexReader reader = new IvfPqVectorIndexReader(COLUMN, buffer, config)) {
+        Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline + 1,
+            "successful construction must hold exactly one extra mmap");
+        Assert.assertEquals(reader.getNumVectors(), NUM_VECTORS);
+      }
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline,
+          "reader.close() must release the mmap");
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Borrowed-buffer path (ownsBuffer=false) — used when the buffer comes from columns.psf
+  // ---------------------------------------------------------------------------
+
+  /**
+   * When {@code ownsBuffer=false}, the reader must NOT close the buffer in {@link
+   * org.apache.pinot.segment.local.segment.index.readers.vector.IvfFlatVectorIndexReader#close()}.
+   * The segment directory owns the lifetime in the consolidated path.
+   */
+  @Test
+  public void testIvfFlatBorrowedBufferNotClosedByReader()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_borrowed_flat_").toFile();
+    try {
+      VectorIndexConfig config = ivfFlatConfig();
+      buildIvfFlatIndex(tempDir, config);
+
+      long baseline = PinotDataBuffer.getMmapBufferCount();
+      PinotDataBuffer buffer = IvfCombinedBuffers.mapCombined(tempDir, COLUMN, config, OWNER_LABEL);
+      try (IvfFlatVectorIndexReader reader =
+          new IvfFlatVectorIndexReader(COLUMN, buffer, config, /* ownsBuffer */ false)) {
+        Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline + 1,
+            "construction must hold exactly one extra mmap");
+        Assert.assertEquals(reader.getNumVectors(), NUM_VECTORS);
+      }
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline + 1,
+          "borrowed buffer must survive reader.close()");
+      // Caller (the test) releases it explicitly.
+      buffer.close();
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline);
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  @Test
+  public void testIvfPqBorrowedBufferNotClosedByReader()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_borrowed_pq_").toFile();
+    try {
+      VectorIndexConfig config = ivfPqConfig();
+      buildIvfPqIndex(tempDir, config);
+
+      long baseline = PinotDataBuffer.getMmapBufferCount();
+      PinotDataBuffer buffer = IvfCombinedBuffers.mapCombined(tempDir, COLUMN, config, OWNER_LABEL);
+      try (IvfPqVectorIndexReader reader =
+          new IvfPqVectorIndexReader(COLUMN, buffer, config, /* ownsBuffer */ false)) {
+        Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline + 1);
+        Assert.assertEquals(reader.getNumVectors(), NUM_VECTORS);
+      }
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline + 1,
+          "borrowed buffer must survive reader.close()");
+      buffer.close();
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline);
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  @Test
+  public void testIvfOnDiskBorrowedBufferNotClosedByReader()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_borrowed_ondisk_").toFile();
+    try {
+      VectorIndexConfig config = ivfFlatConfig();
+      buildIvfFlatIndex(tempDir, config);
+
+      long baseline = PinotDataBuffer.getMmapBufferCount();
+      PinotDataBuffer buffer = IvfCombinedBuffers.mapCombined(tempDir, COLUMN, config, OWNER_LABEL);
+      try (IvfOnDiskVectorIndexReader reader =
+          new IvfOnDiskVectorIndexReader(COLUMN, buffer, config, /* ownsBuffer */ false)) {
+        Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline + 1);
+        Assert.assertEquals(reader.getNumVectors(), NUM_VECTORS);
+      }
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline + 1,
+          "borrowed buffer must survive reader.close()");
+      buffer.close();
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline);
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  /**
+   * Constructor failure on a borrowed buffer must NOT close it either — the segment directory
+   * still owns the lifetime even if a particular reader fails to initialise.
+   */
+  @Test
+  public void testIvfFlatBorrowedBufferNotClosedOnConstructorFailure()
+      throws Exception {
+    File tempDir = Files.createTempDirectory("ivf_borrow_fail_flat_").toFile();
+    try {
+      VectorIndexConfig config = ivfFlatConfig();
+      buildIvfFlatIndex(tempDir, config);
+      File combined = new File(tempDir, COLUMN + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+      File corrupted = corruptMagic(combined);
+
+      long baseline = PinotDataBuffer.getMmapBufferCount();
+      PinotDataBuffer buffer = IvfCombinedBuffers.mapCombinedFile(corrupted, COLUMN, OWNER_LABEL);
+      try {
+        new IvfFlatVectorIndexReader(COLUMN, buffer, config, /* ownsBuffer */ false);
+        Assert.fail("Expected RuntimeException from corrupted IVF_FLAT magic");
+      } catch (RuntimeException expected) {
+        // Expected.
+      }
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline + 1,
+          "borrowed buffer must NOT be closed when a borrowed-mode constructor fails");
+      buffer.close();
+      Assert.assertEquals(PinotDataBuffer.getMmapBufferCount(), baseline);
+    } finally {
+      FileUtils.deleteQuietly(tempDir);
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // helpers
+  // ---------------------------------------------------------------------------
+
+  private static void buildIvfFlatIndex(File tempDir, VectorIndexConfig config)
+      throws Exception {
+    try (IvfFlatVectorIndexCreator creator = new IvfFlatVectorIndexCreator(COLUMN, tempDir, config)) {
+      for (int i = 0; i < NUM_VECTORS; i++) {
+        creator.add(makeVector(i));
+      }
+      creator.seal();
+    }
+  }
+
+  private static void buildIvfPqIndex(File tempDir, VectorIndexConfig config)
+      throws Exception {
+    try (IvfPqVectorIndexCreator creator = new IvfPqVectorIndexCreator(COLUMN, tempDir, config)) {
+      for (int i = 0; i < NUM_VECTORS; i++) {
+        creator.add(makeVector(i));
+      }
+      creator.seal();
+    }
+  }
+
+  /**
+   * Returns a copy of {@code source} with the first 4 bytes overwritten with zeros, guaranteed
+   * to fail the magic check in any IVF reader. The corrupted file lives next to the source so
+   * the temp directory clean-up still removes it.
+   */
+  private static File corruptMagic(File source)
+      throws Exception {
+    File corrupted = new File(source.getParentFile(), source.getName() + ".corrupted");
+    Files.copy(source.toPath(), corrupted.toPath(), StandardCopyOption.REPLACE_EXISTING);
+    byte[] zeros = new byte[4];
+    try (RandomAccessFile raf = new RandomAccessFile(corrupted, "rw")) {
+      raf.seek(0);
+      raf.write(zeros);
+    }
+    return corrupted;
+  }
+
+  private static VectorIndexConfig ivfFlatConfig() {
+    Map<String, String> props = new HashMap<>();
+    props.put("vectorIndexType", "IVF_FLAT");
+    props.put("vectorDimension", String.valueOf(DIMENSION));
+    props.put("vectorDistanceFunction", "EUCLIDEAN");
+    props.put("nlist", String.valueOf(NLIST));
+    props.put("quantizer", "FLAT");
+    return new VectorIndexConfig(false, "IVF_FLAT", DIMENSION, 1,
+        VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, props);
+  }
+
+  private static VectorIndexConfig ivfPqConfig() {
+    Map<String, String> props = new HashMap<>();
+    props.put("vectorIndexType", "IVF_PQ");
+    props.put("vectorDimension", String.valueOf(DIMENSION));
+    props.put("vectorDistanceFunction", "EUCLIDEAN");
+    props.put("nlist", String.valueOf(NLIST));
+    props.put("pqM", "2");
+    props.put("pqNbits", "8");
+    props.put("trainSampleSize", String.valueOf(NUM_VECTORS));
+    props.put("trainingSeed", "42");
+    return new VectorIndexConfig(false, "IVF_PQ", DIMENSION, 1,
+        VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, props);
+  }
+
+  private static float[] makeVector(int seed) {
+    float[] v = new float[DIMENSION];
+    for (int i = 0; i < DIMENSION; i++) {
+      v[i] = (float) ((seed + 1) * (i + 1));
+    }
+    return v;
+  }
+}
diff --git a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/VectorIndexTypeTest.java b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/VectorIndexTypeTest.java
index 05ad97dbd55..b0e57f15f88 100644
--- a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/VectorIndexTypeTest.java
+++ b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/VectorIndexTypeTest.java
@@ -19,14 +19,18 @@
 package org.apache.pinot.segment.local.segment.index.vector;
 
 import java.io.File;
+import java.util.HashMap;
 import java.util.Map;
 import org.apache.commons.io.FileUtils;
+import org.apache.pinot.segment.local.segment.creator.impl.vector.HnswVectorIndexCreator;
 import org.apache.pinot.segment.spi.ColumnMetadata;
 import org.apache.pinot.segment.spi.V1Constants;
 import org.apache.pinot.segment.spi.index.FieldIndexConfigs;
 import org.apache.pinot.segment.spi.index.StandardIndexes;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
+import org.apache.pinot.segment.spi.index.reader.VectorIndexReader;
 import org.apache.pinot.segment.spi.store.SegmentDirectory;
+import org.apache.pinot.segment.spi.store.SegmentDirectoryPaths;
 import org.apache.pinot.spi.data.DimensionFieldSpec;
 import org.apache.pinot.spi.data.FieldSpec;
 import org.mockito.Mockito;
@@ -100,4 +104,199 @@ public class VectorIndexTypeTest {
       FileUtils.deleteQuietly(indexDir);
     }
   }
+
+  /**
+   * Regression: with {@code storeInSegmentFile=true} but no consolidated entry in columns.psf (e.g.
+   * a legacy sidecar that the handler has not yet absorbed), the IVF reader factory must fall back
+   * to the on-disk sidecar and return a usable reader — mirroring the HNSW fallback — rather than
+   * returning null and silently disabling the index (forcing an exact scan).
+   */
+  @Test
+  public void testReaderFactoryFallsBackToSidecarWhenStoreInSegmentFileButNoConsolidatedEntry()
+      throws Exception {
+    File indexDir = new File(FileUtils.getTempDirectory(), "vector-index-type-fallback-test-" + System.nanoTime());
+    FileUtils.deleteQuietly(indexDir);
+    try {
+      Assert.assertTrue(indexDir.mkdirs());
+      int dimension = 4;
+      // Build a real IVF_FLAT sidecar at embedding.vector.ivfflat.index in the segment dir.
+      Map<String, String> creatorProps = new HashMap<>();
+      creatorProps.put("vectorIndexType", "IVF_FLAT");
+      creatorProps.put("vectorDimension", String.valueOf(dimension));
+      creatorProps.put("vectorDistanceFunction", "EUCLIDEAN");
+      creatorProps.put("nlist", "2");
+      creatorProps.put("trainingSeed", "42");
+      VectorIndexConfig creatorConfig = new VectorIndexConfig(false, "IVF_FLAT", dimension, 1,
+          VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, creatorProps);
+      try (IvfFlatVectorIndexCreator creator = new IvfFlatVectorIndexCreator("embedding", indexDir, creatorConfig)) {
+        for (int i = 0; i < 8; i++) {
+          creator.add(new float[] {i, i + 1, i + 2, i + 3});
+        }
+        creator.seal();
+      }
+      Assert.assertTrue(
+          new File(indexDir, "embedding" + V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION).exists(),
+          "test setup: IVF_FLAT sidecar must exist");
+
+      SegmentDirectory segmentDirectory = Mockito.mock(SegmentDirectory.class);
+      SegmentDirectory.Reader segmentReader = Mockito.mock(SegmentDirectory.Reader.class);
+      Mockito.when(segmentDirectory.getPath()).thenReturn(indexDir.toPath());
+      Mockito.when(segmentReader.toSegmentDirectory()).thenReturn(segmentDirectory);
+      Mockito.when(segmentReader.hasIndexFor("embedding", StandardIndexes.vector())).thenReturn(true);
+      // No consolidated typed entry yet: getConsolidatedVectorEntry sees the store's "absent" signal
+      // and returns null, which must trigger the sidecar fallback (not a null reader).
+      Mockito.when(segmentReader.getIndexFor("embedding", StandardIndexes.vector()))
+          .thenThrow(new RuntimeException("Could not find index for column: embedding, type: vector"));
+
+      ColumnMetadata metadata = Mockito.mock(ColumnMetadata.class);
+      Mockito.when(metadata.getColumnName()).thenReturn("embedding");
+      Mockito.when(metadata.getDataType()).thenReturn(FieldSpec.DataType.FLOAT);
+      Mockito.when(metadata.getFieldSpec())
+          .thenReturn(new DimensionFieldSpec("embedding", FieldSpec.DataType.FLOAT, false));
+
+      Map<String, String> props = new HashMap<>(creatorProps);
+      props.put(VectorIndexConfig.STORE_IN_SEGMENT_FILE, "true");
+      VectorIndexConfig storeInSegmentFileConfig = new VectorIndexConfig(false, "IVF_FLAT", dimension, 1,
+          VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, props);
+      FieldIndexConfigs fieldIndexConfigs =
+          new FieldIndexConfigs.Builder().add(StandardIndexes.vector(), storeInSegmentFileConfig).build();
+
+      VectorIndexReader reader = StandardIndexes.vector().getReaderFactory()
+          .createIndexReader(segmentReader, fieldIndexConfigs, metadata);
+      Assert.assertNotNull(reader, "IVF reader must fall back to the on-disk sidecar, not return null");
+      // The reader owns the sidecar mmap (ownsBuffer=true) and must close without error.
+      reader.close();
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * Rolling-upgrade safety: with {@code storeInSegmentFile=true} and the legacy HNSW Lucene
+   * directory still on disk (a not-yet-migrated V3 segment, or a V1/V2 segment backed by
+   * {@code FilePerIndexDirectory}), the reader factory must use the directory directly WITHOUT
+   * probing the consolidated entry. On {@code FilePerIndexDirectory} the probe resolves the
+   * directory itself and fails to map it ({@code IllegalArgumentException: ... must be a regular
+   * file}), which used to kill the segment load before the legacy fallback could run.
+   */
+  @Test
+  public void testReaderFactoryUsesLegacyHnswDirectoryWithoutProbingConsolidatedEntry()
+      throws Exception {
+    File indexDir = new File(FileUtils.getTempDirectory(), "vector-index-type-hnsw-legacy-" + System.nanoTime());
+    FileUtils.deleteQuietly(indexDir);
+    try {
+      Assert.assertTrue(indexDir.mkdirs());
+      int dimension = 4;
+      int numDocs = 8;
+      // Build a real legacy HNSW index (storeInSegmentFile=false => Lucene directory on disk).
+      Map<String, String> creatorProps = new HashMap<>();
+      creatorProps.put("commit", "true");
+      creatorProps.put("useCompoundFile", "false");
+      VectorIndexConfig creatorConfig = new VectorIndexConfig(false, "HNSW", dimension, 1,
+          VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, creatorProps);
+      try (HnswVectorIndexCreator creator = new HnswVectorIndexCreator("embedding", indexDir, creatorConfig)) {
+        for (int i = 0; i < numDocs; i++) {
+          creator.add(new float[] {i, i + 1, i + 2, i + 3});
+        }
+        creator.seal();
+      }
+      File hnswDir = new File(indexDir, "embedding" + V1Constants.Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION);
+      Assert.assertTrue(hnswDir.isDirectory(), "test setup: legacy HNSW Lucene directory must exist");
+
+      SegmentDirectory segmentDirectory = Mockito.mock(SegmentDirectory.class);
+      SegmentDirectory.Reader segmentReader = Mockito.mock(SegmentDirectory.Reader.class);
+      Mockito.when(segmentDirectory.getPath()).thenReturn(indexDir.toPath());
+      Mockito.when(segmentReader.toSegmentDirectory()).thenReturn(segmentDirectory);
+      Mockito.when(segmentReader.hasIndexFor("embedding", StandardIndexes.vector())).thenReturn(true);
+      // Mirror FilePerIndexDirectory on a V1/V2 segment: getIndexFor resolves the Lucene DIRECTORY
+      // and mapForReads rejects it. If the factory probes the consolidated entry, this propagates
+      // and fails the load — the legacy-directory-first gate must prevent the call entirely.
+      Mockito.when(segmentReader.getIndexFor("embedding", StandardIndexes.vector()))
+          .thenThrow(new IllegalArgumentException("File: " + hnswDir + " must be a regular file"));
+
+      ColumnMetadata metadata = Mockito.mock(ColumnMetadata.class);
+      Mockito.when(metadata.getColumnName()).thenReturn("embedding");
+      Mockito.when(metadata.getDataType()).thenReturn(FieldSpec.DataType.FLOAT);
+      Mockito.when(metadata.getTotalDocs()).thenReturn(numDocs);
+      Mockito.when(metadata.getFieldSpec())
+          .thenReturn(new DimensionFieldSpec("embedding", FieldSpec.DataType.FLOAT, false));
+
+      Map<String, String> readerProps = new HashMap<>(creatorProps);
+      readerProps.put(VectorIndexConfig.STORE_IN_SEGMENT_FILE, "true");
+      VectorIndexConfig readerConfig = new VectorIndexConfig(false, "HNSW", dimension, 1,
+          VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, readerProps);
+      FieldIndexConfigs fieldIndexConfigs =
+          new FieldIndexConfigs.Builder().add(StandardIndexes.vector(), readerConfig).build();
+
+      VectorIndexReader reader = StandardIndexes.vector().getReaderFactory()
+          .createIndexReader(segmentReader, fieldIndexConfigs, metadata);
+      Assert.assertNotNull(reader, "legacy HNSW directory must be readable with storeInSegmentFile=true");
+      reader.close();
+      // The consolidated-entry probe must never have run while the legacy directory exists.
+      Mockito.verify(segmentReader, Mockito.never()).getIndexFor("embedding", StandardIndexes.vector());
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * V3-layout sibling of the legacy-directory-first test: a not-yet-migrated V3 segment keeps its
+   * Lucene directory under the {@code v3/} subdirectory. The gate's lookup
+   * ({@code SegmentDirectoryPaths.findVectorIndexIndexFile}) must find it there and skip the
+   * consolidated-entry probe the same way.
+   */
+  @Test
+  public void testReaderFactoryUsesLegacyHnswDirectoryInV3LayoutWithoutProbing()
+      throws Exception {
+    File indexDir = new File(FileUtils.getTempDirectory(), "vector-index-type-hnsw-v3-legacy-" + System.nanoTime());
+    FileUtils.deleteQuietly(indexDir);
+    try {
+      File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+      Assert.assertTrue(v3Dir.mkdirs());
+      int dimension = 4;
+      int numDocs = 8;
+      Map<String, String> creatorProps = new HashMap<>();
+      creatorProps.put("commit", "true");
+      creatorProps.put("useCompoundFile", "false");
+      VectorIndexConfig creatorConfig = new VectorIndexConfig(false, "HNSW", dimension, 1,
+          VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, creatorProps);
+      try (HnswVectorIndexCreator creator = new HnswVectorIndexCreator("embedding", v3Dir, creatorConfig)) {
+        for (int i = 0; i < numDocs; i++) {
+          creator.add(new float[] {i, i + 1, i + 2, i + 3});
+        }
+        creator.seal();
+      }
+      Assert.assertTrue(
+          new File(v3Dir, "embedding" + V1Constants.Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION).isDirectory(),
+          "test setup: legacy HNSW directory must exist under v3/");
+
+      SegmentDirectory segmentDirectory = Mockito.mock(SegmentDirectory.class);
+      SegmentDirectory.Reader segmentReader = Mockito.mock(SegmentDirectory.Reader.class);
+      Mockito.when(segmentDirectory.getPath()).thenReturn(indexDir.toPath());
+      Mockito.when(segmentReader.toSegmentDirectory()).thenReturn(segmentDirectory);
+      Mockito.when(segmentReader.hasIndexFor("embedding", StandardIndexes.vector())).thenReturn(true);
+
+      ColumnMetadata metadata = Mockito.mock(ColumnMetadata.class);
+      Mockito.when(metadata.getColumnName()).thenReturn("embedding");
+      Mockito.when(metadata.getDataType()).thenReturn(FieldSpec.DataType.FLOAT);
+      Mockito.when(metadata.getTotalDocs()).thenReturn(numDocs);
+      Mockito.when(metadata.getFieldSpec())
+          .thenReturn(new DimensionFieldSpec("embedding", FieldSpec.DataType.FLOAT, false));
+
+      Map<String, String> readerProps = new HashMap<>(creatorProps);
+      readerProps.put(VectorIndexConfig.STORE_IN_SEGMENT_FILE, "true");
+      VectorIndexConfig readerConfig = new VectorIndexConfig(false, "HNSW", dimension, 1,
+          VectorIndexConfig.VectorDistanceFunction.EUCLIDEAN, readerProps);
+      FieldIndexConfigs fieldIndexConfigs =
+          new FieldIndexConfigs.Builder().add(StandardIndexes.vector(), readerConfig).build();
+
+      VectorIndexReader reader = StandardIndexes.vector().getReaderFactory()
+          .createIndexReader(segmentReader, fieldIndexConfigs, metadata);
+      Assert.assertNotNull(reader, "v3-layout legacy HNSW directory must be readable with storeInSegmentFile=true");
+      reader.close();
+      Mockito.verify(segmentReader, Mockito.never()).getIndexFor("embedding", StandardIndexes.vector());
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
 }
diff --git a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/VectorSearchBenchmark.java b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/VectorSearchBenchmark.java
index a4d3d966e40..b18525fb6b3 100644
--- a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/VectorSearchBenchmark.java
+++ b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/index/vector/VectorSearchBenchmark.java
@@ -98,7 +98,8 @@ public class VectorSearchBenchmark {
       creator.seal();
     }
 
-    _ivfReader = new IvfFlatVectorIndexReader("embedding", _tempDir, config);
+    _ivfReader = new IvfFlatVectorIndexReader("embedding",
+        IvfCombinedBuffers.mapCombined(_tempDir, "embedding", config, "test-vector"), config);
   }
 
   @AfterClass
diff --git a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/store/SegmentDirectoryPathsTest.java b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/store/SegmentDirectoryPathsTest.java
index 6206f82d00d..09cdbdb1274 100644
--- a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/store/SegmentDirectoryPathsTest.java
+++ b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/store/SegmentDirectoryPathsTest.java
@@ -23,6 +23,7 @@ import java.util.Map;
 import org.apache.commons.io.FileUtils;
 import org.apache.pinot.segment.spi.V1Constants;
 import org.apache.pinot.segment.spi.creator.SegmentVersion;
+import org.apache.pinot.segment.spi.index.creator.VectorBackendType;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
 import org.apache.pinot.segment.spi.store.SegmentDirectoryPaths;
 import org.testng.Assert;
@@ -96,4 +97,100 @@ public class SegmentDirectoryPathsTest {
       FileUtils.deleteQuietly(indexDir);
     }
   }
+
+  /**
+   * When only the combined-form IVF file exists on disk (segment built with
+   * {@code storeInSegmentFile=true} whose absorb has not yet run), the lookup must still find it.
+   * Without this the reader factory silently returns null on a flag rollback and ANN queries
+   * degrade to brute-force scan.
+   */
+  @Test
+  public void testFindVectorIndexFileFindsCombinedFormWhenLegacyAbsent()
+      throws Exception {
+    File indexDir = new File(SegmentDirectoryPaths.class.toString() + "_vector_combined");
+    FileUtils.deleteQuietly(indexDir);
+    try {
+      Assert.assertTrue(indexDir.mkdirs());
+      File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+      Assert.assertTrue(v3Dir.mkdir());
+
+      File ivfFlatCombined = new File(v3Dir,
+          "embedding" + V1Constants.Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION);
+      FileUtils.touch(ivfFlatCombined);
+
+      Assert.assertEquals(
+          SegmentDirectoryPaths.findVectorIndexIndexFile(indexDir, "embedding", VectorBackendType.IVF_FLAT),
+          ivfFlatCombined);
+      Assert.assertEquals(
+          SegmentDirectoryPaths.findVectorIndexIndexFile(indexDir, "embedding", VectorBackendType.IVF_ON_DISK),
+          ivfFlatCombined);
+      // The no-backend overload (used by detectVectorIndexBackend) must also find it.
+      Assert.assertEquals(SegmentDirectoryPaths.findVectorIndexIndexFile(indexDir, "embedding"),
+          ivfFlatCombined);
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * When only the HNSW combined-form file exists (segment built with {@code storeInSegmentFile=true}
+   * whose absorb step has not yet run), {@code findVectorIndexIndexFile} must still find it so that
+   * the reader factory can open the index without treating a missing file as "no index".
+   */
+  @Test
+  public void testFindVectorIndexFileFindsCombinedHnswWhenLegacyDirAbsent()
+      throws Exception {
+    File indexDir = new File(SegmentDirectoryPaths.class.toString() + "_vector_hnsw_combined");
+    FileUtils.deleteQuietly(indexDir);
+    try {
+      Assert.assertTrue(indexDir.mkdirs());
+      File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+      Assert.assertTrue(v3Dir.mkdir());
+
+      File hnswCombined = new File(v3Dir,
+          "embedding" + V1Constants.Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION);
+      FileUtils.touch(hnswCombined);
+
+      Assert.assertEquals(
+          SegmentDirectoryPaths.findVectorIndexIndexFile(indexDir, "embedding", VectorBackendType.HNSW),
+          hnswCombined,
+          "findVectorIndexIndexFile must fall back to the combined HNSW extension");
+      // The no-backend overload (used by detectVectorIndexBackend) must also find it.
+      Assert.assertEquals(
+          SegmentDirectoryPaths.findVectorIndexIndexFile(indexDir, "embedding"),
+          hnswCombined);
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
+
+  /**
+   * When both legacy and combined-form IVF files exist (mixed state from a crashed toggle), the
+   * legacy file is returned — preserves the prior behaviour for unchanged segments and lets the
+   * reader factory keep using the well-tested legacy path.
+   */
+  @Test
+  public void testFindVectorIndexFilePrefersLegacyWhenBothExist()
+      throws Exception {
+    File indexDir = new File(SegmentDirectoryPaths.class.toString() + "_vector_mixed");
+    FileUtils.deleteQuietly(indexDir);
+    try {
+      Assert.assertTrue(indexDir.mkdirs());
+      File v3Dir = new File(indexDir, SegmentDirectoryPaths.V3_SUBDIRECTORY_NAME);
+      Assert.assertTrue(v3Dir.mkdir());
+
+      File ivfPqLegacy = new File(v3Dir,
+          "embedding" + V1Constants.Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION);
+      File ivfPqCombined = new File(v3Dir,
+          "embedding" + V1Constants.Indexes.VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION);
+      FileUtils.touch(ivfPqLegacy);
+      FileUtils.touch(ivfPqCombined);
+
+      Assert.assertEquals(
+          SegmentDirectoryPaths.findVectorIndexIndexFile(indexDir, "embedding", VectorBackendType.IVF_PQ),
+          ivfPqLegacy);
+    } finally {
+      FileUtils.deleteQuietly(indexDir);
+    }
+  }
 }
diff --git a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/store/VectorIndexUtilsTest.java b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/store/VectorIndexUtilsTest.java
index 9541aed5062..ee981735c06 100644
--- a/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/store/VectorIndexUtilsTest.java
+++ b/pinot-segment-local/src/test/java/org/apache/pinot/segment/local/segment/store/VectorIndexUtilsTest.java
@@ -20,16 +20,25 @@ package org.apache.pinot.segment.local.segment.store;
 
 import java.io.File;
 import java.io.IOException;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
 import org.apache.commons.io.FileUtils;
 import org.apache.lucene.index.VectorSimilarityFunction;
 import org.apache.pinot.segment.spi.V1Constants.Indexes;
+import org.apache.pinot.segment.spi.index.StandardIndexes;
 import org.apache.pinot.segment.spi.index.creator.VectorBackendType;
 import org.apache.pinot.segment.spi.index.creator.VectorIndexConfig;
+import org.apache.pinot.segment.spi.memory.PinotDataBuffer;
+import org.apache.pinot.segment.spi.store.SegmentDirectory;
 import org.testng.Assert;
 import org.testng.annotations.AfterMethod;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
 
 /**
  * Tests for {@link VectorIndexUtils}.
@@ -81,6 +90,26 @@ public class VectorIndexUtilsTest {
     Assert.assertEquals(VectorIndexUtils.detectVectorIndexBackend(_tempDir, COLUMN), VectorBackendType.IVF_PQ);
   }
 
+  @Test
+  public void testHasVectorIndexExcludesCombinedForm()
+      throws IOException {
+    // The combined-form extension is the transient consolidated file meant to be packed into
+    // columns.psf by the V2→V3 converter — not preserved as a sibling. hasVectorIndex (used by
+    // the converter's "skip standard copy" gate) must return false when only the combined form
+    // exists so the bytes get packed instead of dropped.
+    touch(COLUMN + Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION);
+    Assert.assertFalse(VectorIndexUtils.hasVectorIndex(_tempDir, COLUMN));
+    Assert.assertTrue(VectorIndexUtils.hasCombinedFormVectorIndex(_tempDir, COLUMN));
+  }
+
+  @Test
+  public void testHasCombinedFormVectorIndexDetectsBothBackends()
+      throws IOException {
+    Assert.assertFalse(VectorIndexUtils.hasCombinedFormVectorIndex(_tempDir, COLUMN));
+    touch(COLUMN + Indexes.VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION);
+    Assert.assertTrue(VectorIndexUtils.hasCombinedFormVectorIndex(_tempDir, COLUMN));
+  }
+
   @Test
   public void testGetIndexFileExtensionMatchesBackend() {
     Assert.assertEquals(VectorIndexUtils.getIndexFileExtension(VectorBackendType.HNSW),
@@ -91,6 +120,27 @@ public class VectorIndexUtilsTest {
         Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION);
   }
 
+  @Test
+  public void testGetIndexFileExtensionCombinedReturnsHnswCombined() {
+    Assert.assertEquals(VectorIndexUtils.getIndexFileExtension(VectorBackendType.HNSW, /* combined */ true),
+        Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION);
+    // Non-combined HNSW must still return the legacy extension.
+    Assert.assertEquals(VectorIndexUtils.getIndexFileExtension(VectorBackendType.HNSW, /* combined */ false),
+        Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION);
+  }
+
+  @Test
+  public void testHasCombinedFormVectorIndexDetectsHnswCombined()
+      throws IOException {
+    Assert.assertFalse(VectorIndexUtils.hasCombinedFormVectorIndex(_tempDir, COLUMN));
+    touch(COLUMN + Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION);
+    Assert.assertTrue(VectorIndexUtils.hasCombinedFormVectorIndex(_tempDir, COLUMN),
+        "hasCombinedFormVectorIndex must return true when only HNSW combined file exists");
+    // hasVectorIndex must return false — the combined form is transient, not a sidecar.
+    Assert.assertFalse(VectorIndexUtils.hasVectorIndex(_tempDir, COLUMN),
+        "hasVectorIndex must not report the HNSW combined form as a sidecar");
+  }
+
   @Test
   public void testToSimilarityFunctionSupportsDistanceAliases() {
     Assert.assertEquals(VectorIndexUtils.toSimilarityFunction(VectorIndexConfig.VectorDistanceFunction.COSINE),
@@ -105,6 +155,155 @@ public class VectorIndexUtilsTest {
         VectorSimilarityFunction.EUCLIDEAN);
   }
 
+  @Test
+  public void testGetConsolidatedVectorEntryReturnsNullWhenEntryMissing()
+      throws IOException {
+    SegmentDirectory.Reader reader = mock(SegmentDirectory.Reader.class);
+    // Real "absent typed entry" signal, built from the shared prefix the store classes throw.
+    when(reader.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector())))
+        .thenThrow(new RuntimeException(
+            SingleFileIndexDirectory.INDEX_NOT_FOUND_MESSAGE_PREFIX + ": " + COLUMN + ", type: vector"));
+    Assert.assertNull(VectorIndexUtils.getConsolidatedVectorEntry(reader, COLUMN),
+        "missing typed entry must map to null");
+  }
+
+  @Test
+  public void testGetConsolidatedVectorEntryRethrowsUnexpectedRuntimeException()
+      throws IOException {
+    SegmentDirectory.Reader reader = mock(SegmentDirectory.Reader.class);
+    // A non-"absent" RuntimeException (e.g. corruption) must propagate, not be masked as absent.
+    when(reader.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector())))
+        .thenThrow(new RuntimeException("Inconsistent data read. Index data file is possibly corrupted"));
+    try {
+      VectorIndexUtils.getConsolidatedVectorEntry(reader, COLUMN);
+      Assert.fail("corruption RuntimeException must propagate, not be swallowed as 'absent'");
+    } catch (RuntimeException expected) {
+      Assert.assertTrue(expected.getMessage().contains("possibly corrupted"),
+          "original error must be preserved; got: " + expected.getMessage());
+    }
+  }
+
+  @Test
+  public void testGetConsolidatedVectorEntryReturnsBufferWhenPresent()
+      throws IOException {
+    SegmentDirectory.Reader reader = mock(SegmentDirectory.Reader.class);
+    PinotDataBuffer buffer = PinotDataBuffer.empty();
+    when(reader.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(buffer);
+    Assert.assertSame(VectorIndexUtils.getConsolidatedVectorEntry(reader, COLUMN), buffer,
+        "present typed entry must be returned as-is");
+  }
+
+  /**
+   * The HNSW extract path unpacks into temp artifacts ({@code .vector.extract-tmp},
+   * {@code .vector.hnsw.extract-tmp-dir}) and relies on {@code removeIndex} → {@code cleanupVectorIndex}
+   * NOT deleting them. Pin that invariant against the real cleanup, independent of the handler's stub.
+   */
+  @Test
+  public void testCleanupVectorIndexLeavesExtractTempArtifacts()
+      throws IOException {
+    // A recognised artifact that cleanup must delete (modelling the legacy Lucene directory as a dir).
+    File hnswDir = new File(_tempDir, COLUMN + Indexes.VECTOR_V912_HNSW_INDEX_FILE_EXTENSION);
+    Assert.assertTrue(hnswDir.mkdir());
+    FileUtils.touch(new File(hnswDir, "segments_1"));
+    // Temp artifacts the extract path uses; their names are not in cleanup's delete list.
+    File tempFile = new File(_tempDir, COLUMN + ".vector.extract-tmp");
+    FileUtils.touch(tempFile);
+    File tempDir = new File(_tempDir, COLUMN + ".vector.hnsw.extract-tmp-dir");
+    Assert.assertTrue(tempDir.mkdir());
+    FileUtils.touch(new File(tempDir, "segments_1"));
+
+    VectorIndexUtils.cleanupVectorIndex(_tempDir, COLUMN);
+
+    Assert.assertFalse(hnswDir.exists(), "recognised legacy HNSW directory must be deleted");
+    Assert.assertTrue(tempFile.exists(), "temp extract file must survive cleanup");
+    Assert.assertTrue(tempDir.isDirectory(), "temp extract directory must survive cleanup");
+  }
+
+  @Test
+  public void testSniffVectorPayloadBackendClassifiesByMagic()
+      throws IOException {
+    // HNSW combined pack: "LUCENE_V2" magic string.
+    Assert.assertEquals(sniff("LUCENE_V2".getBytes(StandardCharsets.US_ASCII)), VectorBackendType.HNSW);
+    // IVF magics: 4 ASCII bytes in file order.
+    Assert.assertEquals(sniff(new byte[]{'I', 'V', 'F', 'F', 0, 0, 0, 1}), VectorBackendType.IVF_FLAT);
+    Assert.assertEquals(sniff(new byte[]{'I', 'V', 'P', 'Q', 0, 0, 0, 1}), VectorBackendType.IVF_PQ);
+    // Unknown magic and too-short payloads classify as null, never as a wrong backend.
+    Assert.assertNull(sniff(new byte[]{(byte) 0xAB, (byte) 0xCD, (byte) 0xEF, 0x01}));
+    Assert.assertNull(sniff(new byte[]{'I', 'V'}));
+  }
+
+  @Test
+  public void testDetectConsolidatedVectorBackendReadsTypedEntryMagic()
+      throws IOException {
+    SegmentDirectory.Reader reader = mock(SegmentDirectory.Reader.class);
+    byte[] payload = {'I', 'V', 'P', 'Q', 2, 0, 0, 0};
+    PinotDataBuffer buffer = PinotDataBuffer.allocateDirect(payload.length, ByteOrder.BIG_ENDIAN,
+        "sniff-test");
+    try {
+      buffer.readFrom(0, payload, 0, payload.length);
+      when(reader.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector()))).thenReturn(buffer);
+      Assert.assertEquals(VectorIndexUtils.detectConsolidatedVectorBackend(reader, COLUMN),
+          VectorBackendType.IVF_PQ);
+    } finally {
+      buffer.close();
+    }
+    // Absent entry maps to null via getConsolidatedVectorEntry.
+    SegmentDirectory.Reader emptyReader = mock(SegmentDirectory.Reader.class);
+    when(emptyReader.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector())))
+        .thenThrow(new RuntimeException(
+            SingleFileIndexDirectory.INDEX_NOT_FOUND_MESSAGE_PREFIX + ": " + COLUMN));
+    Assert.assertNull(VectorIndexUtils.detectConsolidatedVectorBackend(emptyReader, COLUMN));
+  }
+
+  /**
+   * V1/V2 {@code FilePerIndexDirectory} resolves a still-present legacy HNSW Lucene DIRECTORY as
+   * the vector artifact and throws {@code IllegalArgumentException(... must be a regular file)}
+   * from {@code mapForReads}. A directory can never be a packed typed entry, so the probe must map
+   * that to null ("no consolidated entry") instead of killing the caller's segment load.
+   */
+  @Test
+  public void testGetConsolidatedVectorEntryTreatsUnmappableDirectoryAsAbsent()
+      throws IOException {
+    SegmentDirectory.Reader reader = mock(SegmentDirectory.Reader.class);
+    when(reader.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector())))
+        .thenThrow(new IllegalArgumentException("File: /seg/" + COLUMN + ".vector.v912.hnsw.index"
+            + FilePerIndexDirectory.NOT_A_REGULAR_FILE_MESSAGE_SUFFIX));
+    Assert.assertNull(VectorIndexUtils.getConsolidatedVectorEntry(reader, COLUMN),
+        "unmappable-directory resolution must map to 'no consolidated entry'");
+
+    // Any other IllegalArgumentException must still propagate — only the directory case is benign.
+    SegmentDirectory.Reader otherReader = mock(SegmentDirectory.Reader.class);
+    when(otherReader.getIndexFor(eq(COLUMN), eq(StandardIndexes.vector())))
+        .thenThrow(new IllegalArgumentException("File size must be less than 2GB"));
+    try {
+      VectorIndexUtils.getConsolidatedVectorEntry(otherReader, COLUMN);
+      Assert.fail("unrelated IllegalArgumentException must propagate");
+    } catch (IllegalArgumentException expected) {
+      Assert.assertTrue(expected.getMessage().contains("2GB"));
+    }
+  }
+
+  @Test
+  public void testStorageFormatOfAliasesIvfOnDiskToIvfFlat() {
+    Assert.assertEquals(VectorIndexUtils.storageFormatOf(VectorBackendType.IVF_ON_DISK),
+        VectorBackendType.IVF_FLAT, "IVF_ON_DISK shares the IVF_FLAT storage format");
+    Assert.assertEquals(VectorIndexUtils.storageFormatOf(VectorBackendType.IVF_FLAT), VectorBackendType.IVF_FLAT);
+    Assert.assertEquals(VectorIndexUtils.storageFormatOf(VectorBackendType.IVF_PQ), VectorBackendType.IVF_PQ);
+    Assert.assertEquals(VectorIndexUtils.storageFormatOf(VectorBackendType.HNSW), VectorBackendType.HNSW);
+  }
+
+  private static VectorBackendType sniff(byte[] payload)
+      throws IOException {
+    PinotDataBuffer buffer = PinotDataBuffer.allocateDirect(payload.length, ByteOrder.BIG_ENDIAN,
+        "sniff-test");
+    try {
+      buffer.readFrom(0, payload, 0, payload.length);
+      return VectorIndexUtils.sniffVectorPayloadBackend(buffer);
+    } finally {
+      buffer.close();
+    }
+  }
+
   private void touch(String fileName)
       throws IOException {
     FileUtils.touch(new File(_tempDir, fileName));
diff --git a/pinot-segment-spi/src/main/java/org/apache/pinot/segment/spi/V1Constants.java b/pinot-segment-spi/src/main/java/org/apache/pinot/segment/spi/V1Constants.java
index 84adb3b421c..d611f2d2620 100644
--- a/pinot-segment-spi/src/main/java/org/apache/pinot/segment/spi/V1Constants.java
+++ b/pinot-segment-spi/src/main/java/org/apache/pinot/segment/spi/V1Constants.java
@@ -73,6 +73,24 @@ public class V1Constants {
     public static final String VECTOR_HNSW_INDEX_DOCID_MAPPING_FILE_EXTENSION = ".vector.hnsw.mapping";
     public static final String VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION = ".vector.ivfflat.index";
     public static final String VECTOR_IVF_PQ_INDEX_FILE_EXTENSION = ".vector.ivfpq.index";
+    /**
+     * Combined-form IVF file extensions. Written by the IVF creators when
+     * {@code VectorIndexConfig.storeInSegmentFile} is {@code true}; consumed (and removed) by the
+     * V2→V3 format converter, which packs the bytes into {@code columns.psf} as a typed entry via
+     * the standard {@code copyIndexIfExists} loop. Mirrors the text-index {@code .text.index}
+     * extension that signals "ready to be consolidated into the combined segment file."
+     */
+    public static final String VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION = ".vector.ivfflat.combined.index";
+    public static final String VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION = ".vector.ivfpq.combined.index";
+    /**
+     * Combined-form HNSW file — packs the Lucene HNSW directory's files (and the optional docId
+     * mapping file) into a single file using the same LUCENE_V2 layout the text index uses.
+     * Build-time transient: the V2→V3 converter packs it into {@code columns.psf} and removes the
+     * sibling. At read time the bytes are exposed as a Lucene {@code Directory} backed by a
+     * {@code PinotDataBuffer} slice, so {@code KnnVectorsReader} works against the consolidated
+     * entry without re-extracting to disk.
+     */
+    public static final String VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION = ".vector.hnsw.combined.index";
   }
 
   public static class MetadataKeys {
diff --git a/pinot-segment-spi/src/main/java/org/apache/pinot/segment/spi/index/creator/VectorIndexConfig.java b/pinot-segment-spi/src/main/java/org/apache/pinot/segment/spi/index/creator/VectorIndexConfig.java
index 11da1c79866..3bc65794843 100644
--- a/pinot-segment-spi/src/main/java/org/apache/pinot/segment/spi/index/creator/VectorIndexConfig.java
+++ b/pinot-segment-spi/src/main/java/org/apache/pinot/segment/spi/index/creator/VectorIndexConfig.java
@@ -19,6 +19,7 @@
 package org.apache.pinot.segment.spi.index.creator;
 
 import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.google.common.base.Preconditions;
 import java.util.Map;
@@ -26,21 +27,19 @@ import javax.annotation.Nullable;
 import org.apache.pinot.spi.config.table.IndexConfig;
 
 
-/**
- * Config for vector index.
- *
- * <p>This is the backend-neutral configuration for all vector index types. Common fields include
- * {@code vectorIndexType}, {@code vectorDimension}, {@code vectorDistanceFunction}, and {@code version}.
- * All backend-specific configuration (e.g., HNSW maxCon/beamWidth, IVF_FLAT nlist/trainSampleSize)
- * is stored in the {@code properties} map.</p>
- *
- * <p>The {@code vectorIndexType} field determines which backend is used. If absent or null, it defaults
- * to {@code HNSW} for backward compatibility. Use {@link #resolveBackendType()} to safely resolve the
- * backend type with this default applied.</p>
- *
- * @see VectorBackendType
- * @see VectorIndexConfigValidator
- */
+/// Config for vector index.
+///
+/// This is the backend-neutral configuration for all vector index types. Common fields include
+/// {@code vectorIndexType}, {@code vectorDimension}, {@code vectorDistanceFunction}, and {@code version}.
+/// All backend-specific configuration (e.g., HNSW maxCon/beamWidth, IVF_FLAT nlist/trainSampleSize)
+/// is stored in the {@code properties} map.
+///
+/// The {@code vectorIndexType} field determines which backend is used. If absent or null, it defaults
+/// to {@code HNSW} for backward compatibility. Use {@link #resolveBackendType()} to safely resolve the
+/// backend type with this default applied.
+///
+/// @see VectorBackendType
+/// @see VectorIndexConfigValidator
 public class VectorIndexConfig extends IndexConfig {
   public static final VectorIndexConfig DISABLED = new VectorIndexConfig(true);
   private static final String VECTOR_INDEX_TYPE = "vectorIndexType";
@@ -51,15 +50,20 @@ public class VectorIndexConfig extends IndexConfig {
   private static final VectorDistanceFunction DEFAULT_VECTOR_DISTANCE_FUNCTION =
       VectorDistanceFunction.COSINE;
 
+  /// Key in {@link #_properties} controlling whether the IVF vector index payload is consolidated
+  /// into the segment's combined index file ({@code columns.psf}) instead of living as a separate
+  /// combined file. Default {@code false} preserves the legacy combined layout. Mirrors the text
+  /// index's {@code storeInSegmentFile} flag.
+  public static final String STORE_IN_SEGMENT_FILE = "storeInSegmentFile";
+  public static final boolean DEFAULT_STORE_IN_SEGMENT_FILE = false;
+
   private String _vectorIndexType;
   private int _vectorDimension;
   private int _version;
   private VectorDistanceFunction _vectorDistanceFunction;
   private Map<String, String> _properties;
 
-  /**
-   * @param disabled whether the config is disabled. Null is considered enabled.
-   */
+  /// @param disabled whether the config is disabled. Null is considered enabled.
   public VectorIndexConfig(Boolean disabled) {
     super(disabled);
   }
@@ -139,13 +143,37 @@ public class VectorIndexConfig extends IndexConfig {
     return this;
   }
 
-  /**
-   * Resolves the {@link VectorBackendType} for this config. If {@code vectorIndexType} is null or empty,
-   * defaults to {@link VectorBackendType#HNSW} for backward compatibility.
-   *
-   * @return the resolved backend type
-   * @throws IllegalArgumentException if vectorIndexType is set to an unrecognized value
-   */
+  /// Whether the vector index payload is consolidated into the segment's combined index file
+  /// ({@code columns.psf}) rather than left beside it as a sidecar. Default {@code false}. Only
+  /// applies to V3 segments, and covers both IVF and HNSW backends.
+  ///
+  /// When {@code true} the segment build first produces a transient combined file (the IVF creator
+  /// writes the IVF `.combined.index`; for HNSW the Lucene directory is packed into
+  /// `.vector.hnsw.combined.index`); the {@code VectorIndexHandler} / V2→V3 converter then absorbs
+  /// it into {@code columns.psf} as a typed entry and deletes the sibling. The reader path is
+  /// selected by this flag — flag-on reads from
+  /// {@code segmentReader.getIndexFor(column, StandardIndexes.vector())} (the IVF reader consumes
+  /// the buffer directly; the HNSW reader builds a buffer-backed Lucene `Directory` over it),
+  /// flag-off reads the legacy sidecar (IVF combined mmap or HNSW Lucene directory).
+  ///
+  /// This accessor is intentionally not a JSON property: the value is carried inside the
+  /// {@code properties} map (key {@link #STORE_IN_SEGMENT_FILE}). Marking it {@link JsonIgnore}
+  /// keeps the on-wire shape of {@code VectorIndexConfig} unchanged for callers that round-trip
+  /// the config through Jackson.
+  @JsonIgnore
+  public boolean isStoreInSegmentFile() {
+    if (_properties == null) {
+      return DEFAULT_STORE_IN_SEGMENT_FILE;
+    }
+    String value = _properties.get(STORE_IN_SEGMENT_FILE);
+    return value == null ? DEFAULT_STORE_IN_SEGMENT_FILE : Boolean.parseBoolean(value);
+  }
+
+  /// Resolves the {@link VectorBackendType} for this config. If {@code vectorIndexType} is null or empty,
+  /// defaults to {@link VectorBackendType#HNSW} for backward compatibility.
+  ///
+  /// @return the resolved backend type
+  /// @throws IllegalArgumentException if vectorIndexType is set to an unrecognized value
   public VectorBackendType resolveBackendType() {
     return VectorIndexConfigValidator.resolveBackendType(this);
   }
@@ -156,12 +184,10 @@ public class VectorIndexConfig extends IndexConfig {
         + _vectorDistanceFunction + ", _properties=" + _properties + '}';
   }
 
-  /**
-   * Distance functions supported by vector indexes.
-   *
-   * <p>Note: {@code L2} is an alias for {@code EUCLIDEAN}. Both refer to Euclidean (L2) distance.
-   * Existing configs using {@code EUCLIDEAN} continue to work unchanged.</p>
-   */
+  /// Distance functions supported by vector indexes.
+  ///
+  /// Note: {@code L2} is an alias for {@code EUCLIDEAN}. Both refer to Euclidean (L2) distance.
+  /// Existing configs using {@code EUCLIDEAN} continue to work unchanged.
   public enum VectorDistanceFunction {
     COSINE, INNER_PRODUCT, EUCLIDEAN, DOT_PRODUCT, L2;
   }
diff --git a/pinot-segment-spi/src/main/java/org/apache/pinot/segment/spi/store/SegmentDirectoryPaths.java b/pinot-segment-spi/src/main/java/org/apache/pinot/segment/spi/store/SegmentDirectoryPaths.java
index ce7eca5c7eb..8207c188aa5 100644
--- a/pinot-segment-spi/src/main/java/org/apache/pinot/segment/spi/store/SegmentDirectoryPaths.java
+++ b/pinot-segment-spi/src/main/java/org/apache/pinot/segment/spi/store/SegmentDirectoryPaths.java
@@ -134,12 +134,14 @@ public class SegmentDirectoryPaths {
   public static File findVectorIndexIndexFile(File segmentIndexDir, String column) {
     File formatFile = findHnswVectorIndexFile(segmentIndexDir, column);
     if (formatFile == null) {
-      formatFile = findFlatVectorIndexFile(segmentIndexDir, column,
-          V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+      formatFile = findIvfVectorIndexFile(segmentIndexDir, column,
+          V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION,
+          V1Constants.Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION);
     }
     if (formatFile == null) {
-      formatFile = findFlatVectorIndexFile(segmentIndexDir, column,
-          V1Constants.Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION);
+      formatFile = findIvfVectorIndexFile(segmentIndexDir, column,
+          V1Constants.Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION,
+          V1Constants.Indexes.VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION);
     }
     return formatFile;
   }
@@ -160,20 +162,36 @@ public class SegmentDirectoryPaths {
       case HNSW:
         return findHnswVectorIndexFile(segmentIndexDir, column);
       case IVF_FLAT:
-        return findFlatVectorIndexFile(segmentIndexDir, column,
-            V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+        return findIvfVectorIndexFile(segmentIndexDir, column,
+            V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION,
+            V1Constants.Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION);
       case IVF_PQ:
-        return findFlatVectorIndexFile(segmentIndexDir, column,
-            V1Constants.Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION);
+        return findIvfVectorIndexFile(segmentIndexDir, column,
+            V1Constants.Indexes.VECTOR_IVF_PQ_INDEX_FILE_EXTENSION,
+            V1Constants.Indexes.VECTOR_IVF_PQ_COMBINED_INDEX_FILE_EXTENSION);
       case IVF_ON_DISK:
         // IVF_ON_DISK reuses the IVF_FLAT file format with FileChannel random-access reads
-        return findFlatVectorIndexFile(segmentIndexDir, column,
-            V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION);
+        return findIvfVectorIndexFile(segmentIndexDir, column,
+            V1Constants.Indexes.VECTOR_IVF_FLAT_INDEX_FILE_EXTENSION,
+            V1Constants.Indexes.VECTOR_IVF_FLAT_COMBINED_INDEX_FILE_EXTENSION);
       default:
         throw new IllegalStateException("Unsupported vector backend type: " + backendType);
     }
   }
 
+  /**
+   * Probes for an IVF vector index file under either the legacy extension (sidecar layout) or
+   * the combined extension (transient single-file form left on disk when a build with
+   * {@code storeInSegmentFile=true} has not yet been absorbed into {@code columns.psf}). Legacy
+   * wins if both are present so the caller's behaviour is stable for unchanged segments.
+   */
+  @Nullable
+  private static File findIvfVectorIndexFile(File segmentIndexDir, String column, String legacyExtension,
+      String combinedExtension) {
+    File legacy = findFlatVectorIndexFile(segmentIndexDir, column, legacyExtension);
+    return legacy != null ? legacy : findFlatVectorIndexFile(segmentIndexDir, column, combinedExtension);
+  }
+
   /**
    * Find a file in any segment version.
    * <p>Index directory passed in should be top level segment directory.
@@ -211,6 +229,13 @@ public class SegmentDirectoryPaths {
       vectorIndexDirectory = column + V1Constants.Indexes.VECTOR_HNSW_INDEX_FILE_EXTENSION;
       formatFile = findFormatFile(segmentIndexDir, vectorIndexDirectory);
     }
+    // Combined-form: a single packed file built by HnswVectorIndexCombined that bundles the
+    // Lucene HNSW directory's contents. Probed after the legacy directories so existing segments
+    // keep the pre-existing behaviour when a directory and a combined file coexist.
+    if (formatFile == null) {
+      vectorIndexDirectory = column + V1Constants.Indexes.VECTOR_HNSW_COMBINED_INDEX_FILE_EXTENSION;
+      formatFile = findFormatFile(segmentIndexDir, vectorIndexDirectory);
+    }
     return formatFile;
   }
 


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@pinot.apache.org
For additional commands, e-mail: commits-help@pinot.apache.org