From 0b5a8d110f19bd5fd38b04458379a351b321146f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ricardo=20Gro=C3=9F?= <ricardo@mr-gross.de>
Date: Tue, 22 Sep 2026 20:54:10 +0200
Subject: [PATCH 1/3] fix: render JSON-member index parts as Npgsql's queries
 do; open 5.4.0

PostgreSQL uses an expression index only for a query whose expression
matches it. Every JSON member was rendered as "doc" -> 'A' ->> 'B' text
with no cast, which matched Npgsql's query translation only for a
top-level string: indexes on nested members (#>> '{A,B}' in the query)
or typed members (CAST(... AS integer)) applied, enforced uniqueness and
served no query. Members now render exactly as NpgsqlQuerySqlGenerator
renders them (identical in Npgsql 10 and 11), in index parts, typed
expression indexes and index filters.

Parts are resolved at diff time on both sides, so a rendering change
alone never produces a migration. Every declaration now writes
CustomIndex:RenderingVersion onto the model; a snapshot without it is
rendered by the old rules, which turns the fix into one drop-and-create
per affected index. Default names come from the path (NameToken), and
ResolvedIndexPart equality ignores the derived metadata, so nothing is
renamed or rebuilt without a reason. Exclusion constraint filters keep
the old rendering.

Date and time members stay text (their casts are not IMMUTABLE); a
non-unique index leading with one is rejected at migrations add.

Guards: rendering asserted against EF's own ToQueryString(); rollout on
a real compiled snapshot; EXPLAIN on PostgreSQL 18 with seqscan off.
Reverting each of the six parts of the fix turns its tests red.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   8 +
 CLAUDE.md                                     |  29 +-
 Directory.Build.props                         |   4 +-
 README.md                                     |   2 +-
 SECURITY.md                                   |   4 +-
 docs/postgresql-indexes.md                    |  30 +-
 .../CHANGELOG.md                              |  14 +
 ...NpgsqlComplexIndexMigrationsModelDiffer.cs | 123 ++++-
 .../README.md                                 |   9 +-
 src/EFCore.ComplexIndexes/CHANGELOG.md        |  12 +
 .../ComplexIndexAnnotations.cs                |  13 +
 .../ComplexIndexExtensions.cs                 |   2 +
 .../ComplexIndexStorage.cs                    |  22 +-
 .../CustomMigrationsModelDiffer.cs            |  73 ++-
 .../IndexPartDefinition.cs                    |   7 +
 .../ResolvedIndexPart.cs                      |  38 +-
 .../DocumentationApiTests.cs                  |   4 +-
 .../NpgsqlJsonMemberIndexTests.cs             |   7 +-
 .../NpgsqlJsonMemberRenderingTests.cs         | 441 ++++++++++++++++++
 .../PostgresIntegrationTests.cs               | 102 ++++
 .../SnapshotRoundTripTests.cs                 |  57 ++-
 21 files changed, 955 insertions(+), 46 deletions(-)
 create mode 100644 test/EFCore.ComplexIndexes.Tests/NpgsqlJsonMemberRenderingTests.cs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e4eefd5..dab872f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,14 @@ covering only what changed for that package:
 [PostgreSQL](src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md),
 [SQL Server](src/EFCore.ComplexIndexes.SqlServer/CHANGELOG.md).
 
+## 5.4.0
+
+Fixes to what 5.x already ships, found while testing the packages against EF Core 11: indexes on
+JSON members that no query could use.
+
+- **Fixed:** indexes on members of a `ToJson()` complex property are written the way Npgsql's queries read the member, so PostgreSQL can use them. It uses an expression index only for a query whose expression matches, and until now every member was extracted as `"doc" -> 'A' ->> 'B'` text with no cast, which matched only a top-level string. A nested member (`#>> '{Address,City}'` in the query) or a typed one (`CAST("doc" ->> 'Rank' AS integer)`) got an index that applied cleanly, enforced uniqueness, and was never used by a single query. Members now render as Npgsql renders them — `->>` or `#>>`, cast to the member's store type unless it is a string, `decode(…, 'base64')` for `byte[]`, `jsonb` for a primitive collection — in index parts, typed expression indexes and index filters. That also makes a filter such as `x => x.Profile.Rank > 5` valid SQL: it compared text with an integer and failed at apply time. Default index names do not change. **Upgrading:** the first `migrations add` drops and re-creates each affected index under its existing name; indexes on top-level string members are untouched. Until that migration exists, `has-pending-model-changes` reports changes and `Migrate()` raises EF Core's pending-model-changes error. The re-create blocks writes while it builds, so on a large table declare the index with `IsCreatedConcurrently()` first. Exclusion constraint filters keep their rendering. The snapshot gains one `CustomIndex:RenderingVersion` annotation, which records the rules a model was declared under and is what lets the change reach databases built by earlier versions.
+- **Changed:** a non-unique index that starts with a date or time JSON member (`DateTime`, `DateTimeOffset`, `DateOnly`, `TimeOnly`) is rejected at `migrations add`. EF Core's queries cast such a member to `timestamptz`, `date` or `time`, and PostgreSQL cannot index those casts (the conversion from text is not IMMUTABLE), so no query could ever use the index. A unique one is still allowed and enforces uniqueness on the stored text; a member in a later position leaves the index usable through the parts before it.
+
 ## 5.3.0
 
 One fix, found the first time a 5.2.0 converter-member path met the model snapshot
diff --git a/CLAUDE.md b/CLAUDE.md
index dc38b65..3fa105b 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -360,13 +360,32 @@ differ let satellites resolve what the core cannot:
 
 - `IsForwardedIndexAnnotation` — the annotation whitelist (see below).
 - `ResolveUnmappedPart` — a path with no table column; the Npgsql differ builds a JSON extraction
-  (`"col" -> 'A' ->> 'B'`) when the path traverses a `ToJson()` complex property, honoring
-  `HasJsonPropertyName`. Members extract as text — no automatic casts (text→timestamptz casts are
-  not IMMUTABLE and would blow up `CREATE INDEX`). A path that *ends* at the JSON-mapped complex
+  when the path traverses a `ToJson()` complex property, honoring `HasJsonPropertyName`, rendered
+  **exactly as Npgsql's query translation renders the member** (`NpgsqlQuerySqlGenerator.VisitJsonScalar`
+  and `GenerateJsonPath`, identical in Npgsql 10 and 11): `->>` for one step, `#>> '{A,B}'` for
+  more (`ARRAY[…]::text[]` when a segment is not ASCII-alphanumeric), and a `CAST` to the member's
+  store type unless it is a string mapping, `decode(…, 'base64')` for `bytea`, `jsonb` for a
+  primitive collection. PostgreSQL uses an expression index only for a query whose expression
+  matches it, so this is not cosmetic: until 5.4.0 every member was `"col" -> 'A' ->> 'B'` text,
+  and indexes on nested or typed members applied, enforced, and served no query
+  (`NpgsqlJsonMemberRenderingTests` asserts each rendering against EF's own `ToQueryString()`).
+  Date and time members stay text — their casts are not IMMUTABLE and cannot appear in an index —
+  and the part records a `TextFallback`; `ValidateQueryUsableLeadingParts` rejects a non-unique
+  index that starts with one (target model only). A path that *ends* at the JSON-mapped complex
   property — or at a complex collection, which is always JSON — resolves to the container column
   as a plain **column** part (so a whole-document GIN needs no runtime wiring); a complex property
-  nested inside the document resolves to a `->` extraction yielding `jsonb`. A table-split complex
-  property stays unresolved: there is no single column to stand for it.
+  nested inside the document resolves to a `jsonb` extraction. A table-split complex property
+  stays unresolved: there is no single column to stand for it.
+
+  **Rendering changes need `ComplexIndexAnnotations.RenderingVersion`.** Parts are resolved at diff
+  time on *both* sides, so changing how a member renders produces no migration at all — both sides
+  resolve alike and existing databases keep the old index forever. Every declaration writes the
+  version onto the model; a snapshot without it (scaffolded before 5.4.0) is resolved by the old
+  rules, which is what turns the change into one drop-and-create per affected index. Default index
+  names come from `ResolvedIndexPart.NameToken` (container plus path), never from the rendered SQL,
+  so a rendering change never renames an index; and `ResolvedIndexPart` equality ignores both
+  internal members, or identical SQL would still rebuild. Exclusion constraint filters pass
+  `renderingVersion: 1` and keep the old rendering: rebuilding a constraint buys no enforcement.
 - `ResolveTemplatePart` — substitutes template placeholders with quoted columns or parenthesized
   JSON extractions. Since 5.2.0 the core implements it, quoting through the `QuoteIdentifier`
   virtual (ANSI by default; the SQL Server satellite brackets), so satellites override neither.
diff --git a/Directory.Build.props b/Directory.Build.props
index d224267..96ef5bb 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -1,6 +1,6 @@
 <Project>
     <PropertyGroup>
-        <Version>5.3.0</Version>
+        <Version>5.4.0</Version>
         <Authors>CaffeinatedCoder</Authors>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
@@ -63,7 +63,7 @@
     -->
     <PropertyGroup>
         <EnablePackageValidation>true</EnablePackageValidation>
-        <PackageValidationBaselineVersion>5.2.0</PackageValidationBaselineVersion>
+        <PackageValidationBaselineVersion>5.3.0</PackageValidationBaselineVersion>
     </PropertyGroup>
 
     <!--
diff --git a/README.md b/README.md
index 64a082b..a5f8b31 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@ EF Core 8.0 introduced complex properties, but migration tooling doesn't automat
 - **Composite Indexes**: Define multi-column indexes spanning both scalar and nested properties with a single, intuitive expression — with per-column `ASC`/`DESC` ordering via `DbOrder.Asc`/`DbOrder.Desc`
 - **Expression Indexes** *(PostgreSQL)*: Index arbitrary SQL expressions such as `lower(email)` or `to_tsvector('english', body)` — including on plain, non-complex entities
 - **Typed Expression Indexes** *(PostgreSQL)*: Write `HasExpressionIndex(x => x.Email.ToLower())` and let the package translate it — property paths resolve to real columns at migration time
-- **JSON Member Indexes** *(PostgreSQL)*: Index members of complex properties mapped with `ToJson()` — the same `HasComplexIndex` declaration becomes a `(col ->> 'Member')` expression index automatically
+- **JSON Member Indexes** *(PostgreSQL)*: Index members of complex properties mapped with `ToJson()` — the same `HasComplexIndex` declaration becomes an expression index written the way Npgsql's queries read the member (`col ->> 'Member'`, `col #>> '{A,B}'`, cast to its type), so the queries use it
 - **Temporal Constraints** *(PostgreSQL 18)*: Declare `UNIQUE … WITHOUT OVERLAPS` constraints to guarantee no two rows occupy overlapping time periods — the database enforces scheduling integrity for you
 - **Exclusion Constraints** *(PostgreSQL)*: Declare `EXCLUDE USING gist (… WITH =, … WITH &&) WHERE (…)` constraints — filtered overlap protection (e.g. ignore soft-deleted rows), on any supported PostgreSQL version
 - **SQL Server Options** *(SQL Server)*: Clustered, covering (`INCLUDE`), online-built, fill-factor, and data-compression index options on complex-property indexes — rendered by the stock SQL Server generator, no runtime wiring
diff --git a/SECURITY.md b/SECURITY.md
index 2d0125f..fe278bf 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -50,8 +50,8 @@ remedy for those is to upgrade.
 
 | Version | Supported |
 |---|---|
-| 5.3.x | ✅ |
-| < 5.3 | ❌ |
+| 5.4.x | ✅ |
+| < 5.4 | ❌ |
 
 ### For how long
 
diff --git a/docs/postgresql-indexes.md b/docs/postgresql-indexes.md
index a2d0a24..e364f76 100644
--- a/docs/postgresql-indexes.md
+++ b/docs/postgresql-indexes.md
@@ -199,9 +199,33 @@ builder.HasComplexIndex(x => x.Name.ShortName, isUnique: true, indexName: "ux_em
 // ALTER: CREATE UNIQUE INDEX "ux_employer_short_name" ON employers (("name" ->> 'ShortName'));
 ```
 
-Nested complex types become `->` segments (`("profile" -> 'Address' ->> 'City')`), and
-`HasJsonPropertyName` is honored. Members are extracted as **text**; for typed comparisons or
-ordering semantics use `HasExpressionIndex` with an explicit cast.
+Each member is rendered **exactly the way Npgsql's queries read it**, because PostgreSQL uses an
+expression index only for a query whose expression matches it. That decides the path operator and
+the cast:
+
+| Member | Index expression | Serves |
+|---|---|---|
+| `string`, enum stored as string | `"name" ->> 'ShortName'` | `x.Name.ShortName == …` |
+| nested member | `"profile" #>> '{Address,City}'` | `x.Profile.Address.City == …` |
+| `int`, `long`, `short`, `decimal`, `double`, `bool`, `Guid`, enum | `CAST("profile" ->> 'Rank' AS integer)` (the member's store type) | `x.Profile.Rank == …`, `> …`, `ORDER BY` |
+| `byte[]` | `decode("profile" ->> 'Blob', 'base64')` | `x.Profile.Blob == …` |
+| primitive collection | `"profile" -> 'Tags'` (`jsonb`) | a GIN over it |
+| `DateTime`, `DateTimeOffset`, `DateOnly`, `TimeOnly` | `"profile" ->> 'At'` (text) | uniqueness only |
+
+`HasJsonPropertyName` is honored throughout. Date and time members are the exception: Npgsql's
+queries cast them to `timestamp with time zone`, `date` or `time`, and PostgreSQL cannot index those
+casts (the conversion from text is not `IMMUTABLE`), so no index can match the query. The member
+stays text, a **unique** index over it still enforces uniqueness, and a **non-unique** index that
+starts with it is rejected at `migrations add`, since no query would ever use it. Put another part
+first, or map the member to a regular column.
+
+> **Upgrading from 5.3 or earlier:** before 5.4.0 every member was extracted as text with `->`
+> segments, which only matched the query for a top-level string. Such indexes enforced uniqueness
+> but no query used them. The first `migrations add` after upgrading drops and re-creates each
+> affected index under its existing name; indexes on top-level string members are untouched.
+> Until that migration exists, `has-pending-model-changes` reports changes and `Migrate()` raises
+> EF Core's pending-model-changes error. The re-create is a plain `CREATE INDEX` that blocks writes
+> while it builds; on a large table, declare the index with `IsCreatedConcurrently()` first.
 
 ### Indexing the whole document
 
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md b/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md
index 11e3664..ce72bbf 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md
@@ -4,6 +4,20 @@ Changes to the PostgreSQL satellite, newest first. The
 [root changelog](https://github.com/CaffeinatedCoder/EFCore.ComplexIndexes/blob/main/CHANGELOG.md)
 covers all three packages.
 
+## 5.4.0
+
+- **Fixed:** indexes on `ToJson()` members are written the way Npgsql's queries read the member —
+  `->>` or `#>> '{A,B}'`, cast to the member's store type unless it is a string, `decode(…,
+  'base64')` for `byte[]`, `jsonb` for a primitive collection — so PostgreSQL can use them. Before,
+  every member was `"doc" -> 'A' ->> 'B'` text, which matched a query only for a top-level string:
+  indexes on nested or typed members applied, enforced uniqueness, and served no query. Applies to
+  index parts, typed expression indexes and index filters; exclusion constraint filters keep their
+  rendering. Upgrading rebuilds each affected index once, under its existing name, at the first
+  `migrations add`.
+- **Changed:** a non-unique index that starts with a `DateTime`, `DateTimeOffset`, `DateOnly` or
+  `TimeOnly` JSON member is rejected at `migrations add`: the queries cast the member to a type
+  PostgreSQL cannot index from text, so the index could never be used. Unique ones are allowed.
+
 ## 5.2.0
 
 - **Changed:** an index, exclusion constraint, temporal constraint or temporal foreign key whose
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs
index acb5404..01bcb55 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs
@@ -143,14 +143,32 @@ StoreObjectIdentifier storeObject
     /// <summary>
     /// Resolves an index part whose path has no table column: a member of a complex property mapped
     /// to JSON via <c>ToJson()</c>, or the JSON-mapped complex property (or complex collection)
-    /// itself. A member becomes a PostgreSQL text extraction, e.g.
-    /// <c>"name" -&gt; 'Inner' -&gt;&gt; 'Leaf'</c>, honoring <c>HasJsonPropertyName</c>; for typed
-    /// semantics use <c>HasExpressionIndex</c> with an explicit cast. A path ending at the JSON-mapped
-    /// complex property resolves to its container column — a plain column index, typically
-    /// <c>USING gin</c>, that the stock generator renders with no runtime wiring. A complex property
-    /// nested inside the document resolves to a <c>-&gt;</c> extraction yielding <c>jsonb</c>, which
-    /// GIN indexes too. Expression parts require the <c>UseNpgsqlComplexIndexes()</c> runtime wiring.
+    /// itself.
     /// </summary>
+    /// <remarks>
+    /// A member is rendered exactly as Npgsql's query translation renders it, because PostgreSQL only
+    /// uses an expression index for a query whose expression matches it:
+    /// <c>"doc" -&gt;&gt; 'A'</c> for one step and <c>"doc" #&gt;&gt; '{A,B}'</c> for more, cast to
+    /// the member's store type unless that is a string (<c>CAST("doc" -&gt;&gt; 'Rank' AS integer)</c>),
+    /// <c>decode(…, 'base64')</c> for <c>bytea</c>, and <c>jsonb</c> for a primitive collection.
+    /// <c>HasJsonPropertyName</c> is honored. A date or time member stays text: the cast EF Core's
+    /// queries apply to it is not IMMUTABLE and cannot appear in an index, so the part records the
+    /// fallback and the differ rejects a non-unique index that leads with it.
+    /// <para>
+    /// A path ending at the JSON-mapped complex property resolves to its container column — a plain
+    /// column index, typically <c>USING gin</c>, that the stock generator renders with no runtime
+    /// wiring. A complex property nested inside the document resolves to a <c>jsonb</c> extraction,
+    /// which GIN indexes too. Expression parts require the <c>UseNpgsqlComplexIndexes()</c> runtime
+    /// wiring.
+    /// </para>
+    /// <para>
+    /// A model without <see cref="ComplexIndexAnnotations.RenderingVersion"/> — a snapshot written
+    /// before 5.4.0 — is rendered the original way, <c>"doc" -&gt; 'A' -&gt;&gt; 'B'</c> as text with no
+    /// cast, which matched the query translation only for a top-level string. Resolving the snapshot
+    /// by its own rules is what turns the change into one drop-and-create per affected index; resolved
+    /// alike, the two sides would never differ and existing databases would keep the unused index.
+    /// </para>
+    /// </remarks>
     protected override ResolvedIndexPart? ResolveUnmappedPart(
         IEntityType           entityType,
         IndexPartDefinition   part,
@@ -160,6 +178,8 @@ StoreObjectIdentifier storeObject
         if (part.PropertyPath is null)
             return null;
 
+        var queryAligned = (part.RenderingVersion ?? ComplexIndexStorage.GetRenderingVersion(entityType.Model)) >= 2;
+
         var       segments        = part.PropertyPath.Split('.');
         ITypeBase current         = entityType;
         string?   containerColumn = null;
@@ -183,27 +203,93 @@ StoreObjectIdentifier storeObject
 
         var leaf = current.FindProperty(segments[^1]);
         if (leaf is null)
-            return ResolveComplexLeaf(current, segments[^1], containerColumn, jsonPath, part);
+            return ResolveComplexLeaf(current, segments[^1], containerColumn, jsonPath, part, queryAligned);
 
         if (containerColumn is null)
             return null;
 
         jsonPath.Add(leaf.GetJsonPropertyName() ?? leaf.Name);
 
-        return new ResolvedIndexPart(true, BuildJsonExtraction(containerColumn, jsonPath, asText: true), part.Descending, part.NullSort);
+        // Default index names come from the container and the path, never from the rendered SQL.
+        var nameToken = containerColumn + string.Concat(jsonPath);
+
+        if (!queryAligned)
+            return new ResolvedIndexPart(true, BuildLegacyJsonExtraction(containerColumn, jsonPath, asText: true), part.Descending, part.NullSort)
+                   {
+                       NameToken = nameToken
+                   };
+
+        var (sql, fallbackStoreType) = RenderJsonScalar(leaf, containerColumn, jsonPath);
+
+        return new ResolvedIndexPart(true, sql, part.Descending, part.NullSort)
+               {
+                   NameToken    = nameToken,
+                   TextFallback = fallbackStoreType is null ? null : (part.PropertyPath, fallbackStoreType)
+               };
+    }
+
+    // Types whose text input function is STABLE rather than IMMUTABLE — the conversion depends on
+    // DateStyle, TimeZone or lc_monetary — so a cast to them from text cannot appear in an index.
+    private static readonly HashSet<string> StableTextInputTypes = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "date", "time", "time without time zone", "time with time zone", "timetz",
+        "timestamp", "timestamp without time zone", "timestamp with time zone", "timestamptz",
+        "interval", "money"
+    };
+
+    // Mirrors NpgsqlQuerySqlGenerator.VisitJsonScalar, identical in Npgsql 10 and 11: no cast for a
+    // string mapping, decode() for bytea, jsonb for a primitive collection, and a CAST to the store
+    // type for everything else — except where that cast is not IMMUTABLE, which falls back to text
+    // and reports the store type the queries use instead.
+    private (string Sql, string? FallbackStoreType) RenderJsonScalar(IProperty leaf, string containerColumn, List<string> jsonPath)
+    {
+        if (leaf.IsPrimitiveCollection)
+            return (BuildJsonPath(containerColumn, jsonPath, returnsText: false), null);
+
+        var text    = BuildJsonPath(containerColumn, jsonPath, returnsText: true);
+        var mapping = leaf.FindRelationalTypeMapping() ?? _typeMappingSource.FindMapping(leaf);
+
+        return mapping switch
+        {
+            null or StringTypeMapping                                     => (text, null),
+            _ when mapping.StoreTypeNameBase == "bytea"                    => ($"decode({text}, 'base64')", null),
+            _ when StableTextInputTypes.Contains(mapping.StoreTypeNameBase) => (text, mapping.StoreType),
+            _                                                             => ($"CAST({text} AS {mapping.StoreType})", null)
+        };
+    }
+
+    // Mirrors NpgsqlQuerySqlGenerator.GenerateJsonPath: -> / ->> for a single step; #> / #>> for
+    // more, with a '{A,B}' literal when every segment is ASCII letters and digits and an
+    // ARRAY['A','B']::text[] otherwise. PostgreSQL matches an index to a query by expression, so the
+    // choice has to be the same one.
+    private static string BuildJsonPath(string containerColumn, List<string> jsonPath, bool returnsText)
+    {
+        var column = Quote(containerColumn);
+
+        if (jsonPath.Count == 1)
+            return $"{column} {(returnsText ? "->>" : "->")} {Literal(jsonPath[0])}";
+
+        var path = jsonPath.All(segment => segment.All(char.IsAsciiLetterOrDigit))
+                       ? $"'{{{string.Join(",", jsonPath)}}}'"
+                       : $"ARRAY[{string.Join(",", jsonPath.Select(Literal))}]::text[]";
+
+        return $"{column} {(returnsText ? "#>>" : "#>")} {path}";
+
+        static string Literal(string value) => $"'{value.Replace("'", "''")}'";
     }
 
     // The path ends at a complex property rather than a scalar: the whole document, or a
     // sub-document. At the top of a ToJson() mapping — and a complex collection is always JSON —
     // that is the container column itself, so the index is a plain column index the stock generator
-    // renders. Nested inside a document it is a `->` extraction, which yields jsonb rather than text.
+    // renders. Nested inside a document it is an extraction yielding jsonb rather than text.
     // A table-split complex property has no single column to stand for it, so that stays unresolved.
     private static ResolvedIndexPart? ResolveComplexLeaf(
         ITypeBase           current,
         string              name,
         string?             containerColumn,
         List<string>        jsonPath,
-        IndexPartDefinition part
+        IndexPartDefinition part,
+        bool                queryAligned
     )
     {
         var complexProperty = current.FindComplexProperty(name);
@@ -220,11 +306,16 @@ IndexPartDefinition part
 
         jsonPath.Add(complexProperty.GetJsonPropertyName() ?? complexProperty.Name);
 
-        return new ResolvedIndexPart(true, BuildJsonExtraction(containerColumn, jsonPath, asText: false), part.Descending, part.NullSort);
+        var sql = queryAligned
+                      ? BuildJsonPath(containerColumn, jsonPath, returnsText: false)
+                      : BuildLegacyJsonExtraction(containerColumn, jsonPath, asText: false);
+
+        return new ResolvedIndexPart(true, sql, part.Descending, part.NullSort) { NameToken = containerColumn + string.Concat(jsonPath) };
     }
 
-    // "col" -> 'A' -> 'B' (jsonb) or, with asText, "col" -> 'A' ->> 'B' (text) for the last step.
-    private static string BuildJsonExtraction(string containerColumn, List<string> jsonPath, bool asText)
+    // Rendering version 1, kept for snapshots written before 5.4.0: "col" -> 'A' -> 'B' (jsonb) or,
+    // with asText, "col" -> 'A' ->> 'B' (text) for the last step.
+    private static string BuildLegacyJsonExtraction(string containerColumn, List<string> jsonPath, bool asText)
     {
         var sql = new System.Text.StringBuilder(Quote(containerColumn));
         for (var i = 0; i < jsonPath.Count; i++)
@@ -655,7 +746,9 @@ private HashSet<ExclusionDescriptor> BuildExclusionDescriptors(IRelationalModel?
                     name,
                     parts,
                     def.Method,
-                    ResolveFilter(entityType, def.Filter, storeObject),
+                    // Pinned to the original JSON rendering: the constraint enforces the same rows
+                    // either way, so the 5.4.0 rendering change would only drop and re-add it.
+                    ResolveFilter(entityType, def.Filter, storeObject, renderingVersion: 1),
                     def.Deferrable,
                     def.InitiallyDeferred));
             }
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/README.md b/src/EFCore.ComplexIndexes.PostgreSQL/README.md
index 3ffd3f3..9e525ec 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/README.md
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/README.md
@@ -11,7 +11,7 @@ Adds, on top of the core's complex-property, composite, unique, and filtered ind
   (`WITH (fillfactor=70)`)
 - **`NULLS FIRST` / `NULLS LAST`** per-column null ordering
 - **Expression (functional) indexes** — raw SQL *or* typed LINQ, on any entity, complex or not
-- **JSON indexes** — index members of `ToJson()` complex properties as `->>` extractions, or the
+- **JSON indexes** — index members of `ToJson()` complex properties as the extractions Npgsql's queries use, or the
   whole document (or a complex collection) with a GIN over the `jsonb` column
 - **Temporal `UNIQUE … WITHOUT OVERLAPS` constraints and temporal foreign keys** (PostgreSQL 18)
 - **Exclusion (`EXCLUDE`) constraints** — filtered overlap protection, on every supported version
@@ -119,7 +119,12 @@ builder.HasComplexIndex(x => x.Name.ShortName, isUnique: true, indexName: "ux_em
 // CREATE UNIQUE INDEX "ux_employer_short_name" ON employers (("name" ->> 'ShortName'));
 ```
 
-Nested complex types become `->` segments and `HasJsonPropertyName` is honored.
+Each member is rendered the way Npgsql's queries read it, so the index serves them: nested members
+as `#>> '{Address,City}'`, typed members cast to their store type
+(`CAST("profile" ->> 'Rank' AS integer)`), and `HasJsonPropertyName` is honored. Date and time
+members stay text, because PostgreSQL cannot index their cast: a unique index over one still
+enforces uniqueness, and a non-unique index starting with one is rejected at `migrations add`.
+Upgrading from 5.3 or earlier rebuilds the affected indexes once, under their existing names.
 
 ### Temporal constraints — PostgreSQL 18
 
diff --git a/src/EFCore.ComplexIndexes/CHANGELOG.md b/src/EFCore.ComplexIndexes/CHANGELOG.md
index 83f8b6c..c094803 100644
--- a/src/EFCore.ComplexIndexes/CHANGELOG.md
+++ b/src/EFCore.ComplexIndexes/CHANGELOG.md
@@ -4,6 +4,18 @@ Changes to the core package, newest first. The
 [root changelog](https://github.com/CaffeinatedCoder/EFCore.ComplexIndexes/blob/main/CHANGELOG.md)
 covers all three packages.
 
+## 5.4.0
+
+- **New:** `ComplexIndexAnnotations.RenderingVersion`, written onto the model by every index
+  declaration. It records which rules the differ renders the model's parts with. Parts are resolved
+  at diff time on both sides, so without it a rendering change would never produce a migration; a
+  snapshot scaffolded before 5.4.0 carries none and is rendered by the original rules, and the
+  change reaches an existing database as one drop-and-create per affected index. The next
+  `migrations add` adds one `HasAnnotation` line to the snapshot, which on its own changes no DDL.
+- **Changed:** default names of expression parts are built from the property path rather than the
+  rendered SQL, so a change in how a part renders never renames an index. Every name 5.3.0
+  produced stays the same.
+
 ## 5.3.0
 
 - **Fixed:** a converter-member path (`x => x.Email.Value`) resolves against a model snapshot. The
diff --git a/src/EFCore.ComplexIndexes/ComplexIndexAnnotations.cs b/src/EFCore.ComplexIndexes/ComplexIndexAnnotations.cs
index d5b08db..3c69678 100644
--- a/src/EFCore.ComplexIndexes/ComplexIndexAnnotations.cs
+++ b/src/EFCore.ComplexIndexes/ComplexIndexAnnotations.cs
@@ -32,4 +32,17 @@ public static class ComplexIndexAnnotations
     /// generators read this to render expression indexes.
     /// </summary>
     public const string IndexParts = "CustomIndex:IndexParts";
+
+    /// <summary>
+    /// Set on the model by every index declaration, recording which rules the differ renders the
+    /// model's index parts with. A snapshot written before the key existed carries none and is
+    /// rendered by the original rules, so a change of rules reaches existing databases as one
+    /// drop-and-create per affected index instead of never: parts are resolved at diff time on both
+    /// sides, and without this key both sides would resolve alike.
+    /// </summary>
+    /// <remarks>
+    /// Version 2 (5.4.0) renders JSON members the way the provider's query translation does, so that
+    /// the database can use the index for EF Core's own queries.
+    /// </remarks>
+    public const string RenderingVersion = "CustomIndex:RenderingVersion";
 }
\ No newline at end of file
diff --git a/src/EFCore.ComplexIndexes/ComplexIndexExtensions.cs b/src/EFCore.ComplexIndexes/ComplexIndexExtensions.cs
index 516a71c..770fdf4 100644
--- a/src/EFCore.ComplexIndexes/ComplexIndexExtensions.cs
+++ b/src/EFCore.ComplexIndexes/ComplexIndexExtensions.cs
@@ -32,6 +32,7 @@ public ComplexTypePropertyBuilder HasComplexIndex(
         {
             builder.HasAnnotation(ComplexIndexAnnotations.IsIndexed, true);
             builder.HasAnnotation(ComplexIndexAnnotations.IsUnique,  isUnique);
+            ComplexIndexStorage.MarkRenderingVersion(builder.Metadata.DeclaringType.Model);
 
             if (filter is not null)
                 builder.HasAnnotation(ComplexIndexAnnotations.Filter, filter);
@@ -55,6 +56,7 @@ public ComplexTypePropertyBuilder HasComplexIndex(Action<ComplexIndexBuilder> co
             configure(indexBuilder);
 
             builder.HasAnnotation(ComplexIndexAnnotations.IsIndexed, true);
+            ComplexIndexStorage.MarkRenderingVersion(builder.Metadata.DeclaringType.Model);
 
             foreach (var (key, value) in indexBuilder.Annotations)
                 builder.HasAnnotation(key, value);
diff --git a/src/EFCore.ComplexIndexes/ComplexIndexStorage.cs b/src/EFCore.ComplexIndexes/ComplexIndexStorage.cs
index 524697d..a3ae11d 100644
--- a/src/EFCore.ComplexIndexes/ComplexIndexStorage.cs
+++ b/src/EFCore.ComplexIndexes/ComplexIndexStorage.cs
@@ -58,7 +58,27 @@ public static List<CompositeIndexDefinition> GetExisting(IReadOnlyEntityType ent
     }
 
     public static void Write(IMutableEntityType entityType, IReadOnlyList<CompositeIndexDefinition> definitions)
-        => entityType.SetAnnotation(ComplexIndexAnnotations.CompositeIndexes, CompositeIndexSerializer.Serialize(definitions));
+    {
+        entityType.SetAnnotation(ComplexIndexAnnotations.CompositeIndexes, CompositeIndexSerializer.Serialize(definitions));
+        MarkRenderingVersion(entityType.Model);
+    }
+
+    /// <summary>The rendering rules this version writes; see <see cref="ComplexIndexAnnotations.RenderingVersion"/>.</summary>
+    public const int CurrentRenderingVersion = 2;
+
+    /// <summary>
+    /// Records on the model that its declarations were made under <see cref="CurrentRenderingVersion"/>.
+    /// Every declaration path calls this, so the key is present exactly when the model declares an index.
+    /// </summary>
+    public static void MarkRenderingVersion(IMutableModel model)
+        => model.SetAnnotation(ComplexIndexAnnotations.RenderingVersion, CurrentRenderingVersion);
+
+    /// <summary>
+    /// The rendering rules a model's declarations were made under. A model without the key — a
+    /// snapshot written before 5.4.0 — predates it and is version 1.
+    /// </summary>
+    public static int GetRenderingVersion(IReadOnlyModel model)
+        => model.FindAnnotation(ComplexIndexAnnotations.RenderingVersion)?.Value is int version ? version : 1;
 
     /// <summary>
     /// The filter that results from adding <paramref name="predicate"/> to <paramref name="existing"/>
diff --git a/src/EFCore.ComplexIndexes/CustomMigrationsModelDiffer.cs b/src/EFCore.ComplexIndexes/CustomMigrationsModelDiffer.cs
index 0ac853a..fcdac41 100644
--- a/src/EFCore.ComplexIndexes/CustomMigrationsModelDiffer.cs
+++ b/src/EFCore.ComplexIndexes/CustomMigrationsModelDiffer.cs
@@ -78,6 +78,7 @@ public override IReadOnlyList<MigrationOperation> GetDifferences(
         ValidateUniqueIndexNames(targetIndexes);
         ValidateNoNativeIndexNameCollision(target, targetIndexes);
         ValidateIndexNameLengths(target, targetIndexes);
+        ValidateQueryUsableLeadingParts(targetIndexes);
 
         if (sourceIndexes.Count == 0 && targetIndexes.Count == 0)
             return operations;
@@ -333,6 +334,10 @@ StoreObjectIdentifier storeObject
         var template = part.Template!;
         var sql      = new StringBuilder(template.Length);
 
+        // The default-name token is built alongside the SQL, from each placeholder's own token, so
+        // that it depends on what the template names rather than on how a member is rendered.
+        var token    = new StringBuilder(template.Length);
+
         for (var i = 0; i < template.Length; i++)
         {
             var ch = template[i];
@@ -350,7 +355,10 @@ StoreObjectIdentifier storeObject
                 if (end < 0)
                     throw new InvalidOperationException($"Malformed index expression template '{template}' on entity '{entityType.Name}'.");
 
-                sql.Append(ResolvePlaceholder(entityType, template[(i + 1)..end], storeObject, "an index expression"));
+                var (placeholderSql, placeholderToken) =
+                    ResolvePlaceholder(entityType, template[(i + 1)..end], storeObject, "an index expression", renderingVersion: null);
+                sql.Append(placeholderSql);
+                token.Append(placeholderToken);
                 i = end;
                 continue;
             }
@@ -368,9 +376,10 @@ StoreObjectIdentifier storeObject
             }
 
             sql.Append(ch);
+            token.Append(ch);
         }
 
-        return new ResolvedIndexPart(true, sql.ToString(), part.Descending, part.NullSort);
+        return new ResolvedIndexPart(true, sql.ToString(), part.Descending, part.NullSort) { NameToken = token.ToString() };
     }
 
     /// <summary>
@@ -394,6 +403,17 @@ StoreObjectIdentifier storeObject
     /// <param name="storeObject">The table whose column names are used.</param>
     /// <returns>The filter with every placeholder replaced, or <paramref name="filter"/> unchanged when it has none.</returns>
     protected string? ResolveFilter(IEntityType entityType, string? filter, StoreObjectIdentifier storeObject)
+        => ResolveFilter(entityType, filter, storeObject, renderingVersion: null);
+
+    /// <inheritdoc cref="ResolveFilter(IEntityType, string?, StoreObjectIdentifier)"/>
+    /// <param name="entityType">The entity type the placeholders are resolved against.</param>
+    /// <param name="filter">The filter as declared, or null.</param>
+    /// <param name="storeObject">The table whose column names are used.</param>
+    /// <param name="renderingVersion">
+    /// Renders JSON members under this <see cref="ComplexIndexAnnotations.RenderingVersion"/> instead of
+    /// the model's; exclusion constraint filters pass 1 so that their DDL never changes.
+    /// </param>
+    internal string? ResolveFilter(IEntityType entityType, string? filter, StoreObjectIdentifier storeObject, int? renderingVersion)
     {
         if (filter is null || !filter.Contains('{'))
             return filter;
@@ -414,7 +434,7 @@ StoreObjectIdentifier storeObject
                 var end = filter.IndexOf('}', i + 1);
                 if (end > i + 1 && IsPropertyPath(filter.AsSpan(i + 1, end - i - 1)))
                 {
-                    sql.Append(ResolvePlaceholder(entityType, filter[(i + 1)..end], storeObject, "a filter"));
+                    sql.Append(ResolvePlaceholder(entityType, filter[(i + 1)..end], storeObject, "a filter", renderingVersion).Sql);
                     i = end;
                     continue;
                 }
@@ -450,15 +470,24 @@ private static bool IsPropertyPath(ReadOnlySpan<char> text)
         return !segmentStart;
     }
 
-    private string ResolvePlaceholder(IEntityType entityType, string path, StoreObjectIdentifier storeObject, string usage)
+    // Returns the SQL for the placeholder and the token it contributes to a default index name.
+    private (string Sql, string Token) ResolvePlaceholder(
+        IEntityType           entityType,
+        string                path,
+        StoreObjectIdentifier storeObject,
+        string                usage,
+        int?                  renderingVersion
+    )
     {
         var column = ResolveColumnName(entityType, path, storeObject);
         if (column is not null)
-            return QuoteIdentifier(column);
+            return (QuoteIdentifier(column), column);
 
-        var unmapped = ResolveUnmappedPart(entityType, new IndexPartDefinition { PropertyPath = path }, storeObject);
+        var part     = new IndexPartDefinition { PropertyPath = path, RenderingVersion = renderingVersion };
+        var unmapped = ResolveUnmappedPart(entityType, part, storeObject);
         if (unmapped is not null)
-            return unmapped.IsExpression ? $"({unmapped.Value})" : QuoteIdentifier(unmapped.Value);
+            return (unmapped.IsExpression ? $"({unmapped.Value})" : QuoteIdentifier(unmapped.Value),
+                    unmapped.NameToken ?? unmapped.Value);
 
         throw new InvalidOperationException(
             $"Could not resolve property path '{path}' referenced by {usage} on entity '{entityType.Name}'.");
@@ -556,6 +585,31 @@ private static void ValidateNoNativeIndexNameCollision(IRelationalModel? target,
         }
     }
 
+    /// <summary>
+    /// Fails when a non-unique index leads with a JSON member that had to fall back to text.
+    /// </summary>
+    /// <remarks>
+    /// The provider's queries compare such a member through a cast PostgreSQL cannot index (text to
+    /// <c>timestamptz</c>, <c>date</c>, … is not IMMUTABLE), so no query ever uses an index that
+    /// starts with it: it scaffolds, applies, costs every write and speeds up nothing. A unique index
+    /// is still allowed, since enforcing uniqueness on the stored text is its purpose; a member in a
+    /// later position leaves the index usable through the parts before it.
+    /// </remarks>
+    private static void ValidateQueryUsableLeadingParts(HashSet<IndexDescriptor> descriptors)
+    {
+        foreach (var descriptor in descriptors)
+        {
+            if (descriptor.IsUnique || descriptor.Parts[0].TextFallback is not { } fallback)
+                continue;
+
+            throw new InvalidOperationException(
+                $"The complex index '{descriptor.IndexName}' on table '{descriptor.TableName}' starts with the JSON member "
+              + $"'{fallback.Path}', which EF Core's queries compare as {fallback.StoreType}. PostgreSQL cannot index that conversion from "
+              + "the stored text (it is not IMMUTABLE), so no query would ever use this index. Declare it unique if it "
+              + "exists to enforce uniqueness, put another part first, or map the member to a regular column.");
+        }
+    }
+
     private void ValidateIndexNameLengths(IRelationalModel? target, HashSet<IndexDescriptor> descriptors)
     {
         if (target is null)
@@ -753,13 +807,14 @@ StoreObjectIdentifier   storeObject
     }
 
     // Builds a default index-name token for a part: column names pass through; expressions are
-    // reduced to their alphanumeric characters (e.g. lower("Email") -> "lowerEmail").
+    // reduced to their alphanumeric characters (e.g. lower("Email") -> "lowerEmail"), starting from
+    // the part's name token where it has one, so a rendering change never renames the index.
     private static string BuildPartToken(ResolvedIndexPart part)
     {
         if (!part.IsExpression)
             return part.Value;
 
-        var token = new string([.. part.Value.Where(char.IsLetterOrDigit)]);
+        var token = new string([.. (part.NameToken ?? part.Value).Where(char.IsLetterOrDigit)]);
         return token.Length > 0 ? token : "expr";
     }
 
diff --git a/src/EFCore.ComplexIndexes/IndexPartDefinition.cs b/src/EFCore.ComplexIndexes/IndexPartDefinition.cs
index cc6b6d1..4a6fdbc 100644
--- a/src/EFCore.ComplexIndexes/IndexPartDefinition.cs
+++ b/src/EFCore.ComplexIndexes/IndexPartDefinition.cs
@@ -41,6 +41,13 @@ public sealed class IndexPartDefinition : IEquatable<IndexPartDefinition>
     /// <summary>Whether this part is a SQL template whose placeholders still need resolving.</summary>
     [JsonIgnore] public bool IsTemplate => Template is not null;
 
+    /// <summary>
+    /// Overrides the model's <see cref="ComplexIndexAnnotations.RenderingVersion"/> for this one
+    /// resolution. Never stored; the differ sets it on the parts it builds for placeholders in a
+    /// context whose rendering must not change — exclusion constraint filters.
+    /// </summary>
+    [JsonIgnore] internal int? RenderingVersion { get; init; }
+
     /// <summary>
     /// Returns a copy of this part with the given sort options applied; null arguments keep the
     /// current value.
diff --git a/src/EFCore.ComplexIndexes/ResolvedIndexPart.cs b/src/EFCore.ComplexIndexes/ResolvedIndexPart.cs
index 840c0c8..a01fd31 100644
--- a/src/EFCore.ComplexIndexes/ResolvedIndexPart.cs
+++ b/src/EFCore.ComplexIndexes/ResolvedIndexPart.cs
@@ -16,4 +16,40 @@ public sealed record ResolvedIndexPart(
     [property: JsonPropertyName("v")] string Value,
     [property: JsonPropertyName("d"), JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)] bool Descending = false,
     [property: JsonPropertyName("n"), JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault), JsonConverter(typeof(JsonStringEnumConverter<DbNullSort>))] DbNullSort NullSort = DbNullSort.Default
-);
+)
+{
+    // Neither member is serialized: both matter to the differ only, never to a SQL generator.
+
+    /// <summary>
+    /// What a default index name is built from, when that should not be the rendered SQL. A JSON
+    /// member sets its container column and path here, so a change in how the member is rendered —
+    /// a cast added, a different path operator — never renames an index an application may be
+    /// matching on by name.
+    /// </summary>
+    internal string? NameToken { get; init; }
+
+    /// <summary>
+    /// Set when a JSON member of a date or time type fell back to text: the path and the store type
+    /// the provider's queries cast the member to. PostgreSQL cannot index that cast (the conversion
+    /// from text is not IMMUTABLE), so no query ever uses such a part.
+    /// </summary>
+    internal (string Path, string StoreType)? TextFallback { get; init; }
+
+    /// <summary>
+    /// Compares the rendered part only. <see cref="NameToken"/> and <see cref="TextFallback"/> are
+    /// facts about how the part was derived, and the differ compares parts to decide whether an index
+    /// changed: counting them in would rebuild an index whose SQL is identical, as it did for a
+    /// date member between a pre-5.4.0 snapshot and the current model.
+    /// </summary>
+    /// <param name="other">The part to compare with.</param>
+    /// <returns>True when both render the same SQL with the same sort options.</returns>
+    public bool Equals(ResolvedIndexPart? other)
+        => other is not null
+        && IsExpression == other.IsExpression
+        && Value        == other.Value
+        && Descending   == other.Descending
+        && NullSort     == other.NullSort;
+
+    /// <inheritdoc/>
+    public override int GetHashCode() => HashCode.Combine(IsExpression, Value, Descending, NullSort);
+}
diff --git a/test/EFCore.ComplexIndexes.Tests/DocumentationApiTests.cs b/test/EFCore.ComplexIndexes.Tests/DocumentationApiTests.cs
index e1afcba..09c15bc 100644
--- a/test/EFCore.ComplexIndexes.Tests/DocumentationApiTests.cs
+++ b/test/EFCore.ComplexIndexes.Tests/DocumentationApiTests.cs
@@ -60,7 +60,9 @@ public class DocumentationApiTests
         // Dependency injection
         "ServiceCollection", "BuildServiceProvider", "AddDbContext",
         // BCL
-        "ToLower", "Trim", "Where", "SelectMany", "ToList"
+        "ToLower", "Trim", "Where", "SelectMany", "ToList",
+        // SQL, in examples of the DDL the differ renders
+        "CAST"
     };
 
     [TestMethod(DisplayName = "Every API the documentation names exists")]
