diff --git a/graph/test/java/expected/61-var-local-type.known-missing b/graph/test/java/expected/61-var-local-type.known-missing
new file mode 100644
index 000000000..996b5ec5e
--- /dev/null
+++ b/graph/test/java/expected/61-var-local-type.known-missing
@@ -0,0 +1,13 @@
+# Accepted gap, measured by the bytecode oracle in CI: a `var` local whose type comes from something
+# other than its initializer expression is left a declared unknown. Before #1401 each of these was a
+# wrong `external:var.<m>` edge; now the receiver is honestly untyped. Three shapes:
+#   - the element variable of an enhanced for loop (`for (var w : widgets)`): its type is the
+#     iterable's element type;
+#   - a try-with-resources variable (`try (var w = open())` where open() is not typed client-side);
+#   - `var` lambda parameters (`(var w) -> w.paint()`): the type comes from the target functional
+#     interface.
+# Follow-up: type `var` in these three shapes. It cannot rot: when one starts resolving, this line
+# reports NOW-FIXED and the case fails until it is removed.
+probe.VarLocals#fromEnhancedFor -> probe.Widget#paint()
+probe.VarLocals#fromResource -> probe.Widget#close()
+probe.VarLocals#lambdaParams -> probe.Widget#paint()
diff --git a/graph/test/java/expected/61-var-local-type.oracle b/graph/test/java/expected/61-var-local-type.oracle
new file mode 100644
index 000000000..b29608363
--- /dev/null
+++ b/graph/test/java/expected/61-var-local-type.oracle
@@ -0,0 +1,4 @@
+oracle=20 engine=17 agree=17 missing=3 (known 3, NEW 0) extra=0
+  known-missing  probe.VarLocals#fromEnhancedFor -> probe.Widget#paint()
+  known-missing  probe.VarLocals#fromResource -> probe.Widget#close()
+  known-missing  probe.VarLocals#lambdaParams -> probe.Widget#paint()
diff --git a/graph/test/java/expected/oracle-agreement.txt b/graph/test/java/expected/oracle-agreement.txt
index a204958ea..22a372c44 100644
--- a/graph/test/java/expected/oracle-agreement.txt
+++ b/graph/test/java/expected/oracle-agreement.txt
@@ -1,4 +1,4 @@
-cases compared 45   agreeing 45
+cases compared 46   agreeing 46
 CONSTRUCTOR-RULE disagreements: 0 cases, 0 rows
 OTHER disagreements: 0
 rows naming no method: 0
diff --git a/graph/test/typescript/cases/75-jsx-wrapper-guards/src/app.tsx b/graph/test/typescript/cases/75-jsx-wrapper-guards/src/app.tsx
new file mode 100644
index 000000000..9a7c373c2
--- /dev/null
+++ b/graph/test/typescript/cases/75-jsx-wrapper-guards/src/app.tsx
@@ -0,0 +1,73 @@
+import { dynamic, lazy, makeThing, memo, observer, useMemoLike, type Fc } from "./parts";
+import { Button } from "./ui/Button";
+
+export function factoryArgBody(): number {
+  return 3;
+}
+export function memoBody(): number {
+  return 4;
+}
+function ObservedImpl(): string {
+  return "observed";
+}
+
+// A loader that projects a NAMED export: the component is NamedHeavy, never Heavy.
+const LazyNamed = lazy(() => import("./heavy").then((m) => ({ default: m.NamedHeavy })));
+const DynNamed = dynamic(() => import("./heavy").then((m) => m.NamedHeavy));
+// …and the same projections written with a block body, where the returned value is a row.
+const LazyBlock = lazy(() => import("./heavy").then((m) => { return { default: m.NamedHeavy }; }));
+const DynAwait = dynamic(async () => { const m = await import("./heavy"); return m.NamedHeavy; });
+// CONTROL: a loader returning the module itself renders its default export.
+const LazyDefault = lazy(() => import("./heavy"));
+const DynDefault = dynamic(() => import("./heavy"));
+
+// NOT wrappers: argument 0 is not what the product renders.
+const Thing = makeThing(() => factoryArgBody());
+const Made = useMemoLike(() => function MadeInner(): string { return "made"; }, []);
+
+// CONTROL: real wrappers still reach their argument.
+const Memoed = memo(function MemoInner(): string { return String(memoBody()); });
+const Observed = observer(ObservedImpl);
+
+export function Page(): string {
+  return (
+    <main>
+      <LazyNamed />
+      <DynNamed />
+      <LazyBlock />
+      <DynAwait />
+      <LazyDefault />
+      <DynDefault />
+      <Thing />
+      <Made />
+      <Memoed />
+      <Observed />
+    </main>
+  );
+}
+
+// A destructured prop SHADOWS the imported Button: none of these render ui/Button.
+export function ShorthandTag({ Button }: { Button: Fc<{}> }): string {
+  return <Button />;
+}
+export function RenameTag({ icon: Button }: { icon: Fc<{}> }): string {
+  return <Button />;
+}
+export function ArrowRenameTag(xs: { icon: Fc<{}> }[]): string[] {
+  return xs.map(({ icon: Button }) => <Button />);
+}
+export function PlainParamTag(Button: Fc<{}>): string {
+  return <Button />;
+}
+// …and the same for ordinary calls.
+export function ShorthandCall({ Button }: { Button: () => string }): string {
+  return Button();
+}
+export function RenameCall({ run: Button }: { run: () => string }): string {
+  return Button();
+}
+
+// CONTROL: with nothing shadowing it, the tag is the imported component.
+export function UsesButton(): string {
+  return <Button label="ok" />;
+}
diff --git a/graph/test/typescript/cases/75-jsx-wrapper-guards/src/heavy.tsx b/graph/test/typescript/cases/75-jsx-wrapper-guards/src/heavy.tsx
new file mode 100644
index 000000000..c125e18b6
--- /dev/null
+++ b/graph/test/typescript/cases/75-jsx-wrapper-guards/src/heavy.tsx
@@ -0,0 +1,16 @@
+// A module with a default AND a named component. A loader that projects the named one
+// out of the module (`.then(m => m.NamedHeavy)`) must not land on the default.
+export function heavyWork(): number {
+  return 1;
+}
+export function namedWork(): number {
+  return 2;
+}
+
+export default function Heavy(): string {
+  return String(heavyWork());
+}
+
+export function NamedHeavy(): string {
+  return String(namedWork());
+}
diff --git a/graph/test/typescript/cases/75-jsx-wrapper-guards/src/parts.tsx b/graph/test/typescript/cases/75-jsx-wrapper-guards/src/parts.tsx
new file mode 100644
index 000000000..cd12d1b85
--- /dev/null
+++ b/graph/test/typescript/cases/75-jsx-wrapper-guards/src/parts.tsx
@@ -0,0 +1,28 @@
+// Wrappers, loaders and ordinary factories, declared with the signatures that matter.
+// No React dependency.
+declare global {
+  namespace JSX {
+    type Element = string;
+    interface ElementAttributesProperty {
+      props: unknown;
+    }
+    interface IntrinsicElements {
+      [name: string]: unknown;
+    }
+  }
+}
+
+export type Fc<P> = (props: P) => string;
+export declare function memo<P>(component: Fc<P>): Fc<P>;
+export declare function observer<P>(component: Fc<P>): Fc<P>;
+export declare function lazy(load: () => Promise<{ default: Fc<any> }>): Fc<any>;
+export declare function dynamic(load: () => Promise<Fc<any> | { default: Fc<any> }>): Fc<any>;
+
+// NOT component wrappers: what they return is not argument 0.
+export function makeThing(f: () => number): Fc<{}> {
+  f();
+  return () => "thing";
+}
+export function useMemoLike<T>(f: () => T, deps: unknown[]): T {
+  return f();
+}
diff --git a/graph/test/typescript/cases/75-jsx-wrapper-guards/src/ui/Button.tsx b/graph/test/typescript/cases/75-jsx-wrapper-guards/src/ui/Button.tsx
new file mode 100644
index 000000000..69b27ce00
--- /dev/null
+++ b/graph/test/typescript/cases/75-jsx-wrapper-guards/src/ui/Button.tsx
@@ -0,0 +1,3 @@
+export function Button(p: { label: string }): string {
+  return p.label;
+}
diff --git a/graph/test/typescript/expected/75-jsx-wrapper-guards.edges b/graph/test/typescript/expected/75-jsx-wrapper-guards.edges
new file mode 100644
index 000000000..4fde5b860
--- /dev/null
+++ b/graph/test/typescript/expected/75-jsx-wrapper-guards.edges
@@ -0,0 +1,46 @@
+ambient_terminal	FUNCTION_CALL	app#<module-init>() @L15 -> parts#lazy(() ={ default: Fc })
+ambient_terminal	FUNCTION_CALL	app#<module-init>() @L16 -> parts#dynamic(() =Fc | { default: Fc })
+ambient_terminal	FUNCTION_CALL	app#<module-init>() @L18 -> parts#lazy(() ={ default: Fc })
+ambient_terminal	FUNCTION_CALL	app#<module-init>() @L19 -> parts#dynamic(() =Fc | { default: Fc })
+ambient_terminal	FUNCTION_CALL	app#<module-init>() @L21 -> parts#lazy(() ={ default: Fc })
+ambient_terminal	FUNCTION_CALL	app#<module-init>() @L22 -> parts#dynamic(() =Fc | { default: Fc })
+ambient_terminal	FUNCTION_CALL	app#<module-init>() @L29 -> parts#memo(Fc)
+ambient_terminal	FUNCTION_CALL	app#<module-init>() @L30 -> parts#observer(Fc)
+ambiguous_unknown	FUNCTION_CALL	app#MemoInner() @L29 -> -
+ambiguous_unknown	FUNCTION_CALL	app#RenameCall({ run: () =,{ run: () =) @L67 -> -
+ambiguous_unknown	FUNCTION_CALL	app#ShorthandCall({ Button: () =,{ Button: () =) @L64 -> -
+ambiguous_unknown	FUNCTION_CALL	heavy#Heavy() @L11 -> -
+ambiguous_unknown	FUNCTION_CALL	heavy#NamedHeavy() @L15 -> -
+ambiguous_unknown	JSX_COMPONENT_CALL	app#<arrow@57>(?,?) @L57 -> -
+ambiguous_unknown	JSX_COMPONENT_CALL	app#Page() @L42 -> -
+ambiguous_unknown	JSX_COMPONENT_CALL	app#RenameTag({ icon: Fc },{ icon: Fc }) @L54 -> -
+ambiguous_unknown	JSX_COMPONENT_CALL	app#ShorthandTag({ Button: Fc },{ Button: Fc }) @L51 -> -
+ambiguous_unknown	METHOD_CALL	app#<arrow@15>() @L15 -> -
+ambiguous_unknown	METHOD_CALL	app#<arrow@16>() @L16 -> -
+ambiguous_unknown	METHOD_CALL	app#<arrow@18>() @L18 -> -
+ambiguous_unknown	METHOD_CALL	app#ArrowRenameTag({ icon: Fc }[]) @L57 -> -
+intrinsic_terminal	DYNAMIC_IMPORT_CALL	app#<arrow@15>() @L15 -> -
+intrinsic_terminal	DYNAMIC_IMPORT_CALL	app#<arrow@16>() @L16 -> -
+intrinsic_terminal	DYNAMIC_IMPORT_CALL	app#<arrow@18>() @L18 -> -
+intrinsic_terminal	DYNAMIC_IMPORT_CALL	app#<arrow@19>() @L19 -> -
+intrinsic_terminal	DYNAMIC_IMPORT_CALL	app#<arrow@21>() @L21 -> -
+intrinsic_terminal	DYNAMIC_IMPORT_CALL	app#<arrow@22>() @L22 -> -
+known_edge	FUNCTION_CALL	app#<arrow@25>() @L25 -> app#factoryArgBody()
+known_edge	FUNCTION_CALL	app#<module-init>() @L25 -> parts#makeThing(() =)
+known_edge	FUNCTION_CALL	app#<module-init>() @L26 -> parts#useMemoLike(() =,unknown[])
+known_edge	FUNCTION_CALL	app#MemoInner() @L29 -> app#memoBody()
+known_edge	FUNCTION_CALL	heavy#Heavy() @L11 -> heavy#heavyWork()
+known_edge	FUNCTION_CALL	heavy#NamedHeavy() @L15 -> heavy#namedWork()
+known_edge	FUNCTION_CALL	parts#makeThing(() =) @L23 -> parts#<arrow@22>()
+known_edge	FUNCTION_CALL	parts#useMemoLike(() =,unknown[]) @L27 -> parts#<arrow@26>()
+known_edge	JSX_COMPONENT_CALL	app#Page() @L35 -> parts#<arrow@15>(T)
+known_edge	JSX_COMPONENT_CALL	app#Page() @L36 -> parts#<arrow@15>(T)
+known_edge	JSX_COMPONENT_CALL	app#Page() @L37 -> heavy#NamedHeavy()
+known_edge	JSX_COMPONENT_CALL	app#Page() @L38 -> heavy#NamedHeavy()
+known_edge	JSX_COMPONENT_CALL	app#Page() @L39 -> heavy#Heavy()
+known_edge	JSX_COMPONENT_CALL	app#Page() @L40 -> heavy#Heavy()
+known_edge	JSX_COMPONENT_CALL	app#Page() @L41 -> parts#<arrow@15>(T)
+known_edge	JSX_COMPONENT_CALL	app#Page() @L43 -> app#MemoInner()
+known_edge	JSX_COMPONENT_CALL	app#Page() @L44 -> app#ObservedImpl()
+known_edge	JSX_COMPONENT_CALL	app#PlainParamTag(Fc) @L60 -> parts#<arrow@15>(T)
+known_edge	JSX_COMPONENT_CALL	app#UsesButton() @L72 -> ui/Button#Button({ label: string })
diff --git a/graph/test/typescript/expected/75-jsx-wrapper-guards.entries b/graph/test/typescript/expected/75-jsx-wrapper-guards.entries
new file mode 100644
index 000000000..d6169b1e4
--- /dev/null
+++ b/graph/test/typescript/expected/75-jsx-wrapper-guards.entries
@@ -0,0 +1,12 @@
+── entry_point (11) ──
+  exported_from_entry_module app#ArrowRenameTag   app.tsx:56
+  exported_from_entry_module app#Page   app.tsx:32
+  exported_from_entry_module app#PlainParamTag   app.tsx:59
+  exported_from_entry_module app#RenameCall   app.tsx:66
+  exported_from_entry_module app#RenameTag   app.tsx:53
+  exported_from_entry_module app#ShorthandCall   app.tsx:63
+  exported_from_entry_module app#ShorthandTag   app.tsx:50
+  exported_from_entry_module app#UsesButton   app.tsx:71
+  exported_from_entry_module app#factoryArgBody   app.tsx:4
+  exported_from_entry_module app#memoBody   app.tsx:7
+  unimported_module app#<module>   app.tsx:1
diff --git a/graph/test/typescript/expected/75-jsx-wrapper-guards.envelope b/graph/test/typescript/expected/75-jsx-wrapper-guards.envelope
new file mode 100644
index 000000000..4274ea0da
--- /dev/null
+++ b/graph/test/typescript/expected/75-jsx-wrapper-guards.envelope
@@ -0,0 +1,15 @@
+value	parts#<function-type>@15:21 -> app#MemoInner
+value	parts#<function-type>@15:21 -> app#ObservedImpl
+value	parts#<function-type>@15:21 -> parts#<arrow>
+value	parts#<function-type>@18:36 -> app#<arrow>@15
+value	parts#<function-type>@18:36 -> app#<arrow>@18
+value	parts#<function-type>@18:36 -> app#<arrow>@21
+value	parts#<function-type>@19:39 -> app#<arrow>@16
+value	parts#<function-type>@19:39 -> app#<arrow>@19
+value	parts#<function-type>@19:39 -> app#<arrow>@22
+value	parts#<function-type>@22:30 -> app#<arrow>@25
+value	parts#<function-type>@26:35 -> app#<arrow>@26
+value_call	app#Page -> app#MadeInner
+value_call	app#Page -> parts#<arrow>
+value_call	parts#makeThing -> app#<arrow>@25
+value_call	parts#useMemoLike -> app#<arrow>@26
diff --git a/graph/test/typescript/expected/75-jsx-wrapper-guards.fields b/graph/test/typescript/expected/75-jsx-wrapper-guards.fields
new file mode 100644
index 000000000..886e2e7cc
--- /dev/null
+++ b/graph/test/typescript/expected/75-jsx-wrapper-guards.fields
@@ -0,0 +1,4 @@
+ambiguous_unknown	read	app#<arrow@18>(?) -> -
+ambiguous_unknown	read	app#<arrow@19>() -> -
+ambiguous_unknown	read	app#<module-init>() -> -
+known_edge	read	ui/Button#Button({ label: string }) -> { label: string }#label
diff --git a/graph/test/typescript/expected/75-jsx-wrapper-guards.fields-oracle b/graph/test/typescript/expected/75-jsx-wrapper-guards.fields-oracle
new file mode 100644
index 000000000..3617bfdbe
--- /dev/null
+++ b/graph/test/typescript/expected/75-jsx-wrapper-guards.fields-oracle
@@ -0,0 +1,9 @@
+75-jsx-wrapper-guards [fields]
+  precision 0.0000   (0 correct, 1 wrong)
+  recall    0.0000   (0 of 1 the compiler resolved)
+  sites 5   resolved 1 (20.0%)
+  tiers ambiguous_unknown=4  known_edge=1
+  access read=5
+  not scored: 4 rows whose target is not a client declaration
+    WRONG   ui/Button#Button({ label: string }) READ { label: string }#label
+    MISSING ui/Button#Button({ label: string }) READ ui/Button#label
diff --git a/graph/test/typescript/expected/75-jsx-wrapper-guards.known-missing b/graph/test/typescript/expected/75-jsx-wrapper-guards.known-missing
new file mode 100644
index 000000000..4b3ae9b66
--- /dev/null
+++ b/graph/test/typescript/expected/75-jsx-wrapper-guards.known-missing
@@ -0,0 +1,18 @@
+# Accepted gaps for 75-jsx-wrapper-guards — each line is an edge the TypeScript compiler
+# resolves and this engine does not. A NEW missing edge fails the suite;
+# a line here that STARTS working also fails, so the debt cannot rot.
+#
+# A name bound by a DESTRUCTURED parameter carries no declared type the engine reads, so
+# the call through it stays unresolved. The compiler names the prop's type signature.
+# Before this case these sites resolved to the same-named IMPORT (a wrong edge); unresolved
+# is the honest answer until destructured parameters are typed.
+app#<arrow@57>(?) -> parts#<arrow@15>(T)
+app#RenameTag({ icon: Fc }) -> parts#<arrow@15>(T)
+app#ShorthandTag({ Button: Fc }) -> parts#<arrow@15>(T)
+app#RenameCall({ run: () =) -> app#<arrow@66>()
+app#ShorthandCall({ Button: () =) -> app#<arrow@63>()
+# `useMemoLike(() => function MadeInner…)` returns what its argument RETURNS, through a
+# generic T. Argument 0 is not a component wrapper, so the tag no longer lands on the
+# argument arrow; following the generic return to MadeInner is value flow the engine
+# does not do here.
+app#Page() -> app#MadeInner()
diff --git a/graph/test/typescript/expected/75-jsx-wrapper-guards.lib.known-missing b/graph/test/typescript/expected/75-jsx-wrapper-guards.lib.known-missing
new file mode 100644
index 000000000..dd12e0f5e
--- /dev/null
+++ b/graph/test/typescript/expected/75-jsx-wrapper-guards.lib.known-missing
@@ -0,0 +1,18 @@
+# Accepted client->client gaps for 75-jsx-wrapper-guards (library pass) — each line is an edge the TypeScript compiler
+# resolves and this engine does not. A NEW missing edge fails the suite;
+# a line here that STARTS working also fails, so the debt cannot rot.
+#
+# A name bound by a DESTRUCTURED parameter carries no declared type the engine reads, so
+# the call through it stays unresolved. The compiler names the prop's type signature.
+# Before this case these sites resolved to the same-named IMPORT (a wrong edge); unresolved
+# is the honest answer until destructured parameters are typed.
+app#<arrow@57>(?) -> parts#<arrow@15>(T)
+app#RenameTag({ icon: Fc }) -> parts#<arrow@15>(T)
+app#ShorthandTag({ Button: Fc }) -> parts#<arrow@15>(T)
+app#RenameCall({ run: () =) -> app#<arrow@66>()
+app#ShorthandCall({ Button: () =) -> app#<arrow@63>()
+# `useMemoLike(() => function MadeInner…)` returns what its argument RETURNS, through a
+# generic T. Argument 0 is not a component wrapper, so the tag no longer lands on the
+# argument arrow; following the generic return to MadeInner is value flow the engine
+# does not do here.
+app#Page() -> app#MadeInner()
diff --git a/graph/test/typescript/expected/75-jsx-wrapper-guards.oracle b/graph/test/typescript/expected/75-jsx-wrapper-guards.oracle
new file mode 100644
index 000000000..ff8858f30
--- /dev/null
+++ b/graph/test/typescript/expected/75-jsx-wrapper-guards.oracle
@@ -0,0 +1,11 @@
+oracle=21 engine=19 agree=15 missing=6 (known 6, NEW 0) extra=4
+  known    app#<arrow@57>(?) -> parts#<arrow@15>(T)
+  known    app#Page() -> app#MadeInner()
+  known    app#RenameCall({ run: () =) -> app#<arrow@66>()
+  known    app#RenameTag({ icon: Fc }) -> parts#<arrow@15>(T)
+  known    app#ShorthandCall({ Button: () =) -> app#<arrow@63>()
+  known    app#ShorthandTag({ Button: Fc }) -> parts#<arrow@15>(T)
+  extra    app#Page() -> app#MemoInner()
+  extra    app#Page() -> app#ObservedImpl()
+  extra    app#Page() -> heavy#Heavy()
+  extra    app#Page() -> heavy#NamedHeavy()
diff --git a/graph/test/typescript/expected/75-jsx-wrapper-guards.type-use b/graph/test/typescript/expected/75-jsx-wrapper-guards.type-use
new file mode 100644
index 000000000..6c846c28c
--- /dev/null
+++ b/graph/test/typescript/expected/75-jsx-wrapper-guards.type-use
@@ -0,0 +1,9 @@
+ambiguous_unknown	METHOD_RETURN	1	parts [METHOD_PARAM] -> -
+known_edge	FIELD_TYPE	1	app [METHOD_PARAM] -> Fc
+known_edge	FIELD_TYPE	2	app [METHOD_PARAM] -> Fc
+known_edge	FIELD_TYPE	3	parts [METHOD_PARAM] -> Fc
+known_edge	FIELD_TYPE	4	parts [METHOD_PARAM] -> Fc
+known_edge	METHOD_PARAM	0	app [METHOD_PARAM] -> Fc
+known_edge	METHOD_PARAM	0	parts [METHOD_PARAM] -> Fc
+known_edge	METHOD_RETURN	0	parts [METHOD] -> Fc
+known_edge	TYPE_ELEMENT	3	parts [METHOD_PARAM] -> Fc
diff --git a/graph/test/typescript/expected/75-jsx-wrapper-guards.types-oracle b/graph/test/typescript/expected/75-jsx-wrapper-guards.types-oracle
new file mode 100644
index 000000000..aaebfab98
--- /dev/null
+++ b/graph/test/typescript/expected/75-jsx-wrapper-guards.types-oracle
@@ -0,0 +1,7 @@
+75-jsx-wrapper-guards [types]
+  precision 1.0000   (2 correct, 0 wrong)
+  recall    1.0000   (2 of 2 the compiler resolved)
+  sites 16   resolved 14 (87.5%)
+  tiers ambiguous_unknown=2  known_edge=14
+  contexts FIELD_TYPE=5  METHOD_PARAM=3  METHOD_RETURN=7  TYPE_ELEMENT=1
+  not scored: 2 rows whose target is not a client declaration
diff --git a/graph/typescript/PARSER-DEFECTS.md b/graph/typescript/PARSER-DEFECTS.md
index 6072a233d..cee58b565 100644
--- a/graph/typescript/PARSER-DEFECTS.md
+++ b/graph/typescript/PARSER-DEFECTS.md
@@ -18,8 +18,8 @@ day the defect is fixed.
 
 **Status: fixed.** A component element emits a JSX_ELEMENT / JSX_SELF_CLOSING row and a
 JSX_COMPONENT_CALL site; `callee-resolution.dl` rule (13) resolves it, and also follows a
-wrapper's argument 0 (`memo`, `forwardRef`) and a `lazy()` loader's default export. Pinned
-by cases 10 and 74. The measurement below is kept as the record of the defect.
+wrapper's argument 0 (`memo`, `forwardRef`, `observer`, `withX`) and what a `lazy` /
+`dynamic` loader settles to. Pinned by cases 10, 74 and 75. The measurement below is kept as the record of the defect.
 
 **Severity: blocking for any React / Preact / Solid codebase.**
 
diff --git a/graph/typescript/README.md b/graph/typescript/README.md
index 9b8d53be0..aad0c5a04 100644
--- a/graph/typescript/README.md
+++ b/graph/typescript/README.md
@@ -137,9 +137,12 @@ demonstrable false positive.
 Stated because a graph you cannot trust the boundaries of is not useful.
 
 * **A JSX member tag is only as good as its receiver.** `<Badge/>` is a
-  `JSX_COMPONENT_CALL` resolved by tag name, including through `memo()` / `forwardRef()`
-  wrappers and `lazy(() => import(...))`; `<ui.Card/>` is a `METHOD_CALL` and resolves
-  only where `ui.Card(...)` would. `<div>` produces no site.
+  `JSX_COMPONENT_CALL` resolved by tag name, including through the component wrappers
+  (`memo`, `forwardRef`, `observer`, a `withX` HOC) and a `lazy` / `dynamic` loader;
+  `<ui.Card/>` is a `METHOD_CALL` and resolves only where `ui.Card(...)` would. `<div>`
+  produces no site. A tag bound by a destructured prop (`({ icon: Icon }) => <Icon/>`)
+  is the prop, not a same-named import, and stays unresolved; so does a loader whose
+  `.then` projects a named export through a concise arrow body.
 * **Generic inference through a callback** — `map<U>(f: (t: T) => U): U[]` — is not
   substituted. `U` is bound by the argument's return type, which is inference rather
   than substitution, and guessing it would fabricate. Those sites stay unresolved and
