diff --git a/content/index.md b/content/index.md
index 081b944..cf9d353 100644
--- a/content/index.md
+++ b/content/index.md
@@ -15,7 +15,7 @@ index current. (Keep entries and their keywords in sync with each document's `ta
 Proposals the group broadly agrees are implementation-ready.
 
 - [[shared/external-memory-for-dace-arrays/external-memory-for-dace-arrays|External workspace memory for DaCe temporary arrays]] — keywords: dace, backend, gpu, memory, temporary-arrays, workspace, cuda, hip, mempool, persistent, external, allocation, icon4py, performance
-- [[shared/dimensions-as-types|Dimensions as types]] — keywords: type-system, dimensions, type-checking, mypy, mypy-plugin, pyright, nominal-types, metaclass, migration, serialization, frontend, foast, extension-point
+- [[shared/dimensions-as-types|Dimensions as types]] (superseded by [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types]]) — keywords: type-system, dimensions, type-checking, mypy, mypy-plugin, pyright, nominal-types, metaclass, migration, serialization, frontend, foast, extension-point
 
 <!-- Entry format:
 - [[shared/<slug>|Title]] — keywords: keyword1, keyword2, keyword3
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
index 3d8ae53..0c8158b 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types.md
@@ -12,10 +12,10 @@ status: draft
 > `FieldOffset` tag, the local `Dimension` name and the `offset_provider` key —
 > plus a fourth, hidden one: the Python variable the `FieldOffset` is bound to.
 > Make the connectivity a **class** that *contains* its local dimension, is its
-> own provider key, and whose identity — like every dimension after
-> [[shared/dimensions-as-types|dimensions as types]] — is its qualified Python
-> name. In the IR it is named by its local dimension's tag, so shifts,
-> reductions and sparse arguments all find the table under one string:
+> own provider key, and whose identity — like every dimension's (ADR 0028) — is
+> its qualified Python name. In the IR it is named by its local dimension's
+> tag, so shifts, reductions and sparse arguments all find the table under one
+> string:
 >
 > ```python
 > class V2E(NeighborConnectivity[V, E]):
@@ -30,24 +30,13 @@ status: draft
 > identity constraints in the current tree, five (A1–A5) dissolve by
 > construction and three (A6–A8) collapse into a single bind-time check.
 
-> **Implementation status (2026-09-23).** Implemented as the stacked
-> GridTools/gt4py PRs listed in [Implementation](#implementation), with
-> ADR 0028 (dimensions as nominal types) and ADR 0029 (connectivities as
-> types). PR 1 is ready for review; PRs 2–8 are drafts. The sections below
-> describe the design **as implemented** on the top branch
-> (`connectivities-as-types-8-typed-positions`), including the review-fix
-> commits on PRs 2–8 that followed a check of this note against the code at
-> `65fa529b6` (2026-09-23); where the implementation had to depart from the
-> original proposal, the text was corrected and the departure is listed in
-> [Where the implementation departs](#where-the-implementation-departs-from-the-original-proposal).
-
-> **Status**: draft, AI-assisted. The *Problem* section and the appendix are
-> derived from a full audit of the gt4py tree at `b3c53fa7e` (v1.2.2,
-> 2026-09-03), i.e. *before* the implementation; their `file:line` references
-> point to that tree, and the two behaviours the proposal leans on hardest were
-> confirmed by *running* them, not by reading. The complete constraint
-> catalogue and concept inventory are in the appendix
-> [[personal/egparedes/connectivities-as-types/connectivities-as-types_research|Tag and name constraints — full catalogue]].
+> **Implementation.** The design below is implemented on the stacked
+> GridTools/gt4py PRs listed in [Implementation](#implementation) (top branch
+> `connectivities-as-types-8-typed-positions`), with ADR 0028 (dimensions as
+> nominal types) and ADR 0029 (connectivities as types). The *Problem* section
+> and the constraint catalogue in the appendix
+> [[personal/egparedes/connectivities-as-types/connectivities-as-types_research|Tag and name constraints — full catalogue]]
+> describe gt4py `main` (`b3c53fa7e`, v1.2.2), the tree the stack is based on.
 > For the type-theoretic background — why the local dimension is owned by the
 > connectivity, and what a Python type can and cannot say about a neighbor
 > table — see
@@ -60,19 +49,24 @@ status: draft
 > It takes no position on chains, reduction order or the path-vs-forest
 > choice, but it does diverge from that proposal's U0/U1 in two places
 > (`min_neighbors` instead of `has_skip_values`; a nested `V2E.Local` instead
-> of a generic `Local[C]`) — see [Open questions / conflicts](#open-questions--conflicts).
+> of a generic `Local[C]`) — see [Open questions](#open-questions--follow-ups).
 > The remap typing it needs is the `Connectivity[NewD, D0]` rule of
 > [[personal/havogt/dimension-generic-fields/dimension-generic-fields|Generic dimensions and statically
-> typed staggering]]. It builds on [[shared/dimensions-as-types|Dimensions as
-> types]] and its implementation in GridTools/gt4py#2844, and **conflicts with
-> one of that proposal's decisions** (identity semantics). It also overlaps
-> with [[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos|A mesh concept with
+> typed staggering]], whose Part II also proposed the `Staggered[D]` shape
+> used here. It **supersedes** [[shared/dimensions-as-types|Dimensions as
+> types]]: the dimension design below (ADR 0028) replaces that note's
+> `(name, kind)` value identity and interning registry with type identity, and
+> is stated here in full. It overlaps with
+> [[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos|A mesh concept with
 > first-class halos]], which proposes replacing the same `offset_provider`
 > dict with a Mesh object; this note re-types the dict and should be read as
 > the typed substrate that proposal can bind through.
 
 ## Problem / motivation
 
+Line references in this section are against gt4py `main` at `b3c53fa7e`
+(v1.2.2, 2026-09-03), relative to `src/gt4py/next/`.
+
 ### Four strings, one dict lookup
 
 To use one connectivity on an unstructured mesh, a user today writes:
@@ -157,29 +151,63 @@ what is one idea — *a mapping between two index spaces, plus a name for it*.
 
 ## Proposal
 
-### Four concepts
+### Concepts
 
 | Concept | Role | Replaces |
 | --- | --- | --- |
 | `DimensionIndex` | a dimension is a subclass, an index along it an instance (ADR 0028) | `Dimension` instances |
-| `LocalDimensionIndex(DimensionIndex)` | a local dimension: **owned** (declared nested in, or adopted by, its connectivity), or **owner-less** (optionally with `size=n`, which sets `max_neighbors = min_neighbors = n`); carries the neighbor counts | `Dimension(..., kind=LOCAL)`, `_CONST_DIM` (now `ConstList`) |
-| `NeighborConnectivity[Origin, Codomain]` | the connectivity **declaration**: shift handle in DSL code and provider key; contains its `Local`; never instantiated, and **not** a `Connectivity` | `FieldOffset`, the `V2EDim` convention |
-| `MultiDimensionIndex[D, *Ls]` | a position in the product of a primary and local dimensions, a tuple of indices; user-facing, nothing in the toolchain requires it | — (new; the iterator-embedded position dicts separately switched from name strings to dimension-class keys) |
-
-The originally proposed `DimensionBaseIndex` root was dropped: `Dimension` is
-`type[DimensionIndex]` and eve validates `type[X]` by `issubclass`, so a sibling
-root would have forced every `type[DimensionIndex]` annotation in the tree to
-widen and then admit local dimensions everywhere anyway. The tree already tells
-local dimensions apart by a runtime `kind` check, and keeps doing so.
-
-`Connectivity` (the runtime data protocol), `CartesianConnectivity`,
-`NeighborTable` / `NdArrayConnectivityField` (the data),
-`NeighborConnectivityType` (the compile-time record) and `ts.OffsetType` (the
-DSL type of a declaration) all **stay**. What changes is that they are
-*produced by* or *checked against* the class instead of being authored in
-parallel with it.
+| `Staggered[D]` | the dimension at the half-integer positions of `D`; a real, interned class (see [`Staggered[D]`](#staggeredd)) | the `_Staggered` name prefix |
+| `LocalDimensionIndex(DimensionIndex)` | a local dimension: **owned** (declared nested in, or adopted by, its connectivity), or **owner-less** (optionally with `size=n`, which sets `max_neighbors = min_neighbors = n`); carries the neighbor counts | `Dimension(..., kind=LOCAL)`, `_CONST_DIM` |
+| `NeighborConnectivity[Domain, Codomain]` | the **static part of a neighbor table's type**: the shift handle in DSL code and the provider key; contains its `Local`; holds no data and is never instantiated | `FieldOffset`, the `V2EDim` convention |
+| `MultiDimensionIndex[D, *Ls]` | a position in the product of a primary and local dimensions, a tuple of indices; user-facing, nothing in the toolchain requires it | — (new; the iterator-embedded position dicts are keyed by dimension classes, not name strings) |
+
+A declaration is not a concept beside the neighbor table: it is the half of
+the table's type that a Python type can express. The "true" type of a local
+index is `Fin<degree(table, v)>` — it depends on the table *value* and on the
+element whose neighbors are visited — and Python types cannot mention values.
+The declaration keeps what a checker, the IR and the fingerprint can see
+(*which* neighbor relation an index belongs to, as the nominal type
+`V2E.Local`, plus the domain, codomain and any declared counts); the bound
+table completes it at each binding ([Binding model](#binding-model)), and the
+value-dependent part becomes a validate-at-the-boundary check whose result is
+reused downstream. The
+[[personal/egparedes/connectivities-as-types/connectivities-as-types_dependent-typing|dependent-typing appendix]]
+develops this with a worked example and lists what is kept, checked and
+given up. The split is what lets DSL code be written, type-checked and
+compiled before any mesh is loaded, and one compiled program serve many
+meshes.
+
+Nothing is an instance of `V2E`: `NeighborConnectivity` is **not** a
+`Connectivity`, and instantiating a declaration raises. The table stays a
+`Connectivity` implementation and is *checked against* the declaration.
+`Field.premap`/`__call__` accept either a table or a declaration, as they
+accepted a `FieldOffset` (which was not a `Connectivity` either).
+
+`LocalDimensionIndex` subclasses `DimensionIndex` rather than a separate
+root: `Dimension` is `type[DimensionIndex]` and eve validates `type[X]` by
+`issubclass`, so a sibling root would force every `type[DimensionIndex]`
+annotation in the tree to widen and then admit local dimensions everywhere
+anyway. The tree tells local dimensions apart by a runtime `kind` check, and
+constructors whose parameter must be a primary dimension
+(`NeighborConnectivity[Domain, Codomain]`, `Staggered[D]`,
+`MultiDimensionIndex`) check that it is not local.
+
+### What stays, and why
+
+The runtime and compile-time connectivity objects of ADR 0019 stay. They are
+*produced by* or *checked against* the declaration instead of being authored
+in parallel with it, and the two that duplicated the declaration are renamed
+and slimmed so that each owns only what the others cannot know:
+
+| Artifact | What it is | Role after this proposal |
+| --- | --- | --- |
+| `Connectivity` | the runtime protocol: a `Field` of integer indices with a `codomain`, which `field(conn)` / `Field.premap` dispatch on | unchanged. It unifies neighbor tables, Cartesian shifts and `as_offset` index fields, so embedded execution has one remap entry point. Essential. |
+| `CartesianConnectivity` | the `Connectivity` behind `I + 1` and `I + 0.5`; carries the ADR 0026 index arithmetic | unchanged. The Cartesian counterpart of a bound table: it needs no declaration and no provider. Essential. |
+| `NeighborTable` / `NdArrayConnectivityField` | the data: a 2-D table over `(Domain, Local)` with values in `Codomain` | unchanged; `check_neighbor_table` checks it against the declaration. Essential. |
+| `NeighborTableType` (was `NeighborConnectivityType`) | the type of a table *bound to a declaration*: `connectivity` (the declaration), `dtype`, `skip_value`, `max_neighbors`; `domain` and `codomain` are derived from the declaration. Built where a table is bound (`check_neighbor_table` returns it; `offset_provider_to_type`) or given directly for ahead-of-time compilation (`table_types`), never authored next to the declaration. A table alone cannot name its declaration — a sharer's table has the owner's domain dims and a different codomain — so the record is built from the provider key: a local dimension records its `owner` and its `sharers`, and the record takes whichever of them the key names. `NeighborTable.__gt_type__()` returns the structural base `ConnectivityType`. A table bound under a name no declaration answers to (hand-written IR) has no declaration: its `connectivity` is then that structural type | what compilation consumes instead of data (ADR 0019), what `compile(table_types=...)` takes when no table exists yet, and what fingerprints a compiled variant (the owner's and a sharer's record over one table fingerprint differently). It owns exactly the facts a declaration may leave open: element dtype, skip-value sentinel and width. Essential; the name says what it types. The base `ConnectivityType` (structural `domain`, `codomain`, `dtype`, `skip_value`) keeps its name and types general connectivity values such as the index field of `as_offset`. |
+| `ts.ShiftType` (was `ts.OffsetType`) | the frontend type of a shift *argument* in DSL code — what `V2E`, `V2E[1]`, `I + 1`, `K + 0.5` and `as_offset(K, f)` type as during FOAST type deduction, and what the lowering reads to emit `OffsetLiteral` / `CartesianOffset`. A `ts.TypeSpec` like `FieldType`, not a description of a connectivity | produced by `V2E.__gt_type__()`; fields `domain` (a tuple: one dimension for Cartesian shifts and `V2E[i]`, two for `V2E`), `codomain` and `tag` (`None` for untagged Cartesian shifts), printed as `Shift[tag: E -> (V, V2E.Local)]`. It carries no counts, dtype or skip value because the frontend never needs them, and it is gone after `foast_to_gtir` reads its `tag`. The literal name `ts.ConnectivityType` is avoided because `common.ConnectivityType` exists; "shift" is the word the note, the frontend errors and users use for `a(V2E)`. The iterator-level `it_ts.OffsetLiteralType` / `it_ts.CartesianOffsetType` keep their names: they type IR literals. |
 
-### Sketch (as implemented)
+### Sketch
 
 ```python
 # ── dimensions (ADR 0028) ─────────────────────────────────────────────────
