@@ -4,8 +4,6 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-# pyre-strict
-
 """
 Serialize a torch.fx graph into the native backend's generic flatbuffer format
 (native_graph.fbs) and back.
@@ -31,6 +29,7 @@
 from enum import IntEnum
 from typing import (
     Any,
+    Callable,
     cast,
     get_args,
     get_origin,
@@ -1487,39 +1486,48 @@ def _iter_graph_args(value: object) -> Iterator[GraphArg]:
             yield from _iter_graph_args(item)
 
 
-def collect_data_keys(program: Program) -> set[str]:
-    """Return every out-of-line data key the program references.
+def map_data_keys(method: Method, fn: Callable[[str], str]) -> None:
+    """Replace every out-of-line data key in ``method`` with ``fn(key)``, in place.
 
     Covers constant references (NamedTensorRef.data_key) plus the quant keys
     (AffineGroup scale and zero-point) carried on any TensorMeta.quant, whether
     it is attached to a constant or to a graph value (intermediates and I/O),
     recursing into HOP subgraphs wherever a schema field carries a ``GraphArg``.
     PackedQuant carries no external keys.
     """
-    keys: set[str] = set()
 
-    def add_meta(meta: Optional[TensorMeta]) -> None:
+    def map_meta(meta: Optional[TensorMeta]) -> None:
         if meta is None or meta.quant is None:
             return
         scheme = meta.quant.scheme
         if isinstance(scheme, AffineGroup):
-            keys.add(scheme.scale_data_key)
+            scheme.scale_data_key = fn(scheme.scale_data_key)
             if scheme.zero_point_data_key:
-                keys.add(scheme.zero_point_data_key)
+                scheme.zero_point_data_key = fn(scheme.zero_point_data_key)
 
     def visit_graph(graph: Graph) -> None:
         for value in graph.tensor_values or []:
-            add_meta(value.meta)
+            map_meta(value.meta)
         for node in graph.nodes:
             for graph_arg in _iter_graph_args(node):
                 visit_graph(graph_arg.graph)
 
-    for method in program.methods:
-        for constant in method.constants or []:
-            keys.add(constant.data_key)
-            add_meta(constant.meta)
-        visit_graph(method.graph)
+    for constant in method.constants or []:
+        constant.data_key = fn(constant.data_key)
+        map_meta(constant.meta)
+    visit_graph(method.graph)
+
 
+def collect_data_keys(program: Program) -> set[str]:
+    """Return every out-of-line data key the program references."""
+    keys: set[str] = set()
+
+    def add(key: str) -> str:
+        keys.add(key)
+        return key
+
+    for method in program.methods:
+        map_data_keys(method, add)
     return keys
 
 
 
@@ -45,7 +45,10 @@ needed in the future like `constant_methods` and ETRecord integration.
 Raises `TypeError` for the wrong input or method-value types. Raises `ValueError`
 for an empty method mapping or method name, if a method does not fully delegate to
 the native backend, if a constant differs between methods, or if a data key the
-graph references has no backing tensor.
+graph references has no backing tensor. Generated immutable
+`_lifted_tensor_constant{i}` keys are always namespaced as `<method>/<name>`,
+including for a single method. Equal tensors under different keys are deduplicated
+on save. A namespaced key that conflicts with an existing constant key is rejected.
 
 ## Current limitations: one complete delegate per method
 
 
@@ -4,8 +4,6 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-# pyre-strict
-
 """
 Direct native lowering.
 
@@ -37,9 +35,11 @@
 
 from executorch.backends.native.preprocess import NativeDelegateInfo
 from executorch.backends.native.serialization.graph_serialize import (
+    _compile_to_bytes,
     _same_tensor,
     collect_data_keys,
     deserialize_program,
+    map_data_keys,
     merge_programs,
     validate_program,
 )
@@ -379,8 +379,10 @@ def to_native(
             dictionary containing only ``ExportedProgram`` values.
         ValueError: If the method dictionary is empty, a method name is empty, a
             method does not fully delegate to the native backend, a constant
-            differs between methods, or a data key the graph references has no
-            backing tensor.
+            differs between methods, a namespaced key conflicts with an existing
+            constant key, or a data key the graph references has no backing tensor.
+            Generated immutable ``_lifted_tensor_constant{i}`` keys are always
+            namespaced per method.
     """
     method_programs = _normalize_programs(programs)
 
