types-bits 0.1.0__tar.gz

types_bits-0.1.0/.claude/agents/camas-lint-fixer-haiku.md

@@ -0,0 +1,27 @@
+---
+name: camas-lint-fixer-haiku
+description: Takes one cheap pass at a scope's lint/format residual — reads the diagnostics, edits the root cause, and always ends by running the deterministic fixer, off the main agent's context. Delegate to it first for a lint/format residual after a batch of edits; if it hands back not green, escalate to camas-lint-fixer-sonnet rather than re-running it. Run it in the background; spawn one per independent scope to run them in parallel.
+model: haiku
+maxTurns: 3
+tools: Read, Edit, mcp__camas__camas_gate, mcp__camas__camas_fix
+---
+
+You get one pass at a scope's lint/format residual, on the cheapest model — spend it on the
+mechanical fix, not on iterating. You are given the changed paths and, when the main agent
+already ran the gate, its failing diagnostics.
+
+1. If you were not handed diagnostics, call `camas_gate` scoped to exactly the paths you were
+   given — do not widen the scope.
+2. Read the diagnostics and edit the smallest change that addresses what was flagged. Do not
+   touch unrelated code.
+3. Whatever you did, call `camas_fix` scoped to your paths as your last action — even if you are
+   not sure the scope is green. The deterministic fixer (formatters, `--fix` linters) is free;
+   never end having edited a file without also having run it.
+
+You get exactly one pass — do not re-gate to loop, and do not call `camas_fix` more than once.
+Never mask a diagnostic: do not suppress, disable, loosen, or ignore a check to make it look
+green.
+
+Your final message must say what you changed and confirm you ran `camas_fix`; do not claim the
+scope is green — the main agent re-gates and escalates to camas-lint-fixer-sonnet if a residual
+remains.

types_bits-0.1.0/.claude/agents/camas-lint-fixer-sonnet.md

@@ -0,0 +1,27 @@
+---
+name: camas-lint-fixer-sonnet
+description: The escalation tier for a lint/format residual camas-lint-fixer-haiku could not settle — the same single-pass discipline on a stronger model. Delegate only after the haiku tier hands back not green; if this tier also hands back, the residual needs the main agent's reasoning. Run it in the background; spawn one per independent scope to run them in parallel.
+model: sonnet
+maxTurns: 4
+tools: Read, Edit, mcp__camas__camas_gate, mcp__camas__camas_fix
+---
+
+You are the escalation tier: camas-lint-fixer-haiku already took a pass at this scope's
+lint/format residual and handed it back not green. You get one more pass, on a stronger model —
+spend it on the mechanical fix, not on iterating. You are given the changed paths and the
+failing diagnostics (the haiku tier's, or a fresh gate if the main agent re-ran it).
+
+1. If you were not handed diagnostics, call `camas_gate` scoped to exactly the paths you were
+   given — do not widen the scope.
+2. Read the diagnostics and edit the root cause — if the haiku tier's edit was on the wrong
+   track, correct it rather than layering another change on top.
+3. Whatever you did, call `camas_fix` scoped to your paths as your last action — even if you are
+   not sure the scope is green. The deterministic fixer (formatters, `--fix` linters) is free;
+   never end having edited a file without also having run it.
+
+You get exactly one pass — do not re-gate to loop, and do not call `camas_fix` more than once.
+Never mask a diagnostic: do not suppress, disable, loosen, or ignore a check to make it look
+green.
+
+Your final message must say what you changed and confirm you ran `camas_fix`; do not claim the
+scope is green — the main agent re-gates and takes over if a residual remains.

types_bits-0.1.0/.claude/agents/camas-test-fixer.md

@@ -0,0 +1,28 @@
+---
+name: camas-test-fixer
+description: Fixes test and coverage residuals for a scope on a capable model — diagnoses the failing test or coverage gap, edits source or tests to address the root cause, then ends by running the deterministic fixer and re-gating to confirm green. Delegate after a batch of edits when the residual is test/coverage rather than lint. Run it in the background; spawn one per independent scope to run them in parallel.
+model: sonnet
+maxTurns: 6
+tools: Read, Edit, mcp__camas__camas_gate, mcp__camas__camas_fix
+---
+
+You fix test and coverage residuals for a scope so the main agent spends no reasoning on a
+mechanical test failure or coverage gap it can hand off. You are given the changed paths and,
+when the main agent already ran the gate, its failing diagnostics.
+
+1. If you were not handed diagnostics, call `camas_gate` scoped to exactly the paths you were
+   given — do not widen the scope.
+2. Read the failing test or coverage report and diagnose the root cause: a real behavior bug
+   (fix the source), a stale or wrong test (fix the test to match the intended behavior), or a
+   genuine coverage gap (add a test). If it is unclear which the diagnostics call for — whether
+   the test or the behavior is wrong — that is exactly the residual you hand back; do not guess.
+3. End by calling `camas_fix` (applies deterministic formatters/`--fix` linters over your edits)
+   and then `camas_gate` again, both scoped to your paths, to confirm you actually reached green.
+
+Never change behavior just to make a test pass, and never mask a diagnostic: do not suppress,
+disable, loosen, or delete a test or a coverage requirement to make the gate pass. A green gate
+must mean the code and its tests are actually correct.
+
+When the re-gate is still not green, or the right fix is ambiguous, stop and hand back: your
+final message must say so and quote the remaining diagnostics (or state the ambiguity) verbatim,
+so the main agent can take over without re-running anything.

types_bits-0.1.0/.claude/settings.json

@@ -0,0 +1,30 @@
+{
+  "hooks": {
+    "PostToolBatch": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "uv run camas mcp fix || exit 0"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "uv run camas mcp fix || exit 0"
+          },
+          {
+            "type": "command",
+            "command": "uv run camas mcp gate --under 5s --nudge",
+            "async": true,
+            "asyncRewake": true
+          }
+        ]
+      }
+    ]
+  }
+}