diff --git a/graph/typescript/engine/expression-resolution/callee-resolution.dl b/graph/typescript/engine/expression-resolution/callee-resolution.dl
index 0cc00ad63..818f326ff 100644
--- a/graph/typescript/engine/expression-resolution/callee-resolution.dl
+++ b/graph/typescript/engine/expression-resolution/callee-resolution.dl
@@ -81,12 +81,14 @@ expr_call_candidate(ce, m) :- call_site("client", ck, cn, "NONE", _, ce, cs),
     cn != "",
     call_module(cs, mod),
     !callee_expr_bound(ce),
+    !callee_names_local(ce),
     name_binds(mod, cn, _, "METHOD", m).
 expr_call_candidate(ce, m) :- call_site("client", ck, cn, "NONE", _, ce, cs),
     call_kind_is_plain_call(ck),
     cn != "",
     call_module(cs, mod),
     !callee_expr_bound(ce),
+    !callee_names_local(ce),
     name_binds(mod, cn, _, "VARIABLE", v),
     var_is_function(v, m).
 // The same bound name, where the value is not a function declaration but a VARIABLE
@@ -100,6 +102,7 @@ expr_call_candidate(ce, m) :- call_site("client", ck, cn, "NONE", _, ce, cs),
     cn != "",
     call_module(cs, mod),
     !callee_expr_bound(ce),
