Stabilize runtime correctness, typing parity, and docs for release

- Async-safe @shapix.check: preserve coroutine behavior and memo lifetime
- Reject mixed Scalar in shape specs (e.g. F32[N, Scalar] raises TypeError)
- Fix DT64/TD64 to accept unit-qualified dtypes (datetime64[ns], etc.)
- Exclude booleans from numeric ScalarLike aliases and make_scalar_like_type
- Robust __version__ fallback when package metadata is unavailable
- Full type-checker parity: pyright, mypy, and ty via TypeVar/TypeAliasType
  under TYPE_CHECKING; unified test suite across all three checkers
- Backend coverage: JAX/Torch Value(...) and boolean rejection tests
- Docs: async support, Scalar constraints, DT64/TD64, boolean semantics,
  make_scalar_like_type location, checker-agnostic language

Author: acecchini

CLAUDE.md

@@ -18,7 +18,7 @@ Shapix turns array shape annotations into **Python objects** that beartype valid
 
 - **Zero boilerplate** — works with standard `@beartype` decorators and `beartype.claw` import hooks. No custom decorator required.
 - **Cross-argument consistency** — named dimensions are enforced across all parameters and the return value within a single function call.
-- **Static type checker friendly** — under `TYPE_CHECKING`, array types resolve to proper `NDArray` / `Array` / `Tensor` aliases. Pyright sees real types.
+- **Static type checker friendly** — under `TYPE_CHECKING`, array types resolve to proper `NDArray` / `Array` / `Tensor` aliases. Works with pyright, mypy, and ty.
 - **Readable annotations** — `F32[N, C, H, W]` reads like documentation.
 - **Full `BeartypeConf` support** — unlike jaxtyping, shapix doesn't replace your beartype configuration.
 - **Thread-safe** — each thread gets independent dimension bindings.
@@ -265,6 +265,8 @@ def dot(x: F32[N], y: F32[N]) -> F32[Scalar]:
     return np.dot(x, y)  # returns shape ()
 ```
 
+> **Note:** `Scalar` must be the only shape token. Mixed forms like `F32[N, Scalar]` or `F32[Scalar, ...]` raise `TypeError` at hint construction time.
+
 ### Custom dimensions
 
 Create your own with `Dimension`:
@@ -328,6 +330,8 @@ from shapix.numpy import F32, I64, Shaped  # and many more
 
 **Additional dtypes:** `V` (void), `Str` (string), `Bytes` (bytes), `Obj` (object), `DT64` (datetime64), `TD64` (timedelta64)
 
+> `DT64` and `TD64` accept unit-qualified NumPy dtypes such as `datetime64[ns]`, `datetime64[D]`, `timedelta64[ms]`, etc.
+
 ### JAX
 
 ```python
@@ -428,7 +432,9 @@ from shapix.torch import F32Like   # accepts Tensor, ndarray, scalars, sequences
 
 ### ScalarLike types (range-validated scalars)
 
-ScalarLike types validate individual scalar values with range checking — no shape, just value:
+ScalarLike types validate individual scalar values with range checking — no shape, just value.
+
+> **Note:** Numeric scalar aliases (`I8ScalarLike`, `F32ScalarLike`, `NumScalarLike`, etc.) reject `bool` and `np.bool_` values. Python `bool` is a subclass of `int`, but shapix treats booleans as non-numeric. Use `BoolScalarLike` for boolean scalars.
 
 ```python
 from shapix.numpy import I8ScalarLike, F32ScalarLike, U8ScalarLike
@@ -701,6 +707,8 @@ def f(x: F32[N, C], y: F32[N, C]) -> F32[N, C]: ...
 
 If you want a guarantee that cross-argument checking works regardless of how your code is called (by test runners, async frameworks, deep middleware stacks), `@shapix.check` removes all dependence on call-stack structure.
 
+`@shapix.check` supports both sync and async functions. For async functions, the memo scope covers the full awaited execution, and `inspect.iscoroutinefunction()` is preserved on the decorated function.
+
 **When you don't need it:** If you're using plain `@beartype` and your tests pass, the frame-based detection is working. Most applications never need `@shapix.check`.
 
 ### Manual checks with `check_context`
@@ -733,61 +741,58 @@ Shapix uses three key mechanisms:
 
 3. **Thread-local storage** — Each thread gets its own memo stack via `threading.local()`, ensuring thread safety.
 
-## Static type checkers (pyright / Pylance)
+## Static type checkers (pyright, mypy, ty)
 
-Shapix's pre-defined dimension symbols (`N`, `C`, `H`, `W`, ...) work out of the box with pyright and Pylance — under `TYPE_CHECKING` they resolve to `int` type aliases, so annotations like `F32[N, C]` are fully valid type expressions.
+Shapix supports **pyright**, **mypy**, and **ty**. Under `TYPE_CHECKING`, pre-defined dimension symbols (`N`, `C`, `H`, `W`, …) resolve to `TypeVar` and array types resolve to `TypeAliasType`, so core annotations like `F32[N, C]` are valid type expressions across all three checkers.
 
-However, some patterns produce type checker errors because they place **runtime values** where pyright expects **types**:
+However, some patterns are fundamentally runtime-only and produce type checker errors regardless of the checker:
 
-| Pattern | Example | Pyright rule |
-|---------|---------|--------------|
-| Integer literals | `F32[N, 3, H, W]` | `reportGeneralTypeIssues` |
-| Unary operators | `F32[~B, C]`, `F32[+N, C]` | `reportInvalidTypeForm` |
-| Arithmetic | `F32[N + 2]` | `reportInvalidTypeForm` |
-| Custom dimensions | `F32[Vocab, Embed]` | `reportInvalidTypeForm` (or use `TYPE_CHECKING` pattern) |
+| Pattern | Example | Workaround |
+|---------|---------|------------|
+| Integer literals | `F32[N, 3, H, W]` | Wrap in `Dimension("3")` |
+| Unary operators | `F32[~B, C]`, `F32[+N, C]` | `# type: ignore` |
+| Arithmetic | `F32[N + 2]` | `# type: ignore` |
+| Custom dimensions | `F32[Vocab, Embed]` | `# type: ignore` or `TYPE_CHECKING` pattern |
+| `Value(...)` | `F32[Value("size")]` | `# type: ignore` |
 