types_bits-0.1.0/.claude/skills/gate/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: gate
+description: Keep the workspace green while you edit — the free autofix hooks, and delegating the check-and-fix loop to the tiered camas-fixer ladder so residuals never spend your reasoning. Read after a batch of edits and before declaring work done.
+---
+
+The camas gate keeps the workspace green as you edit, in two layers — both driven by what the
+project declares in `Config.agent`.
+
+**Fix (automatic, free).** A `PostToolBatch` hook runs `camas mcp fix` after each edit batch, and
+a `Stop` hook runs it again as you finish your turn — the node the project registered as
+`Config.agent.fix` (its mutating, behavior-preserving auto-fixers: formatters, `--fix` linters),
+scoped to the just-changed files. Both run at zero model tokens and never ask you anything; with
+no fix registered they are a no-op.
+
+**Check (you delegate — to a tiered ladder).** The check node (`Config.agent.check`, else the
+default task) is read-only: it runs the project's checks and classifies the result `green` or
+`needs_reasoning`. After a batch of edits, and before you declare work done, **delegate the
+check-and-fix loop to the camas-fixer ladder** rather than running the checks and chasing
+residuals in your own context. Subagents cannot nest — a haiku subagent cannot spawn a sonnet
+one — so you orchestrate the escalation yourself:
+
+- For a **lint/format** residual (the diagnostic names formatters or `--fix` linters): spawn
+  `camas-lint-fixer-haiku` with the changed paths as its scope. It takes one pass and hands back.
+  If it hands back not green, escalate by spawning `camas-lint-fixer-sonnet` on the same scope —
+  it also takes one pass. If *that* hands back not green, the residual is yours: take it from
+  there.
+- For a **test/coverage** residual (the diagnostic names a test runner or coverage tool): spawn
+  `camas-test-fixer` directly — it fixes tests and coverage on a capable model in one delegation,
+  ending by re-gating to confirm green. If it hands back not green, or says the fix is ambiguous
+  (test wrong vs. behavior wrong), take it from there yourself.
+- When diagnostics span both kinds, or you can't tell from the names, start with the lint ladder
+  (cheaper) and send whatever remains to `camas-test-fixer`.
+
+Run each fixer in the background and keep working; for independent changed scopes, spawn one per
+scope so they run in parallel. Each fixer hands back only what it could not settle: a green
+result means that scope is done; a result quoting remaining diagnostics is the residual that
+needs your reasoning.
+
+**The Stop-hook nudge.** If your turn ends before you delegated (or a fixer's residual never got
+picked up), a background check runs after you stop and, if the workspace isn't green, wakes you
+with a reminder to launch the fixer ladder — so a skipped check-and-fix loop doesn't go silently
+unnoticed. It wakes you at most once per prompt and never for a configuration gap (no check node
+registered), so it cannot loop your turn. Prefer delegating proactively per the ladder above;
+treat the nudge as a backstop, not your primary signal.
+
+Never mask a residual — yours or a fixer's: do not suppress, disable, or loosen a check to make
+the gate pass. A green gate must mean the work is actually correct.

