@@ -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
 
 
 
@@ -44,8 +44,14 @@ 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.
+the native backend, if a mutable constant differs between methods, if namespaced
+keys conflict, or if a data key the graph references has no backing tensor.
+
+All immutable constant keys are namespaced as `<method>/<key>`, including for a
+single method. Equal immutable tensors under different keys are deduplicated on
+save. A key mutated by any method keeps its original name in every method,
+including methods that only read it, preserving shared runtime state. Namespaced
+keys must not collide with each other or with preserved mutable keys.
 
 ## 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,
 )
@@ -254,13 +254,7 @@ def _delegate_info(lowered: object, method_name: str) -> NativeDelegateInfo:
 def _merge_constants(
     per_method: dict[str, dict[str, torch.Tensor]],
 ) -> dict[str, torch.Tensor]:
-    """Union per-method constants by fqn.
-
-    serialize_program treats an fqn as one buffer across every method, so hold to
-    that here rather than letting a later method silently clobber an earlier one.
-    _same_tensor short-circuits on identity and shared storage, which is the usual
-    case for a weight referenced by several methods.
-    """
+    """Merge constants by their final data keys, rejecting differing values."""
     merged: dict[str, torch.Tensor] = {}
     source: dict[str, str] = {}
     for method_name, constants in per_method.items():
@@ -363,6 +357,10 @@ def to_native(
     ``programs`` is a single ``ExportedProgram`` (lowered as the sole ``forward``
     method) or a dict mapping method name to ``ExportedProgram``.
 
+    Immutable constant keys are namespaced as ``<method>/<key>``, including for a
+    single method. Keys mutated by any method keep their original names so state
+    remains shared across methods. Equal immutable tensors deduplicate on save.
+
     Nothing about lowering is configurable yet. The passes, the partitioner, and
     the edge compile config are all owned here, because correctness of the package
     depends on them. Exposing the compile config is worth reconsidering.
@@ -378,9 +376,9 @@ def to_native(
         TypeError: If ``programs`` is not an ``ExportedProgram`` or a method-name
             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.
+            method does not fully delegate to the native backend, a mutable
+            constant differs between methods, namespaced keys conflict, or a data
+            key the graph references has no backing tensor.
     """
     method_programs = _normalize_programs(programs)
 
@@ -437,13 +435,33 @@ 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 = set(mutated_keys)
+    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 not in mutated_keys
+        }
+        conflicts = set(mapping.values()) & data_keys
+        if conflicts:
+            raise ValueError(
+                "to_native: namespaced constant keys already exist: "
+                f"{sorted(conflicts)}"
+            )
+        data_keys.update(mapping.values())
+        map_data_keys(method, lambda key, mapping=mapping: 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"]