knitting 0.1.54 → 0.1.55

package/src/memory/payloadCodec.js

@@ -1,1334 +0,0 @@
-import { attachPayloadTransportFinalizer, beginPromisePayload, finishPromisePayload, getTaskSlotIndex, HEADER_BYTE_LENGTH, HEADER_SLOT_STRIDE_U32, HEADER_STATIC_PAYLOAD_U32, LockBound, PayloadBuffer, PayloadSignal, TaskIndex, } from "./lock.js";
-import { register } from "./regionRegistry.js";
-import { createSharedDynamicBufferIO, createSharedStaticBufferIO, } from "./shared-buffer-io.js";
-import { getStridedRegionSpanBytes } from "./byte-carpet.js";
-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";
-const BUFFER_REFERENCE_NUMERIC_TRANSFER = Symbol.for("knitting.bufferReference.numericTransfer");
-const memory = new ArrayBuffer(8);
-const Float64View = new Float64Array(memory);
-const BigInt64View = new BigInt64Array(memory);
-const Uint32View = new Uint32Array(memory);
-const textEncode = new TextEncoder();
-const runtimeBufferClass = globalThis.Buffer;
-const runtimeBufferByteLength = typeof runtimeBufferClass?.byteLength ===
-    "function"
-    ? ((value, encoding) => runtimeBufferClass.byteLength(value, encoding))
-    : undefined;
-const isRuntimeBuffer = (value) => typeof runtimeBufferClass?.isBuffer === "function" &&
-    runtimeBufferClass.isBuffer(value);
-const isRuntimeUint8Array = (value) => value != null &&
-    typeof value === "object" &&
-    Object.getPrototypeOf(value) === Uint8Array.prototype;
-const utf8ByteLength = !runtimeBufferByteLength
-    ? (text) => textEncode.encode(text).byteLength
-    : (text) => runtimeBufferByteLength(text, "utf8");
-const BIGINT64_MIN = -(1n << 63n);
-const BIGINT64_MAX = (1n << 63n) - 1n;
-const { parse: parseJSON, stringify: stringifyJSON } = JSON;
-const { for: symbolFor, keyFor: symbolKeyFor } = Symbol;
-const EXTERNAL_PAYLOAD_BRAND = symbolFor("knitting.payloadCodec");
-const BUFFER_REFERENCE_CODEC_ID = "knitting.bufferReference";
-const PROCESS_SHARED_BUFFER_CODEC_ID = "knitting.processSharedBuffer";
-const externalPayloadGlobal = globalThis;
-const objectGetPrototypeOf = Object.getPrototypeOf;
-const objectHasOwn = Object.prototype.hasOwnProperty;
-const arrayIsArray = Array.isArray;
-const objectPrototype = Object.prototype;
-const UNSUPPORTED_OBJECT_DETAIL = "Unsupported object type. Allowed: plain object, array, Error, Date, Envelope, Buffer, ArrayBuffer, DataView, typed arrays, and registered external payloads. Serialize it yourself.";
-const ENVELOPE_PAYLOAD_DETAIL = "Envelope payload must be an ArrayBuffer, SharedArrayBuffer, " +
-    "ProcessSharedBuffer, or BufferReference.";
-const ENVELOPE_HEADER_DETAIL = "Envelope header must be a JSON-like value or string.";
-const ENVELOPE_PROMISE_DETAIL = "Envelope header cannot contain Promise values.";
-const DYNAMIC_PAYLOAD_LIMIT_DETAIL = "Dynamic payload exceeds maxPayloadBytes.";
-const DYNAMIC_PAYLOAD_CAPACITY_DETAIL = "Dynamic payload buffer capacity exceeded.";
-const isPlainJsonObject = (value) => {
-    const proto = objectGetPrototypeOf(value);
-    return proto === objectPrototype || proto === null;
-};
-const readExternalPayloadCodecId = (value) => {
-    const codecId = value[EXTERNAL_PAYLOAD_BRAND];
-    return typeof codecId === "string" ? codecId : undefined;
-};
-const runtimeCode = (value) => {
-    switch (value) {
-        case "node":
-            return 1;
-        case "deno":
-            return 2;
-        case "bun":
-            return 3;
-        default:
-            return 0;
-    }
-};
-const kindCode = (value) => {
-    switch (value) {
-        case "shared-array-buffer":
-            return 1;
-        case "external-array-buffer":
-            return 2;
-        default:
-            return 0;
-    }
-};
-const isU32 = (value) => typeof value === "number" &&
-    Number.isInteger(value) &&
-    value >= 0 &&
-    value <= 0xffffffff;
-const isExternalPayloadLike = (value) => typeof value.toMetadata === "function" &&
-    typeof value[EXTERNAL_PAYLOAD_BRAND] ===
-        "string";
-const decodeExternalPayload = (raw) => {
-    const payload = parseJSON(raw);
-    if (!arrayIsArray(payload) || payload.length !== 2)
-        return payload;
-    const codecId = payload[0];
-    const metadata = payload[1];
-    if (typeof codecId !== "string") {
-        return { codec: codecId, metadata };
-    }
-    const codec = externalPayloadGlobal.__KNITTING_PAYLOAD_CODECS__?.[codecId];
-    return typeof codec?.decode === "function"
-        ? codec.decode(metadata)
-        : { codec: codecId, metadata };
-};
-const PROCESS_SHARED_BUFFER_NUMERIC_WORDS = 8;
-const BUFFER_REFERENCE_NUMERIC_WORDS = 8;
-const NUMERIC_SENTINEL = 0xffffffff;
-const decodeNumericExternalPayload = (codecId, words) => {
-    const codec = externalPayloadGlobal.__KNITTING_PAYLOAD_CODECS__?.[codecId];
-    if (typeof codec?.decodeNumeric === "function") {
-        return codec.decodeNumeric(words);
-    }
-    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);
-const tryEncodePrimitiveTask = (task) => {
-    const value = task.value;
-    switch (typeof value) {
-        case "number":
-            if (value !== value) {
-                task[TaskIndex.Type] = PayloadSignal.NaN;
-                return true;
-            }
-            Float64View[0] = value;
-            task[TaskIndex.Type] = PayloadSignal.Float64;
-            task[TaskIndex.Start] = Uint32View[0];
-            task[TaskIndex.End] = Uint32View[1];
-            return true;
-        case "boolean":
-            task[TaskIndex.Type] = value ? PayloadSignal.True : PayloadSignal.False;
-            return true;
-        case "undefined":
-            task[TaskIndex.Type] = PayloadSignal.Undefined;
-            return true;
-        case "bigint":
-            if (value < BIGINT64_MIN || value > BIGINT64_MAX)
-                return false;
-            BigInt64View[0] = value;
-            task[TaskIndex.Type] = PayloadSignal.BigInt;
-            task[TaskIndex.Start] = Uint32View[0];
-            task[TaskIndex.End] = Uint32View[1];
-            return true;
-        case "object":
-            if (value === null) {
-                task[TaskIndex.Type] = PayloadSignal.Null;
-                return true;
-            }
-            return false;
-        default:
-            return false;
-    }
-};
-const hasPromiseInEnvelopeHeader = (value, seen) => {
-    if (value instanceof Promise)
-        return true;
-    if (value === null || typeof value !== "object")
-        return false;
-    const objectValue = value;
-    const visited = seen ?? new Set();
-    if (visited.has(objectValue))
-        return false;
-    visited.add(objectValue);
-    if (arrayIsArray(objectValue)) {
-        const list = objectValue;
-        for (let i = 0; i < list.length; i++) {
-            if (hasPromiseInEnvelopeHeader(list[i], visited))
-                return true;
-        }
-        return false;
-    }
-    if (!isPlainJsonObject(objectValue))
-        return false;
-    const record = objectValue;
-    for (const key in record) {
-        if (!objectHasOwn.call(record, key))
-            continue;
-        if (hasPromiseInEnvelopeHeader(record[key], visited))
-            return true;
-    }
-    return false;
-};
-const toErrorCause = (cause) => {
-    if (cause === null || cause === undefined)
-        return cause;
-    switch (typeof cause) {
-        case "string":
-        case "number":
-        case "boolean":
-            return cause;
-        case "bigint":
-            return cause.toString();
-        case "symbol":
-        case "function":
-            return String(cause);
-    }
-    if (cause instanceof Error) {
-        const nested = {
-            name: cause.name,
-            message: cause.message,
-        };
-        if (typeof cause.stack === "string")
-            nested.stack = cause.stack;
-        if (objectHasOwn.call(cause, "cause")) {
-            nested.cause = toErrorCause(cause.cause);
-        }
-        return nested;
-    }
-    try {
-        return parseJSON(stringifyJSON(cause));
-    }
-    catch {
-        return String(cause);
-    }
-};
-const toErrorPayload = (error) => {
-    const payload = {
-        name: error.name,
-        message: error.message,
-    };
-    if (typeof error.stack === "string")
-        payload.stack = error.stack;
-    if (objectHasOwn.call(error, "cause")) {
-        payload.cause = toErrorCause(error.cause);
-    }
-    return payload;
-};
-const parseErrorPayload = (raw) => {
-    let parsed;
-    try {
-        parsed = parseJSON(raw);
-    }
-    catch {
-        return new Error(raw);
-    }
-    if (parsed == null || typeof parsed !== "object") {
-        return new Error(String(parsed));
-    }
-    const payload = parsed;
-    const err = new Error(typeof payload.message === "string" ? payload.message : "");
-    if (typeof payload.name === "string" && payload.name.length > 0) {
-        err.name = payload.name;
-    }
-    if (typeof payload.stack === "string") {
-        try {
-            err.stack = payload.stack;
-        }
-        catch {
-        }
-    }
-    if (objectHasOwn.call(payload, "cause")) {
-        err.cause = payload.cause;
-    }
-    return err;
-};
-const decodeBigIntBinary = (bytes) => {
-    const sign = bytes[0];
-    let value = 0n;
-    for (let i = bytes.length - 1; i >= 1; i--) {
-        value = (value << 8n) | BigInt(bytes[i]);
-    }
-    return sign === 1 ? -value : value;
-};
-const initStaticIO = (headersBuffer, headerSlotStrideU32, textCompat) => {
-    const slotStride = headerSlotStrideU32 ?? HEADER_SLOT_STRIDE_U32;
-    const requiredBytes = getStridedRegionSpanBytes({
-        slotCount: LockBound.slots,
-        slotStrideU32: slotStride,
-        slotLengthU32: HEADER_STATIC_PAYLOAD_U32,
-        baseU32: LockBound.header,
-    });
-    if (headersBuffer.byteLength < Math.max(requiredBytes, HEADER_BYTE_LENGTH)) {
-        return null;
-    }
-    return createSharedStaticBufferIO({
-        headersBuffer,
-        slotStrideU32: slotStride,
-        textCompat,
-    });
-};
-const requireStaticIO = (headersBuffer, headerSlotStrideU32, textCompat) => {
-    const staticIO = initStaticIO(headersBuffer, headerSlotStrideU32, textCompat);
-    if (staticIO === null) {
-        throw new RangeError("headersBuffer is too small for static payload IO");
-    }
-    return staticIO;
-};
-/**
- * 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, }) => {
-    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({
-        sab: payloadSab,
-        payloadConfig: resolvedPayloadConfig,
-        textCompat: textCompat?.payload,
-    });
-    const { maxBytes: staticMaxBytes, writeBinary: writeStaticBinary, writeBuffer: writeStaticBuffer, writeArrayBuffer: writeStaticArrayBuffer, writeExactUint8Array: writeStaticExactUint8Array, writeU32Words: writeStaticU32Words, write8Binary: writeStatic8Binary, writeUtf8: writeStaticUtf8, } = requireStaticIO(headersBuffer, headerSlotStrideU32, textCompat?.headers);
-    const dynamicLimitError = (task, actualBytes, label) => encoderError({
-        task,
-        type: ErrorKnitting.Serializable,
-        onPromise,
-        detail: `${DYNAMIC_PAYLOAD_LIMIT_DETAIL} limit=${maxPayloadBytes}; ` +
-            `actual=${actualBytes}; type=${label}.`,
-    });
-    const dynamicCapacityError = (task) => encoderError({
-        task,
-        type: ErrorKnitting.Serializable,
-        onPromise,
-        detail: DYNAMIC_PAYLOAD_CAPACITY_DETAIL,
-    });
-    const ensureWithinDynamicLimit = (task, bytes, label) => {
-        if (bytes <= maxPayloadBytes)
-            return true;
-        return dynamicLimitError(task, bytes, label);
-    };
-    const dynamicUtf8ReserveBytesWithExtra = (task, text, extraBytes, label) => {
-        const estimatedBytes = text.length * 3;
-        const estimatedTotal = estimatedBytes + extraBytes;
-        if (estimatedTotal <= maxPayloadBytes)
-            return estimatedBytes;
-        const exactBytes = utf8ByteLength(text);
-        const exactTotal = exactBytes + extraBytes;
-        if (exactTotal > maxPayloadBytes) {
-            dynamicLimitError(task, exactTotal, label);
-            return -1;
-        }
-        return exactBytes;
-    };
-    const dynamicUtf8ReserveBytes = (task, text, label) => dynamicUtf8ReserveBytesWithExtra(task, text, 0, label);
-    const reserveDynamic = (task, bytes) => {
-        task[TaskIndex.PayloadLen] = bytes;
-        // PayloadCodec only reserves after the lock has guaranteed capacity.
-        return allocTask(task);
-    };
-    let objectDynamicSlot = -1;
-    const reserveDynamicObject = (task, bytes) => {
-        task[TaskIndex.PayloadLen] = bytes;
-        const reservedSlot = allocTask(task);
-        objectDynamicSlot = reservedSlot;
-        return reservedSlot;
-    };
-    const rollbackObjectDynamic = () => {
-        if (objectDynamicSlot !== -1) {
-            free(objectDynamicSlot);
-            objectDynamicSlot = -1;
-        }
-    };
-    const failDynamicWriteAfterReserve = (task, reservedSlot) => {
-        free(reservedSlot);
-        if (objectDynamicSlot === reservedSlot)
-            objectDynamicSlot = -1;
-        return dynamicCapacityError(task);
-    };
-    let bigintScratch = new Uint8Array(16);
-    const encodeBigIntIntoScratch = (value) => {
-        let sign = 0;
-        let abs = value;
-        if (value < 0n) {
-            sign = 1;
-            abs = -value;
-        }
-        let at = 1;
-        while (abs > 0n) {
-            if (at >= bigintScratch.byteLength) {
-                const next = new Uint8Array(bigintScratch.byteLength << 1);
-                next.set(bigintScratch, 0);
-                bigintScratch = next;
-            }
-            bigintScratch[at++] = Number(abs & 0xffn);
-            abs >>= 8n;
-        }
-        bigintScratch[0] = sign;
-        return at;
-    };
-    const clearBigIntScratch = (used) => {
-        bigintScratch.fill(0, 0, used);
-    };
-    const encodeErrorObject = (task, error) => {
-        let text;
-        try {
-            text = stringifyJSON(toErrorPayload(error));
-        }
-        catch (encodeErrorReason) {
-            const detail = encodeErrorReason instanceof Error
-                ? encodeErrorReason.message
-                : String(encodeErrorReason);
-            return encoderError({
-                task,
-                type: ErrorKnitting.Serializable,
-                onPromise,
-                detail,
-            });
-        }
-        const reserveBytes = dynamicUtf8ReserveBytes(task, text, "Error");
-        if (reserveBytes < 0)
-            return false;
-        task[TaskIndex.Type] = PayloadBuffer.Error;
-        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;
-    };
-    const encodeObjectBinary = (task, slotIndex, bytesView, dynamicType, staticType) => {
-        const bytes = bytesView.byteLength;
-        if (bytes <= staticMaxBytes) {
-            const written = writeStaticBinary(bytesView, slotIndex);
-            if (written !== -1) {
-                task[TaskIndex.Type] = staticType;
-                task[TaskIndex.PayloadLen] = written;
-                task.value = null;
-                return true;
-            }
-        }
-        task[TaskIndex.Type] = dynamicType;
-        if (!ensureWithinDynamicLimit(task, bytes, PayloadBuffer[dynamicType])) {
-            return false;
-        }
-        const reservedSlot = reserveDynamicObject(task, bytes);
-        const written = writeDynamicBinary(bytesView, task[TaskIndex.Start]);
-        if (written < 0)
-            return failDynamicWriteAfterReserve(task, reservedSlot);
-        task[TaskIndex.PayloadLen] = written;
-        setSlotLength(reservedSlot, written);
-        task.value = null;
-        return true;
-    };
-    const encodeObjectUint8Array = (task, slotIndex, bytesView) => {
-        const bytes = bytesView.byteLength;
-        if (bytes <= staticMaxBytes) {
-            writeStaticExactUint8Array(bytesView, slotIndex);
-            task[TaskIndex.Type] = PayloadBuffer.StaticBinary;
-            task[TaskIndex.PayloadLen] = bytes;
-            task.value = null;
-            return true;
-        }
-        task[TaskIndex.Type] = PayloadBuffer.Binary;
-        if (!ensureWithinDynamicLimit(task, bytes, "Binary"))
-            return false;
-        const reservedSlot = reserveDynamicObject(task, bytes);
-        const written = writeDynamicBinary(bytesView, task[TaskIndex.Start]);
-        if (written < 0)
-            return failDynamicWriteAfterReserve(task, reservedSlot);
-        task[TaskIndex.PayloadLen] = written;
-        setSlotLength(reservedSlot, written);
-        task.value = null;
-        return true;
-    };
-    const encodeObjectBuffer = (task, slotIndex, buffer) => {
-        const bytes = buffer.byteLength;
-        if (bytes <= staticMaxBytes) {
-            const written = writeStaticBuffer(buffer, slotIndex);
-            if (written !== -1) {
-                task[TaskIndex.Type] = PayloadBuffer.StaticBuffer;
-                task[TaskIndex.PayloadLen] = written;
-                task.value = null;
-                return true;
-            }
-        }
-        task[TaskIndex.Type] = PayloadBuffer.Buffer;
-        if (!ensureWithinDynamicLimit(task, bytes, "Buffer"))
-            return false;
-        const reservedSlot = reserveDynamicObject(task, bytes);
-        const written = writeDynamicBuffer(buffer, task[TaskIndex.Start]);
-        if (written < 0)
-            return failDynamicWriteAfterReserve(task, reservedSlot);
-        task[TaskIndex.PayloadLen] = written;
-        setSlotLength(reservedSlot, written);
-        task.value = null;
-        return true;
-    };
-    const encodeObjectFloat64Array = (task, slotIndex, float64) => {
-        const bytes = float64.byteLength;
-        if (bytes <= staticMaxBytes) {
-            const written = writeStatic8Binary(float64, slotIndex);
-            if (written !== -1) {
-                task[TaskIndex.Type] = PayloadBuffer.StaticFloat64Array;
-                task[TaskIndex.PayloadLen] = written;
-                task.value = null;
-                return true;
-            }
-        }
-        task[TaskIndex.Type] = PayloadBuffer.Float64Array;
-        if (!ensureWithinDynamicLimit(task, bytes, "Float64Array"))
-            return false;
-        const reservedSlot = reserveDynamicObject(task, bytes);
-        const written = writeDynamic8Binary(float64, task[TaskIndex.Start]);
-        if (written < 0)
-            return failDynamicWriteAfterReserve(task, reservedSlot);
-        task[TaskIndex.PayloadLen] = written;
-        setSlotLength(reservedSlot, written);
-        task.value = null;
-        return true;
-    };
-    const encodeObjectArrayBuffer = (task, slotIndex, arrayBuffer) => {
-        const bytes = arrayBuffer.byteLength;
-        if (bytes <= staticMaxBytes) {
-            const written = writeStaticArrayBuffer(arrayBuffer, slotIndex);
-            if (written !== -1) {
-                task[TaskIndex.Type] = PayloadBuffer.StaticArrayBuffer;
-                task[TaskIndex.PayloadLen] = written;
-                task.value = null;
-                return true;
-            }
-        }
-        task[TaskIndex.Type] = PayloadBuffer.ArrayBuffer;
-        if (!ensureWithinDynamicLimit(task, bytes, "ArrayBuffer"))
-            return false;
-        const reservedSlot = reserveDynamicObject(task, bytes);
-        const written = writeDynamicArrayBuffer(arrayBuffer, task[TaskIndex.Start]);
-        if (written < 0)
-            return failDynamicWriteAfterReserve(task, reservedSlot);
-        task[TaskIndex.PayloadLen] = written;
-        setSlotLength(reservedSlot, written);
-        task.value = null;
-        return true;
-    };
-    const processSharedBufferWords = new Uint32Array(PROCESS_SHARED_BUFFER_NUMERIC_WORDS);
-    const sharedArrayBufferWords = new Uint32Array(SHARED_ARRAY_BUFFER_NUMERIC_WORDS);
-    const tryEncodeProcessSharedBufferNumeric = (task, slotIndex, value) => {
-        const descriptor = value.descriptor;
-        if (descriptor === undefined ||
-            descriptor.name !== undefined ||
-            !isU32(descriptor.fd) ||
-            !isU32(descriptor.size) ||
-            !isU32(descriptor.byteLength) ||
-            !isU32(value.byteOffset) ||
-            !isU32(value.byteLength)) {
-            return false;
-        }
-        const baseAddressMod64 = descriptor.baseAddressMod64;
-        if (baseAddressMod64 !== undefined &&
-            !isU32(baseAddressMod64)) {
-            return false;
-        }
-        processSharedBufferWords[0] = descriptor.fd;
-        processSharedBufferWords[1] = descriptor.size;
-        processSharedBufferWords[2] = descriptor.byteLength;
-        processSharedBufferWords[3] = value.byteOffset;
-        processSharedBufferWords[4] = value.byteLength;
-        processSharedBufferWords[5] = runtimeCode(descriptor.runtime);
-        processSharedBufferWords[6] = kindCode(descriptor.kind);
-        processSharedBufferWords[7] = baseAddressMod64 === undefined
-            ? NUMERIC_SENTINEL
-            : baseAddressMod64;
-        task[TaskIndex.Type] = PayloadBuffer.ProcessSharedBuffer;
-        // Static region is a Uint32Array shared in-process; write the descriptor
-        // words straight in instead of staging bytes through a DataView + copy.
-        task[TaskIndex.PayloadLen] = writeStaticU32Words(processSharedBufferWords, PROCESS_SHARED_BUFFER_NUMERIC_WORDS, slotIndex);
-        task.value = null;
-        return true;
-    };
-    const tryEncodeBufferReferenceNumeric = (task, slotIndex, value) => {
-        const words = value[BUFFER_REFERENCE_NUMERIC_TRANSFER]?.();
-        if (words === undefined)
-            return false;
-        task[TaskIndex.Type] = PayloadBuffer.BufferReference;
-        task[TaskIndex.PayloadLen] = writeStaticU32Words(words, BUFFER_REFERENCE_NUMERIC_WORDS, slotIndex);
-        attachPayloadTransportFinalizer(task, value);
-        task.value = null;
-        return true;
-    };
-    const tryEncodeSharedArrayBufferNumeric = (task, slotIndex, value) => {
-        const words = value[SHARED_ARRAY_BUFFER_NUMERIC_TRANSFER]?.(lockSector);
-        if (words === undefined)
-            return false;
-        sharedArrayBufferWords[0] = words[0] ?? 0;
-        sharedArrayBufferWords[1] = words[1] ?? 0;
-        sharedArrayBufferWords[2] = words[2] ?? 0;
-        sharedArrayBufferWords[3] = words[3] ?? 0;
-        sharedArrayBufferWords[4] = words[4] ?? 0;
-        sharedArrayBufferWords[5] = words[5] ?? 0;
-        sharedArrayBufferWords[6] = words[6] ?? 0;
-        sharedArrayBufferWords[7] = words[7] ?? 0;
-        task[TaskIndex.Type] = PayloadBuffer.SharedArrayBuffer;
-        task[TaskIndex.PayloadLen] = writeStaticU32Words(sharedArrayBufferWords, words.length, slotIndex);
-        task.value = null;
-        return true;
-    };
-    const encodeObjectExternalPayload = (task, slotIndex, externalPayload) => {
-        const codecId = readExternalPayloadCodecId(externalPayload);
-        if (codecId === undefined) {
-            return encoderError({
-                task,
-                type: ErrorKnitting.Serializable,
-                onPromise,
-                detail: UNSUPPORTED_OBJECT_DETAIL,
-            });
-        }
-        if (codecId === SHARED_ARRAY_BUFFER_CODEC_ID &&
-            tryEncodeSharedArrayBufferNumeric(task, slotIndex, externalPayload)) {
-            return true;
-        }
-        if (codecId === BUFFER_REFERENCE_CODEC_ID &&
-            tryEncodeBufferReferenceNumeric(task, slotIndex, externalPayload)) {
-            return true;
-        }
-        if (codecId === PROCESS_SHARED_BUFFER_CODEC_ID &&
-            tryEncodeProcessSharedBufferNumeric(task, slotIndex, externalPayload)) {
-            return true;
-        }
-        let text;
-        try {
-            text = stringifyJSON([codecId, externalPayload.toMetadata()]);
-        }
-        catch (error) {
-            const detail = error instanceof Error ? error.message : String(error);
-            return encoderError({
-                task,
-                type: ErrorKnitting.Serializable,
-                onPromise,
-                detail,
-            });
-        }
-        if (typeof text !== "string") {
-            return encoderError({
-                task,
-                type: ErrorKnitting.Serializable,
-                onPromise,
-                detail: "External payload metadata must be JSON serializable.",
-            });
-        }
-        if (text.length <= staticMaxBytes) {
-            const written = writeStaticUtf8(text, slotIndex);
-            if (written !== -1) {
-                task[TaskIndex.Type] = PayloadBuffer.StaticExternalPayload;
-                task[TaskIndex.PayloadLen] = written;
-                attachPayloadTransportFinalizer(task, externalPayload);
-                task.value = null;
-                return true;
-            }
-        }
-        task[TaskIndex.Type] = PayloadBuffer.ExternalPayload;
-        const reserveBytes = dynamicUtf8ReserveBytes(task, text, "ExternalPayload");
-        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);
-        attachPayloadTransportFinalizer(task, externalPayload);
-        task.value = null;
-        return true;
-    };
-    const encodeObjectDate = (task, date) => {
-        Float64View[0] = date.getTime();
-        task[TaskIndex.Type] = PayloadBuffer.Date;
-        task[TaskIndex.Start] = Uint32View[0];
-        task[TaskIndex.End] = Uint32View[1];
-        task.value = null;
-        return true;
-    };
-    const encodeEnvelopeHeaderText = (task, header, headerIsString) => {
-        if (hasPromiseInEnvelopeHeader(header)) {
-            encoderError({
-                task,
-                type: ErrorKnitting.Serializable,
-                onPromise,
-                detail: ENVELOPE_PROMISE_DETAIL,
-            });
-            return undefined;
-        }
-        if (headerIsString)
-            return header;
-        let headerText;
-        try {
-            headerText = stringifyJSON(header);
-        }
-        catch (error) {
-            const detail = error instanceof Error ? error.message : String(error);
-            encoderError({ task, type: ErrorKnitting.Json, onPromise, detail });
-            return undefined;
-        }
-        if (typeof headerText !== "string") {
-            encoderError({
-                task,
-                type: ErrorKnitting.Serializable,
-                onPromise,
-                detail: ENVELOPE_HEADER_DETAIL,
-            });
-            return undefined;
-        }
-        return headerText;
-    };
-    const resolveEnvelopeExternalBody = (body) => {
-        if (body === null || typeof body !== "object")
-            return undefined;
-        const sharedArrayBuffer = getSharedArrayBufferPayload(body);
-        if (sharedArrayBuffer !== undefined)
-            return sharedArrayBuffer;
-        if (isExternalPayloadLike(body)) {
-            return body;
-        }
-        return undefined;
-    };
-    const encodeEnvelopeArrayBufferBody = (task, slotIndex, headerText, headerIsString, payload) => {
-        const payloadBytes = new Uint8Array(payload);
-        const payloadLength = payloadBytes.byteLength;
-        const payloadReserveBytes = payloadLength > 0 ? payloadLength : 1;
-        const staticHeaderWritten = writeStaticUtf8(headerText, slotIndex);
-        if (staticHeaderWritten !== -1) {
-            if (!ensureWithinDynamicLimit(task, payloadReserveBytes, "EnvelopeStaticHeaderPayload"))
-                return false;
-            const reservedSlot = reserveDynamicObject(task, payloadReserveBytes);
-            task[TaskIndex.Type] = headerIsString
-                ? PayloadBuffer.EnvelopeStaticHeaderString
-                : PayloadBuffer.EnvelopeStaticHeader;
-            task[TaskIndex.PayloadLen] = staticHeaderWritten;
-            task[TaskIndex.End] = payloadLength;
-            if (payloadLength > 0) {
-                const payloadWritten = writeDynamicBinary(payloadBytes, task[TaskIndex.Start]);
-                if (payloadWritten < 0) {
-                    return failDynamicWriteAfterReserve(task, reservedSlot);
-                }
-                setSlotLength(reservedSlot, payloadWritten);
-            }
-            task.value = null;
-            return true;
-        }
-        const headerReserveBytes = dynamicUtf8ReserveBytesWithExtra(task, headerText, payloadLength, headerIsString ? "EnvelopeDynamicHeaderString" : "EnvelopeDynamicHeader");
-        if (headerReserveBytes < 0)
-            return false;
-        task[TaskIndex.Type] = headerIsString
-            ? PayloadBuffer.EnvelopeDynamicHeaderString
-            : PayloadBuffer.EnvelopeDynamicHeader;
-        const reservedSlot = reserveDynamicObject(task, headerReserveBytes + payloadLength);
-        const baseStart = task[TaskIndex.Start];
-        const writtenHeaderBytes = writeDynamicUtf8(headerText, baseStart, headerReserveBytes);
-        if (writtenHeaderBytes < 0) {
-            return failDynamicWriteAfterReserve(task, reservedSlot);
-        }
-        if (payloadLength > 0) {
-            const payloadWritten = writeDynamicBinary(payloadBytes, baseStart + writtenHeaderBytes);
-            if (payloadWritten < 0) {
-                return failDynamicWriteAfterReserve(task, reservedSlot);
-            }
-        }
-        task[TaskIndex.PayloadLen] = writtenHeaderBytes;
-        task[TaskIndex.End] = payloadLength;
-        setSlotLength(reservedSlot, writtenHeaderBytes + payloadLength);
-        task.value = null;
-        return true;
-    };
-    const encodeEnvelopeExternalBody = (task, slotIndex, headerText, headerIsString, externalBody) => {
-        const codecId = readExternalPayloadCodecId(externalBody);
-        if (codecId === undefined) {
-            return encoderError({
-                task,
-                type: ErrorKnitting.Serializable,
-                onPromise,
-                detail: ENVELOPE_PAYLOAD_DETAIL,
-            });
-        }
-        let bodyText;
-        try {
-            bodyText = stringifyJSON([codecId, externalBody.toMetadata()]);
-        }
-        catch (error) {
-            const detail = error instanceof Error ? error.message : String(error);
-            return encoderError({
-                task,
-                type: ErrorKnitting.Serializable,
-                onPromise,
-                detail,
-            });
-        }
-        if (typeof bodyText !== "string") {
-            return encoderError({
-                task,
-                type: ErrorKnitting.Serializable,
-                onPromise,
-                detail: "Envelope body metadata must be JSON serializable.",
-            });
-        }
-        const bodyBytes = textEncode.encode(bodyText);
-        const bodyLength = bodyBytes.byteLength;
-        const staticHeaderWritten = writeStaticUtf8(headerText, slotIndex);
-        if (staticHeaderWritten !== -1) {
-            if (!ensureWithinDynamicLimit(task, bodyLength, "EnvelopeStaticHeaderExternal"))
-                return false;
-            const reservedSlot = reserveDynamicObject(task, bodyLength);
-            task[TaskIndex.Type] = headerIsString
-                ? PayloadBuffer.EnvelopeStaticHeaderStringExternal
-                : PayloadBuffer.EnvelopeStaticHeaderExternal;
-            task[TaskIndex.PayloadLen] = staticHeaderWritten;
-            task[TaskIndex.End] = bodyLength;
-            const bodyWritten = writeDynamicBinary(bodyBytes, task[TaskIndex.Start]);
-            if (bodyWritten < 0) {
-                return failDynamicWriteAfterReserve(task, reservedSlot);
-            }
-            setSlotLength(reservedSlot, bodyWritten);
-            attachPayloadTransportFinalizer(task, externalBody);
-            task.value = null;
-            return true;
-        }
-        const headerReserveBytes = dynamicUtf8ReserveBytesWithExtra(task, headerText, bodyLength, headerIsString
-            ? "EnvelopeDynamicHeaderStringExternal"
-            : "EnvelopeDynamicHeaderExternal");
-        if (headerReserveBytes < 0)
-            return false;
-        task[TaskIndex.Type] = headerIsString
-            ? PayloadBuffer.EnvelopeDynamicHeaderStringExternal
-            : PayloadBuffer.EnvelopeDynamicHeaderExternal;
-        const reservedSlot = reserveDynamicObject(task, headerReserveBytes + bodyLength);
-        const baseStart = task[TaskIndex.Start];
-        const writtenHeaderBytes = writeDynamicUtf8(headerText, baseStart, headerReserveBytes);
-        if (writtenHeaderBytes < 0) {
-            return failDynamicWriteAfterReserve(task, reservedSlot);
-        }
-        const bodyWritten = writeDynamicBinary(bodyBytes, baseStart + writtenHeaderBytes);
-        if (bodyWritten < 0) {
-            return failDynamicWriteAfterReserve(task, reservedSlot);
-        }
-        task[TaskIndex.PayloadLen] = writtenHeaderBytes;
-        task[TaskIndex.End] = bodyLength;
-        setSlotLength(reservedSlot, writtenHeaderBytes + bodyLength);
-        attachPayloadTransportFinalizer(task, externalBody);
-        task.value = null;
-        return true;
-    };
-    const encodeObjectEnvelope = (task, slotIndex, envelope) => {
-        const header = envelope.header;
-        const payload = envelope.payload;
-        const headerIsString = typeof header === "string";
-        if (payload instanceof ArrayBuffer) {
-            const headerText = encodeEnvelopeHeaderText(task, header, headerIsString);
-            if (headerText === undefined)
-                return false;
-            return encodeEnvelopeArrayBufferBody(task, slotIndex, headerText, headerIsString, payload);
-        }
-        const externalBody = resolveEnvelopeExternalBody(payload);
-        if (externalBody !== undefined) {
-            const headerText = encodeEnvelopeHeaderText(task, header, headerIsString);
-            if (headerText === undefined)
-                return false;
-            return encodeEnvelopeExternalBody(task, slotIndex, headerText, headerIsString, externalBody);
-        }
-        return encoderError({
-            task,
-            type: ErrorKnitting.Serializable,
-            onPromise,
-            detail: ENVELOPE_PAYLOAD_DETAIL,
-        });
-    };
-    const encodeObjectPromise = (task, promise) => {
-        if (beginPromisePayload(task)) {
-            promise.then((value) => {
-                finishPromisePayload(task);
-                task.value = value;
-                onPromise(task, false, value);
-            }, (reason) => {
-                finishPromisePayload(task);
-                task.value = reason;
-                onPromise(task, true, reason);
-            });
-        }
-        return false;
-    };
-    // Named function so V8/TurboFan can compile it independently from the
-    // encodePayload factory closure. Anonymous returns prevent full optimization
-    // because the outer factory is too large for TurboFan's bytecode limit.
-    const encodeDispatch = (task, slotIndex) => {
-        const args = task.value;
-        if (tryEncodePrimitiveTask(task))
-            return true;
-        switch (typeof args) {
-            case "bigint": {
-                const binaryBytes = encodeBigIntIntoScratch(args);
-                const binary = bigintScratch.subarray(0, binaryBytes);
-                if (binaryBytes <= staticMaxBytes) {
-                    const written = writeStaticBinary(binary, slotIndex);
-                    if (written !== -1) {
-                        task[TaskIndex.Type] = PayloadBuffer.StaticBigInt;
-                        task[TaskIndex.PayloadLen] = written;
-                        clearBigIntScratch(binaryBytes);
-                        task.value = null;
-                        return true;
-                    }
-                }
-                task[TaskIndex.Type] = PayloadBuffer.BigInt;
-                if (!ensureWithinDynamicLimit(task, binaryBytes, "BigInt")) {
-                    clearBigIntScratch(binaryBytes);
-                    return false;
-                }
-                const reservedSlot = reserveDynamic(task, binaryBytes);
-                const written = writeDynamicBinary(binary, task[TaskIndex.Start]);
-                if (written < 0) {
-                    clearBigIntScratch(binaryBytes);
-                    return failDynamicWriteAfterReserve(task, reservedSlot);
-                }
-                task[TaskIndex.PayloadLen] = written;
-                setSlotLength(reservedSlot, written);
-                clearBigIntScratch(binaryBytes);
-                task.value = null;
-                return true;
-            }
-            case "function":
-                return encoderError({
-                    task,
-                    type: ErrorKnitting.Function,
-                    onPromise,
-                });
-            case "object":
-                objectDynamicSlot = -1;
-                try {
-                    const objectValue = args;
-                    const sharedArrayBufferPayload = getSharedArrayBufferPayload(objectValue);
-                    if (sharedArrayBufferPayload !== undefined) {
-                        return encodeObjectExternalPayload(task, slotIndex, sharedArrayBufferPayload);
-                    }
-                    const objectProto = objectGetPrototypeOf(objectValue);
-                    if (isRuntimeUint8Array(objectValue)) {
-                        return encodeObjectUint8Array(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;
-                    }
-                    const objectCtor = objectValue
-                        .constructor;
-                    if (isRuntimeBuffer(objectValue)) {
-                        return encodeObjectBuffer(task, slotIndex, objectValue);
-                    }
-                    switch (objectCtor) {
-                        case ArrayBuffer:
-                            return encodeObjectArrayBuffer(task, slotIndex, objectValue);
-                        case Int32Array: {
-                            const int32 = objectValue;
-                            return encodeObjectBinary(task, slotIndex, new Uint8Array(int32.buffer, int32.byteOffset, int32.byteLength), PayloadBuffer.Int32Array, PayloadBuffer.StaticInt32Array);
-                        }
-                        case Float64Array:
-                            return encodeObjectFloat64Array(task, slotIndex, objectValue);
-                        case BigInt64Array: {
-                            const bigInt64 = objectValue;
-                            return encodeObjectBinary(task, slotIndex, new Uint8Array(bigInt64.buffer, bigInt64.byteOffset, bigInt64.byteLength), PayloadBuffer.BigInt64Array, PayloadBuffer.StaticBigInt64Array);
-                        }
-                        case BigUint64Array: {
-                            const bigUint64 = objectValue;
-                            return encodeObjectBinary(task, slotIndex, new Uint8Array(bigUint64.buffer, bigUint64.byteOffset, bigUint64.byteLength), PayloadBuffer.BigUint64Array, PayloadBuffer.StaticBigUint64Array);
-                        }
-                        case DataView: {
-                            const dataView = objectValue;
-                            return encodeObjectBinary(task, slotIndex, new Uint8Array(dataView.buffer, dataView.byteOffset, dataView.byteLength), PayloadBuffer.DataView, PayloadBuffer.StaticDataView);
-                        }
-                        case Date:
-                            return encodeObjectDate(task, objectValue);
-                        case Envelope:
-                            return encodeObjectEnvelope(task, slotIndex, objectValue);
-                        case Promise:
-                            return encodeObjectPromise(task, objectValue);
-                        case Error:
-                            return encodeErrorObject(task, objectValue);
-                    }
-                    if (objectValue instanceof Date) {
-                        return encodeObjectDate(task, objectValue);
-                    }
-                    if (objectValue instanceof Envelope) {
-                        return encodeObjectEnvelope(task, slotIndex, objectValue);
-                    }
-                    if (objectValue instanceof Promise) {
-                        return encodeObjectPromise(task, objectValue);
-                    }
-                    if (objectValue instanceof Error) {
-                        return encodeErrorObject(task, objectValue);
-                    }
-                    if (isExternalPayloadLike(objectValue)) {
-                        return encodeObjectExternalPayload(task, slotIndex, objectValue);
-                    }
-                    return encoderError({
-                        task,
-                        type: ErrorKnitting.Serializable,
-                        onPromise,
-                        detail: UNSUPPORTED_OBJECT_DETAIL,
-                    });
-                }
-                catch (error) {
-                    rollbackObjectDynamic();
-                    const detail = error instanceof Error ? error.message : String(error);
-                    return encoderError({
-                        task,
-                        type: ErrorKnitting.Serializable,
-                        onPromise,
-                        detail,
-                    });
-                }
-            case "string": {
-                const text = args;
-                if (text.length <= staticMaxBytes) {
-                    const written = writeStaticUtf8(text, slotIndex);
-                    if (written !== -1) {
-                        task[TaskIndex.Type] = PayloadBuffer.StaticString;
-                        task[TaskIndex.PayloadLen] = written;
-                        task.value = null;
-                        return true;
-                    }
-                }
-                task[TaskIndex.Type] = PayloadBuffer.String;
-                const reserveBytes = dynamicUtf8ReserveBytes(task, text, "String");
-                if (reserveBytes < 0)
-                    return false;
-                const reservedSlot = reserveDynamic(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;
-            }
-            case "symbol": {
-                const key = symbolKeyFor(args);
-                if (key === undefined) {
-                    return encoderError({
-                        task,
-                        type: ErrorKnitting.Symbol,
-                        onPromise,
-                    });
-                }
-                if (key.length * 3 <= staticMaxBytes) {
-                    const written = writeStaticUtf8(key, slotIndex);
-                    if (written !== -1) {
-                        task[TaskIndex.Type] = PayloadBuffer.StaticSymbol;
-                        task[TaskIndex.PayloadLen] = written;
-                        task.value = null;
-                        return true;
-                    }
-                }
-                task[TaskIndex.Type] = PayloadBuffer.Symbol;
-                const reserveBytes = dynamicUtf8ReserveBytes(task, key, "Symbol");
-                if (reserveBytes < 0)
-                    return false;
-                const reservedSlot = reserveDynamic(task, reserveBytes);
-                const written = writeDynamicUtf8(key, task[TaskIndex.Start], reserveBytes);
-                if (written < 0) {
-                    return failDynamicWriteAfterReserve(task, reservedSlot);
-                }
-                task[TaskIndex.PayloadLen] = written;
-                setSlotLength(reservedSlot, written);
-                task.value = null;
-                return true;
-            }
-        }
-        return false;
-    };
-    return encodeDispatch;
-};
-export const decodePayload = ({ lockSector, payload, sab, payloadConfig, headersBuffer, headerSlotStrideU32, textCompat, host, }) => {
-    const payloadSab = payload?.sab ?? sab;
-    const resolvedPayloadConfig = resolvePayloadBufferOptions({
-        sab: payloadSab,
-        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({
-        sab: payloadSab,
-        payloadConfig: resolvedPayloadConfig,
-        textCompat: textCompat?.payload,
-    });
-    const { readUtf8: readStaticUtf8, readBytesBufferCopy: readStaticBufferCopy, readBufferCopy: readStaticBuffer, readUint8ArrayCopy: readStaticUint8ArrayCopy, readBytesArrayBufferCopy: readStaticArrayBufferCopy, readArrayBufferCopy: readStaticArrayBuffer, read8BytesFloatCopy: readStatic8BytesFloatCopy, readU32Words: readStaticU32Words, } = requireStaticIO(headersBuffer, headerSlotStrideU32, textCompat?.headers);
-    // Reusable scratch for the ProcessSharedBuffer raw-word decode. Safe to share:
-    // decode is single-consumer and not re-entrant, and the words are consumed
-    // synchronously when building the ProcessSharedBuffer.
-    const processSharedBufferWords = new Uint32Array(PROCESS_SHARED_BUFFER_NUMERIC_WORDS);
-    const sharedArrayBufferWords = new Uint32Array(SHARED_ARRAY_BUFFER_NUMERIC_WORDS);
-    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) => {
-        switch (task[TaskIndex.Type]) {
-            case PayloadSignal.BigInt:
-                Uint32View[0] = task[TaskIndex.Start];
-                Uint32View[1] = task[TaskIndex.End];
-                task.value = BigInt64View[0];
-                return;
-            case PayloadSignal.True:
-                task.value = true;
-                return;
-            case PayloadSignal.False:
-                task.value = false;
-                return;
-            case PayloadSignal.Float64:
-                Uint32View[0] = task[TaskIndex.Start];
-                Uint32View[1] = task[TaskIndex.End];
-                task.value = Float64View[0];
-                return;
-            case PayloadSignal.NaN:
-                task.value = NaN;
-                return;
-            case PayloadSignal.Null:
-                task.value = null;
-                return;
-            case PayloadSignal.Undefined:
-                task.value = undefined;
-                return;
-            case PayloadBuffer.String:
-                task.value = readDynamicUtf8(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]);
-                freeTaskSlot(task);
-                return;
-            case PayloadBuffer.StaticString:
-                task.value = readStaticUtf8(0, task[TaskIndex.PayloadLen], slotIndex);
-                return;
-            case PayloadBuffer.Json:
-                task.value = parseJSON(readDynamicUtf8(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]));
-                freeTaskSlot(task);
-                return;
-            case PayloadBuffer.StaticJson:
-                task.value = parseJSON(readStaticUtf8(0, task[TaskIndex.PayloadLen], slotIndex));
-                return;
-            case PayloadBuffer.EnvelopeStaticHeader:
-            case PayloadBuffer.EnvelopeStaticHeaderString: {
-                const rawHeader = readStaticUtf8(0, task[TaskIndex.PayloadLen], slotIndex);
-                const header = task[TaskIndex.Type] === PayloadBuffer.EnvelopeStaticHeaderString
-                    ? rawHeader
-                    : parseJSON(rawHeader);
-                const payloadLength = task[TaskIndex.End];
-                const payload = payloadLength > 0
-                    ? readDynamicArrayBufferCopy(task[TaskIndex.Start], task[TaskIndex.Start] + payloadLength)
-                    : new ArrayBuffer(0);
-                task.value = new Envelope(header, payload);
-                freeTaskSlot(task);
-                return;
-            }
-            case PayloadBuffer.EnvelopeDynamicHeader:
-            case PayloadBuffer.EnvelopeDynamicHeaderString: {
-                const headerStart = task[TaskIndex.Start];
-                const payloadStart = headerStart + task[TaskIndex.PayloadLen];
-                const payloadLength = task[TaskIndex.End];
-                const rawHeader = readDynamicUtf8(headerStart, payloadStart);
-                const header = task[TaskIndex.Type] === PayloadBuffer.EnvelopeDynamicHeaderString
-                    ? rawHeader
-                    : parseJSON(rawHeader);
-                const payload = payloadLength > 0
-                    ? readDynamicArrayBufferCopy(payloadStart, payloadStart + payloadLength)
-                    : new ArrayBuffer(0);
-                task.value = new Envelope(header, payload);
-                freeTaskSlot(task);
-                return;
-            }
-            case PayloadBuffer.EnvelopeStaticHeaderExternal:
-            case PayloadBuffer.EnvelopeStaticHeaderStringExternal: {
-                const rawHeader = readStaticUtf8(0, task[TaskIndex.PayloadLen], slotIndex);
-                const header = task[TaskIndex.Type] ===
-                    PayloadBuffer.EnvelopeStaticHeaderStringExternal
-                    ? rawHeader
-                    : parseJSON(rawHeader);
-                const bodyStart = task[TaskIndex.Start];
-                const body = decodeExternalPayload(readDynamicUtf8(bodyStart, bodyStart + task[TaskIndex.End]));
-                task.value = new Envelope(header, body);
-                freeTaskSlot(task);
-                return;
-            }
-            case PayloadBuffer.EnvelopeDynamicHeaderExternal:
-            case PayloadBuffer.EnvelopeDynamicHeaderStringExternal: {
-                const headerStart = task[TaskIndex.Start];
-                const bodyStart = headerStart + task[TaskIndex.PayloadLen];
-                const rawHeader = readDynamicUtf8(headerStart, bodyStart);
-                const header = task[TaskIndex.Type] ===
-                    PayloadBuffer.EnvelopeDynamicHeaderStringExternal
-                    ? rawHeader
-                    : parseJSON(rawHeader);
-                const body = decodeExternalPayload(readDynamicUtf8(bodyStart, bodyStart + task[TaskIndex.End]));
-                task.value = new Envelope(header, body);
-                freeTaskSlot(task);
-                return;
-            }
-            case PayloadBuffer.BigInt:
-                task.value = decodeBigIntBinary(readDynamicBufferCopy(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]));
-                freeTaskSlot(task);
-                return;
-            case PayloadBuffer.StaticBigInt:
-                task.value = decodeBigIntBinary(readStaticBufferCopy(0, task[TaskIndex.PayloadLen], slotIndex));
-                return;
-            case PayloadBuffer.Symbol:
-                task.value = symbolFor(readDynamicUtf8(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]));
-                freeTaskSlot(task);
-                return;
-            case PayloadBuffer.StaticSymbol:
-                task.value = symbolFor(readStaticUtf8(0, task[TaskIndex.PayloadLen], slotIndex));
-                return;
-            case PayloadBuffer.Int32Array: {
-                const bytes = readDynamicBufferCopy(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]);
-                task.value = new Int32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >>> 2);
-                freeTaskSlot(task);
-                return;
-            }
-            case PayloadBuffer.StaticInt32Array: {
-                const bytes = readStaticBufferCopy(0, task[TaskIndex.PayloadLen], slotIndex);
-                task.value = new Int32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >>> 2);
-                return;
-            }
-            case PayloadBuffer.Float64Array: {
-                task.value = readDynamic8BytesFloatCopy(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]);
-                freeTaskSlot(task);
-                return;
-            }
-            case PayloadBuffer.StaticFloat64Array:
-                task.value = readStatic8BytesFloatCopy(0, task[TaskIndex.PayloadLen], slotIndex);
-                return;
-            case PayloadBuffer.BigInt64Array: {
-                const bytes = readDynamicBufferCopy(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]);
-                task.value = new BigInt64Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >>> 3);
-                freeTaskSlot(task);
-                return;
-            }
-            case PayloadBuffer.StaticBigInt64Array: {
-                const bytes = readStaticBufferCopy(0, task[TaskIndex.PayloadLen], slotIndex);
-                task.value = new BigInt64Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >>> 3);
-                return;
-            }
-            case PayloadBuffer.BigUint64Array: {
-                const bytes = readDynamicBufferCopy(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]);
-                task.value = new BigUint64Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >>> 3);
-                freeTaskSlot(task);
-                return;
-            }
-            case PayloadBuffer.StaticBigUint64Array: {
-                const bytes = readStaticBufferCopy(0, task[TaskIndex.PayloadLen], slotIndex);
-                task.value = new BigUint64Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >>> 3);
-                return;
-            }
-            case PayloadBuffer.DataView: {
-                const bytes = readDynamicBufferCopy(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]);
-                task.value = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-                freeTaskSlot(task);
-                return;
-            }
-            case PayloadBuffer.StaticDataView: {
-                const bytes = readStaticBufferCopy(0, task[TaskIndex.PayloadLen], slotIndex);
-                task.value = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-                return;
-            }
-            case PayloadBuffer.ExternalPayload:
-                task.value = decodeExternalPayload(readDynamicUtf8(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]));
-                freeTaskSlot(task);
-                return;
-            case PayloadBuffer.StaticExternalPayload:
-                task.value = decodeExternalPayload(readStaticUtf8(0, task[TaskIndex.PayloadLen], slotIndex));
-                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));
-                return;
-            case PayloadBuffer.BufferReference:
-                task.value = decodeBufferReferenceNumericWords(readStaticU32Words(bufferReferenceWords, BUFFER_REFERENCE_NUMERIC_WORDS, slotIndex));
-                return;
-            case PayloadBuffer.Date:
-                Uint32View[0] = task[TaskIndex.Start];
-                Uint32View[1] = task[TaskIndex.End];
-                task.value = new Date(Float64View[0]);
-                return;
-            case PayloadBuffer.Error:
-                task.value = parseErrorPayload(readDynamicUtf8(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]));
-                freeTaskSlot(task);
-                return;
-            case PayloadBuffer.Binary:
-                {
-                    const buffer = readDynamicBufferCopy(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]);
-                    task.value = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-                }
-                freeTaskSlot(task);
-                return;
-            case PayloadBuffer.StaticBinary:
-                task.value = readStaticUint8ArrayCopy(0, task[TaskIndex.PayloadLen], slotIndex);
-                return;
-            case PayloadBuffer.ArrayBuffer:
-                task.value = readDynamicArrayBuffer(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]);
-                freeTaskSlot(task);
-                return;
-            case PayloadBuffer.StaticArrayBuffer:
-                task.value = readStaticArrayBuffer(0, task[TaskIndex.PayloadLen], slotIndex);
-                return;
-            case PayloadBuffer.Buffer:
-                task.value = readDynamicBuffer(task[TaskIndex.Start], task[TaskIndex.Start] + task[TaskIndex.PayloadLen]);
-                freeTaskSlot(task);
-                return;
-            case PayloadBuffer.StaticBuffer:
-                task.value = readStaticBuffer(0, task[TaskIndex.PayloadLen], slotIndex);
-                return;
-        }
-    };
-};