@rootzero/contracts 0.9.2 → 0.9.4

package/blocks/Writers.sol

@@ -12,15 +12,22 @@ struct Writer {
     uint i;
     /// @dev Logical buffer capacity in bytes; writers should not advance past this limit.
     uint end;
+    /// @dev Whether append helpers may expand the backing buffer when more capacity is needed.
+    bool growable;
     /// @dev Destination buffer. Physical capacity may be padded up to a full 32-byte word;
     ///      final length is set to `i` by `finish`.
     bytes dst;
 }
 
-// Fixed-point scaling denominator for output-count allocation.
-// A `scaledRatio` of `ALLOC_SCALE` means 1:1 (one output block per input block).
-// `2 * ALLOC_SCALE` means 2:1; non-integer ratios revert with `BadWriterRatio`.
-uint constant ALLOC_SCALE = 10_000;
+/// @title Hints
+/// @notice Initial per-block capacity estimates for growable writers.
+library Hints {
+    uint constant Any = 128;
+    uint constant Bytes = 128;
+    uint constant Step = 256;
+    uint constant Call = 256;
+    uint constant Context = 512;
+}
 
 /// @title Writers
 /// @notice Response block stream builder for the rootzero protocol.
@@ -36,8 +43,6 @@ library Writers {
     error IncompleteWriter();
     /// @dev An alloc function received a zero count, or `finish` found no bytes written.
     error EmptyRequest();
-    /// @dev `scaledRatio * count` is not evenly divisible by `ALLOC_SCALE`.
-    error BadWriterRatio();
     /// @dev A fixed-width low-level writer received an invalid final-word keep length.
     error InvalidKeep();
 
@@ -54,25 +59,35 @@ library Writers {
         // Extra 32 bytes ensure mstore in write/append32 never reaches past allocated memory,
         // even when a sub-word packed write starts within the last 31 bytes of the logical region.
         uint padded = ((len + 31) & ~uint(31)) + 32;
-        writer = Writer({i: 0, end: len, dst: new bytes(padded)});
+        writer = Writer({i: 0, end: len, growable: false, dst: new bytes(padded)});
+    }
+
+    /// @notice Allocate a growable writer with an initial logical byte capacity.
+    /// @param hint Initial logical byte capacity to allocate.
+    /// @return writer Freshly allocated growable writer positioned at index 0.
+    function dynamic(uint hint) internal pure returns (Writer memory writer) {
+        writer = alloc(hint);
+        writer.growable = true;
     }
 
     /// @notice Core allocation routine used by all counted `alloc*` helpers.
-    /// Computes `(count * scaledRatio / ALLOC_SCALE) * blockLen` and allocates that many bytes.
-    /// @param count Number of input blocks.
-    /// @param scaledRatio Output-to-input ratio in `ALLOC_SCALE` units.
+    /// Computes `count * blockLen` and allocates that many bytes.
+    /// @param count Number of output blocks.
     /// @param blockLen Logical byte size of each output block (including 8-byte header).
     /// @return writer Allocated writer.
-    function allocFromScaledCount(
-        uint count,
-        uint scaledRatio,
-        uint blockLen
-    ) internal pure returns (Writer memory writer) {
+    function allocFromCount(uint count, uint blockLen) internal pure returns (Writer memory writer) {
         if (count == 0) revert EmptyRequest();
-        uint scaledCount = count * scaledRatio;
-        if (scaledCount % ALLOC_SCALE != 0) revert BadWriterRatio();
-        uint len = (scaledCount / ALLOC_SCALE) * blockLen;
-        writer = alloc(len);
+        writer = alloc(count * blockLen);
+    }
+
+    /// @notice Core allocation routine used by counted growable `alloc*` helpers.
+    /// Computes `count * hint` and allocates an expandable writer with that initial capacity.
+    /// @param count Number of output blocks.
+    /// @param hint Initial logical byte capacity per output block.
+    /// @return writer Allocated growable writer.
+    function allocFromHint(uint count, uint hint) internal pure returns (Writer memory writer) {
+        if (count == 0) revert EmptyRequest();
+        writer = dynamic(count * hint);
     }
 
     /// @notice Allocate a writer sized for exactly `count` dynamic blocks with a shared payload length.
@@ -81,180 +96,131 @@ library Writers {
     /// @param payloadLen Payload byte length for each block.
     /// @return writer Allocated writer.
     function allocBytes(uint count, uint payloadLen) internal pure returns (Writer memory writer) {
-        return allocFromScaledCount(count, ALLOC_SCALE, Sizes.Header + payloadLen);
+        return allocFromCount(count, Sizes.Header + payloadLen);
+    }
+
+    /// @notice Allocate a writer for `count` variable-sized blocks using a per-block capacity hint.
+    /// @dev The backing buffer expands automatically if encoded blocks exceed the initial hint.
+    /// @param count Number of blocks to allocate space for.
+    /// @return writer Allocated growable writer.
+    function allocAny(uint count) internal pure returns (Writer memory writer) {
+        return allocFromHint(count, Hints.Any);
+    }
+
+    /// @notice Allocate a writer for `count` BYTES blocks using a per-block capacity hint.
+    /// @dev The backing buffer expands automatically if encoded bytes blocks exceed the initial hint.
+    /// @param count Number of bytes blocks to allocate space for.
+    /// @return writer Allocated growable writer.
+    function allocBytes(uint count) internal pure returns (Writer memory writer) {
+        return allocFromHint(count, Hints.Bytes);
     }
 
-    /// @notice Allocate a writer sized for exactly `count` 32-byte-payload blocks (1:1 ratio).
+    /// @notice Allocate a writer sized for exactly `count` 32-byte-payload blocks.
     /// @param count Number of blocks to allocate space for.
     /// @return writer Allocated writer.
     function alloc32s(uint count) internal pure returns (Writer memory writer) {
-        return allocFromScaledCount(count, ALLOC_SCALE, Sizes.B32);
+        return allocFromCount(count, Sizes.B32);
     }
 
-    /// @notice Allocate a writer sized for exactly `count` 64-byte-payload blocks (1:1 ratio).
+    /// @notice Allocate a writer sized for exactly `count` 64-byte-payload blocks.
     /// @param count Number of blocks to allocate space for.
     /// @return writer Allocated writer.
     function alloc64s(uint count) internal pure returns (Writer memory writer) {
-        return allocFromScaledCount(count, ALLOC_SCALE, Sizes.B64);
+        return allocFromCount(count, Sizes.B64);
     }
 
-    /// @notice Allocate a writer sized for exactly `count` 96-byte-payload blocks (1:1 ratio).
+    /// @notice Allocate a writer sized for exactly `count` 96-byte-payload blocks.
     /// @param count Number of blocks to allocate space for.
     /// @return writer Allocated writer.
     function alloc96s(uint count) internal pure returns (Writer memory writer) {
-        return allocFromScaledCount(count, ALLOC_SCALE, Sizes.B96);
+        return allocFromCount(count, Sizes.B96);
     }
 
-    /// @notice Allocate a writer sized for exactly `count` 128-byte-payload blocks (1:1 ratio).
+    /// @notice Allocate a writer sized for exactly `count` 128-byte-payload blocks.
     /// @param count Number of blocks to allocate space for.
     /// @return writer Allocated writer.
     function alloc128s(uint count) internal pure returns (Writer memory writer) {
-        return allocFromScaledCount(count, ALLOC_SCALE, Sizes.B128);
+        return allocFromCount(count, Sizes.B128);
     }
 
-    /// @notice Allocate a writer sized for exactly `count` 160-byte-payload blocks (1:1 ratio).
+    /// @notice Allocate a writer sized for exactly `count` 160-byte-payload blocks.
     /// @param count Number of blocks to allocate space for.
     /// @return writer Allocated writer.
     function alloc160s(uint count) internal pure returns (Writer memory writer) {
-        return allocFromScaledCount(count, ALLOC_SCALE, Sizes.B160);
-    }
-
-    /// @notice Allocate a writer for dynamic blocks with a shared payload length and custom output ratio.
-    /// Each block reserves `Sizes.Header + payloadLen` bytes.
-    /// @param count Number of input blocks.
-    /// @param scaledRatio Output count multiplier expressed in `ALLOC_SCALE` units.
-    /// @param payloadLen Payload byte length for each block.
-    /// @return writer Allocated writer.
-    function allocScaledBytes(
-        uint count,
-        uint scaledRatio,
-        uint payloadLen
-    ) internal pure returns (Writer memory writer) {
-        return allocFromScaledCount(count, scaledRatio, Sizes.Header + payloadLen);
-    }
-
-    /// @notice Allocate a writer for 32-byte-payload blocks with a custom output-to-input ratio.
-    /// @param count Number of input blocks.
-    /// @param scaledRatio Output count multiplier expressed in `ALLOC_SCALE` units.
-    /// @return writer Allocated writer.
-    function allocScaled32s(uint count, uint scaledRatio) internal pure returns (Writer memory writer) {
-        return allocFromScaledCount(count, scaledRatio, Sizes.B32);
-    }
-
-    /// @notice Allocate a writer for 64-byte-payload blocks with a custom output-to-input ratio.
-    /// @param count Number of input blocks.
-    /// @param scaledRatio Output count multiplier expressed in `ALLOC_SCALE` units.
-    /// @return writer Allocated writer.
-    function allocScaled64s(uint count, uint scaledRatio) internal pure returns (Writer memory writer) {
-        return allocFromScaledCount(count, scaledRatio, Sizes.B64);
-    }
-
-    /// @notice Allocate a writer for 96-byte-payload blocks with a custom output-to-input ratio.
-    /// @param count Number of input blocks.
-    /// @param scaledRatio Output count multiplier expressed in `ALLOC_SCALE` units.
-    /// @return writer Allocated writer.
-    function allocScaled96s(uint count, uint scaledRatio) internal pure returns (Writer memory writer) {
-        return allocFromScaledCount(count, scaledRatio, Sizes.B96);
-    }
-
-    /// @notice Allocate a writer for 128-byte-payload blocks with a custom output-to-input ratio.
-    /// @param count Number of input blocks.
-    /// @param scaledRatio Output count multiplier expressed in `ALLOC_SCALE` units.
-    /// @return writer Allocated writer.
-    function allocScaled128s(uint count, uint scaledRatio) internal pure returns (Writer memory writer) {
-        return allocFromScaledCount(count, scaledRatio, Sizes.B128);
-    }
-
-    /// @notice Allocate a writer for 160-byte-payload blocks with a custom output-to-input ratio.
-    /// @param count Number of input blocks.
-    /// @param scaledRatio Output count multiplier expressed in `ALLOC_SCALE` units.
-    /// @return writer Allocated writer.
-    function allocScaled160s(uint count, uint scaledRatio) internal pure returns (Writer memory writer) {
-        return allocFromScaledCount(count, scaledRatio, Sizes.B160);
+        return allocFromCount(count, Sizes.B160);
     }
 
     /// @notice Allocate a writer sized for exactly `count` STATUS form blocks.
     /// @param count Number of blocks to allocate space for.
     /// @return writer Allocated writer.
     function allocStatuses(uint count) internal pure returns (Writer memory writer) {
-        return alloc32s(count);
+        return allocFromCount(count, Sizes.Status);
     }
 
-    /// @notice Allocate a writer sized for exactly `count` ASSET blocks (1:1 ratio).
+    /// @notice Allocate a writer sized for exactly `count` ASSET blocks.
     /// @param count Number of asset blocks to allocate space for.
     /// @return writer Allocated writer.
     function allocAssets(uint count) internal pure returns (Writer memory writer) {
         return alloc64s(count);
     }
 
-    /// @notice Allocate a writer sized for exactly `count` AMOUNT blocks (1:1 ratio).
+    /// @notice Allocate a writer sized for exactly `count` AMOUNT blocks.
     /// @param count Number of amount blocks to allocate space for.
     /// @return writer Allocated writer.
     function allocAmounts(uint count) internal pure returns (Writer memory writer) {
         return alloc96s(count);
     }
 
-    /// @notice Allocate a writer sized for exactly `count` BALANCE blocks (1:1 ratio).
+    /// @notice Allocate a writer sized for exactly `count` BALANCE blocks.
     /// @param count Number of balance blocks to allocate space for.
     /// @return writer Allocated writer.
     function allocBalances(uint count) internal pure returns (Writer memory writer) {
         return alloc96s(count);
     }
 
-    /// @notice Allocate a writer sized for exactly `count` ACCOUNT_AMOUNT form blocks (1:1 ratio).
+    /// @notice Allocate a writer sized for exactly `count` ACCOUNT_AMOUNT form blocks.
     /// @param count Number of account amount blocks to allocate space for.
     /// @return writer Allocated writer.
     function allocAccountAmounts(uint count) internal pure returns (Writer memory writer) {
         return alloc128s(count);
     }
 
-    /// @notice Allocate a writer sized for exactly `count` CUSTODY blocks (1:1 ratio).
+    /// @notice Allocate a writer sized for exactly `count` CUSTODY blocks.
     /// @param count Number of custody blocks to allocate space for.
     /// @return writer Allocated writer.
     function allocCustodies(uint count) internal pure returns (Writer memory writer) {
         return alloc128s(count);
     }
 
-    /// @notice Allocate a writer sized for exactly `count` TRANSACTION blocks (1:1 ratio).
+    /// @notice Allocate a writer sized for exactly `count` TRANSACTION blocks.
     /// @param count Number of transaction blocks to allocate space for.
     /// @return writer Allocated writer.
     function allocTransactions(uint count) internal pure returns (Writer memory writer) {
         return alloc160s(count);
     }
 
-    /// @notice Allocate a writer for ASSET blocks with a custom output-to-input ratio.
-    /// @param count Number of input blocks.
-    /// @param scaledRatio Output count multiplier expressed in `ALLOC_SCALE` units
-    ///        (e.g. `ALLOC_SCALE` = 1:1, `2 * ALLOC_SCALE` = 2:1).
-    /// @return writer Allocated writer.
-    function allocScaledAssets(uint count, uint scaledRatio) internal pure returns (Writer memory writer) {
-        return allocScaled64s(count, scaledRatio);
+    /// @notice Allocate a writer for `count` STEP blocks using a per-block capacity hint.
+    /// @dev The backing buffer expands automatically if encoded steps exceed the initial hint.
+    /// @param count Number of step blocks to allocate space for.
+    /// @return writer Allocated growable writer.
+    function allocSteps(uint count) internal pure returns (Writer memory writer) {
+        return allocFromHint(count, Hints.Step);
     }
 
-    /// @notice Allocate a writer for AMOUNT blocks with a custom output-to-input ratio.
-    /// @param count Number of input blocks.
-    /// @param scaledRatio Output count multiplier expressed in `ALLOC_SCALE` units
-    ///        (e.g. `ALLOC_SCALE` = 1:1, `2 * ALLOC_SCALE` = 2:1).
-    /// @return writer Allocated writer.
-    function allocScaledAmounts(uint count, uint scaledRatio) internal pure returns (Writer memory writer) {
-        return allocScaled96s(count, scaledRatio);
+    /// @notice Allocate a writer for `count` CALL blocks using a per-block capacity hint.
+    /// @dev The backing buffer expands automatically if encoded calls exceed the initial hint.
+    /// @param count Number of call blocks to allocate space for.
+    /// @return writer Allocated growable writer.
+    function allocCalls(uint count) internal pure returns (Writer memory writer) {
+        return allocFromHint(count, Hints.Call);
     }
 
-    /// @notice Allocate a writer for BALANCE blocks with a custom output-to-input ratio.
-    /// @param count Number of input blocks.
-    /// @param scaledRatio Output count multiplier expressed in `ALLOC_SCALE` units
-    ///        (e.g. `ALLOC_SCALE` = 1:1, `2 * ALLOC_SCALE` = 2:1).
-    /// @return writer Allocated writer.
-    function allocScaledBalances(uint count, uint scaledRatio) internal pure returns (Writer memory writer) {
-        return allocScaled96s(count, scaledRatio);
-    }
-
-    /// @notice Allocate a writer for CUSTODY blocks with a custom output-to-input ratio.
-    /// @param count Number of input blocks.
-    /// @param scaledRatio Output count multiplier in `ALLOC_SCALE` units.
-    /// @return writer Allocated writer.
-    function allocScaledCustodies(uint count, uint scaledRatio) internal pure returns (Writer memory writer) {
-        return allocScaled128s(count, scaledRatio);
+    /// @notice Allocate a writer for `count` CONTEXT blocks using a per-block capacity hint.
+    /// @dev The backing buffer expands automatically if encoded contexts exceed the initial hint.
+    /// @param count Number of context blocks to allocate space for.
+    /// @return writer Allocated growable writer.
+    function allocContexts(uint count) internal pure returns (Writer memory writer) {
+        return allocFromHint(count, Hints.Context);
     }
 
     // -------------------------------------------------------------------------
@@ -276,14 +242,6 @@ library Writers {
         }
     }
 
-    /// @notice Commit a logical writer advance after a low-level write.
-    /// @dev Low-level write helpers validate the padded backing buffer. This
-    ///      enforces the caller-requested logical capacity recorded in `end`.
-    function commit(Writer memory writer, uint next) private pure {
-        if (next > writer.end) revert WriterOverflow();
-        writer.i = next;
-    }
-
     /// @notice Write raw bytes directly into `dst` at byte offset `i` without a block header.
     /// @param dst Destination buffer.
     /// @param i Write offset within `dst`.
@@ -535,57 +493,160 @@ library Writers {
         }
     }
 
-    /// @notice Write a dynamic block with a fixed 32-byte head word.
-    /// @param dst Destination buffer; must have at least `i + Sizes.B32 + tail.length` bytes.
+    /// @notice Write a block with a 32-byte head and two nested BYTES payloads.
+    /// @param dst Destination buffer; must have at least `i + Sizes.B32 + 2 * Sizes.Header + b.length + c.length` bytes.
     /// @param i Write offset within `dst`.
-    /// @param key Block type key.
+    /// @param key Block key.
     /// @param a Fixed head word.
-    /// @param tail Dynamic payload bytes appended after the head.
+    /// @param b First raw nested payload.
+    /// @param c Second raw nested payload.
     /// @return next Byte offset immediately after the written block.
-    function writeBlockHead32(
+    function writeBlock32BytesBytes(
         bytes memory dst,
         uint i,
         bytes4 key,
         bytes32 a,
-        bytes memory tail
+        bytes memory b,
+        bytes memory c
     ) internal pure returns (uint next) {
-        uint len = 32 + tail.length;
+        uint bLen = b.length;
+        uint len = 32 + 2 * Sizes.Header + bLen + c.length;
         next = i + Sizes.Header + len;
-        if (i + Sizes.B32 + tail.length > dst.length) revert WriterOverflow();
-        uint p = writeHeader(dst, i, key, uint32(max32(len)));
-        assembly ("memory-safe") {
-            mstore(add(p, 0x08), a)
-            mcopy(add(p, 0x28), add(tail, 0x20), mload(tail))
+        if (next > dst.length) revert WriterOverflow();
+
+        {
+            uint p = writeHeader(dst, i, key, uint32(max32(len)));
+            assembly ("memory-safe") {
+                mstore(add(p, 0x08), a)
+            }
+        }
+
+        {
+            uint q = writeHeader(dst, i + Sizes.Header + 32, Keys.Bytes, uint32(max32(bLen)));
+            assembly ("memory-safe") {
+                mcopy(add(q, 0x08), add(b, 0x20), mload(b))
+            }
+        }
+
+        {
+            uint r = writeHeader(dst, i + Sizes.Header + 32 + Sizes.Header + bLen, Keys.Bytes, uint32(max32(c.length)));
+            assembly ("memory-safe") {
+                mcopy(add(r, 0x08), add(c, 0x20), mload(c))
+            }
         }
     }
 
-    /// @notice Write a dynamic block with a fixed 64-byte head.
-    /// @param dst Destination buffer; must have at least `i + Sizes.B64 + tail.length` bytes.
+    /// @notice Write a block with a 64-byte head and two nested BYTES payloads.
+    /// @param dst Destination buffer; must have at least `i + Sizes.B64 + 2 * Sizes.Header + c.length + d.length` bytes.
     /// @param i Write offset within `dst`.
-    /// @param key Block type key.
-    /// @param a First fixed head word.
-    /// @param b Second fixed head word.
-    /// @param tail Dynamic payload bytes appended after the head.
+    /// @param key Block key.
+    /// @param a First head word.
+    /// @param b Second head word.
+    /// @param c First raw nested payload.
+    /// @param d Second raw nested payload.
     /// @return next Byte offset immediately after the written block.
-    function writeBlockHead64(
+    function writeBlock64BytesBytes(
         bytes memory dst,
         uint i,
         bytes4 key,
         bytes32 a,
         bytes32 b,
-        bytes memory tail
+        bytes memory c,
+        bytes memory d
     ) internal pure returns (uint next) {
-        uint len = 64 + tail.length;
+        uint cLen = c.length;
+        uint len = 64 + 2 * Sizes.Header + cLen + d.length;
         next = i + Sizes.Header + len;
-        if (i + Sizes.B64 + tail.length > dst.length) revert WriterOverflow();
-        uint p = writeHeader(dst, i, key, uint32(max32(len)));
-        assembly ("memory-safe") {
-            mstore(add(p, 0x08), a)
-            mstore(add(p, 0x28), b)
-            mcopy(add(p, 0x48), add(tail, 0x20), mload(tail))
+        if (next > dst.length) revert WriterOverflow();
+
+        {
+            uint p = writeHeader(dst, i, key, uint32(max32(len)));
+            assembly ("memory-safe") {
+                mstore(add(p, 0x08), a)
+                mstore(add(p, 0x28), b)
+            }
+        }
+
+        {
+            uint q = writeHeader(dst, i + Sizes.Header + 64, Keys.Bytes, uint32(max32(cLen)));
+            assembly ("memory-safe") {
+                mcopy(add(q, 0x08), add(c, 0x20), mload(c))
+            }
+        }
+
+        {
+            uint r = writeHeader(dst, i + Sizes.Header + 64 + Sizes.Header + cLen, Keys.Bytes, uint32(max32(d.length)));
+            assembly ("memory-safe") {
+                mcopy(add(r, 0x08), add(d, 0x20), mload(d))
+            }
         }
     }
 
+    /// @notice Write a block with a 64-byte head and nested BYTES payload.
+    /// @param dst Destination buffer; must have at least `i + Sizes.B64 + Sizes.Header + c.length` bytes.
+    /// @param i Write offset within `dst`.
+    /// @param key Block key.
+    /// @param a First head word.
+    /// @param b Second head word.
+    /// @param c Raw nested payload.
+    /// @return next Byte offset immediately after the written block.
+    function writeBlock64Bytes(
+        bytes memory dst,
+        uint i,
+        bytes4 key,
+        bytes32 a,
+        bytes32 b,
+        bytes memory c
+    ) internal pure returns (uint next) {
+        uint cLen = c.length;
+        uint len = 64 + Sizes.Header + cLen;
+        next = i + Sizes.Header + len;
+        if (next > dst.length) revert WriterOverflow();
+
+        {
+            uint p = writeHeader(dst, i, key, uint32(max32(len)));
+            assembly ("memory-safe") {
+                mstore(add(p, 0x08), a)
+                mstore(add(p, 0x28), b)
+            }
+        }
+
+        {
+            uint q = writeHeader(dst, i + Sizes.Header + 64, Keys.Bytes, uint32(max32(cLen)));
+            assembly ("memory-safe") {
+                mcopy(add(q, 0x08), add(c, 0x20), mload(c))
+            }
+        }
+    }
+
+    /// @notice Reserve physical write space and advance the logical writer position.
+    /// Fixed writers may use padded backing space but cannot advance past logical capacity;
+    /// growable writers expand when `touch` exceeds current capacity.
+    /// @return i Original write offset.
+    function reserve(Writer memory writer, uint next, uint touch) private pure returns (uint i) {
+        i = writer.i;
+        if (writer.growable) {
+            if (touch > writer.end) {
+                uint end = writer.end == 0 ? 64 : writer.end * 2;
+                while (end < touch) {
+                    end *= 2;
+                }
+
+                uint padded = ((end + 31) & ~uint(31)) + 32;
+                bytes memory src = writer.dst;
+                bytes memory dst = new bytes(padded);
+                assembly ("memory-safe") {
+                    mcopy(add(dst, 0x20), add(src, 0x20), i)
+                }
+                writer.end = end;
+                writer.dst = dst;
+            }
+        } else if (touch > writer.dst.length) revert WriterOverflow();
+
+        if (next > writer.end) revert WriterOverflow();
+        writer.i = next;
+    }
+
     // -------------------------------------------------------------------------
     // Append helpers
     // -------------------------------------------------------------------------
@@ -594,7 +655,9 @@ library Writers {
     /// @param writer Destination writer; `i` is advanced by `data.length`.
     /// @param data Bytes to append.
     function append(Writer memory writer, bytes memory data) internal pure {
-        commit(writer, write(writer.dst, writer.i, data));
+        uint next = writer.i + data.length;
+        uint i = reserve(writer, next, next);
+        write(writer.dst, i, data);
     }
 
     /// @notice Append a raw 32-byte word without a block header.
@@ -602,7 +665,10 @@ library Writers {
     /// @param value Word to append.
     /// @param keep Number of bytes to keep from the word (1..32).
     function append32(Writer memory writer, bytes32 value, uint keep) internal pure {
-        commit(writer, write32(writer.dst, writer.i, value, keep));
+        uint i = writer.i;
+        uint next = i + keep;
+        i = reserve(writer, next, i + 32);
+        write32(writer.dst, i, value, keep);
     }
 
     /// @notice Append two raw 32-byte words without a block header.
@@ -611,7 +677,10 @@ library Writers {
     /// @param b Second word to append.
     /// @param keep Number of bytes to keep from the final word (1..32).
     function append64(Writer memory writer, bytes32 a, bytes32 b, uint keep) internal pure {
-        commit(writer, write64(writer.dst, writer.i, a, b, keep));
+        uint i = writer.i;
+        uint next = i + 32 + keep;
+        i = reserve(writer, next, i + 64);
+        write64(writer.dst, i, a, b, keep);
     }
 
     /// @notice Append three raw 32-byte words without a block header.
@@ -621,7 +690,10 @@ library Writers {
     /// @param c Third word to append.
     /// @param keep Number of bytes to keep from the final word (1..32).
     function append96(Writer memory writer, bytes32 a, bytes32 b, bytes32 c, uint keep) internal pure {
-        commit(writer, write96(writer.dst, writer.i, a, b, c, keep));
+        uint i = writer.i;
+        uint next = i + 64 + keep;
+        i = reserve(writer, next, i + 96);
+        write96(writer.dst, i, a, b, c, keep);
     }
 
     /// @notice Append a dynamic block.
@@ -629,7 +701,9 @@ library Writers {
     /// @param key Block type key.
     /// @param data Dynamic payload bytes.
     function appendBlock(Writer memory writer, bytes4 key, bytes memory data) internal pure {
-        commit(writer, writeBlock(writer.dst, writer.i, key, data));
+        uint next = writer.i + Sizes.Header + data.length;
+        uint i = reserve(writer, next, next);
+        writeBlock(writer.dst, i, key, data);
     }
 
     /// @notice Append a fixed-width 32-byte-payload block.
@@ -638,7 +712,10 @@ library Writers {
     /// @param a First payload word.
     /// @param keep Number of bytes to keep from the final payload word (1..32).
     function appendBlock32(Writer memory writer, bytes4 key, bytes32 a, uint keep) internal pure {
-        commit(writer, writeBlock32(writer.dst, writer.i, key, a, keep));
+        uint i = writer.i;
+        uint next = i + Sizes.Header + keep;
+        i = reserve(writer, next, i + Sizes.B32);
+        writeBlock32(writer.dst, i, key, a, keep);
     }
 
     /// @notice Append a fixed-width 64-byte-payload block.
@@ -648,7 +725,10 @@ library Writers {
     /// @param b Second payload word.
     /// @param keep Number of bytes to keep from the final payload word (1..32).
     function appendBlock64(Writer memory writer, bytes4 key, bytes32 a, bytes32 b, uint keep) internal pure {
-        commit(writer, writeBlock64(writer.dst, writer.i, key, a, b, keep));
+        uint i = writer.i;
+        uint next = i + Sizes.Header + 32 + keep;
+        i = reserve(writer, next, i + Sizes.B64);
+        writeBlock64(writer.dst, i, key, a, b, keep);
     }
 
     /// @notice Append a fixed-width 96-byte-payload block.
@@ -659,7 +739,10 @@ library Writers {
     /// @param c Third payload word.
     /// @param keep Number of bytes to keep from the final payload word (1..32).
     function appendBlock96(Writer memory writer, bytes4 key, bytes32 a, bytes32 b, bytes32 c, uint keep) internal pure {
-        commit(writer, writeBlock96(writer.dst, writer.i, key, a, b, c, keep));
+        uint i = writer.i;
+        uint next = i + Sizes.Header + 64 + keep;
+        i = reserve(writer, next, i + Sizes.B96);
+        writeBlock96(writer.dst, i, key, a, b, c, keep);
     }
 
     /// @notice Append a fixed-width 128-byte-payload block.
@@ -679,7 +762,10 @@ library Writers {
         bytes32 d,
         uint keep
     ) internal pure {
-        commit(writer, writeBlock128(writer.dst, writer.i, key, a, b, c, d, keep));
+        uint i = writer.i;
+        uint next = i + Sizes.Header + 96 + keep;
+        i = reserve(writer, next, i + Sizes.B128);
+        writeBlock128(writer.dst, i, key, a, b, c, d, keep);
     }
 
     /// @notice Append a fixed-width 160-byte-payload block.
@@ -701,39 +787,111 @@ library Writers {
         bytes32 e,
         uint keep
     ) internal pure {
-        commit(writer, writeBlock160(writer.dst, writer.i, key, a, b, c, d, e, keep));
+        uint i = writer.i;
+        uint next = i + Sizes.Header + 128 + keep;
+        i = reserve(writer, next, i + Sizes.B160);
+        writeBlock160(writer.dst, i, key, a, b, c, d, e, keep);
     }
 
-    /// @notice Append a dynamic block with a fixed 32-byte head word.
-    /// @param writer Destination writer; `i` is advanced by `Sizes.B32 + tail.length`.
-    /// @param key Block type key.
+    /// @notice Append a block with a 32-byte head and two nested BYTES payloads.
+    /// @param writer Destination writer; `i` is advanced by the encoded block length.
+    /// @param key Block key.
     /// @param a Fixed head word.
-    /// @param tail Dynamic payload bytes appended after the head.
-    function appendBlockHead32(Writer memory writer, bytes4 key, bytes32 a, bytes memory tail) internal pure {
-        commit(writer, writeBlockHead32(writer.dst, writer.i, key, a, tail));
-    }
-
-    /// @notice Append a dynamic block with a fixed 64-byte head.
-    /// @param writer Destination writer; `i` is advanced by `Sizes.B64 + tail.length`.
-    /// @param key Block type key.
-    /// @param a First fixed head word.
-    /// @param b Second fixed head word.
-    /// @param tail Dynamic payload bytes appended after the head.
-    function appendBlockHead64(
+    /// @param b First raw nested payload.
+    /// @param c Second raw nested payload.
+    function appendBlock32BytesBytes(
+        Writer memory writer,
+        bytes4 key,
+        bytes32 a,
+        bytes memory b,
+        bytes memory c
+    ) internal pure {
+        uint i = writer.i;
+        uint next = i + Sizes.B32 + 2 * Sizes.Header + b.length + c.length;
+        i = reserve(writer, next, next);
+        writeBlock32BytesBytes(writer.dst, i, key, a, b, c);
+    }
+
+    /// @notice Append a block with a 64-byte head and two nested BYTES payloads.
+    /// @param writer Destination writer; `i` is advanced by the encoded block length.
+    /// @param key Block key.
+    /// @param a First head word.
+    /// @param b Second head word.
+    /// @param c First raw nested payload.
+    /// @param d Second raw nested payload.
+    function appendBlock64BytesBytes(
         Writer memory writer,
         bytes4 key,
         bytes32 a,
         bytes32 b,
-        bytes memory tail
+        bytes memory c,
+        bytes memory d
+    ) internal pure {
+        uint i = writer.i;
+        uint next = i + Sizes.B64 + 2 * Sizes.Header + c.length + d.length;
+        i = reserve(writer, next, next);
+        writeBlock64BytesBytes(writer.dst, i, key, a, b, c, d);
+    }
+
+    /// @notice Append a block with a 64-byte head and nested BYTES payload.
+    /// @param writer Destination writer; `i` is advanced by the encoded block length.
+    /// @param key Block key.
+    /// @param a First head word.
+    /// @param b Second head word.
+    /// @param c Raw nested payload.
+    function appendBlock64Bytes(Writer memory writer, bytes4 key, bytes32 a, bytes32 b, bytes memory c) internal pure {
+        uint i = writer.i;
+        uint next = i + Sizes.B64 + Sizes.Header + c.length;
+        i = reserve(writer, next, next);
+        writeBlock64Bytes(writer.dst, i, key, a, b, c);
+    }
+
+    /// @notice Append a BYTES block.
+    /// @param writer Destination writer; `i` is advanced by the encoded BYTES block length.
+    /// @param data Raw bytes payload.
+    function appendBytes(Writer memory writer, bytes memory data) internal pure {
+        appendBlock(writer, Keys.Bytes, data);
+    }
+
+    /// @notice Append a STEP block with a nested request BYTES payload.
+    /// @param writer Destination writer; `i` is advanced by the encoded STEP block length.
+    /// @param target Command target identifier.
+    /// @param value Native value forwarded with the step.
+    /// @param request Raw nested request payload.
+    function appendStep(Writer memory writer, uint target, uint value, bytes memory request) internal pure {
+        appendBlock64Bytes(writer, Keys.Step, bytes32(target), bytes32(value), request);
+    }
+
+    /// @notice Append a CALL block with a nested payload BYTES block.
+    /// @param writer Destination writer; `i` is advanced by the encoded CALL block length.
+    /// @param target Call target identifier.
+    /// @param value Native value forwarded with the call.
+    /// @param data Raw nested call payload.
+    function appendCall(Writer memory writer, uint target, uint value, bytes memory data) internal pure {
+        appendBlock64Bytes(writer, Keys.Call, bytes32(target), bytes32(value), data);
+    }
+
+    /// @notice Append a CONTEXT block with a value budget and nested state/request BYTES payloads.
+    /// @param writer Destination writer; `i` is advanced by the encoded CONTEXT block length.
+    /// @param account Command account identifier.
+    /// @param value Native value budget assigned to the context.
+    /// @param state Raw nested state payload.
+    /// @param request Raw nested request payload.
+    function appendContext(
+        Writer memory writer,
+        bytes32 account,
+        uint value,
+        bytes memory state,
+        bytes memory request
     ) internal pure {
-        commit(writer, writeBlockHead64(writer.dst, writer.i, key, a, b, tail));
+        appendBlock64BytesBytes(writer, Keys.Context, account, bytes32(value), state, request);
     }
 
     /// @notice Append a STATUS form block.
-    /// @param writer Destination writer; `i` is advanced by `Sizes.B32`.
+    /// @param writer Destination writer; `i` is advanced by `Sizes.Status`.
     /// @param ok Status value to encode.
     function appendStatus(Writer memory writer, bool ok) internal pure {
-        commit(writer, writeBlock32(writer.dst, writer.i, Keys.Status, ok ? bytes32(uint(1)) : bytes32(0), 32));
+        appendBlock32(writer, Keys.Status, ok ? bytes32(uint(1) << 248) : bytes32(0), 1);
     }
 
     /// @notice Append a BALANCE block using separate field values.
@@ -742,17 +900,14 @@ library Writers {
     /// @param meta Asset metadata slot.
     /// @param amount Token amount.
     function appendBalance(Writer memory writer, bytes32 asset, bytes32 meta, uint amount) internal pure {
-        commit(writer, writeBlock96(writer.dst, writer.i, Keys.Balance, asset, meta, bytes32(amount), 32));
+        appendBlock96(writer, Keys.Balance, asset, meta, bytes32(amount), 32);
     }
 
     /// @notice Append a BALANCE block from a struct.
     /// @param writer Destination writer; `i` is advanced by `Sizes.Balance`.
     /// @param value Balance fields to encode.
     function appendBalance(Writer memory writer, AssetAmount memory value) internal pure {
-        commit(
-            writer,
-            writeBlock96(writer.dst, writer.i, Keys.Balance, value.asset, value.meta, bytes32(value.amount), 32)
-        );
+        appendBalance(writer, value.asset, value.meta, value.amount);
     }
 
     /// @notice Append an AMOUNT block using separate field values.
@@ -761,17 +916,14 @@ library Writers {
     /// @param meta Asset metadata slot.
     /// @param amount Token amount.
     function appendAmount(Writer memory writer, bytes32 asset, bytes32 meta, uint amount) internal pure {
-        commit(writer, writeBlock96(writer.dst, writer.i, Keys.Amount, asset, meta, bytes32(amount), 32));
+        appendBlock96(writer, Keys.Amount, asset, meta, bytes32(amount), 32);
     }
 
     /// @notice Append an AMOUNT block from a struct.
     /// @param writer Destination writer; `i` is advanced by `Sizes.Balance`.
     /// @param value Amount fields to encode.
     function appendAmount(Writer memory writer, AssetAmount memory value) internal pure {
-        commit(
-            writer,
-            writeBlock96(writer.dst, writer.i, Keys.Amount, value.asset, value.meta, bytes32(value.amount), 32)
-        );
+        appendAmount(writer, value.asset, value.meta, value.amount);
     }
 
     /// @notice Append an ACCOUNT_AMOUNT form block using separate field values.
@@ -787,29 +939,14 @@ library Writers {
         bytes32 meta,
         uint amount
     ) internal pure {
-        commit(
-            writer,
-            writeBlock128(writer.dst, writer.i, Keys.AccountAmount, account, asset, meta, bytes32(amount), 32)
-        );
+        appendBlock128(writer, Keys.AccountAmount, account, asset, meta, bytes32(amount), 32);
     }
 
     /// @notice Append an ACCOUNT_AMOUNT form block from a struct.
     /// @param writer Destination writer; `i` is advanced by `Sizes.B128`.
     /// @param value Account amount fields to encode.
     function appendAccountAmount(Writer memory writer, AccountAmount memory value) internal pure {
-        commit(
-            writer,
-            writeBlock128(
-                writer.dst,
-                writer.i,
-                Keys.AccountAmount,
-                value.account,
-                value.asset,
-                value.meta,
-                bytes32(value.amount),
-                32
-            )
-        );
+        appendAccountAmount(writer, value.account, value.asset, value.meta, value.amount);
     }
 
     /// @notice Append an ASSET block.
@@ -817,7 +954,7 @@ library Writers {
     /// @param asset Asset identifier.
     /// @param meta Asset metadata slot.
     function appendAsset(Writer memory writer, bytes32 asset, bytes32 meta) internal pure {
-        commit(writer, writeBlock64(writer.dst, writer.i, Keys.Asset, asset, meta, 32));
+        appendBlock64(writer, Keys.Asset, asset, meta, 32);
     }
 
     /// @notice Append a BOUNTY block to the writer.
@@ -825,7 +962,7 @@ library Writers {
     /// @param amount Relayer reward amount.
     /// @param relayer Relayer account identifier.
     function appendBounty(Writer memory writer, uint amount, bytes32 relayer) internal pure {
-        commit(writer, writeBlock64(writer.dst, writer.i, Keys.Bounty, bytes32(amount), relayer, 32));
+        appendBlock64(writer, Keys.Bounty, bytes32(amount), relayer, 32);
     }
 
     /// @notice Append a CUSTODY block using separate field values.
@@ -835,10 +972,7 @@ library Writers {
     /// @param meta Asset metadata slot.
     /// @param amount Token amount.
     function appendCustody(Writer memory writer, uint host, bytes32 asset, bytes32 meta, uint amount) internal pure {
-        commit(
-            writer,
-            writeBlock128(writer.dst, writer.i, Keys.Custody, bytes32(host), asset, meta, bytes32(amount), 32)
-        );
+        appendBlock128(writer, Keys.Custody, bytes32(host), asset, meta, bytes32(amount), 32);
     }
 
     /// @notice Append a CUSTODY block from a host and asset amount.
@@ -846,57 +980,29 @@ library Writers {
     /// @param host Host node ID.
     /// @param value Custody fields to encode.
     function appendCustody(Writer memory writer, uint host, AssetAmount memory value) internal pure {
-        commit(
-            writer,
-            writeBlock128(
-                writer.dst,
-                writer.i,
-                Keys.Custody,
-                bytes32(host),
-                value.asset,
-                value.meta,
-                bytes32(value.amount),
-                32
-            )
-        );
+        appendCustody(writer, host, value.asset, value.meta, value.amount);
     }
 
     /// @notice Append a CUSTODY block from a host amount struct.
     /// @param writer Destination writer; `i` is advanced by `Sizes.HostAmount`.
     /// @param value Custody fields to encode.
     function appendCustody(Writer memory writer, HostAmount memory value) internal pure {
-        commit(
-            writer,
-            writeBlock128(
-                writer.dst,
-                writer.i,
-                Keys.Custody,
-                bytes32(value.host),
-                value.asset,
-                value.meta,
-                bytes32(value.amount),
-                32
-            )
-        );
+        appendCustody(writer, value.host, value.asset, value.meta, value.amount);
     }
 
     /// @notice Append a TRANSACTION block from a struct.
     /// @param writer Destination writer; `i` is advanced by `Sizes.Transaction`.
     /// @param value Transfer record fields to encode.
     function appendTransaction(Writer memory writer, Tx memory value) internal pure {
-        commit(
+        appendBlock160(
             writer,
-            writeBlock160(
-                writer.dst,
-                writer.i,
-                Keys.Transaction,
-                bytes32(value.from),
-                bytes32(value.to),
-                value.asset,
-                value.meta,
-                bytes32(value.amount),
-                32
-            )
+            Keys.Transaction,
+            bytes32(value.from),
+            bytes32(value.to),
+            value.asset,
+            value.meta,
+            bytes32(value.amount),
+            32
         );
     }