diff --git a/.github/ISSUE_TEMPLATE/typing.yml b/.github/ISSUE_TEMPLATE/typing.yml
index a35b339e4883..17eedfae1c6c 100644
--- a/.github/ISSUE_TEMPLATE/typing.yml
+++ b/.github/ISSUE_TEMPLATE/typing.yml
@@ -1,7 +1,7 @@
 name: Static Typing
 description: Report an issue with the NumPy typing hints.
 title: "TYP: <Please write a comprehensive title after the 'TYP: ' prefix>"
-labels: [Static typing]
+labels: [41 - Static typing]
 
 body:
 - type: markdown
diff --git a/.github/pr-prefix-labeler.yml b/.github/pr-prefix-labeler.yml
index 4905b502045d..65ed35aa1a11 100644
--- a/.github/pr-prefix-labeler.yml
+++ b/.github/pr-prefix-labeler.yml
@@ -12,5 +12,5 @@
 "REV": "34 - Reversion"
 "STY": "03 - Maintenance"
 "TST": "05 - Testing"
-"TYP": "static typing"
+"TYP": "41 - Static typing"
 "WIP": "25 - WIP"
diff --git a/.github/workflows/compiler_sanitizers.yml b/.github/workflows/compiler_sanitizers.yml
new file mode 100644
index 000000000000..9477e0be1bd1
--- /dev/null
+++ b/.github/workflows/compiler_sanitizers.yml
@@ -0,0 +1,127 @@
+name: Test with compiler sanitizers
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+      - maintenance/**
+
+defaults:
+  run:
+    shell: bash
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read # to fetch code (actions/checkout)
+
+jobs:
+  clang_ASAN:
+    # To enable this workflow on a fork, comment out:
+    if: github.repository == 'numpy/numpy'
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        submodules: recursive
+        fetch-tags: true
+        persist-credentials: false
+    - name: Set up pyenv
+      run: |
+        git clone https://github.com/pyenv/pyenv.git "$HOME/.pyenv"
+        PYENV_ROOT="$HOME/.pyenv"
+        PYENV_BIN="$PYENV_ROOT/bin"
+        PYENV_SHIMS="$PYENV_ROOT/shims"
+        echo "$PYENV_BIN" >> $GITHUB_PATH
+        echo "$PYENV_SHIMS" >> $GITHUB_PATH
+        echo "PYENV_ROOT=$PYENV_ROOT" >> $GITHUB_ENV
+    - name: Check pyenv is working
+      run:
+        pyenv --version
+    - name: Set up LLVM
+      run: |
+        brew install llvm@19
+        LLVM_PREFIX=$(brew --prefix llvm@19)
+        echo CC="$LLVM_PREFIX/bin/clang" >> $GITHUB_ENV
+        echo CXX="$LLVM_PREFIX/bin/clang++" >> $GITHUB_ENV
+        echo LDFLAGS="-L$LLVM_PREFIX/lib" >> $GITHUB_ENV
+        echo CPPFLAGS="-I$LLVM_PREFIX/include" >> $GITHUB_ENV
+    - name: Build Python with address sanitizer
+      run: |
+        CONFIGURE_OPTS="--with-address-sanitizer" pyenv install 3.13
+        pyenv global 3.13
+    - name: Install dependencies
+      run: |
+        pip install -r requirements/build_requirements.txt
+        pip install -r requirements/ci_requirements.txt
+        pip install -r requirements/test_requirements.txt
+        # xdist captures stdout/stderr, but we want the ASAN output
+        pip uninstall -y pytest-xdist
+    - name: Build
+      run:
+        python -m spin build -j2 -- -Db_sanitize=address
+    - name: Test
+      run: |
+        # pass -s to pytest to see ASAN errors and warnings, otherwise pytest captures them
+        ASAN_OPTIONS=detect_leaks=0:symbolize=1:strict_init_order=true:allocator_may_return_null=1:halt_on_error=1 \
+        python -m spin test -- -v -s --timeout=600 --durations=10
+
+  clang_TSAN:
+    # To enable this workflow on a fork, comment out:
+    if: github.repository == 'numpy/numpy'
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      with:
+        submodules: recursive
+        fetch-tags: true
+        persist-credentials: false
+    - name: Set up pyenv
+      run: |
+        git clone https://github.com/pyenv/pyenv.git "$HOME/.pyenv"
+        PYENV_ROOT="$HOME/.pyenv"
+        PYENV_BIN="$PYENV_ROOT/bin"
+        PYENV_SHIMS="$PYENV_ROOT/shims"
+        echo "$PYENV_BIN" >> $GITHUB_PATH
+        echo "$PYENV_SHIMS" >> $GITHUB_PATH
+        echo "PYENV_ROOT=$PYENV_ROOT" >> $GITHUB_ENV
+    - name: Check pyenv is working
+      run:
+        pyenv --version
+    - name: Set up LLVM
+      run: |
+        brew install llvm@19
+        LLVM_PREFIX=$(brew --prefix llvm@19)
+        echo CC="$LLVM_PREFIX/bin/clang" >> $GITHUB_ENV
+        echo CXX="$LLVM_PREFIX/bin/clang++" >> $GITHUB_ENV
+        echo LDFLAGS="-L$LLVM_PREFIX/lib" >> $GITHUB_ENV
+        echo CPPFLAGS="-I$LLVM_PREFIX/include" >> $GITHUB_ENV
+    - name: Build Python with thread sanitizer support
+      run: |
+        # free-threaded Python is much more likely to trigger races
+        CONFIGURE_OPTS="--with-thread-sanitizer" pyenv install 3.13t
+        pyenv global 3.13t
+    - name: Install dependencies
+      run: |
+        # TODO: remove when a released cython supports free-threaded python
+        pip install -i https://pypi.anaconda.org/scientific-python-nightly-wheels/simple cython
+        pip install -r requirements/build_requirements.txt
+        pip install -r requirements/ci_requirements.txt
+        pip install -r requirements/test_requirements.txt
+        # xdist captures stdout/stderr, but we want the TSAN output
+        pip uninstall -y pytest-xdist
+    - name: Build
+      run:
+        python -m spin build -j2 -- -Db_sanitize=thread
+    - name: Test
+      run: |
+        # These tests are slow, so only run tests in files that do "import threading" to make them count
+        TSAN_OPTIONS=allocator_may_return_null=1:halt_on_error=1 \
+        python -m spin test \
+        `find numpy -name "test*.py" | xargs grep -l "import threading" | tr '\n' ' '` \
+        -- -v -s --timeout=600 --durations=10
diff --git a/doc/changelog/2.2.3-changelog.rst b/doc/changelog/2.2.3-changelog.rst
new file mode 100644
index 000000000000..2cb6e99eec51
--- /dev/null
+++ b/doc/changelog/2.2.3-changelog.rst
@@ -0,0 +1,43 @@
+
+Contributors
+============
+
+A total of 9 people contributed to this release.  People with a "+" by their
+names contributed a patch for the first time.
+
+* !amotzop
+* Charles Harris
+* Chris Sidebottom
+* Joren Hammudoglu
+* Matthew Brett
+* Nathan Goldbaum
+* Raghuveer Devulapalli
+* Sebastian Berg
+* Yakov Danishevsky +
+
+Pull requests merged
+====================
+
+A total of 21 pull requests were merged for this release.
+
+* `#28185 <https://github.com/numpy/numpy/pull/28185>`__: MAINT: Prepare 2.2.x for further development
+* `#28201 <https://github.com/numpy/numpy/pull/28201>`__: BUG: fix data race in a more minimal way on stable branch
+* `#28208 <https://github.com/numpy/numpy/pull/28208>`__: BUG: Fix ``from_float_positional`` errors for huge pads
+* `#28209 <https://github.com/numpy/numpy/pull/28209>`__: BUG: fix data race in np.repeat
+* `#28212 <https://github.com/numpy/numpy/pull/28212>`__: MAINT: Use VQSORT_COMPILER_COMPATIBLE to determine if we should...
+* `#28224 <https://github.com/numpy/numpy/pull/28224>`__: MAINT: update highway to latest
+* `#28236 <https://github.com/numpy/numpy/pull/28236>`__: BUG: Add cpp atomic support (#28234)
+* `#28237 <https://github.com/numpy/numpy/pull/28237>`__: BLD: Compile fix for clang-cl on WoA
+* `#28243 <https://github.com/numpy/numpy/pull/28243>`__: TYP: Avoid upcasting ``float64`` in the set-ops
+* `#28249 <https://github.com/numpy/numpy/pull/28249>`__: BLD: better fix for clang / ARM compiles
+* `#28266 <https://github.com/numpy/numpy/pull/28266>`__: TYP: Fix ``timedelta64.__divmod__`` and ``timedelta64.__mod__``...
+* `#28274 <https://github.com/numpy/numpy/pull/28274>`__: TYP: Fixed missing typing information of set_printoptions
+* `#28278 <https://github.com/numpy/numpy/pull/28278>`__: BUG: backport resource cleanup bugfix from gh-28273
+* `#28282 <https://github.com/numpy/numpy/pull/28282>`__: BUG: fix incorrect bytes to stringdtype coercion
+* `#28283 <https://github.com/numpy/numpy/pull/28283>`__: TYP: Fix scalar constructors
+* `#28284 <https://github.com/numpy/numpy/pull/28284>`__: TYP: stub ``numpy.matlib``
+* `#28285 <https://github.com/numpy/numpy/pull/28285>`__: TYP: stub the missing ``numpy.testing`` modules
+* `#28286 <https://github.com/numpy/numpy/pull/28286>`__: CI: Fix the github label for ``TYP:`` PR's and issues
+* `#28305 <https://github.com/numpy/numpy/pull/28305>`__: TYP: Backport typing updates from main
+* `#28321 <https://github.com/numpy/numpy/pull/28321>`__: BUG: fix race initializing legacy dtype casts
+* `#28324 <https://github.com/numpy/numpy/pull/28324>`__: CI: update test_moderately_small_alpha
diff --git a/doc/source/release.rst b/doc/source/release.rst
index 4c83cd3d1ae4..a22178a055ee 100644
--- a/doc/source/release.rst
+++ b/doc/source/release.rst
@@ -5,6 +5,7 @@ Release notes
 .. toctree::
     :maxdepth: 2
 
+    2.2.3 <release/2.2.3-notes>
     2.2.2 <release/2.2.2-notes>
     2.2.1 <release/2.2.1-notes>
     2.2.0 <release/2.2.0-notes>
diff --git a/doc/source/release/2.2.3-notes.rst b/doc/source/release/2.2.3-notes.rst
new file mode 100644
index 000000000000..cf21d751ec00
--- /dev/null
+++ b/doc/source/release/2.2.3-notes.rst
@@ -0,0 +1,56 @@
+.. currentmodule:: numpy
+
+==========================
+NumPy 2.2.3 Release Notes
+==========================
+
+NumPy 2.2.3 is a patch release that fixes bugs found after the 2.2.2 release.
+The majority of the changes are typing improvements and fixes for free
+threaded Python. Both of those areas are still under development, so if you
+discover new problems, please report them.
+
+This release supports Python versions 3.10-3.13.
+
+
+Contributors
+============
+
+A total of 9 people contributed to this release.  People with a "+" by their
+names contributed a patch for the first time.
+
+* !amotzop
+* Charles Harris
+* Chris Sidebottom
+* Joren Hammudoglu
+* Matthew Brett
+* Nathan Goldbaum
+* Raghuveer Devulapalli
+* Sebastian Berg
+* Yakov Danishevsky +
+
+Pull requests merged
+====================
+
+A total of 21 pull requests were merged for this release.
+
+* `#28185 <https://github.com/numpy/numpy/pull/28185>`__: MAINT: Prepare 2.2.x for further development
+* `#28201 <https://github.com/numpy/numpy/pull/28201>`__: BUG: fix data race in a more minimal way on stable branch
+* `#28208 <https://github.com/numpy/numpy/pull/28208>`__: BUG: Fix ``from_float_positional`` errors for huge pads
+* `#28209 <https://github.com/numpy/numpy/pull/28209>`__: BUG: fix data race in np.repeat
+* `#28212 <https://github.com/numpy/numpy/pull/28212>`__: MAINT: Use VQSORT_COMPILER_COMPATIBLE to determine if we should...
+* `#28224 <https://github.com/numpy/numpy/pull/28224>`__: MAINT: update highway to latest
+* `#28236 <https://github.com/numpy/numpy/pull/28236>`__: BUG: Add cpp atomic support (#28234)
+* `#28237 <https://github.com/numpy/numpy/pull/28237>`__: BLD: Compile fix for clang-cl on WoA
+* `#28243 <https://github.com/numpy/numpy/pull/28243>`__: TYP: Avoid upcasting ``float64`` in the set-ops
+* `#28249 <https://github.com/numpy/numpy/pull/28249>`__: BLD: better fix for clang / ARM compiles
+* `#28266 <https://github.com/numpy/numpy/pull/28266>`__: TYP: Fix ``timedelta64.__divmod__`` and ``timedelta64.__mod__``...
+* `#28274 <https://github.com/numpy/numpy/pull/28274>`__: TYP: Fixed missing typing information of set_printoptions
+* `#28278 <https://github.com/numpy/numpy/pull/28278>`__: BUG: backport resource cleanup bugfix from gh-28273
+* `#28282 <https://github.com/numpy/numpy/pull/28282>`__: BUG: fix incorrect bytes to stringdtype coercion
+* `#28283 <https://github.com/numpy/numpy/pull/28283>`__: TYP: Fix scalar constructors
+* `#28284 <https://github.com/numpy/numpy/pull/28284>`__: TYP: stub ``numpy.matlib``
+* `#28285 <https://github.com/numpy/numpy/pull/28285>`__: TYP: stub the missing ``numpy.testing`` modules
+* `#28286 <https://github.com/numpy/numpy/pull/28286>`__: CI: Fix the github label for ``TYP:`` PR's and issues
+* `#28305 <https://github.com/numpy/numpy/pull/28305>`__: TYP: Backport typing updates from main
+* `#28321 <https://github.com/numpy/numpy/pull/28321>`__: BUG: fix race initializing legacy dtype casts
+* `#28324 <https://github.com/numpy/numpy/pull/28324>`__: CI: update test_moderately_small_alpha
diff --git a/numpy/__init__.pyi b/numpy/__init__.pyi
index 225e63b4d32d..1a2d6a08bbb1 100644
--- a/numpy/__init__.pyi
+++ b/numpy/__init__.pyi
@@ -5,7 +5,6 @@ import mmap
 import ctypes as ct
 import array as _array
 import datetime as dt
-import enum
 from abc import abstractmethod
 from types import EllipsisType, ModuleType, TracebackType, MappingProxyType, GenericAlias
 from decimal import Decimal
@@ -442,6 +441,8 @@ from numpy._core.shape_base import (
     unstack,
 )
 
+from ._expired_attrs_2_0 import __expired_attributes__ as __expired_attributes__
+
 from numpy.lib import (
     scimath as emath,
 )
@@ -505,6 +506,8 @@ from numpy.lib._function_base_impl import (
     quantile,
 )
 
+from numpy._globals import _CopyMode
+
 from numpy.lib._histograms_impl import (
     histogram_bin_edges,
     histogram,
@@ -1184,7 +1187,6 @@ newaxis: Final[None] = None
 # not in __all__
 __NUMPY_SETUP__: Final[L[False]] = False
 __numpy_submodules__: Final[set[LiteralString]] = ...
-__expired_attributes__: Final[dict[LiteralString, LiteralString]]
 __former_attrs__: Final[_FormerAttrsDict] = ...
 __future_scalars__: Final[set[L["bytes", "str", "object"]]] = ...
 __array_api_version__: Final[L["2023.12"]] = "2023.12"
@@ -4134,6 +4136,9 @@ float32: TypeAlias = floating[_32Bit]
 
 # either a C `double`, `float`, or `longdouble`
 class float64(floating[_64Bit], float):  # type: ignore[misc]
+    def __new__(cls, x: _ConvertibleToFloat | None = ..., /) -> Self: ...
+
+    #
     @property
     def itemsize(self) -> L[8]: ...
     @property
@@ -4268,7 +4273,15 @@ longdouble: TypeAlias = floating[_NBitLongDouble]
 # describing the two 64 bit floats representing its real and imaginary component
 
 class complexfloating(inexact[_NBit1, complex], Generic[_NBit1, _NBit2]):
-    def __init__(self, value: _ConvertibleToComplex | None = ..., /) -> None: ...
+    @overload
+    def __init__(
+        self,
+        real: complex | SupportsComplex | SupportsFloat | SupportsIndex = ...,
+        imag: complex | SupportsFloat | SupportsIndex = ...,
+        /,
+    ) -> None: ...
+    @overload
+    def __init__(self, real: _ConvertibleToComplex | None = ..., /) -> None: ...
 
     @property
     def real(self) -> floating[_NBit1]: ...  # type: ignore[override]
@@ -4352,6 +4365,17 @@ class complexfloating(inexact[_NBit1, complex], Generic[_NBit1, _NBit2]):
 complex64: TypeAlias = complexfloating[_32Bit, _32Bit]
 
 class complex128(complexfloating[_64Bit, _64Bit], complex):  # type: ignore[misc]
+    @overload
+    def __new__(
+        cls,
+        real: complex | SupportsComplex | SupportsFloat | SupportsIndex = ...,
+        imag: complex | SupportsFloat | SupportsIndex = ...,
+        /,
+    ) -> Self: ...
+    @overload
+    def __new__(cls, real: _ConvertibleToComplex | None = ..., /) -> Self: ...
+
+    #
     @property
     def itemsize(self) -> L[16]: ...
     @property
@@ -4414,10 +4438,12 @@ class timedelta64(_IntegralMixin, generic[_TD64ItemT_co], Generic[_TD64ItemT_co]
     @overload
     def __init__(self: timedelta64[None], value: _NaTValue | None, format: _TimeUnitSpec, /) -> None: ...
     @overload
-    def __init__(self: timedelta64[int], value: dt.timedelta, format: _TimeUnitSpec[_IntTimeUnit], /) -> None: ...
+    def __init__(self: timedelta64[L[0]], value: L[0], format: _TimeUnitSpec[_IntTD64Unit] = ..., /) -> None: ...
     @overload
     def __init__(self: timedelta64[int], value: _IntLike_co, format: _TimeUnitSpec[_IntTD64Unit] = ..., /) -> None: ...
     @overload
+    def __init__(self: timedelta64[int], value: dt.timedelta, format: _TimeUnitSpec[_IntTimeUnit], /) -> None: ...
+    @overload
     def __init__(
         self: timedelta64[dt.timedelta],
         value: dt.timedelta | _IntLike_co,
@@ -4458,29 +4484,68 @@ class timedelta64(_IntegralMixin, generic[_TD64ItemT_co], Generic[_TD64ItemT_co]
     def __mul__(self, x: float | np.floating[Any] | np.integer[Any] | np.bool, /) -> timedelta64: ...
     __rmul__ = __mul__
 
+    @overload
+    def __mod__(self, x: timedelta64[None | L[0]], /) -> timedelta64[None]: ...
     @overload
     def __mod__(self: timedelta64[None], x: timedelta64, /) -> timedelta64[None]: ...
     @overload
+    def __mod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> timedelta64[int | None]: ...
+    @overload
+    def __mod__(self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], /) -> timedelta64[_AnyTD64Item | None]: ...
+    @overload
     def __mod__(self: timedelta64[dt.timedelta], x: dt.timedelta, /) -> dt.timedelta: ...
     @overload
-    def __mod__(self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], /) -> timedelta64[_AnyTD64Item]: ...
+    def __mod__(self, x: timedelta64[int], /) -> timedelta64[int | None]: ...
     @overload
-    def __mod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> timedelta64[int]: ...
+    def __mod__(self, x: timedelta64, /) -> timedelta64: ...
+
+    # the L[0] makes __mod__ non-commutative, which the first two overloads reflect
     @overload
-    def __mod__(self, x: timedelta64[None], /) -> timedelta64[None]: ...
+    def __rmod__(self, x: timedelta64[None], /) -> timedelta64[None]: ...
     @overload
-    def __mod__(self, x: timedelta64[int], /) -> timedelta64[int]: ...
+    def __rmod__(self: timedelta64[None | L[0]], x: timedelta64, /) -> timedelta64[None]: ...
     @overload
-    def __mod__(self, x: timedelta64, /) -> timedelta64: ...
-    __rmod__ = __mod__  # at runtime the outcomes differ, but the type signatures are the same
+    def __rmod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> timedelta64[int | None]: ...
+    @overload
+    def __rmod__(self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], /) -> timedelta64[_AnyTD64Item | None]: ...
+    @overload
+    def __rmod__(self: timedelta64[dt.timedelta], x: dt.timedelta, /) -> dt.timedelta: ...
+    @overload
+    def __rmod__(self, x: timedelta64[int], /) -> timedelta64[int | None]: ...
+    @overload
+    def __rmod__(self, x: timedelta64, /) -> timedelta64: ...
 
+    # keep in sync with __mod__
+    @overload
+    def __divmod__(self, x: timedelta64[None | L[0]], /) -> tuple[int64, timedelta64[None]]: ...
     @overload
     def __divmod__(self: timedelta64[None], x: timedelta64, /) -> tuple[int64, timedelta64[None]]: ...
     @overload
+    def __divmod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> tuple[int64, timedelta64[int | None]]: ...
+    @overload
+    def __divmod__(self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], /) -> tuple[int64, timedelta64[_AnyTD64Item | None]]: ...
+    @overload
     def __divmod__(self: timedelta64[dt.timedelta], x: dt.timedelta, /) -> tuple[int, dt.timedelta]: ...
     @overload
+    def __divmod__(self, x: timedelta64[int], /) -> tuple[int64, timedelta64[int | None]]: ...
+    @overload
     def __divmod__(self, x: timedelta64, /) -> tuple[int64, timedelta64]: ...
-    __rdivmod__ = __divmod__
+
+    # keep in sync with __rmod__
+    @overload
+    def __rdivmod__(self, x: timedelta64[None], /) -> tuple[int64, timedelta64[None]]: ...
+    @overload
+    def __rdivmod__(self: timedelta64[None | L[0]], x: timedelta64, /) -> tuple[int64, timedelta64[None]]: ...
+    @overload
+    def __rdivmod__(self: timedelta64[int], x: timedelta64[int | dt.timedelta], /) -> tuple[int64, timedelta64[int | None]]: ...
+    @overload
+    def __rdivmod__(self: timedelta64[dt.timedelta], x: timedelta64[_AnyTD64Item], /) -> tuple[int64, timedelta64[_AnyTD64Item | None]]: ...
+    @overload
+    def __rdivmod__(self: timedelta64[dt.timedelta], x: dt.timedelta, /) -> tuple[int, dt.timedelta]: ...
+    @overload
+    def __rdivmod__(self, x: timedelta64[int], /) -> tuple[int64, timedelta64[int | None]]: ...
+    @overload
+    def __rdivmod__(self, x: timedelta64, /) -> tuple[int64, timedelta64]: ...
 
     @overload
     def __sub__(self: timedelta64[None], b: _TD64Like_co, /) -> timedelta64[None]: ...
@@ -4665,12 +4730,26 @@ class character(flexible[_CharacterItemT_co], Generic[_CharacterItemT_co]):
 
 class bytes_(character[bytes], bytes):
     @overload
-    def __init__(self, value: object = ..., /) -> None: ...
+    def __new__(cls, o: object = ..., /) -> Self: ...
     @overload
-    def __init__(self, value: str, /, encoding: str = ..., errors: str = ...) -> None: ...
+    def __new__(cls, s: str, /, encoding: str, errors: str = ...) -> Self: ...
+
+    #
+    @overload
+    def __init__(self, o: object = ..., /) -> None: ...
+    @overload
+    def __init__(self, s: str, /, encoding: str, errors: str = ...) -> None: ...
+
+    #
     def __bytes__(self, /) -> bytes: ...
 
 class str_(character[str], str):
+    @overload
+    def __new__(cls, value: object = ..., /) -> Self: ...
+    @overload
+    def __new__(cls, value: bytes, /, encoding: str = ..., errors: str = ...) -> Self: ...
+
+    #
     @overload
     def __init__(self, value: object = ..., /) -> None: ...
     @overload
@@ -4835,11 +4914,6 @@ bitwise_right_shift = right_shift
 permute_dims = transpose
 pow = power
 
-class _CopyMode(enum.Enum):
-    ALWAYS: L[True]
-    IF_NEEDED: L[False]
-    NEVER: L[2]
-
 class errstate:
     def __init__(
         self,
diff --git a/numpy/_configtool.pyi b/numpy/_configtool.pyi
new file mode 100644
index 000000000000..7e7363e797f3
--- /dev/null
+++ b/numpy/_configtool.pyi
@@ -0,0 +1 @@
+def main() -> None: ...
diff --git a/numpy/_core/arrayprint.pyi b/numpy/_core/arrayprint.pyi
index 10728131ba3f..661d58a22fe3 100644
--- a/numpy/_core/arrayprint.pyi
+++ b/numpy/_core/arrayprint.pyi
@@ -1,42 +1,52 @@
 from collections.abc import Callable
-from typing import Any, Literal, TypeAlias, TypedDict, SupportsIndex, type_check_only
 
 # Using a private class is by no means ideal, but it is simply a consequence
 # of a `contextlib.context` returning an instance of aforementioned class
 from contextlib import _GeneratorContextManager
+from typing import Any, Final, Literal, SupportsIndex, TypeAlias, TypedDict, overload, type_check_only
+
+from typing_extensions import deprecated
 
 import numpy as np
-from numpy import (
-    integer,
-    timedelta64,
-    datetime64,
-    floating,
-    complexfloating,
-    void,
-    longdouble,
-    clongdouble,
-)
 from numpy._typing import NDArray, _CharLike_co, _FloatLike_co
 
+__all__ = [
+    "array2string",
+    "array_repr",
+    "array_str",
+    "format_float_positional",
+    "format_float_scientific",
+    "get_printoptions",
+    "printoptions",
+    "set_printoptions",
+]
+
+###
+
 _FloatMode: TypeAlias = Literal["fixed", "unique", "maxprec", "maxprec_equal"]
+_LegacyNoStyle: TypeAlias = Literal["1.21", "1.25", "2.1", False]
+_Legacy: TypeAlias = Literal["1.13", _LegacyNoStyle]
+_Sign: TypeAlias = Literal["-", "+", " "]
+_Trim: TypeAlias = Literal["k", ".", "0", "-"]
+_ReprFunc: TypeAlias = Callable[[NDArray[Any]], str]
 
 @type_check_only
 class _FormatDict(TypedDict, total=False):
     bool: Callable[[np.bool], str]
-    int: Callable[[integer[Any]], str]
-    timedelta: Callable[[timedelta64], str]
-    datetime: Callable[[datetime64], str]
-    float: Callable[[floating[Any]], str]
-    longfloat: Callable[[longdouble], str]
-    complexfloat: Callable[[complexfloating[Any, Any]], str]
-    longcomplexfloat: Callable[[clongdouble], str]
-    void: Callable[[void], str]
+    int: Callable[[np.integer], str]
+    timedelta: Callable[[np.timedelta64], str]
+    datetime: Callable[[np.datetime64], str]
+    float: Callable[[np.floating], str]
+    longfloat: Callable[[np.longdouble], str]
+    complexfloat: Callable[[np.complexfloating], str]
+    longcomplexfloat: Callable[[np.clongdouble], str]
+    void: Callable[[np.void], str]
     numpystr: Callable[[_CharLike_co], str]
     object: Callable[[object], str]
     all: Callable[[object], str]
-    int_kind: Callable[[integer[Any]], str]
-    float_kind: Callable[[floating[Any]], str]
-    complex_kind: Callable[[complexfloating[Any, Any]], str]
+    int_kind: Callable[[np.integer], str]
+    float_kind: Callable[[np.floating], str]
+    complex_kind: Callable[[np.complexfloating], str]
     str_kind: Callable[[_CharLike_co], str]
 
 @type_check_only
@@ -48,10 +58,14 @@ class _FormatOptions(TypedDict):
     suppress: bool
     nanstr: str
     infstr: str
-    formatter: None | _FormatDict
-    sign: Literal["-", "+", " "]
+    formatter: _FormatDict | None
+    sign: _Sign
     floatmode: _FloatMode
-    legacy: Literal[False, "1.13", "1.21"]
+    legacy: _Legacy
+
+###
+
+__docformat__: Final = "restructuredtext"  # undocumented
 
 def set_printoptions(
     precision: None | SupportsIndex = ...,
@@ -62,37 +76,112 @@ def set_printoptions(
     nanstr: None | str = ...,
     infstr: None | str = ...,
     formatter: None | _FormatDict = ...,
-    sign: Literal[None, "-", "+", " "] = ...,
-    floatmode: None | _FloatMode = ...,
+    sign: _Sign | None = None,
+    floatmode: _FloatMode | None = None,
     *,
-    legacy: Literal[None, False, "1.13", "1.21"] = ...,
-    override_repr: None | Callable[[NDArray[Any]], str] = ...,
+    legacy: _Legacy | None = None,
+    override_repr: _ReprFunc | None = None,
 ) -> None: ...
 def get_printoptions() -> _FormatOptions: ...
+
+# public numpy export
+@overload  # no style
 def array2string(
     a: NDArray[Any],
-    max_line_width: None | int = ...,
-    precision: None | SupportsIndex = ...,
-    suppress_small: None | bool = ...,
-    separator: str = ...,
-    prefix: str = ...,
-    # NOTE: With the `style` argument being deprecated,
-    # all arguments between `formatter` and `suffix` are de facto
-    # keyworld-only arguments
+    max_line_width: int | None = None,
+    precision: SupportsIndex | None = None,
+    suppress_small: bool | None = None,
+    separator: str = " ",
+    prefix: str = "",
     *,
-    formatter: None | _FormatDict = ...,
-    threshold: None | int = ...,
-    edgeitems: None | int = ...,
-    sign: Literal[None, "-", "+", " "] = ...,
-    floatmode: None | _FloatMode = ...,
-    suffix: str = ...,
-    legacy: Literal[None, False, "1.13", "1.21"] = ...,
+    formatter: _FormatDict | None = None,
+    threshold: int | None = None,
+    edgeitems: int | None = None,
+    sign: _Sign | None = None,
+    floatmode: _FloatMode | None = None,
+    suffix: str = "",
+    legacy: _Legacy | None = None,
 ) -> str: ...
+@overload  # style=<given> (positional), legacy="1.13"
+def array2string(
+    a: NDArray[Any],
+    max_line_width: int | None,
+    precision: SupportsIndex | None,
+    suppress_small: bool | None,
+    separator: str,
+    prefix: str,
+    style: _ReprFunc,
+    formatter: _FormatDict | None = None,
+    threshold: int | None = None,
+    edgeitems: int | None = None,
+    sign: _Sign | None = None,
+    floatmode: _FloatMode | None = None,
+    suffix: str = "",
+    *,
+    legacy: Literal["1.13"],
+) -> str: ...
+@overload  # style=<given> (keyword), legacy="1.13"
+def array2string(
+    a: NDArray[Any],
+    max_line_width: int | None = None,
+    precision: SupportsIndex | None = None,
+    suppress_small: bool | None = None,
+    separator: str = " ",
+    prefix: str = "",
+    *,
+    style: _ReprFunc,
+    formatter: _FormatDict | None = None,
+    threshold: int | None = None,
+    edgeitems: int | None = None,
+    sign: _Sign | None = None,
+    floatmode: _FloatMode | None = None,
+    suffix: str = "",
+    legacy: Literal["1.13"],
+) -> str: ...
+@overload  # style=<given> (positional), legacy!="1.13"
+@deprecated("'style' argument is deprecated and no longer functional except in 1.13 'legacy' mode")
+def array2string(
+    a: NDArray[Any],
+    max_line_width: int | None,
+    precision: SupportsIndex | None,
+    suppress_small: bool | None,
+    separator: str,
+    prefix: str,
+    style: _ReprFunc,
+    formatter: _FormatDict | None = None,
+    threshold: int | None = None,
+    edgeitems: int | None = None,
+    sign: _Sign | None = None,
+    floatmode: _FloatMode | None = None,
+    suffix: str = "",
+    *,
+    legacy: _LegacyNoStyle | None = None,
+) -> str: ...
+@overload  # style=<given> (keyword), legacy="1.13"
+@deprecated("'style' argument is deprecated and no longer functional except in 1.13 'legacy' mode")
+def array2string(
+    a: NDArray[Any],
+    max_line_width: int | None = None,
+    precision: SupportsIndex | None = None,
+    suppress_small: bool | None = None,
+    separator: str = " ",
+    prefix: str = "",
+    *,
+    style: _ReprFunc,
+    formatter: _FormatDict | None = None,
+    threshold: int | None = None,
+    edgeitems: int | None = None,
+    sign: _Sign | None = None,
+    floatmode: _FloatMode | None = None,
+    suffix: str = "",
+    legacy: _LegacyNoStyle | None = None,
+) -> str: ...
+
 def format_float_scientific(
     x: _FloatLike_co,
     precision: None | int = ...,
     unique: bool = ...,
-    trim: Literal["k", ".", "0", "-"] = ...,
+    trim: _Trim = "k",
     sign: bool = ...,
     pad_left: None | int = ...,
     exp_digits: None | int = ...,
@@ -103,7 +192,7 @@ def format_float_positional(
     precision: None | int = ...,
     unique: bool = ...,
     fractional: bool = ...,
-    trim: Literal["k", ".", "0", "-"] = ...,
+    trim: _Trim = "k",
     sign: bool = ...,
     pad_left: None | int = ...,
     pad_right: None | int = ...,
@@ -130,8 +219,9 @@ def printoptions(
     nanstr: None | str = ...,
     infstr: None | str = ...,
     formatter: None | _FormatDict = ...,
-    sign: Literal[None, "-", "+", " "] = ...,
-    floatmode: None | _FloatMode = ...,
+    sign: None | _Sign = None,
+    floatmode: _FloatMode | None = None,
     *,
-    legacy: Literal[None, False, "1.13", "1.21"] = ...
+    legacy: _Legacy | None = None,
+    override_repr: _ReprFunc | None = None,
 ) -> _GeneratorContextManager[_FormatOptions]: ...
diff --git a/numpy/_core/src/common/npy_atomic.h b/numpy/_core/src/common/npy_atomic.h
index 910028dcde7c..f5b41d7068be 100644
--- a/numpy/_core/src/common/npy_atomic.h
+++ b/numpy/_core/src/common/npy_atomic.h
@@ -9,11 +9,18 @@
 
 #include "numpy/npy_common.h"
 
-#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L \
+#ifdef __cplusplus
+    extern "C++" {
+        #include <atomic>
+    }
+    #define _NPY_USING_STD using namespace std
+    #define _Atomic(tp) atomic<tp>
+    #define STDC_ATOMICS
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L \
     && !defined(__STDC_NO_ATOMICS__)
-// TODO: support C++ atomics as well if this header is ever needed in C++
     #include <stdatomic.h>
     #include <stdint.h>
+    #define _NPY_USING_STD
     #define STDC_ATOMICS
 #elif _MSC_VER
     #include <intrin.h>
@@ -35,6 +42,7 @@
 static inline npy_uint8
 npy_atomic_load_uint8(const npy_uint8 *obj) {
 #ifdef STDC_ATOMICS
+    _NPY_USING_STD;
     return (npy_uint8)atomic_load((const _Atomic(uint8_t)*)obj);
 #elif defined(MSC_ATOMICS)
 #if defined(_M_X64) || defined(_M_IX86)
@@ -50,6 +58,7 @@ npy_atomic_load_uint8(const npy_uint8 *obj) {
 static inline void*
 npy_atomic_load_ptr(const void *obj) {
 #ifdef STDC_ATOMICS
+    _NPY_USING_STD;
     return atomic_load((const _Atomic(void *)*)obj);
 #elif defined(MSC_ATOMICS)
 #if SIZEOF_VOID_P == 8
@@ -73,6 +82,7 @@ npy_atomic_load_ptr(const void *obj) {
 static inline void
 npy_atomic_store_uint8(npy_uint8 *obj, npy_uint8 value) {
 #ifdef STDC_ATOMICS
+    _NPY_USING_STD;
     atomic_store((_Atomic(uint8_t)*)obj, value);
 #elif defined(MSC_ATOMICS)
     _InterlockedExchange8((volatile char *)obj, (char)value);
@@ -85,6 +95,7 @@ static inline void
 npy_atomic_store_ptr(void *obj, void *value)
 {
 #ifdef STDC_ATOMICS
+    _NPY_USING_STD;
     atomic_store((_Atomic(void *)*)obj, value);
 #elif defined(MSC_ATOMICS)
     _InterlockedExchangePointer((void * volatile *)obj, (void *)value);
diff --git a/numpy/_core/src/highway b/numpy/_core/src/highway
index 68b0fdebffb1..0b696633f9ad 160000
--- a/numpy/_core/src/highway
+++ b/numpy/_core/src/highway
@@ -1 +1 @@
-Subproject commit 68b0fdebffb14f3b8473fed1c33ce368efc431e7
+Subproject commit 0b696633f9ad89497dd5532b55eaa01625ad71ca
diff --git a/numpy/_core/src/multiarray/_multiarray_tests.c.src b/numpy/_core/src/multiarray/_multiarray_tests.c.src
index 5d0d91f1e996..fc73a64b19a0 100644
--- a/numpy/_core/src/multiarray/_multiarray_tests.c.src
+++ b/numpy/_core/src/multiarray/_multiarray_tests.c.src
@@ -1877,7 +1877,9 @@ get_fpu_mode(PyObject *NPY_UNUSED(self), PyObject *args)
         result = _controlfp(0, 0);
         return PyLong_FromLongLong(result);
     }
-#elif (defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))) || (defined(_MSC_VER) && defined(__clang__))
+#elif (defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))) \
+  || (defined(_MSC_VER) && defined(__clang__) && \
+      (defined(_M_IX86) || defined(_M_AMD64)))
     {
         unsigned short cw = 0;
         __asm__("fstcw %w0" : "=m" (cw));
diff --git a/numpy/_core/src/multiarray/convert_datatype.c b/numpy/_core/src/multiarray/convert_datatype.c
index 1dff38a1d1ef..00251af5bf68 100644
--- a/numpy/_core/src/multiarray/convert_datatype.c
+++ b/numpy/_core/src/multiarray/convert_datatype.c
@@ -62,46 +62,24 @@ static PyObject *
 PyArray_GetObjectToGenericCastingImpl(void);
 
 
-/**
- * Fetch the casting implementation from one DType to another.
- *
- * @param from The implementation to cast from
- * @param to The implementation to cast to
- *
- * @returns A castingimpl (PyArrayDTypeMethod *), None or NULL with an
- *          error set.
- */
-NPY_NO_EXPORT PyObject *
-PyArray_GetCastingImpl(PyArray_DTypeMeta *from, PyArray_DTypeMeta *to)
+static PyObject *
+create_casting_impl(PyArray_DTypeMeta *from, PyArray_DTypeMeta *to)
 {
-    PyObject *res;
-    if (from == to) {
-        res = (PyObject *)NPY_DT_SLOTS(from)->within_dtype_castingimpl;
-    }
-    else {
-        res = PyDict_GetItemWithError(NPY_DT_SLOTS(from)->castingimpls, (PyObject *)to);
-    }
-    if (res != NULL || PyErr_Occurred()) {
-        Py_XINCREF(res);
-        return res;
-    }
     /*
-     * The following code looks up CastingImpl based on the fact that anything
+     * Look up CastingImpl based on the fact that anything
      * can be cast to and from objects or structured (void) dtypes.
-     *
-     * The last part adds casts dynamically based on legacy definition
      */
     if (from->type_num == NPY_OBJECT) {
-        res = PyArray_GetObjectToGenericCastingImpl();
+        return PyArray_GetObjectToGenericCastingImpl();
     }
     else if (to->type_num == NPY_OBJECT) {
-        res = PyArray_GetGenericToObjectCastingImpl();
+        return PyArray_GetGenericToObjectCastingImpl();
     }
     else if (from->type_num == NPY_VOID) {
-        res = PyArray_GetVoidToGenericCastingImpl();
+        return PyArray_GetVoidToGenericCastingImpl();
     }
     else if (to->type_num == NPY_VOID) {
-        res = PyArray_GetGenericToVoidCastingImpl();
+        return PyArray_GetGenericToVoidCastingImpl();
     }
     /*
      * Reject non-legacy dtypes. They need to use the new API to add casts and
@@ -125,42 +103,105 @@ PyArray_GetCastingImpl(PyArray_DTypeMeta *from, PyArray_DTypeMeta *to)
                     from->singleton, to->type_num);
             if (castfunc == NULL) {
                 PyErr_Clear();
-                /* Remember that this cast is not possible */
-                if (PyDict_SetItem(NPY_DT_SLOTS(from)->castingimpls,
-                            (PyObject *) to, Py_None) < 0) {
-                    return NULL;
-                }
                 Py_RETURN_NONE;
             }
         }