-### Option A — Suppress `reportInvalidTypeForm` and wrap integers (recommended)
-
-Add one line to your pyright config to silence operators, custom dimensions, and arithmetic globally. Then wrap bare integer literals in `Dimension()` to shift them to the same suppressed rule:
-
-```jsonc
-// pyrightconfig.json (recommended — Pylance always reads this)
-{ "reportInvalidTypeForm": false }
-```
+### Recommended pyright config
 
-Or equivalently in `pyproject.toml`:
+Add to your `pyproject.toml` or `pyrightconfig.json` to suppress the most common shapix-related diagnostics:
 
 ```toml
 [tool.pyright]
 reportInvalidTypeForm = false
 ```
 
-```python
-from shapix import N, H, W, Dimension
+### Inline `# type: ignore`
+
+For patterns that all three checkers reject (arithmetic dims, Value(), custom dims), use blanket `# type: ignore`:
 
-# Integer literals — wrap in Dimension() to avoid reportGeneralTypeIssues
+```python
 @beartype
-def rgb_to_gray(x: F32[N, Dimension("3"), H, W]) -> F32[N, Dimension("1"), H, W]:
+def pad(x: F32[N]) -> F32[N + 2]:  # type: ignore
     ...
 
-# Operators, arithmetic, custom dimensions — all covered by the suppression
 @beartype
-def pad(x: F32[N]) -> F32[N + 2]:
+def f(x: F32[~B, C]) -> F32[~B, C]:  # type: ignore
     ...
 ```
 
-### Option B — Inline `# type: ignore`
+### Custom dimensions under TYPE_CHECKING
 
-If you prefer not to change your pyright config, silence individual lines:
+Custom dimensions created with `Dimension()` are runtime objects. To make them work with all type checkers, use the `TYPE_CHECKING` pattern:
 
 ```python
-@beartype
-def rgb_to_gray(x: F32[N, 3, H, W]) -> F32[N, 1, H, W]:  # type: ignore[reportGeneralTypeIssues]
-    ...
+import typing as tp
+from shapix import Dimension
 
-@beartype
-def f(x: F32[~B, C]) -> F32[~B, C]:  # type: ignore[reportInvalidTypeForm]
-    ...
+if tp.TYPE_CHECKING:
+    import typing as _tp
+    Vocab = _tp.TypeVar("Vocab")
+    Embed = _tp.TypeVar("Embed")
+else:
+    Vocab = Dimension("Vocab")
+    Embed = Dimension("Embed")
 ```
 
 ## Compared to jaxtyping
@@ -835,17 +840,22 @@ def f(x: F32[~B, C]) -> F32[~B, C]:  # type: ignore[reportInvalidTypeForm]
 
 Most NumPy array types, plus `BF16` and `BF16Like`. NumPy-only extended-precision array aliases such as `F128` / `C256` stay in `shapix.numpy`. Both export `Like` types, `ScalarLike` types (re-exported from numpy), and `make_scalar_like_type`. JAX also exports `Tree`.
 
-### Factories (`shapix`)
+### Factories
+
+From `shapix` (root):
 
 `make_array_type(array_class, dtype_spec)` — custom array type
 `make_array_like_type(dtype_spec, *, casting="same_kind", name="ArrayLike")` — custom Like type
