@zlink-systems/framework 0.31.0 → 0.32.0

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

@@ -521,33 +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, CHANNEL_JSON_PARSE_OPTIONS, 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;
+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;
@@ -591,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;
@@ -611,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;
@@ -687,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;
@@ -696,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;
@@ -720,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;