-
-        /* PyArray_AddLegacyWrapping_CastingImpl find the correct casting level: */
-        /*
-         * TODO: Possibly move this to the cast registration time. But if we do
-         *       that, we have to also update the cast when the casting safety
-         *       is registered.
+        /* Create a cast using the state of the legacy casting setup defined
+         * during the setup of the DType.
+         *
+         * Ideally we would do this when we create the DType, but legacy user
+         * DTypes don't have a way to signal that a DType is done setting up
+         * casts. Without such a mechanism, the safest way to know that a
+         * DType is done setting up is to register the cast lazily the first
+         * time a user does the cast.
+         *
+         * We *could* register the casts when we create the wrapping
+         * DTypeMeta, but that means the internals of the legacy user DType
+         * system would need to update the state of the casting safety flags
+         * in the cast implementations stored on the DTypeMeta. That's an
+         * inversion of abstractions and would be tricky to do without
+         * creating circular dependencies inside NumPy.
          */
         if (PyArray_AddLegacyWrapping_CastingImpl(from, to, -1) < 0) {
             return NULL;
         }
+        /* castingimpls is unconditionally filled by
+         * AddLegacyWrapping_CastingImpl, so this won't create a recursive
+         * critical section
+         */
         return PyArray_GetCastingImpl(from, to);
     }
+}
 
