@zlink-systems/framework 0.30.3 → 0.32.0

package/dist/runtime/channels/channel-envelope.js

@@ -15,7 +15,6 @@ exports.decodeChannelPayload = decodeChannelPayload;
 exports.closeMessages = closeMessages;
 exports.decodeChannelHeader = decodeChannelHeader;
 exports.isValidChannelCorrelationId = isValidChannelCorrelationId;
-const runtime_message_1 = require("../backend/runtime-message");
 const node_crypto_1 = require("node:crypto");
 const node_buffer_1 = require("node:buffer");
 const contracts_1 = require("../../contracts");
@@ -47,7 +46,7 @@ const CHANNEL_CORRELATION_TEXT = /^[0-9a-f]{32}$/;
 const CHANNEL_FLOW_FIELD = ',"flowId":';
 // A flow id is a lowercase UUIDv7 (spec 27 §3): fixed 36 JSON-safe ASCII bytes.
 const PREPARED_CHANNEL_FLOW = '00000000-0000-7000-8000-000000000000';
-const CHANNEL_FLOW_TEXT = /^[0-9a-f-]{36}$/;
+const CHANNEL_FLOW_TEXT = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 // A per-process random 64-bit prefix followed by a per-process counter, both
 // as lowercase hex: unique among the runtime's pending requests (spec 06-obs/04
 // §3) without drawing random bytes for every request — the shape Java
@@ -56,8 +55,10 @@ const CHANNEL_CORRELATION_PREFIX = (0, node_crypto_1.randomBytes)(CHANNEL_CORREL
 let channelCorrelationCounter = 0;
 function newChannelCorrelationId() {
     channelCorrelationCounter += 1;
+    const suffix = channelCorrelationCounter.toString(16);
     return (CHANNEL_CORRELATION_PREFIX +
-        channelCorrelationCounter.toString(16).padStart(CHANNEL_CORRELATION_TEXT_LENGTH / 2, '0'));
+        PREPARED_CHANNEL_CORRELATION.slice(suffix.length, CHANNEL_CORRELATION_TEXT_LENGTH / 2) +
+        suffix);
 }
 function encodeChannelEnvelopeParts(kind, channelName, packetName, payload, timeoutMs, topic, codecs, correlationId, createFlow = true, metadata = EMPTY_OUTBOUND_METADATA) {
     return encodeChannelEnvelopePartsAtDeadline(kind, channelName, packetName, payload, timeoutMs === undefined ? undefined : Date.now() + timeoutMs, topic, codecs, correlationId, createFlow, metadata);
@@ -74,29 +75,14 @@ function encodeChannelEnvelopePartsAtDeadline(kind, channelName, packetName, pay
         throw new RangeError('deadlineUnixMs must be a positive safe integer.');
     }
     const messageName = (0, packet_name_1.resolveFrameworkPacketName)(payload, packetName, 'Channel');
-    const encoded = encodePayload(payload, (0, channel_framework_packets_1.codecsForFrameworkPacket)(messageName, codecs), messageName, 'payload');
-    const flow = createFlow ? (0, flow_context_1.currentOrCreateFlow)('Application') : undefined;
-    const envelopeCorrelationId = correlationIdForOutboundKind(kind, correlationId);
-    return [
-        encodeChannelHeader(kind, channelName, messageName, encoded.contentType, envelopeCorrelationId, deadlineUnixMs === undefined ? null : new Date(deadlineUnixMs).toISOString(), topic ?? null, null, null, undefined, applicationMetadataRecord(metadata), flow?.flowId, flow?.flowOrigin, codecs),
-        encoded.message
-    ];
+    return encodePayload(payload, (0, channel_framework_packets_1.codecsForFrameworkPacket)(messageName, codecs), messageName, 'payload', kind, channelName, correlationId, deadlineUnixMs, topic, createFlow, metadata, undefined, codecs);
 }
 function encodeChannelPublishEnvelopeParts(channelName, topic, packetName, payload, codecs, createFlow = true, metadata = EMPTY_OUTBOUND_METADATA) {
     const messageName = (0, packet_name_1.resolveFrameworkPacketName)(payload, packetName, 'Channel');
-    const encoded = encodePayload(payload, (0, channel_framework_packets_1.codecsForFrameworkPacket)(messageName, codecs), messageName, 'payload');
-    const flow = createFlow ? (0, flow_context_1.currentOrCreateFlow)('Application') : undefined;
-    return [
-        encodeChannelHeader(4 /* ZLinkChannelMessageKind.Publish */, channelName, messageName, encoded.contentType, null, null, topic, null, null, undefined, applicationMetadataRecord(metadata), flow?.flowId, flow?.flowOrigin),
-        encoded.message
-    ];
+    return encodePayload(payload, (0, channel_framework_packets_1.codecsForFrameworkPacket)(messageName, codecs), messageName, 'payload', 4 /* ZLinkChannelMessageKind.Publish */, channelName, undefined, undefined, topic, createFlow, metadata);
 }
 function encodeChannelReplyParts(request, payload, codecs) {
-    const encoded = encodePayload(payload ?? Buffer.alloc(0), (0, channel_framework_packets_1.codecsForFrameworkPacket)(request.messageName, codecs), request.messageName, 'reply');
-    return [
-        encodeChannelHeader(2 /* ZLinkChannelMessageKind.Response */, request.channelName, request.messageName, encoded.contentType, request.correlationId, null, null, undefined, undefined, undefined, EMPTY_APPLICATION_METADATA, request.flowId, request.flowOrigin, codecs),
-        encoded.message
-    ];
+    return encodePayload(payload ?? Buffer.alloc(0), (0, channel_framework_packets_1.codecsForFrameworkPacket)(request.messageName, codecs), request.messageName, 'reply', 2 /* ZLinkChannelMessageKind.Response */, request.channelName, request.correlationId ?? undefined, undefined, undefined, false, EMPTY_OUTBOUND_METADATA, request, codecs);
 }
 /**
  * Reply metadata marker for errors the framework generated itself (never for
@@ -138,7 +124,7 @@ function encodeChannelErrorReplyParts(request, error, metadata = {}) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     return [
         encodeChannelHeader(5 /* ZLinkChannelMessageKind.Error */, request.channelName, request.messageName, exports.JSON_CONTENT_TYPE, request.correlationId, null, null, errorCode, errorMessage, undefined, metadata, request.flowId, request.flowOrigin),
