diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3e21e8a..5235dd2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,24 @@ covering only what changed for that package:
 [PostgreSQL](src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md),
 [SQL Server](src/EFCore.ComplexIndexes.SqlServer/CHANGELOG.md).
 
+## 5.2.0
+
+The features AuditOffice's review of its own workarounds asked for, in the order they pay off:
+a validation for a failure that reports nothing, a read model so an application can check its
+own obligations, filters that resolve property paths the way index parts already do, an amend
+API, and typed filter predicates.
+
+- **Changed:** an index or constraint name longer than the provider's identifier limit is rejected at `dotnet ef migrations add`. PostgreSQL truncates a name past 63 bytes with a NOTICE and applies the migration cleanly, so the index exists under a name that neither the declaration nor a later constraint-violation error reports — a slice dispatching on the constraint name falls through in silence; SQL Server rejects the statement at apply time instead. Explicit and default names alike are checked, measured the way the provider measures them (bytes on PostgreSQL, characters on SQL Server), on the target model only. The names this package derives are never truncated, unlike EF Core's own default names, so a long table name plus a long column path reaches the limit quietly, and a default temporal foreign key name, built from two table names, is the first to. Give the declaration a name; a name-only change renames in place.
+
+- **New:** a read model. `GetComplexIndexes()` on an entity type or the model returns every declaration this package holds — property-level, entity-level, composite and expression indexes alike — as `ComplexIndexDeclaration`s carrying the parts as property paths, `IsUnique`, `Filter`, the explicit `Name` and, for entity-level declarations, the provider options; `FindComplexIndex(name)` looks one up by explicit name. The PostgreSQL package adds `GetExclusionConstraints()` and `FindExclusionConstraint(name)` for exclusion constraints, whose element type `ExclusionPartDefinition` and annotation key `NpgsqlExclusionAnnotations.Constraints` are now public. Both work on the mutable model inside `OnModelCreating`, so an application can check a convention such as "every unique index and exclusion constraint on a withdrawable aggregate is filtered to live rows" while the model is built. The differ builds its own descriptors from the same readers, so what the read model reports is what the migration is scaffolded from.
+
+- **New:** filters resolve `{Property.Path}` placeholders, the way expression parts already did — on complex, composite and expression indexes, and on PostgreSQL exclusion constraints. `filter: "{RevokedAt} IS NULL"` becomes `"revoked_at" IS NULL` (`[revoked_at]` on SQL Server) at `migrations add`, honouring `HasColumnName` and, on PostgreSQL, `ToJson()` members; the resolved text is what the migration carries, rendered by the stock generator with no runtime wiring, and what the snapshot is compared on. Only a brace pair holding a dotted identifier path outside a single-quoted literal is a placeholder, so existing filters with array or JSON literals (`'{urgent}'`, `'{"a": 1}'`) are unaffected, and a placeholder naming no property fails loudly. Template resolution now lives in the core differ over a new `QuoteIdentifier` seam, which is also why the SQL Server satellite resolves them.
+- **New:** property paths see through a value converter. For a value object mapped as one column, `x => x.Email.Value` — in `HasComplexIndex`, a typed `HasExpressionIndex`, an exclusion element, or a filter placeholder — resolves to that column, provided the member's type is the converter's provider type. Without that guard `x.CreatedAt.Year` would have indexed the whole column; it still fails, and says so.
+
+- **New:** a mutable API. On an `IMutableEntityType`, `AddComplexIndexFilter(predicate, where)` ANDs a predicate onto the filter of every selected complex index — property-level and entity-level alike — so a shared convention can install a live-rows filter the way it installs the query filter, instead of every configuration repeating it; `AddComplexIndex(definition)` adds an entity-level declaration with the fluent API's identity and name rules. The PostgreSQL package adds `AddExclusionConstraintFilter`. An unfiltered declaration gets the predicate, a filtered one `(existing) AND (predicate)`, one that already carries it is left alone, so the calls are safe to repeat. They amend what is declared at the time of the call, so they belong after the configurations.
+
+- **New:** typed filter predicates on PostgreSQL. Every `filter:` string has a lambda form — `HasComplexIndex(x => x.Email, x => x.RevokedAt == null)`, `HasComplexCompositeIndex(…, x => …)`, `HasExpressionIndex(…, x => …)`, `HasExclusionConstraint(…, x => …)` — and the index and constraint builders take `HasFilter(x => …)` (`HasFilter<TEntity>` on the non-generic index builders). The predicate is translated at the declaration into a filter template, so the column names come from the model: `==`/`!=` (`IS NULL`/`IS NOT NULL` against null), `<`, `<=`, `>`, `>=`, `&&`, `||`, `!`, boolean properties, and on the operands the string operations and constants a typed expression index accepts. Enums are refused — how one is stored depends on a value conversion the filter cannot see, so `Status == Status.Active` would compare a text column against `0` and fail at apply time — as are values with no portable SQL spelling (`DateTime`, `Guid`), which the typed expression translator used to render as bare text. The amend calls have typed forms too.
+
 ## 5.1.0
 
 Small enhancements around the two seams, plus the silent failures found while planning the next