@@ -189,6 +217,7 @@ class DimensionMeta(type):
         return f"{cls.__module__}.{cls.__qualname__}"
     kind: DimensionKind
     __hash__ = type.__hash__                   # __eq__ stays for `I == 5` -> Domain
+    def __add__(cls, offset: int | float) -> Connectivity: ...   # I + 1, K + 0.5
 
 
 class DimensionIndex(metaclass=DimensionMeta):
@@ -199,6 +228,7 @@ type Dimension = type[DimensionIndex]          # PEP 695: `Dimension("I")` is no
 
 class LocalDimensionIndex(DimensionIndex):     # kind is LOCAL; `kind=LOCAL` elsewhere is an error
     owner: ClassVar[type[NeighborConnectivity] | None]   # None: owner-less; set by the owner
+    sharers: ClassVar[tuple[type[NeighborConnectivity], ...]]   # later declarations over it
     max_neighbors: ClassVar[int | None]        # the counts live here, not on the connectivity
     min_neighbors: ClassVar[int | None]        # min == max  <=>  no skip values
     def __init_subclass__(cls, *, size: int | None = None): ...   # size: max = min = size
@@ -213,23 +243,24 @@ Staggered[KDim]                                # an interned, real dimension cla
 class ConnectivityMeta(type):
     tag: Tag                                   # the declaration's qualified name
     offset_tag: Tag                            # how the IR names it, see "Identity"
-    origin: Dimension; codomain: Dimension     # read from the base subscription
+    domain: Dimension; codomain: Dimension     # read from the base subscription
     def __call__(cls, *a, **kw) -> NoReturn: ...        # no instances
     def __getitem__(cls, item): ...            # V2E[1] = bound_table()[Local(1)] in embedded;
                                                # NC[V, E] forwarded to __class_getitem__
-    def __gt_type__(cls) -> ts.OffsetType: ...  # Codomain -> (Origin, Local), tag=offset_tag
+    def __gt_type__(cls) -> ts.ShiftType: ...   # Shift[offset_tag: Codomain -> (Domain, Local)]
     def bound_table(cls) -> NeighborTable: ... # the table bound in the current embedded run
 
 
