diff --git a/packages/bindx-ui/src/select/multi-select-field.tsx b/packages/bindx-ui/src/select/multi-select-field.tsx
index af54616..73a159e 100644
--- a/packages/bindx-ui/src/select/multi-select-field.tsx
+++ b/packages/bindx-ui/src/select/multi-select-field.tsx
@@ -41,8 +41,8 @@ import {
 	SelectPopoverContent,
 } from './ui.js'
 
-/** Extract the target entity type from a HasManyRef */
-type HasManyTarget<F> = F extends HasManyRef<infer TEntity> ? TEntity : object
+// `infer _S` (not `any`) is load-bearing — see relationTargetInference.test.ts.
+type HasManyTarget<F> = F extends HasManyRef<infer TEntity, infer _S> ? TEntity : object
 
 /** Scalar field keys of an entity (for filter/sorting) */
 type ScalarKeys<T> = { [K in keyof T]: T[K] extends (object | object[] | null) ? never : K }[keyof T] & string
diff --git a/packages/bindx-ui/src/select/select-field.tsx b/packages/bindx-ui/src/select/select-field.tsx
index 9b87906..68f532e 100644
--- a/packages/bindx-ui/src/select/select-field.tsx
+++ b/packages/bindx-ui/src/select/select-field.tsx
@@ -38,8 +38,8 @@ import {
 	SelectPopoverContent,
 } from './ui.js'
 
-/** Extract the target entity type from a HasOneRef */
-type RelationTarget<F> = F extends HasOneRef<infer TEntity, any> ? TEntity : object
+// `infer _S` (not `any`) is load-bearing — see relationTargetInference.test.ts.
+type RelationTarget<F> = F extends HasOneRef<infer TEntity, infer _S> ? TEntity : object
 
 /** Scalar field keys of an entity (for filter/sorting) */
 type ScalarKeys<T> = { [K in keyof T]: T[K] extends (object | object[] | null) ? never : K }[keyof T] & string
diff --git a/packages/bindx/src/handles/index.ts b/packages/bindx/src/handles/index.ts
index 22c6fd7..975156a 100644
--- a/packages/bindx/src/handles/index.ts
+++ b/packages/bindx/src/handles/index.ts
@@ -31,5 +31,8 @@ export {
 	// Type extraction helpers
 	type ExtractHasOneEntityName,
 	type ExtractHasManyEntityName,
+	type ExtractHasOneEntity,
+	type ExtractHasManyEntity,
+	type ExtractEntityRefEntity,
 	type ExtractRoleMap,
 } from './types.js'
diff --git a/packages/bindx/src/handles/types.ts b/packages/bindx/src/handles/types.ts
index 8259920..58ff3d2 100644
--- a/packages/bindx/src/handles/types.ts
+++ b/packages/bindx/src/handles/types.ts
@@ -251,6 +251,11 @@ export interface HasOneRefInterface<
 
 /**
  * HasOneRef = interface props + proxy field access returning Ref variants.
+ *
+ * Inference caveat: `T extends HasOneRef<infer E, any>` does NOT reliably
+ * infer `E` when `T`'s `TSelected` is a narrow subset of `TEntity` — the
+ * mapped-type half of the intersection poisons inference. Use
+ * `ExtractHasOneEntity<T>` (or `infer _S` instead of `any`) instead.
  */
 export type HasOneRef<
 	TEntity,
@@ -316,6 +321,10 @@ export interface EntityRefInterface<
 
 /**
  * EntityRef = interface props + proxy field access returning Ref variants.
+ *
+ * Inference caveat: `T extends EntityRef<infer E, any>` does NOT reliably
+ * infer `E` when `T`'s `TSelected` is a narrow subset of `TEntity`. Use
+ * `ExtractEntityRefEntity<T>` (or `infer _S` instead of `any`) instead.
  */
 export type EntityRef<
 	TEntity,
@@ -446,3 +455,16 @@ export type ExtractHasManyEntityName<T> =
 		: T extends HasManyRef<any, any, any, infer TEntityName, any>
 			? TEntityName
 			: never
+
+// Inference-safe target-entity extractors. Prefer these over hand-rolled
+// `T extends HasOneRef<infer E, any> ? E : ...` — see relationTargetInference.test.ts
+// for why putting `any` in the TSelected slot poisons inference for these aliases.
+
+export type ExtractHasOneEntity<T> =
+	T extends HasOneRefInterface<infer TEntity, any, any, any, any> ? TEntity : never
+
+export type ExtractHasManyEntity<T> =
+	T extends HasManyRef<infer TEntity, any, any, any, any> ? TEntity : never
+
+export type ExtractEntityRefEntity<T> =
+	T extends EntityRefInterface<infer TEntity, any, any, any, any> ? TEntity : never
diff --git a/packages/bindx/src/index.ts b/packages/bindx/src/index.ts
index 64112f7..8452075 100644
--- a/packages/bindx/src/index.ts
+++ b/packages/bindx/src/index.ts
@@ -70,6 +70,9 @@ export type {
 	// Type extraction helpers
 	ExtractHasOneEntityName,
 	ExtractHasManyEntityName,
+	ExtractHasOneEntity,
+	ExtractHasManyEntity,
+	ExtractEntityRefEntity,
 	ExtractRoleMap,
 } from './handles/index.js'
 