+    !callee_names_local(ce),
     name_binds(mod, cn, _, "VARIABLE", v),
     var_type(v, _, t),
     call_signature_in_scope(t, m).
@@ -108,12 +111,27 @@ expr_call_candidate(ce, m) :- call_site("client", ck, cn, "NONE", _, ce, cs),
     cn != "",
     call_module(cs, mod),
     !callee_expr_bound(ce),
+    !callee_names_local(ce),
     name_binds(mod, cn, _, "VARIABLE", v),
     var_shape(v, sh),
     call_signature_in_scope(sh, m).
 
 callee_expr_bound(ce) :- call_callee_expr(_, ce, ne), expr_callable(ne, _).
 
+// The binder bound the callee to a LOCAL — a parameter (plain or destructured, where
+// `({ Button }) => Button()` and `({ icon: Button }) => <Button/>` both bind one), or
+// a variable other than the module-scope one of that name. The local shadows whatever
+// the module scope calls by that name, so looking the name up there lands on an
+// unrelated declaration, usually an import (#1562). The site stays with what the local
+// itself resolves to, or unresolved; a module-level const is still its own binding.
+callee_names_local(ce) :- call_callee_expr(_, ce, ne),
+    expr_referenced("client", "PARAMETER", _, ne).
+callee_names_local(ce) :- call_callee_expr(cs, ce, ne),
+    expr_referenced("client", "VARIABLE", v, ne),
+    call_site("client", _, cn, _, _, ce, cs),
+    call_module(cs, mod),
+    !name_binds(mod, cn, _, "VARIABLE", v).
+
 call_kind_is_plain_call("FUNCTION_CALL").
 call_kind_is_plain_call("OPTIONAL_CALL").
 call_kind_is_plain_call("DECORATOR_CALL").
