Write partition scopes directly and reuse the registered payload serializer

Remove the profiled intermediate key component lists and reuse Orleans' singleton typed serializer with independently pooled sessions. Preserve literal key bytes, complete decoding validation, component bounds, aliases and versions.

Validation: strict Debug solution build, touched-source formatting verification, governance, 279 focused operation/key tests, 144 serialization tests, one real HTTP SDK/MCP revocation and two-cold-restart scenario, 3041-case discovery and all five coverage selectors. Three alternating million-call measurements retain exact results: key allocation 408 to 152 B/call and decoded VectorSpace allocation 248 to 208 B/call; these are local component measurements.

Author: KSemenenko

docs/Features/InternalSerialization.md

@@ -1,5 +1,7 @@
 # InternalSerialization
 
+The internal payload reader obtains its typed serializer from Orleans' existing singleton registration. Each decode still owns a separate pooled session and performs the original complete envelope, version, root-type and trailing-byte validation. Reusing the registered serializer changes no generated bytes, aliases or persisted/public versions.
+
 The official Orleans 10.4.2 generated serializer encodes owned internal DTOs.
 [ADR-060](../ADR/ADR-060-internal-serialization.md) defines the current contract.
 Public HTTP/MCP JSON, exact user content, sortable keys, opaque ZoneTree bytes,

docs/Features/StorageRecovery.md

@@ -1,5 +1,7 @@
 # StorageRecovery
 
+REQ-KEYCODEC-001/003: partition scopes and dynamic suffixes are written directly into one canonical key buffer. The component ceiling applies to their combined count. `KeySpacePartitionEncodingTests` preserves literal persisted bytes, case, NUL escaping, Unicode, typed/dynamic value parity, the exact component boundary and the original null/unsupported-value refusals. No key version or persisted format changes.
+
 Storage mode selects physical ownership. With `IsolatedVolumes`, a silo-local Orleans Grain Service owns that node's ZoneTree stores (each with ZoneTree's own write-ahead log), file locks and ordered apply gate; copies use typed Orleans calls to those owners. With `SharedVolume`, all silos use the configured shared paths and one ordinary database grain activation acquires the physical session; other silos call that owner. Shared storage requires `ReplicaCount=1` and never permits concurrent writers to the same ZoneTree files. The local runtime retains handles until actual borrowers join and the session closes. Orleans owns placement and activation movement; deployed shared-filesystem locking and flush behavior remain unqualified.
 
 This feature specifies the canonical key codec, physical ownership and lifetime, ZoneTree write-ahead-log durability and recovery, scoped read cuts, the current format and process-kill recovery qualification. With isolated storage, a successful persisted receipt requires every configured copy to confirm its synced local apply and reports the actual `PersistedCopies` ([ADR-136](../ADR/ADR-136-orleans-partition-ownership.md), [ADR-143](../ADR/ADR-143-independent-silo-replica-topology.md)); storage mode adds no format here. Backup and restore of a store are specified in [BackupRestore](BackupRestore.md).

docs/implementation/competitor-performance-review.md

@@ -8,6 +8,8 @@ The confirmed common-path waste is an auxiliary database read of the current pri
 
 Independent request execution activations remain necessary. The real synchronous-concurrency test holds one execution thread and requires another request on the same connection and physical owner to complete. Orleans interleaving cannot preempt synchronous work. Removing request grains failed this design review and is not part of the implementation.
 
+The follow-up active allocation profile attributes repeated list growth and component-array copies to `KeySpace.Partition`, and repeated typed serializer construction to our payload reader. Partition scope and suffix now share one encoder buffer; the reader uses Orleans' registered singleton typed serializer with an independent pooled session per decode. Literal key bytes, malformed envelopes, concurrent round trips and retained native records remain correctness gates. This is consumer API reuse, not a dependency defect or a change to storage formats.
+
 The next targets are actual access and materialization work: scalar index-range seeks, exact vector top-K and graph count/vertex projection. An active allocation profile also identified repeated catalog decoding inside our storage adapter for every candidate point read. One immutable native read operation can reuse its own resource-mode decision while validating every complete key. This introduces no cross-request metadata authority or engine cache.
 
 ## Versions relevant to the repository benchmark

docs/implementation/status.json

@@ -60378,6 +60378,50 @@
       "nonContributorReason": "required-control",
       "reviewBasis": "Direct encoded-key component-limit and malformed-input validation control; no database operation is invoked. Required ordinary control, not operation contributor."
     },
