@@ -7,6 +7,7 @@
 #include <executorch/backends/native/runtime/deserialize/OwnedBytes.h>
 
 #include <cerrno>
+#include <cstdint>
 #include <filesystem>
 #include <fstream>
 #include <limits>
@@ -43,6 +44,23 @@ OwnedBytes OwnedBytes::from_vector(std::vector<uint8_t> bytes) {
   return OwnedBytes(std::move(bytes));
 }
 
+OwnedBytes OwnedBytes::view(
+    std::shared_ptr<const OwnedBytes> owner,
+    ByteSpan bytes) {
+  if (owner == nullptr) {
+    throw std::invalid_argument("OwnedBytes::view: owner is null");
+  }
+  const ByteSpan whole = owner->span();
+  const auto begin = reinterpret_cast<uintptr_t>(whole.data());
+  const auto first = reinterpret_cast<uintptr_t>(bytes.data());
+  if (!bytes.empty() &&
+      (first < begin || first - begin > whole.size() ||
+       bytes.size() > whole.size() - (first - begin))) {
+    throw std::invalid_argument("OwnedBytes::view: bytes lie outside owner");
+  }
+  return OwnedBytes(SharedView{std::move(owner), bytes});
+}
+
 OwnedBytes OwnedBytes::from_file(
     const std::string& path,
     bool use_mmap,
@@ -160,11 +178,17 @@ ByteSpan OwnedBytes::span() const {
     return ByteSpan(
         static_cast<const uint8_t*>(mapped->get()), mapped->get_deleter().size);
   }
+  if (const SharedView* view = std::get_if<SharedView>(&storage_)) {
+    return view->bytes;
+  }
   const std::vector<uint8_t>& bytes = std::get<std::vector<uint8_t>>(storage_);
   return ByteSpan(bytes.data(), bytes.size());
 }
 
 bool OwnedBytes::is_mapped() const {
+  if (const SharedView* view = std::get_if<SharedView>(&storage_)) {
+    return view->owner->is_mapped();
+  }
   return std::holds_alternative<MappedFile>(storage_);
 }
 
 
