Fuzzing Crash: MaskedArray execution produces dtype mismatch

[github-actions]

Fuzzing Crash Report

Analysis

Crash Location: vortex-array/src/vtable/dyn_.rs:execute

Error Message:

to_canonical should succeed in fuzz test:
  Executed canonical dtype mismatch for Encoding<vortex_array::arrays::masked::vtable::MaskedVTable>

Stack Trace:

   3: execute<vortex_array::arrays::masked::vtable::MaskedVTable>
             at ./vortex-array/src/vtable/dyn_.rs:152:13
   4: execute
             at ./vortex-array/src/executor.rs:195:14
   5: execute<alloc::sync::Arc<dyn vortex_array::array::Array, alloc::alloc::Global>>
             at ./vortex-array/src/executor.rs:40:9
   6: execute
             at ./vortex-array/src/columnar.rs:105:27
   7: execute
             at ./vortex-array/src/canonical.rs:487:18
   8: execute<vortex_array::canonical::Canonical>
             at ./vortex-array/src/executor.rs:40:9
   9: to_canonical<vortex_array::arrays::masked::vtable::MaskedVTable>
             at ./vortex-array/src/array/mod.rs:609:14

Root Cause: The MaskedArray execute function is producing a canonical array with a dtype that doesn't match the input MaskedArray's dtype. This violates the debug assertion at vortex-array/src/vtable/dyn_.rs:152-156 which verifies that after execution, the result dtype must match the input dtype.

Based on the fuzzer debug output, the sequence is:

1. Start with a ChunkedArray containing VarBinArray and VarBinViewArray chunks (both Utf8, NonNullable)
2. Compress it (still NonNullable)
3. Apply a mask operation, creating a MaskedArray with Nullable dtype wrapping the compressed data
4. Try to convert to canonical - this triggers the crash