-    if (res == NULL) {
+static PyObject *
+ensure_castingimpl_exists(PyArray_DTypeMeta *from, PyArray_DTypeMeta *to)
+{
+    int return_error = 0;
+    PyObject *res = NULL;
+
+    /* Need to create the cast. This might happen at runtime so we enter a
+       critical section to avoid races */
+
+    Py_BEGIN_CRITICAL_SECTION(NPY_DT_SLOTS(from)->castingimpls);
+
+    /* check if another thread filled it while this thread was blocked on
+       acquiring the critical section */
+    if (PyDict_GetItemRef(NPY_DT_SLOTS(from)->castingimpls, (PyObject *)to,
+                          &res) < 0) {
+        return_error = 1;
+    }
+    else if (res == NULL) {
+        res = create_casting_impl(from, to);
+        if (res == NULL) {
+            return_error = 1;
+        }
+        else if (PyDict_SetItem(NPY_DT_SLOTS(from)->castingimpls,
+                                (PyObject *)to, res) < 0) {
+            return_error = 1;
+        }
+    }
+    Py_END_CRITICAL_SECTION();
+    if (return_error) {
+        Py_XDECREF(res);
         return NULL;
     }
-    if (from == to) {
+    if (from == to && res == Py_None) {
         PyErr_Format(PyExc_RuntimeError,
                 "Internal NumPy error, within-DType cast missing for %S!", from);
         Py_DECREF(res);
         return NULL;
     }
-    if (PyDict_SetItem(NPY_DT_SLOTS(from)->castingimpls,
-                (PyObject *)to, res) < 0) {
-        Py_DECREF(res);
+    return res;
+}
+
+/**
+ * Fetch the casting implementation from one DType to another.
+ *
+ * @param from The implementation to cast from
+ * @param to The implementation to cast to
+ *
+ * @returns A castingimpl (PyArrayDTypeMethod *), None or NULL with an
+ *          error set.
+ */
+NPY_NO_EXPORT PyObject *
+PyArray_GetCastingImpl(PyArray_DTypeMeta *from, PyArray_DTypeMeta *to)
+{
+    PyObject *res = NULL;
+    if (from == to) {
+        if ((NPY_DT_SLOTS(from)->within_dtype_castingimpl) != NULL) {
+            res = Py_XNewRef(
+                    (PyObject *)NPY_DT_SLOTS(from)->within_dtype_castingimpl);
+        }
+    }
+    else if (PyDict_GetItemRef(NPY_DT_SLOTS(from)->castingimpls,
+                               (PyObject *)to, &res) < 0) {
         return NULL;
     }
-    return res;
+    if (res != NULL) {
+        return res;
+    }
+
+    return ensure_castingimpl_exists(from, to);
 }
 
 
@@ -409,7 +450,7 @@ _get_cast_safety_from_castingimpl(PyArrayMethodObject *castingimpl,
  * implementations fully to have them available for doing the actual cast
  * later.
  *
- * @param from The descriptor to cast from 
+ * @param from The descriptor to cast from
  * @param to The descriptor to cast to (may be NULL)
  * @param to_dtype If `to` is NULL, must pass the to_dtype (otherwise this
  *        is ignored).
@@ -2031,6 +2072,11 @@ PyArray_AddCastingImplementation(PyBoundArrayMethodObject *meth)
 /**
  * Add a new casting implementation using a PyArrayMethod_Spec.
  *
+ * Using this function outside of module initialization without holding a
+ * critical section on the castingimpls dict may lead to a race to fill the
+ * dict. Use PyArray_GetGastingImpl to lazily register casts at runtime
+ * safely.
+ *
  * @param spec The specification to use as a source
  * @param private If private, allow slots not publicly exposed.
  * @return 0 on success -1 on failure
diff --git a/numpy/_core/src/multiarray/ctors.c b/numpy/_core/src/multiarray/ctors.c
index cfa8b9231818..b6a935e419a6 100644
--- a/numpy/_core/src/multiarray/ctors.c
+++ b/numpy/_core/src/multiarray/ctors.c
@@ -1829,12 +1829,18 @@ PyArray_CheckFromAny_int(PyObject *op, PyArray_Descr *in_descr,
 {
     PyObject *obj;
     if (requires & NPY_ARRAY_NOTSWAPPED) {
-        if (!in_descr && PyArray_Check(op)) {
-            in_descr = PyArray_DESCR((PyArrayObject *)op);
-            Py_INCREF(in_descr);
+        if (!in_descr && PyArray_Check(op) &&
+                PyArray_ISBYTESWAPPED((PyArrayObject* )op)) {
+            in_descr = PyArray_DescrNew(PyArray_DESCR((PyArrayObject *)op));
+            if (in_descr == NULL) {
+                return NULL;
+            }
+        }
+        else if (in_descr && !PyArray_ISNBO(in_descr->byteorder)) {
+            PyArray_DESCR_REPLACE(in_descr);
         }
-        if (in_descr) {
-            PyArray_DESCR_REPLACE_CANONICAL(in_descr);
+        if (in_descr && in_descr->byteorder != NPY_IGNORE && in_descr->byteorder != NPY_NATIVE) {
+            in_descr->byteorder = NPY_NATIVE;
         }
     }
 
diff --git a/numpy/_core/src/multiarray/dragon4.c b/numpy/_core/src/multiarray/dragon4.c
index 7cd8afbed6d8..b936f4dc213e 100644
--- a/numpy/_core/src/multiarray/dragon4.c
+++ b/numpy/_core/src/multiarray/dragon4.c
@@ -1615,7 +1615,8 @@ typedef struct Dragon4_Options {
  *
  * See Dragon4_Options for description of remaining arguments.
  */
-static npy_uint32
+
+static npy_int32
 FormatPositional(char *buffer, npy_uint32 bufferSize, BigInt *mantissa,
                  npy_int32 exponent, char signbit, npy_uint32 mantissaBit,
                  npy_bool hasUnequalMargins, DigitMode digit_mode,
@@ -1646,7 +1647,7 @@ FormatPositional(char *buffer, npy_uint32 bufferSize, BigInt *mantissa,
         buffer[pos++] = '-';
         has_sign = 1;
     }
-
+        
     numDigits = Dragon4(mantissa, exponent, mantissaBit, hasUnequalMargins,
                         digit_mode, cutoff_mode, precision, min_digits,
                         buffer + has_sign, maxPrintLen - has_sign,
@@ -1658,14 +1659,14 @@ FormatPositional(char *buffer, npy_uint32 bufferSize, BigInt *mantissa,
     /* if output has a whole number */
     if (printExponent >= 0) {
         /* leave the whole number at the start of the buffer */
-        numWholeDigits = printExponent+1;
+        numWholeDigits = printExponent+1;        
         if (numDigits <= numWholeDigits) {
             npy_int32 count = numWholeDigits - numDigits;
             pos += numDigits;
 
-            /* don't overflow the buffer */
-            if (pos + count > maxPrintLen) {
-                count = maxPrintLen - pos;
+            if (count > maxPrintLen - pos) {
+                PyErr_SetString(PyExc_RuntimeError, "Float formating result too large");
+                return -1;
             }
 
             /* add trailing zeros up to the decimal point */
@@ -1767,9 +1768,12 @@ FormatPositional(char *buffer, npy_uint32 bufferSize, BigInt *mantissa,
              pos < maxPrintLen) {
         /* add trailing zeros up to add_digits length */
         /* compute the number of trailing zeros needed */
+        
         npy_int32 count = desiredFractionalDigits - numFractionDigits;
-        if (pos + count > maxPrintLen) {
-            count = maxPrintLen - pos;
+        
+        if (count > maxPrintLen - pos) {
+            PyErr_SetString(PyExc_RuntimeError, "Float formating result too large");
+            return -1;
         }
         numFractionDigits += count;
 
@@ -1802,7 +1806,7 @@ FormatPositional(char *buffer, npy_uint32 bufferSize, BigInt *mantissa,
     }
 
     /* add any whitespace padding to right side */
-    if (digits_right >= numFractionDigits) {
+    if (digits_right >= numFractionDigits) {        
         npy_int32 count = digits_right - numFractionDigits;
 
         /* in trim_mode DptZeros, if right padding, add a space for the . */
@@ -1811,8 +1815,9 @@ FormatPositional(char *buffer, npy_uint32 bufferSize, BigInt *mantissa,
             buffer[pos++] = ' ';
         }
 
-        if (pos + count > maxPrintLen) {
-            count = maxPrintLen - pos;
+        if (count > maxPrintLen - pos) {
+            PyErr_SetString(PyExc_RuntimeError, "Float formating result too large");
+            return -1;
         }
 
         for ( ; count > 0; count--) {
@@ -1823,14 +1828,16 @@ FormatPositional(char *buffer, npy_uint32 bufferSize, BigInt *mantissa,
     if (digits_left > numWholeDigits + has_sign) {
         npy_int32 shift = digits_left - (numWholeDigits + has_sign);
         npy_int32 count = pos;
-
-        if (count + shift > maxPrintLen) {
-            count = maxPrintLen - shift;
+                
+        if (count > maxPrintLen - shift) {
+            PyErr_SetString(PyExc_RuntimeError, "Float formating result too large");
+            return -1;
         }
 
         if (count > 0) {
             memmove(buffer + shift, buffer, count);
         }
+
         pos = shift + count;
         for ( ; shift > 0; shift--) {
             buffer[shift - 1] = ' ';
@@ -1860,7 +1867,7 @@ FormatPositional(char *buffer, npy_uint32 bufferSize, BigInt *mantissa,
  *
  * See Dragon4_Options for description of remaining arguments.
  */
-static npy_uint32
+static npy_int32
 FormatScientific (char *buffer, npy_uint32 bufferSize, BigInt *mantissa,
                   npy_int32 exponent, char signbit, npy_uint32 mantissaBit,
                   npy_bool hasUnequalMargins, DigitMode digit_mode,
@@ -2158,7 +2165,7 @@ PrintInfNan(char *buffer, npy_uint32 bufferSize, npy_uint64 mantissa,
  * Helper function that takes Dragon4 parameters and options and
  * calls Dragon4.
  */
-static npy_uint32
+static npy_int32
 Format_floatbits(char *buffer, npy_uint32 bufferSize, BigInt *mantissa,
                  npy_int32 exponent, char signbit, npy_uint32 mantissaBit,
                  npy_bool hasUnequalMargins, Dragon4_Options *opt)
@@ -2187,7 +2194,7 @@ Format_floatbits(char *buffer, npy_uint32 bufferSize, BigInt *mantissa,
  * exponent:  5 bits
  * mantissa: 10 bits
  */
-static npy_uint32
+static npy_int32
 Dragon4_PrintFloat_IEEE_binary16(
         npy_half *value, Dragon4_Options *opt)
 {
@@ -2274,7 +2281,7 @@ Dragon4_PrintFloat_IEEE_binary16(
  * exponent:  8 bits
  * mantissa: 23 bits
  */
-static npy_uint32
+static npy_int32
 Dragon4_PrintFloat_IEEE_binary32(
         npy_float32 *value,
         Dragon4_Options *opt)
@@ -2367,7 +2374,7 @@ Dragon4_PrintFloat_IEEE_binary32(
  * exponent: 11 bits
  * mantissa: 52 bits
  */
-static npy_uint32
+static npy_int32
 Dragon4_PrintFloat_IEEE_binary64(
         npy_float64 *value, Dragon4_Options *opt)
 {
@@ -2482,7 +2489,7 @@ typedef struct FloatVal128 {
  * intbit     1 bit,  first u64
  * mantissa: 63 bits, first u64
  */
-static npy_uint32
+static npy_int32
 Dragon4_PrintFloat_Intel_extended(
     FloatVal128 value, Dragon4_Options *opt)
 {
@@ -2580,7 +2587,7 @@ Dragon4_PrintFloat_Intel_extended(
  * system. But numpy defines NPY_FLOAT80, so if we come across it, assume it is
  * an Intel extended format.
  */
-static npy_uint32
+static npy_int32
 Dragon4_PrintFloat_Intel_extended80(
     npy_float80 *value, Dragon4_Options *opt)
 {
@@ -2604,7 +2611,7 @@ Dragon4_PrintFloat_Intel_extended80(
 
 #ifdef HAVE_LDOUBLE_INTEL_EXTENDED_12_BYTES_LE
 /* Intel's 80-bit IEEE extended precision format, 96-bit storage */
-static npy_uint32
+static npy_int32
 Dragon4_PrintFloat_Intel_extended96(
     npy_float96 *value, Dragon4_Options *opt)
 {
@@ -2628,7 +2635,7 @@ Dragon4_PrintFloat_Intel_extended96(
 
 #ifdef HAVE_LDOUBLE_MOTOROLA_EXTENDED_12_BYTES_BE
 /* Motorola Big-endian equivalent of the Intel-extended 96 fp format */
-static npy_uint32
+static npy_int32
 Dragon4_PrintFloat_Motorola_extended96(
     npy_float96 *value, Dragon4_Options *opt)
 {
@@ -2665,7 +2672,7 @@ typedef union FloatUnion128
 
 #ifdef HAVE_LDOUBLE_INTEL_EXTENDED_16_BYTES_LE
 /* Intel's 80-bit IEEE extended precision format, 128-bit storage */
-static npy_uint32
+static npy_int32
 Dragon4_PrintFloat_Intel_extended128(
     npy_float128 *value, Dragon4_Options *opt)
 {
@@ -2694,7 +2701,7 @@ Dragon4_PrintFloat_Intel_extended128(
  * I am not sure if the arch also supports uint128, and C does not seem to
  * support int128 literals. So we use uint64 to do manipulation.
  */
-static npy_uint32
+static npy_int32
 Dragon4_PrintFloat_IEEE_binary128(
     FloatVal128 val128, Dragon4_Options *opt)
 {
@@ -2779,7 +2786,7 @@ Dragon4_PrintFloat_IEEE_binary128(
 }
 
 #if defined(HAVE_LDOUBLE_IEEE_QUAD_LE)
-static npy_uint32
+static npy_int32
 Dragon4_PrintFloat_IEEE_binary128_le(
     npy_float128 *value, Dragon4_Options *opt)
 {
@@ -2799,7 +2806,7 @@ Dragon4_PrintFloat_IEEE_binary128_le(
  * This function is untested, very few, if any, architectures implement
  * big endian IEEE binary128 floating point.
  */
-static npy_uint32
+static npy_int32
 Dragon4_PrintFloat_IEEE_binary128_be(
     npy_float128 *value, Dragon4_Options *opt)
 {
@@ -2854,7 +2861,7 @@ Dragon4_PrintFloat_IEEE_binary128_be(
  * https://gcc.gnu.org/wiki/Ieee128PowerPCA
  * https://www.ibm.com/support/knowledgecenter/en/ssw_aix_71/com.ibm.aix.genprogc/128bit_long_double_floating-point_datatype.htm
  */
-static npy_uint32
+static npy_int32
 Dragon4_PrintFloat_IBM_double_double(
     npy_float128 *value, Dragon4_Options *opt)
 {
@@ -3041,6 +3048,7 @@ Dragon4_PrintFloat_IBM_double_double(
  * which goes up to about 10^4932. The Dragon4_scratch struct provides a string
  * buffer of this size.
  */
+
 #define make_dragon4_typefuncs_inner(Type, npy_type, format) \
 \
 PyObject *\
diff --git a/numpy/_core/src/multiarray/dtypemeta.c b/numpy/_core/src/multiarray/dtypemeta.c
index a60e6fd59fd9..0b1b0fb39192 100644
--- a/numpy/_core/src/multiarray/dtypemeta.c
+++ b/numpy/_core/src/multiarray/dtypemeta.c
@@ -1252,6 +1252,12 @@ dtypemeta_wrap_legacy_descriptor(
             return -1;
         }
     }
+    else {
+        // ensure the within dtype cast is populated for legacy user dtypes
+        if (PyArray_GetCastingImpl(dtype_class, dtype_class) == NULL) {
+            return -1;
+        }
+    }
 
     return 0;
 }
diff --git a/numpy/_core/src/multiarray/item_selection.c b/numpy/_core/src/multiarray/item_selection.c
index eadb7cc099d3..fbcc0f7b162c 100644
--- a/numpy/_core/src/multiarray/item_selection.c
+++ b/numpy/_core/src/multiarray/item_selection.c
@@ -922,16 +922,23 @@ PyArray_Repeat(PyArrayObject *aop, PyObject *op, int axis)
         }
     }
 
+    /* Fill in dimensions of new array */
+    npy_intp dims[NPY_MAXDIMS] = {0};
+
+    for (int i = 0; i < PyArray_NDIM(aop); i++) {
+        dims[i] = PyArray_DIMS(aop)[i];
+    }
+
+    dims[axis] = total;
+
     /* Construct new array */
-    PyArray_DIMS(aop)[axis] = total;
     Py_INCREF(PyArray_DESCR(aop));
     ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(aop),
                                                 PyArray_DESCR(aop),
                                                 PyArray_NDIM(aop),
-                                                PyArray_DIMS(aop),
+                                                dims,
                                                 NULL, NULL, 0,
                                                 (PyObject *)aop);
-    PyArray_DIMS(aop)[axis] = n;
     if (ret == NULL) {
         goto fail;
     }
diff --git a/numpy/_core/src/multiarray/stringdtype/dtype.c b/numpy/_core/src/multiarray/stringdtype/dtype.c
index 81a846bf6d96..cb8265dd3d7a 100644
--- a/numpy/_core/src/multiarray/stringdtype/dtype.c
+++ b/numpy/_core/src/multiarray/stringdtype/dtype.c
@@ -270,6 +270,15 @@ as_pystring(PyObject *scalar, int coerce)
                         "string coercion is disabled.");
         return NULL;
     }
+    else if (scalar_type == &PyBytes_Type) {
+        // assume UTF-8 encoding
+        char *buffer;
+        Py_ssize_t length;
+        if (PyBytes_AsStringAndSize(scalar, &buffer, &length) < 0) {
+            return NULL;
+        }
+        return PyUnicode_FromStringAndSize(buffer, length);
+    }
     else {
         // attempt to coerce to str
         scalar = PyObject_Str(scalar);
diff --git a/numpy/_core/src/npysort/highway_qsort.dispatch.cpp b/numpy/_core/src/npysort/highway_qsort.dispatch.cpp
index 194a81e2d7e9..645055537d87 100644
--- a/numpy/_core/src/npysort/highway_qsort.dispatch.cpp
+++ b/numpy/_core/src/npysort/highway_qsort.dispatch.cpp
@@ -1,6 +1,4 @@
 #include "highway_qsort.hpp"
-#define VQSORT_ONLY_STATIC 1
-#include "hwy/contrib/sort/vqsort-inl.h"
 
 #if VQSORT_ENABLED
 
diff --git a/numpy/_core/src/npysort/highway_qsort.hpp b/numpy/_core/src/npysort/highway_qsort.hpp
index ba3fe4920594..77cd9f085943 100644
--- a/numpy/_core/src/npysort/highway_qsort.hpp
+++ b/numpy/_core/src/npysort/highway_qsort.hpp
@@ -1,18 +1,13 @@
 #ifndef NUMPY_SRC_COMMON_NPYSORT_HWY_SIMD_QSORT_HPP
 #define NUMPY_SRC_COMMON_NPYSORT_HWY_SIMD_QSORT_HPP
 
+#define VQSORT_ONLY_STATIC 1
 #include "hwy/highway.h"
+#include "hwy/contrib/sort/vqsort-inl.h"
 
 #include "common.hpp"
 
-// This replicates VQSORT_ENABLED from hwy/contrib/sort/shared-inl.h
-// without checking the scalar target as this is not built within the dynamic
-// dispatched sources.
-#if (HWY_COMPILER_MSVC && !HWY_IS_DEBUG_BUILD) ||                   \
-    (HWY_ARCH_ARM_V7 && HWY_IS_DEBUG_BUILD) ||                      \
-    (HWY_ARCH_ARM_A64 && HWY_COMPILER_GCC_ACTUAL && HWY_IS_ASAN) || \
-    (HWY_ARCH_ARM_A64 && HWY_COMPILER_CLANG &&                      \
-    (HWY_IS_HWASAN || HWY_IS_MSAN || HWY_IS_TSAN || HWY_IS_ASAN))
+#if !VQSORT_COMPILER_COMPATIBLE
 #define NPY_DISABLE_HIGHWAY_SORT
 #endif
 
diff --git a/numpy/_core/src/npysort/highway_qsort_16bit.dispatch.cpp b/numpy/_core/src/npysort/highway_qsort_16bit.dispatch.cpp
index d069cb6373d0..d151de2b5e62 100644
--- a/numpy/_core/src/npysort/highway_qsort_16bit.dispatch.cpp
+++ b/numpy/_core/src/npysort/highway_qsort_16bit.dispatch.cpp
@@ -1,6 +1,4 @@
 #include "highway_qsort.hpp"
-#define VQSORT_ONLY_STATIC 1
-#include "hwy/contrib/sort/vqsort-inl.h"
 
 #include "quicksort.hpp"
 
diff --git a/numpy/_core/src/umath/ufunc_object.c b/numpy/_core/src/umath/ufunc_object.c
index 657330b6f4be..69bb0b1eb197 100644
--- a/numpy/_core/src/umath/ufunc_object.c
+++ b/numpy/_core/src/umath/ufunc_object.c
@@ -5963,7 +5963,6 @@ ufunc_at(PyUFuncObject *ufunc, PyObject *args)
     NPY_AUXDATA_FREE(auxdata);
 
     Py_XDECREF(op2_array);
-    Py_XDECREF(iter);
     Py_XDECREF(iter2);
     for (int i = 0; i < nop; i++) {
         Py_XDECREF(operation_descrs[i]);
@@ -5979,9 +5978,13 @@ ufunc_at(PyUFuncObject *ufunc, PyObject *args)
         if (PyArray_FLAGS(op1_array) & NPY_ARRAY_WRITEBACKIFCOPY) {
             PyArray_DiscardWritebackIfCopy(op1_array);
         }
+        // iter might own the last refrence to op1_array,
+        // so it must be decref'd second
+        Py_XDECREF(iter);
         return NULL;
     }
     else {
+        Py_XDECREF(iter);
         Py_RETURN_NONE;
     }
 }
diff --git a/numpy/_core/tests/test_multithreading.py b/numpy/_core/tests/test_multithreading.py
index b614f2c76385..133268d276ee 100644
--- a/numpy/_core/tests/test_multithreading.py
+++ b/numpy/_core/tests/test_multithreading.py
@@ -1,10 +1,13 @@
+import concurrent.futures
 import threading
+import string
 
 import numpy as np
 import pytest
 
 from numpy.testing import IS_WASM
 from numpy.testing._private.utils import run_threaded
+from numpy._core import _rational_tests
 
 if IS_WASM:
     pytest.skip(allow_module_level=True, reason="no threading support in wasm")
@@ -38,7 +41,7 @@ def f(b):
         b.wait()
         return a.sum()
 
-    run_threaded(f, NUM_THREADS, max_workers=NUM_THREADS, pass_barrier=True)
+    run_threaded(f, NUM_THREADS, pass_barrier=True)
 
 
 def test_temp_elision_thread_safety():
@@ -129,8 +132,7 @@ def closure(b):
         b.wait()
         np.sum(x)
 
-    run_threaded(closure, NUM_THREADS, max_workers=NUM_THREADS,
-                 pass_barrier=True)
+    run_threaded(closure, NUM_THREADS, pass_barrier=True)
 
 
 def test_parallel_flat_iterator():
@@ -155,3 +157,117 @@ def closure(x, b):
             y.flat[x] = x
 
     run_threaded(closure, pass_barrier=True, prepare_args=prepare_args)
+
+
+def test_multithreaded_repeat():
+    x0 = np.arange(10)
+
+    def closure(b):
+        b.wait()
+        for _ in range(100):
+            x = np.repeat(x0, 2, axis=0)[::2]
+
+    run_threaded(closure, max_workers=10, pass_barrier=True)
+
+
+def test_structured_advanced_indexing():
+    # Test that copyswap(n) used by integer array indexing is threadsafe
+    # for structured datatypes, see gh-15387. This test can behave randomly.
+
+    # Create a deeply nested dtype to make a failure more likely:
+    dt = np.dtype([("", "f8")])
+    dt = np.dtype([("", dt)] * 2)
+    dt = np.dtype([("", dt)] * 2)
+    # The array should be large enough to likely run into threading issues
+    arr = np.random.uniform(size=(6000, 8)).view(dt)[:, 0]
+
+    rng = np.random.default_rng()
+
+    def func(arr):
+        indx = rng.integers(0, len(arr), size=6000, dtype=np.intp)
+        arr[indx]
+
+    tpe = concurrent.futures.ThreadPoolExecutor(max_workers=8)
+    futures = [tpe.submit(func, arr) for _ in range(10)]
+    for f in futures:
+        f.result()
+
+    assert arr.dtype is dt
+
+
+def test_structured_threadsafety2():
+    # Nonzero (and some other functions) should be threadsafe for
+    # structured datatypes, see gh-15387. This test can behave randomly.
+    from concurrent.futures import ThreadPoolExecutor
+
+    # Create a deeply nested dtype to make a failure more likely:
+    dt = np.dtype([("", "f8")])
+    dt = np.dtype([("", dt)])
+    dt = np.dtype([("", dt)] * 2)
+    # The array should be large enough to likely run into threading issues
+    arr = np.random.uniform(size=(5000, 4)).view(dt)[:, 0]
+
+    def func(arr):
+        arr.nonzero()
+
+    tpe = ThreadPoolExecutor(max_workers=8)
+    futures = [tpe.submit(func, arr) for _ in range(10)]
+    for f in futures:
+        f.result()
+
+    assert arr.dtype is dt
+
+
+def test_stringdtype_multithreaded_access_and_mutation(
+        dtype, random_string_list):
+    # this test uses an RNG and may crash or cause deadlocks if there is a
+    # threading bug
+    rng = np.random.default_rng(0x4D3D3D3)
+
+    chars = list(string.ascii_letters + string.digits)
+    chars = np.array(chars, dtype="U1")
+    ret = rng.choice(chars, size=100 * 10, replace=True)
+    random_string_list = ret.view("U100")
+
+    def func(arr):
+        rnd = rng.random()
+        # either write to random locations in the array, compute a ufunc, or
+        # re-initialize the array
+        if rnd < 0.25:
+            num = np.random.randint(0, arr.size)
+            arr[num] = arr[num] + "hello"
+        elif rnd < 0.5:
+            if rnd < 0.375:
+                np.add(arr, arr)
+            else:
+                np.add(arr, arr, out=arr)
+        elif rnd < 0.75:
+            if rnd < 0.875:
+                np.multiply(arr, np.int64(2))
+            else:
+                np.multiply(arr, np.int64(2), out=arr)
+        else:
+            arr[:] = random_string_list
+
+    with concurrent.futures.ThreadPoolExecutor(max_workers=8) as tpe:
+        arr = np.array(random_string_list, dtype=dtype)
+        futures = [tpe.submit(func, arr) for _ in range(500)]
+
+        for f in futures:
+            f.result()
+
+
+def test_legacy_usertype_cast_init_thread_safety():
+    def closure(b):
+        b.wait()
+        np.full((10, 10), 1, _rational_tests.rational)
+
+    try:
+        run_threaded(closure, 250, pass_barrier=True)
+    except RuntimeError:
+        # The 32 bit linux runner will trigger this with 250 threads. I can
+        # trigger it on my Linux laptop with 500 threads but the CI runner is
+        # more resource-constrained.
+        # Reducing the number of threads means the test doesn't trigger the
+        # bug. Better to skip on some platforms than add a useless test.
+        pytest.skip("Couldn't spawn enough threads to run the test")
diff --git a/numpy/_core/tests/test_scalarprint.py b/numpy/_core/tests/test_scalarprint.py
index f47542ef779c..b6872c2b482b 100644
--- a/numpy/_core/tests/test_scalarprint.py
+++ b/numpy/_core/tests/test_scalarprint.py
@@ -8,7 +8,8 @@
 
 from tempfile import TemporaryFile
 import numpy as np
-from numpy.testing import assert_, assert_equal, assert_raises, IS_MUSL
+from numpy.testing import (
+    assert_, assert_equal, assert_raises, assert_raises_regex, IS_MUSL)
 
 class TestRealScalars:
     def test_str(self):
@@ -260,53 +261,93 @@ def test_dragon4(self):
         assert_equal(fpos64('324', unique=False, precision=5,
                                    fractional=False), "324.00")
 
-    def test_dragon4_interface(self):
-        tps = [np.float16, np.float32, np.float64]
+    available_float_dtypes = [np.float16, np.float32, np.float64, np.float128]\
+        if hasattr(np, 'float128') else [np.float16, np.float32, np.float64]
+    
+    @pytest.mark.parametrize("tp", available_float_dtypes)
+    def test_dragon4_positional_interface(self, tp):
         # test is flaky for musllinux on np.float128
-        if hasattr(np, 'float128') and not IS_MUSL:
-            tps.append(np.float128)
-
+        if IS_MUSL and tp == np.float128:
+            pytest.skip("Skipping flaky test of float128 on musllinux")
+                
+        fpos = np.format_float_positional
+        
+        # test padding
+        assert_equal(fpos(tp('1.0'), pad_left=4, pad_right=4), "   1.    ")
+        assert_equal(fpos(tp('-1.0'), pad_left=4, pad_right=4), "  -1.    ")
+        assert_equal(fpos(tp('-10.2'),
+                        pad_left=4, pad_right=4), " -10.2   ")
+        
+        # test fixed (non-unique) mode
+        assert_equal(fpos(tp('1.0'), unique=False, precision=4), "1.0000")
+
+    @pytest.mark.parametrize("tp", available_float_dtypes)
+    def test_dragon4_positional_interface_trim(self, tp):
+        # test is flaky for musllinux on np.float128
+        if IS_MUSL and tp == np.float128:
+            pytest.skip("Skipping flaky test of float128 on musllinux")
+                        
         fpos = np.format_float_positional
+        # test trimming
+        # trim of 'k' or '.' only affects non-unique mode, since unique
+        # mode will not output trailing 0s.
+        assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='k'),
+                        "1.0000")
+
+        assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='.'),
+                        "1.")
+        assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='.'),
+                        "1.2" if tp != np.float16 else "1.2002")
+
+        assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='0'),
+                        "1.0")
+        assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='0'),
+                        "1.2" if tp != np.float16 else "1.2002")
+        assert_equal(fpos(tp('1.'), trim='0'), "1.0")
+
+        assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='-'),
+                        "1")
+        assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='-'),
+                        "1.2" if tp != np.float16 else "1.2002")
+        assert_equal(fpos(tp('1.'), trim='-'), "1")
+        assert_equal(fpos(tp('1.001'), precision=1, trim='-'), "1")
+                
+    @pytest.mark.parametrize("tp", available_float_dtypes)
+    @pytest.mark.parametrize("pad_val", [10**5, np.iinfo("int32").max])
+    def test_dragon4_positional_interface_overflow(self, tp, pad_val):
+        # test is flaky for musllinux on np.float128
+        if IS_MUSL and tp == np.float128:
+            pytest.skip("Skipping flaky test of float128 on musllinux")
+                
+        fpos = np.format_float_positional
+
+        #gh-28068            
+        with pytest.raises(RuntimeError, 
+                           match="Float formating result too large"):
+            fpos(tp('1.047'), unique=False, precision=pad_val)
+
+        with pytest.raises(RuntimeError, 
+                           match="Float formating result too large"):
+            fpos(tp('1.047'), precision=2, pad_left=pad_val)
+
+        with pytest.raises(RuntimeError, 
+                           match="Float formating result too large"):
+            fpos(tp('1.047'), precision=2, pad_right=pad_val)
+
+    @pytest.mark.parametrize("tp", available_float_dtypes)
+    def test_dragon4_scientific_interface(self, tp):
+        # test is flaky for musllinux on np.float128
+        if IS_MUSL and tp == np.float128:
+            pytest.skip("Skipping flaky test of float128 on musllinux")
+                        
         fsci = np.format_float_scientific
 
-        for tp in tps:
-            # test padding
-            assert_equal(fpos(tp('1.0'), pad_left=4, pad_right=4), "   1.    ")
-            assert_equal(fpos(tp('-1.0'), pad_left=4, pad_right=4), "  -1.    ")
-            assert_equal(fpos(tp('-10.2'),
-                         pad_left=4, pad_right=4), " -10.2   ")
-
-            # test exp_digits
-            assert_equal(fsci(tp('1.23e1'), exp_digits=5), "1.23e+00001")
-
-            # test fixed (non-unique) mode
-            assert_equal(fpos(tp('1.0'), unique=False, precision=4), "1.0000")
-            assert_equal(fsci(tp('1.0'), unique=False, precision=4),
-                         "1.0000e+00")
-
-            # test trimming
-            # trim of 'k' or '.' only affects non-unique mode, since unique
-            # mode will not output trailing 0s.
-            assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='k'),
-                         "1.0000")
-
-            assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='.'),
-                         "1.")
-            assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='.'),
-                         "1.2" if tp != np.float16 else "1.2002")
-
-            assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='0'),
-                         "1.0")
-            assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='0'),
-                         "1.2" if tp != np.float16 else "1.2002")
-            assert_equal(fpos(tp('1.'), trim='0'), "1.0")
-
-            assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='-'),
-                         "1")
-            assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='-'),
-                         "1.2" if tp != np.float16 else "1.2002")
-            assert_equal(fpos(tp('1.'), trim='-'), "1")
-            assert_equal(fpos(tp('1.001'), precision=1, trim='-'), "1")
+        # test exp_digits
+        assert_equal(fsci(tp('1.23e1'), exp_digits=5), "1.23e+00001")
+
+        # test fixed (non-unique) mode
+        assert_equal(fsci(tp('1.0'), unique=False, precision=4),
+                        "1.0000e+00")
 
     @pytest.mark.skipif(not platform.machine().startswith("ppc64"),
                         reason="only applies to ppc float128 values")
diff --git a/numpy/_core/tests/test_stringdtype.py b/numpy/_core/tests/test_stringdtype.py
index ad4276f40a3e..29b52b27afe8 100644
--- a/numpy/_core/tests/test_stringdtype.py
+++ b/numpy/_core/tests/test_stringdtype.py
@@ -190,10 +190,14 @@ def test_array_creation_utf8(dtype, data):
     ],
 )
 def test_scalars_string_conversion(data, dtype):
+    try:
+        str_vals = [str(d.decode('utf-8')) for d in data]
+    except AttributeError:
+        str_vals = [str(d) for d in data]
     if dtype.coerce:
         assert_array_equal(
             np.array(data, dtype=dtype),
-            np.array([str(d) for d in data], dtype=dtype),
+            np.array(str_vals, dtype=dtype),
         )
     else:
         with pytest.raises(ValueError):
@@ -284,6 +288,14 @@ def test_bytes_casts(self, dtype, strings):
             barr = np.array(utf8_bytes, dtype=bytes_dtype)
             assert_array_equal(barr, sarr.astype(bytes_dtype))
             assert_array_equal(barr.astype(dtype), sarr)
+            if dtype.coerce:
+                barr = np.array(utf8_bytes, dtype=dtype)
+                assert_array_equal(barr, sarr)
+                barr = np.array(utf8_bytes, dtype="O")
+                assert_array_equal(barr.astype(dtype), sarr)
+            else:
+                with pytest.raises(ValueError):
+                    np.array(utf8_bytes, dtype=dtype)
         except UnicodeEncodeError:
             with pytest.raises(UnicodeEncodeError):
                 sarr.astype("S20")
diff --git a/numpy/_distributor_init.pyi b/numpy/_distributor_init.pyi
new file mode 100644
index 000000000000..94456aba2bcf
--- /dev/null
+++ b/numpy/_distributor_init.pyi
@@ -0,0 +1 @@
+# intentionally left blank
diff --git a/numpy/_expired_attrs_2_0.pyi b/numpy/_expired_attrs_2_0.pyi
new file mode 100644
index 000000000000..05c630c9b767
--- /dev/null
+++ b/numpy/_expired_attrs_2_0.pyi
@@ -0,0 +1,63 @@
+from typing import Final, TypedDict, final, type_check_only
+
+@final
+@type_check_only
+class _ExpiredAttributesType(TypedDict):
+    geterrobj: str
+    seterrobj: str
+    cast: str
+    source: str
+    lookfor: str
+    who: str
+    fastCopyAndTranspose: str
+    set_numeric_ops: str
+    NINF: str
+    PINF: str
+    NZERO: str
+    PZERO: str
+    add_newdoc: str
+    add_docstring: str
+    add_newdoc_ufunc: str
+    compat: str
+    safe_eval: str
+    float_: str
+    complex_: str
+    longfloat: str
+    singlecomplex: str
+    cfloat: str
+    longcomplex: str
+    clongfloat: str
+    string_: str
+    unicode_: str
+    Inf: str
+    Infinity: str
+    NaN: str
+    infty: str
+    issctype: str
+    maximum_sctype: str
+    obj2sctype: str
+    sctype2char: str
+    sctypes: str
+    issubsctype: str
+    set_string_function: str
+    asfarray: str
+    issubclass_: str
+    tracemalloc_domain: str
+    mat: str
+    recfromcsv: str
+    recfromtxt: str
+    deprecate: str
+    deprecate_with_doc: str
+    disp: str
+    find_common_type: str
+    round_: str
+    get_array_wrap: str
+    DataSource: str
+    nbytes: str
+    byte_bounds: str
+    compare_chararrays: str
+    format_parser: str
+    alltrue: str
+    sometrue: str
+
+__expired_attributes__: Final[_ExpiredAttributesType] = ...
diff --git a/numpy/_globals.pyi b/numpy/_globals.pyi
new file mode 100644
index 000000000000..c6b17d68d6b2
--- /dev/null
+++ b/numpy/_globals.pyi
@@ -0,0 +1,15 @@
+__all__ = ["_CopyMode", "_NoValue"]
+
+import enum
+from typing import Final, final
+
+@final
+class _CopyMode(enum.Enum):
+    ALWAYS = True
+    IF_NEEDED = False
+    NEVER = 2
+
+@final
+class _NoValueType: ...
+
+_NoValue: Final[_NoValueType] = ...
diff --git a/numpy/conftest.py b/numpy/conftest.py
index b37092296005..0eb42d1103e4 100644
--- a/numpy/conftest.py
+++ b/numpy/conftest.py
@@ -2,6 +2,7 @@
 Pytest configuration and fixtures for the Numpy test suite.
 """
 import os
+import string
 import sys
 import tempfile
 from contextlib import contextmanager
@@ -10,9 +11,11 @@
 import hypothesis
 import pytest
 import numpy
+import numpy as np
 
 from numpy._core._multiarray_tests import get_fpu_mode
-from numpy.testing._private.utils import NOGIL_BUILD
+from numpy._core.tests._natype import pd_NA
+from numpy.testing._private.utils import NOGIL_BUILD, get_stringdtype_dtype
 
 try:
     from scipy_doctest.conftest import dt_config
@@ -204,12 +207,12 @@ def warnings_errors_and_rng(test=None):
     dt_config.check_namespace['StringDType'] = numpy.dtypes.StringDType
 
     # temporary skips
-    dt_config.skiplist = set([
+    dt_config.skiplist = {
         'numpy.savez',    # unclosed file
         'numpy.matlib.savez',
         'numpy.__array_namespace_info__',
         'numpy.matlib.__array_namespace_info__',
-    ])
+    }
 
     # xfail problematic tutorials
     dt_config.pytest_extra_xfail = {
@@ -231,3 +234,28 @@ def warnings_errors_and_rng(test=None):
         'numpy/f2py/_backends/_distutils.py',
     ]
 
+
+@pytest.fixture
+def random_string_list():
+    chars = list(string.ascii_letters + string.digits)
+    chars = np.array(chars, dtype="U1")
+    ret = np.random.choice(chars, size=100 * 10, replace=True)
+    return ret.view("U100")
+
+
+@pytest.fixture(params=[True, False])
+def coerce(request):
+    return request.param
+
+
+@pytest.fixture(
+    params=["unset", None, pd_NA, np.nan, float("nan"), "__nan__"],
+    ids=["unset", "None", "pandas.NA", "np.nan", "float('nan')", "string nan"],
+)
+def na_object(request):
+    return request.param
+
+
+@pytest.fixture()
+def dtype(na_object, coerce):
+    return get_stringdtype_dtype(na_object, coerce)
diff --git a/numpy/lib/_arraysetops_impl.pyi b/numpy/lib/_arraysetops_impl.pyi
index 3261cdac8cf6..20f2d576bf00 100644
--- a/numpy/lib/_arraysetops_impl.pyi
+++ b/numpy/lib/_arraysetops_impl.pyi
@@ -10,35 +10,7 @@ from typing import (
 from typing_extensions import deprecated
 
 import numpy as np
-from numpy import (
-    generic,
-    number,
-    ushort,
-    ubyte,
-    uintc,
-    uint,
-    ulonglong,
-    short,
-    int8,
-    byte,
-    intc,
-    int_,
-    intp,
-    longlong,
-    half,
-    single,
-    double,
-    longdouble,
-    csingle,
-    cdouble,
-    clongdouble,
-    timedelta64,
-    datetime64,
-    object_,
-    str_,
-    bytes_,
-    void,
-)
+from numpy import generic, number, int8, intp, timedelta64, object_
 
 from numpy._typing import (
     ArrayLike,
@@ -75,33 +47,17 @@ _NumberType = TypeVar("_NumberType", bound=number[Any])
 # Only relevant if two or more arguments are parametrized, (e.g. `setdiff1d`)
 # which could result in, for example, `int64` and `float64`producing a
 # `number[_64Bit]` array
-_SCTNoCast = TypeVar(
-    "_SCTNoCast",
+_EitherSCT = TypeVar(
+    "_EitherSCT",
     np.bool,
-    ushort,
-    ubyte,
-    uintc,
-    uint,
-    ulonglong,
-    short,
-    byte,
-    intc,
-    int_,
-    longlong,
-    half,
-    single,
-    double,
-    longdouble,
-    csingle,
-    cdouble,
-    clongdouble,
-    timedelta64,
-    datetime64,
-    object_,
-    str_,
-    bytes_,
-    void,
-)
+    np.int8, np.int16, np.int32, np.int64, np.intp,
+    np.uint8, np.uint16, np.uint32, np.uint64, np.uintp,
+    np.float16, np.float32, np.float64, np.longdouble,
+    np.complex64, np.complex128, np.clongdouble,
+    np.timedelta64, np.datetime64,
+    np.bytes_, np.str_, np.void, np.object_,
+    np.integer, np.floating, np.complexfloating, np.character,
+)  # fmt: skip
 
 class UniqueAllResult(NamedTuple, Generic[_SCT]):
     values: NDArray[_SCT]
@@ -339,11 +295,11 @@ def unique_values(x: ArrayLike, /) -> NDArray[Any]: ...
 
 @overload
 def intersect1d(
-    ar1: _ArrayLike[_SCTNoCast],
-    ar2: _ArrayLike[_SCTNoCast],
+    ar1: _ArrayLike[_EitherSCT],
+    ar2: _ArrayLike[_EitherSCT],
     assume_unique: bool = ...,
     return_indices: L[False] = ...,
-) -> NDArray[_SCTNoCast]: ...
+) -> NDArray[_EitherSCT]: ...
 @overload
 def intersect1d(
     ar1: ArrayLike,
@@ -353,11 +309,11 @@ def intersect1d(
 ) -> NDArray[Any]: ...
 @overload
 def intersect1d(
-    ar1: _ArrayLike[_SCTNoCast],
-    ar2: _ArrayLike[_SCTNoCast],
+    ar1: _ArrayLike[_EitherSCT],
+    ar2: _ArrayLike[_EitherSCT],
     assume_unique: bool = ...,
     return_indices: L[True] = ...,
-) -> tuple[NDArray[_SCTNoCast], NDArray[intp], NDArray[intp]]: ...
+) -> tuple[NDArray[_EitherSCT], NDArray[intp], NDArray[intp]]: ...
 @overload
 def intersect1d(
     ar1: ArrayLike,
@@ -368,10 +324,10 @@ def intersect1d(
 
 @overload
 def setxor1d(
-    ar1: _ArrayLike[_SCTNoCast],
-    ar2: _ArrayLike[_SCTNoCast],
+    ar1: _ArrayLike[_EitherSCT],
+    ar2: _ArrayLike[_EitherSCT],
     assume_unique: bool = ...,
-) -> NDArray[_SCTNoCast]: ...
+) -> NDArray[_EitherSCT]: ...
 @overload
 def setxor1d(
     ar1: ArrayLike,
@@ -400,9 +356,9 @@ def in1d(
 
 @overload
 def union1d(
-    ar1: _ArrayLike[_SCTNoCast],
-    ar2: _ArrayLike[_SCTNoCast],
-) -> NDArray[_SCTNoCast]: ...
+    ar1: _ArrayLike[_EitherSCT],
+    ar2: _ArrayLike[_EitherSCT],
+) -> NDArray[_EitherSCT]: ...
 @overload
 def union1d(
     ar1: ArrayLike,
@@ -411,10 +367,10 @@ def union1d(
 
 @overload
 def setdiff1d(
-    ar1: _ArrayLike[_SCTNoCast],
-    ar2: _ArrayLike[_SCTNoCast],
+    ar1: _ArrayLike[_EitherSCT],
+    ar2: _ArrayLike[_EitherSCT],
     assume_unique: bool = ...,
-) -> NDArray[_SCTNoCast]: ...
+) -> NDArray[_EitherSCT]: ...
 @overload
 def setdiff1d(
     ar1: ArrayLike,
diff --git a/numpy/lib/_datasource.pyi b/numpy/lib/_datasource.pyi
new file mode 100644
index 000000000000..9f91fdf893a0
--- /dev/null
+++ b/numpy/lib/_datasource.pyi
@@ -0,0 +1,31 @@
+from pathlib import Path
+from typing import IO, Any, TypeAlias
+
+from _typeshed import OpenBinaryMode, OpenTextMode
+
+_Mode: TypeAlias = OpenBinaryMode | OpenTextMode
+
+###
+
+# exported in numpy.lib.nppyio
+class DataSource:
+    def __init__(self, /, destpath: Path | str | None = ...) -> None: ...
+    def __del__(self, /) -> None: ...
+    def abspath(self, /, path: str) -> str: ...
+    def exists(self, /, path: str) -> bool: ...
+
+    # Whether the file-object is opened in string or bytes mode (by default)
+    # depends on the file-extension of `path`
+    def open(self, /, path: str, mode: _Mode = "r", encoding: str | None = None, newline: str | None = None) -> IO[Any]: ...
+
+class Repository(DataSource):
+    def __init__(self, /, baseurl: str, destpath: str | None = ...) -> None: ...
+    def listdir(self, /) -> list[str]: ...
+
+def open(
+    path: str,
+    mode: _Mode = "r",
+    destpath: str | None = ...,
+    encoding: str | None = None,
+    newline: str | None = None,
+) -> IO[Any]: ...
diff --git a/numpy/lib/_iotools.pyi b/numpy/lib/_iotools.pyi
new file mode 100644
index 000000000000..c1591b1a0251
--- /dev/null
+++ b/numpy/lib/_iotools.pyi
@@ -0,0 +1,106 @@
+from collections.abc import Callable, Iterable, Sequence
+from typing import Any, ClassVar, Final, Literal, TypedDict, overload, type_check_only
+
+from typing_extensions import TypeVar, Unpack
+
+import numpy as np
+import numpy.typing as npt
+
+_T = TypeVar("_T")
+
+@type_check_only
+class _ValidationKwargs(TypedDict, total=False):
+    excludelist: Iterable[str] | None
+    deletechars: Iterable[str] | None
+    case_sensitive: Literal["upper", "lower"] | bool | None
+    replace_space: str
+
+###
+
+__docformat__: Final[str] = "restructuredtext en"
+
+class ConverterError(Exception): ...
+class ConverterLockError(ConverterError): ...
+class ConversionWarning(UserWarning): ...
+
+class LineSplitter:
+    delimiter: str | int | Iterable[int] | None
+    comments: str
+    encoding: str | None
+
+    def __init__(
+        self,
+        /,
+        delimiter: str | bytes | int | Iterable[int] | None = None,
+        comments: str | bytes = "#",
+        autostrip: bool = True,
+        encoding: str | None = None,
+    ) -> None: ...
+    def __call__(self, /, line: str | bytes) -> list[str]: ...
+    def autostrip(self, /, method: Callable[[_T], Iterable[str]]) -> Callable[[_T], list[str]]: ...
+
+class NameValidator:
+    defaultexcludelist: ClassVar[Sequence[str]]
+    defaultdeletechars: ClassVar[Sequence[str]]
+    excludelist: list[str]
+    deletechars: set[str]
+    case_converter: Callable[[str], str]
+    replace_space: str
+
+    def __init__(
+        self,
+        /,
+        excludelist: Iterable[str] | None = None,
+        deletechars: Iterable[str] | None = None,
+        case_sensitive: Literal["upper", "lower"] | bool | None = None,
+        replace_space: str = "_",
+    ) -> None: ...
+    def __call__(self, /, names: Iterable[str], defaultfmt: str = "f%i", nbfields: int | None = None) -> tuple[str, ...]: ...
+    def validate(self, /, names: Iterable[str], defaultfmt: str = "f%i", nbfields: int | None = None) -> tuple[str, ...]: ...
+
+class StringConverter:
+    func: Callable[[str], Any] | None
+    default: Any
+    missing_values: set[str]
+    type: np.dtype[np.datetime64] | np.generic
+
+    def __init__(
+        self,
+        /,
+        dtype_or_func: npt.DTypeLike | None = None,
+        default: None = None,
+        missing_values: Iterable[str] | None = None,
+        locked: bool = False,
+    ) -> None: ...
+    def update(
+        self,
+        /,
+        func: Callable[[str], Any],
+        default: object | None = None,
+        testing_value: str | None = None,
+        missing_values: str = "",
+        locked: bool = False,
+    ) -> None: ...
+    #
+    def __call__(self, /, value: str) -> Any: ...
+    def upgrade(self, /, value: str) -> Any: ...
+    def iterupgrade(self, /, value: Iterable[str] | str) -> None: ...
+
+    #
+    @classmethod
+    def upgrade_mapper(cls, func: Callable[[str], Any], default: object | None = None) -> None: ...
+
+@overload
+def str2bool(value: Literal["false", "False", "FALSE"]) -> Literal[False]: ...
+@overload
+def str2bool(value: Literal["true", "True", "TRUE"]) -> Literal[True]: ...
+
+#
+def has_nested_fields(ndtype: np.dtype[np.void]) -> bool: ...
+def flatten_dtype(ndtype: np.dtype[np.void], flatten_base: bool = False) -> type[np.dtype[Any]]: ...
+def easy_dtype(
+    ndtype: npt.DTypeLike,
+    names: Iterable[str] | None = None,
+    defaultfmt: str = "f%i",
+    **validationargs: Unpack[_ValidationKwargs],
+) -> np.dtype[np.void]: ...
diff --git a/numpy/lib/_npyio_impl.pyi b/numpy/lib/_npyio_impl.pyi
index 2ab86575601c..19257a802d44 100644
--- a/numpy/lib/_npyio_impl.pyi
+++ b/numpy/lib/_npyio_impl.pyi
@@ -1,359 +1,285 @@
-import zipfile
 import types
-from _typeshed import StrOrBytesPath, StrPath, SupportsRead, SupportsWrite, SupportsKeysAndGetItem
+import zipfile
+from collections.abc import Callable, Collection, Iterable, Iterator, Mapping, Sequence
 from re import Pattern
-from collections.abc import Collection, Mapping, Iterator, Sequence, Callable, Iterable
-from typing import (
-    Literal as L,
-    Any,
-    TypeVar,
-    Generic,
-    IO,
-    overload,
-    Protocol,
-    type_check_only,
-)
-from typing_extensions import deprecated
+from typing import IO, Any, ClassVar, Generic, Protocol, TypeAlias, overload, type_check_only
+from typing import Literal as L
 
-from numpy import (
-    recarray,
-    dtype,
-    generic,
-    float64,
-    void,
-    record,
-)
-from numpy.ma.mrecords import MaskedRecords
+from _typeshed import StrOrBytesPath, StrPath, SupportsKeysAndGetItem, SupportsRead, SupportsWrite
+from typing_extensions import Self, TypeVar, deprecated, override
+
+import numpy as np
 from numpy._core.multiarray import packbits, unpackbits
-from numpy._typing import (
-    ArrayLike,
-    DTypeLike,
-    NDArray,
-    _DTypeLike,
-    _SupportsArrayFunc,
-)
+from numpy._typing import ArrayLike, DTypeLike, NDArray, _DTypeLike, _SupportsArrayFunc
+from numpy.ma.mrecords import MaskedRecords
+
+from ._datasource import DataSource as DataSource
 
 __all__ = [
-    "savetxt",
-    "loadtxt",
+    "fromregex",
     "genfromtxt",
     "load",
+    "loadtxt",
+    "packbits",
     "save",
+    "savetxt",
     "savez",
     "savez_compressed",
-    "packbits",
     "unpackbits",
-    "fromregex",
 ]
 
-_T = TypeVar("_T")
-_T_contra = TypeVar("_T_contra", contravariant=True)
 _T_co = TypeVar("_T_co", covariant=True)
-_SCT = TypeVar("_SCT", bound=generic)
+_SCT = TypeVar("_SCT", bound=np.generic)
+_SCT_co = TypeVar("_SCT_co", bound=np.generic, default=Any, covariant=True)
+
+_FName: TypeAlias = StrPath | Iterable[str] | Iterable[bytes]
+_FNameRead: TypeAlias = StrPath | SupportsRead[str] | SupportsRead[bytes]
+_FNameWriteBytes: TypeAlias = StrPath | SupportsWrite[bytes]
+_FNameWrite: TypeAlias = _FNameWriteBytes | SupportsWrite[bytes]
 
 @type_check_only
 class _SupportsReadSeek(SupportsRead[_T_co], Protocol[_T_co]):
     def seek(self, offset: int, whence: int, /) -> object: ...
 
 class BagObj(Generic[_T_co]):
-    def __init__(self, obj: SupportsKeysAndGetItem[str, _T_co]) -> None: ...
-    def __getattribute__(self, key: str) -> _T_co: ...
+    def __init__(self, /, obj: SupportsKeysAndGetItem[str, _T_co]) -> None: ...
+    def __getattribute__(self, key: str, /) -> _T_co: ...
     def __dir__(self) -> list[str]: ...
 
-class NpzFile(Mapping[str, NDArray[Any]]):
+class NpzFile(Mapping[str, NDArray[_SCT_co]]):
+    _MAX_REPR_ARRAY_COUNT: ClassVar[int] = 5
+
     zip: zipfile.ZipFile
-    fid: None | IO[str]
+    fid: IO[str] | None
     files: list[str]
     allow_pickle: bool
-    pickle_kwargs: None | Mapping[str, Any]
-    _MAX_REPR_ARRAY_COUNT: int
-    # Represent `f` as a mutable property so we can access the type of `self`
-    @property
-    def f(self: _T) -> BagObj[_T]: ...
-    @f.setter
-    def f(self: _T, value: BagObj[_T]) -> None: ...
+    pickle_kwargs: Mapping[str, Any] | None
+    f: BagObj[NpzFile[_SCT_co]]
+
+    #
     def __init__(
         self,
-        fid: IO[str],
-        own_fid: bool = ...,
-        allow_pickle: bool = ...,
-        pickle_kwargs: None | Mapping[str, Any] = ...,
-    ) -> None: ...
-    def __enter__(self: _T) -> _T: ...
-    def __exit__(
-        self,
-        exc_type: None | type[BaseException],
-        exc_value: None | BaseException,
-        traceback: None | types.TracebackType,
         /,
+        fid: IO[Any],
+        own_fid: bool = False,
+        allow_pickle: bool = False,
+        pickle_kwargs: Mapping[str, object] | None = None,
+        *,
+        max_header_size: int = 10_000,
     ) -> None: ...
-    def close(self) -> None: ...
     def __del__(self) -> None: ...
-    def __iter__(self) -> Iterator[str]: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, cls: type[BaseException] | None, e: BaseException | None, tb: types.TracebackType | None, /) -> None: ...
+    @override
     def __len__(self) -> int: ...
-    def __getitem__(self, key: str) -> NDArray[Any]: ...
-    def __contains__(self, key: str) -> bool: ...
-    def __repr__(self) -> str: ...
-
-class DataSource:
-    def __init__(self, destpath: StrPath | None = ...) -> None: ...
-    def __del__(self) -> None: ...
-    def abspath(self, path: str) -> str: ...
-    def exists(self, path: str) -> bool: ...
-
-    # Whether the file-object is opened in string or bytes mode (by default)
-    # depends on the file-extension of `path`
-    def open(
-        self,
-        path: str,
-        mode: str = ...,
-        encoding: None | str = ...,
-        newline: None | str = ...,
-    ) -> IO[Any]: ...
+    @override
+    def __iter__(self) -> Iterator[str]: ...
+    @override
+    def __getitem__(self, key: str, /) -> NDArray[_SCT_co]: ...
+    def close(self) -> None: ...
 
 # NOTE: Returns a `NpzFile` if file is a zip file;
 # returns an `ndarray`/`memmap` otherwise
 def load(
     file: StrOrBytesPath | _SupportsReadSeek[bytes],
-    mmap_mode: L[None, "r+", "r", "w+", "c"] = ...,
-    allow_pickle: bool = ...,
-    fix_imports: bool = ...,
-    encoding: L["ASCII", "latin1", "bytes"] = ...,
+    mmap_mode: L["r+", "r", "w+", "c"] | None = None,
+    allow_pickle: bool = False,
+    fix_imports: bool = True,
+    encoding: L["ASCII", "latin1", "bytes"] = "ASCII",
+    *,
+    max_header_size: int = 10_000,
 ) -> Any: ...
 
 @overload
-def save(
-    file: StrPath | SupportsWrite[bytes],
-    arr: ArrayLike,
-    allow_pickle: bool = ...,
-) -> None: ...
+def save(file: _FNameWriteBytes, arr: ArrayLike, allow_pickle: bool = True) -> None: ...
 @overload
 @deprecated("The 'fix_imports' flag is deprecated in NumPy 2.1.")
-def save(
-    file: StrPath | SupportsWrite[bytes],
-    arr: ArrayLike,
-    allow_pickle: bool = ...,
-    *,
-    fix_imports: bool,
-) -> None: ...
+def save(file: _FNameWriteBytes, arr: ArrayLike, allow_pickle: bool, fix_imports: bool) -> None: ...
 @overload
 @deprecated("The 'fix_imports' flag is deprecated in NumPy 2.1.")
-def save(
-    file: StrPath | SupportsWrite[bytes],
-    arr: ArrayLike,
-    allow_pickle: bool,
-    fix_imports: bool,
-) -> None: ...
+def save(file: _FNameWriteBytes, arr: ArrayLike, allow_pickle: bool = True, *, fix_imports: bool) -> None: ...
 
-def savez(
-    file: StrPath | SupportsWrite[bytes],
-    *args: ArrayLike,
-    allow_pickle: bool = ...,
-    **kwds: ArrayLike,
-) -> None: ...
+#
+def savez(file: _FNameWriteBytes, *args: ArrayLike, allow_pickle: bool = True, **kwds: ArrayLike) -> None: ...
 
-def savez_compressed(
-    file: StrPath | SupportsWrite[bytes],
-    *args: ArrayLike,
-    allow_pickle: bool = ...,
-    **kwds: ArrayLike,
-) -> None: ...
+#
+def savez_compressed(file: _FNameWriteBytes, *args: ArrayLike, allow_pickle: bool = True, **kwds: ArrayLike) -> None: ...
 
 # File-like objects only have to implement `__iter__` and,
 # optionally, `encoding`
 @overload
 def loadtxt(
-    fname: StrPath | Iterable[str] | Iterable[bytes],
-    dtype: None = ...,
-    comments: None | str | Sequence[str] = ...,
-    delimiter: None | str = ...,
-    converters: None | Mapping[int | str, Callable[[str], Any]] | Callable[[str], Any] = ...,
-    skiprows: int = ...,
-    usecols: int | Sequence[int] | None = ...,
-    unpack: bool = ...,
-    ndmin: L[0, 1, 2] = ...,
-    encoding: None | str = ...,
-    max_rows: None | int = ...,
+    fname: _FName,
+    dtype: None = None,
+    comments: str | Sequence[str] | None = "#",
+    delimiter: str | None = None,
+    converters: Mapping[int | str, Callable[[str], Any]] | Callable[[str], Any] | None = None,
+    skiprows: int = 0,
+    usecols: int | Sequence[int] | None = None,
+    unpack: bool = False,
+    ndmin: L[0, 1, 2] = 0,
+    encoding: str | None = None,
+    max_rows: int | None = None,
     *,
-    quotechar: None | str = ...,
-    like: None | _SupportsArrayFunc = ...
-) -> NDArray[float64]: ...
+    quotechar: str | None = None,
+    like: _SupportsArrayFunc | None = None,
+) -> NDArray[np.float64]: ...
 @overload
 def loadtxt(
-    fname: StrPath | Iterable[str] | Iterable[bytes],
+    fname: _FName,
     dtype: _DTypeLike[_SCT],
-    comments: None | str | Sequence[str] = ...,
-    delimiter: None | str = ...,
-    converters: None | Mapping[int | str, Callable[[str], Any]] | Callable[[str], Any]  = ...,
-    skiprows: int = ...,
-    usecols: int | Sequence[int] | None = ...,
-    unpack: bool = ...,
-    ndmin: L[0, 1, 2] = ...,
-    encoding: None | str = ...,
-    max_rows: None | int = ...,
+    comments: str | Sequence[str] | None = "#",
+    delimiter: str | None = None,
+    converters: Mapping[int | str, Callable[[str], Any]] | Callable[[str], Any] | None = None,
+    skiprows: int = 0,
+    usecols: int | Sequence[int] | None = None,
+    unpack: bool = False,
+    ndmin: L[0, 1, 2] = 0,
+    encoding: str | None = None,
+    max_rows: int | None = None,
     *,
-    quotechar: None | str = ...,
-    like: None | _SupportsArrayFunc = ...
+    quotechar: str | None = None,
+    like: _SupportsArrayFunc | None = None,
 ) -> NDArray[_SCT]: ...
 @overload
 def loadtxt(
-    fname: StrPath | Iterable[str] | Iterable[bytes],
+    fname: _FName,
     dtype: DTypeLike,
-    comments: None | str | Sequence[str] = ...,
-    delimiter: None | str = ...,
-    converters: None | Mapping[int | str, Callable[[str], Any]] | Callable[[str], Any]  = ...,
-    skiprows: int = ...,
-    usecols: int | Sequence[int] | None = ...,
-    unpack: bool = ...,
-    ndmin: L[0, 1, 2] = ...,
-    encoding: None | str = ...,
-    max_rows: None | int = ...,
+    comments: str | Sequence[str] | None = "#",
+    delimiter: str | None = None,
+    converters: Mapping[int | str, Callable[[str], Any]] | Callable[[str], Any] | None = None,
+    skiprows: int = 0,
+    usecols: int | Sequence[int] | None = None,
+    unpack: bool = False,
+    ndmin: L[0, 1, 2] = 0,
+    encoding: str | None = None,
+    max_rows: int | None = None,
     *,
-    quotechar: None | str = ...,
-    like: None | _SupportsArrayFunc = ...
+    quotechar: str | None = None,
+    like: _SupportsArrayFunc | None = None,
 ) -> NDArray[Any]: ...
 
 def savetxt(
-    fname: StrPath | SupportsWrite[str] | SupportsWrite[bytes],
+    fname: StrPath | _FNameWrite,
     X: ArrayLike,
-    fmt: str | Sequence[str] = ...,
-    delimiter: str = ...,
-    newline: str = ...,
-    header: str = ...,
-    footer: str = ...,
-    comments: str = ...,
-    encoding: None | str = ...,
+    fmt: str | Sequence[str] = "%.18e",
+    delimiter: str = " ",
+    newline: str = "\n",
+    header: str = "",
+    footer: str = "",
+    comments: str = "# ",
+    encoding: str | None = None,
 ) -> None: ...
 
 @overload
 def fromregex(
-    file: StrPath | SupportsRead[str] | SupportsRead[bytes],
+    file: _FNameRead,
     regexp: str | bytes | Pattern[Any],
     dtype: _DTypeLike[_SCT],
-    encoding: None | str = ...
+    encoding: str | None = None,
 ) -> NDArray[_SCT]: ...
 @overload
 def fromregex(
-    file: StrPath | SupportsRead[str] | SupportsRead[bytes],
+    file: _FNameRead,
     regexp: str | bytes | Pattern[Any],
     dtype: DTypeLike,
-    encoding: None | str = ...
+    encoding: str | None = None,
 ) -> NDArray[Any]: ...
 
 @overload
 def genfromtxt(
-    fname: StrPath | Iterable[str] | Iterable[bytes],
-    dtype: None = ...,
+    fname: _FName,
+    dtype: None = None,
     comments: str = ...,
-    delimiter: None | str | int | Iterable[int] = ...,
+    delimiter: str | int | Iterable[int] | None = ...,
     skip_header: int = ...,
     skip_footer: int = ...,
-    converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
+    converters: Mapping[int | str, Callable[[str], Any]] | None = ...,
     missing_values: Any = ...,
     filling_values: Any = ...,
-    usecols: None | Sequence[int] = ...,
-    names: L[None, True] | str | Collection[str] = ...,
-    excludelist: None | Sequence[str] = ...,
+    usecols: Sequence[int] | None = ...,
+    names: L[True] | str | Collection[str] | None = ...,
+    excludelist: Sequence[str] | None = ...,
     deletechars: str = ...,
     replace_space: str = ...,
     autostrip: bool = ...,
-    case_sensitive: bool | L['upper', 'lower'] = ...,
+    case_sensitive: bool | L["upper", "lower"] = ...,
     defaultfmt: str = ...,
-    unpack: None | bool = ...,
+    unpack: bool | None = ...,
     usemask: bool = ...,
     loose: bool = ...,
     invalid_raise: bool = ...,
-    max_rows: None | int = ...,
+    max_rows: int | None = ...,
     encoding: str = ...,
     *,
     ndmin: L[0, 1, 2] = ...,
-    like: None | _SupportsArrayFunc = ...,
+    like: _SupportsArrayFunc | None = ...,
 ) -> NDArray[Any]: ...
 @overload
 def genfromtxt(
-    fname: StrPath | Iterable[str] | Iterable[bytes],
+    fname: _FName,
     dtype: _DTypeLike[_SCT],
     comments: str = ...,
-    delimiter: None | str | int | Iterable[int] = ...,
+    delimiter: str | int | Iterable[int] | None = ...,
     skip_header: int = ...,
     skip_footer: int = ...,
-    converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
+    converters: Mapping[int | str, Callable[[str], Any]] | None = ...,
     missing_values: Any = ...,
     filling_values: Any = ...,
-    usecols: None | Sequence[int] = ...,
-    names: L[None, True] | str | Collection[str] = ...,
-    excludelist: None | Sequence[str] = ...,
+    usecols: Sequence[int] | None = ...,
+    names: L[True] | str | Collection[str] | None = ...,
+    excludelist: Sequence[str] | None = ...,
     deletechars: str = ...,
     replace_space: str = ...,
     autostrip: bool = ...,
-    case_sensitive: bool | L['upper', 'lower'] = ...,
+    case_sensitive: bool | L["upper", "lower"] = ...,
     defaultfmt: str = ...,
-    unpack: None | bool = ...,
+    unpack: bool | None = ...,
     usemask: bool = ...,
     loose: bool = ...,
     invalid_raise: bool = ...,
-    max_rows: None | int = ...,
+    max_rows: int | None = ...,
     encoding: str = ...,
     *,
     ndmin: L[0, 1, 2] = ...,
-    like: None | _SupportsArrayFunc = ...,
+    like: _SupportsArrayFunc | None = ...,
 ) -> NDArray[_SCT]: ...
 @overload
 def genfromtxt(
-    fname: StrPath | Iterable[str] | Iterable[bytes],
+    fname: _FName,
     dtype: DTypeLike,
     comments: str = ...,
-    delimiter: None | str | int | Iterable[int] = ...,
+    delimiter: str | int | Iterable[int] | None = ...,
     skip_header: int = ...,
     skip_footer: int = ...,
-    converters: None | Mapping[int | str, Callable[[str], Any]] = ...,
+    converters: Mapping[int | str, Callable[[str], Any]] | None = ...,
     missing_values: Any = ...,
     filling_values: Any = ...,
-    usecols: None | Sequence[int] = ...,
-    names: L[None, True] | str | Collection[str] = ...,
-    excludelist: None | Sequence[str] = ...,
+    usecols: Sequence[int] | None = ...,
+    names: L[True] | str | Collection[str] | None = ...,
+    excludelist: Sequence[str] | None = ...,
     deletechars: str = ...,
     replace_space: str = ...,
     autostrip: bool = ...,
-    case_sensitive: bool | L['upper', 'lower'] = ...,
+    case_sensitive: bool | L["upper", "lower"] = ...,
     defaultfmt: str = ...,
-    unpack: None | bool = ...,
+    unpack: bool | None = ...,
     usemask: bool = ...,
     loose: bool = ...,
     invalid_raise: bool = ...,
-    max_rows: None | int = ...,
+    max_rows: int | None = ...,
     encoding: str = ...,
     *,
     ndmin: L[0, 1, 2] = ...,
-    like: None | _SupportsArrayFunc = ...,
+    like: _SupportsArrayFunc | None = ...,
 ) -> NDArray[Any]: ...
 
 @overload
-def recfromtxt(
-    fname: StrPath | Iterable[str] | Iterable[bytes],
-    *,
-    usemask: L[False] = ...,
-    **kwargs: Any,
-) -> recarray[Any, dtype[record]]: ...
+def recfromtxt(fname: _FName, *, usemask: L[False] = False, **kwargs: object) -> np.recarray[Any, np.dtype[np.record]]: ...
 @overload
-def recfromtxt(
-    fname: StrPath | Iterable[str] | Iterable[bytes],
-    *,
-    usemask: L[True],
-    **kwargs: Any,
-) -> MaskedRecords[Any, dtype[void]]: ...
+def recfromtxt(fname: _FName, *, usemask: L[True], **kwargs: object) -> MaskedRecords[Any, np.dtype[np.void]]: ...
 
 @overload
-def recfromcsv(
-    fname: StrPath | Iterable[str] | Iterable[bytes],
-    *,
-    usemask: L[False] = ...,
-    **kwargs: Any,
-) -> recarray[Any, dtype[record]]: ...
+def recfromcsv(fname: _FName, *, usemask: L[False] = False, **kwargs: object) -> np.recarray[Any, np.dtype[np.record]]: ...
 @overload
-def recfromcsv(
-    fname: StrPath | Iterable[str] | Iterable[bytes],
-    *,
-    usemask: L[True],
-    **kwargs: Any,
-) -> MaskedRecords[Any, dtype[void]]: ...
+def recfromcsv(fname: _FName, *, usemask: L[True], **kwargs: object) -> MaskedRecords[Any, np.dtype[np.void]]: ...
diff --git a/numpy/lib/_user_array_impl.pyi b/numpy/lib/_user_array_impl.pyi
new file mode 100644
index 000000000000..d5dfb0573c71
--- /dev/null
+++ b/numpy/lib/_user_array_impl.pyi
@@ -0,0 +1,220 @@
+from types import EllipsisType
+from typing import Any, Generic, SupportsIndex, TypeAlias, TypeVar, overload
+
+from _typeshed import Incomplete
+from typing_extensions import Self, deprecated, override
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import _ArrayLike, _ArrayLikeBool_co, _ArrayLikeInt_co, _DTypeLike
+
+###
+
+_ScalarT = TypeVar("_ScalarT", bound=np.generic)
+_ShapeT = TypeVar("_ShapeT", bound=tuple[int, ...])
+_ShapeT_co = TypeVar("_ShapeT_co", bound=tuple[int, ...], default=Any, covariant=True)
+_DTypeT = TypeVar("_DTypeT", bound=np.dtype[Any])
+_DTypeT_co = TypeVar("_DTypeT_co", bound=np.dtype[Any], default=np.dtype[Any], covariant=True)
+
+_BoolArrayT = TypeVar("_BoolArrayT", bound=container[Any, np.dtype[np.bool]])
+_IntegralArrayT = TypeVar("_IntegralArrayT", bound=container[Any, np.dtype[np.bool | np.integer | np.object_]])
+_RealContainerT = TypeVar(
+    "_RealContainerT",
+    bound=container[Any, np.dtype[np.bool | np.integer | np.floating | np.timedelta64 | np.object_]],
+)
+_NumericContainerT = TypeVar("_NumericContainerT", bound=container[Any, np.dtype[np.number | np.timedelta64 | np.object_]])
+
+_ArrayInt_co: TypeAlias = npt.NDArray[np.integer | np.bool]
+
+_ToIndexSlice: TypeAlias = slice | EllipsisType | _ArrayInt_co | None
+_ToIndexSlices: TypeAlias = _ToIndexSlice | tuple[_ToIndexSlice, ...]
+_ToIndex: TypeAlias = SupportsIndex | _ToIndexSlice
+_ToIndices: TypeAlias = _ToIndex | tuple[_ToIndex, ...]
+
+###
+
+class container(Generic[_ShapeT_co, _DTypeT_co]):
+    array: np.ndarray[_ShapeT_co, _DTypeT_co]
+
+    @overload
+    def __init__(
+        self,
+        /,
+        data: container[_ShapeT_co, _DTypeT_co] | np.ndarray[_ShapeT_co, _DTypeT_co],
+        dtype: None = None,
+        copy: bool = True,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: container[Any, np.dtype[_ScalarT]],
+        /,
+        data: _ArrayLike[_ScalarT],
+        dtype: None = None,
+        copy: bool = True,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: container[Any, np.dtype[_ScalarT]],
+        /,
+        data: npt.ArrayLike,
+        dtype: _DTypeLike[_ScalarT],
+        copy: bool = True,
+    ) -> None: ...
+    @overload
+    def __init__(self, /, data: npt.ArrayLike, dtype: npt.DTypeLike | None = None, copy: bool = True) -> None: ...
+
+    #
+    def __complex__(self, /) -> complex: ...
+    def __float__(self, /) -> float: ...
+    def __int__(self, /) -> int: ...
+    def __hex__(self, /) -> str: ...
+    def __oct__(self, /) -> str: ...
+
+    #
+    @override
+    def __eq__(self, other: object, /) -> container[_ShapeT_co, np.dtype[np.bool]]: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @override
+    def __ne__(self, other: object, /) -> container[_ShapeT_co, np.dtype[np.bool]]: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+
+    #
+    def __lt__(self, other: npt.ArrayLike, /) -> container[_ShapeT_co, np.dtype[np.bool]]: ...
+    def __le__(self, other: npt.ArrayLike, /) -> container[_ShapeT_co, np.dtype[np.bool]]: ...
+    def __gt__(self, other: npt.ArrayLike, /) -> container[_ShapeT_co, np.dtype[np.bool]]: ...
+    def __ge__(self, other: npt.ArrayLike, /) -> container[_ShapeT_co, np.dtype[np.bool]]: ...
+
+    #
+    def __len__(self, /) -> int: ...
+
+    # keep in sync with np.ndarray
+    @overload
+    def __getitem__(self, key: _ArrayInt_co | tuple[_ArrayInt_co, ...], /) -> container[_ShapeT_co, _DTypeT_co]: ...
+    @overload
+    def __getitem__(self, key: _ToIndexSlices, /) -> container[Any, _DTypeT_co]: ...
+    @overload
+    def __getitem__(self, key: _ToIndices, /) -> Any: ...
+    @overload
+    def __getitem__(self: container[Any, np.dtype[np.void]], key: list[str], /) -> container[_ShapeT_co, np.dtype[np.void]]: ...
+    @overload
+    def __getitem__(self: container[Any, np.dtype[np.void]], key: str, /) -> container[_ShapeT_co, np.dtype[Any]]: ...
+
+    # keep in sync with np.ndarray
+    @overload
+    def __setitem__(self, index: _ToIndices, value: object, /) -> None: ...
+    @overload
+    def __setitem__(self: container[Any, np.dtype[np.void]], key: str | list[str], value: object, /) -> None: ...
+
+    # keep in sync with np.ndarray
+    @overload
+    def __abs__(self: container[_ShapeT, np.dtype[np.complex64]], /) -> container[_ShapeT, np.dtype[np.float32]]: ...  # type: ignore[overload-overlap]
+    @overload
+    def __abs__(self: container[_ShapeT, np.dtype[np.complex128]], /) -> container[_ShapeT, np.dtype[np.float64]]: ...
+    @overload
+    def __abs__(self: container[_ShapeT, np.dtype[np.complex192]], /) -> container[_ShapeT, np.dtype[np.float96]]: ...
+    @overload
+    def __abs__(self: container[_ShapeT, np.dtype[np.complex256]], /) -> container[_ShapeT, np.dtype[np.float128]]: ...
+    @overload
+    def __abs__(self: _RealContainerT, /) -> _RealContainerT: ...
+
+    #
+    def __neg__(self: _NumericContainerT, /) -> _NumericContainerT: ...  # noqa: PYI019
+    def __pos__(self: _NumericContainerT, /) -> _NumericContainerT: ...  # noqa: PYI019
+    def __invert__(self: _IntegralArrayT, /) -> _IntegralArrayT: ...  # noqa: PYI019
+
+    # TODO(jorenham): complete these binary ops
+
+    #
+    def __add__(self, other: npt.ArrayLike, /) -> Incomplete: ...
+    def __radd__(self, other: npt.ArrayLike, /) -> Incomplete: ...
+    def __iadd__(self, other: npt.ArrayLike, /) -> Self: ...
+
+    #
+    def __sub__(self, other: npt.ArrayLike, /) -> Incomplete: ...
+    def __rsub__(self, other: npt.ArrayLike, /) -> Incomplete: ...
+    def __isub__(self, other: npt.ArrayLike, /) -> Self: ...
+
+    #
+    def __mul__(self, other: npt.ArrayLike, /) -> Incomplete: ...
+    def __rmul__(self, other: npt.ArrayLike, /) -> Incomplete: ...
+    def __imul__(self, other: npt.ArrayLike, /) -> Self: ...
+
+    #
+    def __div__(self, other: npt.ArrayLike, /) -> Incomplete: ...
+    def __rdiv__(self, other: npt.ArrayLike, /) -> Incomplete: ...
+    def __idiv__(self, other: npt.ArrayLike, /) -> Self: ...
+
+    #
+    def __mod__(self, other: npt.ArrayLike, /) -> Incomplete: ...
+    def __rmod__(self, other: npt.ArrayLike, /) -> Incomplete: ...
+    def __imod__(self, other: npt.ArrayLike, /) -> Self: ...
+
+    #
+    def __divmod__(self, other: npt.ArrayLike, /) -> tuple[Incomplete, Incomplete]: ...
+    def __rdivmod__(self, other: npt.ArrayLike, /) -> tuple[Incomplete, Incomplete]: ...
+
+    #
+    def __pow__(self, other: npt.ArrayLike, /) -> Incomplete: ...
+    def __rpow__(self, other: npt.ArrayLike, /) -> Incomplete: ...
+    def __ipow__(self, other: npt.ArrayLike, /) -> Self: ...
+
+    #
+    def __lshift__(self, other: _ArrayLikeInt_co, /) -> container[Any, np.dtype[np.integer]]: ...
+    def __rlshift__(self, other: _ArrayLikeInt_co, /) -> container[Any, np.dtype[np.integer]]: ...
+    def __ilshift__(self, other: _ArrayLikeInt_co, /) -> Self: ...
+
+    #
+    def __rshift__(self, other: _ArrayLikeInt_co, /) -> container[Any, np.dtype[np.integer]]: ...
+    def __rrshift__(self, other: _ArrayLikeInt_co, /) -> container[Any, np.dtype[np.integer]]: ...
+    def __irshift__(self, other: _ArrayLikeInt_co, /) -> Self: ...
+
+    #
+    @overload
+    def __and__(self: container[Any, np.dtype[np.bool]], other: _ArrayLikeBool_co, /) -> container[Any, np.dtype[np.bool]]: ...
+    @overload
+    def __and__(self, other: _ArrayLikeInt_co, /) -> container[Any, np.dtype[np.bool | np.integer]]: ...
+    __rand__ = __and__
+    @overload
+    def __iand__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ...
+    @overload
+    def __iand__(self, other: _ArrayLikeInt_co, /) -> Self: ...
+
+    #
+    @overload
+    def __xor__(self: container[Any, np.dtype[np.bool]], other: _ArrayLikeBool_co, /) -> container[Any, np.dtype[np.bool]]: ...
+    @overload
+    def __xor__(self, other: _ArrayLikeInt_co, /) -> container[Any, np.dtype[np.bool | np.integer]]: ...
+    __rxor__ = __xor__
+    @overload
+    def __ixor__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ...
+    @overload
+    def __ixor__(self, other: _ArrayLikeInt_co, /) -> Self: ...
+
+    #
+    @overload
+    def __or__(self: container[Any, np.dtype[np.bool]], other: _ArrayLikeBool_co, /) -> container[Any, np.dtype[np.bool]]: ...
+    @overload
+    def __or__(self, other: _ArrayLikeInt_co, /) -> container[Any, np.dtype[np.bool | np.integer]]: ...
+    __ror__ = __or__
+    @overload
+    def __ior__(self: _BoolArrayT, other: _ArrayLikeBool_co, /) -> _BoolArrayT: ...
+    @overload
+    def __ior__(self, other: _ArrayLikeInt_co, /) -> Self: ...
+
+    #
+    @overload
+    def __array__(self, /, t: None = None) -> np.ndarray[_ShapeT_co, _DTypeT_co]: ...
+    @overload
+    def __array__(self, /, t: _DTypeT) -> np.ndarray[_ShapeT_co, _DTypeT]: ...
+
+    #
+    @overload
+    def __array_wrap__(self, arg0: npt.ArrayLike, /) -> container[_ShapeT_co, _DTypeT_co]: ...
+    @overload
+    def __array_wrap__(self, a: np.ndarray[_ShapeT, _DTypeT], c: Any = ..., s: Any = ..., /) -> container[_ShapeT, _DTypeT]: ...
+
+    #
+    def copy(self, /) -> Self: ...
+    @deprecated("tostring() is deprecated. Use tobytes() instead.")
+    def tostring(self, /) -> bytes: ...
+    def tobytes(self, /) -> bytes: ...
+    def byteswap(self, /) -> Self: ...
+    def astype(self, /, typecode: _DTypeLike[_ScalarT]) -> container[_ShapeT_co, np.dtype[_ScalarT]]: ...
diff --git a/numpy/lib/introspect.pyi b/numpy/lib/introspect.pyi
new file mode 100644
index 000000000000..7929981cd636
--- /dev/null
+++ b/numpy/lib/introspect.pyi
@@ -0,0 +1,3 @@
+__all__ = ["opt_func_info"]
+
+def opt_func_info(func_name: str | None = None, signature: str | None = None) -> dict[str, dict[str, dict[str, str]]]: ...
diff --git a/numpy/lib/npyio.pyi b/numpy/lib/npyio.pyi
index c3258e88d04f..fd3ae8f5a287 100644
--- a/numpy/lib/npyio.pyi
+++ b/numpy/lib/npyio.pyi
@@ -1,4 +1,5 @@
 from numpy.lib._npyio_impl import (
     DataSource as DataSource,
     NpzFile as NpzFile,
+    __doc__ as __doc__,
 )
diff --git a/numpy/lib/recfunctions.pyi b/numpy/lib/recfunctions.pyi
new file mode 100644
index 000000000000..442530e9cd39
--- /dev/null
+++ b/numpy/lib/recfunctions.pyi
@@ -0,0 +1,435 @@
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from typing import Any, Literal, TypeAlias, overload
+
+from _typeshed import Incomplete
+from typing_extensions import TypeVar
+
+import numpy as np
+import numpy.typing as npt
+from numpy._typing import _DTypeLike, _DTypeLikeVoid
+from numpy.ma.mrecords import MaskedRecords
+
+__all__ = [
+    "append_fields",
+    "apply_along_fields",
+    "assign_fields_by_name",
+    "drop_fields",
+    "find_duplicates",
+    "flatten_descr",
+    "get_fieldstructure",
+    "get_names",
+    "get_names_flat",
+    "join_by",
+    "merge_arrays",
+    "rec_append_fields",
+    "rec_drop_fields",
+    "rec_join",
+    "recursive_fill_fields",
+    "rename_fields",
+    "repack_fields",
+    "require_fields",
+    "stack_arrays",
+    "structured_to_unstructured",
+    "unstructured_to_structured",
+]
+
+_T = TypeVar("_T")
+_ShapeT = TypeVar("_ShapeT", bound=tuple[int, ...])
+_ScalarT = TypeVar("_ScalarT", bound=np.generic)
+_DTypeT = TypeVar("_DTypeT", bound=np.dtype[Any])
+_ArrayT = TypeVar("_ArrayT", bound=npt.NDArray[Any])
+_VoidArrayT = TypeVar("_VoidArrayT", bound=npt.NDArray[np.void])
+_NonVoidDTypeT = TypeVar("_NonVoidDTypeT", bound=_NonVoidDType)
+
+_OneOrMany: TypeAlias = _T | Iterable[_T]
+_BuiltinSequence: TypeAlias = tuple[_T, ...] | list[_T]
+
+_NestedNames: TypeAlias = tuple[str | _NestedNames, ...]
+_NonVoid: TypeAlias = np.bool | np.number | np.character | np.datetime64 | np.timedelta64 | np.object_
+_NonVoidDType: TypeAlias = np.dtype[_NonVoid] | np.dtypes.StringDType
+
+_JoinType: TypeAlias = Literal["inner", "outer", "leftouter"]
+
+###
+
+def recursive_fill_fields(input: npt.NDArray[np.void], output: _VoidArrayT) -> _VoidArrayT: ...
+
+#
+def get_names(adtype: np.dtype[np.void]) -> _NestedNames: ...
+def get_names_flat(adtype: np.dtype[np.void]) -> tuple[str, ...]: ...
+
+#
+@overload
+def flatten_descr(ndtype: _NonVoidDTypeT) -> tuple[tuple[Literal[""], _NonVoidDTypeT]]: ...
+@overload
+def flatten_descr(ndtype: np.dtype[np.void]) -> tuple[tuple[str, np.dtype[Any]]]: ...
+
+#
+def get_fieldstructure(
+    adtype: np.dtype[np.void],
+    lastname: str | None = None,
+    parents: dict[str, list[str]] | None = None,
+) -> dict[str, list[str]]: ...
+
+#
+@overload
+def merge_arrays(
+    seqarrays: Sequence[np.ndarray[_ShapeT, np.dtype[Any]]] | np.ndarray[_ShapeT, np.dtype[Any]],
+    fill_value: float = -1,
+    flatten: bool = False,
+    usemask: bool = False,
+    asrecarray: bool = False,
+) -> np.recarray[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def merge_arrays(
+    seqarrays: Sequence[npt.ArrayLike] | np.void,
+    fill_value: float = -1,
+    flatten: bool = False,
+    usemask: bool = False,
+    asrecarray: bool = False,
+) -> np.recarray[Any, np.dtype[np.void]]: ...
+
+#
+@overload
+def drop_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    drop_names: str | Iterable[str],
+    usemask: bool = True,
+    asrecarray: Literal[False] = False,
+) -> np.ndarray[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def drop_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    drop_names: str | Iterable[str],
+    usemask: bool,
+    asrecarray: Literal[True],
+) -> np.recarray[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def drop_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    drop_names: str | Iterable[str],
+    usemask: bool = True,
+    *,
+    asrecarray: Literal[True],
+) -> np.recarray[_ShapeT, np.dtype[np.void]]: ...
+
+#
+@overload
+def rename_fields(
+    base: MaskedRecords[_ShapeT, np.dtype[np.void]],
+    namemapper: Mapping[str, str],
+) -> MaskedRecords[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def rename_fields(
+    base: np.ma.MaskedArray[_ShapeT, np.dtype[np.void]],
+    namemapper: Mapping[str, str],
+) -> np.ma.MaskedArray[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def rename_fields(
+    base: np.recarray[_ShapeT, np.dtype[np.void]],
+    namemapper: Mapping[str, str],
+) -> np.recarray[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def rename_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    namemapper: Mapping[str, str],
+) -> np.ndarray[_ShapeT, np.dtype[np.void]]: ...
+
+#
+@overload
+def append_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    names: _OneOrMany[str],
+    data: _OneOrMany[npt.NDArray[Any]],
+    dtypes: _BuiltinSequence[np.dtype[Any]] | None,
+    fill_value: int,
+    usemask: Literal[False],
+    asrecarray: Literal[False] = False,
+) -> np.ndarray[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def append_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    names: _OneOrMany[str],
+    data: _OneOrMany[npt.NDArray[Any]],
+    dtypes: _BuiltinSequence[np.dtype[Any]] | None = None,
+    fill_value: int = -1,
+    *,
+    usemask: Literal[False],
+    asrecarray: Literal[False] = False,
+) -> np.ndarray[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def append_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    names: _OneOrMany[str],
+    data: _OneOrMany[npt.NDArray[Any]],
+    dtypes: _BuiltinSequence[np.dtype[Any]] | None,
+    fill_value: int,
+    usemask: Literal[False],
+    asrecarray: Literal[True],
+) -> np.recarray[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def append_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    names: _OneOrMany[str],
+    data: _OneOrMany[npt.NDArray[Any]],
+    dtypes: _BuiltinSequence[np.dtype[Any]] | None = None,
+    fill_value: int = -1,
+    *,
+    usemask: Literal[False],
+    asrecarray: Literal[True],
+) -> np.recarray[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def append_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    names: _OneOrMany[str],
+    data: _OneOrMany[npt.NDArray[Any]],
+    dtypes: _BuiltinSequence[np.dtype[Any]] | None = None,
+    fill_value: int = -1,
+    usemask: Literal[True] = True,
+    asrecarray: Literal[False] = False,
+) -> np.ma.MaskedArray[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def append_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    names: _OneOrMany[str],
+    data: _OneOrMany[npt.NDArray[Any]],
+    dtypes: _BuiltinSequence[np.dtype[Any]] | None,
+    fill_value: int,
+    usemask: Literal[True],
+    asrecarray: Literal[True],
+) -> MaskedRecords[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def append_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    names: _OneOrMany[str],
+    data: _OneOrMany[npt.NDArray[Any]],
+    dtypes: _BuiltinSequence[np.dtype[Any]] | None = None,
+    fill_value: int = -1,
+    usemask: Literal[True] = True,
+    *,
+    asrecarray: Literal[True],
+) -> MaskedRecords[_ShapeT, np.dtype[np.void]]: ...
+
+#
+def rec_drop_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    drop_names: str | Iterable[str],
+) -> np.recarray[_ShapeT, np.dtype[np.void]]: ...
+
+#
+def rec_append_fields(
+    base: np.ndarray[_ShapeT, np.dtype[np.void]],
+    names: _OneOrMany[str],
+    data: _OneOrMany[npt.NDArray[Any]],
+    dtypes: _BuiltinSequence[np.dtype[Any]] | None = None,
+) -> np.ma.MaskedArray[_ShapeT, np.dtype[np.void]]: ...
+
+# TODO(jorenham): Stop passing `void` directly once structured dtypes are implemented,
+# e.g. using a `TypeVar` with constraints.
+# https://github.com/numpy/numtype/issues/92
+@overload
+def repack_fields(a: _DTypeT, align: bool = False, recurse: bool = False) -> _DTypeT: ...
+@overload
+def repack_fields(a: _ScalarT, align: bool = False, recurse: bool = False) -> _ScalarT: ...
+@overload
+def repack_fields(a: _ArrayT, align: bool = False, recurse: bool = False) -> _ArrayT: ...
+
+# TODO(jorenham): Attempt shape-typing (return type has ndim == arr.ndim + 1)
+@overload
+def structured_to_unstructured(
+    arr: npt.NDArray[np.void],
+    dtype: _DTypeLike[_ScalarT],
+    copy: bool = False,
+    casting: np._CastingKind = "unsafe",
+) -> npt.NDArray[_ScalarT]: ...
+@overload
+def structured_to_unstructured(
+    arr: npt.NDArray[np.void],
+    dtype: npt.DTypeLike | None = None,
+    copy: bool = False,
+    casting: np._CastingKind = "unsafe",
+) -> npt.NDArray[Any]: ...
+
+#
+@overload
+def unstructured_to_structured(
+    arr: npt.NDArray[Any],
+    dtype: npt.DTypeLike,
+    names: None = None,
+    align: bool = False,
+    copy: bool = False,
+    casting: str = "unsafe",
+) -> npt.NDArray[np.void]: ...
+@overload
+def unstructured_to_structured(
+    arr: npt.NDArray[Any],
+    dtype: None,
+    names: _OneOrMany[str],
+    align: bool = False,
+    copy: bool = False,
+    casting: str = "unsafe",
+) -> npt.NDArray[np.void]: ...
+
+#
+def apply_along_fields(
+    func: Callable[[np.ndarray[_ShapeT, Any]], npt.NDArray[Any]],
+    arr: np.ndarray[_ShapeT, np.dtype[np.void]],
+) -> np.ndarray[_ShapeT, np.dtype[np.void]]: ...
+
+#
+def assign_fields_by_name(dst: npt.NDArray[np.void], src: npt.NDArray[np.void], zero_unassigned: bool = True) -> None: ...
+
+#
+def require_fields(
+    array: np.ndarray[_ShapeT, np.dtype[np.void]],
+    required_dtype: _DTypeLikeVoid,
+) -> np.ndarray[_ShapeT, np.dtype[np.void]]: ...
+
+# TODO(jorenham): Attempt shape-typing
+@overload
+def stack_arrays(
+    arrays: _ArrayT,
+    defaults: Mapping[str, object] | None = None,
+    usemask: bool = True,
+    asrecarray: bool = False,
+    autoconvert: bool = False,
+) -> _ArrayT: ...
+@overload
+def stack_arrays(
+    arrays: Sequence[npt.NDArray[Any]],
+    defaults: Mapping[str, Incomplete] | None,
+    usemask: Literal[False],
+    asrecarray: Literal[False] = False,
+    autoconvert: bool = False,
+) -> npt.NDArray[np.void]: ...
+@overload
+def stack_arrays(
+    arrays: Sequence[npt.NDArray[Any]],
+    defaults: Mapping[str, Incomplete] | None = None,
+    *,
+    usemask: Literal[False],
+    asrecarray: Literal[False] = False,
+    autoconvert: bool = False,
+) -> npt.NDArray[np.void]: ...
+@overload
+def stack_arrays(
+    arrays: Sequence[npt.NDArray[Any]],
+    defaults: Mapping[str, Incomplete] | None = None,
+    *,
+    usemask: Literal[False],
+    asrecarray: Literal[True],
+    autoconvert: bool = False,
+) -> np.recarray[tuple[int, ...], np.dtype[np.void]]: ...
+@overload
+def stack_arrays(
+    arrays: Sequence[npt.NDArray[Any]],
+    defaults: Mapping[str, Incomplete] | None = None,
+    usemask: Literal[True] = True,
+    asrecarray: Literal[False] = False,
+    autoconvert: bool = False,
+) -> np.ma.MaskedArray[tuple[int, ...], np.dtype[np.void]]: ...
+@overload
+def stack_arrays(
+    arrays: Sequence[npt.NDArray[Any]],
+    defaults: Mapping[str, Incomplete] | None,
+    usemask: Literal[True],
+    asrecarray: Literal[True],
+    autoconvert: bool = False,
+) -> MaskedRecords[tuple[int, ...], np.dtype[np.void]]: ...
+@overload
+def stack_arrays(
+    arrays: Sequence[npt.NDArray[Any]],
+    defaults: Mapping[str, Incomplete] | None = None,
+    usemask: Literal[True] = True,
+    *,
+    asrecarray: Literal[True],
+    autoconvert: bool = False,
+) -> MaskedRecords[tuple[int, ...], np.dtype[np.void]]: ...
+
+#
+@overload
+def find_duplicates(
+    a: np.ma.MaskedArray[_ShapeT, np.dtype[np.void]],
+    key: str | None = None,
+    ignoremask: bool = True,
+    return_index: Literal[False] = False,
+) -> np.ma.MaskedArray[_ShapeT, np.dtype[np.void]]: ...
+@overload
+def find_duplicates(
+    a: np.ma.MaskedArray[_ShapeT, np.dtype[np.void]],
+    key: str | None,
+    ignoremask: bool,
+    return_index: Literal[True],
+) -> tuple[np.ma.MaskedArray[_ShapeT, np.dtype[np.void]], np.ndarray[_ShapeT, np.dtype[np.int_]]]: ...
+@overload
+def find_duplicates(
+    a: np.ma.MaskedArray[_ShapeT, np.dtype[np.void]],
+    key: str | None = None,
+    ignoremask: bool = True,
+    *,
+    return_index: Literal[True],
+) -> tuple[np.ma.MaskedArray[_ShapeT, np.dtype[np.void]], np.ndarray[_ShapeT, np.dtype[np.int_]]]: ...
+
+#
+@overload
+def join_by(
+    key: str | Sequence[str],
+    r1: npt.NDArray[np.void],
+    r2: npt.NDArray[np.void],
+    jointype: _JoinType = "inner",
+    r1postfix: str = "1",
+    r2postfix: str = "2",
+    defaults: Mapping[str, object] | None = None,
+    *,
+    usemask: Literal[False],
+    asrecarray: Literal[False] = False,
+) -> np.ndarray[tuple[int], np.dtype[np.void]]: ...
+@overload
+def join_by(
+    key: str | Sequence[str],
+    r1: npt.NDArray[np.void],
+    r2: npt.NDArray[np.void],
+    jointype: _JoinType = "inner",
+    r1postfix: str = "1",
+    r2postfix: str = "2",
+    defaults: Mapping[str, object] | None = None,
+    *,
+    usemask: Literal[False],
+    asrecarray: Literal[True],
+) -> np.recarray[tuple[int], np.dtype[np.void]]: ...
+@overload
+def join_by(
+    key: str | Sequence[str],
+    r1: npt.NDArray[np.void],
+    r2: npt.NDArray[np.void],
+    jointype: _JoinType = "inner",
+    r1postfix: str = "1",
+    r2postfix: str = "2",
+    defaults: Mapping[str, object] | None = None,
+    usemask: Literal[True] = True,
+    asrecarray: Literal[False] = False,
+) -> np.ma.MaskedArray[tuple[int], np.dtype[np.void]]: ...
+@overload
+def join_by(
+    key: str | Sequence[str],
+    r1: npt.NDArray[np.void],
+    r2: npt.NDArray[np.void],
+    jointype: _JoinType = "inner",
+    r1postfix: str = "1",
+    r2postfix: str = "2",
+    defaults: Mapping[str, object] | None = None,
+    usemask: Literal[True] = True,
+    *,
+    asrecarray: Literal[True],
+) -> MaskedRecords[tuple[int], np.dtype[np.void]]: ...
+
+#
+def rec_join(
+    key: str | Sequence[str],
+    r1: npt.NDArray[np.void],
+    r2: npt.NDArray[np.void],
+    jointype: _JoinType = "inner",
+    r1postfix: str = "1",
+    r2postfix: str = "2",
+    defaults: Mapping[str, object] | None = None,
+) -> np.recarray[tuple[int], np.dtype[np.void]]: ...
diff --git a/numpy/lib/user_array.pyi b/numpy/lib/user_array.pyi
new file mode 100644
index 000000000000..9b90d893326b
--- /dev/null
+++ b/numpy/lib/user_array.pyi
@@ -0,0 +1 @@
+from ._user_array_impl import container as container
diff --git a/numpy/matlib.pyi b/numpy/matlib.pyi
new file mode 100644
index 000000000000..67b753a87c32
--- /dev/null
+++ b/numpy/matlib.pyi
@@ -0,0 +1,578 @@
+from typing import Any, Literal, TypeAlias, TypeVar, overload
+
+import numpy as np
+import numpy.typing as npt
+
+# ruff: noqa: F401
+from numpy import (
+    False_,
+    ScalarType,
+    True_,
+    __array_namespace_info__,
+    __version__,
+    abs,
+    absolute,
+    acos,
+    acosh,
+    add,
+    all,
+    allclose,
+    amax,
+    amin,
+    angle,
+    any,
+    append,
+    apply_along_axis,
+    apply_over_axes,
+    arange,
+    arccos,
+    arccosh,
+    arcsin,
+    arcsinh,
+    arctan,
+    arctan2,
+    arctanh,
+    argmax,
+    argmin,
+    argpartition,
+    argsort,
+    argwhere,
+    around,
+    array,
+    array2string,
+    array_equal,
+    array_equiv,
+    array_repr,
+    array_split,
+    array_str,
+    asanyarray,
+    asarray,
+    asarray_chkfinite,
+    ascontiguousarray,
+    asfortranarray,
+    asin,
+    asinh,
+    asmatrix,
+    astype,
+    atan,
+    atan2,
+    atanh,
+    atleast_1d,
+    atleast_2d,
+    atleast_3d,
+    average,
+    bartlett,
+    base_repr,
+    binary_repr,
+    bincount,
+    bitwise_and,
+    bitwise_count,
+    bitwise_invert,
+    bitwise_left_shift,
+    bitwise_not,
+    bitwise_right_shift,
+    bitwise_xor,
+    blackman,
+    block,
+    bmat,
+    bool,
+    bool_,
+    broadcast,
+    broadcast_arrays,
+    broadcast_shapes,
+    broadcast_to,
+    busday_count,
+    busday_offset,
+    busdaycalendar,
+    byte,
+    bytes_,
+    c_,
+    can_cast,
+    cbrt,
+    ceil,
+    char,
+    character,
+    choose,
+    clip,
+    clongdouble,
+    column_stack,
+    common_type,
+    complex64,
+    complex128,
+    complex256,
+    complexfloating,
+    compress,
+    concat,
+    concatenate,
+    conj,
+    conjugate,
+    convolve,
+    copy,
+    copysign,
+    copyto,
+    core,
+    corrcoef,
+    correlate,
+    cos,
+    cosh,
+    count_nonzero,
+    cov,
+    cross,
+    csingle,
+    ctypeslib,
+    cumprod,
+    cumsum,
+    cumulative_prod,
+    cumulative_sum,
+    datetime64,
+    datetime_as_string,
+    datetime_data,
+    deg2rad,
+    degrees,
+    delete,
+    diag,
+    diag_indices,
+    diag_indices_from,
+    diagflat,
+    diagonal,
+    diff,
+    digitize,
+    divide,
+    divmod,
+    dot,
+    double,
+    dsplit,
+    dstack,
+    dtype,
+    dtypes,
+    e,
+    ediff1d,
+    einsum,
+    einsum_path,
+    emath,
+    empty_like,
+    equal,
+    errstate,
+    euler_gamma,
+    exceptions,
+    exp,
+    exp2,
+    expand_dims,
+    expm1,
+    extract,
+    fabs,
+    fft,
+    fill_diagonal,
+    finfo,
+    fix,
+    flatiter,
+    flatnonzero,
+    flexible,
+    flip,
+    fliplr,
+    flipud,
+    float16,
+    float32,
+    float64,
+    float128,
+    float_power,
+    floating,
+    floor,
+    floor_divide,
+    fmax,
+    fmin,
+    fmod,
+    format_float_positional,
+    format_float_scientific,
+    frexp,
+    from_dlpack,
+    frombuffer,
+    fromfile,
+    fromfunction,
+    fromiter,
+    frompyfunc,
+    fromregex,
+    fromstring,
+    full,
+    full_like,
+    gcd,
+    generic,
+    genfromtxt,
+    geomspace,
+    get_include,
+    get_printoptions,
+    getbufsize,
+    geterr,
+    geterrcall,
+    gradient,
+    greater,
+    greater_equal,
+    half,
+    hamming,
+    heaviside,
+    histogram,
+    histogram2d,
+    histogram_bin_edges,
+    histogramdd,
+    hsplit,
+    hstack,
+    hypot,
+    i0,
+    iinfo,
+    imag,
+    index_exp,
+    indices,
+    inexact,
+    inf,
+    info,
+    inner,
+    insert,
+    int8,
+    int16,
+    int32,
+    int64,
+    int_,
+    intc,
+    integer,
+    interp,
+    intersect1d,
+    intp,
+    invert,
+    is_busday,
+    isclose,
+    iscomplex,
+    iscomplexobj,
+    isdtype,
+    isfinite,
+    isfortran,
+    isin,
+    isinf,
+    isnan,
+    isnat,
+    isneginf,
+    isposinf,
+    isreal,
+    isrealobj,
+    isscalar,
+    issubdtype,
+    iterable,
+    ix_,
+    kaiser,
+    kron,
+    lcm,
+    ldexp,
+    left_shift,
+    less,
+    less_equal,
+    lexsort,
+    lib,
+    linalg,
+    linspace,
+    little_endian,
+    load,
+    loadtxt,
+    log,
+    log1p,
+    log2,
+    log10,
+    logaddexp,
+    logaddexp2,
+    logical_and,
+    logical_not,
+    logical_or,
+    logical_xor,
+    logspace,
+    long,
+    longdouble,
+    longlong,
+    ma,
+    mask_indices,
+    matmul,
+    matrix,
+    matrix_transpose,
+    matvec,
+    max,
+    maximum,
+    may_share_memory,
+    mean,
+    median,
+    memmap,
+    meshgrid,
+    mgrid,
+    min,
+    min_scalar_type,
+    minimum,
+    mintypecode,
+    mod,
+    modf,
+    moveaxis,
+    multiply,
+    nan,
+    nan_to_num,
+    nanargmax,
+    nanargmin,
+    nancumprod,
+    nancumsum,
+    nanmax,
+    nanmean,
+    nanmedian,
+    nanmin,
+    nanpercentile,
+    nanprod,
+    nanquantile,
+    nanstd,
+    nansum,
+    nanvar,
+    ndarray,
+    ndenumerate,
+    ndim,
+    ndindex,
+    nditer,
+    negative,
+    nested_iters,
+    newaxis,
+    nextafter,
+    nonzero,
+    not_equal,
+    number,
+    object_,
+    ogrid,
+    ones_like,
+    outer,
+    packbits,
+    pad,
+    partition,
+    percentile,
+    permute_dims,
+    pi,
+    piecewise,
+    place,
+    poly,
+    poly1d,
+    polyadd,
+    polyder,
+    polydiv,
+    polyfit,
+    polyint,
+    polymul,
+    polynomial,
+    polysub,
+    polyval,
+    positive,
+    pow,
+    power,
+    printoptions,
+    prod,
+    promote_types,
+    ptp,
+    put,
+    put_along_axis,
+    putmask,
+    quantile,
+    r_,
+    rad2deg,
+    radians,
+    random,
+    ravel,
+    ravel_multi_index,
+    real,
+    real_if_close,
+    rec,
+    recarray,
+    reciprocal,
+    record,
+    remainder,
+    repeat,
+    require,
+    reshape,
+    resize,
+    result_type,
+    right_shift,
+    rint,
+    roll,
+    rollaxis,
+    roots,
+    rot90,
+    round,
+    # row_stack,
+    s_,
+    save,
+    savetxt,
+    savez,
+    savez_compressed,
+    sctypeDict,
+    searchsorted,
+    select,
+    set_printoptions,
+    setbufsize,
+    setdiff1d,
+    seterr,
+    seterrcall,
+    setxor1d,
+    shape,
+    shares_memory,
+    short,
+    show_config,
+    show_runtime,
+    sign,
+    signbit,
+    signedinteger,
+    sin,
+    sinc,
+    single,
+    sinh,
+    size,
+    sort,
+    sort_complex,
+    spacing,
+    sqrt,
+    square,
+    squeeze,
+    std,
+    str_,
+    strings,
+    subtract,
+    sum,
+    swapaxes,
+    take,
+    take_along_axis,
+    tan,
+    tanh,
+    tensordot,
+    test,
+    testing,
+    tile,
+    timedelta64,
+    trace,
+    transpose,
+    trapezoid,
+    trapz,
+    tri,
+    tril,
+    tril_indices,
+    tril_indices_from,
+    trim_zeros,
+    triu,
+    triu_indices,
+    triu_indices_from,
+    true_divide,
+    trunc,
+    typecodes,
+    typename,
+    ubyte,
+    ufunc,
+    uint,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+    uintc,
+    uintp,
+    ulong,
+    ulonglong,
+    union1d,
+    unique,
+    unique_all,
+    unique_counts,
+    unique_inverse,
+    unique_values,
+    unpackbits,
+    unravel_index,
+    unsignedinteger,
+    unstack,
+    unwrap,
+    ushort,
+    vander,
+    var,
+    vdot,
+    vecdot,
+    vecmat,
+    vectorize,
+    void,
+    vsplit,
+    vstack,
+    where,
+    zeros_like,
+)
+from numpy._typing import _ArrayLike, _DTypeLike
+
+__all__ = ["rand", "randn", "repmat"]
+__all__ += np.__all__
+
+###
+
+_T = TypeVar("_T", bound=np.generic)
+_Matrix: TypeAlias = np.matrix[tuple[int, int], np.dtype[_T]]
+_Order: TypeAlias = Literal["C", "F"]
+
+###
+
+# ruff: noqa: F811
+
+#
+@overload
+def empty(shape: int | tuple[int, int], dtype: None = None, order: _Order = "C") -> _Matrix[np.float64]: ...
+@overload
+def empty(shape: int | tuple[int, int], dtype: _DTypeLike[_T], order: _Order = "C") -> _Matrix[_T]: ...
+@overload
+def empty(shape: int | tuple[int, int], dtype: npt.DTypeLike, order: _Order = "C") -> _Matrix[Any]: ...
+
+#
+@overload
+def ones(shape: int | tuple[int, int], dtype: None = None, order: _Order = "C") -> _Matrix[np.float64]: ...
+@overload
+def ones(shape: int | tuple[int, int], dtype: _DTypeLike[_T], order: _Order = "C") -> _Matrix[_T]: ...
+@overload
+def ones(shape: int | tuple[int, int], dtype: npt.DTypeLike, order: _Order = "C") -> _Matrix[Any]: ...
+
+#
+@overload
+def zeros(shape: int | tuple[int, int], dtype: None = None, order: _Order = "C") -> _Matrix[np.float64]: ...
+@overload
+def zeros(shape: int | tuple[int, int], dtype: _DTypeLike[_T], order: _Order = "C") -> _Matrix[_T]: ...
+@overload
+def zeros(shape: int | tuple[int, int], dtype: npt.DTypeLike, order: _Order = "C") -> _Matrix[Any]: ...
+
+#
+@overload
+def identity(n: int, dtype: None = None) -> _Matrix[np.float64]: ...
+@overload
+def identity(n: int, dtype: _DTypeLike[_T]) -> _Matrix[_T]: ...
+@overload
+def identity(n: int, dtype: npt.DTypeLike | None = None) -> _Matrix[Any]: ...
+
+#
+@overload
+def eye(
+    n: int,
+    M: int | None = None,
+    k: int = 0,
+    dtype: type[np.float64] | None = ...,
+    order: _Order = "C",
+) -> _Matrix[np.float64]: ...
+@overload
+def eye(n: int, M: int | None, k: int, dtype: _DTypeLike[_T], order: _Order = "C") -> _Matrix[_T]: ...
+@overload
+def eye(n: int, M: int | None = None, k: int = 0, *, dtype: _DTypeLike[_T], order: _Order = "C") -> _Matrix[_T]: ...
+@overload
+def eye(n: int, M: int | None = None, k: int = 0, dtype: npt.DTypeLike = ..., order: _Order = "C") -> _Matrix[Any]: ...
+
+#
+@overload
+def rand(arg: int | tuple[()] | tuple[int] | tuple[int, int], /) -> _Matrix[np.float64]: ...
+@overload
+def rand(arg: int, /, *args: int) -> _Matrix[np.float64]: ...
+
+#
+@overload
+def randn(arg: int | tuple[()] | tuple[int] | tuple[int, int], /) -> _Matrix[np.float64]: ...
+@overload
+def randn(arg: int, /, *args: int) -> _Matrix[np.float64]: ...
+
+#
+@overload
+def repmat(a: _Matrix[_T], m: int, n: int) -> _Matrix[_T]: ...
+@overload
+def repmat(a: _ArrayLike[_T], m: int, n: int) -> npt.NDArray[_T]: ...
+@overload
+def repmat(a: npt.ArrayLike, m: int, n: int) -> npt.NDArray[Any]: ...
diff --git a/numpy/meson.build b/numpy/meson.build
index 353f89398ca2..6fef05b9113f 100644
--- a/numpy/meson.build
+++ b/numpy/meson.build
@@ -276,11 +276,15 @@ python_sources = [
   '_array_api_info.py',
   '_array_api_info.pyi',
   '_configtool.py',
+  '_configtool.pyi',
   '_distributor_init.py',
+  '_distributor_init.pyi',
   '_globals.py',
+  '_globals.pyi',
   '_pytesttester.py',
   '_pytesttester.pyi',
   '_expired_attrs_2_0.py',
+  '_expired_attrs_2_0.pyi',
   'conftest.py',
   'ctypeslib.py',
   'ctypeslib.pyi',
@@ -289,6 +293,7 @@ python_sources = [
   'dtypes.py',
   'dtypes.pyi',
   'matlib.py',
+  'matlib.pyi',
   'py.typed',
   'version.pyi',
 ]
diff --git a/numpy/random/tests/test_generator_mt19937.py b/numpy/random/tests/test_generator_mt19937.py
index 514f9af2ce8c..c9dc81e96a37 100644
--- a/numpy/random/tests/test_generator_mt19937.py
+++ b/numpy/random/tests/test_generator_mt19937.py
@@ -1244,7 +1244,7 @@ def test_dirichlet_small_alpha(self):
     @pytest.mark.slow
     def test_dirichlet_moderately_small_alpha(self):
         # Use alpha.max() < 0.1 to trigger stick breaking code path
-        alpha = np.array([0.02, 0.04, 0.03])
+        alpha = np.array([0.02, 0.04])
         exact_mean = alpha / alpha.sum()
         random = Generator(MT19937(self.seed))
         sample = random.dirichlet(alpha, size=20000000)
diff --git a/numpy/testing/_private/__init__.pyi b/numpy/testing/_private/__init__.pyi
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/numpy/testing/_private/extbuild.pyi b/numpy/testing/_private/extbuild.pyi
new file mode 100644
index 000000000000..609a45e79d16
--- /dev/null
+++ b/numpy/testing/_private/extbuild.pyi
@@ -0,0 +1,25 @@
+import pathlib
+import types
+from collections.abc import Sequence
+
+__all__ = ["build_and_import_extension", "compile_extension_module"]
+
+def build_and_import_extension(
+    modname: str,
+    functions: Sequence[tuple[str, str, str]],
+    *,
+    prologue: str = "",
+    build_dir: pathlib.Path | None = None,
+    include_dirs: Sequence[str] = [],
+    more_init: str = "",
+) -> types.ModuleType: ...
+
+#
+def compile_extension_module(
+    name: str,
+    builddir: pathlib.Path,
+    include_dirs: Sequence[str],
+    source_string: str,
+    libraries: Sequence[str] = [],
+    library_dirs: Sequence[str] = [],
+) -> pathlib.Path: ...
diff --git a/numpy/testing/_private/utils.py b/numpy/testing/_private/utils.py
index 3c2d398e8a29..01fe6327713c 100644
--- a/numpy/testing/_private/utils.py
+++ b/numpy/testing/_private/utils.py
@@ -4,6 +4,7 @@
 """
 import os
 import sys
+import pathlib
 import platform
 import re
 import gc
@@ -19,6 +20,7 @@
 import sysconfig
 import concurrent.futures
 import threading
+import importlib.metadata
 
 import numpy as np
 from numpy._core import (
@@ -26,9 +28,11 @@
 from numpy import isfinite, isnan, isinf
 import numpy.linalg._umath_linalg
 from numpy._utils import _rename_parameter
+from numpy._core.tests._natype import pd_NA
 
 from io import StringIO
 
+
 __all__ = [
         'assert_equal', 'assert_almost_equal', 'assert_approx_equal',
         'assert_array_equal', 'assert_array_less', 'assert_string_equal',
@@ -42,7 +46,7 @@
         'HAS_REFCOUNT', "IS_WASM", 'suppress_warnings', 'assert_array_compare',
         'assert_no_gc_cycles', 'break_cycles', 'HAS_LAPACK64', 'IS_PYSTON',
         'IS_MUSL', 'check_support_sve', 'NOGIL_BUILD',
-        'IS_EDITABLE', 'run_threaded',
+        'IS_EDITABLE', 'IS_INSTALLED', 'NUMPY_ROOT', 'run_threaded',
         ]
 
 
@@ -54,10 +58,40 @@ class KnownFailureException(Exception):
 KnownFailureTest = KnownFailureException  # backwards compat
 verbose = 0
 
+NUMPY_ROOT = pathlib.Path(np.__file__).parent
+
+try:
+    np_dist = importlib.metadata.distribution('numpy')
+except importlib.metadata.PackageNotFoundError:
+    IS_INSTALLED = IS_EDITABLE = False
+else:
+    IS_INSTALLED = True
+    try:
+        if sys.version_info >= (3, 13):
+            IS_EDITABLE = np_dist.origin.dir_info.editable
+        else:
+            # Backport importlib.metadata.Distribution.origin
+            import json, types  # noqa: E401
+            origin = json.loads(
+                np_dist.read_text('direct_url.json') or '{}',
+                object_hook=lambda data: types.SimpleNamespace(**data),
+            )
+            IS_EDITABLE = origin.dir_info.editable
+    except AttributeError:
+        IS_EDITABLE = False
+
+    # spin installs numpy directly via meson, instead of using meson-python, and
+    # runs the module by setting PYTHONPATH. This is problematic because the
+    # resulting installation lacks the Python metadata (.dist-info), and numpy
+    # might already be installed on the environment, causing us to find its
+    # metadata, even though we are not actually loading that package.
+    # Work around this issue by checking if the numpy root matches.
+    if not IS_EDITABLE and np_dist.locate_file('numpy') != NUMPY_ROOT:
+        IS_INSTALLED = False
+
 IS_WASM = platform.machine() in ["wasm32", "wasm64"]
 IS_PYPY = sys.implementation.name == 'pypy'
 IS_PYSTON = hasattr(sys, "pyston_version_info")
-IS_EDITABLE = not bool(np.__path__) or 'editable' in np.__path__[0]
 HAS_REFCOUNT = getattr(sys, 'getrefcount', None) is not None and not IS_PYSTON
 HAS_LAPACK64 = numpy.linalg._umath_linalg._ilp64
 
@@ -101,14 +135,15 @@ def GetPerformanceAttributes(object, counter, instance=None,
         # thread's CPU usage is either 0 or 100).  To read counters like this,
         # you should copy this function, but keep the counter open, and call
         # CollectQueryData() each time you need to know.
-        # See http://msdn.microsoft.com/library/en-us/dnperfmo/html/perfmonpt2.asp (dead link)
+        # See http://msdn.microsoft.com/library/en-us/dnperfmo/html/perfmonpt2.asp
+        #(dead link)
         # My older explanation for this was that the "AddCounter" process
         # forced the CPU to 100%, but the above makes more sense :)
         import win32pdh
         if format is None:
             format = win32pdh.PDH_FMT_LONG
-        path = win32pdh.MakeCounterPath( (machine, object, instance, None,
-                                          inum, counter))
+        path = win32pdh.MakeCounterPath((machine, object, instance, None,
+                                         inum, counter))
         hq = win32pdh.OpenQuery()
         try:
             hc = win32pdh.AddCounter(hq, path)
@@ -166,7 +201,7 @@ def jiffies(_proc_pid_stat=f'/proc/{os.getpid()}/stat', _load_time=[]):
                 l = f.readline().split(' ')
             return int(l[13])
         except Exception:
-            return int(100*(time.time()-_load_time[0]))
+            return int(100 * (time.time() - _load_time[0]))
 else:
     # os.getpid is not in all platforms available.
     # Using time is safe but inaccurate, especially when process
@@ -182,7 +217,7 @@ def jiffies(_load_time=[]):
         import time
         if not _load_time:
             _load_time.append(time.time())
-        return int(100*(time.time()-_load_time[0]))
+        return int(100 * (time.time() - _load_time[0]))
 
 
 def build_err_msg(arrays, err_msg, header='Items are not equal:',
@@ -190,7 +225,7 @@ def build_err_msg(arrays, err_msg, header='Items are not equal:',
     msg = ['\n' + header]
     err_msg = str(err_msg)
     if err_msg:
-        if err_msg.find('\n') == -1 and len(err_msg) < 79-len(header):
+        if err_msg.find('\n') == -1 and len(err_msg) < 79 - len(header):
             msg = [msg[0] + ' ' + err_msg]
         else:
             msg.append(err_msg)
@@ -659,14 +694,14 @@ def assert_approx_equal(actual, desired, significant=7, err_msg='',
     # Normalized the numbers to be in range (-10.0,10.0)
     # scale = float(pow(10,math.floor(math.log10(0.5*(abs(desired)+abs(actual))))))
     with np.errstate(invalid='ignore'):
-        scale = 0.5*(np.abs(desired) + np.abs(actual))
+        scale = 0.5 * (np.abs(desired) + np.abs(actual))
         scale = np.power(10, np.floor(np.log10(scale)))
     try:
-        sc_desired = desired/scale
+        sc_desired = desired / scale
     except ZeroDivisionError:
         sc_desired = 0.0
     try:
-        sc_actual = actual/scale
+        sc_actual = actual / scale
     except ZeroDivisionError:
         sc_actual = 0.0
     msg = build_err_msg(
@@ -687,7 +722,7 @@ def assert_approx_equal(actual, desired, significant=7, err_msg='',
             return
     except (TypeError, NotImplementedError):
         pass
-    if np.abs(sc_desired - sc_actual) >= np.power(10., -(significant-1)):
+    if np.abs(sc_desired - sc_actual) >= np.power(10., -(significant - 1)):
         raise AssertionError(msg)
 
 
@@ -1379,10 +1414,10 @@ def check_support_sve(__cache=[]):
     """
     gh-22982
     """
-    
+
     if __cache:
         return __cache[0]
-    
+
     import subprocess
     cmd = 'lscpu'
     try:
@@ -1543,7 +1578,7 @@ def measure(code_str, times=1, label=None):
         i += 1
         exec(code, globs, locs)
     elapsed = jiffies() - elapsed
-    return 0.01*elapsed
+    return 0.01 * elapsed
 
 
 def _assert_valid_refcount(op):
@@ -1557,7 +1592,7 @@ def _assert_valid_refcount(op):
     import gc
     import numpy as np
 
-    b = np.arange(100*100).reshape(100, 100)
+    b = np.arange(100 * 100).reshape(100, 100)
     c = b
     i = 1
 
@@ -1735,7 +1770,7 @@ def assert_array_almost_equal_nulp(x, y, nulp=1):
     ax = np.abs(x)
     ay = np.abs(y)
     ref = nulp * np.spacing(np.where(ax > ay, ax, ay))
-    if not np.all(np.abs(x-y) <= ref):
+    if not np.all(np.abs(x - y) <= ref):
         if np.iscomplexobj(x) or np.iscomplexobj(y):
             msg = f"Arrays are not equal to {nulp} ULP"
         else:
@@ -1851,7 +1886,7 @@ def nulp_diff(x, y, dtype=None):
                          (x.shape, y.shape))
 
     def _diff(rx, ry, vdt):
-        diff = np.asarray(rx-ry, dtype=vdt)
+        diff = np.asarray(rx - ry, dtype=vdt)
         return np.abs(diff)
 
     rx = integer_repr(x)
@@ -2596,7 +2631,7 @@ def check_free_memory(free_bytes):
         except ValueError as exc:
             raise ValueError(f'Invalid environment variable {env_var}: {exc}')
 
-        msg = (f'{free_bytes/1e9} GB memory required, but environment variable '
+        msg = (f'{free_bytes / 1e9} GB memory required, but environment variable '
                f'NPY_AVAILABLE_MEM={env_value} set')
     else:
         mem_free = _get_mem_available()
@@ -2607,7 +2642,9 @@ def check_free_memory(free_bytes):
                    "the test.")
             mem_free = -1
         else:
-            msg = f'{free_bytes/1e9} GB memory required, but {mem_free/1e9} GB available'
+            free_bytes_gb = free_bytes / 1e9
+            mem_free_gb = mem_free / 1e9
+            msg = f'{free_bytes_gb} GB memory required, but {mem_free_gb} GB available'
 
     return msg if mem_free < free_bytes else None
 
@@ -2685,7 +2722,7 @@ def _get_glibc_version():
 _glibc_older_than = lambda x: (_glibcver != '0.0' and _glibcver < x)
 
 
-def run_threaded(func, iters=8, pass_count=False, max_workers=8,
+def run_threaded(func, max_workers=8, pass_count=False,
                  pass_barrier=False, outer_iterations=1,
                  prepare_args=None):
     """Runs a function many times in parallel"""
@@ -2697,15 +2734,26 @@ def run_threaded(func, iters=8, pass_count=False, max_workers=8,
             else:
                 args = prepare_args()
             if pass_barrier:
-                if max_workers != iters:
-                    raise RuntimeError(
-                        "Must set max_workers equal to the number of "
-                        "iterations to avoid deadlocks.")
                 barrier = threading.Barrier(max_workers)
                 args.append(barrier)
             if pass_count:
-                futures = [tpe.submit(func, i, *args) for i in range(iters)]
+                all_args = [(func, i, *args) for i in range(max_workers)]
             else:
-                futures = [tpe.submit(func, *args) for _ in range(iters)]
+                all_args = [(func, *args) for i in range(max_workers)]
+            try:
+                futures = []
+                for arg in all_args:
+                    futures.append(tpe.submit(*arg))
+            finally:
+                if len(futures) < max_workers and pass_barrier:
+                    barrier.abort()
             for f in futures:
                 f.result()
+
+
+def get_stringdtype_dtype(na_object, coerce=True):
+    # explicit is check for pd_NA because != with pd_NA returns pd_NA
+    if na_object is pd_NA or na_object != "unset":
+        return np.dtypes.StringDType(na_object=na_object, coerce=coerce)
+    else:
+        return np.dtypes.StringDType(coerce=coerce)
diff --git a/numpy/testing/overrides.pyi b/numpy/testing/overrides.pyi
new file mode 100644
index 000000000000..3fefc3f350da
--- /dev/null
+++ b/numpy/testing/overrides.pyi
@@ -0,0 +1,11 @@
+from collections.abc import Callable, Hashable
+from typing import Any
+
+from typing_extensions import TypeIs
+
+import numpy as np
+
+def get_overridable_numpy_ufuncs() -> set[np.ufunc]: ...
+def get_overridable_numpy_array_functions() -> set[Callable[..., Any]]: ...
+def allows_array_ufunc_override(func: object) -> TypeIs[np.ufunc]: ...
+def allows_array_function_override(func: Hashable) -> bool: ...
diff --git a/numpy/testing/print_coercion_tables.pyi b/numpy/testing/print_coercion_tables.pyi
new file mode 100644
index 000000000000..e6430304675e
--- /dev/null
+++ b/numpy/testing/print_coercion_tables.pyi
@@ -0,0 +1,27 @@
+from collections.abc import Iterable
+from typing import ClassVar, Generic
+
+from typing_extensions import Self, TypeVar
+
+import numpy as np
+
+_VT_co = TypeVar("_VT_co", default=object, covariant=True)
+
+# undocumented
+class GenericObject(Generic[_VT_co]):
+    dtype: ClassVar[np.dtype[np.object_]] = ...
+    v: _VT_co
+
+    def __init__(self, /, v: _VT_co) -> None: ...
+    def __add__(self, other: object, /) -> Self: ...
+    def __radd__(self, other: object, /) -> Self: ...
+
+def print_cancast_table(ntypes: Iterable[str]) -> None: ...
+def print_coercion_table(
+    ntypes: Iterable[str],
+    inputfirstvalue: int,
+    inputsecondvalue: int,
+    firstarray: bool,
+    use_promote_types: bool = False,
+) -> None: ...
+def print_new_cast_table(*, can_cast: bool = True, legacy: bool = False, flags: bool = False) -> None: ...
diff --git a/numpy/typing/tests/data/fail/arrayprint.pyi b/numpy/typing/tests/data/fail/arrayprint.pyi
index f8c8a3237816..486c11e79868 100644
--- a/numpy/typing/tests/data/fail/arrayprint.pyi
+++ b/numpy/typing/tests/data/fail/arrayprint.pyi
@@ -6,11 +6,11 @@ import numpy.typing as npt
 
 AR: npt.NDArray[np.float64]
 func1: Callable[[Any], str]
-func2: Callable[[np.integer[Any]], str]
+func2: Callable[[np.integer], str]
 
-np.array2string(AR, style=None)  # E: Unexpected keyword argument
-np.array2string(AR, legacy="1.14")  # E: incompatible type
-np.array2string(AR, sign="*")  # E: incompatible type
-np.array2string(AR, floatmode="default")  # E: incompatible type
-np.array2string(AR, formatter={"A": func1})  # E: incompatible type
-np.array2string(AR, formatter={"float": func2})  # E: Incompatible types
+np.array2string(AR, style=None)  # E: No overload variant
+np.array2string(AR, legacy="1.14")  # E: No overload variant
+np.array2string(AR, sign="*")  # E: No overload variant
+np.array2string(AR, floatmode="default")  # E: No overload variant
+np.array2string(AR, formatter={"A": func1})  # E: No overload variant
+np.array2string(AR, formatter={"float": func2})  # E: No overload variant
diff --git a/numpy/typing/tests/data/fail/scalars.pyi b/numpy/typing/tests/data/fail/scalars.pyi
index 5c6ccb177fbb..e847d8d6c45a 100644
--- a/numpy/typing/tests/data/fail/scalars.pyi
+++ b/numpy/typing/tests/data/fail/scalars.pyi
@@ -28,7 +28,6 @@ np.float32(3j)  # E: incompatible type
 np.float32([1.0, 0.0, 0.0])  # E: incompatible type
 np.complex64([])  # E: incompatible type
 
-np.complex64(1, 2)  # E: Too many arguments
 # TODO: protocols (can't check for non-existent protocols w/ __getattr__)
 
 np.datetime64(0)  # E: No overload variant
@@ -60,7 +59,7 @@ np.flexible(b"test")  # E: Cannot instantiate abstract class
 np.float64(value=0.0)  # E: Unexpected keyword argument
 np.int64(value=0)  # E: Unexpected keyword argument
 np.uint64(value=0)  # E: Unexpected keyword argument
-np.complex128(value=0.0j)  # E: Unexpected keyword argument
+np.complex128(value=0.0j)  # E: No overload variant
 np.str_(value='bob')  # E: No overload variant
 np.bytes_(value=b'test')  # E: No overload variant
 np.void(value=b'test')  # E: No overload variant
diff --git a/numpy/typing/tests/data/pass/lib_user_array.py b/numpy/typing/tests/data/pass/lib_user_array.py
new file mode 100644
index 000000000000..62b7e85d7ff1
--- /dev/null
+++ b/numpy/typing/tests/data/pass/lib_user_array.py
@@ -0,0 +1,22 @@
+"""Based on the `if __name__ == "__main__"` test code in `lib/_user_array_impl.py`."""
+
+from __future__ import annotations
+
+import numpy as np
+from numpy.lib.user_array import container
+
+N = 10_000
+W = H = int(N**0.5)
+
+a: np.ndarray[tuple[int, int], np.dtype[np.int32]]
+ua: container[tuple[int, int], np.dtype[np.int32]]
+
+a = np.arange(N, dtype=np.int32).reshape(W, H)
+ua = container(a)
+
+ua_small: container[tuple[int, int], np.dtype[np.int32]] = ua[:3, :5]
+ua_small[0, 0] = 10
+
+ua_bool: container[tuple[int, int], np.dtype[np.bool]] = ua_small > 1
+
+# shape: tuple[int, int] = np.shape(ua)
diff --git a/numpy/typing/tests/data/pass/recfunctions.py b/numpy/typing/tests/data/pass/recfunctions.py
new file mode 100644
index 000000000000..03322e064be4
--- /dev/null
+++ b/numpy/typing/tests/data/pass/recfunctions.py
@@ -0,0 +1,162 @@
+"""These tests are based on the doctests from `numpy/lib/recfunctions.py`."""
+
+from typing import Any
+from typing_extensions import assert_type
+
+import numpy as np
+import numpy.typing as npt
+from numpy.lib import recfunctions as rfn
+
+
+def test_recursive_fill_fields() -> None:
+    a: npt.NDArray[np.void] = np.array(
+        [(1, 10.0), (2, 20.0)],
+        dtype=[("A", np.int64), ("B", np.float64)],
+    )
+    b = np.zeros((int(3),), dtype=a.dtype)
+    out = rfn.recursive_fill_fields(a, b)
+    assert_type(out, np.ndarray[tuple[int], np.dtype[np.void]])
+
+
+def test_get_names() -> None:
+    names: tuple[str | Any, ...]
+    names = rfn.get_names(np.empty((1,), dtype=[("A", int)]).dtype)
+    names = rfn.get_names(np.empty((1,), dtype=[("A", int), ("B", float)]).dtype)
+
+    adtype = np.dtype([("a", int), ("b", [("b_a", int), ("b_b", int)])])
+    names = rfn.get_names(adtype)
+
+
+def test_get_names_flat() -> None:
+    names: tuple[str, ...]
+    names = rfn.get_names_flat(np.empty((1,), dtype=[("A", int)]).dtype)
+    names = rfn.get_names_flat(np.empty((1,), dtype=[("A", int), ("B", float)]).dtype)
+
+    adtype = np.dtype([("a", int), ("b", [("b_a", int), ("b_b", int)])])
+    names = rfn.get_names_flat(adtype)
+
+
+def test_flatten_descr() -> None:
+    ndtype = np.dtype([("a", "<i4"), ("b", [("b_a", "<f8"), ("b_b", "<i4")])])
+    assert_type(rfn.flatten_descr(ndtype), tuple[tuple[str, np.dtype[Any]]])
+
+
+def test_get_fieldstructure() -> None:
+    ndtype = np.dtype([
+        ("A", int),
+        ("B", [("B_A", int), ("B_B", [("B_B_A", int), ("B_B_B", int)])]),
+    ])
+    assert_type(rfn.get_fieldstructure(ndtype), dict[str, list[str]])
+
+
+def test_merge_arrays() -> None:
+    assert_type(
+        rfn.merge_arrays((
+            np.ones((int(2),), np.int_),
+            np.ones((int(3),), np.float64),
+        )),
+        np.recarray[tuple[int], np.dtype[np.void]],
+    )
+
+
+def test_drop_fields() -> None:
+    ndtype = [("a", np.int64), ("b", [("b_a", np.double), ("b_b", np.int64)])]
+    a = np.ones((int(3),), dtype=ndtype)
+
+    assert_type(
+        rfn.drop_fields(a, "a"),
+        np.ndarray[tuple[int], np.dtype[np.void]],
+    )
+    assert_type(
+        rfn.drop_fields(a, "a", asrecarray=True),
+        np.rec.recarray[tuple[int], np.dtype[np.void]],
+    )
+    assert_type(
+        rfn.rec_drop_fields(a, "a"),
+        np.rec.recarray[tuple[int], np.dtype[np.void]],
+    )
+
+
+def test_rename_fields() -> None:
+    ndtype = [("a", np.int64), ("b", [("b_a", np.double), ("b_b", np.int64)])]
+    a = np.ones((int(3),), dtype=ndtype)
+
+    assert_type(
+        rfn.rename_fields(a, {"a": "A", "b_b": "B_B"}),
+        np.ndarray[tuple[int], np.dtype[np.void]],
+    )
+
+
+def test_repack_fields() -> None:
+    dt: np.dtype[np.void] = np.dtype("u1, <i8, <f8", align=True)
+
+    assert_type(rfn.repack_fields(dt), np.dtype[np.void])
+    assert_type(rfn.repack_fields(dt.type(0)), np.void)
+    assert_type(
+        rfn.repack_fields(np.ones((int(3),), dtype=dt)),
+        np.ndarray[tuple[int], np.dtype[np.void]],
+    )
+
+
+def test_structured_to_unstructured() -> None:
+    a = np.zeros(4, dtype=[("a", "i4"), ("b", "f4,u2"), ("c", "f4", 2)])
+    assert_type(rfn.structured_to_unstructured(a), npt.NDArray[Any])
+
+
+def unstructured_to_structured() -> None:
+    dt: np.dtype[np.void] = np.dtype([("a", "i4"), ("b", "f4,u2"), ("c", "f4", 2)])
+    a = np.arange(20, dtype=np.int32).reshape((4, 5))
+    assert_type(rfn.unstructured_to_structured(a, dt), npt.NDArray[np.void])
+
+
+def test_apply_along_fields() -> None:
+    b = np.ones(4, dtype=[("x", "i4"), ("y", "f4"), ("z", "f8")])
+    assert_type(
+        rfn.apply_along_fields(np.mean, b),
+        np.ndarray[tuple[int], np.dtype[np.void]],
+    )
+
+
+def test_assign_fields_by_name() -> None:
+    b = np.ones(4, dtype=[("x", "i4"), ("y", "f4"), ("z", "f8")])
+    assert_type(
+        rfn.apply_along_fields(np.mean, b),
+        np.ndarray[tuple[int], np.dtype[np.void]],
+    )
+
+
+def test_require_fields() -> None:
+    a = np.ones(4, dtype=[("a", "i4"), ("b", "f8"), ("c", "u1")])
+    assert_type(
+        rfn.require_fields(a, [("b", "f4"), ("c", "u1")]),
+        np.ndarray[tuple[int], np.dtype[np.void]],
+    )
+
+
+def test_stack_arrays() -> None:
+    x = np.zeros((int(2),), np.int32)
+    assert_type(
+        rfn.stack_arrays(x),
+        np.ndarray[tuple[int], np.dtype[np.int32]],
+    )
+
+    z = np.ones((int(2),), [("A", "|S3"), ("B", float)])
+    zz = np.ones((int(2),), [("A", "|S3"), ("B", np.float64), ("C", np.float64)])
+    assert_type(
+        rfn.stack_arrays((z, zz)),
+        np.ma.MaskedArray[tuple[int, ...], np.dtype[np.void]],
+    )
+
+
+def test_find_duplicates() -> None:
+    ndtype = np.dtype([("a", int)])
+
+    a = np.ma.ones(7, mask=[0, 0, 1, 0, 0, 0, 1]).view(ndtype)
+    assert_type(rfn.find_duplicates(a), np.ma.MaskedArray[Any, np.dtype[np.void]])
+    assert_type(
+        rfn.find_duplicates(a, ignoremask=True, return_index=True),
+        tuple[
+            np.ma.MaskedArray[Any, np.dtype[np.void]],
+            np.ndarray[Any, np.dtype[np.int_]],
+        ],
+    )
diff --git a/numpy/typing/tests/data/reveal/arraysetops.pyi b/numpy/typing/tests/data/reveal/arraysetops.pyi
index 33793f8deebc..eabc7677cde9 100644
--- a/numpy/typing/tests/data/reveal/arraysetops.pyi
+++ b/numpy/typing/tests/data/reveal/arraysetops.pyi
@@ -2,10 +2,7 @@ from typing import Any
 
 import numpy as np
 import numpy.typing as npt
-from numpy.lib._arraysetops_impl import (
-    UniqueAllResult, UniqueCountsResult, UniqueInverseResult
-)
-from numpy._typing import _64Bit
+from numpy.lib._arraysetops_impl import UniqueAllResult, UniqueCountsResult, UniqueInverseResult
 
 from typing_extensions import assert_type
 
@@ -28,7 +25,7 @@ assert_type(np.intersect1d(AR_M, AR_M, assume_unique=True), npt.NDArray[np.datet
 assert_type(np.intersect1d(AR_f8, AR_i8), npt.NDArray[Any])
 assert_type(
     np.intersect1d(AR_f8, AR_f8, return_indices=True),
-    tuple[npt.NDArray[np.floating[_64Bit]], npt.NDArray[np.intp], npt.NDArray[np.intp]],
+    tuple[npt.NDArray[np.float64], npt.NDArray[np.intp], npt.NDArray[np.intp]],
 )
 
 assert_type(np.setxor1d(AR_i8, AR_i8), npt.NDArray[np.int64])
diff --git a/numpy/typing/tests/data/reveal/mod.pyi b/numpy/typing/tests/data/reveal/mod.pyi
index bd7a632b0a24..db79504fdd1f 100644
--- a/numpy/typing/tests/data/reveal/mod.pyi
+++ b/numpy/typing/tests/data/reveal/mod.pyi
@@ -1,39 +1,71 @@
 import datetime as dt
-from typing import Any
+from typing import Literal as L
+
+from typing_extensions import assert_type
 
 import numpy as np
 import numpy.typing as npt
-from numpy._typing import _32Bit, _64Bit
+from numpy._typing import _64Bit
 
-from typing_extensions import assert_type
+f8: np.float64
+i8: np.int64
+u8: np.uint64
 
-f8 = np.float64()
-i8 = np.int64()
-u8 = np.uint64()
+f4: np.float32
+i4: np.int32
+u4: np.uint32
 
-f4 = np.float32()
-i4 = np.int32()
-u4 = np.uint32()
+m: np.timedelta64
+m_nat: np.timedelta64[None]
+m_int0: np.timedelta64[L[0]]
+m_int: np.timedelta64[int]
+m_td: np.timedelta64[dt.timedelta]
 
-td = np.timedelta64(0, "D")
-b_ = np.bool()
+b_: np.bool
 
-b = bool()
-f = float()
-i = int()
+b: bool
+i: int
+f: float
 
 AR_b: npt.NDArray[np.bool]
 AR_m: npt.NDArray[np.timedelta64]
 
 # Time structures
 
-assert_type(td % td, np.timedelta64[dt.timedelta])
-assert_type(AR_m % td, npt.NDArray[np.timedelta64])
-assert_type(td % AR_m, npt.NDArray[np.timedelta64])
-
-assert_type(divmod(td, td), tuple[np.int64, np.timedelta64])
-assert_type(divmod(AR_m, td), tuple[npt.NDArray[np.int64], npt.NDArray[np.timedelta64]])
-assert_type(divmod(td, AR_m), tuple[npt.NDArray[np.int64], npt.NDArray[np.timedelta64]])
+assert_type(m % m, np.timedelta64)
+assert_type(m % m_nat, np.timedelta64[None])
+assert_type(m % m_int0, np.timedelta64[None])
+assert_type(m % m_int, np.timedelta64[int | None])
+assert_type(m_nat % m, np.timedelta64[None])
+assert_type(m_int % m_nat, np.timedelta64[None])
+assert_type(m_int % m_int0, np.timedelta64[None])
+assert_type(m_int % m_int, np.timedelta64[int | None])
+assert_type(m_int % m_td, np.timedelta64[int | None])
+assert_type(m_td % m_nat, np.timedelta64[None])
+assert_type(m_td % m_int0, np.timedelta64[None])
+assert_type(m_td % m_int, np.timedelta64[int | None])
+assert_type(m_td % m_td, np.timedelta64[dt.timedelta | None])
+
+assert_type(AR_m % m, npt.NDArray[np.timedelta64])
+assert_type(m % AR_m, npt.NDArray[np.timedelta64])
+
+assert_type(divmod(m, m), tuple[np.int64, np.timedelta64])
+assert_type(divmod(m, m_nat), tuple[np.int64, np.timedelta64[None]])
+assert_type(divmod(m, m_int0), tuple[np.int64, np.timedelta64[None]])
+# workarounds for https://github.com/microsoft/pyright/issues/9663
+assert_type(m.__divmod__(m_int), tuple[np.int64, np.timedelta64[int | None]])
+assert_type(divmod(m_nat, m), tuple[np.int64, np.timedelta64[None]])
+assert_type(divmod(m_int, m_nat), tuple[np.int64, np.timedelta64[None]])
+assert_type(divmod(m_int, m_int0), tuple[np.int64, np.timedelta64[None]])
+assert_type(divmod(m_int, m_int), tuple[np.int64, np.timedelta64[int | None]])
+assert_type(divmod(m_int, m_td), tuple[np.int64, np.timedelta64[int | None]])
+assert_type(divmod(m_td, m_nat), tuple[np.int64, np.timedelta64[None]])
+assert_type(divmod(m_td, m_int0), tuple[np.int64, np.timedelta64[None]])
+assert_type(divmod(m_td, m_int), tuple[np.int64, np.timedelta64[int | None]])
+assert_type(divmod(m_td, m_td), tuple[np.int64, np.timedelta64[dt.timedelta | None]])
+
+assert_type(divmod(AR_m, m), tuple[npt.NDArray[np.int64], npt.NDArray[np.timedelta64]])
+assert_type(divmod(m, AR_m), tuple[npt.NDArray[np.int64], npt.NDArray[np.timedelta64]])
 
 # Bool
 
@@ -47,11 +79,12 @@ assert_type(b_ % f8, np.float64)
 assert_type(b_ % AR_b, npt.NDArray[np.int8])
 
 assert_type(divmod(b_, b), tuple[np.int8, np.int8])
-assert_type(divmod(b_, i), tuple[np.int_, np.int_])
-assert_type(divmod(b_, f), tuple[np.float64, np.float64])
 assert_type(divmod(b_, b_), tuple[np.int8, np.int8])
-assert_type(divmod(b_, i8), tuple[np.int64, np.int64])
-assert_type(divmod(b_, u8), tuple[np.uint64, np.uint64])
+# workarounds for https://github.com/microsoft/pyright/issues/9663
+assert_type(b_.__divmod__(i), tuple[np.int_, np.int_])
+assert_type(b_.__divmod__(f), tuple[np.float64, np.float64])
+assert_type(b_.__divmod__(i8), tuple[np.int64, np.int64])
+assert_type(b_.__divmod__(u8), tuple[np.uint64, np.uint64])
 assert_type(divmod(b_, f8), tuple[np.float64, np.float64])
 assert_type(divmod(b_, AR_b), tuple[npt.NDArray[np.int8], npt.NDArray[np.int8]])
 
@@ -77,26 +110,27 @@ assert_type(divmod(AR_b, b_), tuple[npt.NDArray[np.int8], npt.NDArray[np.int8]])
 
 assert_type(i8 % b, np.int64)
 assert_type(i8 % i8, np.int64)
-assert_type(i8 % f, np.floating[_64Bit])
-assert_type(i8 % f8, np.floating[_64Bit])
+assert_type(i8 % f, np.float64 | np.floating[_64Bit])
+assert_type(i8 % f8, np.float64 | np.floating[_64Bit])
 assert_type(i4 % i8, np.int64 | np.int32)
 assert_type(i4 % f8, np.float64 | np.float32)
 assert_type(i4 % i4, np.int32)
 assert_type(i4 % f4, np.float32)
 assert_type(i8 % AR_b, npt.NDArray[np.int64])
 
-assert_type(divmod(i8, b), tuple[np.signedinteger[_64Bit], np.signedinteger[_64Bit]])
-assert_type(divmod(i8, f), tuple[np.floating[_64Bit], np.floating[_64Bit]])
-assert_type(divmod(i8, i8), tuple[np.signedinteger[_64Bit], np.signedinteger[_64Bit]])
-assert_type(divmod(i8, f8), tuple[np.floating[_64Bit], np.floating[_64Bit]])
-assert_type(divmod(i8, i4), tuple[np.signedinteger[_64Bit], np.signedinteger[_64Bit]] | tuple[np.signedinteger[_32Bit], np.signedinteger[_32Bit]])
-assert_type(divmod(i8, f4), tuple[np.floating[_64Bit], np.floating[_64Bit]] | tuple[np.floating[_32Bit], np.floating[_32Bit]])
-assert_type(divmod(i4, i4), tuple[np.signedinteger[_32Bit], np.signedinteger[_32Bit]])
-assert_type(divmod(i4, f4), tuple[np.floating[_32Bit], np.floating[_32Bit]])
+assert_type(divmod(i8, b), tuple[np.int64, np.int64])
+assert_type(divmod(i8, i4), tuple[np.int64, np.int64] | tuple[np.int32, np.int32])
+assert_type(divmod(i8, i8), tuple[np.int64, np.int64])
+# workarounds for https://github.com/microsoft/pyright/issues/9663
+assert_type(i8.__divmod__(f), tuple[np.floating[_64Bit], np.floating[_64Bit]] | tuple[np.float64, np.float64])
+assert_type(i8.__divmod__(f8), tuple[np.floating[_64Bit], np.floating[_64Bit]] | tuple[np.float64, np.float64])
+assert_type(divmod(i8, f4), tuple[np.floating[_64Bit], np.floating[_64Bit]] | tuple[np.float32, np.float32])
+assert_type(divmod(i4, i4), tuple[np.int32, np.int32])
+assert_type(divmod(i4, f4), tuple[np.float32, np.float32])
 assert_type(divmod(i8, AR_b), tuple[npt.NDArray[np.int64], npt.NDArray[np.int64]])
 
-assert_type(b % i8, np.signedinteger[_64Bit])
-assert_type(f % i8, np.floating[_64Bit])
+assert_type(b % i8, np.int64)
+assert_type(f % i8, np.float64 | np.floating[_64Bit])
 assert_type(i8 % i8, np.int64)
 assert_type(f8 % i8, np.float64)
 assert_type(i8 % i4, np.int64 | np.int32)
@@ -105,21 +139,22 @@ assert_type(i4 % i4, np.int32)
 assert_type(f4 % i4, np.float32)
 assert_type(AR_b % i8, npt.NDArray[np.int64])
 
-assert_type(divmod(b, i8), tuple[np.signedinteger[_64Bit], np.signedinteger[_64Bit]])
-assert_type(divmod(f, i8), tuple[np.floating[_64Bit], np.floating[_64Bit]])
+assert_type(divmod(b, i8), tuple[np.int64, np.int64])
+assert_type(divmod(f, i8), tuple[np.floating[_64Bit], np.floating[_64Bit]] | tuple[np.float64, np.float64])
 assert_type(divmod(i8, i8), tuple[np.int64, np.int64])
 assert_type(divmod(f8, i8), tuple[np.float64, np.float64])
-assert_type(divmod(i4, i8), tuple[np.signedinteger[_64Bit], np.signedinteger[_64Bit]] | tuple[np.signedinteger[_32Bit], np.signedinteger[_32Bit]])
-assert_type(divmod(f4, i8), tuple[np.floating[_64Bit], np.floating[_64Bit]] | tuple[np.floating[_32Bit], np.floating[_32Bit]])
-assert_type(divmod(i4, i4), tuple[np.signedinteger[_32Bit], np.signedinteger[_32Bit]])
-assert_type(divmod(f4, i4), tuple[np.floating[_32Bit], np.floating[_32Bit]])
-assert_type(divmod(AR_b, i8), tuple[npt.NDArray[np.int64], npt.NDArray[np.int64]])
+assert_type(divmod(i4, i8), tuple[np.int64, np.int64] | tuple[np.int32, np.int32])
+assert_type(divmod(i4, i4), tuple[np.int32, np.int32])
+# workarounds for https://github.com/microsoft/pyright/issues/9663
+assert_type(f4.__divmod__(i8), tuple[np.floating[_64Bit], np.floating[_64Bit]] | tuple[np.float32, np.float32])
+assert_type(f4.__divmod__(i4), tuple[np.float32, np.float32])
+assert_type(AR_b.__divmod__(i8), tuple[npt.NDArray[np.int64], npt.NDArray[np.int64]])
 
 # float
 
 assert_type(f8 % b, np.float64)
 assert_type(f8 % f, np.float64)
-assert_type(i8 % f4, np.floating[_64Bit] | np.floating[_32Bit])
+assert_type(i8 % f4, np.floating[_64Bit] | np.float32)
 assert_type(f4 % f4, np.float32)
 assert_type(f8 % AR_b, npt.NDArray[np.float64])
 
@@ -131,15 +166,16 @@ assert_type(divmod(f4, f4), tuple[np.float32, np.float32])
 assert_type(divmod(f8, AR_b), tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]])
 
 assert_type(b % f8, np.float64)
-assert_type(f % f8, np.float64)
+assert_type(f % f8, np.float64)  # pyright: ignore[reportAssertTypeFailure]  # pyright incorrectly infers `builtins.float`
 assert_type(f8 % f8, np.float64)
 assert_type(f8 % f8, np.float64)
 assert_type(f4 % f4, np.float32)
 assert_type(AR_b % f8, npt.NDArray[np.float64])
 
 assert_type(divmod(b, f8), tuple[np.float64, np.float64])
-assert_type(divmod(f, f8), tuple[np.float64, np.float64])
 assert_type(divmod(f8, f8), tuple[np.float64, np.float64])
-assert_type(divmod(f4, f8), tuple[np.float64, np.float64] | tuple[np.float32, np.float32])
 assert_type(divmod(f4, f4), tuple[np.float32, np.float32])
-assert_type(divmod(AR_b, f8), tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]])
+# workarounds for https://github.com/microsoft/pyright/issues/9663
+assert_type(f8.__rdivmod__(f), tuple[np.float64, np.float64])
+assert_type(f8.__rdivmod__(f4), tuple[np.float64, np.float64])
+assert_type(AR_b.__divmod__(f8), tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]])
diff --git a/pavement.py b/pavement.py
index 5b2e5578b08b..6b6a0668b7a1 100644
--- a/pavement.py
+++ b/pavement.py
@@ -36,7 +36,7 @@
 #-----------------------------------
 
 # Path to the release notes
-RELEASE_NOTES = 'doc/source/release/2.2.2-notes.rst'
+RELEASE_NOTES = 'doc/source/release/2.2.3-notes.rst'
 
 
 #-------------------------------------------------------
diff --git a/pyproject.toml b/pyproject.toml
index 7c6b19d91fe5..b4f39af4d56c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -7,7 +7,7 @@ requires = [
 
 [project]
 name = "numpy"
-version = "2.2.2"
+version = "2.2.3"
 # TODO: add `license-files` once PEP 639 is accepted (see meson-python#88)
 license = {file = "LICENSE.txt"}
 
diff --git a/requirements/test_requirements.txt b/requirements/test_requirements.txt
index 7ea464dadc40..93e441f61310 100644
--- a/requirements/test_requirements.txt
+++ b/requirements/test_requirements.txt
@@ -9,6 +9,7 @@ pytest-cov==4.1.0
 meson
 ninja; sys_platform != "emscripten"
 pytest-xdist
+pytest-timeout
 # for numpy.random.test.test_extending
 cffi; python_version < '3.10'
 # For testing types. Notes on the restrictions: