feat(project): add registry content routing and file transport

Author: GaspardKirira

include/vix/cli/project/native/PackageContentAcquisition.hpp

@@ -23,11 +23,21 @@ namespace vix::cli::project::native
 
   enum class PackageContentSourceStatus { available, unavailable, transport_failure };
 
+  enum class RegistryPackageContentSourceStatus
+  {
+    available,
+    not_found,
+    transport_failure,
+    permission_denied,
+    configuration_error,
+    payload_too_large
+  };
+
   // `available` carries untrusted exact P10O canonical bytes. The provider
   // cannot mint a VerifiedPackageContent token.
   struct RegistryPackageContentSourceResult
   {
-    PackageContentSourceStatus status{PackageContentSourceStatus::unavailable};
+    RegistryPackageContentSourceStatus status{RegistryPackageContentSourceStatus::not_found};
     std::optional<std::string> canonicalBytes;
     std::string diagnostic;
   };
@@ -37,7 +47,7 @@ namespace vix::cli::project::native
   public:
     virtual ~RegistryPackageContentSource() = default;
     [[nodiscard]] virtual RegistryPackageContentSourceResult acquire(
-      const RegistryLocation &location,
+      const RegistryContentLocation &location,
       const RegistryPackageContentRequest &request) = 0;
   };
 
@@ -83,14 +93,16 @@ namespace vix::cli::project::native
     package_content_transport_failure,
     package_content_integrity_failure,
     package_content_digest_mismatch,
+    package_content_source_configuration_error,
+    package_content_payload_too_large,
     package_content_git_source_failure,
     package_content_store_failure,
   };
 
   struct RegistryLocationAcquisitionDiagnostic
   {
     std::string locationDescriptor;
-    PackageContentSourceStatus status{PackageContentSourceStatus::unavailable};
+    RegistryPackageContentSourceStatus status{RegistryPackageContentSourceStatus::not_found};
     std::string message;
   };
 

include/vix/cli/project/native/RegistryContentLayout.hpp

@@ -0,0 +1,27 @@
+/** @file RegistryContentLayout.hpp
+ *  Registry format-1 immutable content-object addressing.
+ */
+#ifndef VIX_CLI_PROJECT_NATIVE_REGISTRY_CONTENT_LAYOUT_HPP
+#define VIX_CLI_PROJECT_NATIVE_REGISTRY_CONTENT_LAYOUT_HPP
+
+#include <string>
+#include <string_view>
+
+#include <vix/cli/project/native/PackageContentStore.hpp>
+
+namespace vix::cli::project::native
+{
+  // Registry mirror layout is independent from P10P's local filesystem layout.
+  // PackageContentId can only be created after validated SHA-256 syntax, so the
+  // resulting forward-slash path is safe and digest-derived.
+  [[nodiscard]] inline std::string registry_format1_content_object_path(
+    const PackageContentId &content)
+  {
+    const std::string &digest = content.digest();
+    const std::string_view hex = std::string_view{digest}.substr(7);
+    return "objects/sha256/" + std::string{hex.substr(0, 2)} + "/" +
+      std::string{hex.substr(2)};
+  }
+} // namespace vix::cli::project::native
+
+#endif // VIX_CLI_PROJECT_NATIVE_REGISTRY_CONTENT_LAYOUT_HPP

include/vix/cli/project/native/RegistryContentTransport.hpp