The issue appears to be in the dtype transformation during the mask operation or during the execution to canonical form. The MaskedArray's execute implementation (vortex-array/src/arrays/masked/vtable/mod.rs:110-129) calls mask_validity_canonical which should preserve dtype, but there seems to be a mismatch happening.

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Utf8(
            NonNullable,
        ),
        len: 3,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: BufferHandle(
                Host(
                    Buffer<u8> {
                        length: 24,
                        alignment: Alignment(
                            8,
                        ),
                        as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...],
                    },
                ),
            ),
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            VarBinArray {
                dtype: Utf8(
                    NonNullable,
                ),
                bytes: BufferHandle(
                    Host(
                        Buffer<u8> {
                            length: 0,
                            alignment: Alignment(
                                1,
                            ),
                            as_slice: [],
                        },
                    ),
                ),
                offsets: PrimitiveArray {
                    dtype: Primitive(
                        U32,
                        NonNullable,
                    ),
                    buffer: BufferHandle(
                        Host(
                            Buffer<u8> {
                                length: 4,
                                alignment: Alignment(
                                    4,
                                ),
                                as_slice: [0, 0, 0, 0],
                            },
                        ),
                    ),
                    validity: NonNullable,
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [
                                    (
                                        IsSorted,
                                        Exact(
                                            ScalarValue(
                                                Bool(
                                                    true,
                                                ),
                                            ),
                                        ),
                                    ),
                                ],
                            },
                        },
                    },
                },
                validity: NonNullable,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
            VarBinViewArray {
                dtype: Utf8(
                    NonNullable,
                ),
                buffers: [],
                views: BufferHandle(
                    Host(
                        Buffer<u8> {
                            length: 48,
                            alignment: Alignment(
                                16,
                            ),
                            as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...],
                        },
                    ),
                ),
                validity: NonNullable,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [
        (
            Compress(
                Default,
            ),
            Array(
                ChunkedArray {
                    dtype: Utf8(
                        NonNullable,
                    ),
                    len: 3,
                    chunk_offsets: PrimitiveArray {
                        dtype: Primitive(
                            U64,
                            NonNullable,
                        ),
                        buffer: BufferHandle(
                            Host(
                                Buffer<u8> {
                                    length: 24,
                                    alignment: Alignment(
                                        8,
                                    ),
                                    as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...],
                                },
                            ),
                        ),
                        validity: NonNullable,
                        stats_set: ArrayStats {
                            inner: RwLock {
                                data: StatsSet {
                                    values: [],
                                },
                            },
                        },
                    },
                    chunks: [
                        VarBinArray {
                            dtype: Utf8(
                                NonNullable,
                            ),
                            bytes: BufferHandle(
                                Host(
                                    Buffer<u8> {
                                        length: 0,
                                        alignment: Alignment(
                                            1,
                                        ),
                                        as_slice: [],
                                    },
                                ),
                            ),
                            offsets: PrimitiveArray {
                                dtype: Primitive(
                                    U32,
                                    NonNullable,
                                ),
                                buffer: BufferHandle(
                                    Host(
                                        Buffer<u8> {
                                            length: 4,
                                            alignment: Alignment(
                                                4,
                                            ),
                                            as_slice: [0, 0, 0, 0],
                                        },
                                    ),
                                ),
                                validity: NonNullable,
                                stats_set: ArrayStats {
                                    inner: RwLock {
                                        data: StatsSet {
                                            values: [
                                                (
                                                    IsSorted,
                                                    Exact(
                                                        ScalarValue(
                                                            Bool(
                                                                true,
                                                            ),
                                                        ),
                                                    ),
                                                ),
                                            ],
                                        },
                                    },
                                },
                            },
                            validity: NonNullable,
                            stats_set: ArrayStats {
                                inner: RwLock {
                                    data: StatsSet {
                                        values: [],
                                    },
                                },
                            },
                        },
                        VarBinViewArray {
                            dtype: Utf8(
                                NonNullable,
                            ),
                            buffers: [],
                            views: BufferHandle(
                                Host(
                                    Buffer<u8> {
                                        length: 48,
                                        alignment: Alignment(
                                            16,
                                        ),
                                        as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...],
                                    },
                                ),
                            ),
                            validity: NonNullable,
                            stats_set: ArrayStats {
                                inner: RwLock {
                                    data: StatsSet {
                                        values: [],
                                    },
                                },
                            },
                        },
                    ],
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [],
                            },
                        },
                    },
                },
            ),
        ),
        (
            Mask(
                Values(
                    MaskValues {
                        buffer: BitBuffer {
                            buffer: Buffer<u8> {
                                length: 1,
                                alignment: Alignment(
                                    1,
                                ),
                                as_slice: [4],
                            },
                            offset: 0,
                            len: 3,
                        },
                        indices: OnceLock(
                            <uninit>,
                        ),
                        slices: OnceLock(
                            <uninit>,
                        ),
                        true_count: 1,
                        density: 0.3333333333333333,
                    },
                ),
            ),
            Array(
                VarBinViewArray {
                    dtype: Utf8(
                        Nullable,
                    ),
                    buffers: [],
                    views: BufferHandle(
                        Host(
                            Buffer<u8> {
                                length: 48,
                                alignment: Alignment(
                                    16,
                                ),
                                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...],
                            },
                        ),
                    ),
                    validity: Array(
                        BoolArray {
                            dtype: Bool(
                                NonNullable,
                            ),
                            bits: BufferHandle(
                                Host(
                                    Buffer<u8> {
                                        length: 1,
                                        alignment: Alignment(
                                            1,
                                        ),
                                        as_slice: [251],
                                    },
                                ),
                            ),
                            offset: 0,
                            len: 3,
                            validity: NonNullable,
                            stats_set: ArrayStats {
                                inner: RwLock {
                                    data: StatsSet {
                                        values: [],
                                    },
                                },
                            },
                        },
                    ),
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [],
                            },
                        },
                    },
                },
            ),
        ),
        (
            ScalarAt(
                [
                    0,
                ],
            ),
            ScalarVec(
                [
                    Scalar {
                        dtype: Utf8(
                            Nullable,
                        ),
                        value: ScalarValue(
                            BufferString(
                                BufferString {
                                    string: "",
                                },
                            ),
                        ),
                    },
                ],
            ),
        ),
        (
            Compress(
                Compact,
            ),
            Array(
                VarBinViewArray {
                    dtype: Utf8(
                        Nullable,
                    ),
                    buffers: [],
                    views: BufferHandle(
                        Host(
                            Buffer<u8> {
                                length: 48,
                                alignment: Alignment(
                                    16,
                                ),
                                as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...],
                            },
                        ),
                    ),
                    validity: Array(
                        BoolArray {
                            dtype: Bool(
                                NonNullable,
                            ),
                            bits: BufferHandle(
                                Host(
                                    Buffer<u8> {
                                        length: 1,
                                        alignment: Alignment(
                                            1,
                                        ),
                                        as_slice: [251],
                                    },
                                ),
                            ),
                            offset: 0,
                            len: 3,
                            validity: NonNullable,
                            stats_set: ArrayStats {
                                inner: RwLock {
                                    data: StatsSet {
                                        values: [],
                                    },
                                },
                            },
                        },
                    ),
                    stats_set: ArrayStats {
                        inner: RwLock {
                            data: StatsSet {
                                values: [],
                            },
                        },
                    },
                },
            ),
        ),
    ],
}

Summary

• Target: array_ops
• Crash File: crash-caec2ffa2e36c2363c142c55a4176bef24a9ef3c
• Branch: develop
• Commit: db7811a
• Crash Artifact: https://github.com/spiraldb/vortex/actions/runs//artifacts/

Reproduction

1. Download the crash artifact:

   • Direct download: https://github.com/spiraldb/vortex/actions/runs//artifacts/
   • Or find fuzz-artifacts at: https://github.com/spiraldb/vortex/actions/runs/
   • Extract the zip file

2. Reproduce locally:

# The artifact contains array_ops/crash-caec2ffa2e36c2363c142c55a4176bef24a9ef3c
cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-caec2ffa2e36c2363c142c55a4176bef24a9ef3c -- -rss_limit_mb=0

3. Get full backtrace:

RUST_BACKTRACE=full cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-caec2ffa2e36c2363c142c55a4176bef24a9ef3c -- -rss_limit_mb=0

---

Auto-created by fuzzing workflow with Claude analysis

[github-actions]

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: fuzz/src/array/mod.rs:641 (mask operation via vortex_expect)

Error Message:

mask operation should succeed in fuzz test:
  Internal error: compute function mask returned a result of type {={=decimal(1,-2)?, =binary?}?, ={=decimal(1,-2)?, =decimal(8,-69)?}?}? but expected {={=decimal(1,-2), =binary}, ={=decimal(1,-2)?, =decimal(8,-69)?}?}?
vortex.filter