diff --git a/test/EFCore.ComplexIndexes.Tests/NpgsqlJsonMemberIndexTests.cs b/test/EFCore.ComplexIndexes.Tests/NpgsqlJsonMemberIndexTests.cs
index e0e459a..c77cb9a 100644
--- a/test/EFCore.ComplexIndexes.Tests/NpgsqlJsonMemberIndexTests.cs
+++ b/test/EFCore.ComplexIndexes.Tests/NpgsqlJsonMemberIndexTests.cs
@@ -197,14 +197,17 @@ public void Mixed_composite_resolves()
         Assert.AreEqual("\"name\" ->> 'ShortName'", parts[1].Value);
     }
 
-    [TestMethod(DisplayName = "Nested complex members render intermediate -> segments")]
+    // Npgsql's queries read a nested member with #>>, and PostgreSQL only uses an expression index
+    // whose expression matches the query's: -> 'Address' ->> 'City' enforced uniqueness but was
+    // never used for a lookup.
+    [TestMethod(DisplayName = "Nested complex members render a #>> path, as Npgsql's queries do")]
     public void Nested_json_member_resolves()
     {
         var operations = GetDifferences(source: null, target: BuildRelationalModel<NestedJsonIndexContext>());
 
         var createIndex = Assert.ContainsSingle(operations.OfType<CreateIndexOperation>());
         var part        = Assert.ContainsSingle(PartsOf(createIndex));
-        Assert.AreEqual("\"profile\" -> 'Address' ->> 'City'", part.Value);
+        Assert.AreEqual("\"profile\" #>> '{Address,City}'", part.Value);
     }
 
     [TestMethod(DisplayName = "Unchanged JSON-member index produces no operations")]
diff --git a/test/EFCore.ComplexIndexes.Tests/NpgsqlJsonMemberRenderingTests.cs b/test/EFCore.ComplexIndexes.Tests/NpgsqlJsonMemberRenderingTests.cs
new file mode 100644
index 0000000..1ca372b
--- /dev/null
+++ b/test/EFCore.ComplexIndexes.Tests/NpgsqlJsonMemberRenderingTests.cs
@@ -0,0 +1,441 @@
+using System.Linq.Expressions;
+using System.Text.RegularExpressions;
+using EFCore.ComplexIndexes.PostgreSQL;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Migrations.Operations;
+using NpgsqlTypes;
+
+namespace EFCore.ComplexIndexes.Tests;
+
+/// <summary>
+/// JSON members are rendered the way Npgsql's query translation renders them, because PostgreSQL
+/// uses an expression index only for a query whose expression matches it. Before 5.4.0 every
+/// member was <c>"doc" -&gt; 'A' -&gt;&gt; 'B'</c> text with no cast, which matched only a top-level
+/// string: a nested member (<c>#&gt;&gt; '{A,B}'</c> in the query) or any typed member
+/// (<c>CAST(… AS integer)</c>) got an index that applied cleanly, enforced uniqueness, and was never
+/// used by a single query. The same rules must reach databases built by earlier versions, so a model
+/// without <see cref="ComplexIndexAnnotations.RenderingVersion"/> is still rendered the old way, and
+/// the difference surfaces as one drop-and-create per affected index.
+/// </summary>
+[TestClass]
+public class NpgsqlJsonMemberRenderingTests
+{
+    public enum Tier { Basic, Pro }
+
+    public class Address
+    {
+        public string City       { get; set; } = "";
+        public int    Zip        { get; set; }
+        public string PostalCode { get; set; } = "";
+    }
+
+    public class Profile
+    {
+        public string       Slug     { get; set; } = "";
+        public int          Rank     { get; set; }
+        public long         Big      { get; set; }
+        public decimal      Price    { get; set; }
+        public double       Ratio    { get; set; }
+        public bool         Active   { get; set; }
+        public Guid         Key      { get; set; }
+        public DateTime     At       { get; set; }
+        public DateOnly     Day      { get; set; }
+        public Tier         Tier     { get; set; }
+        public Tier         TierText { get; set; }
+        public int?         Maybe    { get; set; }
+        public byte[]       Blob     { get; set; } = [];
+        public List<string> Tags     { get; set; } = [];
+        public Address      Address  { get; set; } = new();
+    }
+
+    public class Account
+    {
+        public int                   Id      { get; set; }
+        public NpgsqlRange<DateTime> Period  { get; set; }
+        public Profile               Profile { get; set; } = new();
+    }
+
+    private static void ConfigureAccount(EntityTypeBuilder<Account> b)
+    {
+        b.ToTable("accounts");
+        b.HasKey(x => x.Id);
+        b.ComplexProperty(x => x.Profile, p =>
+        {
+            p.ToJson("profile");
+            p.Property(x => x.TierText).HasConversion<string>();
+            p.Property(x => x.Price).HasPrecision(18, 2);
+            p.ComplexProperty(x => x.Address, a => a.Property(x => x.PostalCode).HasJsonPropertyName("postal_code"));
+        });
+    }
+
+    // One explicitly named index per member shape, with the SQL Npgsql's queries use for it.
+    internal static readonly (string Name, Expression<Func<Account, object?>> Member, string Sql)[] Members =
+    [
+        ("ix_slug",      x => x.Profile.Slug,               "\"profile\" ->> 'Slug'"),
+        ("ix_rank",      x => x.Profile.Rank,               "CAST(\"profile\" ->> 'Rank' AS integer)"),
+        ("ix_big",       x => x.Profile.Big,                "CAST(\"profile\" ->> 'Big' AS bigint)"),
+        ("ix_price",     x => x.Profile.Price,              "CAST(\"profile\" ->> 'Price' AS numeric(18,2))"),
+        ("ix_ratio",     x => x.Profile.Ratio,              "CAST(\"profile\" ->> 'Ratio' AS double precision)"),
+        ("ix_active",    x => x.Profile.Active,             "CAST(\"profile\" ->> 'Active' AS boolean)"),
+        ("ix_key",       x => x.Profile.Key,                "CAST(\"profile\" ->> 'Key' AS uuid)"),
+        ("ix_tier",      x => x.Profile.Tier,               "CAST(\"profile\" ->> 'Tier' AS integer)"),
+        ("ix_tier_text", x => x.Profile.TierText,           "\"profile\" ->> 'TierText'"),
+        ("ix_maybe",     x => x.Profile.Maybe,              "CAST(\"profile\" ->> 'Maybe' AS integer)"),
+        ("ix_blob",      x => x.Profile.Blob,               "decode(\"profile\" ->> 'Blob', 'base64')"),
+        ("ix_tags",      x => x.Profile.Tags,               "\"profile\" -> 'Tags'"),
+        ("ix_city",      x => x.Profile.Address.City,       "\"profile\" #>> '{Address,City}'"),
+        ("ix_zip",       x => x.Profile.Address.Zip,        "CAST(\"profile\" #>> '{Address,Zip}' AS integer)"),
+        ("ix_postal",    x => x.Profile.Address.PostalCode, "\"profile\" #>> ARRAY['Address','postal_code']::text[]"),
+        ("ix_address",   x => x.Profile.Address,            "\"profile\" -> 'Address'")
+    ];
+
+    // Date and time members stay text (their casts cannot be indexed); unique, so they are allowed.
+    internal static readonly (string Name, Expression<Func<Account, object?>> Member, string Sql)[] TextFallbackMembers =
+    [
+        ("ux_at",  x => x.Profile.At,  "\"profile\" ->> 'At'"),
+        ("ux_day", x => x.Profile.Day, "\"profile\" ->> 'Day'")
+    ];
+
+    // Rendered identically by both versions: top-level strings, a top-level sub-document, and the text fallbacks.
+    internal static readonly HashSet<string> UnaffectedByRollout = ["ix_slug", "ix_tier_text", "ix_address", "ux_at", "ux_day"];
+
+    internal static void DeclareMatrix(EntityTypeBuilder<Account> b)
+    {
+        ConfigureAccount(b);
+        foreach (var (name, member, _) in Members)
+            b.HasComplexIndex(member, indexName: name);
+        foreach (var (name, member, _) in TextFallbackMembers)
+            b.HasComplexIndex(member, isUnique: true, indexName: name);
+    }
+
+    public class MatrixContext(DbContextOptions<MatrixContext> options) : DbContext(options)
+    {
+        public DbSet<Account> Accounts => Set<Account>();
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+            => modelBuilder.Entity<Account>(DeclareMatrix);
+    }
+
+    // The same declarations as a model written before 5.4.0 carries them: no rendering version.
+    public class MatrixBefore54Context(DbContextOptions<MatrixBefore54Context> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Account>(DeclareMatrix);
+            modelBuilder.Model.RemoveAnnotation(ComplexIndexAnnotations.RenderingVersion);
+        }
+    }
+
+    // Default names, which applications match on: a rendering change must never rename an index.
+    private static void DeclareDefaultNamed(EntityTypeBuilder<Account> b)
+    {
+        ConfigureAccount(b);
+        b.HasComplexIndex(x => x.Profile.Rank);
+        b.HasComplexIndex(x => x.Profile.Address.Zip, isUnique: true);
+        b.HasComplexIndex(x => x.Profile.Address.City);
+        b.HasExpressionIndex(x => x.Profile.Address.City.ToLower());
+    }
+
+    public class DefaultNamedContext(DbContextOptions<DefaultNamedContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) => modelBuilder.Entity<Account>(DeclareDefaultNamed);
+    }
+
+    public class DefaultNamedBefore54Context(DbContextOptions<DefaultNamedBefore54Context> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Account>(DeclareDefaultNamed);
+            modelBuilder.Model.RemoveAnnotation(ComplexIndexAnnotations.RenderingVersion);
+        }
+    }
+
+    public class PropertyLevelContext(DbContextOptions<PropertyLevelContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Account>(b =>
+            {
+                b.ToTable("accounts");
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Profile, p =>
+                {
+                    p.ToJson("profile");
+                    p.Property(x => x.Rank).HasComplexIndex();
+                });
+            });
+    }
+
+    // Filters: index filters follow the new rules; exclusion constraint filters keep the old ones.
+    internal static void DeclareFilters(EntityTypeBuilder<Account> b)
+    {
+        ConfigureAccount(b);
+        b.HasComplexIndex(x => x.Profile.Slug, filter: "{Profile.Address.City} IS NOT NULL", indexName: "ix_filtered_city");
+        b.HasComplexIndex(x => x.Profile.Slug, x => x.Profile.Rank > 5, indexName: "ix_filtered_rank");
+        b.HasExclusionConstraint(x => x.Id, x => x.Period, filter: "{Profile.Address.City} IS NOT NULL", name: "ex_accounts_city");
+    }
+
+    public class FilterContext(DbContextOptions<FilterContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) => modelBuilder.Entity<Account>(DeclareFilters);
+    }
+
+    public class FilterBefore54Context(DbContextOptions<FilterBefore54Context> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Account>(DeclareFilters);
+            modelBuilder.Model.RemoveAnnotation(ComplexIndexAnnotations.RenderingVersion);
+        }
+    }
+
+    public class NonUniqueDateContext(DbContextOptions<NonUniqueDateContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Account>(b =>
+            {
+                ConfigureAccount(b);
+                b.HasComplexIndex(x => x.Profile.At, indexName: "ix_at");
+            });
+    }
+
+    public class NonUniqueDateOnlyContext(DbContextOptions<NonUniqueDateOnlyContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Account>(b =>
+            {
+                ConfigureAccount(b);
+                b.HasComplexIndex(x => x.Profile.Day);
+            });
+    }
+
+    public class TrailingDateContext(DbContextOptions<TrailingDateContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Account>(b =>
+            {
+                ConfigureAccount(b);
+                b.HasComplexCompositeIndex(x => new { x.Profile.Slug, x.Profile.At }, indexName: "ix_slug_at");
+            });
+    }
+
+    public class NoIndexContext(DbContextOptions<NoIndexContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) => modelBuilder.Entity<Account>(ConfigureAccount);
+    }
+
+    // ── Helpers ──
+
+    private static Dictionary<string, string> PartSqlByName(IEnumerable<MigrationOperation> operations)
+        => operations.OfType<CreateIndexOperation>().ToDictionary(
+               o => o.Name,
+               o => o.FindAnnotation(ComplexIndexAnnotations.IndexParts)?.Value is string json
+                        ? IndexPartsSerializer.Deserialize(json)[0].Value
+                        : o.Columns[0]);
+
+    // The member expression EF's own query compares, with the table alias and identifier quoting
+    // removed: Npgsql quotes only when it must, the differ always does, and PostgreSQL reads both
+    // as the same column.
+    private static string QueriedExpression(Expression<Func<Account, bool>> predicate)
+    {
+        using var context = new MatrixContext(
+            new DbContextOptionsBuilder<MatrixContext>().UseNpgsql(MigrationHarness.NpgsqlConnection).Options);
+
+        var sql   = context.Accounts.Where(predicate).ToQueryString();
+        var where = sql[(sql.IndexOf("WHERE ", StringComparison.Ordinal) + 6)..].ReplaceLineEndings(" ").Trim();
+        var cut   = where.LastIndexOf(" = ", StringComparison.Ordinal);
+
+        return Normalize(cut < 0 ? where : where[..cut]);
+    }
+
+    private static string Normalize(string sql)
+    {
+        sql = Regex.Replace(sql, @"(?<![\w'])a\.", "").Replace("\"", "");
+        return sql.StartsWith('(') && sql.EndsWith(')') ? sql[1..^1] : sql;
+    }
+
+    // ── Rendering ──
+
+    [TestMethod(DisplayName = "Every JSON member type renders exactly as Npgsql's query translation does")]
+    public void Members_render_as_the_query_translation_does()
+    {
+        var parts = PartSqlByName(MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<MatrixContext>()));
+
+        foreach (var (name, _, sql) in Members.Concat(TextFallbackMembers))
+            Assert.AreEqual(sql, parts[name], name);
+    }
+
+    // The guard against drift: the expected SQL above is asserted against EF's own query output, so
+    // a future Npgsql that translates a member differently fails here rather than in production.
+    [TestMethod(DisplayName = "The rendered expressions are the ones EF Core's own queries compare")]
+    public void Rendered_expressions_match_live_query_translation()
+    {
+        var key   = Guid.NewGuid();
+        var blob  = new byte[] { 1, 2, 3 };
+        var cases = new (string Name, Expression<Func<Account, bool>> Query)[]
+        {
+            ("ix_slug",      a => a.Profile.Slug == "x"),
+            ("ix_rank",      a => a.Profile.Rank == 5),
+            ("ix_big",       a => a.Profile.Big == 5L),
+            ("ix_price",     a => a.Profile.Price == 5.25m),
+            ("ix_ratio",     a => a.Profile.Ratio == 0.5),
+            ("ix_active",    a => a.Profile.Active),
+            ("ix_key",       a => a.Profile.Key == key),
+            ("ix_tier",      a => a.Profile.Tier == Tier.Pro),
+            ("ix_tier_text", a => a.Profile.TierText == Tier.Pro),
+            ("ix_maybe",     a => a.Profile.Maybe == 5),
+            ("ix_blob",      a => a.Profile.Blob == blob),
+            ("ix_city",      a => a.Profile.Address.City == "x"),
+            ("ix_zip",       a => a.Profile.Address.Zip == 5),
+            ("ix_postal",    a => a.Profile.Address.PostalCode == "x")
+        };
+
+        var parts = PartSqlByName(MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<MatrixContext>()));
+
+        foreach (var (name, query) in cases)
+            Assert.AreEqual(QueriedExpression(query), Normalize(parts[name]), name);
+    }
+
+    [TestMethod(DisplayName = "A property-level declaration inside the document renders the same way")]
+    public void Property_level_member_renders_typed()
+    {
+        var create = Assert.ContainsSingle(
+            MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<PropertyLevelContext>()).OfType<CreateIndexOperation>());
+
+        Assert.AreEqual("IX_accounts_profileRank", create.Name);
+        Assert.AreEqual("CAST(\"profile\" ->> 'Rank' AS integer)", PartSqlByName([create])[create.Name]);
+    }
+
+    [TestMethod(DisplayName = "Default index names do not change with the rendering")]
+    public void Default_names_are_stable_across_rendering_versions()
+    {
+        var before = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<DefaultNamedBefore54Context>())
+                                     .OfType<CreateIndexOperation>().Select(o => o.Name).Order().ToList();
+        var after  = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<DefaultNamedContext>())
+                                     .OfType<CreateIndexOperation>().Select(o => o.Name).Order().ToList();
+
+        CollectionAssert.AreEqual(before, after);
+        CollectionAssert.Contains(after, "IX_accounts_profileRank");
+        CollectionAssert.Contains(after, "IX_accounts_profileAddressZip");
+        CollectionAssert.Contains(after, "IX_accounts_lowerprofileAddressCity");
+    }
+
+    // ── Rollout ──
+
+    [TestMethod(DisplayName = "A pre-5.4.0 model rebuilds exactly the indexes whose rendering changed, under the same names")]
+    public void Rollout_rebuilds_only_affected_indexes()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(
+            MigrationHarness.NpgsqlModel<MatrixBefore54Context>(),
+            MigrationHarness.NpgsqlModel<MatrixContext>());
+
+        var affected = Members.Select(m => m.Name).Concat(TextFallbackMembers.Select(m => m.Name))
+                              .Where(n => !UnaffectedByRollout.Contains(n)).Order().ToList();
+
+        var dropped = operations.OfType<DropIndexOperation>().Select(o => o.Name).Order().ToList();
+        var created = operations.OfType<CreateIndexOperation>().Select(o => o.Name).Order().ToList();
+
+        Assert.AreEqual(string.Join(", ", affected), string.Join(", ", dropped));
+        Assert.AreEqual(string.Join(", ", affected), string.Join(", ", created));
+
+        // Drops before creates: the same name is dropped and re-created in one migration.
+        var lastDrop    = operations.ToList().FindLastIndex(o => o is DropIndexOperation);
+        var firstCreate = operations.ToList().FindIndex(o => o is CreateIndexOperation);
+        Assert.IsLessThan(firstCreate, lastDrop);
+    }
+
+    [TestMethod(DisplayName = "Once the model carries the rendering version, it diffs clean against itself")]
+    public void Current_rendering_has_no_churn()
+        => Assert.IsEmpty(MigrationHarness.NpgsqlDiff(
+               MigrationHarness.NpgsqlModel<MatrixContext>(),
+               MigrationHarness.NpgsqlModel<MatrixContext>()));
+
+    [TestMethod(DisplayName = "Declaring an index marks the model; a model without one stays unmarked")]
+    public void Declarations_mark_the_model()
+    {
+        Assert.AreEqual(
+            ComplexIndexStorage.CurrentRenderingVersion,
+            MigrationHarness.NpgsqlModel<PropertyLevelContext>().Model[ComplexIndexAnnotations.RenderingVersion]);
+        Assert.IsNull(MigrationHarness.NpgsqlModel<NoIndexContext>().Model[ComplexIndexAnnotations.RenderingVersion]);
+    }
+
+    // ── Filters ──
+
+    [TestMethod(DisplayName = "Index filters render JSON placeholders by the new rules")]
+    public void Index_filters_follow_the_rendering()
+    {
+        var creates = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<FilterContext>())
+                                      .OfType<CreateIndexOperation>().ToDictionary(o => o.Name);
+
+        Assert.AreEqual("(\"profile\" #>> '{Address,City}') IS NOT NULL", creates["ix_filtered_city"].Filter);
+
+        // The old rendering compared text with an integer: 42883 at apply time.
+        StringAssert.Contains(creates["ix_filtered_rank"].Filter, "(CAST(\"profile\" ->> 'Rank' AS integer)) > 5");
+    }
+
+    [TestMethod(DisplayName = "Exclusion constraint filters keep the original JSON rendering")]
+    public void Exclusion_filters_keep_the_original_rendering()
+    {
+        var add = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<FilterContext>())
+                                  .OfType<SqlOperation>().Single(o => o.Sql.Contains("EXCLUDE")).Sql;
+
+        StringAssert.Contains(add, "WHERE ((\"profile\" -> 'Address' ->> 'City') IS NOT NULL)");
+    }
+
+    [TestMethod(DisplayName = "The rollout leaves exclusion constraints alone")]
+    public void Rollout_does_not_touch_exclusion_constraints()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(
+            MigrationHarness.NpgsqlModel<FilterBefore54Context>(),
+            MigrationHarness.NpgsqlModel<FilterContext>());
+
+        Assert.IsFalse(operations.OfType<SqlOperation>().Any(o => o.Sql.Contains("ex_accounts_city")));
+        CollectionAssert.AreEquivalent(
+            new[] { "ix_filtered_city", "ix_filtered_rank" },
+            operations.OfType<CreateIndexOperation>().Select(o => o.Name).ToList());
+    }
+
+    // ── Date and time members ──
+
+    [TestMethod(DisplayName = "A non-unique index leading with a timestamp member is rejected")]
+    public void Non_unique_timestamp_member_is_rejected()
+    {
+        var exception = Assert.ThrowsExactly<InvalidOperationException>(
+            () => MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<NonUniqueDateContext>()));
+
+        StringAssert.Contains(exception.Message, "'ix_at'");
+        StringAssert.Contains(exception.Message, "'Profile.At'");
+        StringAssert.Contains(exception.Message, "timestamp with time zone");
+    }
+
+    [TestMethod(DisplayName = "A non-unique index leading with a DateOnly member is rejected")]
+    public void Non_unique_date_member_is_rejected()
+    {
+        var exception = Assert.ThrowsExactly<InvalidOperationException>(
+            () => MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<NonUniqueDateOnlyContext>()));
+
+        StringAssert.Contains(exception.Message, "'Profile.Day'");
+        StringAssert.Contains(exception.Message, " date.");
+    }
+
+    [TestMethod(DisplayName = "A timestamp member after a usable leading part is allowed")]
+    public void Trailing_timestamp_member_is_allowed()
+    {
+        var create = Assert.ContainsSingle(
+            MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<TrailingDateContext>()).OfType<CreateIndexOperation>());
+
+        Assert.AreEqual("ix_slug_at", create.Name);
+    }
+
+    // Validation reads the target only: a snapshot holding the index must stay diffable, or the
+    // model that removes it could never be migrated.
+    [TestMethod(DisplayName = "A rejected index in the source model can still be dropped")]
+    public void Rejected_index_in_source_can_be_dropped()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(
+            MigrationHarness.NpgsqlModel<NonUniqueDateContext>(),
+            MigrationHarness.NpgsqlModel<NoIndexContext>());
+
+        Assert.AreEqual("ix_at", Assert.ContainsSingle(operations.OfType<DropIndexOperation>()).Name);
+    }
+}
diff --git a/test/EFCore.ComplexIndexes.Tests/PostgresIntegrationTests.cs b/test/EFCore.ComplexIndexes.Tests/PostgresIntegrationTests.cs
index 6dd8c29..33c789a 100644
--- a/test/EFCore.ComplexIndexes.Tests/PostgresIntegrationTests.cs
+++ b/test/EFCore.ComplexIndexes.Tests/PostgresIntegrationTests.cs
@@ -382,6 +382,108 @@ public void Json_member_index_applies_and_enforces()
         Sql("""INSERT INTO ig_employers ("Id", name) VALUES (3, '{"ShortName":"Globex","LegalName":"Globex GmbH"}')""");
     }
 
+    // ── JSON-member indexes are used by EF Core's own queries ──
+
+    private enum Plan { Basic, Pro }
+
+    private class Location
+    {
+        public string City { get; set; } = "";
+        public int    Zip  { get; set; }
+    }
+
+    private class Settings
+    {
+        public int      Rank     { get; set; }
+        public decimal  Price    { get; set; }
+        public bool     Active   { get; set; }
+        public Plan     Plan     { get; set; }
+        public DateTime At       { get; set; }
+        public Location Location { get; set; } = new();
+    }
+
+    private class Tenant
+    {
+        public int      Id       { get; set; }
+        public Settings Settings { get; set; } = new();
+    }
+
+    private class TenantContext(DbContextOptions<TenantContext> options) : DbContext(options)
+    {
+        public DbSet<Tenant> Tenants => Set<Tenant>();
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Tenant>(b =>
+            {
+                b.ToTable("ig_tenants");
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Settings, s => { s.ToJson("settings"); s.ComplexProperty(x => x.Location); });
+                b.HasComplexIndex(x => x.Settings.Location.City, isUnique: true, indexName: "ux_ig_tenants_city");
+                b.HasComplexIndex(x => x.Settings.Location.Zip, indexName: "ix_ig_tenants_zip");
+                b.HasComplexIndex(x => x.Settings.Rank, indexName: "ix_ig_tenants_rank");
+                b.HasComplexIndex(x => x.Settings.Price, indexName: "ix_ig_tenants_price");
+                b.HasComplexIndex(x => x.Settings.Active, indexName: "ix_ig_tenants_active");
+                b.HasComplexIndex(x => x.Settings.Plan, indexName: "ix_ig_tenants_plan");
+                b.HasComplexIndex(x => x.Settings.At, isUnique: true, indexName: "ux_ig_tenants_at");
+            });
+    }
+
+    // What the fix is for: until 5.4.0 only a top-level string member was rendered the way Npgsql's
+    // queries read it, so every index here applied and enforced, and not one was used by a query.
+    // Sequential scans are disabled so that "not used" can only mean "cannot be used".
+    [TestMethod(DisplayName = "EF Core's queries over JSON members use the indexes the differ created")]
+    public void Json_member_indexes_serve_ef_queries()
+    {
+        Migrate<TenantContext>();
+
+        using var context = new TenantContext(new DbContextOptionsBuilder<TenantContext>().UseNpgsql(ConnectionString).Options);
+        var start = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        context.Tenants.AddRange(Enumerable.Range(0, 200).Select(i => new Tenant
+        {
+            Settings = new Settings
+            {
+                Rank = i, Price = i + 0.5m, Active = i % 2 == 0, Plan = (Plan)(i % 2), At = start.AddMinutes(i),
+                Location = new Location { City = $"city-{i}", Zip = 10000 + i }
+            }
+        }));
+        context.SaveChanges();
+
+        var queries = new (string Index, IQueryable<Tenant> Query)[]
+        {
+            ("ux_ig_tenants_city",   context.Tenants.Where(t => t.Settings.Location.City == "city-5")),
+            ("ix_ig_tenants_zip",    context.Tenants.Where(t => t.Settings.Location.Zip == 10005)),
+            ("ix_ig_tenants_rank",   context.Tenants.Where(t => t.Settings.Rank == 5)),
+            ("ix_ig_tenants_price",  context.Tenants.Where(t => t.Settings.Price == 5.5m)),
+            ("ix_ig_tenants_active", context.Tenants.Where(t => t.Settings.Active)),
+            ("ix_ig_tenants_plan",   context.Tenants.Where(t => t.Settings.Plan == Plan.Pro))
+        };
+
+        using var connection = new NpgsqlConnection(ConnectionString);
+        connection.Open();
+        using (var off = new NpgsqlCommand("SET enable_seqscan = off", connection))
+            off.ExecuteNonQuery();
+
+        foreach (var (index, query) in queries)
+        {
+            using var explain = new NpgsqlCommand("EXPLAIN (COSTS OFF) " + query.ToQueryString(), connection);
+            using var reader  = explain.ExecuteReader();
+            var plan = new List<string>();
+            while (reader.Read())
+                plan.Add(reader.GetString(0));
+
+            StringAssert.Contains(string.Join("\n", plan), index, $"{index} is not used:\n{string.Join("\n", plan)}");
+        }
+
+        // Uniqueness still holds, for a nested member and for a date member kept as text — the latter
+        // compared on the text EF itself wrote.
+        string storedAt;
+        using (var read = new NpgsqlCommand("SELECT settings ->> 'At' FROM ig_tenants WHERE settings ->> 'Rank' = '5'", connection))
+            storedAt = (string)read.ExecuteScalar()!;
+
+        AssertRejected("""INSERT INTO ig_tenants (settings) VALUES ('{"Rank":1,"Price":1,"Active":true,"Plan":0,"At":"2030-01-01T00:00:00Z","Location":{"City":"city-5","Zip":1}}')""");
+        AssertRejected($$$"""INSERT INTO ig_tenants (settings) VALUES ('{"Rank":1,"Price":1,"Active":true,"Plan":0,"At":"{{{storedAt}}}","Location":{"City":"elsewhere","Zip":1}}')""");
+    }
+
     // ── The regression: native HasIndex ⇄ HasComplexIndex round-trips cleanly ──
 
     private class EmailAddress