@@ -437,13 +439,32 @@ def to_native(
         method_blobs[method_name] = module.processed_bytes
         method_constants[method_name] = _delegate_info(module, method_name).constants
 
-    ptg_blob = merge_programs(method_blobs)
-    constants = _merge_constants(method_constants)
+    program = deserialize_program(merge_programs(method_blobs))
+    mutated_keys = _mutable_data_keys(program)
+    data_keys = {key for constants in method_constants.values() for key in constants}
+    for method in program.methods:
+        constants_for_method = method_constants[method.name]
+        mapping = {
+            key: f"{method.name}/{key}"
+            for key in constants_for_method
+            if key.startswith("_lifted_tensor_constant") and key not in mutated_keys
+        }
+        conflicts = set(mapping.values()) & data_keys
+        if conflicts:
+            raise ValueError(
+                "to_native: namespaced lifted constant keys already exist: "
+                f"{sorted(conflicts)}"
+            )
+        map_data_keys(method, lambda key: mapping.get(key, key))
+        method_constants[method.name] = {
+            mapping.get(key, key): tensor
+            for key, tensor in constants_for_method.items()
+        }
 
-    program = deserialize_program(ptg_blob)
+    constants = _merge_constants(method_constants)
     _validate_merged_program(program, constants)
 
-    return NativeProgramManager(ptg=ptg_blob, constants=constants)
+    return NativeProgramManager(ptg=_compile_to_bytes(program), constants=constants)
 
 
 __all__ = ["NativeProgramManager", "to_native"]
@@ -27,7 +27,12 @@
     Program,
 )
 from executorch.exir import to_edge_transform_and_lower