Stack Trace:

   0: std::backtrace_rs::backtrace::libunwind::trace
   ...
  16: panic_display<vortex_error::VortexError>
             at /rustc/.../library/core/src/panicking.rs:259:5
  17: <core::result::Result<alloc::sync::Arc<dyn vortex_array::array::Array>, vortex_error::VortexError> as vortex_error::VortexExpect>::vortex_expect::{closure#1}
             at vortex-error/src/lib.rs:457:9
  18: unwrap_or_else<...>
  19: vortex_expect<...>
             at vortex-error/src/lib.rs:310:14
  20: vortex_fuzz::array::run_fuzz_action
             at fuzz/src/array/mod.rs:641:22

Similarities to Original Issue:

• Both crashes occur during mask operations on nested struct fields
• Both involve dtype mismatches where nullability is being changed incorrectly
• Both are in the same general area of mask/filter operations

Differences:

• Original issue: MaskedArray execution dtype mismatch during to_canonical
• This crash: Direct mask compute function returning wrong dtype (changing NonNullable nested struct fields to Nullable)
• Original issue involves Utf8 arrays; this crash involves nested structs with Decimal and Binary fields
• These differences may indicate the same root cause manifesting differently

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Struct(
            StructFields {
                names: FieldNames(
                    [
                        FieldName(
                            "",
                        ),
                        FieldName(
                            "",
                        ),
                    ],
                ),
                dtypes: [
                    FieldDType {
                        inner: Owned(
                            Struct(
                                StructFields {
                                    names: FieldNames(
                                        [
                                            FieldName(
                                                "",
                                            ),
                                            FieldName(
                                                "",
                                            ),
                                        ],
                                    ),
                                    dtypes: [
                                        FieldDType {
                                            inner: Owned(
                                                Decimal(
                                                    DecimalDType {
                                                        precision: 1,
                                                        scale: -2,
                                                    },
                                                    NonNullable,
                                                ),
                                            ),
                                        },
                                        FieldDType {
                                            inner: Owned(
                                                Binary(
                                                    NonNullable,
                                                ),
                                            ),
                                        },
                                    ],
                                },
                                NonNullable,
                            ),
                        ),
                    },
                    FieldDType {
                        inner: Owned(
                            Struct(
                                StructFields {
                                    names: FieldNames(
                                        [
                                            FieldName(
                                                "",
                                            ),
                                            FieldName(
                                                "",
                                            ),
                                        ],
                                    ),
                                    dtypes: [
                                        FieldDType {
                                            inner: Owned(
                                                Decimal(
                                                    DecimalDType {
                                                        precision: 1,
                                                        scale: -2,
                                                    },
                                                    Nullable,
                                                ),
                                            ),
                                        },
                                        FieldDType {
                                            inner: Owned(
                                                Decimal(
                                                    DecimalDType {
                                                        precision: 8,
                                                        scale: -69,
                                                    },
                                                    Nullable,
                                                ),
                                            ),
                                        },
                                    ],
                                },
                                Nullable,
                            ),
                        ),
                    },
                ],
            },
            Nullable,
        ),
        len: 1,
        chunk_offsets: PrimitiveArray {
            dtype: Primitive(
                U64,
                NonNullable,
            ),
            buffer: BufferHandle(
                Host(
                    Buffer<u8> {
                        length: 16,
                        alignment: Alignment(
                            8,
                        ),
                        as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
                    },
                ),
            ),
            validity: NonNullable,
            stats_set: ArrayStats {
                inner: RwLock {
                    data: StatsSet {
                        values: [],
                    },
                },
            },
        },
        chunks: [
            StructArray {
                len: 1,
                dtype: Struct(
                    StructFields {
                        names: FieldNames(
                            [
                                FieldName(
                                    "",
                                ),
                                FieldName(
                                    "",
                                ),
                            ],
                        ),
                        dtypes: [
                            FieldDType {
                                inner: Owned(
                                    Struct(
                                        StructFields {
                                            names: FieldNames(
                                                [
                                                    FieldName(
                                                        "",
                                                    ),
                                                    FieldName(
                                                        "",
                                                    ),
                                                ],
                                            ),
                                            dtypes: [
                                                FieldDType {
                                                    inner: Owned(
                                                        Decimal(
                                                            DecimalDType {
                                                                precision: 1,
                                                                scale: -2,
                                                            },
                                                            NonNullable,
                                                        ),
                                                    ),
                                                },
                                                FieldDType {
                                                    inner: Owned(
                                                        Binary(
                                                            NonNullable,
                                                        ),
                                                    ),
                                                },
                                            ],
                                        },
                                        NonNullable,
                                    ),
                                ),
                            },
                            FieldDType {
                                inner: Owned(
                                    Struct(
                                        StructFields {
                                            names: FieldNames(
                                                [
                                                    FieldName(
                                                        "",
                                                    ),
                                                    FieldName(
                                                        "",
                                                    ),
                                                ],
                                            ),
                                            dtypes: [
                                                FieldDType {
                                                    inner: Owned(
                                                        Decimal(
                                                            DecimalDType {
                                                                precision: 1,
                                                                scale: -2,
                                                            },
                                                            Nullable,
                                                        ),
                                                    ),
                                                },
                                                FieldDType {
                                                    inner: Owned(
                                                        Decimal(
                                                            DecimalDType {
                                                                precision: 8,
                                                                scale: -69,
                                                            },
                                                            Nullable,
                                                        ),
                                                    ),
                                                },
                                            ],
                                        },
                                        Nullable,
                                    ),
                                ),
                            },
                        ],
                    },
                    Nullable,
                ),
                fields: [
                    StructArray {
                        len: 1,
                        dtype: Struct(
                            StructFields {
                                names: FieldNames(
                                    [
                                        FieldName(
                                            "",
                                        ),
                                        FieldName(
                                            "",
                                        ),
                                    ],
                                ),
                                dtypes: [
                                    FieldDType {
                                        inner: Owned(
                                            Decimal(
                                                DecimalDType {
                                                    precision: 1,
                                                    scale: -2,
                                                },
                                                NonNullable,
                                            ),
                                        ),
                                    },
                                    FieldDType {
                                        inner: Owned(
                                            Binary(
                                                NonNullable,
                                            ),
                                        ),
                                    },
                                ],
                            },
                            NonNullable,
                        ),
                        fields: [
                            DecimalArray {
                                dtype: Decimal(
                                    DecimalDType {
                                        precision: 1,
                                        scale: -2,
                                    },
                                    NonNullable,
                                ),
                                values: BufferHandle(
                                    Host(
                                        Buffer<u8> {
                                            length: 1,
                                            alignment: Alignment(
                                                1,
                                            ),
                                            as_slice: [247],
                                        },
                                    ),
                                ),
                                values_type: I8,
                                validity: NonNullable,
                                stats_set: ArrayStats {
                                    inner: RwLock {
                                        data: StatsSet {
                                            values: [],
                                        },
                                    },
                                },
                            },
                            VarBinViewArray {
                                dtype: Binary(
                                    NonNullable,
                                ),
                                buffers: [],
                                views: BufferHandle(
                                    Host(
                                        Buffer<u8> {
                                            length: 16,
                                            alignment: Alignment(
                                                16,
                                            ),
                                            as_slice: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                                        },
                                    ),
                                ),
                                validity: NonNullable,
                                stats_set: ArrayStats {
                                    inner: RwLock {
                                        data: StatsSet {
                                            values: [],
                                        },
                                    },
                                },
                            },
                        ],
                        validity: NonNullable,
                        stats_set: ArrayStats {
                            inner: RwLock {
                                data: StatsSet {
                                    values: [],
                                },
                            },
                        },
                    },
                    StructArray {
                        len: 1,
                        dtype: Struct(
                            StructFields {
                                names: FieldNames(
                                    [
                                        FieldName(
                                            "",
                                        ),
                                        FieldName(
                                            "",
                                        ),
                                    ],
                                ),
                                dtypes: [
                                    FieldDType {
                                        inner: Owned(
                                            Decimal(
                                                DecimalDType {
                                                    precision: 1,
                                                    scale: -2,
                                                },
                                                Nullable,
                                            ),
                                        ),
                                    },
                                    FieldDType {
                                        inner: Owned(
                                            Decimal(
                                                DecimalDType {
                                                    precision: 8,
                                                    scale: -69,
                                                },
                                                Nullable,
                                            ),
                                        ),
                                    },
                                ],
                            },
                            Nullable,
                        ),
                        fields: [
                            DecimalArray {
                                dtype: Decimal(
                                    DecimalDType {
                                        precision: 1,
                                        scale: -2,
                                    },
                                    Nullable,
                                ),
                                values: BufferHandle(
                                    Host(
                                        Buffer<u8> {
                                            length: 1,
                                            alignment: Alignment(
                                                1,
                                            ),
                                            as_slice: [251],
                                        },
                                    ),
                                ),
                                values_type: I8,
                                validity: AllValid,
                                stats_set: ArrayStats {
                                    inner: RwLock {
                                        data: StatsSet {
                                            values: [],
                                        },
                                    },
                                },
                            },
                            DecimalArray {
                                dtype: Decimal(
                                    DecimalDType {
                                        precision: 8,
                                        scale: -69,
                                    },
                                    Nullable,
                                ),
                                values: BufferHandle(
                                    Host(
                                        Buffer<u8> {
                                            length: 4,
                                            alignment: Alignment(
                                                4,
                                            ),
                                            as_slice: [1, 32, 10, 250],
                                        },
                                    ),
                                ),
                                values_type: I32,
                                validity: AllValid,
                                stats_set: ArrayStats {
                                    inner: RwLock {
                                        data: StatsSet {
                                            values: [],
                                        },
                                    },
                                },
                            },
                        ],
                        validity: AllInvalid,
                        stats_set: ArrayStats {
                            inner: RwLock {
                                data: StatsSet {
                                    values: [],
                                },
                            },
                        },
                    },
                ],
                validity: AllInvalid,
                stats_set: ArrayStats {
                    inner: RwLock {
                        data: StatsSet {
                            values: [],
                        },
                    },
                },
            },
        ],
        stats_set: ArrayStats {
            inner: RwLock {
                data: StatsSet {
                    values: [],
                },
            },
        },
    },
    actions: [],
}

