knitting 0.1.62 → 0.1.70

package/src/memory/payloadCodec.js

@@ -1,4 +1,4 @@
-import { attachPayloadTransportFinalizer, beginPromisePayload, finishPromisePayload, getTaskSlotIndex, HEADER_BYTE_LENGTH, HEADER_SLOT_STRIDE_U32, HEADER_STATIC_PAYLOAD_U32, LockBound, PayloadBuffer, payloadBufferName, PayloadSignal, registerLockPayloadCodec, TaskIndex, } from "./lock.js";
+import { attachPayloadTransportFinalizer, beginPromisePayload, finishPromisePayload, HEADER_BYTE_LENGTH, HEADER_SLOT_STRIDE_U32, HEADER_STATIC_PAYLOAD_U32, LockBound, PayloadBuffer, payloadBufferName, PayloadSignal, registerLockPayloadCodec, TASK_SLOT_INDEX_MASK, TaskIndex, } from "./lock.js";
 import { register } from "./regionRegistry.js";
 import { createSharedDynamicBufferIO, createSharedStaticBufferIO, } from "./shared-buffer-io.js";
 import { getStridedRegionSpanBytes } from "./byte-carpet.js";
@@ -6,7 +6,8 @@ import { encoderError, ErrorKnitting } from "../error.js";
 import { Envelope } from "../common/envelope.js";
 import { resolvePayloadBufferOptions, } from "./payload-config.js";
 import { getSharedArrayBufferPayload, SHARED_ARRAY_BUFFER_CODEC_ID, SHARED_ARRAY_BUFFER_NUMERIC_TRANSFER, SHARED_ARRAY_BUFFER_NUMERIC_WORDS, } from "../connections/shared-array-buffer-payload.js";
-import { BUFFER_REFERENCE_NUMERIC_TRANSFER, BufferReference, isBufferReferenceValue, } from "../connections/buffer-reference.js";
+import { BUFFER_REFERENCE_NUMERIC_TRANSFER, BufferReference, isArrayBufferDetached, isBufferReferenceValue, } from "../connections/buffer-reference.js";
+import { getBufferReferenceCapabilities, } from "../connections/buffer-reference-native.js";
 import { isProcessSharedBufferValue, ProcessSharedBuffer, } from "../connections/process-shared-buffer.js";
 import { isNumericArray, numericArrayFromFloat64, } from "../connections/numeric-array.js";
 const memory = new ArrayBuffer(8);
@@ -99,7 +100,7 @@ const readTrustedExternalPayloadMetadata = (value) => {
     }
     return value.toMetadata();
 };