diff --git a/test/EFCore.ComplexIndexes.Tests/SnapshotRoundTripTests.cs b/test/EFCore.ComplexIndexes.Tests/SnapshotRoundTripTests.cs
index 48dbc44..3af4b88 100644
--- a/test/EFCore.ComplexIndexes.Tests/SnapshotRoundTripTests.cs
+++ b/test/EFCore.ComplexIndexes.Tests/SnapshotRoundTripTests.cs
@@ -46,7 +46,7 @@ private static TContext CreateContext<TContext>() where TContext : DbContext
     /// the model from the compiled <see cref="ModelSnapshot"/> — the exact source-model path of
     /// `dotnet ef migrations add`.
     /// </summary>
-    private static IRelationalModel BuildModelViaSnapshot<TContext>() where TContext : DbContext
+    private static IRelationalModel BuildModelViaSnapshot<TContext>(Func<string, string>? editSnapshot = null) where TContext : DbContext
     {
         using var context = CreateContext<TContext>();
 
@@ -63,7 +63,7 @@ private static IRelationalModel BuildModelViaSnapshot<TContext>() where TContext
             modelSnapshotName: "RoundTripSnapshot",
             model: context.GetService<IDesignTimeModel>().Model);
 
-        var snapshot = CompileSnapshot(code);
+        var snapshot = CompileSnapshot(editSnapshot?.Invoke(code) ?? code);
 
         var model = designProvider.GetRequiredService<IModelRuntimeInitializer>()
                                   .Initialize(snapshot.Model, designTime: true, validationLogger: null);
@@ -191,6 +191,48 @@ public void Runtime_differ_accepts_converter_member_snapshot()
             "Migrate() uses this runtime pending-model-changes check before applying migrations.");
     }
 
+    [TestMethod(DisplayName = "JSON-member indexes of every type survive the snapshot round trip without churn")]
+    public void Json_member_roundtrip_is_noop()
+    {
+        var operations = GetDifferences(
+            source: BuildModelViaSnapshot<RoundTripJsonContext>(),
+            target: BuildLiveModel<RoundTripJsonContext>());
+
+        Assert.IsEmpty(operations, string.Join("\n", operations.Select(o => o.GetType().Name + " " + (o as CreateIndexOperation)?.Name)));
+    }
+
+    // The rollout's premise, checked on a real snapshot: the rendering version is written into it, and
+    // a snapshot without it — every snapshot scaffolded before 5.4.0 — rebuilds exactly the indexes
+    // whose rendering changed. If the key never reached the snapshot, the first test above would pass
+    // for the wrong reason and every later `migrations add` would rebuild these indexes again.
+    [TestMethod(DisplayName = "A snapshot scaffolded before 5.4.0 rebuilds exactly the affected JSON-member indexes")]
+    public void Pre_54_snapshot_rebuilds_affected_json_indexes()
+    {
+        var sawKey = false;
+        var source = BuildModelViaSnapshot<RoundTripJsonContext>(code =>
+        {
+            sawKey = code.Contains($"\"{ComplexIndexAnnotations.RenderingVersion}\", 2");
+            return System.Text.RegularExpressions.Regex.Replace(
+                code, $@"\s*\.HasAnnotation\(""{ComplexIndexAnnotations.RenderingVersion}"", 2\)", "");
+        });
+
+        Assert.IsTrue(sawKey, "The rendering version must be written into the snapshot.");
+
+        var operations = GetDifferences(source, BuildLiveModel<RoundTripJsonContext>());
+
+        var affected = NpgsqlJsonMemberRenderingTests.Members.Select(m => m.Name)
+                                                     .Concat(NpgsqlJsonMemberRenderingTests.TextFallbackMembers.Select(m => m.Name))
+                                                     .Where(n => !NpgsqlJsonMemberRenderingTests.UnaffectedByRollout.Contains(n))
+                                                     .Append("ix_filtered_city")
+                                                     .Append("ix_filtered_rank")
+                                                     .Order()
+                                                     .ToList();
+
+        Assert.AreEqual(string.Join(", ", affected), string.Join(", ", operations.OfType<DropIndexOperation>().Select(o => o.Name).Order()));
+        Assert.AreEqual(string.Join(", ", affected), string.Join(", ", operations.OfType<CreateIndexOperation>().Select(o => o.Name).Order()));
+        Assert.IsFalse(operations.OfType<SqlOperation>().Any(), "Exclusion constraints keep their rendering.");
+    }
+
     [TestMethod(DisplayName = "A filter change against the snapshot model is still detected")]
     public void Exclusion_filter_change_is_detected_against_snapshot()
     {
@@ -391,4 +433,15 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
         });
 }
 
+// Every JSON member type the differ renders, plus index and exclusion filters over JSON members.
+internal class RoundTripJsonContext(DbContextOptions<RoundTripJsonContext> options) : DbContext(options)
+{
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+        => modelBuilder.Entity<NpgsqlJsonMemberRenderingTests.Account>(b =>
+        {
+            NpgsqlJsonMemberRenderingTests.DeclareMatrix(b);
+            NpgsqlJsonMemberRenderingTests.DeclareFilters(b);
+        });
+}
+
 #pragma warning restore EF1001

From 3c8e11b278a96c678030b415bb1f3ba2efa2a426 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ricardo=20Gro=C3=9F?= <ricardo@mr-gross.de>
Date: Tue, 22 Sep 2026 20:59:32 +0200
Subject: [PATCH 2/3] fix: check PostgreSQL names across kinds and namespaces

PostgreSQL keeps constraint names unique per table and index names
unique per schema, including the index behind every primary key,
unique, exclusion and temporal constraint. Each kind was checked
against its own kind on one table at most, so two temporal constraints
with one name, a temporal foreign key named like a foreign key on its
table, or a temporal constraint named like an index elsewhere in the
schema scaffolded cleanly and failed at apply time (42710, 42P07).

Against an exclusion constraint it did not fail at all: the exclusion
ADD is preceded by DROP CONSTRAINT IF EXISTS, so the same-named
temporal constraint was dropped. Confirmed on PostgreSQL 18: the
migration applied clean and only the EXCLUDE constraint remained.

ValidateNamesAcrossKinds runs last over the target model's complex
indexes, exclusion, temporal and temporal FK constraints plus EF's own
indexes, keys, foreign keys and check constraints, and reports a
collision when one party is this package's. The snapshot side stays
diffable. Removing the check fails the 8 collision tests; the 4 tests
for legitimate reuse pass either way, as they guard against the check
growing too strict.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   6 +-
 CLAUDE.md                                     |  13 +
 .../CHANGELOG.md                              |   6 +
 ...NpgsqlComplexIndexMigrationsModelDiffer.cs | 103 ++++++
 .../CustomMigrationsModelDiffer.cs            |   2 +-
 .../NpgsqlNameCollisionTests.cs               | 325 ++++++++++++++++++
 6 files changed, 452 insertions(+), 3 deletions(-)
 create mode 100644 test/EFCore.ComplexIndexes.Tests/NpgsqlNameCollisionTests.cs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dab872f..a8dc54e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,11 +8,13 @@ covering only what changed for that package:
 
 ## 5.4.0
 
-Fixes to what 5.x already ships, found while testing the packages against EF Core 11: indexes on
-JSON members that no query could use.
+Fixes to what 5.x already ships, found while testing the packages against EF Core 11 and planning
+the next features: indexes on JSON members that no query could use, and constraint names that only
+failed — or quietly vanished — when the migration was applied.
 
 - **Fixed:** indexes on members of a `ToJson()` complex property are written the way Npgsql's queries read the member, so PostgreSQL can use them. It uses an expression index only for a query whose expression matches, and until now every member was extracted as `"doc" -> 'A' ->> 'B'` text with no cast, which matched only a top-level string. A nested member (`#>> '{Address,City}'` in the query) or a typed one (`CAST("doc" ->> 'Rank' AS integer)`) got an index that applied cleanly, enforced uniqueness, and was never used by a single query. Members now render as Npgsql renders them — `->>` or `#>>`, cast to the member's store type unless it is a string, `decode(…, 'base64')` for `byte[]`, `jsonb` for a primitive collection — in index parts, typed expression indexes and index filters. That also makes a filter such as `x => x.Profile.Rank > 5` valid SQL: it compared text with an integer and failed at apply time. Default index names do not change. **Upgrading:** the first `migrations add` drops and re-creates each affected index under its existing name; indexes on top-level string members are untouched. Until that migration exists, `has-pending-model-changes` reports changes and `Migrate()` raises EF Core's pending-model-changes error. The re-create blocks writes while it builds, so on a large table declare the index with `IsCreatedConcurrently()` first. Exclusion constraint filters keep their rendering. The snapshot gains one `CustomIndex:RenderingVersion` annotation, which records the rules a model was declared under and is what lets the change reach databases built by earlier versions.
 - **Changed:** a non-unique index that starts with a date or time JSON member (`DateTime`, `DateTimeOffset`, `DateOnly`, `TimeOnly`) is rejected at `migrations add`. EF Core's queries cast such a member to `timestamptz`, `date` or `time`, and PostgreSQL cannot index those casts (the conversion from text is not IMMUTABLE), so no query could ever use the index. A unique one is still allowed and enforces uniqueness on the stored text; a member in a later position leaves the index usable through the parts before it.
+- **Fixed:** on PostgreSQL, a name this package introduces is checked against every object it shares a namespace with, at `migrations add`. PostgreSQL keeps constraint names unique per table and index names unique per schema — including the index behind every primary key, unique, exclusion and temporal constraint — but each kind was checked against its own kind on one table at most. Two temporal constraints with one name, a temporal foreign key named like a foreign key on its table, or a temporal constraint named like an index anywhere in the schema scaffolded cleanly and failed when applied (42710, 42P07). Against an exclusion constraint it did not even fail: every exclusion constraint is added after `DROP CONSTRAINT IF EXISTS`, so a same-named temporal constraint was dropped and the migration applied clean, one declared guarantee short. Two explicitly named complex indexes on different tables of one schema are caught the same way. A collision between two of EF Core's own objects is left to EF; a snapshot holding a collision stays diffable.
 
 ## 5.3.0
 
diff --git a/CLAUDE.md b/CLAUDE.md
index 3fa105b..87673e3 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -283,6 +283,19 @@ revoked rows" collapsed to one constraint. Name collisions matter more here than
 every ADD is preceded by `DROP CONSTRAINT IF EXISTS`, so a duplicate name does not fail at apply
 time — the second constraint silently replaces the first.
 
+The per-kind checks above each compare a kind with itself on one table, which is not how
+PostgreSQL scopes names, so since 5.4.0 the Npgsql differ's `ValidateNamesAcrossKinds` runs last
+over everything the target model introduces — complex indexes, exclusion, temporal and temporal
+foreign key constraints — plus EF's own indexes, keys, foreign keys and check constraints. Two
+namespaces: constraint names per **table** (42710; against an exclusion constraint, a silent
+replacement instead, confirmed on PostgreSQL 18: the temporal `UNIQUE` vanished and the migration
+applied clean), and index names per **schema**, where every primary key, unique, exclusion and
+temporal constraint also owns an index (42P07). A collision is reported only when one party is
+this package's; two of EF's own objects are EF's business. It collects into a list, not a set: the
+two same-named declarations it exists to find produce identical entries, and a set merged them.
+Core's `ValidateUniqueIndexNames` stays per table on purpose — SQL Server scopes index names per
+table.
+
 ### The read model is the differ's reader
 
 `ComplexIndexModelExtensions.GetDeclaredComplexIndexes` (core) and
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md b/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md
index ce72bbf..2640a49 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md
@@ -17,6 +17,12 @@ covers all three packages.
 - **Changed:** a non-unique index that starts with a `DateTime`, `DateTimeOffset`, `DateOnly` or
   `TimeOnly` JSON member is rejected at `migrations add`: the queries cast the member to a type
   PostgreSQL cannot index from text, so the index could never be used. Unique ones are allowed.
+- **Fixed:** names are checked across kinds at `migrations add`: constraint names per table
+  (temporal, temporal foreign key and exclusion constraints against each other and against EF's
+  keys, foreign keys and check constraints) and index names per schema (complex indexes and the
+  index behind every unique, exclusion and temporal constraint, against EF's indexes and keys).
+  Such a clash failed at apply time with 42710 or 42P07 — or, against an exclusion constraint,
+  whose ADD is preceded by `DROP CONSTRAINT IF EXISTS`, silently dropped the other constraint.
 
 ## 5.2.0
 
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs
index 01bcb55..9d4ca52 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs
@@ -355,9 +355,112 @@ public override IReadOnlyList<MigrationOperation> GetDifferences(
             operations = withExtension;
         }
 
+        // Last, so the per-kind checks before it keep their own messages.
+        ValidateNamesAcrossKinds(target);
+
         return operations;
     }
 
+    /// <summary>
+    /// Fails when a name this package introduces is already taken in the PostgreSQL namespace it
+    /// lands in — by another declaration of any kind, or by one of EF Core's own.
+    /// </summary>
+    /// <remarks>
+    /// PostgreSQL has two namespaces here. A constraint name is unique among the constraints of its
+    /// table: a clash fails the migration with 42710, or — every exclusion constraint being added
+    /// after <c>DROP CONSTRAINT IF EXISTS</c> — silently replaces the other constraint. And an index
+    /// name, including the index behind every primary key, unique, exclusion and temporal
+    /// constraint, is unique among all relations of its schema, not its table: a clash fails with
+    /// 42P07. Each kind used to be checked against its own kind on the same table at most, so a
+    /// temporal constraint named like an exclusion constraint, or like an index anywhere in the
+    /// schema, scaffolded cleanly. Collisions between two of EF Core's own objects are not this
+    /// package's to police. Target model only: a snapshot that already holds a collision must stay
+    /// diffable, or the model could never be fixed.
+    /// </remarks>
+    private void ValidateNamesAcrossKinds(IRelationalModel? target)
+    {
+        if (target is null)
+            return;
+
+        // A list, not a set: two declarations with one name on one table produce identical entries,
+        // and a set would merge exactly the pair this check exists to find. Every source below is
+        // already free of duplicates.
+        var defaultSchema = target.Model.GetDefaultSchema() ?? "public";
+        var names         = new List<NamedObject>();
+
+        void Add(string name, string table, string? schema, string kind, bool ours, bool constraint, bool indexBacked)
+            => names.Add(new NamedObject(name, table, schema ?? defaultSchema, kind, ours, constraint, indexBacked));
+
+        foreach (var index in ExtractAllIndexDescriptors(target))
+            Add(index.IndexName, index.TableName, index.Schema, "complex index", ours: true, constraint: false, indexBacked: true);
+
+        var temporal = BuildDescriptors(target, _typeMappingSource);
+        foreach (var constraint in temporal)
+            Add(constraint.Name, constraint.Table, constraint.Schema, "temporal constraint", ours: true, constraint: true, indexBacked: true);
+
+        foreach (var foreignKey in BuildForeignKeyDescriptors(target, _typeMappingSource, temporal))
+            Add(foreignKey.Name, foreignKey.DependentTable, foreignKey.DependentSchema, "temporal foreign key", ours: true, constraint: true, indexBacked: false);
+
+        foreach (var exclusion in BuildExclusionDescriptors(target))
+            Add(exclusion.Name, exclusion.Table, exclusion.Schema, "exclusion constraint", ours: true, constraint: true, indexBacked: true);
+
+        foreach (var table in target.Tables)
+        {
+            foreach (var index in table.Indexes)
+                Add(index.Name, table.Name, table.Schema, "index", ours: false, constraint: false, indexBacked: true);
+
+            foreach (var key in table.UniqueConstraints)
+                Add(key.Name, table.Name, table.Schema, key.GetIsPrimaryKey() ? "primary key" : "unique constraint", ours: false, constraint: true, indexBacked: true);
+
+            foreach (var foreignKey in table.ForeignKeyConstraints)
+                Add(foreignKey.Name, table.Name, table.Schema, "foreign key", ours: false, constraint: true, indexBacked: false);
+
+            // A check constraint without a name gets one from PostgreSQL, which never collides.
+            foreach (var check in table.CheckConstraints.Where(c => c.Name is not null))
+                Add(check.Name!, table.Name, table.Schema, "check constraint", ours: false, constraint: true, indexBacked: false);
+        }
+
+        ThrowOnFirstCollision(
+            names.Where(n => n.IsConstraint).GroupBy(n => (n.Schema, n.Table, n.Name)),
+            other => "PostgreSQL keeps constraint names unique per table, so the migration would fail when applied (42710)"
+                   + (other.Any(o => o.Kind == "exclusion constraint")
+                          ? " — or, since every exclusion constraint is added after DROP CONSTRAINT IF EXISTS, silently replace the other constraint."
+                          : "."));
+
+        ThrowOnFirstCollision(
+            names.Where(n => n.IsIndexBacked).GroupBy(n => (n.Schema, "", n.Name)),
+            other => "PostgreSQL keeps index names — including the index behind every primary key, unique, exclusion and "
+                   + $"temporal constraint — unique per schema ('{other[0].Schema}'), so the migration would fail when applied (42P07).");
+
+        static void ThrowOnFirstCollision(
+            IEnumerable<IGrouping<(string Schema, string Table, string Name), NamedObject>> groups,
+            Func<IReadOnlyList<NamedObject>, string>                                        rule)
+        {
+            foreach (var group in groups)
+            {
+                var members = group.ToList();
+                var ours    = members.FirstOrDefault(m => m.Ours);
+                if (ours is null || members.Count < 2)
+                    continue;
+
+                var other = members.First(m => !ReferenceEquals(m, ours));
+
+                throw new InvalidOperationException(
+                    $"The {ours.Kind} '{ours.Name}' on table '{ours.Table}' has the same name as the {other.Kind} on table "
+                  + $"'{other.Table}'. {rule([ours, other])} Give one of them a different name.");
+            }
+        }
+    }
+
+    private sealed record NamedObject(
+        string Name,
+        string Table,
+        string Schema,
+        string Kind,
+        bool   Ours,
+        bool   IsConstraint,
+        bool   IsIndexBacked);
+
     // Diffs the temporal UNIQUE constraints and temporal FOREIGN KEY constraints declared on entity
     // types. Drops are emitted as EF's own Drop* operations (the stock generator renders those
     // correctly) and placed before the base EF operations; adds are fully rendered DDL emitted as