@@ -495,13 +513,20 @@ expr_call_candidate(ce, m) :- call_site("client", "INDEX_CALL", _, _, recv, ce,
 // it correctly reaches no project declaration — and downstream that must be
 // classified as an ambient terminal, not as a blind spot, or every DOM element in a
 // React codebase is counted as a failure.
+//
+// Looked up by name in the module scope, so a tag the binder bound to a LOCAL — a
+// prop destructured as `({ icon: Icon }) => <Icon/>`, the commonest way a component
+// renders a component it was handed — is kept out exactly as rule (2) keeps out a
+// plain call: the prop is not the module's `Icon`.
 expr_call_candidate(ce, m) :- call_site("client", "JSX_COMPONENT_CALL", cn, _, _, ce, cs),
     cn != "",
     call_module(cs, mod),
+    !callee_names_local(ce),
     name_binds(mod, cn, _, "METHOD", m).
 expr_call_candidate(ce, m) :- call_site("client", "JSX_COMPONENT_CALL", cn, _, _, ce, cs),
     cn != "",
     call_module(cs, mod),
+    !callee_names_local(ce),
     name_binds(mod, cn, _, "VARIABLE", v),
     var_is_function(v, m).
 // A class component — `<MyView/>` where MyView extends React.Component — invokes its
@@ -509,36 +534,81 @@ expr_call_candidate(ce, m) :- call_site("client", "JSX_COMPONENT_CALL", cn, _, _
 expr_call_candidate(ce, ctor) :- call_site("client", "JSX_COMPONENT_CALL", cn, _, _, ce, cs),
     cn != "",
     call_module(cs, mod),
+    !callee_names_local(ce),
     name_binds(mod, cn, _, "TYPE", t),
     constructor_in_scope(t, ctor).
 // A WRAPPED component — `const Card = memo(function Card() {…})`, `forwardRef(Inner)`,
 // `observer(View)`. The binding holds whatever the wrapper returned, which is typed as
 // the library's own component type, so the rules above find no function behind it.
-// What renders is the function handed to the wrapper as argument 0, and a wrapper that
-// did not render it would not be a component wrapper. JSX only: the same shape at an
-// ordinary call site is a factory, and there argument 0 says nothing about what runs.
+// What renders is the function handed to the wrapper as argument 0. JSX only: the same
+// shape at an ordinary call site is a factory, and there argument 0 says nothing about
+// what runs.
 expr_call_candidate(ce, m) :- call_site("client", "JSX_COMPONENT_CALL", cn, _, _, ce, cs),
     cn != "",
     call_module(cs, mod),
+    !callee_names_local(ce),
     name_binds(mod, cn, _, "VARIABLE", v),
     jsx_wrapped_component(v, m).
+// ONLY a component wrapper. Argument 0 of an arbitrary call is not what its result
+// renders: `makeThing(() => build())` returns something else entirely, and
+// `useMemo(() => Comp, [])` returns what its argument RETURNS, not the argument. The
+// wrappers are named by the libraries that define them — `memo` and `forwardRef`
+// (React, Preact), `observer` (MobX) — and by the higher-order-component convention,
+// `withRouter(Page)`: a `with` prefix and a capital. Read off the call site's callee
+// name, so `React.memo(...)` counts as `memo(...)`.
+jsx_wrapper_name("memo").
+jsx_wrapper_name("forwardRef").
+jsx_wrapper_name("observer").
+jsx_component_wrapper(w) :- call_site("client", _, n, _, _, w, _),
+    jsx_wrapper_name(n).
+jsx_component_wrapper(w) :- call_site("client", _, n, _, _, w, _),
+    match("with[A-Z].*", n).
 jsx_wrapped_component(v, m) :- var_initializer("client", _, w, v),
-    expr_kind("client", "CALL_EXPRESSION", _, w),
+    jsx_component_wrapper(w),
     expr_child("client", w, "ARGUMENT", "0", a),
-    expr_callable(a, m),
-    !jsx_loader_function(m).
-// `lazy(() => import("./Settings"))` — argument 0 is a LOADER, not the component: it
-// returns a module, and the component is that module's default export. The loader
-// itself never renders anything, so it is excluded above.
-jsx_loader_function(f) :- method_returns_expr(f, ie),
-    expr_namespace(ie, _, _).
-jsx_wrapped_component(v, m) :- var_initializer("client", _, w, v),
-    expr_kind("client", "CALL_EXPRESSION", _, w),
+    expr_callable(a, m).
+// A LOADER — `lazy(() => import("./Settings"))`, Next.js `dynamic(...)`, `loadable(...)`.
+// Argument 0 is not the component: it returns a module, or a promise of one, and what
+// renders is the component that settles out of it.
+//
+// The returned expression is read at its ROOT. method_returns_expr holds for every node
+// under a return, and `import("./heavy").then((m) => m.NamedHeavy)` has the namespace
+// as a sub-expression: matched anywhere, it rendered the module's DEFAULT export for a
+// loader that projected a named one.
+jsx_loader_name("lazy").
+jsx_loader_name("dynamic").
+jsx_loader_name("loadable").
+jsx_loader_returns(v, r) :- var_initializer("client", _, w, v),
+    call_site("client", _, n, _, _, w, _),
+    jsx_loader_name(n),
     expr_child("client", w, "ARGUMENT", "0", a),
     expr_callable(a, f),
-    method_returns_expr(f, ie),
-    expr_namespace(ie, prov, mod2),
+    method_returns_expr(f, r),
+    expr_kind("client", _, "ROOT", r).
+// What the loader settles to is its returned value, or — through `.then(cb)` on the
+// module — what the callback returns. The callback's value is read the same way, so a
+// concise body that is not itself a call (`(m) => m.NamedHeavy`) has no returned row
+// and stays with the loader's declared type rather than guessing.
+jsx_loader_value(v, r) :- jsx_loader_returns(v, r).
+jsx_loader_value(v, x) :- jsx_loader_returns(v, r),
+    call_site("client", _, "then", _, recv, r, _),
+    expr_namespace(recv, _, _),
+    callback_arg(r, "0", lm),
+    method_returns_expr(lm, x),
+    expr_kind("client", _, "ROOT", x).
+// …the module itself: its default export renders.
+jsx_wrapped_component(v, m) :- jsx_loader_value(v, r),
+    expr_namespace(r, prov, mod2),
     module_export(prov, mod2, "default", "METHOD", m).
+// …a component projected out of it, `(await import("./heavy")).NamedHeavy` or
+// `.then((m) => { return m.NamedHeavy; })` (the Next.js named-export form).
+jsx_wrapped_component(v, m) :- jsx_loader_value(v, x),
+    expr_callable(x, m).
+// …or re-wrapped for `lazy`, `{ default: m.NamedHeavy }`: the `default` property of
+// the object it settles to.
+jsx_wrapped_component(v, m) :- jsx_loader_value(v, x),
+    objlit_prop(x, "default", val),
+    expr_callable(val, m).
 
 // ============================================================================
 // DISPATCH FAN — a supertype-typed receiver reaches its implementations
diff --git a/graph/typescript/souffle/decls_all.dl b/graph/typescript/souffle/decls_all.dl
index 21cc23524..5a3bdeae9 100644
--- a/graph/typescript/souffle/decls_all.dl
+++ b/graph/typescript/souffle/decls_all.dl
@@ -67,6 +67,7 @@
 .decl call_target_is_signature(c0:symbol)
 .decl call_type_only_target(c0:symbol,c1:symbol)
 .decl callee_expr_bound(c0:symbol)
+.decl callee_names_local(c0:symbol)
 .decl category_is_class(c0:symbol)
 .decl category_is_instantiable(c0:symbol)
 .decl category_is_shape_only(c0:symbol)
@@ -259,8 +260,12 @@
 .decl invocation_site(c0:symbol,c1:symbol)
 .decl jdk_max_depth(c0:number)
 .decl jsx_intrinsic_site(c0:symbol)
-.decl jsx_loader_function(c0:symbol)
+.decl jsx_component_wrapper(c0:symbol)
+.decl jsx_loader_name(c0:symbol)
+.decl jsx_loader_returns(c0:symbol,c1:symbol)
+.decl jsx_loader_value(c0:symbol,c1:symbol)
 .decl jsx_wrapped_component(c0:symbol,c1:symbol)
+.decl jsx_wrapper_name(c0:symbol)
 .decl lib_boundary_reason(c0:symbol,c1:symbol)
 .decl lib_capped()
 .decl lib_export_relative_base(c0:symbol,c1:symbol)