-const decodeExternalPayload = (raw, processBoundary) => {
+const decodeExternalPayload = (raw, processBoundary, transportKey) => {
     const payload = parseJSON(raw);
     if (!arrayIsArray(payload) || payload.length !== 2)
         return payload;
@@ -113,22 +114,33 @@ const decodeExternalPayload = (raw, processBoundary) => {
     }
     const codec = externalPayloadGlobal.__KNITTING_PAYLOAD_CODECS__?.[codecId];
     return typeof codec?.decode === "function"
-        ? codec.decode(metadata)
+        ? codec.decode(metadata, transportKey)
         : { codec: codecId, metadata };
 };
 const PROCESS_SHARED_BUFFER_NUMERIC_WORDS = 8;
 const BUFFER_REFERENCE_NUMERIC_WORDS = 8;
 const NUMERIC_SENTINEL = 0xffffffff;
-const decodeNumericExternalPayload = (codecId, words) => {
+/** Minimum size for automatically borrowed byte returns. */
+export const SHARED_RETURN_MIN_BYTES = 256 * 1024;
+/** Number of later borrowed returns kept before a region is recycled. */
+export const SHARED_RETURN_BORROW_WINDOW = 32;
+// Each payload buffer has one allocator for the worker return lane.
+const sharedReturnAllocators = new WeakMap();
+/** The borrowed-region allocator for `payload`, if an encoder built one. */
+export const getSharedReturnAllocator = (payload) => sharedReturnAllocators.get(payload);
+const decodeNumericExternalPayload = (codecId, words, transportKey) => {
     const codec = externalPayloadGlobal.__KNITTING_PAYLOAD_CODECS__?.[codecId];
     if (typeof codec?.decodeNumeric === "function") {
-        return codec.decodeNumeric(words);
+        return codec.decodeNumeric(words, transportKey);
     }
     return { codec: codecId, metadata: Array.from(words) };
 };
 const decodeProcessSharedBufferNumericWords = (words) => decodeNumericExternalPayload(PROCESS_SHARED_BUFFER_CODEC_ID, words);
 const decodeBufferReferenceNumericWords = (words) => decodeNumericExternalPayload(BUFFER_REFERENCE_CODEC_ID, words);
-const decodeSharedArrayBufferNumericWords = (words) => decodeNumericExternalPayload(SHARED_ARRAY_BUFFER_CODEC_ID, words);
+// The transport key scopes the host's adopted-alias cache to one return lane:
+// producer tokens restart at 1 in every worker isolate, so a shared cache would
+// serve one worker's buffer for another worker's identical token.
+const decodeSharedArrayBufferNumericWords = (words, transportKey) => decodeNumericExternalPayload(SHARED_ARRAY_BUFFER_CODEC_ID, words, transportKey);
 const tryEncodePrimitiveTask = (task) => {
     const value = task.value;
     switch (typeof value) {
@@ -304,15 +316,28 @@ const requireStaticIO = (headersBuffer, headerSlotStrideU32, textCompat) => {
  * Returns `true` when the payload is encoded successfully.
  * Returns `false` when dynamic payload space could not be reserved.
  */
-export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headersBuffer, headerSlotStrideU32, textCompat, onPromise, processBoundary = false, }) => {
+export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headersBuffer, headerSlotStrideU32, textCompat, onPromise, processBoundary = false, sharedReturn = false, moveReturn = false, }) => {
     const payloadSab = payload?.sab ?? sab;
     const resolvedPayloadConfig = resolvePayloadBufferOptions({
         sab: payloadSab,
         options: payload?.config ?? payloadConfig,
     });
     const maxPayloadBytes = resolvedPayloadConfig.maxPayloadBytes;
-    const { allocTask, setSlotLength, free } = register({ lockSector });
-    const { writeBinary: writeDynamicBinary, writeBuffer: writeDynamicBuffer, writeArrayBuffer: writeDynamicArrayBuffer, write8Binary: writeDynamic8Binary, writeUtf8: writeDynamicUtf8, } = createSharedDynamicBufferIO({
+    // Automatic moves are an optimization. Keep ordinary byte returns working
+    // when this runtime has no usable ownership/FFI backend.
+    const canMoveReturn = moveReturn && (() => {
+        try {
+            getBufferReferenceCapabilities();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    })();
+    const registryHandle = register({ lockSector });
+    const { allocTask, setSlotLength, tagTaskSlot, free } = registryHandle;
+    const { allocRegion, regionStart } = registryHandle;
+    const { writeBinary: writeDynamicBinary, writeBuffer: writeDynamicBuffer, writeArrayBuffer: writeDynamicArrayBuffer, write8Binary: writeDynamic8Binary, writeUtf8: writeDynamicUtf8, readBytesView: dynamicRegionView, ensureCapacity: ensureDynamicCapacity, currentBuffer: currentDynamicBuffer, regionBase: dynamicRegionBase, } = createSharedDynamicBufferIO({
         sab: payloadSab,
         payloadConfig: resolvedPayloadConfig,
         textCompat: textCompat?.payload,
@@ -350,9 +375,72 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         return exactBytes;
     };
     const dynamicUtf8ReserveBytes = (task, text, label) => dynamicUtf8ReserveBytesWithExtra(task, text, 0, label);
+    // Borrowed regions are tracked as [slot, start, end] triples, oldest first.
+    const borrowed = [];
+    const BORROW_STRIDE = 3;
+    /** Limit borrowed regions to half the payload arena. */
+    const maxBorrowBytes = ((resolvedPayloadConfig.payloadMaxByteLength >> 1) /
+        SHARED_RETURN_BORROW_WINDOW) | 0;
+    /** Reserve a region to hand over by reference, or -1 when none is free. */
+    const reserveBorrowedRegion = (bytes) => {
+        if (bytes > maxBorrowBytes)
+            return -1;
+        const slot = allocRegion(bytes);
+        if (slot === -1)
+            return -1;
+        const start = regionStart(slot);
+        if (!ensureDynamicCapacity(start + bytes)) {
+            free(slot);
+            return -1;
+        }
+        borrowed.push(slot, start, start + bytes);
+        if (borrowed.length > SHARED_RETURN_BORROW_WINDOW * BORROW_STRIDE) {
+            free(borrowed[0]);
+            borrowed.splice(0, BORROW_STRIDE);
+        }
+        return slot;
+    };
+    const dropBorrowedRegion = (slot) => {
+        for (let at = 0; at < borrowed.length; at += BORROW_STRIDE) {
+            if (borrowed[at] === slot) {
+                borrowed.splice(at, BORROW_STRIDE);
+                break;
+            }
+        }
+        free(slot);
+    };
+    /** Return the arena offset when `view` is inside a live borrowed region. */
+    const borrowedStartOf = (view) => {
+        if (borrowed.length === 0)
+            return -1;
+        if (view.buffer !== currentDynamicBuffer())
+            return -1;
+        const start = view.byteOffset - dynamicRegionBase();
+        const end = start + view.byteLength;
+        for (let at = borrowed.length - BORROW_STRIDE; at >= 0; at -= BORROW_STRIDE) {
+            if (start >= borrowed[at + 1] && end <= borrowed[at + 2])
+                return start;
+        }
+        return -1;
+    };
+    /** Allocate a borrowed return region, or fall back when none is available. */
+    const allocateSharedReturn = (byteLength, zeroFill = false) => {
+        const slot = reserveBorrowedRegion(byteLength);
+        if (slot === -1)
+            return undefined;
+        const start = regionStart(slot);
+        const view = dynamicRegionView(start, start + byteLength);
+        if (zeroFill)
+            view.fill(0);
+        return view;
+    };
+    if (sharedReturn && payloadSab !== undefined) {
+        sharedReturnAllocators.set(payloadSab, allocateSharedReturn);
+    }
     const reserveDynamic = (task, bytes) => {
         task[TaskIndex.PayloadLen] = bytes;
-        // PayloadCodec only reserves after the lock has guaranteed capacity.
+        // -1 is dynamic-region backpressure. Returning false leaves this frame on
+        // the lock's existing pending list until a receiver releases a region.
         return allocTask(task);
     };
     let objectDynamicSlot = -1;
@@ -419,6 +507,8 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
             return false;
         task[TaskIndex.Type] = PayloadBuffer.Error;
         const reservedSlot = reserveDynamicObject(task, reserveBytes);
+        if (reservedSlot === -1)
+            return false;
         const written = writeDynamicUtf8(text, task[TaskIndex.Start], reserveBytes);
         if (written < 0)
             return failDynamicWriteAfterReserve(task, reservedSlot);
@@ -443,6 +533,8 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
             return false;
         }
         const reservedSlot = reserveDynamicObject(task, bytes);
+        if (reservedSlot === -1)
+            return false;
         const written = writeDynamicBinary(bytesView, task[TaskIndex.Start]);
         if (written < 0)
             return failDynamicWriteAfterReserve(task, reservedSlot);
@@ -453,6 +545,15 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
     };
     const encodeObjectUint8Array = (task, slotIndex, bytesView) => {
         const bytes = bytesView.byteLength;
+        // Preserve an arena-backed subarray as an offset/length frame.
+        const borrowedStart = borrowedStartOf(bytesView);
+        if (borrowedStart !== -1) {
+            task[TaskIndex.Type] = PayloadBuffer.ArenaBinary;
+            task[TaskIndex.Start] = borrowedStart;
+            task[TaskIndex.PayloadLen] = bytes;
+            task.value = null;
+            return true;
+        }
         if (bytes <= staticMaxBytes) {
             writeStaticExactUint8Array(bytesView, slotIndex);
             task[TaskIndex.Type] = PayloadBuffer.StaticBinary;
@@ -460,10 +561,16 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
             task.value = null;
             return true;
         }
+        if (canMoveReturn && bytes >= SHARED_RETURN_MIN_BYTES &&
+            tryEncodeMovedReturn(task, slotIndex, bytesView, PayloadBuffer.MovedBinary)) {
+            return true;
+        }
         task[TaskIndex.Type] = PayloadBuffer.Binary;
         if (!ensureWithinDynamicLimit(task, bytes, "Binary"))
             return false;
         const reservedSlot = reserveDynamicObject(task, bytes);
+        if (reservedSlot === -1)
+            return false;
         const written = writeDynamicBinary(bytesView, task[TaskIndex.Start]);
         if (written < 0)
             return failDynamicWriteAfterReserve(task, reservedSlot);
@@ -487,6 +594,8 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         if (!ensureWithinDynamicLimit(task, bytes, "Buffer"))
             return false;
         const reservedSlot = reserveDynamicObject(task, bytes);
+        if (reservedSlot === -1)
+            return false;
         const written = writeDynamicBuffer(buffer, task[TaskIndex.Start]);
         if (written < 0)
             return failDynamicWriteAfterReserve(task, reservedSlot);
@@ -510,6 +619,8 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         if (!ensureWithinDynamicLimit(task, bytes, "Float64Array"))
             return false;
         const reservedSlot = reserveDynamicObject(task, bytes);
+        if (reservedSlot === -1)
+            return false;
         const written = writeDynamic8Binary(float64, task[TaskIndex.Start]);
         if (written < 0)
             return failDynamicWriteAfterReserve(task, reservedSlot);
@@ -541,6 +652,8 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         if (!ensureWithinDynamicLimit(task, bytes, "NumericArray"))
             return false;
         const reservedSlot = reserveDynamicObject(task, bytes);
+        if (reservedSlot === -1)
+            return false;
         const written = writeDynamic8Binary(float64, task[TaskIndex.Start]);
         if (written < 0)
             return failDynamicWriteAfterReserve(task, reservedSlot);
@@ -560,10 +673,16 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
                 return true;
             }
         }
+        if (canMoveReturn && bytes >= SHARED_RETURN_MIN_BYTES &&
+            tryEncodeMovedReturn(task, slotIndex, arrayBuffer, PayloadBuffer.MovedArrayBuffer)) {
+            return true;
+        }
         task[TaskIndex.Type] = PayloadBuffer.ArrayBuffer;
         if (!ensureWithinDynamicLimit(task, bytes, "ArrayBuffer"))
             return false;
         const reservedSlot = reserveDynamicObject(task, bytes);
+        if (reservedSlot === -1)
+            return false;
         const written = writeDynamicArrayBuffer(arrayBuffer, task[TaskIndex.Start]);
         if (written < 0)
             return failDynamicWriteAfterReserve(task, reservedSlot);
@@ -619,6 +738,68 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         task.value = null;
         return true;
     };
+    /**
+     * The safe counterpart to an arena borrow. The producer's source is detached
+     * only after its task has settled; the host adopts the backing store before
+     * its acknowledgement lets the producer release the registry pin.
+     *
+     * This needs its own frame type because public task results remain ordinary
+     * Uint8Array / ArrayBuffer values rather than exposing BufferReference.
+     */
+    const tryEncodeMovedReturn = (task, slotIndex, source, type) => {
+        if (source.byteLength > 0xffffffff)
+            return false;
+        const backing = ArrayBuffer.isView(source) ? source.buffer : source;
+        if (typeof SharedArrayBuffer === "function" &&
+            backing instanceof SharedArrayBuffer) {
+            return false;
+        }
+        // Narrowed by the check above: what is left is a detachable ArrayBuffer.
+        const store = backing;
+        // A move takes the whole backing store, not the slice that was returned.
+        // `return scratch.subarray(0, n)` would detach the producer's entire
+        // scratch buffer and break its next call, so a partial view is copied
+        // like any other return. Only a view that *is* its buffer can move.
+        if (ArrayBuffer.isView(source) &&
+            (source.byteOffset !== 0 || source.byteLength !== store.byteLength)) {
+            return false;
+        }
+        // Moving is an optimization, so a source this runtime cannot detach --
+        // WASM memory, a buffer an external API pinned -- copies rather than
+        // failing the task. Construction is what detaches: a throw before it
+        // leaves the bytes intact and the copy path still works, while a throw
+        // after it has already consumed them has to be reported.
+        let reference;
+        try {
+            reference = new BufferReference(source);
+        }
+        catch (error) {
+            if (isArrayBufferDetached(store))
+                throw error;
+            return false;
+        }
+        // Belt and braces for a runtime that reports success without detaching.
+        // The host would be handed a store still aliasing memory the producer can
+        // write; the source is intact in that case, so dropping the reference and
+        // copying is both safe and the honest answer.
+        if (!isArrayBufferDetached(store)) {
+            reference.release();
+            return false;
+        }
+        const words = BufferReference.prototype[BUFFER_REFERENCE_NUMERIC_TRANSFER]
+            .call(reference);
+        // The size check above guarantees the numeric form for a local reference.
+        // Do not fall back after construction: the source has intentionally moved.
+        if (words === undefined) {
+            reference.release();
+            throw new Error("Moved BufferReference has no numeric transport form");
+        }
+        task[TaskIndex.Type] = type;
+        task[TaskIndex.PayloadLen] = writeStaticU32Words(words, BUFFER_REFERENCE_NUMERIC_WORDS, slotIndex);
+        attachPayloadTransportFinalizer(task, reference);
+        task.value = null;
+        return true;
+    };
     const tryEncodeSharedArrayBufferNumeric = (task, slotIndex, value) => {
         const words = value[SHARED_ARRAY_BUFFER_NUMERIC_TRANSFER]?.(lockSector);
         if (words === undefined)
@@ -719,6 +900,8 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         if (reserveBytes < 0)
             return false;
         const reservedSlot = reserveDynamicObject(task, reserveBytes);
+        if (reservedSlot === -1)
+            return false;
         const written = writeDynamicUtf8(text, task[TaskIndex.Start], reserveBytes);
         if (written < 0)
             return failDynamicWriteAfterReserve(task, reservedSlot);
@@ -728,6 +911,48 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         task.value = null;
         return true;
     };
+    /** Encode plain objects, arrays, and null-prototype objects as JSON. */
+    const encodeObjectJson = (task, slotIndex, objectValue) => {
+        let text;
+        try {
+            text = stringifyJSON(objectValue);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            return encoderError({
+                task,
+                type: ErrorKnitting.Json,
+                onPromise,
+                detail,
+            });
+        }
+        if (text.length <= staticMaxBytes) {
+            const written = writeStaticUtf8(text, slotIndex);
+            if (written !== -1) {
+                task[TaskIndex.Type] = PayloadBuffer.StaticJson;
+                task[TaskIndex.PayloadLen] = written;
+                // Retain any transport-owned memory until the call settles.
+                attachPayloadTransportFinalizer(task, objectValue);
+                task.value = null;
+                return true;
+            }
+        }
+        task[TaskIndex.Type] = PayloadBuffer.Json;
+        const reserveBytes = dynamicUtf8ReserveBytes(task, text, "Json");
+        if (reserveBytes < 0)
+            return false;
+        const reservedSlot = reserveDynamicObject(task, reserveBytes);
+        if (reservedSlot === -1)
+            return false;
+        const written = writeDynamicUtf8(text, task[TaskIndex.Start], reserveBytes);
+        if (written < 0)
+            return failDynamicWriteAfterReserve(task, reservedSlot);
+        task[TaskIndex.PayloadLen] = written;
+        setSlotLength(reservedSlot, written);
+        attachPayloadTransportFinalizer(task, objectValue);
+        task.value = null;
+        return true;
+    };
     const encodeObjectDate = (task, date) => {
         Float64View[0] = date.getTime();
         task[TaskIndex.Type] = PayloadBuffer.Date;
@@ -799,6 +1024,8 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
             if (!ensureWithinDynamicLimit(task, payloadReserveBytes, "EnvelopeStaticHeaderPayload"))
                 return false;
             const reservedSlot = reserveDynamicObject(task, payloadReserveBytes);
+            if (reservedSlot === -1)
+                return false;
             task[TaskIndex.Type] = headerIsString
                 ? PayloadBuffer.EnvelopeStaticHeaderString
                 : PayloadBuffer.EnvelopeStaticHeader;
@@ -811,7 +1038,11 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
                 }
                 setSlotLength(reservedSlot, payloadWritten);
             }
+            else {
+                setSlotLength(reservedSlot, 0);
+            }
             task.value = null;
+            tagTaskSlot(task, reservedSlot);
             return true;
         }
         const headerReserveBytes = dynamicUtf8ReserveBytesWithExtra(task, headerText, payloadLength, headerIsString ? "EnvelopeDynamicHeaderString" : "EnvelopeDynamicHeader");
@@ -821,6 +1052,8 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
             ? PayloadBuffer.EnvelopeDynamicHeaderString
             : PayloadBuffer.EnvelopeDynamicHeader;
         const reservedSlot = reserveDynamicObject(task, headerReserveBytes + payloadLength);
+        if (reservedSlot === -1)
+            return false;
         const baseStart = task[TaskIndex.Start];
         const writtenHeaderBytes = writeDynamicUtf8(headerText, baseStart, headerReserveBytes);
         if (writtenHeaderBytes < 0) {
@@ -836,6 +1069,7 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         task[TaskIndex.End] = payloadLength;
         setSlotLength(reservedSlot, writtenHeaderBytes + payloadLength);
         task.value = null;
+        tagTaskSlot(task, reservedSlot);
         return true;
     };
     const encodeEnvelopeExternalBody = (task, slotIndex, headerText, headerIsString, externalBody, trustedReservedCodec) => {
@@ -901,6 +1135,8 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
             if (!ensureWithinDynamicLimit(task, bodyLength, "EnvelopeStaticHeaderExternal"))
                 return false;
             const reservedSlot = reserveDynamicObject(task, bodyLength);
+            if (reservedSlot === -1)
+                return false;
             task[TaskIndex.Type] = headerIsString
                 ? PayloadBuffer.EnvelopeStaticHeaderStringExternal
                 : PayloadBuffer.EnvelopeStaticHeaderExternal;
@@ -913,6 +1149,7 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
             setSlotLength(reservedSlot, bodyWritten);
             attachPayloadTransportFinalizer(task, externalBody);
             task.value = null;
+            tagTaskSlot(task, reservedSlot);
             return true;
         }
         const headerReserveBytes = dynamicUtf8ReserveBytesWithExtra(task, headerText, bodyLength, headerIsString
@@ -924,6 +1161,8 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
             ? PayloadBuffer.EnvelopeDynamicHeaderStringExternal
             : PayloadBuffer.EnvelopeDynamicHeaderExternal;
         const reservedSlot = reserveDynamicObject(task, headerReserveBytes + bodyLength);
+        if (reservedSlot === -1)
+            return false;
         const baseStart = task[TaskIndex.Start];
         const writtenHeaderBytes = writeDynamicUtf8(headerText, baseStart, headerReserveBytes);
         if (writtenHeaderBytes < 0) {
@@ -938,6 +1177,7 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         setSlotLength(reservedSlot, writtenHeaderBytes + bodyLength);
         attachPayloadTransportFinalizer(task, externalBody);
         task.value = null;
+        tagTaskSlot(task, reservedSlot);
         return true;
     };
     const encodeObjectEnvelope = (task, slotIndex, envelope) => {
@@ -1005,6 +1245,10 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
                     return false;
                 }
                 const reservedSlot = reserveDynamic(task, binaryBytes);
+                if (reservedSlot === -1) {
+                    clearBigIntScratch(binaryBytes);
+                    return false;
+                }
                 const written = writeDynamicBinary(binary, task[TaskIndex.Start]);
                 if (written < 0) {
                     clearBigIntScratch(binaryBytes);
@@ -1026,57 +1270,23 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
                 objectDynamicSlot = -1;
                 try {
                     const objectValue = args;
+                    const objectProto = objectGetPrototypeOf(objectValue);
+                    // Plain objects can skip the typed-array and external-payload checks.
+                    if (objectProto === objectPrototype) {
+                        return encodeObjectJson(task, slotIndex, objectValue);
+                    }
                     const sharedArrayBufferPayload = getSharedArrayBufferPayload(objectValue);
                     if (sharedArrayBufferPayload !== undefined) {
                         return encodeObjectExternalPayload(task, slotIndex, sharedArrayBufferPayload, true);
                     }
-                    const objectProto = objectGetPrototypeOf(objectValue);
                     if (isRuntimeUint8Array(objectValue)) {
                         return encodeObjectUint8Array(task, slotIndex, objectValue);
                     }
                     if (arrayIsArray(objectValue) && isNumericArray(objectValue)) {
                         return encodeObjectNumericArray(task, slotIndex, objectValue);
                     }
-                    if (arrayIsArray(objectValue) ||
-                        objectProto === objectPrototype ||
-                        objectProto === null) {
-                        let text;
-                        try {
-                            text = stringifyJSON(objectValue);
-                        }
-                        catch (error) {
-                            const detail = error instanceof Error
-                                ? error.message
-                                : String(error);
-                            return encoderError({
-                                task,
-                                type: ErrorKnitting.Json,
-                                onPromise,
-                                detail,
-                            });
-                        }
-                        if (text.length <= staticMaxBytes) {
-                            const written = writeStaticUtf8(text, slotIndex);
-                            if (written !== -1) {
-                                task[TaskIndex.Type] = PayloadBuffer.StaticJson;
-                                task[TaskIndex.PayloadLen] = written;
-                                task.value = null;
-                                return true;
-                            }
-                        }
-                        task[TaskIndex.Type] = PayloadBuffer.Json;
-                        const reserveBytes = dynamicUtf8ReserveBytes(task, text, "Json");
-                        if (reserveBytes < 0)
-                            return false;
-                        const reservedSlot = reserveDynamicObject(task, reserveBytes);
-                        const written = writeDynamicUtf8(text, task[TaskIndex.Start], reserveBytes);
-                        if (written < 0) {
-                            return failDynamicWriteAfterReserve(task, reservedSlot);
-                        }
-                        task[TaskIndex.PayloadLen] = written;
-                        setSlotLength(reservedSlot, written);
-                        task.value = null;
-                        return true;
+                    if (arrayIsArray(objectValue) || objectProto === null) {
+                        return encodeObjectJson(task, slotIndex, objectValue);
                     }
                     if (isBufferReferenceValue(objectValue) ||
                         isProcessSharedBufferValue(objectValue)) {
@@ -1165,6 +1375,8 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
                 if (reserveBytes < 0)
                     return false;
                 const reservedSlot = reserveDynamic(task, reserveBytes);
+                if (reservedSlot === -1)
+                    return false;
                 const written = writeDynamicUtf8(text, task[TaskIndex.Start], reserveBytes);
                 if (written < 0) {
                     return failDynamicWriteAfterReserve(task, reservedSlot);
@@ -1197,6 +1409,8 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
                 if (reserveBytes < 0)
                     return false;
                 const reservedSlot = reserveDynamic(task, reserveBytes);
+                if (reservedSlot === -1)
+                    return false;
                 const written = writeDynamicUtf8(key, task[TaskIndex.Start], reserveBytes);
                 if (written < 0) {
                     return failDynamicWriteAfterReserve(task, reservedSlot);
@@ -1218,8 +1432,11 @@ export const decodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         options: payload?.config ?? payloadConfig,
     });
     const { free } = register({ lockSector });
-    const freeTaskSlot = (task) => free(getTaskSlotIndex(task));
-    const { readUtf8: readDynamicUtf8, readBytesCopy: readDynamicBytesCopy, readBytesBufferCopy: readDynamicBufferCopy, readBufferCopy: readDynamicBuffer, readBytesArrayBufferCopy: readDynamicArrayBufferCopy, readArrayBufferCopy: readDynamicArrayBuffer, read8BytesFloatCopy: readDynamic8BytesFloatCopy, read8BytesFloatView: readDynamic8BytesFloatView, } = createSharedDynamicBufferIO({
+    // Region identity is 6 bits only for dynamic payloads. Its high bit rides in
+    // End's otherwise-unused top bit, preserving the 5-bit queue-slot field.
+    const freeTaskSlot = (task) => free((task[TaskIndex.slotBuffer] & TASK_SLOT_INDEX_MASK) |
+        ((task[TaskIndex.End] >>> 31) << 5));
+    const { readUtf8: readDynamicUtf8, readBytesCopy: readDynamicBytesCopy, readBytesBufferCopy: readDynamicBufferCopy, readBufferCopy: readDynamicBuffer, readBytesArrayBufferCopy: readDynamicArrayBufferCopy, readArrayBufferCopy: readDynamicArrayBuffer, read8BytesFloatCopy: readDynamic8BytesFloatCopy, read8BytesFloatView: readDynamic8BytesFloatView, readBytesView: readDynamicBytesView, syncGrowth: syncDynamicGrowth, } = createSharedDynamicBufferIO({
         sab: payloadSab,
         payloadConfig: resolvedPayloadConfig,
         textCompat: textCompat?.payload,
@@ -1230,10 +1447,13 @@ export const decodePayload = ({ lockSector, payload, sab, payloadConfig, headers
     // synchronously when building the ProcessSharedBuffer.
     const processSharedBufferWords = new Uint32Array(PROCESS_SHARED_BUFFER_NUMERIC_WORDS);
     const sharedArrayBufferWords = new Uint32Array(SHARED_ARRAY_BUFFER_NUMERIC_WORDS);
+    // `readStaticU32Words` returns the whole scratch, and the SAB codec dispatches
+    // on word count, so hand it a view cut to the frame's own length.
+    const sharedArrayBufferWordViews = [];
+    for (let count = 0; count <= SHARED_ARRAY_BUFFER_NUMERIC_WORDS; count++) {
+        sharedArrayBufferWordViews.push(sharedArrayBufferWords.subarray(0, count));
+    }
     const bufferReferenceWords = new Uint32Array(BUFFER_REFERENCE_NUMERIC_WORDS);
-    // TODO: remove slotIndex and make that all their callers
-    // store the slot in their Task, to just get it when it comes
-    // to the static versions of decoding
     return (task, slotIndex, specialFlags) => {
         const payloadType = task[TaskIndex.Type];
         if (processBoundary &&
@@ -1287,7 +1507,7 @@ export const decodePayload = ({ lockSector, payload, sab, payloadConfig, headers
                 const header = task[TaskIndex.Type] === PayloadBuffer.EnvelopeStaticHeaderString
                     ? rawHeader
                     : parseJSON(rawHeader);
-                const payloadLength = task[TaskIndex.End];
+                const payloadLength = task[TaskIndex.End] & 0x7FFFFFFF;
                 const payload = payloadLength > 0
                     ? readDynamicArrayBufferCopy(task[TaskIndex.Start], task[TaskIndex.Start] + payloadLength)
                     : new ArrayBuffer(0);
@@ -1299,7 +1519,7 @@ export const decodePayload = ({ lockSector, payload, sab, payloadConfig, headers
             case PayloadBuffer.EnvelopeDynamicHeaderString: {
                 const headerStart = task[TaskIndex.Start];
                 const payloadStart = headerStart + task[TaskIndex.PayloadLen];
-                const payloadLength = task[TaskIndex.End];
+                const payloadLength = task[TaskIndex.End] & 0x7FFFFFFF;
                 const rawHeader = readDynamicUtf8(headerStart, payloadStart);
                 const header = task[TaskIndex.Type] === PayloadBuffer.EnvelopeDynamicHeaderString
                     ? rawHeader
@@ -1319,7 +1539,7 @@ export const decodePayload = ({ lockSector, payload, sab, payloadConfig, headers
                     ? rawHeader
                     : parseJSON(rawHeader);
                 const bodyStart = task[TaskIndex.Start];
-                const body = decodeExternalPayload(readDynamicUtf8(bodyStart, bodyStart + task[TaskIndex.End]), processBoundary);
+                const body = decodeExternalPayload(readDynamicUtf8(bodyStart, bodyStart + (task[TaskIndex.End] & 0x7FFFFFFF)), processBoundary);
                 task.value = new Envelope(header, body);
                 freeTaskSlot(task);
                 return;
@@ -1333,7 +1553,7 @@ export const decodePayload = ({ lockSector, payload, sab, payloadConfig, headers
                     PayloadBuffer.EnvelopeDynamicHeaderStringExternal
                     ? rawHeader
                     : parseJSON(rawHeader);
-                const body = decodeExternalPayload(readDynamicUtf8(bodyStart, bodyStart + task[TaskIndex.End]), processBoundary);
+                const body = decodeExternalPayload(readDynamicUtf8(bodyStart, bodyStart + (task[TaskIndex.End] & 0x7FFFFFFF)), processBoundary);
                 task.value = new Envelope(header, body);
                 freeTaskSlot(task);
                 return;
@@ -1413,21 +1633,39 @@ export const decodePayload = ({ lockSector, payload, sab, payloadConfig, headers
                 return;
             }
             case PayloadBuffer.ExternalPayload:
-                task.value = decodeExternalPayload(readDynamicUtf8(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]), processBoundary);
+                task.value = decodeExternalPayload(readDynamicUtf8(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]), processBoundary, lockSector);
                 freeTaskSlot(task);
                 return;
             case PayloadBuffer.StaticExternalPayload:
-                task.value = decodeExternalPayload(readStaticUtf8(0, task[TaskIndex.PayloadLen], slotIndex), processBoundary);
+                task.value = decodeExternalPayload(readStaticUtf8(0, task[TaskIndex.PayloadLen], slotIndex), processBoundary, lockSector);
                 return;
             case PayloadBuffer.ProcessSharedBuffer:
                 task.value = decodeProcessSharedBufferNumericWords(readStaticU32Words(processSharedBufferWords, PROCESS_SHARED_BUFFER_NUMERIC_WORDS, slotIndex));
                 return;
-            case PayloadBuffer.SharedArrayBuffer:
-                task.value = decodeSharedArrayBufferNumericWords(readStaticU32Words(sharedArrayBufferWords, task[TaskIndex.PayloadLen] >>> 2, slotIndex));
+            case PayloadBuffer.SharedArrayBuffer: {
+                const wordCount = task[TaskIndex.PayloadLen] >>> 2;
+                task.value = decodeSharedArrayBufferNumericWords(readStaticU32Words(sharedArrayBufferWordViews[wordCount] ?? sharedArrayBufferWords, wordCount, slotIndex), lockSector);
                 return;
+            }
             case PayloadBuffer.BufferReference:
                 task.value = decodeBufferReferenceNumericWords(readStaticU32Words(bufferReferenceWords, BUFFER_REFERENCE_NUMERIC_WORDS, slotIndex));
                 return;
+            case PayloadBuffer.MovedBinary: {
+                const reference = decodeBufferReferenceNumericWords(readStaticU32Words(bufferReferenceWords, BUFFER_REFERENCE_NUMERIC_WORDS, slotIndex));
+                if (!isBufferReferenceValue(reference)) {
+                    throw new TypeError("Invalid moved Uint8Array payload");
+                }
+                task.value = reference.toUint8Array();
+                return;
+            }
+            case PayloadBuffer.MovedArrayBuffer: {
+                const reference = decodeBufferReferenceNumericWords(readStaticU32Words(bufferReferenceWords, BUFFER_REFERENCE_NUMERIC_WORDS, slotIndex));
+                if (!isBufferReferenceValue(reference)) {
+                    throw new TypeError("Invalid moved ArrayBuffer payload");
+                }
+                task.value = reference.toArrayBuffer();
+                return;
+            }
             case PayloadBuffer.Date:
                 Uint32View[0] = task[TaskIndex.Start];
                 Uint32View[1] = task[TaskIndex.End];
@@ -1437,6 +1675,12 @@ export const decodePayload = ({ lockSector, payload, sab, payloadConfig, headers
                 task.value = parseErrorPayload(readDynamicUtf8(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]));
                 freeTaskSlot(task);
                 return;
+            // Borrowed region: decode a view into the shared arena.
+            case PayloadBuffer.ArenaBinary:
+                // A borrowed region can sit past the length this endpoint last saw.
+                syncDynamicGrowth();
+                task.value = readDynamicBytesView(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]);
+                return;
             case PayloadBuffer.Binary:
                 {
                     const buffer = readDynamicBufferCopy(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]);