types_bits-0.1.0/.github/workflows/ci.yaml

@@ -0,0 +1,96 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+    tags: ["*"]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  discover:
+    runs-on: ubuntu-latest
+    outputs:
+      axes: ${{ steps.axes.outputs.axes }}
+      tasks: ${{ steps.tasks.outputs.tasks }}
+    steps:
+      - uses: actions/checkout@fbc6f3992d24b796d5a048ff273f7fcc4a7b6c09 # v5
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@11f9893b081a58869d3b5fccaea48c9e9e46f990 # v8.3.2
+        with:
+          enable-cache: false
+
+      - id: axes
+        run: echo "axes=$(uv run camas verify --github-matrix=axes)" >> "$GITHUB_OUTPUT"
+      - id: tasks
+        run: echo "tasks=$(uv run camas suite --github-matrix=tasks)" >> "$GITHUB_OUTPUT"
+
+  check:
+    needs: discover
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, ubuntu-24.04-arm, macos-latest, windows-latest]
+        task: ${{ fromJSON(needs.discover.outputs.tasks).task }}
+        python: ${{ fromJSON(needs.discover.outputs.axes).PY }}
+    runs-on: ${{ matrix.os }}
+    name: ${{ matrix.task }} · py${{ matrix.python }} · ${{ matrix.os }}
+    env:
+      UV_PYTHON: ${{ matrix.python }}
+    steps:
+      - uses: actions/checkout@fbc6f3992d24b796d5a048ff273f7fcc4a7b6c09 # v5
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@11f9893b081a58869d3b5fccaea48c9e9e46f990 # v8.3.2
+        with:
+          enable-cache: false
+      - run: uv run camas "$TASK"
+        shell: bash
+        env:
+          TASK: ${{ matrix.task }}
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@fbc6f3992d24b796d5a048ff273f7fcc4a7b6c09 # v5
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@11f9893b081a58869d3b5fccaea48c9e9e46f990 # v8.3.2
+        with:
+          enable-cache: false
+      - run: uv run camas build
+      - run: unzip -l dist/*.whl | grep -q types_bits/__init__.pyi
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: dist
+          path: dist/
+
+  release:
+    if: startsWith(github.ref, 'refs/tags/')
+    needs: [check, build]
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/types-bits
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: dist
+          path: dist/
+      - uses: astral-sh/setup-uv@11f9893b081a58869d3b5fccaea48c9e9e46f990 # v8.3.2
+        with:
+          enable-cache: false
+      - run: uv publish --trusted-publishing always

types_bits-0.1.0/.gitignore

@@ -0,0 +1,21 @@
+# Materialized type stubs — regenerate with `camas gen`
+/src/types_bits/*.pyi
+
+# Task runner cache
+/.camas/
+
+# Benchmark output
+/bench/results/
+
+.venv/
+__pycache__/
+*.py[cod]
+dist/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.pyrefly_cache/
+.zuban_cache/
+
+/bench/.work/
+*.tmp

types_bits-0.1.0/.mcp.json

@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "camas": {
+      "type": "stdio",
+      "command": "uv",
+      "args": [
+        "run",
+        "camas",
+        "mcp"
+      ]
+    }
+  }
+}

types_bits-0.1.0/.python-version

@@ -0,0 +1,3 @@
+3.14
+3.13
+3.12

types_bits-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JP Hutchins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

types_bits-0.1.0/PKG-INFO

@@ -0,0 +1,222 @@
+Metadata-Version: 2.4
+Name: types-bits
+Version: 0.1.0
+Summary: Sized integer types: exhaustive Literal unions statically, Annotated bounds at runtime
+Author-email: JP Hutchins <jphutchins@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Provides-Extra: rt
+Requires-Dist: annotated-types>=0.7; extra == 'rt'
+Description-Content-Type: text/markdown
+
+# types-bits
+
+`u1`..`u10` and `i1`..`i10` as fully materialized `Literal` unions. Generated `.pyi`, zero
+runtime cost, exhaustively checked.
+
+```python
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from types_bits import u4
+
+x: u4 = 15  # ok
+y: u4 = 16  # error, on every checker
+```
+
+`camas` runs the gate; `camas --list` enumerates it. CI fans the same tree out over a
+runner axis, with both matrix axes emitted from `tasks.py`. `camas bench` and
+`camas bench_shapes` regenerate everything below into `bench/results/`.
+
+## Runtime cost
+
+Zero. The stub is a [PEP 484][pep484] `.pyi` behind `TYPE_CHECKING`. `import types_bits`
+loads two modules and no stdlib (`tests/test_runtime.py`). Every number below is
+type-checker wall clock, per check run.
+
+## Check cost by width
+
+Seconds, cold, best of one, Python 3.14.1 / WSL2. Encoding `flat`
+(`type uN = Literal[0, ..., 2**N-1]`), declaring `u1..uN` (so a probe at N bits holds 2^(N+1)-2 literals) and widening each
+into the next.
+
+| bits | mypy | pyright | basedpyright | ty | pyrefly | zuban |
+|---:|---:|---:|---:|---:|---:|---:|
+| 8 | 2.30 | 0.68 | 0.71 | 0.08 | 0.32 | 0.10 |
+| 10 | 1.98 | 0.75 | 0.83 | 0.09 | 0.38 | 0.12 |
+| 12 | 2.22 | 0.79 | 0.85 | 0.11 | 0.31 | 0.33 |
+| 14 | 3.10 | 0.59 | 0.64 | 0.17 | 0.27 | 3.23 |
+| 16 | 3.85 | 0.70 | 0.79 | 0.41 | 0.46 | 51.26 |
+
+Shipped library (`u1..u10` + `i1..i10`): mypy 2.05, basedpyright 1.43,
+pyright 1.13, pyrefly 0.24, zuban 0.08, ty 0.06 — matching the `type uN = int` control.
+
+```mermaid
+xychart-beta
+    title "16 bits"
+    x-axis [zuban, mypy, basedpyright, pyright, pyrefly, ty]
+    y-axis "seconds" 0 --> 55
+    bar [51.26, 3.85, 0.79, 0.70, 0.46, 0.41]
+```
+
+zuban, same sweep — roughly 16x per extra 2 bits past 12:
+
+```mermaid
+xychart-beta
+    title "zuban vs width"
+    x-axis "bits" [8, 10, 12, 14, 16]
+    y-axis "seconds" 0 --> 55
+    line [0.10, 0.12, 0.33, 3.23, 51.26]
+```
+
+The other five, 0–4s axis. Rising line is mypy; flat cluster is pyright, basedpyright,
+pyrefly, ty:
+
+```mermaid
+xychart-beta
+    title "mypy, pyright, basedpyright, pyrefly, ty"
+    x-axis "bits" [8, 10, 12, 14, 16]
+    y-axis "seconds" 0 --> 4
+    line [2.30, 1.98, 2.22, 3.10, 3.85]
+    line [0.68, 0.75, 0.79, 0.59, 0.70]
+    line [0.71, 0.83, 0.85, 0.64, 0.79]
+    line [0.32, 0.38, 0.31, 0.27, 0.46]
+    line [0.08, 0.09, 0.11, 0.17, 0.41]
+```
+
+## Fixed vs marginal cost
+
+`u(N-1)` and `u(N)` declared in every row; only the use count varies. Italic rows are the
+`type uN = int` control.
+
+10 bits — indistinguishable from `int`:
+
+| uses | mypy | pyright | basedpyright | ty | pyrefly | zuban |
+|---|---:|---:|---:|---:|---:|---:|
+| declared, unused | 1.64 | 0.55 | 0.60 | 0.05 | 0.23 | 0.10 |
+| *control* | *1.64* | *0.60* | *0.59* | *0.06* | *0.23* | *0.08* |
+| 1 widening | 1.50 | 0.56 | 0.64 | 0.06 | 0.26 | 0.09 |
+| 10 widenings | 1.75 | 0.65 | 0.90 | 0.08 | 0.29 | 0.20 |
+
+16 bits — 98,304 literals:
+
+| uses | mypy | pyright | basedpyright | ty | pyrefly | zuban |
+|---|---:|---:|---:|---:|---:|---:|
+| declared, unused | 2.79 | 0.66 | 0.64 | 0.18 | 0.29 | 0.20 |
+| *control* | *1.57* | *0.62* | *0.59* | *0.05* | *0.28* | *0.08* |
+| 1 assignment | 2.77 | 0.62 | 0.65 | 0.19 | 0.33 | 0.21 |
+| 1 widening | 2.81 | 0.64 | 0.65 | 0.22 | 0.37 | **35.66** |
+| 10 widenings | 3.31 | 0.56 | 0.58 | 0.20 | 0.31 | **timeout (>180s)** |
+
+- Declaration: fixed per check run, ~linear in literals (~12 µs/literal on mypy). Not per
+  importing file, not per use.
+- Assignment: free. Enumerated membership is a hash lookup.
+- Widening: free except zuban at width.
+
+## Widening
+
+Cost tracks the *narrow* operand, not the wide one. Wide side fixed at `u16`, one widening:
+
+| narrow | zuban | mypy | ty |
+|---|---:|---:|---:|
+| u1 | 0.18 | 2.54 | 0.20 |
+| u4 | 0.18 | 2.46 | 0.15 |
+| u8 | 0.16 | 2.67 | 0.21 |
+| u12 | 0.76 | 2.50 | 0.17 |
+| u15 | 35.21 | 2.80 | 0.18 |
+
+Both operands must be large. At the 10-bit ceiling the worst case (`u9` → `u10`) is 0.09s.
+Annotating a boundary at one width, so callers assign literals rather than widen between
+adjacent wide aliases, avoids the shape entirely.
+
+## Encodings
+
+| encoding | form | result |
+|---|---|---|
+| `flat` | `Literal[0, ..., 2**N-1]` | shipped; fastest, portable |
+| `nested` | `Literal[u9, 512, ...]` | legal per [PEP 586][pep586]; pyrefly rejects past ~10 levels (`Invalid type inside literal, int`, 1 error at 10 bits → 7 at 16), ty at 16 |
+| `union` | `u9 \| Literal[512, ...]` | ty 44.24s at 14 bits vs 0.17s flat |
+| `annotated` | `Annotated[Literal[...], Ge, Le]` | tracks `flat` within noise to 14 bits |
+| `opaque` | `int` | control |
+
+```mermaid
+xychart-beta
+    title "ty at 14 bits by encoding"
+    x-axis [union, nested, annotated, flat]
+    y-axis "seconds" 0 --> 46
+    bar [44.24, 0.23, 0.22, 0.17]
+```
+
+## Runtime tier
+
+[PEP 562][pep562] module `__getattr__` resolves the same names to
+`Annotated[int, Ge(lo), Le(hi)]` ([PEP 593][pep593]), the shape
+[`annotated-types`][at] consumers read. `tests/test_runtime.py` pins it against the static
+bounds for all 20 widths. Needs the `rt` extra; `annotated_types` imports on first
+attribute access.
+
+```python
+from pydantic import TypeAdapter
+from types_bits import u8  # Annotated[int, Ge(0), Le(255)] at runtime
+
+TypeAdapter(u8).validate_python(256)  # ValidationError
+```
+
+## Prior art
+
+[`range-typed-integers`][rti] defines `u8 = NewType('u8', Annotated[int, ValueRange(0, 255)])`
+for the byte widths `u8`..`u64` / `i8`..`i64`.
+
+| | range-typed-integers | types-bits |
+|---|---|---|
+| carrier | `NewType` over `Annotated[int, ValueRange]` | `Literal` enumeration |
+| bound enforced by | runtime `u8_checked()` / `check_int()`, raising `IntegerBoundError` | the type checker |
+| `a: u8 = 12` | mypy error — `int` is not `u8`; requires `u8(12)` | ok |
+| `a: u8 = 900` | mypy error, *identical* to the line above | error, and distinguished |
+| `u8(900)` | accepted statically | n/a |
+| widths | u8..u64 | u1..u10 |
+
+Verified against every checker in the gate: mypy reports the same `Incompatible types in assignment
+(expression has type "int", variable has type "u8")` on the in-range and out-of-range
+lines alike. The range is metadata no checker reads ([PEP 746][pep746] would not change
+this). `ValueRange` is O(1) per type, so it reaches u64; enumeration is O(2^N), so it
+stops at u10.
+
+## PEPs
+
+No PEP provides bounded integers.
+
+| PEP | Status | Relevance |
+|---|---|---|
+| [586 – Literal Types][pep586] | Final | The mechanism. Calls `Literal` insufficient for numpy-style numeric code and defers integer generics. Permits the `nested` form pyrefly rejects. |
+| [593 – `Annotated`][pep593] | Final | Metadata channel for the runtime tier. |
+| [695 – Type Parameter Syntax][pep695] | Final | `type uN = ...` in the stub. |
+| [561 – Packaging Type Information][pep561] | Final | `py.typed`; why the stub ships in the wheel. |
+| [562 – Module `__getattr__`][pep562] | Final | One name, two tiers. |
+| [649][pep649] / [749][pep749] – Deferred Annotations | Final (3.14) | Guarded import gets cheaper. |
+| [746 – Type checking `Annotated` metadata][pep746] | Draft, targets 3.15 | Lets a checker verify metadata suits its type. Does not make any checker enforce `Ge`/`Le`. |
+
+- [python/typing#554, "Support for Range Types?"][i554] — closed. Requested an Ada-style
+  `RangeType`.
+- [discuss.python.org, "Use type hinting with bound constraints, e.g. `int[0:15]`"][thread]
+  — no resolution. Objections: most constraints are not statically validatable; ranges need
+  new type-system machinery; arithmetic is not closed. Landed on `Annotated` +
+  `annotated-types` with runtime validation.
+
+`fixtures/reject.py` covers the arithmetic case: every checker rejects `u4 + u4` where a
+`u4` is required. mypy widens the sum to `int`; ty and zuban widen it to `Literal[0, ..., 30]`.
+
+[pep484]: https://peps.python.org/pep-0484/
+[pep561]: https://peps.python.org/pep-0561/
+[pep562]: https://peps.python.org/pep-0562/
+[pep586]: https://peps.python.org/pep-0586/
+[pep593]: https://peps.python.org/pep-0593/
+[pep649]: https://peps.python.org/pep-0649/
+[pep695]: https://peps.python.org/pep-0695/
+[pep746]: https://peps.python.org/pep-0746/
+[pep749]: https://peps.python.org/pep-0749/
+[at]: https://github.com/annotated-types/annotated-types
+[i554]: https://github.com/python/typing/issues/554
+[thread]: https://discuss.python.org/t/use-type-hinting-with-bound-constraints-e-g-int-0-15/38820
+[rti]: https://github.com/theCapypara/range-typed-integers