diff --git a/src/EFCore.ComplexIndexes/CustomMigrationsModelDiffer.cs b/src/EFCore.ComplexIndexes/CustomMigrationsModelDiffer.cs
index fcdac41..776f50a 100644
--- a/src/EFCore.ComplexIndexes/CustomMigrationsModelDiffer.cs
+++ b/src/EFCore.ComplexIndexes/CustomMigrationsModelDiffer.cs
@@ -666,7 +666,7 @@ protected virtual (int Length, string Unit) MeasureIdentifier(string identifier)
 
     // Declarations come from the same reader an application uses (ComplexIndexModelExtensions),
     // so the read model and the migration cannot disagree about what was declared.
-    private HashSet<IndexDescriptor> ExtractAllIndexDescriptors(IRelationalModel? relationalModel)
+    internal HashSet<IndexDescriptor> ExtractAllIndexDescriptors(IRelationalModel? relationalModel)
     {
         var result = new HashSet<IndexDescriptor>();
         if (relationalModel is null) return result;
diff --git a/test/EFCore.ComplexIndexes.Tests/NpgsqlNameCollisionTests.cs b/test/EFCore.ComplexIndexes.Tests/NpgsqlNameCollisionTests.cs
new file mode 100644
index 0000000..fcc9d37
--- /dev/null
+++ b/test/EFCore.ComplexIndexes.Tests/NpgsqlNameCollisionTests.cs
@@ -0,0 +1,325 @@
+using EFCore.ComplexIndexes.PostgreSQL;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Migrations.Operations;
+using NpgsqlTypes;
+
+namespace EFCore.ComplexIndexes.Tests;
+
+/// <summary>
+/// PostgreSQL keeps constraint names unique per table and index names — including the index behind
+/// every primary key, unique, exclusion and temporal constraint — unique per schema. Each kind was
+/// checked against its own kind on one table at most, so a temporal constraint named like an
+/// exclusion constraint, a temporal foreign key named like a native one, or any index-backed name
+/// reused elsewhere in the schema scaffolded cleanly and failed at apply time (42710, 42P07) — or,
+/// against an exclusion constraint, whose ADD is preceded by DROP CONSTRAINT IF EXISTS, silently
+/// replaced the other constraint.
+/// </summary>
+[TestClass]
+public class NpgsqlNameCollisionTests
+{
+    private class Booking
+    {
+        public int                   Id     { get; set; }
+        public int                   RoomId { get; set; }
+        public int                   DeskId { get; set; }
+        public string                Code   { get; set; } = "";
+        public NpgsqlRange<DateOnly> Period { get; set; }
+    }
+
+    private class Stay
+    {
+        public int                   Id        { get; set; }
+        public int                   BookingId { get; set; }
+        public int                   RoomId    { get; set; }
+        public string                Code      { get; set; } = "";
+        public NpgsqlRange<DateOnly> Period    { get; set; }
+    }
+
+    private static void MapBooking(EntityTypeBuilder<Booking> b, string? schema = null)
+    {
+        b.ToTable("bookings", schema);
+        b.HasKey(x => x.Id);
+    }
+
+    private static void MapStay(EntityTypeBuilder<Stay> b, string? schema = null)
+    {
+        b.ToTable("stays", schema);
+        b.HasKey(x => x.Id);
+    }
+
+    private abstract class ModelContext(DbContextOptions options) : DbContext(options)
+    {
+        protected abstract void Configure(ModelBuilder modelBuilder);
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder) => Configure(modelBuilder);
+    }
+
+    // ── Collisions ──
+
+    private class TwoTemporalConstraintsContext(DbContextOptions<TwoTemporalConstraintsContext> o) : ModelContext(o)
+    {
+        protected override void Configure(ModelBuilder m) => m.Entity<Booking>(b =>
+        {
+            MapBooking(b);
+            b.HasTemporalConstraint(x => x.RoomId, x => x.Period, name: "tc_booking");
+            b.HasTemporalConstraint(x => x.DeskId, x => x.Period, name: "tc_booking");
+        });
+    }
+
+    private class TemporalLikeExclusionContext(DbContextOptions<TemporalLikeExclusionContext> o) : ModelContext(o)
+    {
+        protected override void Configure(ModelBuilder m) => m.Entity<Booking>(b =>
+        {
+            MapBooking(b);
+            b.HasTemporalConstraint(x => x.RoomId, x => x.Period, name: "no_overlap");
+            b.HasExclusionConstraint(x => x.DeskId, x => x.Period, name: "no_overlap");
+        });
+    }
+
+    private class TemporalForeignKeyLikeConstraintContext(DbContextOptions<TemporalForeignKeyLikeConstraintContext> o) : ModelContext(o)
+    {
+        protected override void Configure(ModelBuilder m)
+        {
+            m.Entity<Booking>(b =>
+            {
+                MapBooking(b);
+                b.HasTemporalConstraint(x => x.RoomId, x => x.Period);
+            });
+            m.Entity<Stay>(b =>
+            {
+                MapStay(b);
+                b.HasTemporalConstraint(x => x.BookingId, x => x.Period, name: "stay_rules");
+                b.HasTemporalForeignKey<Stay, Booking>(x => x.RoomId, x => x.Period, x => x.RoomId, x => x.Period, name: "stay_rules");
+            });
+        }
+    }
+
+    private class TemporalLikeNativeIndexElsewhereContext(DbContextOptions<TemporalLikeNativeIndexElsewhereContext> o) : ModelContext(o)
+    {
+        protected override void Configure(ModelBuilder m)
+        {
+            m.Entity<Booking>(b =>
+            {
+                MapBooking(b);
+                b.HasTemporalConstraint(x => x.RoomId, x => x.Period, name: "ix_code");
+            });
+            m.Entity<Stay>(b =>
+            {
+                MapStay(b);
+                b.HasIndex(x => x.Code).HasDatabaseName("ix_code");
+            });
+        }
+    }
+
+    private class TemporalLikeComplexIndexContext(DbContextOptions<TemporalLikeComplexIndexContext> o) : ModelContext(o)
+    {
+        protected override void Configure(ModelBuilder m) => m.Entity<Booking>(b =>
+        {
+            MapBooking(b);
+            b.HasTemporalConstraint(x => x.RoomId, x => x.Period, name: "booking_room");
+            b.HasComplexIndex(x => x.Code, indexName: "booking_room");
+        });
+    }
+
+    private class ComplexIndexesAcrossTablesContext(DbContextOptions<ComplexIndexesAcrossTablesContext> o) : ModelContext(o)
+    {
+        protected override void Configure(ModelBuilder m)
+        {
+            m.Entity<Booking>(b =>
+            {
+                MapBooking(b);
+                b.HasComplexIndex(x => x.Code, indexName: "ix_by_code");
+            });
+            m.Entity<Stay>(b =>
+            {
+                MapStay(b);
+                b.HasComplexIndex(x => x.Code, indexName: "ix_by_code");
+            });
+        }
+    }
+
+    private class TemporalForeignKeyLikeNativeForeignKeyContext(DbContextOptions<TemporalForeignKeyLikeNativeForeignKeyContext> o) : ModelContext(o)
+    {
+        protected override void Configure(ModelBuilder m)
+        {
+            m.Entity<Booking>(b =>
+            {
+                MapBooking(b);
+                b.HasTemporalConstraint(x => x.RoomId, x => x.Period);
+            });
+            m.Entity<Stay>(b =>
+            {
+                MapStay(b);
+                b.HasOne<Booking>().WithMany().HasForeignKey(x => x.BookingId).HasConstraintName("fk_stay");
+                b.HasTemporalForeignKey<Stay, Booking>(x => x.RoomId, x => x.Period, x => x.RoomId, x => x.Period, name: "fk_stay");
+            });
+        }
+    }
+
+    private class TemporalLikeAlternateKeyElsewhereContext(DbContextOptions<TemporalLikeAlternateKeyElsewhereContext> o) : ModelContext(o)
+    {
+        protected override void Configure(ModelBuilder m)
+        {
+            m.Entity<Booking>(b =>
+            {
+                MapBooking(b);
+                b.HasTemporalConstraint(x => x.RoomId, x => x.Period, name: "ak_code");
+            });
+            m.Entity<Stay>(b =>
+            {
+                MapStay(b);
+                b.HasAlternateKey(x => x.Code).HasName("ak_code");
+            });
+        }
+    }
+
+    // ── Legitimate reuse ──
+
+    private class TemporalForeignKeysAcrossTablesContext(DbContextOptions<TemporalForeignKeysAcrossTablesContext> o) : ModelContext(o)
+    {
+        protected override void Configure(ModelBuilder m)
+        {
+            m.Entity<Booking>(b =>
+            {
+                MapBooking(b);
+                b.HasTemporalConstraint(x => x.RoomId, x => x.Period);
+                b.HasTemporalConstraint(x => x.DeskId, x => x.Period);
+                b.HasTemporalForeignKey<Booking, Booking>(x => x.DeskId, x => x.Period, x => x.RoomId, x => x.Period, name: "fk_room");
+            });
+            m.Entity<Stay>(b =>
+            {
+                MapStay(b);
+                b.HasTemporalForeignKey<Stay, Booking>(x => x.RoomId, x => x.Period, x => x.RoomId, x => x.Period, name: "fk_room");
+            });
+        }
+    }
+
+    private class SameNameInTwoSchemasContext(DbContextOptions<SameNameInTwoSchemasContext> o) : ModelContext(o)
+    {
+        protected override void Configure(ModelBuilder m)
+        {
+            m.Entity<Booking>(b =>
+            {
+                MapBooking(b, "north");
+                b.HasTemporalConstraint(x => x.RoomId, x => x.Period, name: "tc_room");
+            });
+            m.Entity<Stay>(b =>
+            {
+                MapStay(b, "south");
+                b.HasTemporalConstraint(x => x.RoomId, x => x.Period, name: "tc_room");
+            });
+        }
+    }
+
+    // Two of EF Core's own indexes: nothing this package introduced, so nothing it reports.
+    private class NativeOnlyCollisionContext(DbContextOptions<NativeOnlyCollisionContext> o) : ModelContext(o)
+    {
+        protected override void Configure(ModelBuilder m)
+        {
+            m.Entity<Booking>(b =>
+            {
+                MapBooking(b);
+                b.HasIndex(x => x.Code).HasDatabaseName("ix_shared");
+                b.HasTemporalConstraint(x => x.RoomId, x => x.Period);
+            });
+            m.Entity<Stay>(b =>
+            {
+                MapStay(b);
+                b.HasIndex(x => x.Code).HasDatabaseName("ix_shared");
+            });
+        }
+    }
+
+    private class FixedContext(DbContextOptions<FixedContext> o) : ModelContext(o)
+    {
+        protected override void Configure(ModelBuilder m) => m.Entity<Booking>(b =>
+        {
+            MapBooking(b);
+            b.HasTemporalConstraint(x => x.RoomId, x => x.Period, name: "tc_room");
+            b.HasTemporalConstraint(x => x.DeskId, x => x.Period, name: "tc_desk");
+        });
+    }
+
+    private static InvalidOperationException Rejected<TContext>() where TContext : DbContext
+        => Assert.ThrowsExactly<InvalidOperationException>(
+               () => MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<TContext>()));
+
+    private static void Accepted<TContext>() where TContext : DbContext
+        => MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<TContext>());
+
+    [TestMethod(DisplayName = "Two temporal constraints with one name on one table are rejected (42710)")]
+    public void Two_temporal_constraints_collide()
+    {
+        var message = Rejected<TwoTemporalConstraintsContext>().Message;
+        StringAssert.Contains(message, "temporal constraint 'tc_booking' on table 'bookings'");
+        StringAssert.Contains(message, "(42710)");
+    }
+
+    [TestMethod(DisplayName = "A temporal constraint named like an exclusion constraint is rejected, and the silent replacement named")]
+    public void Temporal_constraint_like_exclusion_constraint_collides()
+    {
+        var message = Rejected<TemporalLikeExclusionContext>().Message;
+        StringAssert.Contains(message, "exclusion constraint");
+        StringAssert.Contains(message, "DROP CONSTRAINT IF EXISTS");
+    }
+
+    [TestMethod(DisplayName = "A temporal foreign key named like a temporal constraint on its table is rejected")]
+    public void Temporal_foreign_key_like_temporal_constraint_collides()
+    {
+        var message = Rejected<TemporalForeignKeyLikeConstraintContext>().Message;
+        StringAssert.Contains(message, "'stay_rules'");
+        StringAssert.Contains(message, "temporal foreign key");
+    }
+
+    [TestMethod(DisplayName = "A temporal constraint named like an index on another table is rejected (42P07)")]
+    public void Temporal_constraint_like_native_index_elsewhere_collides()
+    {
+        var message = Rejected<TemporalLikeNativeIndexElsewhereContext>().Message;
+        StringAssert.Contains(message, "the index on table 'stays'");
+        StringAssert.Contains(message, "(42P07)");
+    }
+
+    [TestMethod(DisplayName = "A temporal constraint named like a complex index on its table is rejected")]
+    public void Temporal_constraint_like_complex_index_collides()
+        => StringAssert.Contains(Rejected<TemporalLikeComplexIndexContext>().Message, "(42P07)");
+
+    [TestMethod(DisplayName = "Two complex indexes with one name on different tables of one schema are rejected")]
+    public void Complex_indexes_across_tables_collide()
+    {
+        var message = Rejected<ComplexIndexesAcrossTablesContext>().Message;
+        StringAssert.Contains(message, "complex index 'ix_by_code'");
+        StringAssert.Contains(message, "unique per schema");
+    }
+
+    [TestMethod(DisplayName = "A temporal foreign key named like a native foreign key on its table is rejected")]
+    public void Temporal_foreign_key_like_native_foreign_key_collides()
+        => StringAssert.Contains(Rejected<TemporalForeignKeyLikeNativeForeignKeyContext>().Message, "the foreign key on table 'stays'");
+
+    [TestMethod(DisplayName = "A temporal constraint named like an alternate key on another table is rejected")]
+    public void Temporal_constraint_like_alternate_key_elsewhere_collides()
+        => StringAssert.Contains(Rejected<TemporalLikeAlternateKeyElsewhereContext>().Message, "the unique constraint on table 'stays'");
+
+    [TestMethod(DisplayName = "Temporal foreign keys may share a name across tables — they own no index")]
+    public void Temporal_foreign_keys_across_tables_are_allowed()
+        => Accepted<TemporalForeignKeysAcrossTablesContext>();
+
+    [TestMethod(DisplayName = "The same name in two schemas is allowed")]
+    public void Same_name_in_two_schemas_is_allowed()
+        => Accepted<SameNameInTwoSchemasContext>();
+
+    [TestMethod(DisplayName = "A collision between two of EF Core's own objects is not reported")]
+    public void Native_only_collision_is_not_reported()
+        => Accepted<NativeOnlyCollisionContext>();
+
+    // Target only: the snapshot is history, and a model that fixes the collision must diff.
+    [TestMethod(DisplayName = "A collision in the source model does not block the fix")]
+    public void Collision_in_source_stays_diffable()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(
+            MigrationHarness.NpgsqlModel<TwoTemporalConstraintsContext>(),
+            MigrationHarness.NpgsqlModel<FixedContext>());
+
+        Assert.IsTrue(operations.OfType<SqlOperation>().Any(o => o.Sql.Contains("tc_desk")));
+    }
+}