+    {
+      "className": "KeyLoad.FunctionalTests.StorageRecovery.KeySpacePartitionEncodingTests",
+      "reportClassName": "KeyLoad.FunctionalTests.StorageRecovery.KeySpacePartitionEncodingTests",
+      "methodName": "PartitionScopeKeepsLiteralBytesCaseEscapesAndEveryDynamicComponent",
+      "instanceName": "PartitionScopeKeepsLiteralBytesCaseEscapesAndEveryDynamicComponent",
+      "sourcePath": "tests/KeyLoad.FunctionalTests/StorageRecovery/Cases/KeyCodec/KeySpacePartitionEncodingTests.cs",
+      "sourceSha256": "0b4f2b2215bcf1999dfe279b44a7698977c8f9c6021c61b2a0c49a1292b0a02d",
+      "lineNumber": 14,
+      "endLineNumber": 26,
+      "classification": "required-non-contributor",
+      "exclusionReason": null,
+      "requirements": [
+        "REQ-KEYCODEC-001",
+        "REQ-KEYCODEC-003"
+      ],
+      "acceptance": [
+        "AC-KEYCODEC-001",
+        "AC-KEYCODEC-003"
+      ],
+      "nonContributorReason": "required-control",
+      "reviewBasis": "Direct partition-key byte, scope/suffix component-limit and malformed-input control; no database operation is invoked. Required ordinary control, not operation contributor."
+    },
+    {
+      "className": "KeyLoad.FunctionalTests.StorageRecovery.KeySpacePartitionEncodingTests",
+      "reportClassName": "KeyLoad.FunctionalTests.StorageRecovery.KeySpacePartitionEncodingTests",
+      "methodName": "ScopeAndSuffixShareOneComponentLimitAndPreserveOriginalRefusals",
+      "instanceName": "ScopeAndSuffixShareOneComponentLimitAndPreserveOriginalRefusals",
+      "sourcePath": "tests/KeyLoad.FunctionalTests/StorageRecovery/Cases/KeyCodec/KeySpacePartitionEncodingTests.cs",
+      "sourceSha256": "0b4f2b2215bcf1999dfe279b44a7698977c8f9c6021c61b2a0c49a1292b0a02d",
+      "lineNumber": 28,
+      "endLineNumber": 42,
+      "classification": "required-non-contributor",
+      "exclusionReason": null,
+      "requirements": [
+        "REQ-KEYCODEC-001",
+        "REQ-KEYCODEC-003"
+      ],
+      "acceptance": [
+        "AC-KEYCODEC-001",
+        "AC-KEYCODEC-003"
+      ],
+      "nonContributorReason": "required-control",
+      "reviewBasis": "Direct partition-key byte, scope/suffix component-limit and malformed-input control; no database operation is invoked. Required ordinary control, not operation contributor."
+    },
     {
       "className": "KeyLoad.FunctionalTests.StorageRecovery.NativeMvccStorageTests",
       "reportClassName": "KeyLoad.FunctionalTests.StorageRecovery.NativeMvccStorageTests",

scripts/Features/CodeQuality/functional-coverage.unit-test-inventory.json

@@ -14,6 +14,7 @@ public static class OrleansSerialization
 {
     private static readonly ServiceProvider Services = CreateServices();
     internal static Serializer Serializer { get; } = Services.GetRequiredService<Serializer>();
+    private static Serializer<RuntimePayload> PayloadSerializer { get; } = Services.GetRequiredService<Serializer<RuntimePayload>>();
     private static DeepCopier Copier { get; } = Services.GetRequiredService<DeepCopier>();
 
     /// <summary>Encodes one nonnull owned value through the generated Orleans codec.</summary>
@@ -85,7 +86,7 @@ private static RuntimePayload ReadGeneratedPayload(ReadOnlySpan<byte> value, Ser
         try
         {
             var reader = Reader.Create(value, session);
-            var payload = Serializer.GetSerializer<RuntimePayload>().Deserialize(ref reader);
+            var payload = PayloadSerializer.Deserialize(ref reader);
             if (payload is null || reader.Remaining != EmptyRemainingBytes)
             {
                 throw Errors.Fail(ErrorCode.Corruption, PayloadVersion.InvalidPayload);

src/KeyLoad.Abstractions/InternalSerialization/Serialization/OrleansSerialization.cs

@@ -17,29 +17,7 @@ public static class KeyCodec
     /// <returns>The encoded key bytes.</returns>
     /// <exception cref="KeyLoadException">A component cannot be encoded or the component count exceeds the limit.</exception>
     public static byte[] Encode(params ReadOnlySpan<KeyComponent> components)
-    {
-        if (components.Length > MaximumComponents)
-        {
-            throw Errors.Fail(ErrorCode.ResourceExhausted, TooManyComponentsMessage);
-        }
-
-        Span<byte> initial = stackalloc byte[InitialKeyBytes];
-        var writer = new KeyBufferWriter(initial);
-        try
-        {
-            writer.Write(Version);
-            foreach (ref readonly var component in components)
-            {
-                KeyCodecWritePrimitives.Write(ref writer, in component);
-            }
-
-            return writer.ToArray();
-        }
-        finally
-        {
-            writer.Dispose();
-        }
-    }
+        => Encode(components, []);
 
     /// <summary>Encodes boxed components into a version 1 sortable binary key; the bytes equal the typed overload's.</summary>
     /// <param name="components">The key components, in their comparison order.</param>
@@ -49,7 +27,13 @@ public static byte[] Encode(params ReadOnlySpan<KeyComponent> components)
     public static byte[] Encode(object?[] components)
     {
         ArgumentNullException.ThrowIfNull(components);
-        if (components.Length > MaximumComponents)
+        return Encode([], components);
+    }
+
+    /// <summary>Writes a typed scope and dynamic components directly into the same canonical key buffer.</summary>
+    internal static byte[] Encode(ReadOnlySpan<KeyComponent> prefix, ReadOnlySpan<object?> suffix)
+    {
+        if (prefix.Length > MaximumComponents || suffix.Length > MaximumComponents - prefix.Length)
         {
             throw Errors.Fail(ErrorCode.ResourceExhausted, TooManyComponentsMessage);
         }
@@ -59,7 +43,11 @@ public static byte[] Encode(object?[] components)
         try
         {
             writer.Write(Version);
-            foreach (var component in components)
+            foreach (ref readonly var component in prefix)
+            {
+                KeyCodecWritePrimitives.Write(ref writer, in component);
+            }
+            foreach (var component in suffix)
             {
                 var typed = KeyComponent.From(component);
                 KeyCodecWritePrimitives.Write(ref writer, in typed);

src/KeyLoad.Abstractions/Storage/Serialization/KeyCodec.cs

@@ -41,7 +41,7 @@ public static byte[] Partition(string space, PartitionRef partition, params obje
         ArgumentNullException.ThrowIfNull(partition);
         ArgumentNullException.ThrowIfNull(suffix);
         return KeyCodec.Encode([space, partition.TenantId, partition.DatabaseId,
-            partition.TransactionDomainId, partition.PartitionKey, .. suffix]);
+            partition.TransactionDomainId, partition.PartitionKey], suffix);
     }
 
     /// <summary>Creates an owned resource-catalog key within a tenant and database.</summary>

src/KeyLoad.Core/KeySpace.cs

@@ -0,0 +1,43 @@
+using KeyLoad.Storage;
+
+namespace KeyLoad.FunctionalTests.StorageRecovery;
+
+internal sealed class KeySpacePartitionEncodingTests
+{
+    private const string Space = "document";
+    private const string PartitionKey = "Case";
+    private const int MaximumComponents = 256;
+    private const int ScopeComponents = 5;
+    private const string LiteralKey = "0150646F63756D656E7400005074656E616E740000506461746162617365000050646F6D61696E000050436173650000506974656D73000050494400FFC3A90000";
+    private static readonly PartitionRef Partition = new("tenant", "database", "domain", PartitionKey);
+
+    [Test]
+    public async Task PartitionScopeKeepsLiteralBytesCaseEscapesAndEveryDynamicComponent()
+    {
+        await Assert.That(KeySpace.Partition(Space, Partition, "items", "ID\0é")
+            .SequenceEqual(Convert.FromHexString(LiteralKey))).IsTrue();
+        object?[] suffix = ["items", long.MinValue, 1.25m, double.MaxValue, DateTimeOffset.MaxValue,
+            Guid.Parse("01234567-89ab-cdef-0123-456789abcdef"), true, null, MissingValue.Instance, new byte[] { 0, 255 }];
+        object?[] complete = [Space, "tenant", "database", "domain", PartitionKey, .. suffix];
+        var actual = KeySpace.Partition(Space, Partition, suffix);
+        await Assert.That(actual.SequenceEqual(KeyCodec.Encode(complete))).IsTrue();
+        KeyCodecValidation.Validate(actual);
+        await Assert.That(KeyCodec.Decode(actual).Length).IsEqualTo(ScopeComponents + suffix.Length);
+    }
+
+    [Test]
+    public async Task ScopeAndSuffixShareOneComponentLimitAndPreserveOriginalRefusals()
+    {
+        object?[] suffix = [.. Enumerable.Repeat<object?>(MissingValue.Instance, MaximumComponents - ScopeComponents)];
+        var maximum = KeySpace.Partition(Space, Partition, suffix);
+        await Assert.That(KeyCodec.Decode(maximum).Length).IsEqualTo(MaximumComponents);
+        var excessive = Assert.ThrowsExactly<KeyLoadException>(() => KeySpace.Partition(Space, Partition, [.. suffix, null]));
+        await Assert.That(excessive.Code).IsEqualTo(ErrorCode.ResourceExhausted);
+        var unsupported = Assert.ThrowsExactly<KeyLoadException>(() => KeySpace.Partition(Space, Partition, new object()));
+        await Assert.That(unsupported.Code).IsEqualTo(ErrorCode.UnsupportedCapability);
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => KeySpace.Partition(Space, null!, suffix));
+        _ = Assert.ThrowsExactly<ArgumentNullException>(() => KeySpace.Partition(Space, Partition, (object?[])null!));
+        await Assert.That(KeySpace.Partition(Space, Partition, "items", "ID\0é")
+            .SequenceEqual(Convert.FromHexString(LiteralKey))).IsTrue();
+    }
+}