diff --git a/CLAUDE.md b/CLAUDE.md
index efca8f1..4a4a10c 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -278,6 +278,29 @@ 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 read model is the differ's reader
+
+`ComplexIndexModelExtensions.GetDeclaredComplexIndexes` (core) and
+`NpgsqlExclusionModelExtensions.GetDeclaredExclusionConstraints` (PostgreSQL) turn the annotations
+into `ComplexIndexDeclaration` / `ExclusionConstraintDeclaration` objects — the public surface an
+application uses to check its own conventions ("every unique index and exclusion constraint on a
+withdrawable aggregate is filtered"). Since 5.2.0 the differs build their descriptors from exactly
+these readers and resolve columns on top; there is no second parser. Keep it that way: a read model
+that disagrees with the differ silently checks something other than what the migration enforces,
+which is the outcome the guard exists to prevent. Declarations are reported unresolved — parts as
+property paths, `Name` null for a default-named one — because resolution needs the relational model
+and, for JSON members and templates, the satellite; `FindComplexIndex` therefore matches explicit
+names only.
+
+The mutable side (`ComplexIndexMutableExtensions`, `NpgsqlExclusionMutableExtensions`) works on
+`IMutableEntityType`: `AddComplexIndex` is `ComplexIndexStorage.AddOrReplace` retyped, so it
+carries the same identity and name rules; `AddComplexIndexFilter` / `AddExclusionConstraintFilter`
+AND a predicate onto selected declarations through `ComplexIndexStorage.Conjoin`, whose
+idempotence rule is deliberately narrow — the predicate is "already there" only when it is the
+whole filter or the exact conjunct this method appends. They amend what is declared *at the time
+of the call*: from `OnModelCreating` after the configurations, never from a model-finalizing
+convention, since a convention-source annotation write cannot overwrite the explicit blob.
+
 ### Two integration seams: design-time vs. runtime
 
 There are two distinct hook points, and it matters which one a feature uses:
@@ -340,7 +363,28 @@ differ let satellites resolve what the core cannot:
   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.
 - `ResolveTemplatePart` — substitutes template placeholders with quoted columns or parenthesized
-  JSON extractions; core throws (identifier quoting is provider-specific).
+  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.
+
+Filters go through the same placeholder resolver (`ResolveFilter`, called while building
+descriptors for indexes and, in the Npgsql differ, exclusion constraints), with a narrower rule
+because filters are pre-existing SQL: only a brace pair holding a dotted identifier path *outside a
+single-quoted literal* is a placeholder, there is no `{{` escape (`'{{1,2},{3,4}}'` is an array
+literal), and an unresolvable placeholder throws. The resolved filter is what the descriptor
+carries on both sides of the diff, so placeholder filters never churn and need no runtime wiring.
+`ResolveProperty` (core, shared by every path walk) also unwraps one member of a converter-mapped
+value object — `Email.Value` resolves to the `Email` column only when the property has a converter
+and the member's type equals the converter's provider type; without that check `CreatedAt.Year`
+would silently index the whole column.
+
+Typed filters (`NpgsqlTypedFilterExtensions`, PostgreSQL only) run
+`NpgsqlLinqIndexTranslator.TranslatePredicate` at the declaration and store the resulting
+placeholder template as the filter string — nothing downstream knows the filter was typed. The
+predicate subset is boolean structure over the expression translator's operands, with two
+deliberate refusals: enums, because the stored form depends on a value conversion the translator
+cannot see (`Status == Status.Active` would compare `text` against `0` and fail at apply), and
+literals without a portable SQL spelling (`DateTime`, `Guid`), which `IFormattable` used to render
+as bare text. Both throw at the declaration.
 
 `NULLS FIRST/LAST` (`DbOrder.NullsFirst/NullsLast`, `ExpressionIndexBuilder.NullsFirst()/NullsLast()`)
 rides on the parts as `NullSort`. EF's native `CreateIndexOperation` has no slot for it, so any
@@ -404,7 +448,7 @@ still skipped silently — an index on those is nothing this package could creat
 
 ### Key extension points
 
-- **Adding a new provider**: Subclass `CustomMigrationsModelDiffer` (override `IsForwardedIndexAnnotation`, optionally `ValidateCreateIndexOperation`/`ResolveUnmappedPart`/`ResolveTemplatePart`), implement `IDesignTimeServices` to replace the differ, and ship a `.targets` file that injects the attribute (with `ForProvider` set). The PostgreSQL project is the full-featured reference; the SQL Server project is the minimal one (whitelist + validation, no custom SQL generator).
+- **Adding a new provider**: Subclass `CustomMigrationsModelDiffer` (override `IsForwardedIndexAnnotation`, optionally `ValidateCreateIndexOperation`/`ResolveUnmappedPart`/`QuoteIdentifier`), implement `IDesignTimeServices` to replace the differ, and ship a `.targets` file that injects the attribute (with `ForProvider` set). The PostgreSQL project is the full-featured reference; the SQL Server project is the minimal one (whitelist + validation, no custom SQL generator).
 - **New index options**: Add constants to `ComplexIndexAnnotations.cs` (or `NpgsqlAnnotations.cs`), expose them via `ComplexIndexBuilder`, and read them in the differ when constructing `CreateIndexOperation`.
 
 ### Expression path extraction
diff --git a/Directory.Build.props b/Directory.Build.props
index 74808d4..24a0302 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -1,6 +1,6 @@
 <Project>
     <PropertyGroup>
-        <Version>5.1.0</Version>
+        <Version>5.2.0</Version>
         <Authors>CaffeinatedCoder</Authors>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
@@ -63,7 +63,7 @@
     -->
     <PropertyGroup>
         <EnablePackageValidation>true</EnablePackageValidation>
-        <PackageValidationBaselineVersion>5.0.3</PackageValidationBaselineVersion>
+        <PackageValidationBaselineVersion>5.1.0</PackageValidationBaselineVersion>
     </PropertyGroup>
 
     <!--
diff --git a/README.md b/README.md
index 8d442fd..64a082b 100644
--- a/README.md
+++ b/README.md
@@ -117,6 +117,19 @@ builder.ComplexProperty(x => x.EmailAddress, c =>
 The same overloads exist on the non-generic builder, so a property configured by name works too:
 `c.Property("Value").HasComplexIndex()`.
 
+A filter may name properties instead of columns: `{Property.Path}` placeholders resolve to the
+mapped column at `migrations add` — `HasColumnName`, complex members and (on PostgreSQL) `ToJson()`
+members included — so the filter and the column mapping cannot drift apart:
+
+```csharp
+c.Property(x => x.Value).HasComplexIndex(isUnique: true, filter: "{DeletedAt} IS NULL");
+// WHERE "deleted_at" IS NULL   (PostgreSQL)   WHERE [deleted_at] IS NULL   (SQL Server)
+```
+
+The resolved text is baked into the migration, so no runtime wiring is involved. Only a brace pair
+holding a dotted identifier path, outside a single-quoted literal, is a placeholder — `'{urgent}'`
+and `'{"a": 1}'` stay what they are — and one that names no property fails loudly.
+
 A property-level declaration holds **one** index per property. To give the same column several
 differently-filtered indexes (the classic soft-delete pattern), declare them at the **entity level**
 — the selector reaches into complex properties, and each index needs its own explicit name:
@@ -128,10 +141,18 @@ builder.HasComplexIndex(x => x.EmailAddress.Value,
     indexName: "ix_person_email_all");
 ```
 
+Selectors also see through a value converter: for a value object mapped as one column
+(`HasConversion(e => e.Value, v => new(v))`), `x => x.Email.Value` resolves to that column,
+provided the member's type is the converter's provider type. `x => x.CreatedAt.Year` does not
+resolve, and says so.
+
 Index names must be unique per table, and the package enforces it rather than letting the database
 reject the migration: reusing a name throws at the declaration, and two declarations that resolve to
 the same name — including a property-level and an entity-level index over one column, which share a
-default name — throw during `dotnet ef migrations add`.
+default name — throw during `dotnet ef migrations add`. So does a name longer than the provider's
+identifier limit: PostgreSQL would otherwise truncate it to 63 bytes with a NOTICE and apply the
+migration cleanly, leaving the index under a name that no declaration and no constraint-violation
+error ever reports. Default names are checked too, since this package never truncates them.
 
 ### Composite index across scalar and nested properties
 
@@ -156,6 +177,51 @@ Direction maps to EF Core's native `CreateIndexOperation.IsDescending`, so it is
 
 Markers of different kinds compose in any order; markers of the same kind do not — `DbOrder.Asc(DbOrder.Desc(x.A))` is a contradiction and throws. To control where nulls sort, see [null ordering](docs/postgresql-indexes.md#per-column-null-ordering) (PostgreSQL only).
 
+### Reading declarations back
+
+Every index declared through this package can be read back from the model — the finalized
+`context.Model`, or the mutable one inside `OnModelCreating` — so an application can enforce its
+own conventions instead of trusting each configuration to remember them:
+
+```csharp
+// "Every unique index on a withdrawable aggregate is filtered to live rows."
+var unfiltered = modelBuilder.Model.GetEntityTypes()
+    .Where(IsWithdrawable)
+    .SelectMany(e => e.GetComplexIndexes())
+    .Where(ix => ix.IsUnique && ix.Filter is null)
+    .ToList();
+
+var byName = modelBuilder.Model.FindComplexIndex("ux_person_email_active");
+```
+
+`GetComplexIndexes()` unifies property-level, entity-level, composite and expression indexes as
+`ComplexIndexDeclaration`s: parts as property paths, `IsUnique`, `Filter`, the explicit `Name`
+(null when the differ derives the default from resolved column names — those are not matched by
+`FindComplexIndex`), and for entity-level declarations the provider options. It reports what was
+*declared*; column names are resolved by the differ only. `GetDeclaredComplexIndexes()` leaves
+inherited declarations to the type that declares them. The differ reads the model through the
+same code, so the read model and the migration cannot disagree. PostgreSQL exclusion constraints
+have the same surface — see [reading constraints back](docs/postgresql-constraints.md#reading-constraints-back).
+
+### Amending declarations
+
+The same convention can be *installed* rather than checked. On the mutable model,
+`AddComplexIndexFilter` ANDs a predicate onto the filter of every selected declaration —
+property-level and entity-level alike — and `AddComplexIndex` adds an entity-level declaration
+with the fluent API's identity rules:
+
+```csharp
+// At the end of OnModelCreating, after the configurations have been applied:
+foreach (var entityType in modelBuilder.Model.GetEntityTypes().Where(IsWithdrawable))
+    entityType.AddComplexIndexFilter("{RevokedAt} IS NULL", ix => ix.IsUnique);
+```
+
+An unfiltered index gets the predicate; a filtered one gets `(existing) AND (predicate)`; one that
+already carries it is left alone, so the call is safe to repeat. It amends what is declared *at the
+time of the call*, which is why it belongs after the configurations — and why the read model is
+still worth a check for what a later declaration might add. Exclusion constraints have
+`AddExclusionConstraintFilter` — see [amending constraints](docs/postgresql-constraints.md#amending-constraints).
+
 ---
 
 ## Documentation
@@ -164,8 +230,8 @@ Provider-specific features live in their own pages:
 
 | Page | Covers |
 |---|---|
-| **[PostgreSQL — indexes](docs/postgresql-indexes.md)** | Index methods (GIN, GiST, BRIN, SP-GiST, Hash), operator classes, `INCLUDE`, expression (functional) indexes in raw SQL and typed LINQ, JSON member indexes, `NULLS FIRST/LAST` |
-| **[PostgreSQL — temporal and exclusion constraints](docs/postgresql-constraints.md)** | `UNIQUE … WITHOUT OVERLAPS`, temporal foreign keys (`PERIOD`), `EXCLUDE` constraints with `WHERE` predicates, the `btree_gist` extension |
+| **[PostgreSQL — indexes](docs/postgresql-indexes.md)** | Index methods (GIN, GiST, BRIN, SP-GiST, Hash), operator classes, `INCLUDE`, expression (functional) indexes in raw SQL and typed LINQ, typed filter predicates, JSON member indexes, `NULLS FIRST/LAST` |
+| **[PostgreSQL — temporal and exclusion constraints](docs/postgresql-constraints.md)** | `UNIQUE … WITHOUT OVERLAPS`, temporal foreign keys (`PERIOD`), `EXCLUDE` constraints with `WHERE` predicates, reading and amending them, the `btree_gist` extension |
 | **[SQL Server](docs/sqlserver.md)** | Clustered/nonclustered, covering (`INCLUDE`), online builds, fill factor, sort-in-tempdb, data compression — and the declarations SQL Server rejects outright |
 
 Working on the package itself: [CONTRIBUTING.md](CONTRIBUTING.md) covers the setup and the quality
diff --git a/SECURITY.md b/SECURITY.md
index b28d217..cf4a7ea 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -50,8 +50,8 @@ remedy for those is to upgrade.
 
 | Version | Supported |
 |---|---|
-| 5.1.x | ✅ |
-| < 5.1 | ❌ |
+| 5.2.x | ✅ |
+| < 5.2 | ❌ |
 
 ### For how long
 
diff --git a/docs/postgresql-constraints.md b/docs/postgresql-constraints.md
index 2f56991..67d1b57 100644
--- a/docs/postgresql-constraints.md
+++ b/docs/postgresql-constraints.md
@@ -178,7 +178,13 @@ builder.HasExclusionConstraint(ex => ex
     .IsDeferrable(initiallyDeferred: true));
 ```
 
-Selectors resolve complex-property members to their mapped columns, exactly like complex indexes.
+Selectors resolve complex-property members to their mapped columns, exactly like complex indexes,
+and the filter takes the same `{Property.Path}` placeholders a complex index filter does —
+`filter: "{RevokedAt} IS NULL"` renders `WHERE ("revoked_at" IS NULL)` whatever `HasColumnName`
+decided, JSON members become extractions, and a path that names no property fails at
+`migrations add`. Or write it typed — the scheduling overload takes a predicate in place of the
+string, and the builder has `HasFilter(x => x.RevokedAt == null)` — with the subset described under
+[typed filters](postgresql-indexes.md#typed-filters).
 Scalar equality elements under `gist` need the `btree_gist` extension — the differ injects
 `CREATE EXTENSION IF NOT EXISTS btree_gist` automatically, shared with temporal constraints and
 governed by the same `UseBtreeGist()` / `SuppressTemporalExtensionAutoInjection()` switches.
@@ -210,3 +216,41 @@ just make sure the declared name matches the existing one.
 > `CustomExclusion:Constraints` annotation means the compiled snapshot is stale — typically
 > scaffolding with `--no-build`, or a migrations assembly (`MigrationsAssembly(...)`) resolved from
 > an out-of-date build output. Rebuild the project that hosts the snapshot and re-scaffold.
+
+### Reading constraints back
+
+Exclusion constraints can be read back from the model, mutable or finalized, exactly like
+[complex indexes](../README.md#reading-declarations-back) — which is what makes an application-level
+convention checkable in full rather than for the index half only:
+
+```csharp
+var unfiltered = modelBuilder.Model.GetEntityTypes()
+    .Where(IsWithdrawable)
+    .SelectMany(e => e.GetExclusionConstraints())
+    .Where(ex => ex.Filter is null);
+
+var active = modelBuilder.Model.FindExclusionConstraint("ex_role_grant_active_period");
+```
+
+Each `ExclusionConstraintDeclaration` carries the elements as property paths or expressions with
+their operators, `Method` (`gist` unless set), `Filter`, deferrability and the explicit `Name` —
+null for a default-named constraint, which `FindExclusionConstraint` therefore does not match.
+`GetDeclaredExclusionConstraints()` leaves inherited declarations to the declaring type. The differ
+builds its constraint DDL from the same reader.
+
+### Amending constraints
+
+On the mutable model, `AddExclusionConstraintFilter` ANDs a predicate onto the filter of every
+selected constraint, the way [`AddComplexIndexFilter`](../README.md#amending-declarations) does
+for indexes — an unfiltered constraint gets the predicate, a filtered one `(existing) AND
+(predicate)`, one that already carries it is left alone:
+
+```csharp
+foreach (var entityType in modelBuilder.Model.GetEntityTypes().Where(IsWithdrawable))
+    entityType.AddExclusionConstraintFilter("{RevokedAt} IS NULL");
+```
+
+Both amend calls have a typed form, `AddComplexIndexFilter<TEntity>(x => x.RevokedAt == null)` and
+`AddExclusionConstraintFilter<TEntity>(…)`, with the entity type given explicitly.
+
+It amends what is declared at the time of the call, so it belongs after the configurations.
diff --git a/docs/postgresql-indexes.md b/docs/postgresql-indexes.md
index 7b77276..a2d0a24 100644
--- a/docs/postgresql-indexes.md
+++ b/docs/postgresql-indexes.md
@@ -138,6 +138,47 @@ builder.HasExpressionIndex(x => (x.Nickname ?? x.FirstName) + " " + x.LastName);
 
 The supported subset is deliberately small and fails loudly: `ToLower`/`ToUpper`, `Trim`/`TrimStart`/`TrimEnd`, `Substring` (1-based conversion handled), `Replace`, `string.Length`, string concatenation (`+`), null coalescing (`??`), and constants (captured variables are evaluated and inlined invariant-culture). Anything else throws `NotSupportedException` **at declaration time** with a pointer to the raw-SQL overload.
 
+Paths see through a value converter as well: when `Email` is a value object mapped as one column,
+`x => x.Email.Value.ToLower()` resolves `Email.Value` to that column — provided `Value` has the
+converter's provider type, which is what makes the column hold exactly that member.
+
+Filters take the same placeholders: `filter: "{DeletedAt} IS NULL"` or
+`"{Payload.Kind} = 'invoice'"` resolve to the column — or the JSON extraction — at `migrations add`,
+and the resolved text is what the migration carries. Only a brace pair holding a dotted identifier
+path outside a single-quoted literal is a placeholder, so array and JSON literals such as
+`'{urgent}'` and `'{"a": 1}'` are left alone.
+
+## Typed filters
+
+> No runtime wiring required — the predicate is translated at declaration into a filter template
+> and resolved into the migration like any placeholder filter.
+
+Every entry point that takes a `filter:` string also takes a predicate, and the builders take
+`HasFilter(x => …)`:
+
+```csharp
+builder.HasComplexIndex(x => x.Email, x => x.RevokedAt == null, isUnique: true);
+// CREATE UNIQUE INDEX ... WHERE "revoked_at" IS NULL
+
+builder.HasComplexCompositeIndex(x => new { x.GranteeId, x.Kind },
+    x => x.RevokedAt != null && x.Kind == "federated");
+// WHERE ("revoked_at" IS NOT NULL AND "kind" = 'federated')
+
+builder.HasExpressionIndex(x => x.Email.ToLower(), x => !x.IsDeleted);
+
+builder.ComplexProperty(x => x.Address, c => c.Property(a => a.City)
+    .HasComplexIndex(ix => ix.HasFilter<Person>(p => p.DeletedAt == null)));
+```
+
+The builders are not generic, so `HasFilter<TEntity>` takes the entity type explicitly. The subset
+is small and fails at the declaration: `==`/`!=` (against `null`: `IS NULL`/`IS NOT NULL`), `<`,
+`<=`, `>`, `>=`, `&&`, `||`, `!`, boolean properties, captured booleans, and on the operands the
+string operations and constants a typed expression index accepts. Two things are refused on
+purpose. An enum comparison: how an enum is stored depends on the property's value conversion,
+which a filter cannot see, so `Status == Status.Active` would compare a text column against `0`
+and fail when the migration is applied — write the stored value in the string overload. And a
+value with no portable SQL spelling, a `DateTime` or `Guid`, which used to come out as bare text.
+
 ## JSON member indexes
 
 > Requires [`UseNpgsqlComplexIndexes()`](../README.md#runtime-wiring--the-two-features-that-need-it) — JSON member indexes are expression indexes under the hood.
diff --git a/docs/sqlserver.md b/docs/sqlserver.md
index 2816a6a..6a2a762 100644
--- a/docs/sqlserver.md
+++ b/docs/sqlserver.md
@@ -32,7 +32,8 @@ builder.HasComplexIndex(x => x.Email.Value, ix => ix
 
 `IsClustered()`, `SortInTempDb()`, and `UseDataCompression(DataCompressionType.Page)` are also
 available. Filtered indexes (`filter:`) and `DbOrder.Desc` work out of the box, since both ride on
-EF's native operation.
+EF's native operation. A filter may name properties — `filter: "{DeletedAt} IS NULL"` resolves to
+`[deleted_at] IS NULL` at `migrations add`, bracket-quoted, and is baked into the migration.
 
 `IncludeProperties(...)` entries are resolved as property paths — complex members included — with a
 verbatim column-name fallback, so `IncludeProperties("Email.Value")` finds the real column.
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md b/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md
index 1985d24..11e3664 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/CHANGELOG.md
@@ -4,6 +4,39 @@ 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.2.0
+
+- **Changed:** an index, exclusion constraint, temporal constraint or temporal foreign key whose
+  name exceeds 63 bytes is rejected at `migrations add`. PostgreSQL would truncate it with a NOTICE
+  and apply the migration cleanly, leaving the object under a name that no declaration and no
+  constraint-violation error ever reports. Measured in UTF-8 bytes, as PostgreSQL does. Default
+  temporal foreign key names, built from two table names, are the first to hit it: give the
+  declaration a `name` — a name-only change renames the constraint in place.
+
+- **New:** `GetExclusionConstraints()` / `GetDeclaredExclusionConstraints()` on `IReadOnlyEntityType`,
+  `GetExclusionConstraints()` and `FindExclusionConstraint(name)` on `IReadOnlyModel` — exclusion
+  constraints read back as `ExclusionConstraintDeclaration`s (elements with operators, method,
+  filter, deferrability, explicit name). `ExclusionPartDefinition` and
+  `NpgsqlExclusionAnnotations` are public now. The differ reads the model through the same code.
+
+- **New:** filters on complex, composite and expression indexes and on exclusion constraints
+  resolve `{Property.Path}` placeholders — columns, `HasColumnName`, `ToJson()` members as
+  extractions — at `migrations add`, into the migration itself. Existing filters with array or JSON
+  literals are unaffected.
+- **New:** `x => x.Email.Value` on a converter-mapped value object resolves to the converted column
+  in typed expression indexes and exclusion elements too.
+
+- **New:** `AddExclusionConstraintFilter(predicate, where)` on `IMutableEntityType` — ANDs a
+  predicate onto every selected exclusion constraint's filter, idempotently.
+
+- **New:** typed filter predicates — `x => x.RevokedAt == null` in place of every `filter:` string,
+  `HasFilter(x => …)` on the builders, `AddComplexIndexFilter<TEntity>` / `AddExclusionConstraintFilter<TEntity>`.
+  Translated at the declaration into a placeholder filter: null checks, comparisons, `&&`/`||`/`!`,
+  boolean properties, the string functions of typed expression indexes. Enums and values without a
+  portable SQL spelling are refused at the declaration.
+- **Changed:** the typed expression translator no longer renders a `DateTime`, `Guid` or enum
+  constant as bare text; it throws at the declaration.
+
 ## 5.1.0
 
 - **Changed:** `UseNpgsqlComplexIndexes()` / `AddNpgsqlComplexIndexes()` also register the PostgreSQL
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/ExclusionConstraintDeclaration.cs b/src/EFCore.ComplexIndexes.PostgreSQL/ExclusionConstraintDeclaration.cs
new file mode 100644
index 0000000..134445e
--- /dev/null
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/ExclusionConstraintDeclaration.cs
@@ -0,0 +1,49 @@
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace EFCore.ComplexIndexes.PostgreSQL;
+
+/// <summary>
+/// One EXCLUDE constraint declared through <c>HasExclusionConstraint</c>, read back from the model.
+/// Obtained through <see cref="NpgsqlExclusionModelExtensions"/>; the differ reads its
+/// declarations through the same code, so what an application sees here is what the migration's
+/// <c>ADD CONSTRAINT … EXCLUDE</c> is built from.
+/// </summary>
+/// <remarks>
+/// This is the declaration, not the resolved constraint: column elements carry property paths,
+/// and <see cref="Name"/> is null when the differ derives the default <c>EX_{table}_{columns}</c>
+/// name from the resolved column names.
+/// </remarks>
+public sealed class ExclusionConstraintDeclaration
+{
+    internal ExclusionConstraintDeclaration(IReadOnlyEntityType entityType, ExclusionConstraintDefinition definition)
+    {
+        EntityType        = entityType;
+        Name              = definition.Name;
+        Parts             = definition.Parts;
+        Method            = definition.Method ?? "gist";
+        Filter            = definition.Filter;
+        Deferrable        = definition.Deferrable;
+        InitiallyDeferred = definition.InitiallyDeferred;
+    }
+
+    /// <summary>The entity type the constraint is declared on.</summary>
+    public IReadOnlyEntityType EntityType { get; }
+
+    /// <summary>The explicit constraint name, or null when the differ derives the default from the resolved columns.</summary>
+    public string? Name { get; }
+
+    /// <summary>The ordered elements, each a property path or a verbatim expression with its operator.</summary>
+    public IReadOnlyList<ExclusionPartDefinition> Parts { get; }
+
+    /// <summary>The index access method rendered after <c>USING</c>; <c>gist</c> unless <c>UseMethod</c> set another.</summary>
+    public string Method { get; }
+
+    /// <summary>The SQL predicate rendered as <c>WHERE (…)</c>, or null for an unfiltered constraint.</summary>
+    public string? Filter { get; }
+
+    /// <summary>Whether the constraint is <c>DEFERRABLE</c>.</summary>
+    public bool Deferrable { get; }
+
+    /// <summary>Whether a deferrable constraint is <c>INITIALLY DEFERRED</c>.</summary>
+    public bool InitiallyDeferred { get; }
+}
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/ExclusionConstraintDefinition.cs b/src/EFCore.ComplexIndexes.PostgreSQL/ExclusionConstraintDefinition.cs
index 8b53084..62ed7f1 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/ExclusionConstraintDefinition.cs
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/ExclusionConstraintDefinition.cs
@@ -9,7 +9,7 @@ namespace EFCore.ComplexIndexes.PostgreSQL;
 /// compared with (e.g. <c>=</c>, <c>&amp;&amp;</c>). Exactly one of <see cref="PropertyPath"/> /
 /// <see cref="Expression"/> is set.
 /// </summary>
-internal sealed class ExclusionPartDefinition : IEquatable<ExclusionPartDefinition>
+public sealed class ExclusionPartDefinition : IEquatable<ExclusionPartDefinition>
 {
     /// <summary>Dotted property path (e.g. <c>Address.City</c>) resolved to a column name. Null for expression parts.</summary>
     [JsonPropertyName("path")] public string? PropertyPath { get; init; }
@@ -20,16 +20,22 @@ internal sealed class ExclusionPartDefinition : IEquatable<ExclusionPartDefiniti
     /// <summary>The comparison operator rendered after <c>WITH</c>.</summary>
     [JsonPropertyName("op")] public string Operator { get; init; } = "";
 
+    /// <summary>Whether this element is a verbatim SQL expression rather than a column reference.</summary>
     [JsonIgnore] public bool IsExpression => Expression is not null;
 
+    /// <summary>Compares path, expression and operator.</summary>
+    /// <param name="other">The element to compare with.</param>
+    /// <returns><c>true</c> if the two describe the same element.</returns>
     public bool Equals(ExclusionPartDefinition? other) =>
         other is not null
      && PropertyPath == other.PropertyPath
      && Expression   == other.Expression
      && Operator     == other.Operator;
 
+    /// <inheritdoc />
     public override bool Equals(object? obj) => Equals(obj as ExclusionPartDefinition);
 
+    /// <inheritdoc />
     public override int GetHashCode() => HashCode.Combine(PropertyPath, Expression, Operator);
 }
 
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs
index 3f393cc..acb5404 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlComplexIndexMigrationsModelDiffer.cs
@@ -76,6 +76,13 @@ protected override bool IsForwardedIndexAnnotation(string annotationName)
     /// <summary>PostgreSQL renames indexes standalone (<c>ALTER INDEX … RENAME TO</c>).</summary>
     protected override bool CanRenameIndexes => true;
 
+    /// <summary>
+    /// PostgreSQL's identifier limit (<c>NAMEDATALEN - 1</c>, 63) is a byte count: a name made of
+    /// non-ASCII characters hits it well before its 63rd character.
+    /// </summary>
+    protected override (int Length, string Unit) MeasureIdentifier(string identifier)
+        => (System.Text.Encoding.UTF8.GetByteCount(identifier), "bytes");
+
     /// <summary>
     /// Npgsql's generator reads index collations from <c>Relational:Collation</c> on the operation;
     /// the option is stored under Npgsql's model key so that a property-level declaration is never
@@ -231,74 +238,6 @@ private static string BuildJsonExtraction(string containerColumn, List<string> j
         return sql.ToString();
     }
 
-    /// <summary>
-    /// Resolves a typed-expression template into final SQL: <c>{Property.Path}</c> placeholders
-    /// become quoted column references — or parenthesized JSON extractions for <c>ToJson()</c>
-    /// members; <c>{{</c>/<c>}}</c> unescape to literal braces.
-    /// </summary>
-    protected override ResolvedIndexPart ResolveTemplatePart(
-        IEntityType           entityType,
-        IndexPartDefinition   part,
-        StoreObjectIdentifier storeObject
-    )
-    {
-        var template = part.Template!;
-        var sql      = new System.Text.StringBuilder(template.Length);
-
-        for (var i = 0; i < template.Length; i++)
-        {
-            var ch = template[i];
-
-            if (ch == '{')
-            {
-                if (i + 1 < template.Length && template[i + 1] == '{')
-                {
-                    sql.Append('{');
-                    i++;
-                    continue;
-                }
-
-                var end = template.IndexOf('}', i + 1);
-                if (end < 0)
-                    throw new InvalidOperationException($"Malformed index expression template '{template}' on entity '{entityType.Name}'.");
-
-                sql.Append(ResolvePlaceholder(entityType, template[(i + 1)..end], storeObject));
-                i = end;
-                continue;
-            }
-
-            if (ch == '}')
-            {
-                if (i + 1 < template.Length && template[i + 1] == '}')
-                {
-                    sql.Append('}');
-                    i++;
-                    continue;
-                }
-
-                throw new InvalidOperationException($"Malformed index expression template '{template}' on entity '{entityType.Name}'.");
-            }
-
-            sql.Append(ch);
-        }
-
-        return new ResolvedIndexPart(true, sql.ToString(), part.Descending, part.NullSort);
-    }
-
-    private string ResolvePlaceholder(IEntityType entityType, string path, StoreObjectIdentifier storeObject)
-    {
-        var column = ResolveProperty(entityType, path)?.GetColumnName(storeObject);
-        if (column is not null)
-            return Quote(column);
-
-        var jsonPart = ResolveUnmappedPart(entityType, new IndexPartDefinition { PropertyPath = path }, storeObject);
-        if (jsonPart is not null)
-            return jsonPart.IsExpression ? $"({jsonPart.Value})" : Quote(jsonPart.Value);
-
-        throw new InvalidOperationException(
-            $"Could not resolve property path '{path}' referenced by an index expression on entity '{entityType.Name}'.");
-    }
-
     /// <summary>
     /// Runs the core complex-index diff, then adds PostgreSQL-specific DDL: temporal <c>UNIQUE …
     /// WITHOUT OVERLAPS</c> constraints, temporal foreign keys, exclusion constraints, and a single
@@ -332,7 +271,7 @@ public override IReadOnlyList<MigrationOperation> GetDifferences(
     // 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
     // SqlOperations after them, with UNIQUE constraints before FOREIGN KEYs.
-    private static IReadOnlyList<MigrationOperation> ApplyTemporalConstraints(
+    private IReadOnlyList<MigrationOperation> ApplyTemporalConstraints(
         IReadOnlyList<MigrationOperation> operations,
         IRelationalModel?                 source,
         IRelationalModel?                 target,
@@ -347,6 +286,16 @@ out bool                          needsBtreeGist
         var sourceForeignKeys = BuildForeignKeyDescriptors(source, typeMappingSource, sourceConstraints);
         var targetForeignKeys = BuildForeignKeyDescriptors(target, typeMappingSource, targetConstraints);
 
+        // Target only — the source is history.
+        if (target is not null)
+        {
+            foreach (var constraint in targetConstraints)
+                ThrowIfIdentifierTooLong(target.Model, constraint.Name, "temporal constraint", constraint.Table, "name");
+
+            foreach (var foreignKey in targetForeignKeys)
+                ThrowIfIdentifierTooLong(target.Model, foreignKey.Name, "temporal foreign key", foreignKey.DependentTable, "name");
+        }
+
         if (sourceConstraints.Count == 0 && targetConstraints.Count == 0
                                         && sourceForeignKeys.Count == 0 && targetForeignKeys.Count == 0)
             return operations;
@@ -516,7 +465,7 @@ private static string BuildAddTemporalForeignKeySql(TemporalForeignKeyDescriptor
     // SQL operations (EF has no exclusion-constraint operation type). The DDL is fully rendered at
     // design time, so no runtime SQL-generator wiring is needed. Drops are placed before the base EF
     // operations, adds after — mirroring the index and temporal ordering.
-    private static IReadOnlyList<MigrationOperation> ApplyExclusionConstraints(
+    private IReadOnlyList<MigrationOperation> ApplyExclusionConstraints(
         IReadOnlyList<MigrationOperation> operations,
         IRelationalModel?                 source,
         IRelationalModel?                 target,
@@ -531,6 +480,12 @@ out bool                          needsBtreeGist
         // Target only — a snapshot that already contains a collision must stay diffable.
         ValidateUniqueExclusionNames(targetConstraints);
 
+        if (target is not null)
+        {
+            foreach (var constraint in targetConstraints)
+                ThrowIfIdentifierTooLong(target.Model, constraint.Name, "exclusion constraint", constraint.Table, "name");
+        }
+
         if (sourceConstraints.Count == 0 && targetConstraints.Count == 0)
             return operations;
 
@@ -648,15 +603,16 @@ static string Describe(ExclusionDescriptor descriptor)
         return renamed;
     }
 
-    private static HashSet<ExclusionDescriptor> BuildExclusionDescriptors(IRelationalModel? model)
+    private HashSet<ExclusionDescriptor> BuildExclusionDescriptors(IRelationalModel? model)
     {
         var set = new HashSet<ExclusionDescriptor>();
         if (model is null) return set;
 
+        // Declarations come from the same reader an application uses (NpgsqlExclusionModelExtensions).
         foreach (var entityType in model.Model.GetEntityTypes())
         {
-            if (entityType.FindAnnotation(NpgsqlExclusionAnnotations.Constraints)?.Value is not string json
-             || string.IsNullOrEmpty(json))
+            var declarations = entityType.GetDeclaredExclusionConstraints();
+            if (declarations.Count == 0)
                 continue;
 
             var table = entityType.GetTableName();
@@ -669,7 +625,7 @@ private static HashSet<ExclusionDescriptor> BuildExclusionDescriptors(IRelationa
             var schema      = entityType.GetSchema();
             var storeObject = StoreObjectIdentifier.Table(table, schema);
 
-            foreach (var def in ExclusionConstraintSerializer.Deserialize(json))
+            foreach (var def in declarations)
             {
                 var parts = new List<ResolvedExclusionPart>(def.Parts.Count);
                 foreach (var part in def.Parts)
@@ -698,8 +654,8 @@ private static HashSet<ExclusionDescriptor> BuildExclusionDescriptors(IRelationa
                     schema,
                     name,
                     parts,
-                    def.Method ?? "gist",
-                    def.Filter,
+                    def.Method,
+                    ResolveFilter(entityType, def.Filter, storeObject),
                     def.Deferrable,
                     def.InitiallyDeferred));
             }
@@ -1023,24 +979,6 @@ private static bool IsMultirangeClrType(Type type)
         => type.Namespace is "NpgsqlTypes"
         && type.Name.EndsWith("Multirange", StringComparison.Ordinal);
 
-    private static IProperty? ResolveProperty(ITypeBase entityType, string dotPath)
-    {
-        var       parts   = dotPath.Split('.');
-        ITypeBase current = entityType;
-
-        for (var i = 0; i < parts.Length; i++)
-        {
-            if (i == parts.Length - 1)
-                return current.FindProperty(parts[i]);
-
-            var cp = current.FindComplexProperty(parts[i]);
-            if (cp is null) return null;
-            current = cp.ComplexType;
-        }
-
-        return null;
-    }
-
     private static bool ShouldInjectExtension(IRelationalModel? target)
     {
         if (target is null)
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionAnnotations.cs b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionAnnotations.cs
index ac82ffa..bb5f56b 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionAnnotations.cs
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionAnnotations.cs
@@ -5,7 +5,7 @@ namespace EFCore.ComplexIndexes.PostgreSQL;
 /// <c>HasExclusionConstraint</c>. These use the <c>CustomExclusion:</c> prefix so they never
 /// collide with the <c>Npgsql:</c> keys validated on index operations.
 /// </summary>
-internal static class NpgsqlExclusionAnnotations
+public static class NpgsqlExclusionAnnotations
 {
     /// <summary>
     /// Stamped on an entity type to hold the JSON-serialized list of exclusion constraints
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionConstraintExtensions.cs b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionConstraintExtensions.cs
index b1af699..8d851a0 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionConstraintExtensions.cs
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionConstraintExtensions.cs
@@ -200,6 +200,17 @@ public ExclusionConstraintBuilder<TEntity> HasFilter(string filter)
         return this;
     }
 
+    /// <summary>
+    /// Applies a typed predicate (<c>x => x.RevokedAt == null</c>), translated like a typed index
+    /// filter — see <see cref="NpgsqlTypedFilterExtensions"/> for the supported subset.
+    /// </summary>
+    public ExclusionConstraintBuilder<TEntity> HasFilter(Expression<Func<TEntity, bool>> predicate)
+    {
+        ArgumentNullException.ThrowIfNull(predicate);
+        _filter = NpgsqlLinqIndexTranslator.TranslatePredicate(predicate);
+        return this;
+    }
+
     /// <summary>Sets a custom name for the constraint.</summary>
     public ExclusionConstraintBuilder<TEntity> HasName(string name)
     {
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionModelExtensions.cs b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionModelExtensions.cs
new file mode 100644
index 0000000..7b89eff
--- /dev/null
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionModelExtensions.cs
@@ -0,0 +1,68 @@
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace EFCore.ComplexIndexes.PostgreSQL;
+
+/// <summary>
+/// Reads the EXCLUDE constraints declared through <c>HasExclusionConstraint</c> back from an EF
+/// Core model — mutable or finalized — the counterpart of
+/// <see cref="ComplexIndexModelExtensions"/> for the constraint side, so an application can check
+/// a convention that covers both ("every unique index <em>and</em> every exclusion constraint on a
+/// withdrawable aggregate is filtered to live rows") in full rather than for indexes only.
+/// </summary>
+/// <remarks>
+/// The differ builds its constraint descriptors from
+/// <see cref="GetDeclaredExclusionConstraints"/> too: one reading of the model, shared.
+/// </remarks>
+public static class NpgsqlExclusionModelExtensions
+{
+    extension(IReadOnlyEntityType entityType)
+    {
+        /// <summary>
+        /// The exclusion constraints declared on this entity type itself. Inherited declarations
+        /// are reported by the type that declares them.
+        /// </summary>
+        public IReadOnlyList<ExclusionConstraintDeclaration> GetDeclaredExclusionConstraints()
+        {
+            if (entityType.FindAnnotation(NpgsqlExclusionAnnotations.Constraints)?.Value is not string json
+             || string.IsNullOrEmpty(json))
+                return [];
+
+            return [.. ExclusionConstraintSerializer.Deserialize(json)
+                                                    .Select(definition => new ExclusionConstraintDeclaration(entityType, definition))];
+        }
+
+        /// <summary>
+        /// The exclusion constraints that apply to this entity type: its own declarations plus
+        /// those of its base types, base types first.
+        /// </summary>
+        public IReadOnlyList<ExclusionConstraintDeclaration> GetExclusionConstraints()
+        {
+            var result = new List<ExclusionConstraintDeclaration>();
+
+            for (var type = entityType; type is not null; type = type.BaseType)
+                result.InsertRange(0, type.GetDeclaredExclusionConstraints());
+
+            return result;
+        }
+    }
+
+    extension(IReadOnlyModel model)
+    {
+        /// <summary>Every exclusion constraint declared anywhere in the model, each reported once on its declaring type.</summary>
+        public IReadOnlyList<ExclusionConstraintDeclaration> GetExclusionConstraints()
+            => [.. model.GetEntityTypes().SelectMany(entityType => entityType.GetDeclaredExclusionConstraints())];
+
+        /// <summary>
+        /// Finds the exclusion constraint declared with the explicit name <paramref name="name"/>,
+        /// or null. Default names are derived by the differ from the resolved column names and are
+        /// not matched here — a declaration without a name has
+        /// <see cref="ExclusionConstraintDeclaration.Name"/> null.
+        /// </summary>
+        /// <param name="name">The explicit constraint name, as given to <c>name:</c> or <c>HasName</c>.</param>
+        public ExclusionConstraintDeclaration? FindExclusionConstraint(string name)
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(name);
+            return model.GetExclusionConstraints().FirstOrDefault(constraint => constraint.Name == name);
+        }
+    }
+}
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionMutableExtensions.cs b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionMutableExtensions.cs
new file mode 100644
index 0000000..9357dbe
--- /dev/null
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlExclusionMutableExtensions.cs
@@ -0,0 +1,66 @@
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace EFCore.ComplexIndexes.PostgreSQL;
+
+/// <summary>
+/// Amends exclusion-constraint declarations on an <see cref="IMutableEntityType"/> — the
+/// counterpart of <see cref="ComplexIndexMutableExtensions"/> for the constraint side, so a shared
+/// convention can install a live-rows filter on both in one place.
+/// </summary>
+/// <remarks>
+/// Amends what is declared at the time of the call; run it after the declarations it should
+/// cover, inside <c>OnModelCreating</c>.
+/// </remarks>
+public static class NpgsqlExclusionMutableExtensions
+{
+    extension(IMutableEntityType entityType)
+    {
+        /// <summary>
+        /// Adds <paramref name="predicate"/> to the filter of every exclusion constraint declared on
+        /// this type that <paramref name="where"/> selects, with AND: an unfiltered constraint gets
+        /// the predicate as its filter, a filtered one gets <c>(existing) AND (predicate)</c>.
+        /// Placeholders resolve like any other filter's. Applying the same predicate again is a
+        /// no-op, so the call is safe to repeat.
+        /// </summary>
+        /// <param name="predicate">The SQL predicate to add, e.g. <c>"{RevokedAt} IS NULL"</c>.</param>
+        /// <param name="where">Selects the declarations to amend; null amends every one.</param>
+        /// <returns>How many declarations were changed.</returns>
+        public int AddExclusionConstraintFilter(string predicate, Func<ExclusionConstraintDeclaration, bool>? where = null)
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(predicate);
+
+            if (entityType.FindAnnotation(NpgsqlExclusionAnnotations.Constraints)?.Value is not string json
+             || string.IsNullOrEmpty(json))
+                return 0;
+
+            var definitions  = ExclusionConstraintSerializer.Deserialize(json);
+            var declarations = entityType.GetDeclaredExclusionConstraints();
+            var amended      = 0;
+
+            for (var i = 0; i < definitions.Count; i++)
+            {
+                if (where?.Invoke(declarations[i]) == false)
+                    continue;
+
+                if (ComplexIndexStorage.Conjoin(definitions[i].Filter, predicate) is not { } filter)
+                    continue;
+
+                definitions[i] = new ExclusionConstraintDefinition
+                                 {
+                                     Parts             = definitions[i].Parts,
+                                     Method            = definitions[i].Method,
+                                     Filter            = filter,
+                                     Name              = definitions[i].Name,
+                                     Deferrable        = definitions[i].Deferrable,
+                                     InitiallyDeferred = definitions[i].InitiallyDeferred
+                                 };
+                amended++;
+            }
+
+            if (amended > 0)
+                entityType.SetAnnotation(NpgsqlExclusionAnnotations.Constraints, ExclusionConstraintSerializer.Serialize(definitions));
+
+            return amended;
+        }
+    }
+}
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlLinqIndexTranslator.cs b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlLinqIndexTranslator.cs
index e34acf5..1e07f2b 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlLinqIndexTranslator.cs
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlLinqIndexTranslator.cs
@@ -22,6 +22,98 @@ internal static class NpgsqlLinqIndexTranslator
     public static string Translate(LambdaExpression lambda)
         => Visit(lambda.Body, lambda.Parameters[0]);
 
+    /// <summary>
+    /// Translates a boolean lambda into a filter template: comparisons (<c>==</c>/<c>!=</c> against
+    /// null become <c>IS [NOT] NULL</c>), <c>&amp;&amp;</c>, <c>||</c>, <c>!</c>, boolean members,
+    /// and on the operands everything <see cref="Translate"/> supports. Property paths stay
+    /// <c>{Path}</c> placeholders for the differ to resolve.
+    /// </summary>
+    public static string TranslatePredicate(LambdaExpression lambda)
+        => VisitPredicate(lambda.Body, lambda.Parameters[0]);
+
+    private static string VisitPredicate(Expression node, ParameterExpression root)
+    {
+        switch (node)
+        {
+            case UnaryExpression { NodeType: ExpressionType.Convert } convert:
+                return VisitPredicate(convert.Operand, root);
+
+            case UnaryExpression { NodeType: ExpressionType.Not } not:
+                return $"NOT ({VisitPredicate(not.Operand, root)})";
+
+            case BinaryExpression { NodeType: ExpressionType.AndAlso } and:
+                return $"({VisitPredicate(and.Left, root)} AND {VisitPredicate(and.Right, root)})";
+
+            case BinaryExpression { NodeType: ExpressionType.OrElse } or:
+                return $"({VisitPredicate(or.Left, root)} OR {VisitPredicate(or.Right, root)})";
+
+            case BinaryExpression { NodeType: ExpressionType.Equal or ExpressionType.NotEqual } equality:
+            {
+                var negated = equality.NodeType == ExpressionType.NotEqual;
+
+                if (IsNullConstant(equality.Right))
+                    return $"{VisitOperand(equality.Left, root)} IS {(negated ? "NOT " : "")}NULL";
+
+                if (IsNullConstant(equality.Left))
+                    return $"{VisitOperand(equality.Right, root)} IS {(negated ? "NOT " : "")}NULL";
+
+                return $"{VisitOperand(equality.Left, root)} {(negated ? "<>" : "=")} {VisitOperand(equality.Right, root)}";
+            }
+
+            case BinaryExpression { NodeType: ExpressionType.LessThan } comparison:
+                return $"{VisitOperand(comparison.Left, root)} < {VisitOperand(comparison.Right, root)}";
+
+            case BinaryExpression { NodeType: ExpressionType.LessThanOrEqual } comparison:
+                return $"{VisitOperand(comparison.Left, root)} <= {VisitOperand(comparison.Right, root)}";
+
+            case BinaryExpression { NodeType: ExpressionType.GreaterThan } comparison:
+                return $"{VisitOperand(comparison.Left, root)} > {VisitOperand(comparison.Right, root)}";
+
+            case BinaryExpression { NodeType: ExpressionType.GreaterThanOrEqual } comparison:
+                return $"{VisitOperand(comparison.Left, root)} >= {VisitOperand(comparison.Right, root)}";
+
+            // A boolean column stands on its own.
+            case MemberExpression member when member.Type == typeof(bool) && TryGetPath(member, root, out var path):
+                return "{" + path + "}";
+        }
+
+        // A captured flag: bake it in.
+        if (node.Type == typeof(bool) && !DependsOnParameter(node, root))
+            return Literal(Evaluate(node));
+
+        throw new NotSupportedException(
+            $"The expression '{node}' is not supported in a typed index filter. Supported: comparisons " +
+            "(==, !=, <, <=, >, >=; == null and != null become IS NULL / IS NOT NULL), &&, ||, !, boolean " +
+            "properties, and on the operands the same string operations and constants a typed expression " +
+            "index accepts. Use the string filter overload with raw SQL for anything else.");
+    }
+
+    // Enum values never reach SQL: how one is stored depends on the property's value conversion,
+    // which the translator cannot see, so `Status == Status.Active` would compare against 0 on a
+    // text column and fail at apply time. Refuse it here, at the declaration.
+    private static string VisitOperand(Expression node, ParameterExpression root)
+    {
+        var stripped = node;
+        while (stripped is UnaryExpression { NodeType: ExpressionType.Convert } convert)
+            stripped = convert.Operand;
+
+        if ((Nullable.GetUnderlyingType(stripped.Type) ?? stripped.Type).IsEnum)
+            throw new NotSupportedException(
+                $"The expression '{node}' compares an enum in a typed index filter. How an enum is stored depends " +
+                "on the property's value conversion, which a filter cannot see; write the stored value with the " +
+                "string filter overload instead.");
+
+        return Visit(node, root);
+    }
+
+    private static bool IsNullConstant(Expression node)
+    {
+        while (node is UnaryExpression { NodeType: ExpressionType.Convert } convert)
+            node = convert.Operand;
+
+        return node is ConstantExpression { Value: null };
+    }
+
     private static string Visit(Expression node, ParameterExpression root)
     {
         switch (node)
@@ -120,10 +212,13 @@ private static bool TryGetPath(MemberExpression member, ParameterExpression root
         string s   => "'" + s.Replace("'", "''").Replace("{", "{{").Replace("}", "}}") + "'",
         bool b     => b ? "TRUE" : "FALSE",
         char c     => Literal(c.ToString()),
-        // Invariant culture — a de-DE thread culture must never turn 1.5 into '1,5'.
-        IFormattable f => f.ToString(null, CultureInfo.InvariantCulture),
+        // Invariant culture — a de-DE thread culture must never turn 1.5 into '1,5'. Only numbers:
+        // a DateTime, Guid or enum is IFormattable too, and came out as bare text that is not SQL.
+        int or long or short or byte or sbyte or uint or ulong or ushort or decimal or double or float
+            => ((IFormattable)value).ToString(null, CultureInfo.InvariantCulture),
         _ => throw new NotSupportedException(
-                 $"Cannot inline a value of type '{value.GetType().Name}' as a SQL literal in an index expression.")
+                 $"Cannot inline a value of type '{value.GetType().Name}' as a SQL literal in an index expression or filter. " +
+                 "Only strings, booleans and numbers have a portable SQL spelling; write anything else in the raw-SQL overload.")
     };
 
     private static object? Evaluate(Expression node)
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlTypedFilterExtensions.cs b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlTypedFilterExtensions.cs
new file mode 100644
index 0000000..5b14d3c
--- /dev/null
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/NpgsqlTypedFilterExtensions.cs
@@ -0,0 +1,119 @@
+using System.Linq.Expressions;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace EFCore.ComplexIndexes.PostgreSQL;
+
+/// <summary>
+/// Typed filter predicates: <c>x => x.RevokedAt == null</c> instead of <c>"revoked_at IS NULL"</c>.
+/// The lambda is translated at declaration time into a filter template whose property paths the
+/// differ resolves like any <c>{Property.Path}</c> placeholder — so <c>HasColumnName</c>, complex
+/// members and <c>ToJson()</c> members are honored, and the resolved SQL is baked into the
+/// migration with no runtime wiring.
+/// </summary>
+/// <remarks>
+/// The translated subset is deliberately small and fails at the declaration: comparisons
+/// (<c>== null</c> / <c>!= null</c> become <c>IS NULL</c> / <c>IS NOT NULL</c>), <c>&amp;&amp;</c>,
+/// <c>||</c>, <c>!</c>, boolean properties, and on the operands the string operations and
+/// constants a typed expression index accepts. Enums are refused — how one is stored depends on
+/// the property's value conversion, which a filter cannot see — as are values with no portable SQL
+/// spelling, such as dates; use the string overload for those.
+/// </remarks>
+public static class NpgsqlTypedFilterExtensions
+{
+    /// <summary>Applies a typed predicate as the filter of a complex-property index.</summary>
+    /// <typeparam name="TEntity">The entity type the predicate is written against; give it explicitly.</typeparam>
+    public static ComplexIndexBuilder HasFilter<TEntity>(this ComplexIndexBuilder builder, Expression<Func<TEntity, bool>> predicate)
+        where TEntity : class
+    {
+        ArgumentNullException.ThrowIfNull(predicate);
+        return builder.HasFilter(NpgsqlLinqIndexTranslator.TranslatePredicate(predicate));
+    }
+
+    /// <summary>Applies a typed predicate as the filter of an expression index.</summary>
+    /// <typeparam name="TEntity">The entity type the predicate is written against; give it explicitly.</typeparam>
+    public static ExpressionIndexBuilder HasFilter<TEntity>(this ExpressionIndexBuilder builder, Expression<Func<TEntity, bool>> predicate)
+        where TEntity : class
+    {
+        ArgumentNullException.ThrowIfNull(predicate);
+        return builder.HasFilter(NpgsqlLinqIndexTranslator.TranslatePredicate(predicate));
+    }
+
+    extension<TEntity>(EntityTypeBuilder<TEntity> builder) where TEntity : class
+    {
+        /// <summary>Configures a single-column index at the entity level with a typed filter.</summary>
+        public EntityTypeBuilder<TEntity> HasComplexIndex(
+            Expression<Func<TEntity, object?>> property,
+            Expression<Func<TEntity, bool>>    filter,
+            bool                               isUnique  = false,
+            string?                            indexName = null
+        )
+        {
+            ArgumentNullException.ThrowIfNull(filter);
+            return builder.HasComplexIndex(property, isUnique, NpgsqlLinqIndexTranslator.TranslatePredicate(filter), indexName);
+        }
+
+        /// <summary>Configures a composite index with a typed filter.</summary>
+        public EntityTypeBuilder<TEntity> HasComplexCompositeIndex<TProperties>(
+            Expression<Func<TEntity, TProperties>> columns,
+            Expression<Func<TEntity, bool>>        filter,
+            bool                                   isUnique  = false,
+            string?                                indexName = null
+        )
+        {
+            ArgumentNullException.ThrowIfNull(filter);
+            return builder.HasComplexCompositeIndex(columns, isUnique, NpgsqlLinqIndexTranslator.TranslatePredicate(filter), indexName);
+        }
+
+        /// <summary>Configures a typed expression index with a typed filter.</summary>
+        public EntityTypeBuilder<TEntity> HasExpressionIndex<TResult>(
+            Expression<Func<TEntity, TResult>> expression,
+            Expression<Func<TEntity, bool>>    filter,
+            bool                               isUnique  = false,
+            string?                            indexName = null
+        )
+        {
+            ArgumentNullException.ThrowIfNull(filter);
+            return builder.HasExpressionIndex(expression, isUnique, NpgsqlLinqIndexTranslator.TranslatePredicate(filter), indexName);
+        }
+
+        /// <summary>Adds an exclusion constraint in the scheduling shape with a typed filter.</summary>
+        public EntityTypeBuilder<TEntity> HasExclusionConstraint(
+            Expression<Func<TEntity, object?>> equalityColumns,
+            Expression<Func<TEntity, object?>> overlapsColumn,
+            Expression<Func<TEntity, bool>>    filter,
+            string?                            name = null
+        )
+        {
+            ArgumentNullException.ThrowIfNull(filter);
+            return builder.HasExclusionConstraint(equalityColumns, overlapsColumn, NpgsqlLinqIndexTranslator.TranslatePredicate(filter), name);
+        }
+    }
+
+    extension(IMutableEntityType entityType)
+    {
+        /// <summary>
+        /// Typed form of <see cref="ComplexIndexMutableExtensions.AddComplexIndexFilter"/>: ANDs the
+        /// translated predicate onto the filter of every selected complex index, idempotently.
+        /// </summary>
+        /// <typeparam name="TEntity">The entity type the predicate is written against; give it explicitly.</typeparam>
+        public int AddComplexIndexFilter<TEntity>(Expression<Func<TEntity, bool>> predicate, Func<ComplexIndexDeclaration, bool>? where = null)
+            where TEntity : class
+        {
+            ArgumentNullException.ThrowIfNull(predicate);
+            return entityType.AddComplexIndexFilter(NpgsqlLinqIndexTranslator.TranslatePredicate(predicate), where);
+        }
+
+        /// <summary>
+        /// Typed form of <see cref="NpgsqlExclusionMutableExtensions.AddExclusionConstraintFilter"/>:
+        /// ANDs the translated predicate onto the filter of every selected exclusion constraint, idempotently.
+        /// </summary>
+        /// <typeparam name="TEntity">The entity type the predicate is written against; give it explicitly.</typeparam>
+        public int AddExclusionConstraintFilter<TEntity>(Expression<Func<TEntity, bool>> predicate, Func<ExclusionConstraintDeclaration, bool>? where = null)
+            where TEntity : class
+        {
+            ArgumentNullException.ThrowIfNull(predicate);
+            return entityType.AddExclusionConstraintFilter(NpgsqlLinqIndexTranslator.TranslatePredicate(predicate), where);
+        }
+    }
+}
diff --git a/src/EFCore.ComplexIndexes.PostgreSQL/README.md b/src/EFCore.ComplexIndexes.PostgreSQL/README.md
index d54f1e3..3ffd3f3 100644
--- a/src/EFCore.ComplexIndexes.PostgreSQL/README.md
+++ b/src/EFCore.ComplexIndexes.PostgreSQL/README.md
@@ -105,7 +105,8 @@ builder.HasExpressionIndex(x => x.Email.Value.ToLower(), isUnique: true);
 
 The translated subset is deliberately small — `ToLower`/`ToUpper`, `Trim` variants, `Substring`,
 `Replace`, `string.Length`, concatenation, `??`, constants — and anything else throws
-`NotSupportedException` **at declaration time**, pointing at the raw-SQL overload.
+`NotSupportedException` **at declaration time**, pointing at the raw-SQL overload. A value object
+mapped through a converter resolves through its member: `x.Email.Value` is the `email` column.
 
 ### JSON member indexes
 
@@ -146,7 +147,18 @@ builder.HasExclusionConstraint(
 ```
 
 Constraint identity is the ordered elements **plus** the filter, so the same columns under different
-predicates give you two coexisting partial constraints (both must be named).
+predicates give you two coexisting partial constraints (both must be named). Filters — here and on
+indexes — resolve `{Property.Path}` placeholders to columns or JSON extractions at `migrations add`,
+and every `filter:` has a typed form: `x => x.RevokedAt == null`, or `HasFilter(x => …)` on the
+builders (`HasFilter<TEntity>` on the non-generic index builders). The translated subset is small —
+null checks, comparisons, `&&`/`||`/`!`, the string functions above — and refuses enums and dates
+at the declaration.
+
+Declared constraints can be read back — `GetExclusionConstraints()` on an entity type or the
+model, `FindExclusionConstraint(name)` — with elements, method, filter, deferrability and name, from
+the mutable model in `OnModelCreating` as well as the finalized one; and amended there:
+`AddExclusionConstraintFilter(predicate, where)` ANDs a predicate onto every selected constraint's
+filter, idempotently.
 
 ### `btree_gist`
 
diff --git a/src/EFCore.ComplexIndexes.SqlServer/CHANGELOG.md b/src/EFCore.ComplexIndexes.SqlServer/CHANGELOG.md
index 5ce9849..ca8cb65 100644
--- a/src/EFCore.ComplexIndexes.SqlServer/CHANGELOG.md
+++ b/src/EFCore.ComplexIndexes.SqlServer/CHANGELOG.md
@@ -4,6 +4,13 @@ Changes to the SQL Server satellite, newest first. The
 [root changelog](https://github.com/CaffeinatedCoder/EFCore.ComplexIndexes/blob/main/CHANGELOG.md)
 covers all three packages.
 
+## 5.2.0
+
+- **New:** filters resolve `{Property.Path}` placeholders to the mapped column, bracket-quoted, at
+  `migrations add` — `filter: "{DeletedAt} IS NULL"` becomes `[deleted_at] IS NULL` in the migration.
+- **Changed:** an index name longer than 128 characters is rejected at `migrations add` instead of
+  failing when the migration is applied.
+
 ## 5.1.0
 
 - **New:** `UseSqlServerComplexIndexes()` / `AddSqlServerComplexIndexes()` — optional runtime
diff --git a/src/EFCore.ComplexIndexes.SqlServer/README.md b/src/EFCore.ComplexIndexes.SqlServer/README.md
index e2cede1..df35fe9 100644
--- a/src/EFCore.ComplexIndexes.SqlServer/README.md
+++ b/src/EFCore.ComplexIndexes.SqlServer/README.md
@@ -54,6 +54,9 @@ Also available: `IsClustered()`, `SortInTempDb()`, and
 Filtered indexes (`filter:`) and `DbOrder.Desc` need nothing from this package — both ride on EF
 Core's native index operation.
 
+A filter may name properties instead of columns: `filter: "{DeletedAt} IS NULL"` resolves to
+`[deleted_at] IS NULL` at `migrations add`.
+
 ### Deliberate rejections
 
 Declarations SQL Server cannot express fail at `dotnet ef migrations add` with a targeted error
diff --git a/src/EFCore.ComplexIndexes.SqlServer/SqlServerComplexIndexMigrationsModelDiffer.cs b/src/EFCore.ComplexIndexes.SqlServer/SqlServerComplexIndexMigrationsModelDiffer.cs
index 84e3621..52ab9c8 100644
--- a/src/EFCore.ComplexIndexes.SqlServer/SqlServerComplexIndexMigrationsModelDiffer.cs
+++ b/src/EFCore.ComplexIndexes.SqlServer/SqlServerComplexIndexMigrationsModelDiffer.cs
@@ -53,6 +53,10 @@ protected override bool IsForwardedIndexAnnotation(string annotationName)
     /// <summary>SQL Server renames indexes standalone (<c>sp_rename</c>).</summary>
     protected override bool CanRenameIndexes => true;
 
+    /// <summary>SQL Server delimits identifiers with brackets.</summary>
+    protected override string QuoteIdentifier(string identifier)
+        => "[" + identifier.Replace("]", "]]") + "]";
+
     /// <summary>
     /// Resolves property paths inside INCLUDE lists to column names (verbatim fallback), and
     /// restores the data-compression enum after its JSON round trip.
diff --git a/src/EFCore.ComplexIndexes/AnnotationValues.cs b/src/EFCore.ComplexIndexes/AnnotationValues.cs
index 2ac8b87..87f043e 100644
--- a/src/EFCore.ComplexIndexes/AnnotationValues.cs
+++ b/src/EFCore.ComplexIndexes/AnnotationValues.cs
@@ -1,4 +1,5 @@
 using System.Collections;
+using System.Text.Json;
 
 namespace EFCore.ComplexIndexes;
 
@@ -33,4 +34,51 @@ public static void AddValue(ref HashCode hash, object? value)
         else
             hash.Add(value);
     }
+
+    /// <summary>
+    /// Replaces the <see cref="JsonElement"/>s a deserialized definition carries with plain values,
+    /// so provider annotations compare and render the same whether they came from the code model
+    /// or from the snapshot.
+    /// </summary>
+    public static Dictionary<string, object?> NormalizeProviderAnnotations(Dictionary<string, object?>? annotations)
+    {
+        if (annotations is null) return [];
+
+        var result = new Dictionary<string, object?>(annotations.Count);
+
+        foreach (var (key, value) in annotations)
+        {
+            result[key] = value is JsonElement je
+                              ? NormalizeJsonElement(je)
+                              : value;
+        }
+
+        return result;
+    }
+
+    private static object? NormalizeJsonElement(JsonElement je)
+    {
+        return je.ValueKind switch
+               {
+                   JsonValueKind.String => je.GetString(),
+                   JsonValueKind.True   => true,
+                   JsonValueKind.False  => false,
+                   JsonValueKind.Number => NormalizeNumber(je),
+                   JsonValueKind.Null   => null,
+                   JsonValueKind.Array => je.EnumerateArray()
+                                            .Select(e => e.ValueKind == JsonValueKind.String ? e.GetString() : e.ToString())
+                                            .ToArray(),
+                   _ => je.ToString()
+               };
+    }
+
+    // int first: provider generators read their numeric index options with `as int?` (e.g. SQL
+    // Server's FILLFACTOR), which returns null for a boxed long or double — the option would be
+    // silently dropped. (A ternary here would also coerce every integral to double.)
+    private static object NormalizeNumber(JsonElement je)
+    {
+        if (je.TryGetInt32(out var i)) return i;
+        if (je.TryGetInt64(out var l)) return l;
+        return je.GetDouble();
+    }
 }
diff --git a/src/EFCore.ComplexIndexes/CHANGELOG.md b/src/EFCore.ComplexIndexes/CHANGELOG.md
index c6fee4a..9afe6ea 100644
--- a/src/EFCore.ComplexIndexes/CHANGELOG.md
+++ b/src/EFCore.ComplexIndexes/CHANGELOG.md
@@ -4,6 +4,32 @@ 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.2.0
+
+- **Changed:** a complex index name longer than the provider's identifier limit
+  (`GetMaxIdentifierLength`, 63 on PostgreSQL, 128 on SQL Server) is rejected at `migrations add`.
+  Default names are checked too — this package never truncates them, unlike EF Core's own — and a
+  provider without a limit is left alone.
+
+- **New:** `GetComplexIndexes()` / `GetDeclaredComplexIndexes()` on `IReadOnlyEntityType`,
+  `GetComplexIndexes()` and `FindComplexIndex(name)` on `IReadOnlyModel` — the declarations read
+  back as `ComplexIndexDeclaration`s (parts as property paths, `IsUnique`, `Filter`, explicit `Name`,
+  provider options of entity-level declarations), from the mutable model in `OnModelCreating` too.
+  The differ reads the model through the same code.
+
+- **New:** filters resolve `{Property.Path}` placeholders to the mapped column at `migrations add`,
+  quoted through the new `QuoteIdentifier` seam (ANSI by default); the resolved text is baked into
+  the migration and compared against the snapshot. Only a dotted identifier path in braces outside
+  a single-quoted literal is a placeholder; an unknown one throws. Template resolution moved into
+  the core differ on the same seam.
+- **New:** a property path may end at a member of a converter-mapped value object
+  (`x => x.Email.Value`), which resolves to the converted column when the member's type is the
+  converter's provider type.
+
+- **New:** `AddComplexIndexFilter(predicate, where)` and `AddComplexIndex(definition)` on
+  `IMutableEntityType` — install a filter on every selected declaration (AND-ed onto an existing
+  one, idempotent) or add a declaration with the fluent API's identity rules, from `OnModelCreating`.
+
 ## 5.1.0
 
 - **Fixed:** `HasDifferences` now reports changes to complex indexes (and, through the satellites'
diff --git a/src/EFCore.ComplexIndexes/ComplexIndexDeclaration.cs b/src/EFCore.ComplexIndexes/ComplexIndexDeclaration.cs
new file mode 100644
index 0000000..36c1cb9
--- /dev/null
+++ b/src/EFCore.ComplexIndexes/ComplexIndexDeclaration.cs
@@ -0,0 +1,74 @@
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace EFCore.ComplexIndexes;
+
+/// <summary>
+/// One index declared through this package, read back from the model: a property-level
+/// <c>HasComplexIndex</c>, an entity-level <c>HasComplexIndex</c> or <c>HasComplexCompositeIndex</c>,
+/// or a provider satellite's expression index. Obtained through
+/// <see cref="ComplexIndexModelExtensions"/>; the differ reads its declarations through the same
+/// code, so what an application sees here is what the migration is built from.
+/// </summary>
+/// <remarks>
+/// This is the declaration, not the resolved index. Parts carry property paths, and
+/// <see cref="Name"/> is null when the differ derives the default <c>IX_{table}_{columns}</c>
+/// name from the resolved column names. Resolving columns needs the relational model and, for
+/// JSON members and expression templates, the provider satellite, so it happens in the differ only.
+/// </remarks>
+public sealed class ComplexIndexDeclaration
+{
+    internal ComplexIndexDeclaration(
+        IReadOnlyEntityType                  entityType,
+        IReadOnlyProperty?                   property,
+        IReadOnlyList<IndexPartDefinition>   parts,
+        string?                              name,
+        bool                                 isUnique,
+        string?                              filter,
+        IReadOnlyDictionary<string, object?> providerAnnotations
+    )
+    {
+        EntityType          = entityType;
+        Property            = property;
+        Parts               = parts;
+        Name                = name;
+        IsUnique            = isUnique;
+        Filter              = filter;
+        ProviderAnnotations = providerAnnotations;
+    }
+
+    /// <summary>The entity type the index is declared on.</summary>
+    public IReadOnlyEntityType EntityType { get; }
+
+    /// <summary>
+    /// The indexed property of a property-level declaration (<c>HasComplexIndex</c> on a
+    /// <c>ComplexTypePropertyBuilder</c>); null for an entity-level declaration.
+    /// </summary>
+    public IReadOnlyProperty? Property { get; }
+
+    /// <summary>
+    /// The ordered parts: a dotted property path per column, or a verbatim SQL expression or a
+    /// template for an expression index. A property-level declaration has exactly one column part.
+    /// </summary>
+    public IReadOnlyList<IndexPartDefinition> Parts { get; }
+
+    /// <summary>The explicit index name, or null when the differ derives the default from the resolved columns.</summary>
+    public string? Name { get; }
+
+    /// <summary>Whether the index is unique.</summary>
+    public bool IsUnique { get; }
+
+    /// <summary>The SQL predicate of a filtered (partial) index, or null for a full index.</summary>
+    public string? Filter { get; }
+
+    /// <summary>
+    /// The provider index options of an entity-level declaration (<c>Npgsql:IndexMethod</c>, …),
+    /// with the artefacts of the JSON round trip normalized to plain values. A property-level
+    /// declaration stores its options as annotations on <see cref="Property"/> under the same keys
+    /// and they are not repeated here: which of a property's annotations are index options and
+    /// which are column facets is something only the provider satellite's differ knows.
+    /// </summary>
+    public IReadOnlyDictionary<string, object?> ProviderAnnotations { get; }
+
+    /// <summary>Whether this is a property-level declaration (see <see cref="Property"/>).</summary>
+    public bool IsPropertyLevel => Property is not null;
+}
diff --git a/src/EFCore.ComplexIndexes/ComplexIndexModelExtensions.cs b/src/EFCore.ComplexIndexes/ComplexIndexModelExtensions.cs
new file mode 100644
index 0000000..3f740c5
--- /dev/null
+++ b/src/EFCore.ComplexIndexes/ComplexIndexModelExtensions.cs
@@ -0,0 +1,107 @@
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace EFCore.ComplexIndexes;
+
+/// <summary>
+/// Reads the indexes this package declares back from an EF Core model — mutable or finalized —
+/// so an application can check its own conventions ("every unique index on a withdrawable
+/// aggregate is filtered to live rows") instead of trusting each configuration to remember them.
+/// </summary>
+/// <remarks>
+/// The differ builds its index descriptors from <see cref="GetDeclaredComplexIndexes"/> too, so
+/// this is the same reading of the model that the migration is scaffolded from, not a second
+/// parser that can disagree with it.
+/// </remarks>
+public static class ComplexIndexModelExtensions
+{
+    extension(IReadOnlyEntityType entityType)
+    {
+        /// <summary>
+        /// The complex indexes declared on this entity type itself: property-level ones on its
+        /// declared properties (complex members included), then the entity-level list. Inherited
+        /// declarations are reported by the type that declares them, as with EF's own
+        /// <c>GetDeclaredIndexes</c>.
+        /// </summary>
+        public IReadOnlyList<ComplexIndexDeclaration> GetDeclaredComplexIndexes()
+        {
+            var result = new List<ComplexIndexDeclaration>();
+
+            CollectPropertyLevel(entityType, entityType, pathPrefix: "", result);
+
+            if (entityType.FindAnnotation(ComplexIndexAnnotations.CompositeIndexes)?.Value is string json
+             && !string.IsNullOrEmpty(json))
+            {
+                foreach (var definition in CompositeIndexSerializer.Deserialize(json))
+                    result.Add(new ComplexIndexDeclaration(
+                                   entityType,
+                                   property: null,
+                                   definition.EffectiveParts,
+                                   definition.IndexName,
+                                   definition.IsUnique,
+                                   definition.Filter,
+                                   AnnotationValues.NormalizeProviderAnnotations(definition.ProviderAnnotations)));
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// The complex indexes that apply to this entity type: its own declarations plus those of
+        /// its base types, base types first.
+        /// </summary>
+        public IReadOnlyList<ComplexIndexDeclaration> GetComplexIndexes()
+        {
+            var result = new List<ComplexIndexDeclaration>();
+
+            for (var type = entityType; type is not null; type = type.BaseType)
+                result.InsertRange(0, type.GetDeclaredComplexIndexes());
+
+            return result;
+        }
+    }
+
+    extension(IReadOnlyModel model)
+    {
+        /// <summary>Every complex index declared anywhere in the model, each reported once on its declaring type.</summary>
+        public IReadOnlyList<ComplexIndexDeclaration> GetComplexIndexes()
+            => [.. model.GetEntityTypes().SelectMany(entityType => entityType.GetDeclaredComplexIndexes())];
+
+        /// <summary>
+        /// Finds the complex index declared with the explicit name <paramref name="name"/>, or
+        /// null. Default names are derived by the differ from the resolved column names and are not
+        /// matched here — a declaration without a name has <see cref="ComplexIndexDeclaration.Name"/> null.
+        /// </summary>
+        /// <param name="name">The explicit index name, as given to <c>indexName:</c> or <c>HasName</c>.</param>
+        public ComplexIndexDeclaration? FindComplexIndex(string name)
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(name);
+            return model.GetComplexIndexes().FirstOrDefault(index => index.Name == name);
+        }
+    }
+
+    private static void CollectPropertyLevel(
+        IReadOnlyEntityType           entityType,
+        IReadOnlyTypeBase             typeBase,
+        string                        pathPrefix,
+        List<ComplexIndexDeclaration> result
+    )
+    {
+        foreach (var property in typeBase.GetDeclaredProperties())
+        {
+            if (property.FindAnnotation(ComplexIndexAnnotations.IsIndexed)?.Value is not true)
+                continue;
+
+            result.Add(new ComplexIndexDeclaration(
+                           entityType,
+                           property,
+                           [new IndexPartDefinition { PropertyPath = pathPrefix + property.Name }],
+                           property.FindAnnotation(ComplexIndexAnnotations.IndexName)?.Value as string,
+                           property.FindAnnotation(ComplexIndexAnnotations.IsUnique)?.Value is true,
+                           property.FindAnnotation(ComplexIndexAnnotations.Filter)?.Value as string,
+                           new Dictionary<string, object?>()));
+        }
+
+        foreach (var complexProperty in typeBase.GetDeclaredComplexProperties())
+            CollectPropertyLevel(entityType, complexProperty.ComplexType, $"{pathPrefix}{complexProperty.Name}.", result);
+    }
+}
diff --git a/src/EFCore.ComplexIndexes/ComplexIndexMutableExtensions.cs b/src/EFCore.ComplexIndexes/ComplexIndexMutableExtensions.cs
new file mode 100644
index 0000000..fb4c5e5
--- /dev/null
+++ b/src/EFCore.ComplexIndexes/ComplexIndexMutableExtensions.cs
@@ -0,0 +1,109 @@
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace EFCore.ComplexIndexes;
+
+/// <summary>
+/// Adds and amends complex-index declarations on an <see cref="IMutableEntityType"/> — the surface
+/// for a shared convention that installs an obligation once instead of relying on every
+/// configuration to repeat it: a soft-delete helper that already installs the query filter can
+/// install the live-rows index filter in the same call.
+/// </summary>
+/// <remarks>
+/// These amend what is declared <em>at the time of the call</em>. Run them after the declarations
+/// they should cover — at the end of <c>OnModelCreating</c>, after the configurations have been
+/// applied — and keep a check on <see cref="ComplexIndexModelExtensions.GetComplexIndexes(IReadOnlyEntityType)"/>
+/// for what a later declaration might add. They are meant for <c>OnModelCreating</c>: a model
+/// finalizing convention cannot overwrite an explicitly set annotation, and the declarations live
+/// in one.
+/// </remarks>
+public static class ComplexIndexMutableExtensions
+{
+    extension(IMutableEntityType entityType)
+    {
+        /// <summary>
+        /// Adds an entity-level index declaration, with the identity and validation of the fluent
+        /// API: the same ordered parts with the same filter replace an existing declaration, the
+        /// same parts with a different filter coexist and must both be named, and a reused explicit
+        /// name throws.
+        /// </summary>
+        /// <param name="definition">The declaration, as <see cref="CompositeIndexDefinition"/>.</param>
+        public void AddComplexIndex(CompositeIndexDefinition definition)
+        {
+            ArgumentNullException.ThrowIfNull(definition);
+
+            if (definition.EffectiveParts.Count == 0)
+                throw new ArgumentException("An index needs at least one part.", nameof(definition));
+
+            ComplexIndexStorage.AddOrReplace(entityType, definition);
+        }
+
+        /// <summary>
+        /// Adds <paramref name="predicate"/> to the filter of every complex index declared on this
+        /// type — property-level and entity-level alike — that <paramref name="where"/> selects, with
+        /// AND: an unfiltered index gets the predicate as its filter, a filtered one gets
+        /// <c>(existing) AND (predicate)</c>. Placeholders in the predicate resolve like any other
+        /// filter's. Applying the same predicate again is a no-op, so the call is safe to repeat.
+        /// </summary>
+        /// <param name="predicate">The SQL predicate to add, e.g. <c>"{RevokedAt} IS NULL"</c>.</param>
+        /// <param name="where">Selects the declarations to amend; null amends every one.</param>
+        /// <returns>How many declarations were changed.</returns>
+        public int AddComplexIndexFilter(string predicate, Func<ComplexIndexDeclaration, bool>? where = null)
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(predicate);
+
+            var amended = 0;
+
+            // Property-level declarations hold their filter on the property.
+            foreach (var declaration in entityType.GetDeclaredComplexIndexes())
+            {
+                if (declaration.Property is not { } property || where?.Invoke(declaration) == false)
+                    continue;
+
+                if (ComplexIndexStorage.Conjoin(declaration.Filter, predicate) is not { } filter)
+                    continue;
+
+                var mutable = property as IMutableProperty
+                           ?? throw new InvalidOperationException(
+                                  $"The property '{property.Name}' on '{entityType.DisplayName()}' is not mutable; " +
+                                  "amend declarations on the mutable model, inside OnModelCreating.");
+
+                mutable.SetAnnotation(ComplexIndexAnnotations.Filter, filter);
+                amended++;
+            }
+
+            // Entity-level declarations are one JSON list; rewrite it once.
+            var definitions  = ComplexIndexStorage.GetExisting(entityType);
+            var declarations = entityType.GetDeclaredComplexIndexes().Where(d => !d.IsPropertyLevel).ToList();
+            var changed      = false;
+
+            for (var i = 0; i < definitions.Count; i++)
+            {
+                if (where?.Invoke(declarations[i]) == false)
+                    continue;
+
+                if (ComplexIndexStorage.Conjoin(definitions[i].Filter, predicate) is not { } filter)
+                    continue;
+
+                definitions[i] = WithFilter(definitions[i], filter);
+                changed        = true;
+                amended++;
+            }
+
+            if (changed)
+                ComplexIndexStorage.Write(entityType, definitions);
+
+            return amended;
+        }
+    }
+
+    private static CompositeIndexDefinition WithFilter(CompositeIndexDefinition definition, string filter)
+        => new()
+           {
+               PropertyPaths       = definition.PropertyPaths,
+               Parts               = definition.Parts,
+               IsUnique            = definition.IsUnique,
+               Filter              = filter,
+               IndexName           = definition.IndexName,
+               ProviderAnnotations = definition.ProviderAnnotations
+           };
+}
diff --git a/src/EFCore.ComplexIndexes/ComplexIndexStorage.cs b/src/EFCore.ComplexIndexes/ComplexIndexStorage.cs
index 6a5544b..524697d 100644
--- a/src/EFCore.ComplexIndexes/ComplexIndexStorage.cs
+++ b/src/EFCore.ComplexIndexes/ComplexIndexStorage.cs
@@ -1,4 +1,5 @@
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
 namespace EFCore.ComplexIndexes;
@@ -19,8 +20,12 @@ internal static class ComplexIndexStorage
     /// collide in the database.
     /// </summary>
     public static void AddOrReplace(EntityTypeBuilder entityTypeBuilder, CompositeIndexDefinition definition)
+        => AddOrReplace(entityTypeBuilder.Metadata, definition);
+
+    /// <inheritdoc cref="AddOrReplace(EntityTypeBuilder, CompositeIndexDefinition)"/>
+    public static void AddOrReplace(IMutableEntityType entityType, CompositeIndexDefinition definition)
     {
-        var existing = GetExisting(entityTypeBuilder);
+        var existing = GetExisting(entityType);
         existing.RemoveAll(d => HasSameParts(d, definition) && d.Filter == definition.Filter);
 
         var unnamedSibling = existing.FirstOrDefault(
@@ -40,18 +45,37 @@ public static void AddOrReplace(EntityTypeBuilder entityTypeBuilder, CompositeIn
                 "this entity. Index names must be unique per table.");
 
         existing.Add(definition);
-        entityTypeBuilder.HasAnnotation(ComplexIndexAnnotations.CompositeIndexes, CompositeIndexSerializer.Serialize(existing));
+        Write(entityType, existing);
     }
 
-    public static List<CompositeIndexDefinition> GetExisting(EntityTypeBuilder entityTypeBuilder)
+    public static List<CompositeIndexDefinition> GetExisting(IReadOnlyEntityType entityType)
     {
-        var annotation = entityTypeBuilder.Metadata.FindAnnotation(ComplexIndexAnnotations.CompositeIndexes);
+        var annotation = entityType.FindAnnotation(ComplexIndexAnnotations.CompositeIndexes);
 
         return annotation?.Value is string json && !string.IsNullOrEmpty(json)
                    ? CompositeIndexSerializer.Deserialize(json)
                    : [];
     }
 
+    public static void Write(IMutableEntityType entityType, IReadOnlyList<CompositeIndexDefinition> definitions)
+        => entityType.SetAnnotation(ComplexIndexAnnotations.CompositeIndexes, CompositeIndexSerializer.Serialize(definitions));
+
+    /// <summary>
+    /// The filter that results from adding <paramref name="predicate"/> to <paramref name="existing"/>
+    /// with AND, or null when it is already there — either as the whole filter or as the conjunct
+    /// this method itself appended — so that applying an amendment twice is a no-op.
+    /// </summary>
+    public static string? Conjoin(string? existing, string predicate)
+    {
+        if (existing is null)
+            return predicate;
+
+        if (existing == predicate || existing.EndsWith($" AND ({predicate})", StringComparison.Ordinal))
+            return null;
+
+        return $"({existing}) AND ({predicate})";
+    }
+
     // Direction is deliberately ignored: re-declaring with a different DbOrder updates the index.
     private static bool HasSameParts(CompositeIndexDefinition a, CompositeIndexDefinition b)
         => a.EffectiveParts.Select(p => (p.PropertyPath, p.Expression, p.Template))
diff --git a/src/EFCore.ComplexIndexes/CustomMigrationsModelDiffer.cs b/src/EFCore.ComplexIndexes/CustomMigrationsModelDiffer.cs
index d3c9de0..e67dbca 100644
--- a/src/EFCore.ComplexIndexes/CustomMigrationsModelDiffer.cs
+++ b/src/EFCore.ComplexIndexes/CustomMigrationsModelDiffer.cs
@@ -1,4 +1,5 @@
-using System.Text.Json;
+using System.Reflection;
+using System.Text;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Migrations;
@@ -76,6 +77,7 @@ public override IReadOnlyList<MigrationOperation> GetDifferences(
         // still be diffable, or the model could never be fixed.
         ValidateUniqueIndexNames(targetIndexes);
         ValidateNoNativeIndexNameCollision(target, targetIndexes);
+        ValidateIndexNameLengths(target, targetIndexes);
 
         if (sourceIndexes.Count == 0 && targetIndexes.Count == 0)
             return operations;
@@ -317,16 +319,160 @@ StoreObjectIdentifier storeObject
 
     /// <summary>
     /// Resolves a template part (<c>{Property.Path}</c> placeholders from a typed-expression
-    /// translator) into a final SQL expression. Identifier quoting is provider-specific, so the
-    /// core has no implementation — provider satellites override this.
+    /// translator) into a final SQL expression: each placeholder becomes a quoted column reference
+    /// — or, through <see cref="ResolveUnmappedPart"/>, a parenthesized expression such as a JSON
+    /// extraction — and <c>{{</c>/<c>}}</c> unescape to literal braces. Quoting goes through
+    /// <see cref="QuoteIdentifier"/>, so a satellite normally has nothing to override here.
     /// </summary>
     protected virtual ResolvedIndexPart ResolveTemplatePart(
         IEntityType           entityType,
         IndexPartDefinition   part,
         StoreObjectIdentifier storeObject
-    ) => throw new InvalidOperationException(
-             $"The index template '{part.Template}' on entity '{entityType.Name}' requires a provider " +
-             "satellite differ (e.g. EFCore.ComplexIndexes.PostgreSQL) to resolve column references.");
+    )
+    {
+        var template = part.Template!;
+        var sql      = new StringBuilder(template.Length);
+
+        for (var i = 0; i < template.Length; i++)
+        {
+            var ch = template[i];
+
+            if (ch == '{')
+            {
+                if (i + 1 < template.Length && template[i + 1] == '{')
+                {
+                    sql.Append('{');
+                    i++;
+                    continue;
+                }
+
+                var end = template.IndexOf('}', i + 1);
+                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"));
+                i = end;
+                continue;
+            }
+
+            if (ch == '}')
+            {
+                if (i + 1 < template.Length && template[i + 1] == '}')
+                {
+                    sql.Append('}');
+                    i++;
+                    continue;
+                }
+
+                throw new InvalidOperationException($"Malformed index expression template '{template}' on entity '{entityType.Name}'.");
+            }
+
+            sql.Append(ch);
+        }
+
+        return new ResolvedIndexPart(true, sql.ToString(), part.Descending, part.NullSort);
+    }
+
+    /// <summary>
+    /// Resolves the <c>{Property.Path}</c> placeholders in a filter predicate to quoted column
+    /// references — or parenthesized JSON extractions — the way <see cref="ResolveTemplatePart"/>
+    /// does for expression parts, so a filter can name properties instead of column names. The
+    /// resolved text is what the operation carries, rendered by the stock generator with no runtime
+    /// wiring, and what source and target are compared on, so a filter written with placeholders
+    /// diffs exactly like one written with column names.
+    /// </summary>
+    /// <remarks>
+    /// Filters are existing SQL, so the rule is narrower than for templates: only a brace pair
+    /// whose content is a dotted identifier path, outside a single-quoted string literal, is a
+    /// placeholder. Everything else stays verbatim — <c>'{urgent}'</c> is a PostgreSQL array
+    /// literal, <c>'{"a": 1}'</c> a JSON document, <c>'{{1,2},{3,4}}'</c> a two-dimensional array —
+    /// which is also why there is no <c>{{</c> escape here. A placeholder that names no property
+    /// throws: outside a literal, braces are never valid SQL, so it can only be a mistake.
+    /// </remarks>
+    /// <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>
+    /// <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)
+    {
+        if (filter is null || !filter.Contains('{'))
+            return filter;
+
+        var sql       = new StringBuilder(filter.Length);
+        var inLiteral = false;
+
+        for (var i = 0; i < filter.Length; i++)
+        {
+            var ch = filter[i];
+
+            // A doubled quote inside a literal toggles twice and lands back inside it.
+            if (ch == '\'')
+                inLiteral = !inLiteral;
+
+            if (ch == '{' && !inLiteral)
+            {
+                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"));
+                    i = end;
+                    continue;
+                }
+            }
+
+            sql.Append(ch);
+        }
+
+        return sql.ToString();
+    }
+
+    // Dotted identifier segments: letters, digits and underscores, each starting with a letter or
+    // an underscore. Anything else between braces is SQL text, not a placeholder.
+    private static bool IsPropertyPath(ReadOnlySpan<char> text)
+    {
+        var segmentStart = true;
+
+        foreach (var ch in text)
+        {
+            if (ch == '.')
+            {
+                if (segmentStart) return false;
+                segmentStart = true;
+                continue;
+            }
+
+            var valid = segmentStart ? char.IsLetter(ch) || ch == '_' : char.IsLetterOrDigit(ch) || ch == '_';
+            if (!valid) return false;
+
+            segmentStart = false;
+        }
+
+        return !segmentStart;
+    }
+
+    private string ResolvePlaceholder(IEntityType entityType, string path, StoreObjectIdentifier storeObject, string usage)
+    {
+        var column = ResolveColumnName(entityType, path, storeObject);
+        if (column is not null)
+            return QuoteIdentifier(column);
+
+        var unmapped = ResolveUnmappedPart(entityType, new IndexPartDefinition { PropertyPath = path }, storeObject);
+        if (unmapped is not null)
+            return unmapped.IsExpression ? $"({unmapped.Value})" : QuoteIdentifier(unmapped.Value);
+
+        throw new InvalidOperationException(
+            $"Could not resolve property path '{path}' referenced by {usage} on entity '{entityType.Name}'.");
+    }
+
+    /// <summary>
+    /// Delimits an identifier for the SQL this differ renders itself: resolved template parts and
+    /// filter placeholders. ANSI double quotes by default, which PostgreSQL and SQLite use; the SQL
+    /// Server satellite overrides this with brackets.
+    /// </summary>
+    /// <param name="identifier">The raw column name.</param>
+    /// <returns>The delimited identifier.</returns>
+    protected virtual string QuoteIdentifier(string identifier)
+        => "\"" + identifier.Replace("\"", "\"\"") + "\"";
 
     /// <summary>
     /// Fails when two distinct declarations resolve to the same index name on the same table.
@@ -410,6 +556,62 @@ private static void ValidateNoNativeIndexNameCollision(IRelationalModel? target,
         }
     }
 
+    private void ValidateIndexNameLengths(IRelationalModel? target, HashSet<IndexDescriptor> descriptors)
+    {
+        if (target is null)
+            return;
+
+        foreach (var descriptor in descriptors)
+            ThrowIfIdentifierTooLong(target.Model, descriptor.IndexName, "complex index", descriptor.TableName, "indexName");
+    }
+
+    /// <summary>
+    /// Fails when <paramref name="name"/> is longer than the provider's identifier limit
+    /// (<see cref="RelationalModelExtensions.GetMaxIdentifierLength"/>). Satellites call it for the
+    /// names of the constraints they emit; the core calls it for every complex index name.
+    /// </summary>
+    /// <remarks>
+    /// The names this package derives are never truncated, unlike EF's own default names. PostgreSQL
+    /// cuts a longer identifier down to 63 bytes with a NOTICE and applies the migration cleanly, so
+    /// the index exists under a name that neither the declaration nor a later constraint-violation
+    /// error ever matches — a slice that dispatches on the constraint name falls through in silence.
+    /// SQL Server rejects the statement instead. Both are caught here, at <c>migrations add</c>.
+    /// Validate the <em>target</em> model only: a snapshot already carrying such a name has to stay
+    /// diffable, or the model could never be fixed.
+    /// </remarks>
+    /// <param name="model">The target model, whose provider sets the identifier limit.</param>
+    /// <param name="name">The resolved index or constraint name.</param>
+    /// <param name="kind">What the name belongs to, for the message — <c>"complex index"</c>, <c>"exclusion constraint"</c>, …</param>
+    /// <param name="table">The table the declaration targets, for the message.</param>
+    /// <param name="parameter">The declaration parameter that sets an explicit name, for the message.</param>
+    protected void ThrowIfIdentifierTooLong(IReadOnlyModel model, string name, string kind, string table, string parameter)
+    {
+        var limit            = model.GetMaxIdentifierLength();
+        var (length, unit)   = MeasureIdentifier(name);
+
+        if (length <= limit)
+            return;
+
+        throw new InvalidOperationException(
+            $"The {kind} name '{name}' on table '{table}' is {length} {unit} long, but the provider allows at most {limit}. "
+          + $"A longer name is truncated or rejected when the migration is applied, so the {kind} would exist under a "
+          + "name that neither this declaration nor a constraint-violation error ever reports. "
+          + $"Give the declaration an explicit, shorter name ({parameter}).");
+    }
+
+    /// <summary>
+    /// Measures an identifier the way the provider does when enforcing
+    /// <see cref="RelationalModelExtensions.GetMaxIdentifierLength"/>. The core counts characters,
+    /// which is what SQL Server's 128-character limit means; PostgreSQL's 63 is a byte count, so its
+    /// satellite overrides this to measure UTF-8 bytes.
+    /// </summary>
+    /// <param name="identifier">The identifier to measure.</param>
+    /// <returns>The length and the unit it is expressed in, for error messages.</returns>
+    protected virtual (int Length, string Unit) MeasureIdentifier(string identifier)
+        => (identifier.Length, "characters");
+
+    // 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)
     {
         var result = new HashSet<IndexDescriptor>();
@@ -417,19 +619,26 @@ private HashSet<IndexDescriptor> ExtractAllIndexDescriptors(IRelationalModel? re
 
         foreach (var entityType in relationalModel.Model.GetEntityTypes())
         {
+            var declarations = entityType.GetDeclaredComplexIndexes();
+            if (declarations.Count == 0)
+                continue;
+
             var tableName = entityType.GetTableName();
             var schema    = entityType.GetSchema();
             if (tableName is null)
             {
-                if (DeclaresComplexIndexes(entityType))
-                    ThrowIfDeclaredOnUnmappedType(entityType, "complex indexes");
+                ThrowIfDeclaredOnUnmappedType(entityType, "complex indexes");
                 continue;
             }
 
             var storeObject = StoreObjectIdentifier.Table(tableName, schema);
 
-            ScanForSingleColumnIndexes(entityType, entityType, pathPrefix: "", tableName, schema, storeObject, result);
-            ScanForCompositeIndexes(entityType, tableName, schema, result);
+            foreach (var declaration in declarations)
+            {
+                result.Add(declaration.Property is { } property
+                               ? ResolvePropertyLevelIndex(entityType, declaration, property, tableName, schema, storeObject)
+                               : ResolveEntityLevelIndex(entityType, declaration, tableName, schema, storeObject));
+            }
         }
 
         return result;
@@ -458,175 +667,89 @@ protected static void ThrowIfDeclaredOnUnmappedType(IEntityType entityType, stri
           + "table: declare them on the concrete entity types instead.");
     }
 
-    private static bool DeclaresComplexIndexes(IEntityType entityType)
-        => entityType.FindAnnotation(ComplexIndexAnnotations.CompositeIndexes)?.Value is string { Length: > 2 }
-        || DeclaresPropertyIndexes(entityType);
-
-    private static bool DeclaresPropertyIndexes(ITypeBase typeBase)
-        => typeBase.GetDeclaredProperties().Any(p => p.FindAnnotation(ComplexIndexAnnotations.IsIndexed)?.Value is true)
-        || typeBase.GetDeclaredComplexProperties().Any(cp => DeclaresPropertyIndexes(cp.ComplexType));
-
-    private void ScanForSingleColumnIndexes(
-        IEntityType              rootEntityType,
-        ITypeBase                typeBase,
-        string                   pathPrefix,
-        string                   tableName,
-        string?                  schema,
-        StoreObjectIdentifier    storeObject,
-        HashSet<IndexDescriptor> results
+    private IndexDescriptor ResolvePropertyLevelIndex(
+        IEntityType             entityType,
+        ComplexIndexDeclaration declaration,
+        IReadOnlyProperty       property,
+        string                  tableName,
+        string?                 schema,
+        StoreObjectIdentifier   storeObject
     )
     {
-        foreach (var property in typeBase.GetDeclaredProperties())
+        var columnName = property.GetColumnName(storeObject);
+
+        // No table column — a JSON-mapped complex member, for example. Give the provider
+        // satellite a chance to resolve it to an expression part before giving up.
+        var part = columnName is not null
+                       ? new ResolvedIndexPart(false, columnName)
+                       : ResolveUnmappedPart(entityType, declaration.Parts[0], storeObject)
+                      ?? throw new InvalidOperationException(
+                             $"The property '{property.Name}' on '{property.DeclaringType.Name}' is marked with " +
+                             $"HasComplexIndex but has no column mapping for table '{tableName}'. " +
+                             "A property mapped to JSON (or not mapped to this table) cannot carry " +
+                             "a complex index here; use an expression index over the JSON column instead.");
+
+        var indexName = declaration.Name ?? $"IX_{tableName}_{BuildPartToken(part)}";
+
+        // Collect only whitelisted provider index options; everything else on the property is a
+        // column facet that does not belong on an index operation.
+        var providerAnnotations = new Dictionary<string, object?>();
+        foreach (var annotation in property.GetAnnotations())
         {
-            if (property.FindAnnotation(ComplexIndexAnnotations.IsIndexed)?.Value is not true)
-                continue;
-
-            var columnName = property.GetColumnName(storeObject);
-
-            // No table column — a JSON-mapped complex member, for example. Give the provider
-            // satellite a chance to resolve it to an expression part before giving up.
-            var part = columnName is not null
-                           ? new ResolvedIndexPart(false, columnName)
-                           : ResolveUnmappedPart(
-                                 rootEntityType,
-                                 new IndexPartDefinition { PropertyPath = pathPrefix + property.Name },
-                                 storeObject)
-                          ?? throw new InvalidOperationException(
-                                 $"The property '{property.Name}' on '{typeBase.Name}' is marked with " +
-                                 $"HasComplexIndex but has no column mapping for table '{tableName}'. " +
-                                 "A property mapped to JSON (or not mapped to this table) cannot carry " +
-                                 "a complex index here; use an expression index over the JSON column instead.");
-
-            var isUnique = property.FindAnnotation(ComplexIndexAnnotations.IsUnique)?.Value is true;
-            var filter   = property.FindAnnotation(ComplexIndexAnnotations.Filter)?.Value as string;
-            var indexName = property.FindAnnotation(ComplexIndexAnnotations.IndexName)?.Value as string
-                         ?? $"IX_{tableName}_{BuildPartToken(part)}";
-
-            // Collect only whitelisted provider index options; everything else on the property is a
-            // column facet that does not belong on an index operation.
-            var providerAnnotations = new Dictionary<string, object?>();
-            foreach (var ann in property.GetAnnotations())
-            {
-                if (IsForwardedIndexAnnotation(ann.Name))
-                    providerAnnotations[ann.Name] = TransformIndexAnnotation(rootEntityType, ann.Name, ann.Value, storeObject);
-            }
-
-            results.Add(new IndexDescriptor(tableName, schema, [part], indexName, isUnique, filter, providerAnnotations));
+            if (IsForwardedIndexAnnotation(annotation.Name))
+                providerAnnotations[annotation.Name] = TransformIndexAnnotation(entityType, annotation.Name, annotation.Value, storeObject);
         }
 
-        foreach (var cp in typeBase.GetDeclaredComplexProperties())
-            ScanForSingleColumnIndexes(rootEntityType, cp.ComplexType, $"{pathPrefix}{cp.Name}.", tableName, schema, storeObject, results);
+        return new IndexDescriptor(tableName, schema, [part], indexName, declaration.IsUnique, ResolveFilter(entityType, declaration.Filter, storeObject), providerAnnotations);
     }
 
-    private void ScanForCompositeIndexes(
-        IEntityType              entityType,
-        string                   tableName,
-        string?                  schema,
-        HashSet<IndexDescriptor> results
+    private IndexDescriptor ResolveEntityLevelIndex(
+        IEntityType             entityType,
+        ComplexIndexDeclaration declaration,
+        string                  tableName,
+        string?                 schema,
+        StoreObjectIdentifier   storeObject
     )
     {
-        var annotation = entityType.FindAnnotation(ComplexIndexAnnotations.CompositeIndexes);
+        var parts = new List<ResolvedIndexPart>(declaration.Parts.Count);
 
-        if (annotation?.Value is not string json || string.IsNullOrEmpty(json))
-            return;
-
-        var definitions = CompositeIndexSerializer.Deserialize(json);
-        var storeObject = StoreObjectIdentifier.Table(tableName, schema);
-
-        foreach (var def in definitions)
+        foreach (var part in declaration.Parts)
         {
-            var parts = new List<ResolvedIndexPart>(def.EffectiveParts.Count);
-
-            foreach (var part in def.EffectiveParts)
+            if (part.IsExpression)
             {
-                if (part.IsExpression)
-                {
-                    parts.Add(new ResolvedIndexPart(true, part.Expression!, part.Descending, part.NullSort));
-                    continue;
-                }
-
-                if (part.IsTemplate)
-                {
-                    parts.Add(ResolveTemplatePart(entityType, part, storeObject));
-                    continue;
-                }
-
-                var col = ResolveColumnName(entityType, part.PropertyPath!, storeObject);
-                if (col is not null)
-                {
-                    parts.Add(new ResolvedIndexPart(false, col, part.Descending, part.NullSort));
-                    continue;
-                }
-
-                // No table column — give the provider satellite a chance (JSON members, …).
-                var unmapped = ResolveUnmappedPart(entityType, part, storeObject)
-                            ?? throw new InvalidOperationException(
-                                   $"Could not resolve property path '{part.PropertyPath}' for index on entity {entityType.Name}."
-                               );
-
-                parts.Add(unmapped);
+                parts.Add(new ResolvedIndexPart(true, part.Expression!, part.Descending, part.NullSort));
+                continue;
             }
 
-            var indexName = def.IndexName ?? $"IX_{tableName}_{string.Join("_", parts.Select(BuildPartToken))}";
-
-            var normalized = NormalizeProviderAnnotations(def.ProviderAnnotations);
-            foreach (var key in normalized.Keys.ToList())
-                normalized[key] = TransformIndexAnnotation(entityType, key, normalized[key], storeObject);
-
-            results.Add(
-                new IndexDescriptor(
-                    tableName,
-                    schema,
-                    parts,
-                    indexName,
-                    def.IsUnique,
-                    def.Filter,
-                    normalized
-                )
-            );
-        }
-    }
+            if (part.IsTemplate)
+            {
+                parts.Add(ResolveTemplatePart(entityType, part, storeObject));
+                continue;
+            }
 
-    private static Dictionary<string, object?> NormalizeProviderAnnotations(Dictionary<string, object?>? annotations)
-    {
-        if (annotations is null) return [];
+            var col = ResolveColumnName(entityType, part.PropertyPath!, storeObject);
+            if (col is not null)
+            {
+                parts.Add(new ResolvedIndexPart(false, col, part.Descending, part.NullSort));
+                continue;
+            }
 
-        var result = new Dictionary<string, object?>(annotations.Count);
+            // No table column — give the provider satellite a chance (JSON members, …).
+            var unmapped = ResolveUnmappedPart(entityType, part, storeObject)
+                        ?? throw new InvalidOperationException(
+                               $"Could not resolve property path '{part.PropertyPath}' for index on entity {entityType.Name}."
+                           );
 
-        foreach (var (key, value) in annotations)
-        {
-            result[key] = value is JsonElement je
-                              ? NormalizeJsonElement(je)
-                              : value;
+            parts.Add(unmapped);
         }
 
-        return result;
-    }
+        var indexName = declaration.Name ?? $"IX_{tableName}_{string.Join("_", parts.Select(BuildPartToken))}";
 
-    private static object? NormalizeJsonElement(JsonElement je)
-    {
-        return je.ValueKind switch
-               {
-                   JsonValueKind.String => je.GetString(),
-                   JsonValueKind.True   => true,
-                   JsonValueKind.False  => false,
-                   JsonValueKind.Number => NormalizeNumber(je),
-                   JsonValueKind.Null   => null,
-                   JsonValueKind.Array => je.EnumerateArray()
-                                            .Select(e => e.ValueKind == JsonValueKind.String ? e.GetString() : e.ToString())
-                                            .ToArray(),
-                   _ => je.ToString()
-               };
-    }
+        var providerAnnotations = new Dictionary<string, object?>(declaration.ProviderAnnotations.Count);
+        foreach (var (key, value) in declaration.ProviderAnnotations)
+            providerAnnotations[key] = TransformIndexAnnotation(entityType, key, value, storeObject);
 
-    // int first: provider generators read their numeric index options with `as int?` (e.g. SQL
-    // Server's FILLFACTOR), which returns null for a boxed long or double — the option would be
-    // silently dropped. (A ternary here would also coerce every integral to double.)
-    private static object NormalizeNumber(JsonElement je)
-    {
-        if (je.TryGetInt32(out var i)) return i;
-        if (je.TryGetInt64(out var l)) return l;
-        return je.GetDouble();
+        return new IndexDescriptor(tableName, schema, parts, indexName, declaration.IsUnique, ResolveFilter(entityType, declaration.Filter, storeObject), providerAnnotations);
     }
 
     // Builds a default index-name token for a part: column names pass through; expressions are
@@ -646,23 +769,63 @@ private static string BuildPartToken(ResolvedIndexPart part)
         string                dotPath,
         StoreObjectIdentifier storeObject
     )
+        => ResolveProperty(entityType, dotPath)?.GetColumnName(storeObject);
+
+    /// <summary>
+    /// Resolves a dotted property path to the scalar property it names, walking complex
+    /// properties, or null when there is no such property.
+    /// </summary>
+    /// <remarks>
+    /// A path may also end one step <em>past</em> a scalar property, at a member of its CLR type:
+    /// <c>Email.Value</c> where <c>Email</c> is a value object mapped through a value converter.
+    /// The member unwraps to the property when the property has a converter and the member's type
+    /// is the converter's provider type — the column holds exactly that member. Without the type
+    /// check, <c>CreatedAt.Year</c> would resolve to the whole column and index something other
+    /// than what was written.
+    /// </remarks>
+    /// <param name="typeBase">The entity or complex type the path starts from.</param>
+    /// <param name="dotPath">The path, e.g. <c>Address.City</c>.</param>
+    /// <returns>The property, or null.</returns>
+    protected static IProperty? ResolveProperty(ITypeBase typeBase, string dotPath)
     {
-        var       parts   = dotPath.Split('.');
-        ITypeBase current = entityType;
+        var parts   = dotPath.Split('.');
+        var current = typeBase;
 
         for (var i = 0; i < parts.Length; i++)
         {
             if (i == parts.Length - 1)
-                return current.FindProperty(parts[i])?.GetColumnName(storeObject);
+                return current.FindProperty(parts[i]);
 
-            var cp = current.FindComplexProperty(parts[i]);
-            if (cp is null) return null;
-            current = cp.ComplexType;
+            var complexProperty = current.FindComplexProperty(parts[i]);
+            if (complexProperty is not null)
+            {
+                current = complexProperty.ComplexType;
+                continue;
+            }
+
+            return i == parts.Length - 2 ? FindConvertedMember(current, parts[i], parts[i + 1]) : null;
         }
 
         return null;
     }
 
+    private static IProperty? FindConvertedMember(ITypeBase typeBase, string propertyName, string memberName)
+    {
+        var property  = typeBase.FindProperty(propertyName);
+        var converter = property?.FindTypeMapping()?.Converter ?? property?.GetValueConverter();
+        if (property is null || converter is null)
+            return null;
+
+        var memberType = property.ClrType.GetProperty(memberName, BindingFlags.Public | BindingFlags.Instance)?.PropertyType
+                      ?? property.ClrType.GetField(memberName, BindingFlags.Public | BindingFlags.Instance)?.FieldType;
+        if (memberType is null)
+            return null;
+
+        return Unwrap(memberType) == Unwrap(converter.ProviderClrType) ? property : null;
+
+        static Type Unwrap(Type type) => Nullable.GetUnderlyingType(type) ?? type;
+    }
+
     internal sealed record IndexDescriptor(
         string                        TableName,
         string?                       Schema,
diff --git a/src/EFCore.ComplexIndexes/README.md b/src/EFCore.ComplexIndexes/README.md
index 129f9cf..c0305f0 100644
--- a/src/EFCore.ComplexIndexes/README.md
+++ b/src/EFCore.ComplexIndexes/README.md
@@ -37,6 +37,11 @@ builder.ComplexProperty(x => x.EmailAddress, c =>
 Column names are resolved against the real model, so both convention-based names (`Origin_Source`)
 and explicit `HasColumnName` overrides are honored.
 
+A filter may name properties instead of columns — `filter: "{DeletedAt} IS NULL"` resolves to the
+mapped column at `migrations add`, quoted for the provider, and is baked into the migration. A
+selector reaches into complex properties and, for a value object mapped through a converter, one
+step further: `x => x.Email.Value` resolves to the converted column.
+
 ### Several indexes over one column
 
 A property-level declaration holds **one** index per property. To give a column several
@@ -50,8 +55,9 @@ builder.HasComplexIndex(x => x.EmailAddress.Value,
     indexName: "ix_person_email_all");
 ```
 
-Index names must be unique per table, and the package enforces it rather than letting the database
-reject the migration.
+Index names must be unique per table and within the provider's identifier limit (63 bytes on
+PostgreSQL, which would otherwise truncate silently), and the package enforces both at
+`dotnet ef migrations add` rather than letting the database reject — or quietly shorten — the name.
 
 ### Composite index across scalar and nested properties
 
@@ -79,6 +85,25 @@ see the PostgreSQL package.
 
 ---
 
+### Reading declarations back
+
+`GetComplexIndexes()` on an entity type (or the model) returns every declaration — property-level,
+entity-level, composite, expression — with its parts, `IsUnique`, `Filter` and explicit `Name`, so an
+application can check its own conventions; `FindComplexIndex(name)` looks one up by explicit name.
+It works on the mutable model inside `OnModelCreating` too, and the differ reads declarations
+through the same code.
+
+```csharp
+var unfiltered = modelBuilder.Model.GetEntityTypes()
+    .SelectMany(e => e.GetComplexIndexes())
+    .Where(ix => ix.IsUnique && ix.Filter is null);
+```
+
+Or install the convention: on the mutable model, `AddComplexIndexFilter(predicate, where)` ANDs a
+predicate onto every selected declaration's filter, idempotently, and `AddComplexIndex(definition)`
+adds one with the fluent API's identity rules. Both amend what is declared at the time of the call,
+so run them after the configurations.
+
 ## Documentation
 
 Full documentation, including every provider-specific feature:
diff --git a/test/EFCore.ComplexIndexes.Tests/ConverterMemberTests.cs b/test/EFCore.ComplexIndexes.Tests/ConverterMemberTests.cs
new file mode 100644
index 0000000..432ad7f
--- /dev/null
+++ b/test/EFCore.ComplexIndexes.Tests/ConverterMemberTests.cs
@@ -0,0 +1,145 @@
+using EFCore.ComplexIndexes.PostgreSQL;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Migrations.Operations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using NpgsqlTypes;
+
+namespace EFCore.ComplexIndexes.Tests;
+
+/// <summary>
+/// A value object mapped through a value converter is one scalar property, so <c>x.Email.Value</c>
+/// produced the path <c>Email.Value</c> and the walk died at <c>Email</c>: there is no complex
+/// property to descend into. The member now unwraps to the property when the property has a
+/// converter and the member's type is the converter's provider type — the column holds exactly
+/// that member. Everything else keeps failing, loudly: <c>CreatedAt.Year</c> must not resolve to the
+/// whole column.
+/// </summary>
+[TestClass]
+public class ConverterMemberTests
+{
+    private readonly record struct EmailAddress(string Value);
+
+    private class Money
+    {
+        public decimal Amount   { get; init; }
+        public string  Currency { get; init; } = "EUR";
+    }
+
+    private class Customer
+    {
+        public Guid                  Id        { get; set; }
+        public EmailAddress          Email     { get; set; }
+        public Money                 Price     { get; set; } = new();
+        public DateTime              CreatedAt { get; set; }
+        public NpgsqlRange<DateOnly> Period    { get; set; }
+    }
+
+    private sealed class EmailConverter() : ValueConverter<EmailAddress, string>(e => e.Value, v => new EmailAddress(v));
+
+    private abstract class CustomerContext(DbContextOptions options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Customer>(b =>
+            {
+                b.ToTable("customers");
+                b.HasKey(x => x.Id);
+                b.Property(x => x.Email).HasConversion(e => e.Value, v => new EmailAddress(v)).HasColumnName("email");
+                b.Property(x => x.Price).HasConversion(m => m.Amount, a => new Money { Amount = a }).HasColumnName("price");
+                Declare(b);
+            });
+
+        protected abstract void Declare(Microsoft.EntityFrameworkCore.Metadata.Builders.EntityTypeBuilder<Customer> b);
+    }
+
+    private class ConvertedMemberContext(DbContextOptions<ConvertedMemberContext> options) : CustomerContext(options)
+    {
+        protected override void Declare(Microsoft.EntityFrameworkCore.Metadata.Builders.EntityTypeBuilder<Customer> b)
+        {
+            b.HasComplexIndex(x => x.Email.Value, isUnique: true, indexName: "ux_customer_email");
+            b.HasExpressionIndex(x => x.Email.Value.ToLower(), indexName: "ix_customer_email_lower");
+            b.HasComplexIndex(x => x.Price.Amount, indexName: "ix_customer_amount");
+            b.HasExclusionConstraint(ex => ex.WithEquality(x => x.Email.Value).WithOverlaps(x => x.Period).HasName("ex_customer_email_period"));
+        }
+    }
+
+    private class MismatchedMemberContext(DbContextOptions<MismatchedMemberContext> options) : CustomerContext(options)
+    {
+        protected override void Declare(Microsoft.EntityFrameworkCore.Metadata.Builders.EntityTypeBuilder<Customer> b)
+            => b.HasComplexIndex(x => x.Price.Currency, indexName: "ix_customer_currency");
+    }
+
+    private class UnconvertedMemberContext(DbContextOptions<UnconvertedMemberContext> options) : CustomerContext(options)
+    {
+        protected override void Declare(Microsoft.EntityFrameworkCore.Metadata.Builders.EntityTypeBuilder<Customer> b)
+            => b.HasComplexIndex(x => x.CreatedAt.Year, indexName: "ix_customer_year");
+    }
+
+    // The converter comes from ConfigureConventions rather than the property: the walk must see it too.
+    private class PreConventionContext(DbContextOptions<PreConventionContext> options) : DbContext(options)
+    {
+        protected override void ConfigureConventions(ModelConfigurationBuilder configurationBuilder)
+            => configurationBuilder.Properties<EmailAddress>().HaveConversion<EmailConverter>();
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Customer>(b =>
+            {
+                b.ToTable("customers");
+                b.HasKey(x => x.Id);
+                b.Ignore(x => x.Price);
+                b.Property(x => x.Email).HasColumnName("email");
+                b.HasComplexIndex(x => x.Email.Value, indexName: "ix_customer_email");
+            });
+    }
+
+    [TestMethod(DisplayName = "A converter's member resolves to the converted column")]
+    public void Converted_member_resolves_to_the_column()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<ConvertedMemberContext>());
+
+        var email = operations.OfType<CreateIndexOperation>().Single(o => o.Name == "ux_customer_email");
+        CollectionAssert.AreEqual(new[] { "email" }, email.Columns);
+
+        var amount = operations.OfType<CreateIndexOperation>().Single(o => o.Name == "ix_customer_amount");
+        CollectionAssert.AreEqual(new[] { "price" }, amount.Columns);
+    }
+
+    [TestMethod(DisplayName = "Typed expression indexes and exclusion elements unwrap it as well")]
+    public void Templates_and_exclusion_elements_unwrap()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<ConvertedMemberContext>());
+
+        StringAssert.Contains(MigrationHarness.NpgsqlSql(operations), "CREATE INDEX ix_customer_email_lower ON customers ((lower(\"email\")));");
+
+        var exclusion = operations.OfType<SqlOperation>().Single(o => o.Sql.Contains("\"ex_customer_email_period\" EXCLUDE"));
+        StringAssert.Contains(exclusion.Sql, "(\"email\" WITH =, \"Period\" WITH &&)");
+    }
+
+    [TestMethod(DisplayName = "A member of another type than the converter's provider type does not resolve")]
+    public void Mismatched_member_throws()
+    {
+        var target = MigrationHarness.NpgsqlModel<MismatchedMemberContext>();
+
+        var exception = Assert.ThrowsExactly<InvalidOperationException>(() => MigrationHarness.NpgsqlDiff(null, target));
+
+        StringAssert.Contains(exception.Message, "Price.Currency");
+    }
+
+    [TestMethod(DisplayName = "A member of a property without a converter does not resolve")]
+    public void Unconverted_member_throws()
+    {
+        var target = MigrationHarness.NpgsqlModel<UnconvertedMemberContext>();
+
+        var exception = Assert.ThrowsExactly<InvalidOperationException>(() => MigrationHarness.NpgsqlDiff(null, target));
+
+        StringAssert.Contains(exception.Message, "CreatedAt.Year");
+    }
+
+    [TestMethod(DisplayName = "A converter configured through ConfigureConventions counts too")]
+    public void Pre_convention_converter_is_seen()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<PreConventionContext>());
+
+        var email = operations.OfType<CreateIndexOperation>().Single(o => o.Name == "ix_customer_email");
+        CollectionAssert.AreEqual(new[] { "email" }, email.Columns);
+    }
+}
diff --git a/test/EFCore.ComplexIndexes.Tests/DocumentationApiTests.cs b/test/EFCore.ComplexIndexes.Tests/DocumentationApiTests.cs
index 7fa5ba4..e1afcba 100644
--- a/test/EFCore.ComplexIndexes.Tests/DocumentationApiTests.cs
+++ b/test/EFCore.ComplexIndexes.Tests/DocumentationApiTests.cs
@@ -52,7 +52,7 @@ public class DocumentationApiTests
         // EF Core
         "ComplexProperty", "ComplexCollection", "Property", "HasColumnName", "HasKey", "ToJson", "Entity",
         "MigrationsAssembly", "UseInternalServiceProvider",
-        "EnsureCreated", "GenerateCreateScript", "Migrate",
+        "EnsureCreated", "GenerateCreateScript", "Migrate", "GetEntityTypes", "HasConversion",
         // Npgsql
         "UseNpgsql", "AddEntityFrameworkNpgsql",
         // SQL Server
@@ -60,7 +60,7 @@ public class DocumentationApiTests
         // Dependency injection
         "ServiceCollection", "BuildServiceProvider", "AddDbContext",
         // BCL
-        "ToLower", "Trim"
+        "ToLower", "Trim", "Where", "SelectMany", "ToList"
     };
 
     [TestMethod(DisplayName = "Every API the documentation names exists")]
diff --git a/test/EFCore.ComplexIndexes.Tests/FilterPlaceholderTests.cs b/test/EFCore.ComplexIndexes.Tests/FilterPlaceholderTests.cs
new file mode 100644
index 0000000..71117cf
--- /dev/null
+++ b/test/EFCore.ComplexIndexes.Tests/FilterPlaceholderTests.cs
@@ -0,0 +1,177 @@
+using EFCore.ComplexIndexes.PostgreSQL;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Migrations.Operations;
+using NpgsqlTypes;
+
+namespace EFCore.ComplexIndexes.Tests;
+
+/// <summary>
+/// Filters were spliced into the DDL verbatim while expression parts already resolved
+/// <c>{Property.Path}</c> placeholders, so a filter had to repeat the column name a
+/// <c>HasColumnName</c> elsewhere decides — kept in sync by discipline, not by the package. Now a
+/// filter resolves the same placeholders, at design time: the resolved text rides on the operation
+/// and renders through the stock generator, so no runtime wiring is involved, and source and target
+/// compare on it, so nothing churns.
+/// </summary>
+[TestClass]
+public class FilterPlaceholderTests
+{
+    private class Address
+    {
+        public string City { get; set; } = "";
+    }
+
+    private class Method
+    {
+        public string Type   { get; set; } = "";
+        public string Issuer { get; set; } = "";
+    }
+
+    private class Account
+    {
+        public Guid                  Id        { get; set; }
+        public string                Email     { get; set; } = "";
+        public DateTime?             RevokedAt { get; set; }
+        public Address               Address   { get; set; } = new();
+        public Method                Method    { get; set; } = new();
+        public NpgsqlRange<DateOnly> Period    { get; set; }
+    }
+
+    private class PlaceholderContext(DbContextOptions<PlaceholderContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Account>(b =>
+            {
+                b.ToTable("accounts");
+                b.HasKey(x => x.Id);
+                b.Property(x => x.RevokedAt).HasColumnName("revoked_at");
+                b.Property(x => x.Email).HasColumnName("email");
+                b.ComplexProperty(x => x.Address, c => c.Property(a => a.City)
+                                                        .HasComplexIndex(filter: "{RevokedAt} IS NULL", indexName: "ix_city_active"));
+                b.ComplexProperty(x => x.Method, c => c.ToJson("method"));
+                b.HasComplexIndex(x => x.Email, isUnique: true, filter: "{RevokedAt} IS NULL", indexName: "ux_email_active");
+                b.HasComplexCompositeIndex(x => new { x.Email, x.RevokedAt },
+                                           filter:    "{Method.Type} = 'federated' AND {Method} IS NOT NULL",
+                                           indexName: "ix_federated");
+                b.HasComplexIndex(x => x.RevokedAt,
+                                  filter:    "tags @> '{urgent}' AND '{Email}' <> '' AND doc @> '{\"a\": 1}' AND grid = '{{1,2},{3,4}}' AND {Email} <> ''",
+                                  indexName: "ix_literals");
+                b.HasExclusionConstraint(x => x.Email, x => x.Period, filter: "{RevokedAt} IS NULL", name: "ex_email_active");
+            });
+    }
+
+    private class UnknownPlaceholderContext(DbContextOptions<UnknownPlaceholderContext> 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.Address);
+                b.ComplexProperty(x => x.Method);
+                b.HasComplexIndex(x => x.Email, filter: "{Revoked} IS NULL", indexName: "ix_typo");
+            });
+    }
+
+    // No JSON, no exclusion constraint: diffable by every provider.
+    private class PortableContext(DbContextOptions<PortableContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Account>(b =>
+            {
+                b.ToTable("accounts");
+                b.HasKey(x => x.Id);
+                b.Ignore(x => x.Period);
+                b.Property(x => x.RevokedAt).HasColumnName("revoked_at");
+                b.ComplexProperty(x => x.Address);
+                b.ComplexProperty(x => x.Method);
+                b.HasComplexIndex(x => x.Email, isUnique: true, filter: "{RevokedAt} IS NULL", indexName: "ux_email_active");
+            });
+    }
+
+    private static string FilterOf(IEnumerable<MigrationOperation> operations, string index)
+        => operations.OfType<CreateIndexOperation>().Single(o => o.Name == index).Filter!;
+
+    [TestMethod(DisplayName = "Column placeholders resolve to the mapped column, on property-level and entity-level indexes")]
+    public void Column_placeholders_resolve()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<PlaceholderContext>());
+
+        Assert.AreEqual("\"revoked_at\" IS NULL", FilterOf(operations, "ux_email_active"));
+        Assert.AreEqual("\"revoked_at\" IS NULL", FilterOf(operations, "ix_city_active"));
+    }
+
+    [TestMethod(DisplayName = "JSON members resolve to extractions, the document to its container column")]
+    public void Json_placeholders_resolve()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<PlaceholderContext>());
+
+        Assert.AreEqual("(\"method\" ->> 'Type') = 'federated' AND \"method\" IS NOT NULL", FilterOf(operations, "ix_federated"));
+    }
+
+    [TestMethod(DisplayName = "Braces inside string literals and braces that are not a path stay verbatim")]
+    public void Literals_stay_verbatim()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<PlaceholderContext>());
+
+        Assert.AreEqual(
+            "tags @> '{urgent}' AND '{Email}' <> '' AND doc @> '{\"a\": 1}' AND grid = '{{1,2},{3,4}}' AND \"email\" <> ''",
+            FilterOf(operations, "ix_literals"));
+    }
+
+    [TestMethod(DisplayName = "A placeholder that names no property fails at migrations add")]
+    public void Unknown_placeholder_throws()
+    {
+        var target = MigrationHarness.NpgsqlModel<UnknownPlaceholderContext>();
+
+        var exception = Assert.ThrowsExactly<InvalidOperationException>(() => MigrationHarness.NpgsqlDiff(null, target));
+
+        StringAssert.Contains(exception.Message, "'Revoked'");
+        StringAssert.Contains(exception.Message, "filter");
+    }
+
+    [TestMethod(DisplayName = "Exclusion constraint filters resolve placeholders into the design-time DDL")]
+    public void Exclusion_filter_resolves()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<PlaceholderContext>());
+
+        var add = operations.OfType<SqlOperation>().Single(o => o.Sql.Contains("\"ex_email_active\" EXCLUDE"));
+        StringAssert.Contains(add.Sql, "WHERE (\"revoked_at\" IS NULL)");
+    }
+
+    [TestMethod(DisplayName = "The stock generator renders the resolved filter — no runtime wiring involved")]
+    public void Stock_generator_renders_resolved_filter()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<PortableContext>());
+
+        var sql = MigrationHarness.NpgsqlSql(operations, complexIndexWiring: false);
+
+        StringAssert.Contains(sql, "CREATE UNIQUE INDEX ux_email_active ON accounts (\"Email\") WHERE \"revoked_at\" IS NULL;");
+    }
+
+    [TestMethod(DisplayName = "SQL Server delimits resolved columns with brackets")]
+    public void SqlServer_quotes_with_brackets()
+    {
+        var operations = MigrationHarness.SqlServerDiff(null, MigrationHarness.SqlServerModel<PortableContext>());
+
+        Assert.AreEqual("[revoked_at] IS NULL", FilterOf(operations, "ux_email_active"));
+        StringAssert.Contains(MigrationHarness.SqlServerSql(operations), "WHERE [revoked_at] IS NULL");
+    }
+
+    [TestMethod(DisplayName = "A provider without a satellite resolves with ANSI quotes")]
+    public void Core_quotes_ansi()
+    {
+        var operations = MigrationHarness.CoreDiff(null, MigrationHarness.SqliteModel<PortableContext>());
+
+        Assert.AreEqual("\"revoked_at\" IS NULL", FilterOf(operations, "ux_email_active"));
+    }
+
+    [TestMethod(DisplayName = "A filter with placeholders does not churn between snapshot and model")]
+    public void Placeholder_filter_does_not_churn()
+    {
+        var source = MigrationHarness.NpgsqlModel<PlaceholderContext>();
+        var target = MigrationHarness.NpgsqlModel<PlaceholderContext>();
+
+        Assert.IsEmpty(MigrationHarness.NpgsqlDiff(source, target));
+    }
+}
diff --git a/test/EFCore.ComplexIndexes.Tests/IdentifierLengthTests.cs b/test/EFCore.ComplexIndexes.Tests/IdentifierLengthTests.cs
new file mode 100644
index 0000000..82e8407
--- /dev/null
+++ b/test/EFCore.ComplexIndexes.Tests/IdentifierLengthTests.cs
@@ -0,0 +1,217 @@
+using EFCore.ComplexIndexes.PostgreSQL;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Migrations.Operations;
+using NpgsqlTypes;
+
+namespace EFCore.ComplexIndexes.Tests;
+
+/// <summary>
+/// The names this package derives are never truncated, unlike EF's own default names. PostgreSQL
+/// cuts an identifier past 63 bytes down with a NOTICE and applies the migration cleanly, so the
+/// index exists under a name that neither the declaration nor a later constraint-violation error
+/// matches — a slice dispatching on the constraint name falls through in silence. The differ now
+/// rejects such a name at <c>migrations add</c>, measured the way the provider measures it.
+/// </summary>
+[TestClass]
+public class IdentifierLengthTests
+{
+    private static readonly string SixtyThree = new('x', 63);
+    private static readonly string SixtyFour  = new('x', 64);
+
+    // 32 characters, 64 UTF-8 bytes: past PostgreSQL's limit, well inside SQL Server's.
+    private static readonly string Umlauts = new('ä', 32);
+
+    private class EmailAddress
+    {
+        public string Value { get; set; } = "";
+    }
+
+    private class Person
+    {
+        public Guid         Id    { get; set; }
+        public string       Name  { get; set; } = "";
+        public EmailAddress Email { get; set; } = new();
+    }
+
+    private class Booking
+    {
+        public Guid                  Id     { get; set; }
+        public Guid                  RoomId { get; set; }
+        public NpgsqlRange<DateOnly> Period { get; set; }
+    }
+
+    private class NamedIndexContext(DbContextOptions options, string indexName) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Person>(b =>
+            {
+                b.ToTable("people");
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Email);
+                b.HasComplexIndex(x => x.Email.Value, indexName: indexName);
+            });
+    }
+
+    private class ExactLimitContext(DbContextOptions<ExactLimitContext> options)   : NamedIndexContext(options, SixtyThree);
+    private class PastLimitContext(DbContextOptions<PastLimitContext> options)     : NamedIndexContext(options, SixtyFour);
+    private class UmlautContext(DbContextOptions<UmlautContext> options)           : NamedIndexContext(options, Umlauts);
+    private class SqlServerLimitContext(DbContextOptions<SqlServerLimitContext> options) : NamedIndexContext(options, new string('x', 128));
+    private class SqlServerPastContext(DbContextOptions<SqlServerPastContext> options)   : NamedIndexContext(options, new string('x', 129));
+    private class SqliteContext(DbContextOptions<SqliteContext> options)           : NamedIndexContext(options, new string('x', 200));
+
+    private class UnnamedContext(DbContextOptions<UnnamedContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Person>(b =>
+            {
+                // IX_ + 60 + _Email_Value: the default name is what runs past the limit.
+                b.ToTable(new string('t', 60));
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Email);
+                b.HasComplexIndex(x => x.Email.Value);
+            });
+    }
+
+    private class PropertyLevelContext(DbContextOptions<PropertyLevelContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Person>(b =>
+            {
+                b.ToTable("people");
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Email, c => c.Property(e => e.Value).HasComplexIndex(indexName: SixtyFour));
+            });
+    }
+
+    private class ExclusionContext(DbContextOptions<ExclusionContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Booking>(b =>
+            {
+                b.ToTable("bookings");
+                b.HasKey(x => x.Id);
+                b.HasExclusionConstraint(x => x.RoomId, x => x.Period, name: SixtyFour);
+            });
+    }
+
+    private class TemporalContext(DbContextOptions<TemporalContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Booking>(b =>
+            {
+                b.ToTable("bookings");
+                b.HasKey(x => x.Id);
+                b.HasTemporalConstraint(x => x.RoomId, x => x.Period, name: SixtyFour);
+            });
+    }
+
+    [TestMethod(DisplayName = "An explicit index name past PostgreSQL's 63 bytes is rejected at migrations add")]
+    public void Npgsql_rejects_a_name_past_the_limit()
+    {
+        var target = MigrationHarness.NpgsqlModel<PastLimitContext>();
+
+        var exception = Assert.ThrowsExactly<InvalidOperationException>(() => MigrationHarness.NpgsqlDiff(null, target));
+
+        StringAssert.Contains(exception.Message, SixtyFour);
+        StringAssert.Contains(exception.Message, "64 bytes");
+        StringAssert.Contains(exception.Message, "at most 63");
+        StringAssert.Contains(exception.Message, "indexName");
+    }
+
+    [TestMethod(DisplayName = "A name of exactly 63 bytes passes")]
+    public void Npgsql_accepts_a_name_at_the_limit()
+    {
+        var target = MigrationHarness.NpgsqlModel<ExactLimitContext>();
+
+        var creates = MigrationHarness.NpgsqlDiff(null, target).OfType<CreateIndexOperation>().ToList();
+
+        Assert.HasCount(1, creates);
+        Assert.AreEqual(SixtyThree, creates[0].Name);
+    }
+
+    [TestMethod(DisplayName = "PostgreSQL measures bytes: 32 umlauts are 64 bytes")]
+    public void Npgsql_measures_utf8_bytes()
+    {
+        var target = MigrationHarness.NpgsqlModel<UmlautContext>();
+
+        var exception = Assert.ThrowsExactly<InvalidOperationException>(() => MigrationHarness.NpgsqlDiff(null, target));
+
+        StringAssert.Contains(exception.Message, "64 bytes");
+    }
+
+    [TestMethod(DisplayName = "SQL Server measures characters: 32 umlauts pass, 129 characters do not")]
+    public void SqlServer_measures_characters()
+    {
+        var umlauts = MigrationHarness.SqlServerModel<UmlautContext>();
+        Assert.HasCount(1, MigrationHarness.SqlServerDiff(null, umlauts).OfType<CreateIndexOperation>().ToList());
+
+        var atLimit = MigrationHarness.SqlServerModel<SqlServerLimitContext>();
+        Assert.HasCount(1, MigrationHarness.SqlServerDiff(null, atLimit).OfType<CreateIndexOperation>().ToList());
+
+        var pastLimit = MigrationHarness.SqlServerModel<SqlServerPastContext>();
+        var exception = Assert.ThrowsExactly<InvalidOperationException>(() => MigrationHarness.SqlServerDiff(null, pastLimit));
+
+        StringAssert.Contains(exception.Message, "129 characters");
+        StringAssert.Contains(exception.Message, "at most 128");
+    }
+
+    [TestMethod(DisplayName = "A provider without a limit accepts any length")]
+    public void Core_without_a_limit_accepts_any_length()
+    {
+        var target = MigrationHarness.SqliteModel<SqliteContext>();
+
+        Assert.HasCount(1, MigrationHarness.CoreDiff(null, target).OfType<CreateIndexOperation>().ToList());
+    }
+
+    [TestMethod(DisplayName = "A default name that runs past the limit is rejected too")]
+    public void Default_name_past_the_limit_is_rejected()
+    {
+        var target = MigrationHarness.NpgsqlModel<UnnamedContext>();
+
+        var exception = Assert.ThrowsExactly<InvalidOperationException>(() => MigrationHarness.NpgsqlDiff(null, target));
+
+        StringAssert.Contains(exception.Message, "IX_" + new string('t', 60) + "_Email_Value");
+    }
+
+    [TestMethod(DisplayName = "Property-level declarations are checked as well")]
+    public void Property_level_name_is_checked()
+    {
+        var target = MigrationHarness.NpgsqlModel<PropertyLevelContext>();
+
+        Assert.ThrowsExactly<InvalidOperationException>(() => MigrationHarness.NpgsqlDiff(null, target));
+    }
+
+    [TestMethod(DisplayName = "An exclusion constraint name past the limit is rejected")]
+    public void Exclusion_constraint_name_is_checked()
+    {
+        var target = MigrationHarness.NpgsqlModel<ExclusionContext>();
+
+        var exception = Assert.ThrowsExactly<InvalidOperationException>(() => MigrationHarness.NpgsqlDiff(null, target));
+
+        StringAssert.Contains(exception.Message, "exclusion constraint");
+        StringAssert.Contains(exception.Message, "bookings");
+    }
+
+    [TestMethod(DisplayName = "A temporal constraint name past the limit is rejected")]
+    public void Temporal_constraint_name_is_checked()
+    {
+        var target = MigrationHarness.NpgsqlModel<TemporalContext>();
+
+        var exception = Assert.ThrowsExactly<InvalidOperationException>(() => MigrationHarness.NpgsqlDiff(null, target));
+
+        StringAssert.Contains(exception.Message, "temporal constraint");
+    }
+
+    // Guards against a future over-correction: the check must not make a snapshot undiffable.
+    [TestMethod(DisplayName = "A source model carrying such a name stays diffable")]
+    public void Source_model_is_not_validated()
+    {
+        var source = MigrationHarness.NpgsqlModel<PastLimitContext>();
+        var target = MigrationHarness.NpgsqlModel<ExactLimitContext>();
+
+        var operations = MigrationHarness.NpgsqlDiff(source, target);
+
+        // Name-only change → a rename from the over-long name to the fixed one.
+        Assert.IsTrue(operations.OfType<RenameIndexOperation>().Any(o => o.Name == SixtyFour && o.NewName == SixtyThree));
+    }
+}
diff --git a/test/EFCore.ComplexIndexes.Tests/MutableApiTests.cs b/test/EFCore.ComplexIndexes.Tests/MutableApiTests.cs
new file mode 100644
index 0000000..5035cdd
--- /dev/null
+++ b/test/EFCore.ComplexIndexes.Tests/MutableApiTests.cs
@@ -0,0 +1,168 @@
+using EFCore.ComplexIndexes.PostgreSQL;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Migrations.Operations;
+using NpgsqlTypes;
+
+namespace EFCore.ComplexIndexes.Tests;
+
+/// <summary>
+/// A soft-delete helper that installs the query filter automatically had no way to install the
+/// matching index filter, so every unique index and exclusion constraint on a withdrawable
+/// aggregate repeated it by hand. <c>AddComplexIndexFilter</c> and
+/// <c>AddExclusionConstraintFilter</c> AND a predicate onto what is declared, idempotently, on the
+/// mutable model; <c>AddComplexIndex</c> adds a declaration with the fluent API's identity rules.
+/// </summary>
+[TestClass]
+public class MutableApiTests
+{
+    private class EmailAddress
+    {
+        public string Value { get; set; } = "";
+    }
+
+    private class Grant
+    {
+        public Guid                  Id        { get; set; }
+        public Guid                  GranteeId { get; set; }
+        public string                Role      { get; set; } = "";
+        public EmailAddress          Email     { get; set; } = new();
+        public DateTime?             RevokedAt { get; set; }
+        public DateTime?             DeletedAt { get; set; }
+        public NpgsqlRange<DateOnly> Period    { get; set; }
+    }
+
+    // The helper's shape: configurations declare, then one call at the end installs the obligation.
+    private class AmendingContext(DbContextOptions<AmendingContext> options) : DbContext(options)
+    {
+        public int Amended { get; private set; }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Grant>(b =>
+            {
+                b.ToTable("grants");
+                b.HasKey(x => x.Id);
+                b.Property(x => x.RevokedAt).HasColumnName("revoked_at");
+                b.Property(x => x.DeletedAt).HasColumnName("deleted_at");
+                b.ComplexProperty(x => x.Email, c => c.Property(e => e.Value).HasComplexIndex(isUnique: true, indexName: "ux_grant_email"));
+                b.HasComplexIndex(x => x.Role, isUnique: true, filter: "{DeletedAt} IS NULL", indexName: "ux_grant_role");
+                b.HasComplexIndex(x => x.GranteeId, indexName: "ix_grant_grantee");
+                b.HasExclusionConstraint(x => x.GranteeId, x => x.Period, name: "ex_grant_period");
+                b.HasExclusionConstraint(x => x.Role, x => x.Period, filter: "{DeletedAt} IS NULL", name: "ex_grant_role_period");
+            });
+
+            var grant = modelBuilder.Model.FindEntityType(typeof(Grant))!;
+            Amended += grant.AddComplexIndexFilter("{RevokedAt} IS NULL", ix => ix.IsUnique);
+            Amended += grant.AddExclusionConstraintFilter("{RevokedAt} IS NULL");
+
+            // Applying it again must change nothing.
+            Amended += grant.AddComplexIndexFilter("{RevokedAt} IS NULL", ix => ix.IsUnique);
+            Amended += grant.AddExclusionConstraintFilter("{RevokedAt} IS NULL");
+        }
+    }
+
+    private class AddingContext(DbContextOptions<AddingContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Grant>(b =>
+            {
+                b.ToTable("grants");
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Email);
+            });
+
+            var grant = modelBuilder.Model.FindEntityType(typeof(Grant))!;
+            grant.AddComplexIndex(new CompositeIndexDefinition { PropertyPaths = ["GranteeId", "Role"], IsUnique = false, IndexName = "ix_first" });
+            // Same parts, same (null) filter: replaces — with the fluent API's identity rule.
+            grant.AddComplexIndex(new CompositeIndexDefinition { PropertyPaths = ["GranteeId", "Role"], IsUnique = true, IndexName = "ux_grantee_role" });
+        }
+    }
+
+    private static string FilterOf(IEnumerable<MigrationOperation> operations, string index)
+        => operations.OfType<CreateIndexOperation>().Single(o => o.Name == index).Filter!;
+
+    [TestMethod(DisplayName = "The predicate is ANDed onto selected declarations, property-level and entity-level, once")]
+    public void Filters_are_amended_idempotently()
+    {
+        using var context = new AmendingContext(new DbContextOptionsBuilder<AmendingContext>().UseNpgsql(MigrationHarness.NpgsqlConnection).Options);
+        var grant = context.Model.FindEntityType(typeof(Grant))!;
+
+        // Two unique indexes and two constraints on the first pass; nothing on the second.
+        Assert.AreEqual(4, context.Amended);
+
+        var byName = grant.GetComplexIndexes().ToDictionary(i => i.Name!);
+        Assert.AreEqual("{RevokedAt} IS NULL", byName["ux_grant_email"].Filter);
+        Assert.AreEqual("({DeletedAt} IS NULL) AND ({RevokedAt} IS NULL)", byName["ux_grant_role"].Filter);
+        Assert.IsNull(byName["ix_grant_grantee"].Filter, "the non-unique index was not selected");
+
+        var constraints = grant.GetExclusionConstraints().ToDictionary(c => c.Name!);
+        Assert.AreEqual("{RevokedAt} IS NULL", constraints["ex_grant_period"].Filter);
+        Assert.AreEqual("({DeletedAt} IS NULL) AND ({RevokedAt} IS NULL)", constraints["ex_grant_role_period"].Filter);
+    }
+
+    [TestMethod(DisplayName = "Amended filters reach the migration, placeholders resolved")]
+    public void Amended_filters_reach_the_migration()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<AmendingContext>());
+
+        Assert.AreEqual("\"revoked_at\" IS NULL", FilterOf(operations, "ux_grant_email"));
+        Assert.AreEqual("(\"deleted_at\" IS NULL) AND (\"revoked_at\" IS NULL)", FilterOf(operations, "ux_grant_role"));
+
+        var constraint = operations.OfType<SqlOperation>().Single(o => o.Sql.Contains("\"ex_grant_role_period\" EXCLUDE"));
+        StringAssert.Contains(constraint.Sql, "WHERE ((\"deleted_at\" IS NULL) AND (\"revoked_at\" IS NULL))");
+    }
+
+    [TestMethod(DisplayName = "Conjoin: null takes the predicate, a filter gets AND, an applied predicate is left alone")]
+    public void Conjoin_rules()
+    {
+        Assert.AreEqual("p", ComplexIndexStorage.Conjoin(null, "p"));
+        Assert.AreEqual("(a) AND (p)", ComplexIndexStorage.Conjoin("a", "p"));
+        Assert.IsNull(ComplexIndexStorage.Conjoin("p", "p"));
+        Assert.IsNull(ComplexIndexStorage.Conjoin("(a) AND (p)", "p"));
+        Assert.AreEqual("(NOT (p)) AND (p)", ComplexIndexStorage.Conjoin("NOT (p)", "p"), "a negation is not the predicate");
+    }
+
+    [TestMethod(DisplayName = "AddComplexIndex applies the fluent API's identity rule and reaches the migration")]
+    public void Add_complex_index_on_the_mutable_type()
+    {
+        var target     = MigrationHarness.NpgsqlModel<AddingContext>();
+        var operations = MigrationHarness.NpgsqlDiff(null, target);
+
+        var indexes = target.Model.FindEntityType(typeof(Grant))!.GetComplexIndexes();
+        Assert.HasCount(1, indexes);
+        Assert.AreEqual("ux_grantee_role", indexes[0].Name);
+
+        var create = operations.OfType<CreateIndexOperation>().Single();
+        Assert.AreEqual("ux_grantee_role", create.Name);
+        Assert.IsTrue(create.IsUnique);
+        CollectionAssert.AreEqual(new[] { "GranteeId", "Role" }, create.Columns);
+    }
+
+    [TestMethod(DisplayName = "A reused explicit name is rejected at the call, as the fluent API does")]
+    public void Reused_name_is_rejected()
+    {
+        using var context = new CollidingContext(new DbContextOptionsBuilder<CollidingContext>().UseNpgsql(MigrationHarness.NpgsqlConnection).Options);
+
+        var exception = Assert.ThrowsExactly<ArgumentException>(() => _ = context.Model);
+
+        StringAssert.Contains(exception.Message, "ix_dup");
+    }
+
+    private class CollidingContext(DbContextOptions<CollidingContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Grant>(b =>
+            {
+                b.ToTable("grants");
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Email);
+            });
+
+            var grant = modelBuilder.Model.FindEntityType(typeof(Grant))!;
+            grant.AddComplexIndex(new CompositeIndexDefinition { PropertyPaths = ["GranteeId"], IndexName = "ix_dup" });
+            grant.AddComplexIndex(new CompositeIndexDefinition { PropertyPaths = ["Role"],      IndexName = "ix_dup" });
+        }
+    }
+}
diff --git a/test/EFCore.ComplexIndexes.Tests/NpgsqlTemporalForeignKeyDifferTests.cs b/test/EFCore.ComplexIndexes.Tests/NpgsqlTemporalForeignKeyDifferTests.cs
index 8ad8f17..032ee83 100644
--- a/test/EFCore.ComplexIndexes.Tests/NpgsqlTemporalForeignKeyDifferTests.cs
+++ b/test/EFCore.ComplexIndexes.Tests/NpgsqlTemporalForeignKeyDifferTests.cs
@@ -16,7 +16,7 @@ namespace EFCore.ComplexIndexes.Tests;
 [TestClass]
 public class NpgsqlTemporalForeignKeyDifferTests
 {
-    private const string DefaultName = "FK_subscription_addons_subscriptions_subscription_id_active_during";
+    private const string DefaultName = "FK_addons_subscriptions_subscription_id_active_during";
 
     // ── Helpers ──
 
@@ -63,7 +63,7 @@ private static void MapSubscription(EntityTypeBuilder<Subscription> b)
 
     private static void MapAddOn(EntityTypeBuilder<SubscriptionAddOn> b)
     {
-        b.ToTable("subscription_addons");
+        b.ToTable("addons");
         b.HasKey(x => x.Id);
         b.Property(x => x.Id).HasColumnName("id");
         b.Property(x => x.SubscriptionId).HasColumnName("subscription_id");
@@ -316,7 +316,7 @@ private class BadDependentPeriodAddOn
 
     private static void MapBadDependentPeriodAddOn(EntityTypeBuilder<BadDependentPeriodAddOn> b)
     {
-        b.ToTable("subscription_addons");
+        b.ToTable("addons");
         b.HasKey(x => x.Id);
         b.Property(x => x.SubscriptionId).HasColumnName("subscription_id");
         b.Property(x => x.ActiveDuring).HasColumnName("active_during");
@@ -393,7 +393,7 @@ public void Temporal_foreign_key_emits_add_foreign_key()
 
         var sql = Assert.ContainsSingle(ForeignKeySql(operations));
         Assert.AreEqual(
-            $"ALTER TABLE \"subscription_addons\" ADD CONSTRAINT \"{DefaultName}\" " +
+            $"ALTER TABLE \"addons\" ADD CONSTRAINT \"{DefaultName}\" " +
             "FOREIGN KEY (\"subscription_id\", PERIOD \"active_during\") " +
             "REFERENCES \"subscriptions\" (\"subscription_id\", PERIOD \"valid_during\");",
             sql);
@@ -434,7 +434,7 @@ public void Named_composite_temporal_foreign_key()
 
         var sql = Assert.ContainsSingle(ForeignKeySql(operations));
         Assert.AreEqual(
-            "ALTER TABLE \"subscription_addons\" ADD CONSTRAINT \"fk_addons_subscriptions_temporal\" " +
+            "ALTER TABLE \"addons\" ADD CONSTRAINT \"fk_addons_subscriptions_temporal\" " +
             "FOREIGN KEY (\"tenant_id\", \"subscription_id\", PERIOD \"active_during\") " +
             "REFERENCES \"subscriptions\" (\"tenant_id\", \"subscription_id\", PERIOD \"valid_during\");",
             sql);
@@ -459,7 +459,7 @@ public void Removing_temporal_foreign_key_drops_it()
 
         var drop = Assert.ContainsSingle(operations.OfType<DropForeignKeyOperation>());
         Assert.AreEqual(DefaultName,           drop.Name);
-        Assert.AreEqual("subscription_addons", drop.Table);
+        Assert.AreEqual("addons", drop.Table);
         Assert.IsEmpty(ForeignKeySql(operations));
     }
 
@@ -492,7 +492,7 @@ public void Dropping_dependent_table_skips_explicit_foreign_key_drop()
             target: BuildRelationalModel<PrincipalOnlyNoDependentTableContext>());
 
         Assert.IsEmpty(operations.OfType<DropForeignKeyOperation>());
-        Assert.IsTrue(operations.OfType<DropTableOperation>().Any(o => o.Name == "subscription_addons"));
+        Assert.IsTrue(operations.OfType<DropTableOperation>().Any(o => o.Name == "addons"));
     }
 
     [TestMethod(DisplayName = "Dropping the principal table drops temporal FK first")]