From 127ff6db39cfb08805b587a0d163260d65053575 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ricardo=20Gro=C3=9F?= <ricardo@mr-gross.de>
Date: Tue, 22 Sep 2026 21:06:01 +0200
Subject: [PATCH 3/3] fix: render json/jsonb JSON members as jsonb fragments,
 as Npgsql does

Found by the migration-safety review of this release. A json/jsonb
scalar inside a ToJson document (a JsonDocument, say) rendered as
CAST("doc" ->> 'Raw' AS jsonb), while Npgsql's query translation reads
it as "doc" -> 'Raw' (its NpgsqlJsonTypeMapping case, checked before the
string case). The index would not match the query, and the text round
trip fails CREATE INDEX on any document holding a JSON string there.
Reverting the check makes the new test fail with the CAST form.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  2 +-
 CLAUDE.md                                     |  2 +-
 docs/postgresql-indexes.md                    |  2 +-
 .../CHANGELOG.md                              |  3 +-
 ...NpgsqlComplexIndexMigrationsModelDiffer.cs | 16 +++++-----
 .../NpgsqlJsonMemberRenderingTests.cs         | 31 +++++++++++++++++++
 6 files changed, 45 insertions(+), 11 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a8dc54e..5bd52aa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,7 +12,7 @@ Fixes to what 5.x already ships, found while testing the packages against EF Cor
 the next features: indexes on JSON members that no query could use, and constraint names that only
 failed — or quietly vanished — when the migration was applied.
 
-- **Fixed:** indexes on members of a `ToJson()` complex property are written the way Npgsql's queries read the member, so PostgreSQL can use them. It uses an expression index only for a query whose expression matches, and until now every member was extracted as `"doc" -> 'A' ->> 'B'` text with no cast, which matched only a top-level string. A nested member (`#>> '{Address,City}'` in the query) or a typed one (`CAST("doc" ->> 'Rank' AS integer)`) got an index that applied cleanly, enforced uniqueness, and was never used by a single query. Members now render as Npgsql renders them — `->>` or `#>>`, cast to the member's store type unless it is a string, `decode(…, 'base64')` for `byte[]`, `jsonb` for a primitive collection — in index parts, typed expression indexes and index filters. That also makes a filter such as `x => x.Profile.Rank > 5` valid SQL: it compared text with an integer and failed at apply time. Default index names do not change. **Upgrading:** the first `migrations add` drops and re-creates each affected index under its existing name; indexes on top-level string members are untouched. Until that migration exists, `has-pending-model-changes` reports changes and `Migrate()` raises EF Core's pending-model-changes error. The re-create blocks writes while it builds, so on a large table declare the index with `IsCreatedConcurrently()` first. Exclusion constraint filters keep their rendering. The snapshot gains one `CustomIndex:RenderingVersion` annotation, which records the rules a model was declared under and is what lets the change reach databases built by earlier versions.
+- **Fixed:** indexes on members of a `ToJson()` complex property are written the way Npgsql's queries read the member, so PostgreSQL can use them. It uses an expression index only for a query whose expression matches, and until now every member was extracted as `"doc" -> 'A' ->> 'B'` text with no cast, which matched only a top-level string. A nested member (`#>> '{Address,City}'` in the query) or a typed one (`CAST("doc" ->> 'Rank' AS integer)`) got an index that applied cleanly, enforced uniqueness, and was never used by a single query. Members now render as Npgsql renders them — `->>` or `#>>`, cast to the member's store type unless it is a string, `decode(…, 'base64')` for `byte[]`, `jsonb` for a primitive collection or a `json`/`jsonb` member — in index parts, typed expression indexes and index filters. That also makes a filter such as `x => x.Profile.Rank > 5` valid SQL: it compared text with an integer and failed at apply time. Default index names do not change. **Upgrading:** the first `migrations add` drops and re-creates each affected index under its existing name; indexes on top-level string members are untouched. Until that migration exists, `has-pending-model-changes` reports changes and `Migrate()` raises EF Core's pending-model-changes error. The re-create blocks writes while it builds, so on a large table declare the index with `IsCreatedConcurrently()` first. Exclusion constraint filters keep their rendering. The snapshot gains one `CustomIndex:RenderingVersion` annotation, which records the rules a model was declared under and is what lets the change reach databases built by earlier versions.
 - **Changed:** a non-unique index that starts with a date or time JSON member (`DateTime`, `DateTimeOffset`, `DateOnly`, `TimeOnly`) is rejected at `migrations add`. EF Core's queries cast such a member to `timestamptz`, `date` or `time`, and PostgreSQL cannot index those casts (the conversion from text is not IMMUTABLE), so no query could ever use the index. A unique one is still allowed and enforces uniqueness on the stored text; a member in a later position leaves the index usable through the parts before it.
 - **Fixed:** on PostgreSQL, a name this package introduces is checked against every object it shares a namespace with, at `migrations add`. PostgreSQL keeps constraint names unique per table and index names unique per schema — including the index behind every primary key, unique, exclusion and temporal constraint — but each kind was checked against its own kind on one table at most. Two temporal constraints with one name, a temporal foreign key named like a foreign key on its table, or a temporal constraint named like an index anywhere in the schema scaffolded cleanly and failed when applied (42710, 42P07). Against an exclusion constraint it did not even fail: every exclusion constraint is added after `DROP CONSTRAINT IF EXISTS`, so a same-named temporal constraint was dropped and the migration applied clean, one declared guarantee short. Two explicitly named complex indexes on different tables of one schema are caught the same way. A collision between two of EF Core's own objects is left to EF; a snapshot holding a collision stays diffable.
 
diff --git a/CLAUDE.md b/CLAUDE.md
index 87673e3..8452553 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -378,7 +378,7 @@ differ let satellites resolve what the core cannot:
   and `GenerateJsonPath`, identical in Npgsql 10 and 11): `->>` for one step, `#>> '{A,B}'` for
   more (`ARRAY[…]::text[]` when a segment is not ASCII-alphanumeric), and a `CAST` to the member's
   store type unless it is a string mapping, `decode(…, 'base64')` for `bytea`, `jsonb` for a
-  primitive collection. PostgreSQL uses an expression index only for a query whose expression
+  primitive collection or a `json`/`jsonb` scalar (checked in that order, as Npgsql does). PostgreSQL uses an expression index only for a query whose expression
   matches it, so this is not cosmetic: until 5.4.0 every member was `"col" -> 'A' ->> 'B'` text,
   and indexes on nested or typed members applied, enforced, and served no query
   (`NpgsqlJsonMemberRenderingTests` asserts each rendering against EF's own `ToQueryString()`).
diff --git a/docs/postgresql-indexes.md b/docs/postgresql-indexes.md
index e364f76..2e155c9 100644
--- a/docs/postgresql-indexes.md
+++ b/docs/postgresql-indexes.md
@@ -209,7 +209,7 @@ the cast:
 | nested member | `"profile" #>> '{Address,City}'` | `x.Profile.Address.City == …` |
 | `int`, `long`, `short`, `decimal`, `double`, `bool`, `Guid`, enum | `CAST("profile" ->> 'Rank' AS integer)` (the member's store type) | `x.Profile.Rank == …`, `> …`, `ORDER BY` |
 | `byte[]` | `decode("profile" ->> 'Blob', 'base64')` | `x.Profile.Blob == …` |
-| primitive collection | `"profile" -> 'Tags'` (`jsonb`) | a GIN over it |
+| primitive collection, `JsonDocument` or other `jsonb` member | `"profile" -> 'Tags'` (`jsonb`) | a GIN over it |
 | `DateTime`, `DateTimeOffset`, `DateOnly`, `TimeOnly` | `"profile" ->> 'At'` (text) | uniqueness only |
 
 `HasJsonPropertyName` is honored throughout. Date and time members are the exception: Npgsql's
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md b/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md
index 2640a49..5f40aa7 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md
@@ -8,7 +8,8 @@ covers all three packages.
 
 - **Fixed:** indexes on `ToJson()` members are written the way Npgsql's queries read the member —
   `->>` or `#>> '{A,B}'`, cast to the member's store type unless it is a string, `decode(…,
-  'base64')` for `byte[]`, `jsonb` for a primitive collection — so PostgreSQL can use them. Before,
+  'base64')` for `byte[]`, `jsonb` for a primitive collection or a `json`/`jsonb` member — so
+  PostgreSQL can use them. Before,
   every member was `"doc" -> 'A' ->> 'B'` text, which matched a query only for a top-level string:
   indexes on nested or typed members applied, enforced uniqueness, and served no query. Applies to
   index parts, typed expression indexes and index filters; exclusion constraint filters keep their
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs
index 9d4ca52..2600524 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs
@@ -237,17 +237,19 @@ StoreObjectIdentifier storeObject
         "interval", "money"
     };
 
-    // Mirrors NpgsqlQuerySqlGenerator.VisitJsonScalar, identical in Npgsql 10 and 11: no cast for a
-    // string mapping, decode() for bytea, jsonb for a primitive collection, and a CAST to the store
-    // type for everything else — except where that cast is not IMMUTABLE, which falls back to text
-    // and reports the store type the queries use instead.
+    // Mirrors NpgsqlQuerySqlGenerator.VisitJsonScalar, identical in Npgsql 10 and 11, case for case
+    // and in its order: jsonb for a JSON-mapped value (a primitive collection, or a json/jsonb
+    // scalar such as a JsonDocument), no cast for a string mapping, decode() for bytea, and a CAST to
+    // the store type for everything else — except where that cast is not IMMUTABLE, which falls
+    // back to text and reports the store type the queries use instead.
     private (string Sql, string? FallbackStoreType) RenderJsonScalar(IProperty leaf, string containerColumn, List<string> jsonPath)
     {
-        if (leaf.IsPrimitiveCollection)
+        var mapping = leaf.FindRelationalTypeMapping() ?? _typeMappingSource.FindMapping(leaf);
+
+        if (leaf.IsPrimitiveCollection || mapping?.StoreTypeNameBase is "jsonb" or "json")
             return (BuildJsonPath(containerColumn, jsonPath, returnsText: false), null);
 
-        var text    = BuildJsonPath(containerColumn, jsonPath, returnsText: true);
-        var mapping = leaf.FindRelationalTypeMapping() ?? _typeMappingSource.FindMapping(leaf);
+        var text = BuildJsonPath(containerColumn, jsonPath, returnsText: true);
 
         return mapping switch
         {
diff --git a/test/EFCore.ComplexIndexes.Tests/NpgsqlJsonMemberRenderingTests.cs b/test/EFCore.ComplexIndexes.Tests/NpgsqlJsonMemberRenderingTests.cs
index 1ca372b..cc8b7dd 100644
--- a/test/EFCore.ComplexIndexes.Tests/NpgsqlJsonMemberRenderingTests.cs
+++ b/test/EFCore.ComplexIndexes.Tests/NpgsqlJsonMemberRenderingTests.cs
@@ -189,6 +189,31 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
         }
     }
 
+    public class Envelope
+    {
+        public System.Text.Json.JsonDocument? Raw { get; set; }
+    }
+
+    public class Message
+    {
+        public int      Id       { get; set; }
+        public Envelope Envelope { get; set; } = new();
+    }
+
+    // A json/jsonb scalar inside the document: Npgsql reads it as a jsonb fragment (->), never as
+    // text cast back to jsonb, which would also fail on any document holding a JSON string there.
+    public class JsonScalarContext(DbContextOptions<JsonScalarContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Message>(b =>
+            {
+                b.ToTable("messages");
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Envelope, e => e.ToJson("envelope"));
+                b.HasComplexIndex(x => x.Envelope.Raw, indexName: "ix_raw");
+            });
+    }
+
     public class NonUniqueDateContext(DbContextOptions<NonUniqueDateContext> options) : DbContext(options)
     {
         protected override void OnModelCreating(ModelBuilder modelBuilder) =>
@@ -296,6 +321,12 @@ public void Rendered_expressions_match_live_query_translation()
             Assert.AreEqual(QueriedExpression(query), Normalize(parts[name]), name);
     }
 
+    [TestMethod(DisplayName = "A jsonb scalar member renders as a jsonb fragment, as Npgsql reads it")]
+    public void Json_scalar_member_renders_as_jsonb()
+        => Assert.AreEqual(
+               "\"envelope\" -> 'Raw'",
+               PartSqlByName(MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<JsonScalarContext>()))["ix_raw"]);
+
     [TestMethod(DisplayName = "A property-level declaration inside the document renders the same way")]
     public void Property_level_member_renders_typed()
     {