-from executorch.exir._serialize._ptn import ALIASES_ENTRY, PTG_ENTRY, SAFETENSORS_ENTRY
+from executorch.exir._serialize._ptn import (
+    ALIASES_ENTRY,
+    PTG_ENTRY,
+    read_ptn,
+    SAFETENSORS_ENTRY,
+)
 from executorch.exir.lowered_backend_module import (
     executorch_call_delegate,
     get_lowered_submodules,
@@ -60,7 +65,7 @@ def _test_equivalence(self, programs):
         flow keeps one single-method delegate blob per method and would ship the
         same constants in a .ptd. The graphs are compared modulo that wrapping,
         and the full key sets (safetensors owners + aliases) must match the
-        delegates' named-data keys.
+        delegates' named-data keys after namespacing lifted constants.
         """
         method_programs = (
             programs if isinstance(programs, dict) else {"forward": programs}
@@ -113,9 +118,17 @@ def _test_equivalence(self, programs):
                 # Constants may be embedded in the .pte (pte_data) or shipped to a
                 # .ptd (external_data) depending on external_constants_tag; collect
                 # both so the key set matches to_native's .ptn/.safetensors.
-                et_keys |= set(nds.pte_data.keys())
+                method_keys = set(nds.pte_data.keys())
                 for key_to_entry in nds.external_data.values():
-                    et_keys |= set(key_to_entry.keys())
+                    method_keys |= set(key_to_entry.keys())
+                et_keys |= {
+                    (
+                        f"{name}/{key}"
+                        if key.startswith("_lifted_tensor_constant")
+                        else key
+                    )
+                    for key in method_keys
+                }
 
         # Emission is outside the comparison, but keep proving the ExecuTorch path
         # still completes end to end through the unchanged NamedDataStore branch.
@@ -239,7 +252,7 @@ def forward(self, x):
 
         ep = torch.export.export(ConstAdd(), (torch.randn(2, 4),))
         _, st_keys, _ = self._test_equivalence(ep)
-        self.assertTrue(any("lifted" in k for k in st_keys))
+        self.assertEqual(st_keys, {"forward/_lifted_tensor_constant0"})
 
 
 class ToNativeInputValidationTest(unittest.TestCase):
@@ -393,6 +406,83 @@ def test_dropped_public_input_is_rejected(self):
             self._check(self._graph_module(drop_input=True))
 
 
+class LiftedConstantNamespaceTest(unittest.TestCase):
+    def _scalar_shift(self, offset: float):
+        class Shift(nn.Module):
+            def forward(self, x):
+                return x + offset
+
+        return torch.export.export(Shift(), (torch.randn(2, 4),))
+
+    def _read(self, native) -> tuple[Program, dict[str, torch.Tensor]]:
+        with tempfile.TemporaryDirectory() as td:
+            path = os.path.join(td, "m.ptn")
+            native.save(path)
+            ptg, constants = read_ptn(path)
+        return deserialize_program(ptg), constants
+
+    def _lifted_keys(self, program: Program, method_name: str) -> list[str]:
+        (method,) = [m for m in program.methods if m.name == method_name]
+        return [c.data_key for c in method.constants or [] if "lifted" in c.data_key]
+
+    def test_distinct_lifted_constants_are_namespaced(self):
+        programs = {"a": self._scalar_shift(1.0), "b": self._scalar_shift(2.0)}
+        native = to_native(programs)
+        self.assertEqual(native.methods, {"a", "b"})
+        program, constants = self._read(native)
+        (a_key,) = self._lifted_keys(program, "a")
+        (b_key,) = self._lifted_keys(program, "b")
+        self.assertEqual(a_key, "a/_lifted_tensor_constant0")
+        self.assertEqual(b_key, "b/_lifted_tensor_constant0")
+        torch.testing.assert_close(
+            constants[a_key], torch.full_like(constants[a_key], 1.0), rtol=0, atol=0
+        )
+        torch.testing.assert_close(
+            constants[b_key], torch.full_like(constants[b_key], 2.0), rtol=0, atol=0
+        )
+
+    def test_identical_lifted_constants_dedup_on_save(self):
+        programs = {"a": self._scalar_shift(1.0), "b": self._scalar_shift(1.0)}
+        native = to_native(programs)
+        with tempfile.TemporaryDirectory() as td:
+            path = os.path.join(td, "m.ptn")
+            native.save(path)
+            ptg, constants = read_ptn(path)
+            with zipfile.ZipFile(path) as pkg:
+                owners = _safetensors_keys(pkg.read(SAFETENSORS_ENTRY))
+                aliases = json.loads(pkg.read(ALIASES_ENTRY))
+
+        program = deserialize_program(ptg)
+        (a_key,) = self._lifted_keys(program, "a")
+        (b_key,) = self._lifted_keys(program, "b")
+        self.assertEqual(a_key, "a/_lifted_tensor_constant0")
+        self.assertEqual(b_key, "b/_lifted_tensor_constant0")
+        self.assertEqual(owners, {a_key})
+        self.assertEqual(aliases, {b_key: a_key})
+        self.assertIs(constants[a_key], constants[b_key])
+
+    def test_parameter_fqn_collision_is_still_rejected(self):
+        programs = {
+            "a": torch.export.export(nn.Linear(4, 4), (torch.randn(1, 4),)),
+            "b": torch.export.export(nn.Linear(4, 4), (torch.randn(1, 4),)),
+        }
+        with self.assertRaisesRegex(ValueError, "differs between methods"):
+            to_native(programs)
+
+    def test_namespaced_key_collision_is_rejected(self):
+        class ConstWithBuffer(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.register_buffer("forward/_lifted_tensor_constant1", torch.zeros(4))
+
+            def forward(self, x):
+                return x + self.get_buffer("forward/_lifted_tensor_constant1") + 1.0
+
+        ep = torch.export.export(ConstWithBuffer(), (torch.randn(4),))
+        with self.assertRaisesRegex(ValueError, "namespaced lifted constant keys"):
+            to_native(ep)
+
+
 class MutableBufferDedupTest(unittest.TestCase):
     def test_identical_mutable_buffers_stay_separate(self):
         """Equal bytes must not make two independently mutable buffers one.