diff --git a/tests/unit/handles/relationTargetInference.test.ts b/tests/unit/handles/relationTargetInference.test.ts
new file mode 100644
index 0000000..b8d479d
--- /dev/null
+++ b/tests/unit/handles/relationTargetInference.test.ts
@@ -0,0 +1,117 @@
+/**
+ * Type-level coverage for extracting the target entity from
+ * EntityRef / HasOneRef / HasManyRef via `infer`.
+ *
+ * Background: `EntityRef<T,S,...>` and `HasOneRef<T,S,...>` are type aliases
+ * defined as `XxxInterface<T,S,...> & EntityFieldsRef<T,S,...>`. The mapped
+ * half of the intersection is hostile to inference: when the target's
+ * `TSelected` is a strict subset of `TEntity`, matching against a candidate
+ * with `any` in the `TSelected` slot fails structurally and poisons
+ * `infer TEntity`, silently falling through to the conditional's fallback.
+ *
+ * Two safe shapes:
+ *   1. `T extends HasOneRef<infer E, infer _S>` — let TS pick `_S` itself.
+ *   2. `ExtractHasOneEntity<T>` — routes through `HasOneRefInterface`, where
+ *      the bug doesn't apply.
+ */
+
+import { describe, test } from 'bun:test'
+import type {
+	HasOneRef,
+	HasManyRef,
+	EntityRef,
+	ExtractHasOneEntity,
+	ExtractHasManyEntity,
+	ExtractEntityRefEntity,
+} from '@contember/bindx'
+
+type Equal<X, Y> =
+	(<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false
+
+function assertTrue<T extends true>(): void {}
+function assertFalse<T extends false>(): void {}
+
+interface Family {
+	id: string
+	name: string
+	code: string
+	tariffs: { id: string; price: number }[]
+}
+
+interface Tariff {
+	id: string
+	name: string
+	price: number
+}
+
+type FamilyNarrow = { name: string }
+type TariffNarrow = { id: string; name: string }
+
+declare const oneFull: HasOneRef<Family, Family>
+declare const oneNarrow: HasOneRef<Family, FamilyNarrow>
+declare const manyFull: HasManyRef<Tariff, Tariff>
+declare const manyNarrow: HasManyRef<Tariff, TariffNarrow>
+declare const entityFull: EntityRef<Family, Family>
+declare const entityNarrow: EntityRef<Family, FamilyNarrow>
+
+describe('HasOneRef target inference', () => {
+	test('broken: <infer T, any> does not infer TEntity for narrow TSelected', () => {
+		type Extract<F> = F extends HasOneRef<infer T, any> ? T : object
+		assertTrue<Equal<Extract<typeof oneFull>, Family>>()
+		assertFalse<Equal<Extract<typeof oneNarrow>, Family>>()
+	})
+
+	test('safe: <infer T, infer _S> handles both wide and narrow TSelected', () => {
+		type Extract<F> = F extends HasOneRef<infer T, infer _S> ? T : object
+		assertTrue<Equal<Extract<typeof oneFull>, Family>>()
+		assertTrue<Equal<Extract<typeof oneNarrow>, Family>>()
+	})
+
+	test('safe: ExtractHasOneEntity helper handles both wide and narrow TSelected', () => {
+		assertTrue<Equal<ExtractHasOneEntity<typeof oneFull>, Family>>()
+		assertTrue<Equal<ExtractHasOneEntity<typeof oneNarrow>, Family>>()
+	})
+})
+
+describe('HasManyRef target inference', () => {
+	test('broken: <infer T> (one arg) does not infer TEntity for narrow TSelected', () => {
+		type Extract<F> = F extends HasManyRef<infer T> ? T : object
+		assertFalse<Equal<Extract<typeof manyNarrow>, Tariff>>()
+	})
+
+	test('safe: <infer T, any> works (HasManyRef has no mapped-type intersection)', () => {
+		type Extract<F> = F extends HasManyRef<infer T, any> ? T : object
+		assertTrue<Equal<Extract<typeof manyFull>, Tariff>>()
+		assertTrue<Equal<Extract<typeof manyNarrow>, Tariff>>()
+	})
+
+	test('safe: <infer T, infer _S> works', () => {
+		type Extract<F> = F extends HasManyRef<infer T, infer _S> ? T : object
+		assertTrue<Equal<Extract<typeof manyFull>, Tariff>>()
+		assertTrue<Equal<Extract<typeof manyNarrow>, Tariff>>()
+	})
+
+	test('safe: ExtractHasManyEntity helper works', () => {
+		assertTrue<Equal<ExtractHasManyEntity<typeof manyFull>, Tariff>>()
+		assertTrue<Equal<ExtractHasManyEntity<typeof manyNarrow>, Tariff>>()
+	})
+})
+
+describe('EntityRef target inference', () => {
+	test('broken: <infer T, any> does not infer TEntity for narrow TSelected', () => {
+		type Extract<F> = F extends EntityRef<infer T, any> ? T : object
+		assertTrue<Equal<Extract<typeof entityFull>, Family>>()
+		assertFalse<Equal<Extract<typeof entityNarrow>, Family>>()
+	})
+
+	test('safe: <infer T, infer _S> handles both wide and narrow TSelected', () => {
+		type Extract<F> = F extends EntityRef<infer T, infer _S> ? T : object
+		assertTrue<Equal<Extract<typeof entityFull>, Family>>()
+		assertTrue<Equal<Extract<typeof entityNarrow>, Family>>()
+	})
+
+	test('safe: ExtractEntityRefEntity helper handles both wide and narrow TSelected', () => {
+		assertTrue<Equal<ExtractEntityRefEntity<typeof entityFull>, Family>>()
+		assertTrue<Equal<ExtractEntityRefEntity<typeof entityNarrow>, Family>>()
+	})
+})