-class NeighborConnectivity[Origin: DimensionIndex, Codomain: DimensionIndex](
+class NeighborConnectivity[Domain: DimensionIndex, Codomain: DimensionIndex](
     metaclass=ConnectivityMeta
 ):
-    Local: ClassVar[type[LocalDimensionIndex]]   # annotation only; every subclass declares it
+    # every subclass declares `Local` (a nested class or a TypeAlias); it is
+    # deliberately *not* annotated here, see "The local dimension"
     def __init_subclass__(cls, *, max_neighbors=None, min_neighbors=None): ...
     # writes Local.owner and the counts onto Local; subclassing a declaration is an error
 
 
-def check_neighbor_table(connectivity, table_or_type) -> None: ...   # A6–A8 as one check
+def check_neighbor_table(connectivity, table_or_type) -> NeighborTableType: ...   # A6–A8 as one check
 
 
 # ── user code ──────────────────────────────────────────────────────────────
@@ -263,26 +294,34 @@ program(a, out=out, offset_provider={V2E: v2e_table})
 a(as_offset(KDim, k_offsets))                 # was as_offset(Koff, ...)
 ```
 
-Vocabulary: `Origin` is the dimension the remapped field lives on
-(`conn.domain[0]`), `Codomain` is what the table entries point into
-(`conn.codomain`) — the terms of ADR 0019 and of
-[[personal/havogt/dependent-local-dimensions/dependent-local-dimensions|dependent local dimensions]] §3,
-chosen precisely because `FieldOffset.source`/`target` obscure direction.
+Vocabulary: a declaration is a mapping from one index space to another —
+`Domain` is the dimension it maps from (the dimension a remapped field lands
+on), `Codomain` the dimension its entries point into. A bound table is a
+field over `(Domain, Local)` with values in `Codomain`, i.e. the *table's*
+domain is the declaration's domain extended by the local axis:
+`table.domain.dims == (V2E.domain, V2E.Local)`. `FieldOffset.source`/`target`
+obscured the direction (`source` was the codomain);
+[[personal/havogt/dependent-local-dimensions/dependent-local-dimensions|dependent local dimensions]]
+§3 uses `origin` for the same role, which is avoided here because `origin`
+already names a buffer's origin in gt4py (`__gt_origin__`).
 
 ### Identity is the qualified Python name
 
 A dimension's or connectivity's identity is the Python type; its tag is
 `f"{cls.__module__}.{cls.__qualname__}"` (except `Staggered[D]`, whose tag
 embeds its base's full tag, rule 1; a connectivity is *named in the IR* by its
-`offset_tag`, rule 7). The static view (checkers see
-nominal types) and the runtime view (equality is `is`) agree by
-construction, and the tag is a valid, unique IR string. This is a deliberate
-departure from [[shared/dimensions-as-types|dimensions as types]] and #2844,
+`offset_tag`, rule 7). The static view (checkers see nominal types) and the
+runtime view (equality is `is`) agree by construction, and the tag is a
+valid, unique IR string. This is the point on which this note supersedes
+[[shared/dimensions-as-types|dimensions as types]] and GridTools/gt4py#2844,
 which chose `(name, kind)` value equality plus an interning registry so that
 the test tree's many independently declared `IDim`s stay interchangeable.
-The position taken here: *existing tests that redeclare dummy dimensions can
-be fixed in other ways; they should not constrain the design of the
-concepts.* The consequences, stated as rules:
+Under value equality the `typing` subscription cache aliases
+`Field[Dims[I]] is Field[Dims[I2]]` for two distinct same-named classes, so
+the static and runtime views disagree exactly there; under type identity
+that aliasing disappears. The cost is that the many function-local dummy
+dimensions in `tests/next_tests` move to module level. The consequences,
+stated as rules:
 
 1. **Reconstruction from the IR is an import.** `resolve(tag)` imports the
    longest importable module prefix and walks the rest as attributes (nested
@@ -296,53 +335,104 @@ concepts.* The consequences, stated as rules:
 2. **Types reaching the IR must be importable.** `<locals>` in a qualname is
    rejected at class creation (for dimensions and connectivities); pickle's
    own `save_global` stays the authoritative check. Interactive `__main__`
-   (REPL, notebooks, `python -c`) turned out to matter — every notebook
-   declares its dimensions there — so the process-pool runner
-   (`BUILD_JOBS_MODE=process`) detects a job that references such a class
-   and, with a warning, **compiles it in the calling thread** instead of
-   failing in a spawn worker.
+   (REPL, notebooks, `python -c`) matters — every notebook declares its
+   dimensions there — so the process-pool runner (`BUILD_JOBS_MODE=process`)
+   detects a job that references such a class and, with a warning,
+   **compiles it in the calling thread** instead of failing in a spawn worker.
 3. **No registry.** Classes pickle by reference. One narrow `copyreg` hook
-   remains, for `Staggered[D]`, whose bracketed qualname `save_global` cannot
+   exists, for `Staggered[D]`, whose bracketed qualname `save_global` cannot
    look up; it reduces to the base dimension and re-interns.
 4. **Fingerprints depend on qualified names.** Dimensions are fingerprinted by
    reference (`Staggered[D]` through its base); a connectivity declaration
-   additionally by its origin, codomain, `Local` and counts, so a redefinition
-   under the same name does not reuse artifacts.
+   additionally by its domain, codomain, `Local` and counts, so a redefinition
+   under the same name does not reuse artifacts. Consequently the ADR 0023
+   build cache invalidates on module renames.
 5. **Codegen names need injective mangling.** `codegen_name(tag)` is a prefix
    escape — `_`→`_u`, `.`→`_d`, `[`→`_l`, `]`→`_r` — used by gtfn, DaCe, the
    roundtrip backend and the nanobind bindings; its inverse
-   `from_codegen_name` is used by DaCe to parse names back. The first
-   draft's "escape `__` then replace `.`" was **not** injective (`".."` and
-   `"_"` collide); the prefix escape is tested exhaustively over its alphabet
-   up to length 4.
-6. **Staggering came into scope, and earlier than planned.**
-   `Staggered[D]` is an interning metaclass subscription producing a real
-   class at runtime (a PEP 695 generic would give a `typing` alias, which
-   fails `issubclass` and eve's `type[...]` validation); under
-   `TYPE_CHECKING` it *is* declared as a PEP 695 generic, so checkers accept
-   `Staggered[K]` in annotations. It had to land with the
-   dimension change itself, since the old `_Staggered` name prefix needs a
-   name→class registry.
+   `from_codegen_name` is used by DaCe to parse names back. The simpler
+   "escape `__`, then replace `.`" is **not** injective (`".."` and `"_"`
+   collide); the prefix escape is tested exhaustively over its alphabet up
+   to length 4.
+6. **Staggering is part of the dimension change.** The `_Staggered` name
+   prefix needs the name→class lookup that type identity removes, so
+   `Staggered[D]` is a real class and part of ADR 0028 (PR A); see
+   [`Staggered[D]`](#staggeredd).
 7. **The IR names a connectivity by its `offset_tag`.** That is its local
    dimension's tag when it declares the local dimension: shifts, reductions
-   and sparse arguments then all find the table under **one** string, which
-   made the backends' A3/A4 lookups correct without touching them. A
-   connectivity *sharing* another one's local dimension is named by its own
-   tag, since the local tag already names the owner's table; for that case
-   the backends needed a fallback lookup, `connectivity_key_over` (see *The
-   local dimension*).
+   and sparse arguments then all find the table under **one** string, so the
+   backends' A3/A4 lookups are correct without touching them. A connectivity
+   *sharing* another one's local dimension is named by its own tag, since the
+   local tag already names the owner's table; for that case the backends have
+   a fallback lookup, `connectivity_key_over` (see *The local dimension*).
+8. **Same-named declarations are different connectivities.** Two
+   declarations with the same qualified name from different modules, or a
+   redefinition, are simply different classes; no warning is issued, and
+   `check_neighbor_table` hints "was the declaration redefined?" when a table
+   built for one is bound to the other.
+
+### `Staggered[D]`
+
+A staggered dimension sits at the **half-integer positions** of a base
+dimension (ADR 0026): `Staggered[K](0)` is the point half a cell *below*
+`K(0)`. Cell- and edge-located fields on a Cartesian grid then carry
+different dimensions and cannot be combined by accident. The semantics of
+ADR 0026 — the position convention, the shift rule and the backend treatment
+— are unchanged; what changes is the *encoding*, from a reserved `_Staggered`
+prefix on the dimension name to a class.
+
+- **Runtime representation.** `Staggered[K]` is a real, interned class:
+  `Staggered` has a metaclass whose `__getitem__` builds one class per base
+  and caches it by base identity (with `setdefault`, so concurrent
+  compilation threads see one class). It is deliberately *not* a subclass of
+  `K`, so a `Field[Dims[Staggered[K]]]` is rejected where a `Field[Dims[K]]`
+  is required; it has `base = K` and `K`'s kind. Staggering a local
+  dimension, staggering twice, or subclassing a staggered class directly is a
+  `TypeError`. A PEP 695 generic cannot serve here — it would be a `typing`
+  alias, failing `issubclass` and eve's `type[...]` validation — but under
+  `TYPE_CHECKING` `Staggered` *is* declared as one, so mypy and pyright accept
+  `Staggered[K]` in annotations and in `Field[Dims[Staggered[K]], float]`.
+  `is_staggered`, `flip_staggered` and `as_non_staggered` keep their meaning
+  and read `base`.
+- **Embedded.** `K + 0.5` builds, through `connectivity_for_cartesian_shift`,
+  a `CartesianConnectivity` whose codomain is `flip_staggered(K)`, with the
+  `+1` index correction the position convention requires when shifting *out
+  of* an unstaggered dimension: `K + 0.5` maps `K(i)` to `Staggered[K](i+1)`
+  (position `i+½`), `Staggered[K] + 0.5` maps `Staggered[K](i)` to `K(i)`.
+  The frontend accepts only integer and half-integer literal offsets and
+  types the shift as an `OffsetType` at type-deduction time; statically,
+  `K + 0.5` is a plain `Connectivity`. `check_dims` rejects a dimension and
+  its staggered counterpart in one field or domain, and `order_dimensions`
+  orders by the base, so a staggered field has the layout of its base.
+- **IR and serialization.** The tag is
+  `gt4py.next.common.Staggered[<base tag>]` — the one tag that is not a
+  qualified name. `resolve` parses the `<owner>[<base>]` grammar and
+  subscripts the owner, the IR pretty-parser accepts it, and `codegen_name`
+  escapes the brackets. `pickle` cannot look up a bracketed qualname, so one
+  `copyreg` hook reduces a staggered class to its base and re-subscripts on
+  load; fingerprints are likewise taken through the base.
+- **Backends.** gtfn emits the staggered tag as a C++ alias of its base tag
+  (`_add_staggered_aliases`), since its shift primitive can offset along an
+  axis but not rename it. DaCe names map variables by the base
+  (`as_non_staggered` in `get_map_variable`), so map fusion sees one
+  iteration space for a field and its staggered counterpart.
+
+[[personal/havogt/dimension-generic-fields/dimension-generic-fields|Generic dimensions and statically typed staggering]]
+Part II proposed this `Staggered[D]` shape with the same shift convention.
+Its static involution overloads (typing `Staggered[K] + 0.5` as landing on
+`K` for the checkers) are not part of the stack.
 
 ### Binding model
 
 The connectivity *type* conceptually depends on the *table*: two different
-tables assign different neighbors to the same origin element. The model:
+tables assign different neighbors to the same domain element. The model:
 
-- The class `V2E` is a **declaration**. Its static part — `V2E.origin`,
+- The class `V2E` is a **declaration**. Its static part — `V2E.domain`,
   `V2E.codomain`, `V2E.Local`, and *optionally* the counts
   `V2E.Local.max_neighbors` / `V2E.Local.min_neighbors` (they are stored on
   the local dimension; `V2E.max_neighbors` does not exist) — is what
   compilation sees. Declared counts are a constraint on the table; undeclared
-  ones are simply taken from the bound table's `NeighborConnectivityType` when
+  ones are simply taken from the bound table's `NeighborTableType` when
   a variant is compiled. Binding never writes anything back to the class.
 - Why the counts are not static-only. Two in-tree and in-ICON facts: the
   arity of the same connectivity varies per mesh (`fvm_nabla_setup.py` sizes
@@ -350,9 +440,18 @@ tables assign different neighbors to the same origin element. The model:
   *configuration*-dependent in ICON (`icon.py:130`: pentagon offsets have skip
   values on the icosahedron but not on the torus), so a static `min_neighbors`
   would force duplicate classes or always-on skip handling.
-- A **bound connectivity** is the class plus a table; the provider
-  `{V2E: table}` *is* the binding, and a dict makes one-table-per-class
-  structural.
+- **One table per declaration per binding context.** A binding context is
+  one program or field-operator call, one `compile`, or one embedded
+  context. Within it, the provider `{V2E: table}` binds exactly one table to
+  `V2E` — the dict makes this structural, and `check_offset_provider`
+  verifies it (a tag bound twice, through a class key and a string key, is an
+  error). Across contexts the same declaration may be bound to different
+  tables: tests bind several meshes per process, ICON runs the same
+  declarations on the torus and the icosahedron, and this is what lets one
+  compiled program serve many meshes. The one relaxation is at the
+  local-dimension level: connectivities that *share* a local dimension bind
+  several tables over one local axis in one context, subject to the
+  consistency checks below.
 - **Normalized at the entry points.** `as_tag_keyed_offset_provider`
   rewrites the provider to the form the IR uses, keyed by `offset_tag`. It is
   called *strictly* by `Program.__call__`, `FieldOperator.__call__`,
@@ -364,12 +463,12 @@ tables assign different neighbors to the same origin element. The model:
   string — e.g. `"V2E"`, the removed `FieldOffset` spelling — raises
   `TypeError`; the iterator-level hooks accept any string, since hand-written
   IR names offsets freely. A dotted string is accepted as an
-  already-normalized tag everywhere, and class and string keys can be mixed
-  (binding one tag twice is an error). Lowering, the backends and the
-  compiled-program cache keep seeing tag-keyed providers — like hand-written
-  IR — so the backends' accesses *by connectivity tag* did not change; those
-  keyed by a *local dimension* (reductions, sparse and list arguments) now
-  find the table through `connectivity_key_over`.
+  already-normalized tag everywhere, and class and string keys can be mixed.
+  Lowering, the backends and the compiled-program cache keep seeing
+  tag-keyed providers — like hand-written IR — so the backends' accesses *by
+  connectivity tag* are unchanged; those keyed by a *local dimension*
+  (reductions, sparse and list arguments) find the table through
+  `connectivity_key_over`.
 - **Validated at the boundary.** `check_offset_provider` runs at *every* entry
   point, including the iterator `fendef`, `FieldOperatorFromFoast` and the DaCe
   orchestration's `CompilationOptions.connectivities`. Its result is remembered
@@ -379,7 +478,7 @@ tables assign different neighbors to the same origin element. The model:
   replaced at the same address. Reading the tables — comparing skip positions,
   below — happens only where a program is compiled, not on the call path. It
   calls `check_neighbor_table` per declaration, which checks the domain
-  `(Origin, Local)` and the codomain by class identity (with a hint when a
+  `(Domain, Local)` and the codomain by class identity (with a hint when a
   declaration looks redefined), an integral dtype, `max_neighbors` equal to
   the table's width and `min_neighbors` not above it if declared, and — only
   when `min_neighbors` is declared — that the table has a skip value iff
@@ -395,16 +494,6 @@ tables assign different neighbors to the same origin element. The model:
   attempt in total rather than one per call.
 - The class never holds data; the table crosses process boundaries as it did.
 
-In dependent-typing terms, the "true" type of a local index is
-`Fin<degree(table, v)>`: it depends on the table *value* and on the origin
-element. Python types cannot mention values, so the design keeps the part a
-checker can see — *which* neighbor relation the index belongs to, as the
-nominal type `V2E.Local` — and turns the value-dependent part into a
-validate-at-the-boundary check whose result is reused downstream. The
-[[personal/egparedes/connectivities-as-types/connectivities-as-types_dependent-typing|dependent-typing appendix]]
-develops this with a worked example and lists what is kept, checked and given
-up.
-
 ### The local dimension
 
 - `V2E.Local` **must be given explicitly** in the class body — a nested
@@ -418,10 +507,9 @@ up.
   in the local dimension, is an `arg-type` error, probe P1b), while a `Local`
   generated in `__init_subclass__` and
   annotated `ClassVar[type[LocalDimensionIndex]]` on the base is rejected by
-  both as *not valid as a type* — the very error class
-  [[shared/dimensions-as-types|dimensions as types]] exists to remove. Two
-  lines per connectivity buy a real type; ICON4Py has 16 declarations. Its
-  tag is `<owner tag>.Local`, unique by construction.
+  both as *not valid as a type* — the very error class ADR 0028 exists to
+  remove. Two lines per connectivity buy a real type; ICON4Py has 16
+  declarations. Its tag is `<owner tag>.Local`, unique by construction.
 - `Local` is **not** passed through the base subscription
   (`NeighborConnectivity[V, "V2E.Local", E]`): mypy accepts that string
   forward reference, pyright reports `Class definition for "V2E" depends on
@@ -448,7 +536,8 @@ up.
   rewrites existing `FieldOffset`s without renaming anything. Adopting is *not*
   side-effect free: the adopter becomes the local's `owner` and writes its
   counts onto the module-level class, and ownership is first-come — the first
-  connectivity declared over a local dimension owns it, later ones share it. A
+  connectivity declared over a local dimension owns it, later ones share it and
+  are recorded in its `sharers`. A
   declaration *redefined* under the same tag (a re-run notebook cell) takes
   ownership over again rather than becoming a sharer, and the counts it repeats
   are then checked against the local dimension's own `size=`, not against what
@@ -460,7 +549,7 @@ up.
   `C2CEC`) need exactly this, because their results must combine with
   `C2E`-shaped sparse fields. The
   owner stays the first declaration over the local (here `C2E`); the sharer