@@ -0,0 +1,69 @@
+/** @file RegistryContentTransport.hpp
+ *  Local Registry format-1 content mirror transport.
+ */
+#ifndef VIX_CLI_PROJECT_NATIVE_REGISTRY_CONTENT_TRANSPORT_HPP
+#define VIX_CLI_PROJECT_NATIVE_REGISTRY_CONTENT_TRANSPORT_HPP
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <string_view>
+
+#include <vix/cli/project/native/PackageContentAcquisition.hpp>
+
+namespace vix::cli::project::native
+{
+  inline constexpr std::uint64_t default_registry_content_maximum_bytes =
+    1024ULL * 1024ULL * 1024ULL;
+
+  using RegistryContentTransportStatus = RegistryPackageContentSourceStatus;
+
+  struct RegistryContentTransportResult
+  {
+    RegistryContentTransportStatus status{RegistryContentTransportStatus::not_found};
+    std::optional<std::string> bytes;
+    std::string diagnostic;
+  };
+
+  // Fetches one digest-addressed object from one configured mirror. It does
+  // not iterate mirrors or validate P10O content.
+  class RegistryContentTransport
+  {
+  public:
+    virtual ~RegistryContentTransport() = default;
+    [[nodiscard]] virtual RegistryContentTransportResult fetch(
+      const RegistryContentLocation &location,
+      std::string_view relativeObjectPath,
+      std::uint64_t maximumBytes) = 0;
+  };
+
+  class FileRegistryContentTransport final : public RegistryContentTransport
+  {
+  public:
+    [[nodiscard]] RegistryContentTransportResult fetch(
+      const RegistryContentLocation &location,
+      std::string_view relativeObjectPath,
+      std::uint64_t maximumBytes) override;
+  };
+
+  // Adapts a single-location transport to the P10Q-A source boundary. P10Q-A
+  // retains ownership of mirror fallback; P10O/P10P retain integrity/storage.
+  class TransportRegistryPackageContentSource final : public RegistryPackageContentSource
+  {
+  public:
+    explicit TransportRegistryPackageContentSource(
+      RegistryContentTransport &transport,
+      std::uint64_t maximumBytes = default_registry_content_maximum_bytes)
+      : transport_(transport), maximumBytes_(maximumBytes) {}
+
+    [[nodiscard]] RegistryPackageContentSourceResult acquire(
+      const RegistryContentLocation &location,
+      const RegistryPackageContentRequest &request) override;
+
+  private:
+    RegistryContentTransport &transport_;
+    std::uint64_t maximumBytes_;
+  };
+} // namespace vix::cli::project::native
+
+#endif // VIX_CLI_PROJECT_NATIVE_REGISTRY_CONTENT_TRANSPORT_HPP

include/vix/cli/project/native/RegistryDirectory.hpp

@@ -21,11 +21,22 @@ namespace vix::cli::project::native
     friend bool operator==(const RegistryLocation &, const RegistryLocation &) = default;
   };
 
+  // Opaque transport configuration for immutable Registry package content.
+  // This is deliberately distinct from metadata-observation routing.
+  struct RegistryContentLocation
+  {
+    std::string descriptor;
+    friend bool operator==(const RegistryContentLocation &, const RegistryContentLocation &) = default;
+  };
+
   struct RegistryDefinition
   {
     std::string id;
     // Declaration order is fallback preference, not package semantics.
     std::vector<RegistryLocation> locations;
+    // Independent content mirrors; declaration order is fallback preference.
+    // Empty is valid when this Registry serves metadata but no content mirrors.
+    std::vector<RegistryContentLocation> contentLocations;
   };
 
   enum class RegistryDirectoryErrorCode
@@ -34,7 +45,9 @@ namespace vix::cli::project::native
     duplicate_registry_id,
     no_registry_locations,
     invalid_location,
-    duplicate_location
+    duplicate_location,
+    invalid_content_location,
+    duplicate_content_location
   };
 
   struct RegistryDirectoryIssue

src/project/native/PackageContentAcquisition.cpp

@@ -86,16 +86,33 @@ namespace vix::cli::project::native
         return failure(acquisition_issue(PackageContentAcquisitionIssueCode::unknown_registry,
           required, "locked Registry ID has no routing definition"));
 
+      if (definition->contentLocations.empty())
+        return failure(acquisition_issue(PackageContentAcquisitionIssueCode::package_content_source_unavailable,
+          required, "registry has no package content locations configured"));
+
       const RegistryPackageContentRequest request{node.identity, node.version, required.id};
       std::vector<RegistryLocationAcquisitionDiagnostic> diagnostics;
       bool sawTransportFailure = false;
-      for (const auto &location : definition->locations)
+      for (const auto &location : definition->contentLocations)
       {
         const auto response = source.acquire(location, request);
-        if (response.status != PackageContentSourceStatus::available)
+        if (response.status == RegistryPackageContentSourceStatus::configuration_error ||
+            response.status == RegistryPackageContentSourceStatus::payload_too_large)
+        {
+          diagnostics.push_back({location.descriptor, response.status, response.diagnostic});
+          const auto code = response.status == RegistryPackageContentSourceStatus::configuration_error
+            ? PackageContentAcquisitionIssueCode::package_content_source_configuration_error
+            : PackageContentAcquisitionIssueCode::package_content_payload_too_large;
+          auto issue = acquisition_issue(code, required,
+            response.diagnostic.empty() ? "Registry content transport failed terminally" : response.diagnostic);
+          issue.registryLocations = std::move(diagnostics);
+          return failure(std::move(issue));
+        }
+        if (response.status != RegistryPackageContentSourceStatus::available)
         {
           sawTransportFailure = sawTransportFailure ||
-            response.status == PackageContentSourceStatus::transport_failure;
+            response.status == RegistryPackageContentSourceStatus::transport_failure ||
+            response.status == RegistryPackageContentSourceStatus::permission_denied;
           diagnostics.push_back({location.descriptor, response.status, response.diagnostic});
           continue;
         }