Occurrence Details

• Crash File: crash-90842783145b6d06ed70db217aeacb869ae5e31f
• Branch: develop
• Commit: 7057a13
• Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/13898558623/artifacts/2857033992

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops fuzz/artifacts/array_ops/crash-90842783145b6d06ed70db217aeacb869ae5e31f -- -rss_limit_mb=0

---

Auto-detected by fuzzing workflow with Claude analysis

[github-actions]

Related Crash Detected

A similar crash was detected in the array_ops target.

Crash Details

Crash Location: vortex-array/src/compute/mod.rs:149

Error Message:

mask operation should succeed in fuzz test:
  Internal error: compute function mask returned a result of type {={}?, =utf8?}? but expected {={}, =utf8?}?
vortex.slice

Stack Trace:

   0: std::backtrace_rs::backtrace::libunwind::trace
   1: std::backtrace_rs::backtrace::trace_unsynchronized
   2: <std::backtrace::Backtrace>::create
   3: invoke
             at ./vortex-array/src/compute/mod.rs:149:13
   4: mask
             at ./vortex-array/src/compute/mask.rs:74:10
   5: run_fuzz_action
             at ./fuzz/src/array/mod.rs:640:33

Similarities to Original Issue:

• Both involve mask operations on struct arrays
• Both produce dtype mismatches where NonNullable fields become Nullable
• Both fail at dtype validation in the compute system
• Same underlying area: mask operations on struct types