@@ -517,7 +517,7 @@ public void Dropping_dependent_period_column_drops_foreign_key_first()
             target: BuildRelationalModel<DependentPeriodDroppedContext>()).ToList();
 
         var dropForeignKey = operations.FindIndex(o => o is DropForeignKeyOperation);
-        var dropColumn = operations.FindIndex(o => o is DropColumnOperation { Name: "active_during", Table: "subscription_addons" });
+        var dropColumn = operations.FindIndex(o => o is DropColumnOperation { Name: "active_during", Table: "addons" });
 
         Assert.IsTrue(dropForeignKey >= 0);
         Assert.IsTrue(dropColumn     > dropForeignKey);
diff --git a/test/EFCore.ComplexIndexes.Tests/NpgsqlTypedFilterTests.cs b/test/EFCore.ComplexIndexes.Tests/NpgsqlTypedFilterTests.cs
new file mode 100644
index 0000000..1308342
--- /dev/null
+++ b/test/EFCore.ComplexIndexes.Tests/NpgsqlTypedFilterTests.cs
@@ -0,0 +1,171 @@
+using EFCore.ComplexIndexes.PostgreSQL;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Migrations.Operations;
+using NpgsqlTypes;
+
+namespace EFCore.ComplexIndexes.Tests;
+
+/// <summary>
+/// Ten filter strings in one application repeated the column names the model already knows. A
+/// typed predicate is translated at declaration into a filter template — the placeholders the
+/// differ resolves — so <c>x => x.RevokedAt == null</c> renders <c>"revoked_at" IS NULL</c> whatever
+/// <c>HasColumnName</c> decided. The subset is small and refuses at the declaration what it cannot
+/// translate faithfully: enums, whose storage the filter cannot see, and values without a portable
+/// SQL spelling.
+/// </summary>
+[TestClass]
+public class NpgsqlTypedFilterTests
+{
+    private enum Status { Active, Revoked }
+
+    private class Method
+    {
+        public string Type { get; set; } = "";
+    }
+
+    private class Grant
+    {
+        public Guid                  Id        { get; set; }
+        public Guid                  GranteeId { get; set; }
+        public string                Email     { get; set; } = "";
+        public string                Kind      { get; set; } = "";
+        public bool                  IsDeleted { get; set; }
+        public int?                  Count     { get; set; }
+        public DateTime?             RevokedAt { get; set; }
+        public DateTime              ValidTo   { get; set; }
+        public Status                Status    { get; set; }
+        public string[]              Tags      { get; set; } = [];
+        public Method                Method    { get; set; } = new();
+        public NpgsqlRange<DateOnly> Period    { get; set; }
+    }
+
+    private static readonly bool IncludeArchived = false;
+
+    private class TypedFilterContext(DbContextOptions<TypedFilterContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Grant>(b =>
+            {
+                b.ToTable("grants");
+                b.HasKey(x => x.Id);
+                b.Property(x => x.RevokedAt).HasColumnName("revoked_at");
+                b.Property(x => x.IsDeleted).HasColumnName("is_deleted");
+                b.ComplexProperty(x => x.Method, c => c.ToJson("method"));
+
+                b.HasComplexIndex(x => x.Email, x => x.RevokedAt == null, isUnique: true, indexName: "ux_email_active");
+                b.HasComplexIndex(x => x.Kind, x => x.RevokedAt != null && x.Kind == "federated", indexName: "ix_kind");
+                b.HasComplexIndex(x => x.Count, x => !x.IsDeleted || x.Count > 0, indexName: "ix_count");
+                b.HasComplexIndex(x => x.GranteeId, x => x.Email.ToLower() == "root" && x.Count <= 10 && x.Count >= 1 && x.Count < 5, indexName: "ix_operators");
+                b.HasComplexIndex(x => x.Email, x => x.Method.Type == "federated", indexName: "ix_json");
+                b.HasComplexIndex(x => x.Kind, x => x.IsDeleted == IncludeArchived, indexName: "ix_captured");
+                b.HasComplexCompositeIndex(x => new { x.GranteeId, x.Kind }, x => x.RevokedAt == null, indexName: "ix_composite");
+                b.HasExpressionIndex(x => x.Email.ToLower(), x => x.RevokedAt == null, indexName: "ix_email_lower_active");
+                b.HasComplexIndex(x => x.Email, ix => ix.HasFilter<Grant>(g => g.IsDeleted).HasName("ix_builder"));
+                b.HasExclusionConstraint(x => x.GranteeId, x => x.Period, x => x.RevokedAt == null, name: "ex_active");
+                b.HasExclusionConstraint(ex => ex.WithEquality(x => x.Kind).WithOverlaps(x => x.Period)
+                                                 .HasFilter(x => x.RevokedAt != null).HasName("ex_revoked"));
+            });
+    }
+
+    private static Dictionary<string, string?> Filters<TContext>() where TContext : DbContext
+        => MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<TContext>())
+                           .OfType<CreateIndexOperation>()
+                           .ToDictionary(o => o.Name, o => o.Filter);
+
+    [TestMethod(DisplayName = "Null checks, boolean logic and comparisons translate, resolved against the mapping")]
+    public void Predicates_translate()
+    {
+        var filters = Filters<TypedFilterContext>();
+
+        Assert.AreEqual("\"revoked_at\" IS NULL", filters["ux_email_active"]);
+        Assert.AreEqual("(\"revoked_at\" IS NOT NULL AND \"Kind\" = 'federated')", filters["ix_kind"]);
+        Assert.AreEqual("(NOT (\"is_deleted\") OR \"Count\" > 0)", filters["ix_count"]);
+        Assert.AreEqual("(((lower(\"Email\") = 'root' AND \"Count\" <= 10) AND \"Count\" >= 1) AND \"Count\" < 5)", filters["ix_operators"]);
+        Assert.AreEqual("(\"method\" ->> 'Type') = 'federated'", filters["ix_json"]);
+        Assert.AreEqual("\"is_deleted\" = FALSE", filters["ix_captured"]);
+        Assert.AreEqual("\"revoked_at\" IS NULL", filters["ix_composite"]);
+        Assert.AreEqual("\"is_deleted\"", filters["ix_builder"]);
+    }
+
+    [TestMethod(DisplayName = "Expression indexes and exclusion constraints take the same predicates")]
+    public void Expression_indexes_and_constraints_take_predicates()
+    {
+        var operations = MigrationHarness.NpgsqlDiff(null, MigrationHarness.NpgsqlModel<TypedFilterContext>());
+
+        StringAssert.Contains(MigrationHarness.NpgsqlSql(operations), "ix_email_lower_active ON grants ((lower(\"Email\"))) WHERE \"revoked_at\" IS NULL;");
+
+        var active = operations.OfType<SqlOperation>().Single(o => o.Sql.Contains("\"ex_active\" EXCLUDE"));
+        StringAssert.Contains(active.Sql, "WHERE (\"revoked_at\" IS NULL)");
+
+        var revoked = operations.OfType<SqlOperation>().Single(o => o.Sql.Contains("\"ex_revoked\" EXCLUDE"));
+        StringAssert.Contains(revoked.Sql, "WHERE (\"revoked_at\" IS NOT NULL)");
+    }
+
+    [TestMethod(DisplayName = "The declaration stores a template; the model does not churn")]
+    public void Stored_as_template_without_churn()
+    {
+        var model = MigrationHarness.NpgsqlModel<TypedFilterContext>();
+
+        Assert.AreEqual("{RevokedAt} IS NULL", model.Model.FindComplexIndex("ux_email_active")!.Filter);
+        Assert.IsEmpty(MigrationHarness.NpgsqlDiff(model, MigrationHarness.NpgsqlModel<TypedFilterContext>()));
+    }
+
+    [TestMethod(DisplayName = "An enum comparison is refused at the declaration")]
+    public void Enum_comparison_is_refused()
+    {
+        var exception = Assert.ThrowsExactly<NotSupportedException>(
+            () => new ComplexIndexBuilder().HasFilter<Grant>(g => g.Status == Status.Active));
+
+        StringAssert.Contains(exception.Message, "enum");
+    }
+
+    [TestMethod(DisplayName = "A value without a portable SQL spelling is refused at the declaration")]
+    public void Date_literal_is_refused()
+    {
+        var exception = Assert.ThrowsExactly<NotSupportedException>(
+            () => new ComplexIndexBuilder().HasFilter<Grant>(g => g.ValidTo > DateTime.UtcNow));
+
+        StringAssert.Contains(exception.Message, "DateTime");
+    }
+
+    [TestMethod(DisplayName = "An untranslatable construct is refused at the declaration, pointing at the string overload")]
+    public void Unsupported_construct_is_refused()
+    {
+        var exception = Assert.ThrowsExactly<NotSupportedException>(
+            () => new ComplexIndexBuilder().HasFilter<Grant>(g => g.Tags.Contains("urgent")));
+
+        StringAssert.Contains(exception.Message, "string filter overload");
+    }
+
+    [TestMethod(DisplayName = "The typed amend calls translate and delegate")]
+    public void Typed_amend_calls()
+    {
+        using var context = new AmendingContext(new DbContextOptionsBuilder<AmendingContext>().UseNpgsql(MigrationHarness.NpgsqlConnection).Options);
+        var grant = context.Model.FindEntityType(typeof(Grant))!;
+
+        Assert.AreEqual(2, context.Amended);
+        Assert.AreEqual("{RevokedAt} IS NULL", grant.GetComplexIndexes().Single(i => i.Name == "ux_email").Filter);
+        Assert.AreEqual("{RevokedAt} IS NULL", grant.GetExclusionConstraints().Single().Filter);
+    }
+
+    private class AmendingContext(DbContextOptions<AmendingContext> options) : DbContext(options)
+    {
+        public int Amended { get; private set; }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Grant>(b =>
+            {
+                b.ToTable("grants");
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Method);
+                b.HasComplexIndex(x => x.Email, isUnique: true, indexName: "ux_email");
+                b.HasExclusionConstraint(x => x.GranteeId, x => x.Period, name: "ex_period");
+            });
+
+            var grant = modelBuilder.Model.FindEntityType(typeof(Grant))!;
+            Amended += grant.AddComplexIndexFilter<Grant>(g => g.RevokedAt == null);
+            Amended += grant.AddExclusionConstraintFilter<Grant>(g => g.RevokedAt == null);
+        }
+    }
+}
diff --git a/test/EFCore.ComplexIndexes.Tests/ReadModelTests.cs b/test/EFCore.ComplexIndexes.Tests/ReadModelTests.cs
new file mode 100644
index 0000000..365ee9a
--- /dev/null
+++ b/test/EFCore.ComplexIndexes.Tests/ReadModelTests.cs
@@ -0,0 +1,233 @@
+using EFCore.ComplexIndexes.PostgreSQL;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
+using NpgsqlTypes;
+
+namespace EFCore.ComplexIndexes.Tests;
+
+/// <summary>
+/// An application that owes every unique index and exclusion constraint on a withdrawable
+/// aggregate a live-rows filter had no way to check that it paid: the declarations were write-only
+/// annotations, half of them behind internal types. <c>GetComplexIndexes</c> and
+/// <c>GetExclusionConstraints</c> read them back — from the finalized model or from the mutable one
+/// in <c>OnModelCreating</c> — through the same code the differ uses.
+/// </summary>
+[TestClass]
+public class ReadModelTests
+{
+    private class EmailAddress
+    {
+        public string Value { get; set; } = "";
+    }
+
+    private class Grant
+    {
+        public Guid                  Id        { get; set; }
+        public Guid                  GranteeId { get; set; }
+        public string                Role      { get; set; } = "";
+        public EmailAddress          Email     { get; set; } = new();
+        public DateTime?             RevokedAt { get; set; }
+        public NpgsqlRange<DateOnly> Period    { get; set; }
+    }
+
+    private class GrantContext(DbContextOptions<GrantContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Grant>(b =>
+            {
+                b.ToTable("grants");
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Email, c => c.Property(e => e.Value)
+                                                      .HasComplexIndex(ix => ix.IsUnique().HasFilter("revoked_at IS NULL").HasName("ux_grant_email")));
+                b.HasComplexIndex(x => x.Role, filter: "revoked_at IS NULL", indexName: "ix_grant_role_active");
+                b.HasComplexCompositeIndex(x => new { x.GranteeId, x.Role },
+                                           ix => ix.IsUnique().HasName("ux_grant_grantee_role").UseGin().HasStorageParameter("fillfactor", 70));
+                b.HasExpressionIndex(x => x.Email.Value.ToLower(), indexName: "ix_grant_email_lower");
+                b.HasExclusionConstraint(x => x.GranteeId, x => x.Period, filter: "revoked_at IS NULL", name: "ex_grant_active");
+                b.HasExclusionConstraint(ex => ex.WithEquality(x => x.GranteeId)
+                                                 .WithOverlaps(x => x.Period)
+                                                 .HasFilter("revoked_at IS NOT NULL")
+                                                 .HasName("ex_grant_revoked")
+                                                 .IsDeferrable(initiallyDeferred: true));
+            });
+    }
+
+    private class DefaultNamesContext(DbContextOptions<DefaultNamesContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+            modelBuilder.Entity<Grant>(b =>
+            {
+                b.ToTable("grants");
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Email);
+                b.HasComplexIndex(x => x.Role);
+                b.HasExclusionConstraint(x => x.GranteeId, x => x.Period);
+            });
+    }
+
+    // The guard's shape: read the declarations while the model is still being built.
+    private class GuardingContext(DbContextOptions<GuardingContext> options) : DbContext(options)
+    {
+        public List<string> Unfiltered { get; } = [];
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Grant>(b =>
+            {
+                b.ToTable("grants");
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Email);
+                b.HasComplexIndex(x => x.Role, isUnique: true, indexName: "ux_grant_role");                      // the obligation, forgotten
+                b.HasComplexIndex(x => x.GranteeId, isUnique: true, filter: "revoked_at IS NULL", indexName: "ux_grant_grantee");
+                b.HasExclusionConstraint(x => x.GranteeId, x => x.Period, name: "ex_grant_period");              // forgotten here too
+            });
+
+            foreach (var entityType in modelBuilder.Model.GetEntityTypes())
+            {
+                Unfiltered.AddRange(entityType.GetComplexIndexes()
+                                              .Where(index => index.IsUnique && index.Filter is null)
+                                              .Select(index => index.Name ?? "<default>"));
+                Unfiltered.AddRange(entityType.GetExclusionConstraints()
+                                              .Where(constraint => constraint.Filter is null)
+                                              .Select(constraint => constraint.Name ?? "<default>"));
+            }
+        }
+    }
+
+    private class Animal
+    {
+        public Guid         Id   { get; set; }
+        public EmailAddress Tag  { get; set; } = new();
+        public string       Name { get; set; } = "";
+    }
+
+    private class Cat : Animal
+    {
+        public int Lives { get; set; }
+    }
+
+    private class HierarchyContext(DbContextOptions<HierarchyContext> options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Animal>(b =>
+            {
+                b.ToTable("animals");
+                b.HasKey(x => x.Id);
+                b.ComplexProperty(x => x.Tag, c => c.Property(t => t.Value).HasComplexIndex(indexName: "ix_animal_tag"));
+            });
+            modelBuilder.Entity<Cat>(b => b.HasComplexIndex(x => x.Name, indexName: "ix_cat_name"));
+        }
+    }
+
+    private static IModel Model<TContext>() where TContext : DbContext
+        => MigrationHarness.NpgsqlModel<TContext>().Model;
+
+    [TestMethod(DisplayName = "Every declaration kind is reported: property-level, entity-level, composite, expression")]
+    public void Entity_type_reports_every_declaration_kind()
+    {
+        var grant   = Model<GrantContext>().FindEntityType(typeof(Grant))!;
+        var indexes = grant.GetComplexIndexes();
+
+        Assert.HasCount(4, indexes);
+        CollectionAssert.AreEqual(
+            new[] { "ux_grant_email", "ix_grant_role_active", "ux_grant_grantee_role", "ix_grant_email_lower" },
+            indexes.Select(i => i.Name).ToList());
+
+        var propertyLevel = indexes[0];
+        Assert.IsTrue(propertyLevel.IsPropertyLevel);
+        Assert.AreEqual("Value", propertyLevel.Property!.Name);
+        Assert.AreEqual("Email.Value", propertyLevel.Parts.Single().PropertyPath);
+        Assert.IsTrue(propertyLevel.IsUnique);
+        Assert.AreEqual("revoked_at IS NULL", propertyLevel.Filter);
+        Assert.AreSame(grant, propertyLevel.EntityType);
+
+        var single = indexes[1];
+        Assert.IsFalse(single.IsPropertyLevel);
+        Assert.AreEqual("Role", single.Parts.Single().PropertyPath);
+        Assert.IsFalse(single.IsUnique);
+
+        var composite = indexes[2];
+        CollectionAssert.AreEqual(new[] { "GranteeId", "Role" }, composite.Parts.Select(p => p.PropertyPath).ToList());
+        Assert.IsTrue(composite.IsUnique);
+        Assert.IsNull(composite.Filter);
+
+        Assert.IsTrue(indexes[3].Parts.Single().IsTemplate);
+    }
+
+    [TestMethod(DisplayName = "Provider options come back as plain values, not JSON elements")]
+    public void Provider_annotations_are_normalized()
+    {
+        var composite = Model<GrantContext>().FindComplexIndex("ux_grant_grantee_role")!;
+
+        Assert.AreEqual("gin", composite.ProviderAnnotations["Npgsql:IndexMethod"]);
+        Assert.AreEqual(70, composite.ProviderAnnotations["Npgsql:StorageParameter:fillfactor"]);
+    }
+
+    [TestMethod(DisplayName = "FindComplexIndex matches explicit names and carries the entity type")]
+    public void Find_by_explicit_name()
+    {
+        var model = Model<GrantContext>();
+
+        var found = model.FindComplexIndex("ux_grant_email");
+
+        Assert.IsNotNull(found);
+        Assert.AreEqual(typeof(Grant), found.EntityType.ClrType);
+        Assert.IsNull(model.FindComplexIndex("ix_nothing"));
+        Assert.HasCount(4, model.GetComplexIndexes());
+    }
+
+    [TestMethod(DisplayName = "A default-named declaration has no name and is not found by the name the differ will derive")]
+    public void Default_names_are_not_matched()
+    {
+        var model = Model<DefaultNamesContext>();
+
+        Assert.IsNull(model.GetComplexIndexes().Single().Name);
+        Assert.IsNull(model.FindComplexIndex("IX_grants_Role"));
+        Assert.IsNull(model.GetExclusionConstraints().Single().Name);
+        Assert.IsNull(model.FindExclusionConstraint("EX_grants_GranteeId_Period"));
+    }
+
+    [TestMethod(DisplayName = "Exclusion constraints are reported with method, filter, name and deferrability")]
+    public void Exclusion_constraints_are_reported()
+    {
+        var model       = Model<GrantContext>();
+        var constraints = model.FindEntityType(typeof(Grant))!.GetExclusionConstraints();
+
+        Assert.HasCount(2, constraints);
+
+        var active = constraints[0];
+        Assert.AreEqual("ex_grant_active", active.Name);
+        Assert.AreEqual("gist", active.Method);
+        Assert.AreEqual("revoked_at IS NULL", active.Filter);
+        Assert.IsFalse(active.Deferrable);
+        CollectionAssert.AreEqual(new[] { "GranteeId", "Period" }, active.Parts.Select(p => p.PropertyPath).ToList());
+        CollectionAssert.AreEqual(new[] { "=", "&&" }, active.Parts.Select(p => p.Operator).ToList());
+
+        var revoked = model.FindExclusionConstraint("ex_grant_revoked")!;
+        Assert.IsTrue(revoked.Deferrable);
+        Assert.IsTrue(revoked.InitiallyDeferred);
+        Assert.AreEqual(typeof(Grant), revoked.EntityType.ClrType);
+    }
+
+    [TestMethod(DisplayName = "Declarations can be read from the mutable model inside OnModelCreating")]
+    public void Reads_from_the_mutable_model()
+    {
+        using var context = new GuardingContext(new DbContextOptionsBuilder<GuardingContext>().UseNpgsql(MigrationHarness.NpgsqlConnection).Options);
+
+        _ = context.Model;
+
+        CollectionAssert.AreEquivalent(new[] { "ux_grant_role", "ex_grant_period" }, context.Unfiltered);
+    }
+
+    [TestMethod(DisplayName = "Inherited declarations are reported by the declaring type only, unless asked for")]
+    public void Inherited_declarations()
+    {
+        var model = Model<HierarchyContext>();
+        var cat   = model.FindEntityType(typeof(Cat))!;
+
+        Assert.AreEqual("ix_cat_name", cat.GetDeclaredComplexIndexes().Single().Name);
+        CollectionAssert.AreEqual(new[] { "ix_animal_tag", "ix_cat_name" }, cat.GetComplexIndexes().Select(i => i.Name).ToList());
+        Assert.HasCount(2, model.GetComplexIndexes());
+    }
+}