-  must have the same origin (its codomain is free), any counts it repeats must
+  must have the same domain (its codomain is free), any counts it repeats must
   equal the owner's, and reductions over the shared axis take the neighbor
   structure from any bound table over it (`connectivity_key_over`: the owner's
   key if bound, else the smallest bound key over that local, which raises
@@ -471,10 +560,11 @@ up.
   widens the plain form to `LocalDimensionIndex`). With the alias, annotations
   may name the local dimension through any of its spellings — `C2CE.Local`,
   `C2E.Local`, `V2EDim` — and they are one type.
-- `max_neighbors` / `min_neighbors` are class keywords, exactly as #2844 does
-  `kind`, and optional (see Binding model). They are *not* type parameters:
-  Python has no integer-valued type parameters, and nothing static needs the
-  count — what must be in the type is *which* local dimension.
+- `max_neighbors` / `min_neighbors` are class keywords, like `kind` on a
+  dimension, and optional (see Binding model). They are *not* type
+  parameters: Python has no integer-valued type parameters, and nothing
+  static needs the count — what must be in the type is *which* local
+  dimension.
 - **Owner-less local dimensions** exist: `class LsqUnk(LocalDimensionIndex, size=3)`
   has `owner = None`, `min == max == size`, no skip values, and never appears
   in the provider — unless a connectivity later adopts it, which makes it