-        encodeJsonBytes(null)
+        encodeJsonText(null)
     ];
 }
 function decodeChannelReply(parts, codecs) {
@@ -158,16 +144,17 @@ function decodeChannelReply(parts, codecs) {
         header.contentType !== exports.JSON_CONTENT_TYPE) {
         throw unsupportedChannelContentType(header.contentType);
     }
-    if (parts.length < 2 || parts[1].data().length === 0) {
+    const body = parts.length < 2 ? undefined : parts[1].data();
+    if (body === undefined || body.length === 0) {
         return undefined;
     }
     if (header.contentType === exports.BINARY_CONTENT_TYPE) {
-        return runtime_message_1.ZLinkBufferMessage.retainPayload(parts[1]);
+        return body;
     }
     if (serializer !== undefined) {
-        return serializer.deserialize((0, payload_codec_1.encodedPayloadFromOwned)(parts[1].data()), Object);
+        return serializer.deserialize((0, payload_codec_1.encodedPayloadFromOwned)(body), Object);
     }
-    return parseWireJson(parts[1].data().toString(), (0, Attributes_1.readZLinkPacketJsonContract)(header.messageName)?.reply);
+    return parseWireJson(body.toString(), (0, Attributes_1.readZLinkPacketJsonContract)(header.messageName)?.reply);
 }
 function decodeChannelError(header) {
     const code = header.errorCode;
@@ -215,14 +202,14 @@ function decodeChannelEnvelope(parts, decodedHeader, flowEnabled = true) {
     // Borrow its Buffer so envelope admission does not copy the whole payload.
     return { header, packetName: header.messageName, payload: parts[1].data() };
 }
-function decodeChannelPayload(envelope, codecs) {
+function decodeChannelPayload(envelope, codecs, messageType) {
     try {
         if (!(0, CodecContentType_1.isCanonicalCodecContentType)(envelope.header.contentType)) {
             throw unsupportedChannelContentType(envelope.header.contentType);
         }
         const serializer = codecs?.serializers.get(envelope.header.contentType);
         if (serializer !== undefined) {
-            return serializer.deserialize((0, payload_codec_1.encodedPayloadFromOwned)(envelope.payload), Object);
+            return serializer.deserialize((0, payload_codec_1.encodedPayloadFromOwned)(envelope.payload), (messageType ?? Object));
         }
         if (envelope.header.contentType === exports.BINARY_CONTENT_TYPE) {
             // The receive loop owns the Message for the duration of dispatch, so
@@ -230,7 +217,7 @@ function decodeChannelPayload(envelope, codecs) {
             return envelope.payload;
         }
         if (envelope.header.contentType === exports.JSON_CONTENT_TYPE) {
-            return parseWireJson(envelope.payload.toString(), schemaForInboundChannelEnvelope(envelope.header));
+            return (0, ZLinkMessage_1.materializeZLinkMessageValue)(parseWireJson(envelope.payload.toString(), schemaForInboundChannelEnvelope(envelope.header)), messageType);
         }
         throw unsupportedChannelContentType(envelope.header.contentType);
     }
@@ -251,36 +238,45 @@ function closeMessages(parts) {
         }
     }
 }
-function encodePayload(value, codecs, packetName, contractPart) {
+function encodePayload(value, codecs, packetName, contractPart, kind, channelName, correlationId, deadlineUnixMs, topic, createFlow, metadata, request, headerCodecs) {
+    let declaredType;
+    let contentType;
+    let message;
     if ((0, ZLinkMessage_1.isZLinkMessage)(value) && value.isEncoded()) {
         const payload = value.toEncodedPayload();
-        return {
-            contentType: exports.BINARY_CONTENT_TYPE,
-            message: (0, encoded_payload_storage_1.borrowEncodedPayload)(payload) ?? payload.data()
-        };
+        contentType = exports.BINARY_CONTENT_TYPE;
+        message = (0, encoded_payload_storage_1.borrowEncodedPayload)(payload) ?? payload.data();
     }
-    const declaredType = (0, ZLinkMessage_1.isZLinkMessage)(value) ? (0, ZLinkMessage_1.readZLinkMessageDeclaredType)(value) : undefined;
-    if ((0, ZLinkMessage_1.isZLinkMessage)(value))
-        value = value.decode();
-    const selected = (0, payload_codec_1.selectSerializerWithContentType)(value, codecs, declaredType);
-    if (selected !== undefined &&
-        !(Buffer.isBuffer(value) || value instanceof Uint8Array || isMessage(value))) {
-        const payload = selected.serializer.serialize(value);
-        return {
-            contentType: selected.contentType,
-            message: (0, encoded_payload_storage_1.borrowEncodedPayload)(payload) ?? payload.data()
-        };
+    else {
+        if ((0, ZLinkMessage_1.isZLinkMessage)(value)) {
+            declaredType = (0, ZLinkMessage_1.readZLinkMessageDeclaredType)(value);
+            value = value.decode();
+        }
+        const selected = (0, payload_codec_1.selectSerializerWithContentType)(value, codecs, declaredType);
+        if (selected !== undefined &&
+            !(Buffer.isBuffer(value) || value instanceof Uint8Array || isMessage(value))) {
+            const payload = selected.serializer.serialize(value);
+            contentType = selected.contentType;
+            message = (0, encoded_payload_storage_1.borrowEncodedPayload)(payload) ?? payload.data();
+        }
+        else {
+            contentType = contentTypeOf(value);
+            message = toMessageLike(value, (0, Attributes_1.readZLinkPacketJsonContract)(packetName)?.[contractPart]);
+        }
     }
-    return {
-        contentType: contentTypeOf(value),
-        message: toMessageLike(value, (0, Attributes_1.readZLinkPacketJsonContract)(packetName)?.[contractPart])
-    };
+    const flow = request ?? (createFlow ? (0, flow_context_1.currentOrCreateFlow)('Application') : undefined);
+    return [
+        encodeChannelHeader(kind, channelName, packetName, contentType, request === undefined
+            ? correlationIdForOutboundKind(kind, correlationId)
+            : request.correlationId, deadlineUnixMs === undefined ? null : new Date(deadlineUnixMs).toISOString(), topic ?? null, contractPart === 'reply' ? undefined : null, contractPart === 'reply' ? undefined : null, undefined, applicationMetadataRecord(metadata), flow?.flowId, flow?.flowOrigin, headerCodecs),
+        message
+    ];
 }
 function toMessageLike(value, schema) {
     if (Buffer.isBuffer(value) || value instanceof Uint8Array || isMessage(value)) {
         return value;
     }
-    return encodeJsonBytes(value, schema);
+    return encodeJsonText(value, schema);
 }
 function contentTypeOf(value) {
     return Buffer.isBuffer(value) || value instanceof Uint8Array || isMessage(value)
@@ -292,8 +288,8 @@ function isMessage(value) {
         value !== null &&
         typeof value.data === 'function');
 }
-function encodeJsonBytes(value, schema) {
-    return Buffer.from((0, framework_json_v1_1.stringifyFrameworkJsonV1)(value, schema));
+function encodeJsonText(value, schema) {
+    return (0, framework_json_v1_1.stringifyFrameworkJsonV1)(value, schema);
 }
 function encodeChannelHeader(kind, channelName, messageName, contentType, correlationId, deadline, topic, errorCode, errorMessage, source, metadata, flowId, flowOrigin, codecs) {
     if (codecs !== undefined &&
@@ -525,34 +521,62 @@ function decodeChannelHeader(parts, flowEnabled = true) {
     if (parts.length === 0) {
         throw new configuration_1.ZLinkConfigurationException('Channel envelope header part is missing.');
     }
-    return validateChannelHeader(parseChannelHeaderBytes(parts[0].data()), flowEnabled);
+    return validateChannelHeader(parseChannelHeaderBytes(parts[0].data(), flowEnabled), flowEnabled);
 }
+const CHANNEL_JSON_PARSE_OPTIONS = Object.freeze({ rejectPropertyName: isPrototypeKey });
 function parseWireJson(payload, schema) {
-    return (0, framework_json_v1_1.parseFrameworkJsonV1)(payload, {
-        rejectPropertyName: isPrototypeKey
-    }, schema);
-}
-function parseChannelHeaderBytes(payload) {
-    const reader = new CanonicalChannelHeaderReader(payload);
-    const canonical = tryParseCanonicalChannelHeader(reader);
-    // An all-ASCII canonical header is valid UTF-8 by construction; any other
-    // header is checked before it is decoded.
-    if (canonical !== undefined && !reader.sawNonAscii)
-        return canonical;
+    return (0, framework_json_v1_1.parseFrameworkJsonV1)(payload, CHANNEL_JSON_PARSE_OPTIONS, schema);
+}
+const CHANNEL_HEADER_FIELD_NAMES = [
+    '',
+    'formatMarker',
+    'kind',
+    'channelName',
+    'messageName',
+    'contentType',
+    'correlationId',
+    'deadline',
+    'topic',
+    'errorCode',
+    'errorMessage',
+    'source',
+    'flowId',
+    'flowOrigin',
+    'metadata'
+];
+const CHANNEL_HEADER_FIELD_COUNT = CHANNEL_HEADER_FIELD_NAMES.length - 1;
+const CHANNEL_HEADER_INVALID_VALUE = Symbol('invalid channel header value');
+const CANONICAL_CHANNEL_HEADER_PREFIX = '{"formatMarker":242,"kind":';
+function parseChannelHeaderBytes(payload, flowEnabled) {
+    if (startsWithJson(payload, CANONICAL_CHANNEL_HEADER_PREFIX)) {
+        const reader = new CanonicalChannelHeaderReader(payload, CANONICAL_CHANNEL_HEADER_PREFIX.length);
+        const canonical = tryParseCanonicalChannelHeader(reader, flowEnabled);
+        // Canonical ASCII headers need no UTF-8 pass; all other paths are checked
+        // before byte slices are decoded.
+        if (canonical !== undefined && !reader.sawNonAscii)
+            return canonical;
+        if (canonical !== undefined) {
+            if (!(0, node_buffer_1.isUtf8)(payload)) {
+                throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.ProtocolError, 'Channel envelope header must contain valid UTF-8.');
+            }
+            return canonical;
+        }
+    }
     if (!(0, node_buffer_1.isUtf8)(payload)) {
         throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.ProtocolError, 'Channel envelope header must contain valid UTF-8.');
     }
-    return canonical ?? (0, framework_json_v1_1.parseFrameworkJsonV1)(payload.toString());
+    return new ChannelHeaderJsonReader(payload, flowEnabled).parse();
 }
-/**
- * Accept the byte layout emitted by writeChannelHeader without materializing
- * the enclosing JSON text. Any variation falls through to the established
- * framework-json-v1 parser, which remains the sole authority for JSON
- * failures and unknown properties. Header metadata accepts every valid string key.
- */
-function tryParseCanonicalChannelHeader(reader) {
-    if (!reader.consume('{"formatMarker":242,"kind":'))
-        return undefined;
+function startsWithJson(bytes, value) {
+    if (bytes.length < value.length)
+        return false;
+    for (let index = 0; index < value.length; index += 1) {
+        if (bytes[index] !== value.charCodeAt(index))
+            return false;
+    }
+    return true;
+}
+function tryParseCanonicalChannelHeader(reader, flowEnabled) {
     const kind = reader.readSingleDigit();
     if (kind === undefined || !reader.consume(',"channelName":'))
         return undefined;
@@ -582,7 +606,13 @@ function tryParseCanonicalChannelHeader(reader) {
         contentType,
         correlationId: correlationId === NULL_JSON_STRING ? null : correlationId,
         deadline: deadline === NULL_JSON_STRING ? null : deadline,
-        topic: topic === NULL_JSON_STRING ? null : topic
+        topic: topic === NULL_JSON_STRING ? null : topic,
+        errorCode: null,
+        errorMessage: null,
+        source: undefined,
+        metadata: undefined,
+        flowId: undefined,
+        flowOrigin: undefined
     };
     if (!reader.readOptionalNullableString(CANONICAL_ERROR_CODE, 'errorCode', header))
         return undefined;
@@ -590,10 +620,13 @@ function tryParseCanonicalChannelHeader(reader) {
         return undefined;
     if (!reader.readOptionalNullableString(CANONICAL_SOURCE, 'source', header))
         return undefined;
-    // Empty metadata validates to the shared empty record.
-    if (!reader.consume(',"metadata":{}'))
+    const metadata = reader.readMetadata();
+    if (metadata === undefined)
         return undefined;
-    if (!reader.readOptionalString(CANONICAL_FLOW_ID, 'flowId', header))
+    // Empty metadata validates to the shared empty record.
+    if (metadata !== NULL_JSON_STRING)
+        header.metadata = metadata;
+    if (!reader.readOptionalString(CANONICAL_FLOW_ID, 'flowId', header, flowEnabled))
         return undefined;
     if (!reader.readOptionalSingleDigit(CANONICAL_FLOW_ORIGIN, 'flowOrigin', header))
         return undefined;
@@ -610,8 +643,9 @@ class CanonicalChannelHeaderReader {
     index = 0;
     /** A string held a byte outside ASCII, so the caller must still check UTF-8. */
     sawNonAscii = false;
-    constructor(bytes) {
+    constructor(bytes, initialIndex = 0) {
         this.bytes = bytes;
+        this.index = initialIndex;
     }
     atEnd() {
         return this.index === this.bytes.length;
@@ -686,6 +720,41 @@ class CanonicalChannelHeaderReader {
             return NULL_JSON_STRING;
         return this.readString();
     }
+    readMetadata() {
+        if (!this.consume(',"metadata":{'))
+            return undefined;
+        if (this.consume('}'))
+            return NULL_JSON_STRING;
+        const metadata = {};
+        for (;;) {
+            const key = this.readString();
+            if (key === undefined)
+                return undefined;
+            if (Object.prototype.hasOwnProperty.call(metadata, key)) {
+                throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.ProtocolError, 'duplicate envelope metadata key');
+            }
+            if (!this.consume(':'))
+                return undefined;
+            const value = this.readString();
+            if (value === undefined)
+                return undefined;
+            if (key === '__proto__') {
+                Object.defineProperty(metadata, key, {
+                    configurable: true,
+                    enumerable: true,
+                    value,
+                    writable: true
+                });
+            }
+            else {
+                metadata[key] = value;
+            }
+            if (this.consume('}'))
+                return metadata;
+            if (!this.consume(','))
+                return undefined;
+        }
+    }
     readOptionalNullableString(token, name, target) {
         if (!this.consume(token))
             return true;
@@ -695,15 +764,54 @@ class CanonicalChannelHeaderReader {
         target[name] = value === NULL_JSON_STRING ? null : value;
         return true;
     }
-    readOptionalString(token, name, target) {
+    readOptionalString(token, name, target, decode = true) {
         if (!this.consume(token))
             return true;
+        if (!decode)
+            return this.skipString();
         const value = this.readString();
         if (value === undefined)
             return false;
         target[name] = value;
         return true;
     }
+    skipString() {
+        if (this.bytes[this.index] !== 0x22)
+            return false;
+        this.index += 1;
+        while (this.index < this.bytes.length) {
+            const value = this.bytes[this.index++];
+            if (value === 0x22)
+                return true;
+            if (value < 0x20)
+                return false;
+            if (value >= 0x80)
+                this.sawNonAscii = true;
+            if (value !== 0x5c)
+                continue;
+            if (this.index === this.bytes.length)
+                return false;
+            const escaped = this.bytes[this.index++];
+            if (escaped === 0x75) {
+                for (let count = 0; count < 4; count += 1) {
+                    if (this.index === this.bytes.length || !isHexDigit(this.bytes[this.index]))
+                        return false;
+                    this.index += 1;
+                }
+            }
+            else if (escaped !== 0x22 &&
+                escaped !== 0x5c &&
+                escaped !== 0x2f &&
+                escaped !== 0x62 &&
+                escaped !== 0x66 &&
+                escaped !== 0x6e &&
+                escaped !== 0x72 &&
+                escaped !== 0x74) {
+                return false;
+            }
+        }
+        return false;
+    }
     readOptionalSingleDigit(token, name, target) {
         if (!this.consume(token))
             return true;
@@ -719,6 +827,419 @@ function isHexDigit(value) {
         (value >= 0x41 && value <= 0x46) ||
         (value >= 0x61 && value <= 0x66));
 }
+/** Reads a noncanonical channel header directly from its UTF-8 bytes. */
+class ChannelHeaderJsonReader {
+    bytes;
+    flowEnabled;
+    index = 0;
+    propertyName = '';
+    stringStart = 0;
+    stringEnd = 0;
+    stringHasEscapes = false;
+    constructor(bytes, flowEnabled) {
+        this.bytes = bytes;
+        this.flowEnabled = flowEnabled;
+    }
+    parse() {
+        if (this.bytes.length >= 3 &&
+            this.bytes[0] === 0xef &&
+            this.bytes[1] === 0xbb &&
+            this.bytes[2] === 0xbf) {
+            throw new SyntaxError('framework-json-v1 does not allow a UTF-8 BOM.');
+        }
+        this.skipWhitespace();
+        if (this.bytes[this.index] !== 0x7b) {
+            this.skipValue();
+            this.skipWhitespace();
+            if (this.index !== this.bytes.length)
+                this.fail('trailing data');
+            return CHANNEL_HEADER_INVALID_VALUE;
+        }
+        const header = {};
+        let seenFields = 0;
+        this.index += 1;
+        this.skipWhitespace();
+        if (this.consumeByte(0x7d))
+            return this.finish(header);
+        for (;;) {
+            const field = this.readPropertyName(true);
+            const propertyName = this.propertyName;
+            this.skipWhitespace();
+            this.expectByte(0x3a, "':' after object property");
+            this.skipWhitespace();
+            if (field !== 0) {
+                const bit = 1 << field;
+                if ((seenFields & bit) !== 0) {
+                    throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.ProtocolError, 'duplicate envelope header field');
+                }
+                seenFields |= bit;
+                const name = CHANNEL_HEADER_FIELD_NAMES[field];
+                if (!this.flowEnabled && (field === 12 || field === 13)) {
+                    this.skipValue();
+                    header[name] = undefined;
+                }
+                else if (field === 14) {
+                    header[name] = this.readMetadata();
+                }
+                else {
+                    header[name] = this.readValue(field === 1 || field === 2 || field === 13);
+                }
+            }
+            else {
+                const value = this.readValue();
+                if (propertyName === '__proto__') {
+                    Object.defineProperty(header, propertyName, {
+                        configurable: true,
+                        enumerable: true,
+                        value,
+                        writable: true
+                    });
+                }
+                else {
+                    header[propertyName] = value;
+                }
+            }
+            this.skipWhitespace();
+            if (this.consumeByte(0x7d))
+                break;
+            this.expectByte(0x2c, "',' or '}' after object property");
+            this.skipWhitespace();
+        }
+        return this.finish(header);
+    }
+    finish(header) {
+        this.skipWhitespace();
+        if (this.index !== this.bytes.length)
+            this.fail('trailing data');
+        return header;
+    }
+    readMetadata() {
+        if (this.bytes[this.index] !== 0x7b)
+            return this.readValue();
+        this.index += 1;
+        this.skipWhitespace();
+        if (this.consumeByte(0x7d))
+            return undefined;
+        const metadata = {};
+        for (;;) {
+            const key = this.readString();
+            if (Object.prototype.hasOwnProperty.call(metadata, key)) {
+                throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.ProtocolError, 'duplicate envelope metadata key');
+            }
+            this.skipWhitespace();
+            this.expectByte(0x3a, "':' after object property");
+            this.skipWhitespace();
+            const value = this.readValue();
+            if (key === '__proto__') {
+                Object.defineProperty(metadata, key, {
+                    configurable: true,
+                    enumerable: true,
+                    value,
+                    writable: true
+                });
+            }
+            else {
+                metadata[key] = value;
+            }
+            this.skipWhitespace();
+            if (this.consumeByte(0x7d))
+                return metadata;
+            this.expectByte(0x2c, "',' or '}' after object property");
+            this.skipWhitespace();
+        }
+    }
+    readPropertyName(materializeUnknown = false) {
+        this.scanString();
+        let field = 0;
+        let decoded;
+        if (this.stringHasEscapes) {
+            decoded = this.decodeString();
+            for (let candidate = 1; candidate <= CHANNEL_HEADER_FIELD_COUNT; candidate += 1) {
+                if (CHANNEL_HEADER_FIELD_NAMES[candidate] === decoded) {
+                    field = candidate;
+                    break;
+                }
+            }
+        }
+        else {
+            for (let candidate = 1; candidate <= CHANNEL_HEADER_FIELD_COUNT; candidate += 1) {
+                if (this.matchesAscii(this.stringStart + 1, this.stringEnd - 1, CHANNEL_HEADER_FIELD_NAMES[candidate])) {
+                    field = candidate;
+                    break;
+                }
+            }
+        }
+        this.propertyName =
+            field !== 0
+                ? CHANNEL_HEADER_FIELD_NAMES[field]
+                : (decoded ??
+                    (materializeUnknown
+                        ? this.bytes.toString('utf8', this.stringStart + 1, this.stringEnd - 1)
+                        : ''));
+        return field;
+    }
+    readValue(integerOnly = false) {
+        const value = this.bytes[this.index];
+        if (value === 0x22)
+            return this.readString();
+        if (value === 0x7b)
+            return this.readObject();
+        if (value === 0x5b)
+            return this.readArray();
+        if (value === 0x74) {
+            this.readLiteral('true');
+            return true;
+        }
+        if (value === 0x66) {
+            this.readLiteral('false');
+            return false;
+        }
+        if (value === 0x6e) {
+            this.readLiteral('null');
+            return null;
+        }
+        return this.readNumber(integerOnly);
+    }
+    readObject() {
+        this.index += 1;
+        this.skipWhitespace();
+        const object = {};
+        if (this.consumeByte(0x7d))
+            return object;
+        for (;;) {
+            const key = this.readString();
+            this.skipWhitespace();
+            this.expectByte(0x3a, "':' after object property");
+            this.skipWhitespace();
+            const value = this.readValue();
+            if (key === '__proto__') {
+                Object.defineProperty(object, key, {
+                    configurable: true,
+                    enumerable: true,
+                    value,
+                    writable: true
+                });
+            }
+            else {
+                object[key] = value;
+            }
+            this.skipWhitespace();
+            if (this.consumeByte(0x7d))
+                return object;
+            this.expectByte(0x2c, "',' or '}' after object property");
+            this.skipWhitespace();
+        }
+    }
+    readArray() {
+        this.index += 1;
+        this.skipWhitespace();
+        const array = [];
+        if (this.consumeByte(0x5d))
+            return array;
+        for (;;) {
+            array.push(this.readValue());
+            this.skipWhitespace();
+            if (this.consumeByte(0x5d))
+                return array;
+            this.expectByte(0x2c, "',' or ']' after array item");
+            this.skipWhitespace();
+        }
+    }
+    skipValue() {
+        const value = this.bytes[this.index];
+        if (value === 0x22) {
+            this.scanString();
+            return;
+        }
+        if (value === 0x7b)
+            return this.skipObject();
+        if (value === 0x5b)
+            return this.skipArray();
+        if (value === 0x74)
+            return this.readLiteral('true');
+        if (value === 0x66)
+            return this.readLiteral('false');
+        if (value === 0x6e)
+            return this.readLiteral('null');
+        this.readNumber();
+    }
+    skipObject() {
+        this.index += 1;
+        this.skipWhitespace();
+        if (this.consumeByte(0x7d))
+            return;
+        for (;;) {
+            this.readPropertyName();
+            this.skipWhitespace();
+            this.expectByte(0x3a, "':' after object property");
+            this.skipWhitespace();
+            this.skipValue();
+            this.skipWhitespace();
+            if (this.consumeByte(0x7d))
+                return;
+            this.expectByte(0x2c, "',' or '}' after object property");
+            this.skipWhitespace();
+        }
+    }
+    skipArray() {
+        this.index += 1;
+        this.skipWhitespace();
+        if (this.consumeByte(0x5d))
+            return;
+        for (;;) {
+            this.skipValue();
+            this.skipWhitespace();
+            if (this.consumeByte(0x5d))
+                return;
+            this.expectByte(0x2c, "',' or ']' after array item");
+            this.skipWhitespace();
+        }
+    }
+    readString() {
+        this.scanString();
+        return this.decodeString();
+    }
+    scanString() {
+        if (this.bytes[this.index] !== 0x22)
+            this.fail('string');
+        this.stringStart = this.index++;
+        this.stringHasEscapes = false;
+        while (this.index < this.bytes.length) {
+            const value = this.bytes[this.index++];
+            if (value === 0x22) {
+                this.stringEnd = this.index;
+                return;
+            }
+            if (value < 0x20)
+                this.fail('valid string character');
+            if (value !== 0x5c)
+                continue;
+            this.stringHasEscapes = true;
+            if (this.index === this.bytes.length)
+                this.fail('valid string escape');
+            const escaped = this.bytes[this.index++];
+            if (escaped === 0x75) {
+                for (let count = 0; count < 4; count += 1) {
+                    if (this.index === this.bytes.length || !isHexDigit(this.bytes[this.index]))
+                        this.fail('four hexadecimal digits after \\u');
+                    this.index += 1;
+                }
+            }
+            else if (escaped !== 0x22 &&
+                escaped !== 0x5c &&
+                escaped !== 0x2f &&
+                escaped !== 0x62 &&
+                escaped !== 0x66 &&
+                escaped !== 0x6e &&
+                escaped !== 0x72 &&
+                escaped !== 0x74) {
+                this.fail('valid string escape');
+            }
+        }
+        this.fail('terminated string');
+    }
+    decodeString() {
+        return this.stringHasEscapes
+            ? JSON.parse(this.bytes.toString('utf8', this.stringStart, this.stringEnd))
+            : this.bytes.toString('utf8', this.stringStart + 1, this.stringEnd - 1);
+    }
+    readNumber(integerOnly = false) {
+        const start = this.index;
+        let hasFractionOrExponent = false;
+        if (this.bytes[this.index] === 0x2d)
+            this.index += 1;
+        if (this.bytes[this.index] === 0x30) {
+            this.index += 1;
+        }
+        else if (this.isDigitOneToNine(this.bytes[this.index])) {
+            while (this.isDigit(this.bytes[this.index]))
+                this.index += 1;
+        }
+        else {
+            this.fail('JSON value');
+        }
+        if (this.bytes[this.index] === 0x2e) {
+            hasFractionOrExponent = true;
+            this.index += 1;
+            if (!this.isDigit(this.bytes[this.index]))
+                this.fail('digit after decimal point');
+            while (this.isDigit(this.bytes[this.index]))
+                this.index += 1;
+        }
+        if (this.bytes[this.index] === 0x65 || this.bytes[this.index] === 0x45) {
+            hasFractionOrExponent = true;
+            this.index += 1;
+            if (this.bytes[this.index] === 0x2b || this.bytes[this.index] === 0x2d)
+                this.index += 1;
+            if (!this.isDigit(this.bytes[this.index]))
+                this.fail('digit in exponent');
+            while (this.isDigit(this.bytes[this.index]))
+                this.index += 1;
+        }
+        if (integerOnly && hasFractionOrExponent) {
+            throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.ProtocolError, 'Channel envelope integer fields must use an integer literal.');
+        }
+        if (integerOnly) {
+            const negative = this.bytes[start] === 0x2d;
+            const digitsStart = start + (negative ? 1 : 0);
+            if (this.index - digitsStart <= 3) {
+                let integer = 0;
+                for (let offset = digitsStart; offset < this.index; offset += 1) {
+                    integer = integer * 10 + this.bytes[offset] - 0x30;
+                }
+                return negative ? -integer : integer;
+            }
+        }
+        const number = Number(this.bytes.toString('ascii', start, this.index));
+        if (!Number.isFinite(number)) {
+            throw new TypeError('framework-json-v1 only accepts finite JSON numbers.');
+        }
+        return number;
+    }
+    readLiteral(value) {
+        for (let offset = 0; offset < value.length; offset += 1) {
+            if (this.bytes[this.index + offset] !== value.charCodeAt(offset))
+                this.fail(value);
+        }
+        this.index += value.length;
+    }
+    matchesAscii(start, end, value) {
+        if (end - start !== value.length)
+            return false;
+        for (let offset = 0; offset < value.length; offset += 1) {
+            if (this.bytes[start + offset] !== value.charCodeAt(offset))
+                return false;
+        }
+        return true;
+    }
+    isDigit(value) {
+        return value !== undefined && value >= 0x30 && value <= 0x39;
+    }
+    isDigitOneToNine(value) {
+        return value !== undefined && value >= 0x31 && value <= 0x39;
+    }
+    skipWhitespace() {
+        while (this.bytes[this.index] === 0x20 ||
+            this.bytes[this.index] === 0x09 ||
+            this.bytes[this.index] === 0x0a ||
+            this.bytes[this.index] === 0x0d) {
+            this.index += 1;
+        }
+    }
+    consumeByte(value) {
+        if (this.bytes[this.index] !== value)
+            return false;
+        this.index += 1;
+        return true;
+    }
+    expectByte(value, expected) {
+        if (!this.consumeByte(value))
+            this.fail(expected);
+    }
+    fail(expected) {
+        throw new SyntaxError(`framework-json-v1 expected ${expected} at offset ${this.index}.`);
+    }
+}
 function schemaForInboundChannelEnvelope(header) {
     const contract = (0, Attributes_1.readZLinkPacketJsonContract)(header.messageName);
     return header.kind === 2 /* ZLinkChannelMessageKind.Response */ ? contract?.reply : contract?.payload;
@@ -797,8 +1318,13 @@ function validateCorrelationForKind(kind, correlationId) {
 }
 const MAXIMUM_CORRELATION_ID_BYTES = 64;
 function isValidChannelCorrelationId(value) {
-    const byteLength = Buffer.byteLength(value, 'utf8');
-    return (byteLength >= 1 && byteLength <= MAXIMUM_CORRELATION_ID_BYTES && /^[\x00-\x7f]*$/.test(value));
+    if (value.length < 1 || value.length > MAXIMUM_CORRELATION_ID_BYTES)
+        return false;
+    for (let index = 0; index < value.length; index++) {
+        if (value.charCodeAt(index) > 0x7f)
+            return false;
+    }
+    return true;
 }
 function validateCorrelationValue(correlationId) {
     if (!isValidChannelCorrelationId(correlationId)) {
@@ -867,7 +1393,7 @@ function optionalFlowOrigin(value) {
 }
 function requireFlowId(value) {
     const flowId = requireString(value, 'flowId');
-    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(flowId)) {
+    if (!CHANNEL_FLOW_TEXT.test(flowId)) {
         throw new configuration_1.ZLinkConfigurationException('Channel envelope flowId must be a lowercase UUIDv7.');
     }
     return flowId;