Differences:

• Original issue: fails at vortex-array/src/vtable/dyn_.rs:152 during to_canonical
• This crash: fails at vortex-array/src/compute/mod.rs:149 during mask operation invocation
• Original: Utf8 NonNullable → Nullable
• This crash: nested empty Struct NonNullable → Nullable (first field: {} → {}?)
• These differences may indicate the same root cause manifesting at different validation points

Debug Output

FuzzArrayAction {
    array: ChunkedArray {
        dtype: Struct(
            StructFields {
                names: FieldNames(
                    [
                        FieldName(
                            "",
                        ),
                        FieldName(
                            "",
                        ),
                    ],
                ),
                dtypes: [
                    FieldDType {
                        inner: Owned(
                            Struct(
                                StructFields {
                                    names: FieldNames(
                                        [],
                                    ),
                                    dtypes: [],
                                },
                                NonNullable,
                            ),
                        ),
                    },
                    FieldDType {
                        inner: Owned(
                            Utf8(
                                Nullable,
                            ),
                        ),
                    },
                ],
            },
            Nullable,
        ),
        len: 189,
        chunk_offsets: PrimitiveArray { dtype: Primitive(U64, NonNullable), ... },
        chunks: [
            StructArray {
                len: 121,
                dtype: Struct(
                    StructFields {
                        names: FieldNames([FieldName(""), FieldName("")]),
                        dtypes: [
                            FieldDType { inner: Owned(Struct(StructFields { names: FieldNames([]), dtypes: [] }, NonNullable)) },
                            FieldDType { inner: Owned(Utf8(Nullable)) },
                        ],
                    },
                    Nullable,
                ),
                fields: [
                    ChunkedArray {
                        dtype: Struct(StructFields { names: FieldNames([]), dtypes: [] }, NonNullable),
                        len: 121,
                        chunks: [ StructArray { len: 23, fields: [], ... }, StructArray { len: 2, ... }, StructArray { len: 96, ... } ],
                    },
                    ChunkedArray { dtype: Utf8(Nullable), len: 121, ... },
                ],
            },
            StructArray { len: 68, ... },
        ],
    },
    actions: [ Mask(...) ],
}

Occurrence Details

• Crash File: crash-d10db78142e9551875d1771cd0a74dcce117806d
• Branch: develop
• Commit: a11336d
• Crash Artifact: https://github.com/vortex-data/vortex/actions/runs/21762683825/artifacts/5411111251

Reproduction

cargo +nightly fuzz run -D --sanitizer=none array_ops array_ops/crash-d10db78142e9551875d1771cd0a74dcce117806d -- -rss_limit_mb=0

---

Auto-detected by fuzzing workflow with Claude analysis