@@ -510,22 +600,20 @@ up.
   one* local index, and an owned local dimension must index the neighbors of the
   primary index's dimension — `MultiDimensionIndex(Edge(1), V2E.Local(1))` is a
   `TypeError`, since `V2E` indexes the neighbors of a vertex. An owner-less
-  local axis (`LsqCoeff`) is accepted next to any primary dimension.
-- The original note also made it "the domain index of a
-  `NeighborConnectivity`", i.e. `Connectivity[MultiDimensionIndex[Origin,
-  Local], Codomain]`. That was dropped with the decision that a declaration is
-  not a `Connectivity` (see Open question 6).
+  local axis (`LsqUnk`) is accepted next to any primary dimension.
+- It is a position in a *table*, not in a declaration: a declaration is not a
+  `Connectivity` and cannot be indexed.
 - The iterator-level embedded execution keys its positions by dimension
   classes instead of tag strings and steps along a local dimension with an
   explicit `SparseAxis(dim)`; `SparseTag` is gone.
 
 ### Effect per layer
 
-| Layer | Before | As implemented |
+| Layer | Before | After |
 | --- | --- | --- |
 | Frontend declaration | `Dimension(LOCAL)` + `FieldOffset` + provider key | one class |
-| Frontend types | `ts.OffsetType(source, target)`, tag dropped | `ts.OffsetType` produced by the class (`__gt_type__`), its `tag` field (added in PR 1) set to `offset_tag`; `V2E.Local` in DSL code types as the local dimension |
-| FOAST → GTIR | shift tag = **Python variable name** | tag = `offset_tag`; the variable name is irrelevant (fixed first, as PR 1) |
+| Frontend types | `ts.OffsetType(source, target)`, tag dropped | `ts.ShiftType(domain, codomain, tag)` produced by the class (`__gt_type__`), `tag` set to `offset_tag`; `V2E.Local` in DSL code types as the local dimension |
+| FOAST → GTIR | shift tag = **Python variable name** | tag = `offset_tag`; the variable name is irrelevant (PR 1) |
 | ITIR | `OffsetLiteral(str)` + dict lookup; `AxisLiteral(value, kind)` | `OffsetLiteral(offset_tag)`, unchanged node; `AxisLiteral(value)` with `kind` derived |
 | ITIR types | `ListType.offset_type: Dimension` | unchanged (already the local dim) |
 | Embedded field | `get_offset(provider, axis.value)` | table over the local dimension (`connectivity_key_over`); `V2E.bound_table()` |
@@ -533,7 +621,7 @@ up.
 | gtfn | `dim.value` lookups; `TagDefinition` per tag and per `neighbor_dim` | still a `TagDefinition` per offset tag (and per differing `neighbor_dim`, i.e. for sharers), named by `codegen_name(tag)`; sparse-argument lookups through `connectivity_key_over` |
 | DaCe | ~10 `offset_type.value` lookups; `Dimension(offset, LOCAL)` synthesized | `codegen_name` for array/symbol names; `connectivity_key_over`; a local dimension sized from its own table (`local_dimension_size`); no synthesis |
 | roundtrip backend | emits `gtx.Dimension("<name>")` / `offset("<tag>")` as source text | emits `<mangled> = gtx.resolve("<tag>")` for axes and `<mangled> = offset("<tag>")` for offsets |
-| Provider | `Mapping[str, NeighborTable]` | public: `{V2E: table}` (a dotted tag string is also accepted; the type stays `Mapping[Any, …]`); internal: keyed by `offset_tag`, normalized at the entry points; no deprecation window (a migration script for ICON4Py instead) |
+| Provider | `Mapping[str, NeighborTable]`; `offset_provider_type: Mapping[str, NeighborConnectivityType]` | public: `{V2E: table}`, and `table_types={V2E: NeighborTableType(...)}` (`TableTypesLike`, normalized to `TableTypes = Mapping[Tag, NeighborTableType]`) for ahead-of-time compilation (a dotted tag string is also accepted; the type stays `Mapping[Any, …]`); internal: keyed by `offset_tag`, normalized at the entry points; no deprecation window (a migration script for ICON4Py instead) |
 
 ### What it deletes
 
@@ -544,18 +632,18 @@ grammar); `_CONST_DIM` as a magic name; the stored `AxisLiteral.kind`;
 `SparseTag`; `NamedIndex` and the dimension half of the mypy plugin;
 `DimensionIndex(kind=LOCAL)` as a way to declare a local dimension; and the
 convention that `V2EDim = Dimension("V2E", LOCAL)` must sit next to
-`V2E = FieldOffset("V2E", ...)`. **Not adopted** from #2844 (they were never
-on `main`): `dimension(tag, kind)`, the interning registry and the general
-`copyreg` hook (only a narrow one for `Staggered[D]` exists).
-
-**Kept**, contrary to the original note: `ts.OffsetType` (it types
-declarations, `V2E[i]`, Cartesian `Dim ± i` and `as_offset`; renaming it to
-`ConnectivityType` would be churn without a user-visible gain), `iterator.runtime.offset("...")` (the
-iterator-level API names offsets by string, like the IR), and string-keyed
-providers *below* the entry points.
-
-The Cartesian `FieldOffset` went in the same PR as the unstructured one:
-Cartesian shifts were already `Dim + i`, and `as_offset` now takes the
+`V2E = FieldOffset("V2E", ...)`; the names `ts.OffsetType` (now
+`ts.ShiftType`, with `domain`/`codomain` instead of the inverted
+`source`/`target`), `NeighborConnectivityType` (now `NeighborTableType`) and
+the parameter `offset_provider_type` (now `table_types`).
+
+**Kept**: `ts.ShiftType` and the runtime connectivity objects (see
+[What stays, and why](#what-stays-and-why)); `iterator.runtime.offset("...")`
+(the iterator-level API names offsets by string, like the IR); and
+string-keyed providers *below* the entry points.
+
+The Cartesian `FieldOffset` goes together with the unstructured one:
+Cartesian shifts were already `Dim + i`, and `as_offset` takes the
 dimension, `as_offset(KDim, field)`.
 
 ### Relation to `Local[V2E]`
@@ -584,22 +672,23 @@ static encoding is.
 **Keep every concept; fix only which string wins.** Emit `FieldOffset.value`
 instead of `foast.Name.id` in `foast_to_gtir`, validate `value == target[-1].value`
 eagerly, extend the #1789 regression test. Two PRs, low risk — and the
-`foast_to_gtir` part is a real bug that should land regardless. But it
-*enforces* the tangle rather than removing it; no concept goes away.
+`foast_to_gtir` part is a real bug that is fixed regardless (PR 1).
+But it *enforces* the tangle rather than removing it; no concept goes away.
 
 **A declaration object with a derived local dimension, keeping `Dimension`
-instances** (the "Option B" that led here). Same shape as this proposal minus
-static typing and minus type identity: `local_dim.value == name` by
-construction, provider keyed by the declaration object. Superseded by
-building on dimensions-as-types instead: once dimensions are classes, the
-nested-class form is both simpler and statically meaningful.
-
-**`(name, kind)` value equality with an interning registry** (the #2844
-design). Keeps independently declared same-named dimensions interchangeable
-and avoids the importability rule. Rejected here because it decouples the
-Python type's identity from the IR's, needs a registry plus `copyreg` plus a
-custom fingerprint deconstructor to paper over that gap, and cannot give a
-nested `V2E.Local` a unique name without further convention. See conflicts.
+instances.** Same shape as this proposal minus static typing and minus type
+identity: `local_dim.value == name` by construction, provider keyed by the
+declaration object. Superseded by building on dimensions as types instead:
+once dimensions are classes, the nested-class form is both simpler and
+statically meaningful.
+
+**`(name, kind)` value equality with an interning registry** (the design of
+[[shared/dimensions-as-types|dimensions as types]] and GridTools/gt4py#2844).
+Keeps independently declared same-named dimensions interchangeable and
+avoids the importability rule. Rejected because it decouples the Python
+type's identity from the IR's, needs a registry plus `copyreg` plus a custom
+fingerprint deconstructor to paper over that gap, and cannot give a nested
+`V2E.Local` a unique name without further convention. See *Identity*.
 
 **Integer type parameters for `max_neighbors`** (`LocalDimensionIndex[F: int, M: int]`).
 Would need `Literal[6]` type arguments and `Final[F]` over a `TypeVar`;
@@ -631,162 +720,78 @@ are distinct types for every checker (probe P3); see Relation to `Local[V2E]`.
 become domain dimensions with a range in every program domain and lose the
 sparse storage treatment, changing ICON4Py's layout for `LsqUnkDim` fields.
 
-## Open questions / conflicts
-
-**Conflicts, stated explicitly:**
-
-- **[[shared/dimensions-as-types|Dimensions as types]] / #2844 — identity
-  semantics.** That proposal decides `(name, kind)` equality, an interning
-  factory (`Dimension("I") is Dimension("I")`), and a value-based
-  `__reduce__`. Its reasons are concrete and should be weighed, not waved
-  away: `tests/next_tests` declares a dimension named `"I"` 46 times and
-  `IDim` in 45 files (its Step 0); ADR 0028 records that nominal identity
-  "changes the meaning of `Dimension("I") == Dimension("I")`, which downstream
-  code relies on"; and its "first declaration wins" residual means
-  `Dimension("I") is <some module's I>` is already *not* guaranteed today.
-  This proposal reverses all three decisions in favour of type identity. One
-  argument in its favour that the shared note itself raises as a known
-  residual: under `(name, kind)` equality the `typing` subscription cache
-  aliases `Field[Dims[I]] is Field[Dims[I2]]` for two distinct same-named
-  classes, so the static and runtime views disagree exactly there; under type
-  identity that aliasing disappears. If accepted, `shared/dimensions-as-types.md`
-  needs a revision and #2844 should stop hardening the registry and `copyreg`
-  paths. The test-tree consequence is real: the many function-local dummy
-  dimensions in `tests/next_tests` must move to module level (a larger sweep
-  than #2845).
-- **ADR 0028 / #2844 (fingerprinting of dimensions).** #2844 adds a
-  `(tag, kind)` fingerprint deconstructor; under type identity dimensions are
-  fingerprinted by qualified name instead, and ADR 0023's cache invalidates
-  on module renames. A consequence to record in the new ADR.
-- **[[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos|A mesh concept with
-  first-class halos]].** Proposes replacing the `offset_provider` dict with a
-  Mesh object and keeps `Koff`/`LsqUnkDim` outside it. This note re-types the
-  same dict. The two are compatible if the Mesh binds typed connectivity
-  classes to tables, but that has to be said in one of the two documents,
-  and the multi-table case (halo variants, rewritten `keep_skip_values`
-  tables, several meshes in one process) is addressed by neither yet.
-- **ADR 0026 (Staggered dimensions).** The `_Staggered` name prefix cannot
-  survive type identity; `Staggered[D]` is required, not optional
-  (implemented in PR 2).
-- **ADR 0019 (Connectivities).** The part naming `FieldOffset` as the
-  frontend identifier is superseded (by ADR 0029); the `Connectivity` /
-  `NeighborTable` / `ConnectivityType` vocabulary is kept.
-- **[[personal/havogt/closure-variable-resolution|Closure variable
-  resolution]].** The N2 leak (Python variable name becoming the IR tag) is a
-  closure-variable-resolution bug in `foast_to_gtir`; that proposal's
-  resolution mechanism should be the vehicle for the fix.
-
-**Open questions, and how the implementation answered them:**
-
-1. **Naming.** Implemented with `NeighborConnectivity[Origin, Codomain]`,
-   `Local`, `max_neighbors` / `min_neighbors`, and `offset_tag` for the IR
-   name. Convergence with
+**A `PEP 695` generic for `Staggered[D]`.** Rejected: the subscription would
+be a `typing` alias, not a class, failing `issubclass` and eve's `type[...]`
+validation and unable to carry a tag. The metaclass subscription builds a
+real class; the PEP 695 form is used only under `TYPE_CHECKING`.
+
+## Relation to gt4py ADRs
+
+- **ADR 0019 (Connectivities).** The part naming `FieldOffset` as the frontend
+  identifier is superseded by ADR 0029; the `Connectivity` / `NeighborTable` /
+  `ConnectivityType` vocabulary is kept ([What stays](#what-stays-and-why)).
+- **ADR 0026 (Staggered dimensions).** Its encoding is superseded by
+  `Staggered[D]` ([above](#staggeredd)); its semantics are unchanged.
+- **ADR 0028 (Dimensions as nominal types)** and **ADR 0029 (Connectivities
+  as types)** record this design in the gt4py tree.
+- **ADR 0023 (build cache).** Fingerprints depend on qualified names, so the
+  cache invalidates on module renames (Identity, rule 4).
+
+## Open questions / follow-ups
+
+1. **Naming.** `NeighborConnectivity[Domain, Codomain]`, `Local`,
+   `max_neighbors` / `min_neighbors`, and `offset_tag` for the IR name.
+   Convergence with
    [[personal/havogt/dependent-local-dimensions/dependent-local-dimensions|dependent local dimensions]]
    (`Dim`, `has_skip_values`, `source_dim`/`neighbor_dim`) is still to be
-   discussed on the PRs; the names are public from PR 3 on.
-2. **How `Local` reaches the base.** `NeighborConnectivity.__init_subclass__`
-   reads `cls.__dict__["Local"]` after the class body, with a `ClassVar`
-   annotation on the base (3.12-compatible). A PEP 696 default type parameter
-   was not needed.
-3. **`__main__` in spawn workers.** Detected: under the process-pool runner,
-   jobs referencing a class of an interactive `__main__` are compiled in the
-   calling thread, with a warning.
-4. **ICON4Py migration.** `scripts/python/migrate_connectivities.py` rewrites
-   `Dimension(...)` and `FieldOffset(...)` declarations (connectivities adopt
-   their existing local dimensions, so `C2EDim` etc. keep working and `C2CE`
-   becomes a sharer), removes Cartesian offsets and rewrites their uses
-   (`Koff[1]` → `KDim + 1`, `as_offset(KDim, ...)`, imports), and reports
-   what it cannot decide from the source. The counts depend on the ICON4Py
-   revision, so GridTools/gt4py#2910 quotes a pinned one: at ICON4Py
-   `89b4967` (2026-09-21), after ICON4Py had already dropped `Koff[1]`, the
-   script rewrites 4 files (`dimension.py` and 3 stencil modules) and reports
-   46 connectivity provider keys, 2 removable Cartesian provider entries and 10
-   `isinstance(..., Dimension)` sites in 5 modules. Declaring counts is left to
-   ICON4Py.
-5. **Duplicate declarations** (two same-named declarations from different
-   modules, or a redefinition). No warning was added; being different
-   classes, they are simply different connectivities, and
-   `check_neighbor_table` hints "was the declaration redefined?" when a table
-   built for one is bound to the other.
-6. **What is an instance of `V2E`?** Nothing: `NeighborConnectivity` is **not**
-   a `Connectivity`, and instantiating a declaration raises. The table stays a
-   `Connectivity` implementation and is *checked against* the declaration.
-   `Field.premap`/`__call__` accept either a table or a declaration, as they
-   accepted a `FieldOffset` (which was not a `Connectivity` either).
-7. **New: connectivities sharing a local dimension** (raised by the review of
-   the test-tree migration): needed for ICON4Py's flattened sparse offsets;
-   answered by adopting an owned `Local` and naming the sharer by its own tag.
+   discussed on the PRs; the names become public API in PR B.
+2. **The mesh proposal.**
+   [[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos|A mesh concept with
+   first-class halos]] keeps `Koff`/`LsqUnkDim` outside the Mesh object and
+   replaces the same `offset_provider` dict this note re-types. The two are
+   compatible if the Mesh binds typed connectivity classes to tables, but
+   that has to be said in one of the two documents, and the multi-table case
+   (halo variants, rewritten `keep_skip_values` tables, several meshes in one
+   process) is addressed by neither yet.
+3. **Closure variable resolution.** The N2 leak (Python variable name
+   becoming the IR tag) is fixed in `foast_to_gtir` (PR 1); the resolution
+   mechanism of
+   [[personal/havogt/closure-variable-resolution|Closure variable resolution]]
+   would be its natural home.
+4. **Chain proposals.** Their static encodings need rewriting to `C.Local`
+   ([Relation to `Local[V2E]`](#relation-to-localv2e)).
 
 ## Implementation
 
-A stack of GridTools/gt4py PRs, each green in CI on its own. It is an
-alternative to #2844 (which implemented `(name, kind)` value identity) that
-takes over the parts of #2844 compatible with type identity. The one
-substantive review so far (on #2899) prefers this approach over #2844 but
-raises the churn and the long qualified names.
+GridTools/gt4py#2898 (merged 2026-09-23) fixed the N2 leak first: unstructured
+shifts lower with the offset's own tag, shift lowering is type-driven so
+module-qualified offsets (`a(mod.V2E)`) work, and a regression matrix
+{shift, `neighbor_sum`} × {tag ≠ variable name, tag ≠ local-dimension name}
+guards it. The rest is a stack of four GridTools/gt4py PRs, each green in CI
+on its own, each based on the previous one:
 
-| # | PR | What |
+| PR | Branch | What |
 | --- | --- | --- |
-| 1 | GridTools/gt4py#2898 | `fix[next]`: lower unstructured shifts with the offset's own tag (the N2 leak); adds `ts.OffsetType.tag` and makes shift lowering type-driven, so module-qualified offsets (`a(mod.V2E)`) work (supersedes #2730); regression matrix {shift, `neighbor_sum`} × {tag ≠ variable name, tag ≠ local-dimension name}. A later review commit (`25f7a32c4`, 2026-09-23) reports invalid shift arguments as located `DSLError`s; it is not yet in PRs 2–8, and #2899 currently conflicts |
-| 2 | GridTools/gt4py#2899 | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0028); `codegen_name`; `Staggered[D]`; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; the one-string invariant pulled forward (`FieldOffset(V2EDim.tag, ...)`, `{V2EDim.tag: table}`) |
-| 3 | GridTools/gt4py#2907 | `feat[next]`: `NeighborConnectivity`, `LocalDimensionIndex`, `check_neighbor_table`, declaration fingerprinting; usable in the DSL; shared local dimensions; ADR 0029 |
-| 4 | GridTools/gt4py#2908 | `feat[next]`: the test tree and docs declare connectivities as classes; iterator-embedded `shift`/`neighbors` accept them; `DimensionIndex(kind=LOCAL)` rejected; two-target `FieldOffset` deprecated |
-| 5 | GridTools/gt4py#2909 | `feat[next]`: backends support connectivities sharing a local dimension (`connectivity_key_over`, DaCe `local_dimension_size`); lifts PR 1's xfails |
-| 6 | GridTools/gt4py#2910 | `feat[next]!`: class-keyed offset providers; `FieldOffset` removed; `as_offset(dim, field)`; migration script |
-| 7 | GridTools/gt4py#2911 | `refactor[next]`: the `ConstListDim` class (from PR 2) becomes `ConstList` with `size=1`, replacing the `_CONST_DIM` aliases by identity checks; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`) |
-| 8 | GridTools/gt4py#2912 | `refactor[next]`: `MultiDimensionIndex` and typed embedded positions |
-
-Each of PRs 2–8 carries a follow-up commit applying an independent review of
-this note against the code (the "review fixes" commits). The behaviour they
-changed is described above; in outline: `Local` is annotated nowhere, so it
-stays a type for pyright as well as mypy, and `common.local_dimension_of` is
-the accessor for library code (PR 3); adoption and sharing are written
-`Local: TypeAlias = ...`, and the `make_const_list` dimension cannot be adopted
-(PRs 3, 4, 6); a redefined declaration re-owns an adopted local dimension
-(PR 3); `check_offset_provider` runs at every entry point, is memoized per set
-of bound tables and reads the tables only where a program is compiled, and a
-key naming the connectivity rather than the declaration is rejected (PR 6);
-`MultiDimensionIndex` requires a local index and checks it against the primary
-dimension (PR 8); a dimension cannot be staggered twice and staggered classes
-are interned thread-safely (PR 2); pyright runs in the typing nox session
-(PR 3).
-
-### Where the implementation departs from the original proposal
-
-- **No `DimensionBaseIndex`**; `LocalDimensionIndex` subclasses
-  `DimensionIndex`. Generic constructors whose parameter must be a primary
-  dimension (`NeighborConnectivity[Origin, Codomain]`, `Staggered[D]`,
-  `MultiDimensionIndex`) check at runtime that it is not local.
-- **`NeighborConnectivity` is not a `Connectivity`** (Open question 6), so
-  `MultiDimensionIndex` is not the domain index of a declaration.
-- **The IR names a connectivity by its local dimension's tag** (its
-  `offset_tag`), not by the connectivity's own tag, and **internal providers
-  stay keyed by that string**; the public API takes classes (and still
-  accepts dotted tag strings). This made
-  the originally planned "backends resolve through `Local.owner`" step
-  unnecessary — with one string per connectivity, going through `owner`
-  changes nothing.
-- **Shared local dimensions** were not in the proposal and turned out to be
-  needed (ICON4Py's flattened offsets). They reintroduce an offset tag that
-  differs from its local dimension's tag, for which the backends got
-  `connectivity_key_over`.
-- **`Staggered[D]` had to land with the dimension change**, not later, and it
-  is an interning metaclass subscription, not a PEP 695 generic; a narrow
-  `copyreg` hook remains for it.
-- **Codegen mangling** is a prefix escape (`_u`, `_d`, `_l`, `_r`); the
-  proposed "escape `__` then replace `.`" is not injective.
-- **Interactive `__main__`** is handled (in-process compilation), not merely
-  documented.
-- **`ts.OffsetType` and `iterator.runtime.offset` are kept**; providers stay
-  string-keyed below the entry points.
-- **The one-string invariant** (offset tag = local dimension tag = provider
-  key) was pulled forward into the dimension PR: once tags became qualified
-  names, most test-tree local dimensions stopped matching their offsets' tags.
-- **Staging**: the proposal's step 2 bundled the declaration migration, the
-  provider key change and the removals; they had to be separate to stay green
-  (declarations first, class keys last).
-- **Adopting a module-level local dimension** mutates it (owner and counts);
-  the proposal treated adoption as a pure renaming aid.
+| A: GridTools/gt4py#2899 | `connectivities-as-types-2-dimension-classes` | `feat[next]`: a concrete dimension is a class identified by its qualified name (ADR 0028); `codegen_name`; `Staggered[D]`; interactive-`__main__` fallback; `NamedIndex` and the dimension half of the mypy plugin removed; `ConstList` with `size=1` replaces the `_CONST_DIM` aliases; `AxisLiteral` drops `kind`; printing IR never imports (`resolve_loaded`); offset tag = local dimension tag = provider key in the tree |
+| B: GridTools/gt4py#2907 | `connectivities-as-types-3-neighbor-connectivity` | `feat[next]`: `NeighborConnectivity[Domain, Codomain]`, `LocalDimensionIndex`, `check_neighbor_table`, `local_dimension_of`, declaration fingerprinting; usable in the DSL; shared local dimensions, in the declarations and in the backends (`connectivity_key_over`, DaCe `local_dimension_size`); `NeighborTableType` and `ts.ShiftType`; pyright in the typing nox session; ADR 0029 |
+| C: GridTools/gt4py#2910 | `connectivities-as-types-6-class-keyed-providers` | `feat[next]!`: the tree and docs declare connectivities as classes; class-keyed offset providers with `check_offset_provider` at every entry point; `FieldOffset` removed; `as_offset(dim, field)`; `table_types` replaces `offset_provider_type`; migration script |
+| D: GridTools/gt4py#2912 | `connectivities-as-types-8-typed-positions` | `refactor[next]`: `MultiDimensionIndex` and typed embedded positions |
+
+The four PRs form GitHub stack GridTools/gt4py#2917. #2908 (absorbed by C),
+#2909 (absorbed by B) and #2911 (absorbed by A) are closed. `Domain`,
+`NeighborTableType`, `TableTypes` and `ts.ShiftType` land in B; `table_types`
+in C; ADR 0028 and ADR 0029 are in A and B respectively.
+
+**ICON4Py migration.** `scripts/python/migrate_connectivities.py` (PR C)
+rewrites `Dimension(...)` and `FieldOffset(...)` declarations (connectivities
+adopt their existing local dimensions, so `C2EDim` etc. keep working and
+`C2CE` becomes a sharer), removes Cartesian offsets and rewrites their uses
+(`Koff[1]` → `KDim + 1`, `as_offset(KDim, ...)`, imports), and reports what
+it cannot decide from the source. At ICON4Py `89b4967` (2026-09-21) the
+script rewrites 4 files (`dimension.py` and 3 stencil modules) and reports 46
+connectivity provider keys, 2 removable Cartesian provider entries and 10
+`isinstance(..., Dimension)` sites in 5 modules. Declaring counts is left to
+ICON4Py.
 
 ## Appendices
 
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_dependent-typing.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_dependent-typing.md
index 4cc3f76..537cd95 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_dependent-typing.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_dependent-typing.md
@@ -209,7 +209,7 @@ wrappers offer part of this discipline in ordinary languages.
 | `NeighborOrder<g>` — the enumeration | a `NeighborTable` / `NdArrayConnectivityField` | unchanged: the table *is* the enumeration |
 | `(v : Vert<g>) -> Fin<degree(g, v)> -> double` — slot-addressed field | `Field[Dims[V, V2EDim], float]` | `Field[Dims[V, V2E.Local], float]` |
 | `Incidence<g>` — a Σ-typed position | an untyped `{"Vertex": 3, "V2E": 2}` dict | `MultiDimensionIndex(V(3), V2E.Local(2))`; checked at run time that `V2E.Local` indexes the neighbors of a `V` (the dependency of the second component on the first, but not on the value `3`) |
-| the graph value `g` in the signature | a string-keyed `offset_provider` | a bound connectivity: `{V2E: table}` binds the class to one table per call |
+| the graph value `g` in the signature | a string-keyed `offset_provider` | a bound connectivity: `{V2E: table}` binds the class to one table per binding context |
 | `GraphPackage` — graph plus checked operations | — | the provider after `check_offset_provider` (and, in [[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos\|the mesh proposal]], a Mesh object) |
 | validate at the boundary, reuse evidence | no check; errors surface as `KeyError` or wrong results | `check_offset_provider` at every entry point, remembered per set of bound tables, then trusted by lowering and backends |
 
@@ -229,7 +229,7 @@ wrappers offer part of this discipline in ordinary languages.
   relations enumerating it.
 - **A brand per mesh entity (§7).** Nominal identity makes two independently
   declared `Vertex` classes distinct types, statically and at run time. The
-  `(name, kind)` equality of [[shared/dimensions-as-types|dimensions as types]]
+  `(name, kind)` equality of the superseded [[shared/dimensions-as-types|dimensions as types]]
   is the unbranded `Fin<g.nV>` of §7: equal names, interchangeable indices.
   Nominal identity is not sufficient to separate two *meshes* that share the
   same declarations, though — see below.
@@ -240,12 +240,12 @@ Python has no value-indexed types, so the dependency on the table value `g`
 cannot be expressed. The design splits the connectivity type the way §4
 splits data from evidence:
 
-- The **class** `V2E` is the static, erasable part: `Origin`, `Codomain`,
+- The **class** `V2E` is the static, erasable part: `Domain`, `Codomain`,
   `Local` and, optionally, the declared counts. It is what the frontend and the
   type checker see.
-- The **table** is the value `g`. Binding happens per call through the
+- The **table** is the value `g`. Binding happens per binding context through the
   provider (`{V2E: table}`), and `check_neighbor_table` is the "checked
-  decision" of §8: it establishes that the table's domain is `(Origin, Local)`,
+  decision" of §8: it establishes that the table's domain is `(Domain, Local)`,
   its codomain `Codomain`, its dtype integral, its width equal to a declared
   `max_neighbors` and not below a declared `min_neighbors`, and — if
   `min_neighbors` is declared — its skip values consistent with it.
@@ -266,10 +266,10 @@ splits data from evidence:
   representation of §6. `min_neighbors == max_neighbors` is exactly the
   uniform-degree case, which is why it is equivalent to "no skip values".
 - **Same type ⇒ same table (§7).** `V2E` does not identify a mesh. Two
-  different tables bound to `V2E` in two calls give two different, both
-  well-typed, programs. This is deliberate — it is what lets one DSL source run
-  on several meshes — and the one-table-per-class-per-call dict keeps it from
-  becoming ambiguous *within* a call. Guarding against mixing meshes across
+  different tables bound to `V2E` in two binding contexts give two different,
+  both well-typed, programs. This is deliberate — it is what lets one DSL
+  source run on several meshes — and the one-table-per-declaration dict keeps
+  it from becoming ambiguous *within* a context. Guarding against mixing meshes across
   calls (e.g. a field computed on mesh A consumed on mesh B) is out of scope;
   it would need a mesh-level brand, which is where
   [[personal/havogt/mesh-and-first-class-halos/mesh-and-first-class-halos|a mesh concept]]
@@ -278,8 +278,8 @@ splits data from evidence:
 ### The enumeration consequence: shared local dimensions
 
 §6's warning — slot-addressed values are only meaningful relative to one
-enumeration — is the reason for the one genuinely new rule the implementation
-added. `C2CE` (cell → flattened (cell, edge-of-cell) pairs) *shares*
+enumeration — is the reason for the shared-local-dimension rule, the one
+relaxation of "one table per declaration per binding context". `C2CE` (cell → flattened (cell, edge-of-cell) pairs) *shares*
 `C2E.Local` so that its results combine with `C2E`-shaped sparse fields.
 Sharing a slot type across two connectivities is only sound if both tables
 enumerate each cell's fiber in the same order and pad it in the same places.
diff --git a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_research.md b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_research.md
index 0d6179f..83404fa 100644
--- a/content/personal/egparedes/connectivities-as-types/connectivities-as-types_research.md
+++ b/content/personal/egparedes/connectivities-as-types/connectivities-as-types_research.md
@@ -13,9 +13,8 @@ status: draft
 > implementation as it is; the proposal it supports is in the main note.
 
 Line references are against gt4py `main` at `b3c53fa7e` (v1.2.2, 2026-09-03),
-i.e. the tree *before* the implementation (see the main note's Implementation
-section), so this catalogue is a historical record. Paths
-are relative to `src/gt4py/next/` unless they start with `tests/`.
+the tree the PR stack in the main note's Implementation section is based on.
+Paths are relative to `src/gt4py/next/` unless they start with `tests/`.
 
 Related gt4py records:
 [ADR 0019 Connectivities](https://github.com/GridTools/gt4py/blob/main/docs/development/ADRs/next/0019-Connectivities.md),
diff --git a/content/personal/egparedes/connectivities-as-types/typing_probe.py b/content/personal/egparedes/connectivities-as-types/typing_probe.py
index 1bf5ff1..fcc74dd 100644
--- a/content/personal/egparedes/connectivities-as-types/typing_probe.py
+++ b/content/personal/egparedes/connectivities-as-types/typing_probe.py
@@ -10,9 +10,9 @@
 string forward reference in the base subscription, which is why the proposal does
 not pass `Local` through the bases.
 
-`StaticMultiLevelMapping` is scaffolding from an early draft that stored the table
-on the class (rejected, see "Data on the class" in the main note); only the probes
-at the end matter. Last run: mypy 2.3.1 and pyright 1.1.414 (2026-09-23).
+`StaticMultiLevelMapping` is a stand-in that stores the table on the class, which the
+design rejects (see "Data on the class" in the main note); only the probes at the
+end matter. Last run: mypy 2.3.1 and pyright 1.1.414 (2026-09-23).
 """
 
 from __future__ import annotations
diff --git a/content/shared/dimensions-as-types.md b/content/shared/dimensions-as-types.md
index c995bae..329c897 100644
--- a/content/shared/dimensions-as-types.md
+++ b/content/shared/dimensions-as-types.md
@@ -4,9 +4,16 @@ description: "Make a concrete gt4py.next dimension a type (`class I(gtx.Dimensio
 author: havogt
 tags: [type-system, dimensions, type-checking, mypy, mypy-plugin, pyright, nominal-types, metaclass, migration, serialization, frontend, foast, extension-point]
 created: 2026-08-05
-status: proposed
+status: superseded
 ---
 
+> **Superseded** by
+> [[personal/egparedes/connectivities-as-types/connectivities-as-types|Connectivities as types]]
+> (gt4py ADR 0028, GridTools/gt4py#2899), which makes a dimension a class with
+> *type* identity (its qualified name) instead of the `(name, kind)` value
+> identity and interning registry proposed here. Kept for reference until that
+> proposal moves to `shared/`.
+
 > **TL;DR** A concrete dimension is currently an *instance*
 > (`I = Dimension("I")`), so `Field[Dims[I], float64]` is not a valid static
 > annotation and gt4py ships a mypy plugin to paper over it. Make a dimension a