-`make_scalar_like_type(target_dtype, *, casting="same_kind", name="ScalarLike")` — custom ScalarLike type
 `DtypeSpec(name, allowed)` — custom dtype specification
 `DtypeSpec.structured(fields)` — structured dtype specification
 
+From `shapix.numpy` (requires NumPy):
+
+`make_scalar_like_type(target_dtype, *, casting="same_kind", name="ScalarLike")` — custom ScalarLike type
+
 ### Decorators & context managers (`shapix`)
 
-`@shapix.check` — explicit memo management
+`@shapix.check` — explicit memo management (supports both sync and async functions)
 `@shapix.check(conf=BeartypeConf())` — combined memo + beartype
 `shapix.check_context()` — context manager for manual checks
 

README.md

@@ -47,16 +47,20 @@ def conv(x: F32[N, C, H, W]) -> F32[N, C, H, W]: ...
     :func:`make_array_like_type` — create subscriptable array-like type
     factories with configurable dtype casting.
     :func:`check` — optional decorator for explicit memo management.
+    Supports both sync and async functions.
     Also supports combined mode: ``@check(conf=BeartypeConf())``.
 
 Context managers
     :class:`check_context` — shared dimension memo for manual
     ``is_bearable()`` checks.
 """
 
-from importlib.metadata import version
+from importlib.metadata import PackageNotFoundError, version
 
-__version__ = version("shapix")
+try:
+  __version__ = version("shapix")
+except PackageNotFoundError:
+  __version__ = "0+unknown"
 
 __all__ = [
   # Dimension symbols

src/shapix/__init__.py

@@ -29,7 +29,7 @@
 
 from beartype.vale import Is
 
-from ._dimensions import Dimension, _ValueExpr
+from ._dimensions import Dimension, Scalar, _ValueExpr
 from ._dtypes import DtypeSpec
 from ._dtypes import extract_dtype_str as extract_dtype_str
 from ._memo import ShapeMemo as ShapeMemo
@@ -406,6 +406,11 @@ def make_array_like_type(
 
 def _to_shape_spec(dims: tuple[object, ...]) -> tuple[DimSpec, ...]:
   """Convert a tuple of user-facing dim objects to internal DimSpec."""
+  if any(d is Scalar for d in dims) and len(dims) > 1:
+    msg = (
+      "Scalar must be the only shape token; mixed use like F32[N, Scalar] is invalid"
+    )
+    raise TypeError(msg)
   specs: list[DimSpec] = []
   for d in dims:
     if d is Ellipsis:

src/shapix/_array_types.py

@@ -54,6 +54,20 @@ def decorator(fn: Callable[P, R]) -> Callable[P, R]:
 
       inner = beartype(fn, conf=conf)  # type: ignore[arg-type]
 
+    if inspect.iscoroutinefunction(fn):
+
+      @functools.wraps(fn)
+      async def async_wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        bound = signature.bind_partial(*args, **kwargs)
+        bound.apply_defaults()
+        push_memo(scope=dict(bound.arguments))
+        try:
+          return await inner(*args, **kwargs)  # type: ignore[misc]
+        finally:
+          pop_memo()
+
+      return async_wrapper  # type: ignore[return-value]
+
     @functools.wraps(fn)
     def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
       bound = signature.bind_partial(*args, **kwargs)

src/shapix/_decorator.py

@@ -311,17 +311,17 @@ def __new__(cls, expr: str) -> Dimension: ...
 
     def __pos__(self) -> Dimension: ...
 
-  Scalar: Dimension
-  B: Dimension
-  N: Dimension
-  P: Dimension
-  L: Dimension
-  C: Dimension
-  D: Dimension
-  K: Dimension
-  H: Dimension
-  W: Dimension
-  __: Dimension
+  Scalar = tp.TypeVar("Scalar")
+  B = tp.TypeVar("B")
+  N = tp.TypeVar("N")
+  P = tp.TypeVar("P")
+  L = tp.TypeVar("L")
+  C = tp.TypeVar("C")
+  D = tp.TypeVar("D")
+  K = tp.TypeVar("K")
+  H = tp.TypeVar("H")
+  W = tp.TypeVar("W")
+  __ = tp.TypeVar("__")
 else:
 
   class Value(_ValueExpr):

src/shapix/_dimensions.py

@@ -265,6 +265,10 @@ def extract_dtype_str(obj: object) -> str:
       return "bytes"
     if dtype_name.startswith("str"):
       return "str"
+    if dtype_name.startswith("datetime64"):
+      return "datetime64"
+    if dtype_name.startswith("timedelta64"):
+      return "timedelta64"
     return dtype_name
 
   # NumPy / JAX: dtype.type.__name__ (e.g. "float32")