@@ -17,7 +17,8 @@
 
 namespace ptn {
 
-// Owning, read-only bytes: either a heap buffer or a read-only file mapping.
+// Owning, read-only bytes: a heap buffer, a read-only file mapping, or a view
+// that keeps another OwnedBytes alive.
 //
 // Hands out spans that alias the storage. Each alternative keeps its payload
 // address across a move, so spans taken before a move stay valid for as long as
@@ -45,13 +46,20 @@ class OwnedBytes {
   // A read-only mapping of an entire file.
   using MappedFile = std::unique_ptr<void, Unmap>;
 
-  std::variant<std::vector<uint8_t>, HeapBuffer, MappedFile> storage_;
+  struct SharedView {
+    std::shared_ptr<const OwnedBytes> owner;
+    ByteSpan bytes;
+  };
+
+  std::variant<std::vector<uint8_t>, HeapBuffer, MappedFile, SharedView>
+      storage_;
 
   explicit OwnedBytes(std::vector<uint8_t> bytes)
       : storage_(std::move(bytes)) {}
   explicit OwnedBytes(HeapBuffer buffer) : storage_(std::move(buffer)) {}
   explicit OwnedBytes(MappedFile mapped_file)
       : storage_(std::move(mapped_file)) {}
+  explicit OwnedBytes(SharedView view) : storage_(std::move(view)) {}
 
  public:
   // Empty, owning nothing.
@@ -66,12 +74,20 @@ class OwnedBytes {
   // The whole payload. Valid for this OwnedBytes' lifetime.
   ByteSpan span() const;
 
-  // True when these bytes are a file mapping rather than a heap buffer.
+  // True when these bytes are, or view, a file mapping rather than a heap
+  // buffer.
   bool is_mapped() const;
 
   // Take ownership of a buffer the caller already has, without copying it.
   static OwnedBytes from_vector(std::vector<uint8_t> bytes);
 
+  // A view of `bytes`, which must lie within `owner` unless empty, that shares
+  // ownership of `owner` rather than copying. Throws std::invalid_argument
+  // otherwise.
+  static OwnedBytes view(
+      std::shared_ptr<const OwnedBytes> owner,
+      ByteSpan bytes);
+
   // Acquire the contents of `path`. Maps it read-only by default: nothing is
   // copied, pages arrive on demand, and they are shared with any other process
   // mapping the same file. Pass use_mmap=false to read it into the heap
 
@@ -86,16 +86,28 @@ Package::Package()
 
 Package Package::load(OwnedBytes bytes) {
   Package out;
-  out.archive_bytes_ = std::move(bytes);
-  if (out.archive_bytes_.span().size() > detail::kMaxPackageBytes) {
+  out.archive_bytes_ = std::make_shared<const OwnedBytes>(std::move(bytes));
+  if (out.archive_bytes_->span().size() > detail::kMaxPackageBytes) {
     throw ResourceLimitError("package: image exceeds size limit");
   }
-  out.zip_ = ZipReader::open(out.archive_bytes_.span());
+  out.zip_ = ZipReader::open(out.archive_bytes_->span());
   out.load_metadata();
   return out;
 }
 
 Package Package::load(const std::string& path) {
+  std::optional<OwnedBytes> mapped;
+  try {
+    mapped = OwnedBytes::from_file(path, true, detail::kMaxPackageBytes);
+  } catch (const ResourceLimitError&) {
+    throw;
+  } catch (const std::runtime_error&) {
+    // No mmap on this platform or filesystem. Opening through libzip reports
+    // any error that is not about mapping.
+  }
+  if (mapped) {
+    return load(std::move(*mapped));
+  }
   Package out;
   out.zip_ = ZipReader::open(path);
   out.load_metadata();
@@ -202,6 +214,22 @@ std::optional<OwnedBytes> Package::acquire_constant(
   return OwnedBytes::from_vector(std::move(bytes));
 }
 
+std::optional<OwnedBytes> Package::view_constant(const std::string& key) const {
+  const std::optional<ConstantInfo> info = constant_info(key);
+  if (!info) {
+    return std::nullopt;
+  }
+  const std::optional<ByteSpan> member = zip_->member_bytes(kSafeTensorsEntry);
+  if (!member) {
+    return std::nullopt;
+  }
+  return OwnedBytes::view(
+      archive_bytes_,
+      member->subspan(
+          tensor_data_offset_ + tensors_->find(info->owner)->offset,
+          info->nbytes));
+}
+
 bool Package::load_constant_into(
     const std::string& key,
     MutableByteSpan destination) const {
 
@@ -8,6 +8,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <optional>
 #include <string>
 #include <unordered_map>
@@ -42,12 +43,14 @@ struct ConstantInfo {
 // A loaded .ptn package: the serialized native Program plus the constants it
 // references.
 //
-// Opening a file-backed package reads its directory and metadata, but leaves
-// weight payloads on disk until an engine requests them.
+// Opening a package from a path reads its directory and metadata, but leaves
+// weight payloads on disk until an engine requests them. Opening from bytes
+// keeps the caller's whole image resident.
 class Package {
  private:
   uint64_t id_ = 0;
-  OwnedBytes archive_bytes_;
+  // Null when the package is read through file I/O rather than memory.
+  std::shared_ptr<const OwnedBytes> archive_bytes_;
   std::optional<ZipReader> zip_;
   std::vector<uint8_t> program_;
   // Absent when the program references no constants, in which case the package
@@ -66,6 +69,7 @@ class Package {
   Package& operator=(const Package&) = delete;
 
   // Open and parse the .ptn at `path` without loading its weight payloads.
+  // Maps the file where supported; otherwise opens it through libzip.
   static Package load(const std::string& path);
 
   // Parse a .ptn image already in hand. Takes ownership rather than copying, so
@@ -100,6 +104,13 @@ class Package {
   // Load one constant into a new owning buffer. nullopt when absent.
   std::optional<OwnedBytes> acquire_constant(const std::string& key) const;
 
+  // One constant's bytes in place in the package's memory, keeping that memory
+  // alive past the Package instead of copying. nullopt when absent, when the
+  // package is read through file I/O, or when the archive's local headers are
+  // not laid out back to back. Alignment is whatever the file gives, so
+  // a caller with stricter needs checks it and falls back to acquire_constant.
+  std::optional<OwnedBytes> view_constant(const std::string& key) const;
+
   // Load one constant directly into an exact-sized destination. Returns false
   // when absent and throws when the destination has the wrong size.
   bool load_constant_into(const std::string& key, MutableByteSpan destination)
 
@@ -9,6 +9,7 @@
 #include <algorithm>
 #include <array>
 #include <cstdio>
+#include <cstring>
 #include <limits>
 #include <mutex>
 #include <stdexcept>
@@ -48,6 +49,19 @@ using ZipFileHandle = std::unique_ptr<zip_file_t, ZipFileDeleter>;
       "zip: " + operation + ": " + zip_file_strerror(file));
 }
 
+constexpr uint32_t kLocalHeaderSignature = 0x04034b50;
+constexpr size_t kLocalHeaderSize = 30;
+constexpr uint16_t kDataDescriptorFlag = 1 << 3;
+
+uint16_t read_u16(const uint8_t* p) {
+  return static_cast<uint16_t>(p[0] | (p[1] << 8));
+}
+
+uint32_t read_u32(const uint8_t* p) {
+  return static_cast<uint32_t>(read_u16(p)) |
+      (static_cast<uint32_t>(read_u16(p + 2)) << 16);
+}
+
 ZipHandle open_path(const std::string& path) {
   int error_code = 0;
   ZipHandle archive(
@@ -91,9 +105,12 @@ ZipHandle open_memory(ByteSpan bytes) {
 } // namespace
 
 struct ZipReader::Impl {
-  explicit Impl(ZipHandle handle) : archive(std::move(handle)) {}
+  explicit Impl(ZipHandle handle, ByteSpan bytes = {})
+      : archive(std::move(handle)), memory(bytes) {}
 
   ZipHandle archive;
+  // The archive itself when memory-backed; empty when file-backed.
+  ByteSpan memory;
   mutable std::mutex mutex;
 };
 
@@ -134,12 +151,55 @@ ZipReader::ZipReader(std::unique_ptr<Impl> impl) : impl_(std::move(impl)) {
     if (stat.size > std::numeric_limits<size_t>::max()) {
       throw std::runtime_error("zip: member is too large: " + name);
     }
-    if (!entries_.emplace(name, Entry{index, static_cast<size_t>(stat.size)})
-             .second) {
+    const Entry entry{index, static_cast<size_t>(stat.size), std::nullopt};
+    if (!entries_.emplace(name, entry).second) {
       throw std::runtime_error("zip: duplicate member name: " + name);
     }
     names_.push_back(name);
   }
+  if (!impl_->memory.empty()) {
+    locate_member_data();
+  }
+}
+
+// libzip does not expose where member data starts, so walk the local headers.
+// Accept only a simple layout: stored members contiguous from offset zero in
+// central-directory order. Otherwise leave offsets unset and read via libzip.
+void ZipReader::locate_member_data() {
+  const ByteSpan archive = impl_->memory;
+  std::vector<size_t> offsets;
+  offsets.reserve(names_.size());
+  size_t position = 0;
+  for (const std::string& name : names_) {
+    if (archive.size() - position < kLocalHeaderSize) {
+      return;
+    }
+    const uint8_t* header = archive.data() + position;
+    const size_t name_size = read_u16(header + 26);
+    const size_t extra_size = read_u16(header + 28);
+    if (read_u32(header) != kLocalHeaderSignature ||
+        (read_u16(header + 6) & kDataDescriptorFlag) != 0 ||
+        read_u16(header + 8) != ZIP_CM_STORE) {
+      return;
+    }
+    const size_t name_start = position + kLocalHeaderSize;
+    if (archive.size() - name_start < name_size + extra_size ||
+        std::string_view(
+            reinterpret_cast<const char*>(archive.data() + name_start),
+            name_size) != name) {
+      return;
+    }
+    const size_t data = name_start + name_size + extra_size;
+    const size_t size = entries_.find(name)->second.size;
+    if (archive.size() - data < size) {
+      return;
+    }
+    offsets.push_back(data);
+    position = data + size;
+  }
+  for (size_t i = 0; i < offsets.size(); ++i) {
+    entries_.find(names_[i])->second.data_offset = offsets[i];
+  }
 }
 
 ZipReader::~ZipReader() = default;
@@ -151,14 +211,22 @@ ZipReader ZipReader::open(const std::string& path) {
 }
 
 ZipReader ZipReader::open(ByteSpan archive) {
-  return ZipReader(std::make_unique<Impl>(open_memory(archive)));
+  return ZipReader(std::make_unique<Impl>(open_memory(archive), archive));
 }
 
 std::optional<size_t> ZipReader::member_size(std::string_view name) const {
   const Entry* entry = find_entry(name);
   return entry == nullptr ? std::nullopt : std::optional<size_t>(entry->size);
 }
 
+std::optional<ByteSpan> ZipReader::member_bytes(std::string_view name) const {
+  const Entry* entry = find_entry(name);
+  if (entry == nullptr || !entry->data_offset) {
+    return std::nullopt;
+  }
+  return impl_->memory.subspan(*entry->data_offset, entry->size);
+}
+
 std::vector<uint8_t> ZipReader::read(std::string_view name) const {
   const Entry* entry = find_entry(name);
   if (entry == nullptr) {
@@ -197,6 +265,13 @@ void ZipReader::read_entry_into(
   if (destination.empty()) {
     return;
   }
+  if (entry.data_offset) {
+    std::memcpy(
+        destination.data(),
+        impl_->memory.data() + *entry.data_offset + offset,
+        destination.size());
+    return;
+  }
 
   const std::lock_guard<std::mutex> lock(impl_->mutex);
   ZipFileHandle file(
 
@@ -26,6 +26,8 @@ class ZipReader {
   struct Entry {
     uint64_t index = 0;
     size_t size = 0;
+    // Where the member's data starts in a memory-backed archive, when known.
+    std::optional<size_t> data_offset;
   };
 
   struct StringHash {
@@ -43,6 +45,7 @@ class ZipReader {
   std::vector<std::string> names_;
 
   explicit ZipReader(std::unique_ptr<Impl> impl);
+  void locate_member_data();
   const Entry* find_entry(std::string_view name) const;
   void read_entry_into(
       std::string_view name,
@@ -69,6 +72,11 @@ class ZipReader {
   // Member size, or nullopt when the member is absent.
   std::optional<size_t> member_size(std::string_view name) const;
 
+  // A member's bytes in place within a memory-backed archive. nullopt when the
+  // member is absent, the reader is file-backed, or the archive's local headers
+  // are not laid out back to back in central-directory order.
+  std::optional<ByteSpan> member_bytes(std::string_view name) const;
+
   // Copies one complete member.
   std::vector<uint8_t> read(std::string_view name) const;