gremlin 4.0.0-beta.2 → 4.0.0-beta.3

package/build/esm/structure/io/binary/internals/GraphBinaryReader.js

@@ -20,17 +20,34 @@
  * @author Igor Ostapenko
  */
 import { Buffer } from 'buffer';
+import StreamReader from './StreamReader.js';
+import { END_OF_STREAM } from './MarkerSerializer.js';
+import { Traverser } from '../../../../process/traversal.js';
+import ResponseError from '../../../../driver/response-error.js';
+/** GraphBinary response status codes. */
+const StatusCode = {
+    SUCCESS: 200,
+    NO_CONTENT: 204,
+    PARTIAL_CONTENT: 206,
+};
 /**
  * GraphBinary reader.
  */
 export default class GraphBinaryReader {
     constructor(ioc) {
         this.ioc = ioc;
+        this.pdtRegistry = null;
     }
     get mimeType() {
         return 'application/vnd.graphbinary-v4.0';
     }
-    readResponse(buffer) {
+    /**
+     * Read a complete response from a Buffer. Used by the non-streaming submit() path.
+     * Returns the full { status, result } object after reading all data.
+     * @param {Buffer} buffer
+     * @returns {Promise<{status: {code, message, exception}, result: {data: any[], bulked: boolean}}>}
+     */
+    async readResponse(buffer) {
         if (buffer === undefined || buffer === null) {
             throw new Error('Buffer is missing.');
         }
@@ -40,55 +57,109 @@ export default class GraphBinaryReader {
         if (buffer.length < 1) {
             throw new Error('Buffer is empty.');
         }
-        let cursor = buffer;
-        let len;
-        // {version} is a Byte representing the protocol version
-        const version = cursor[0];
+        const reader = StreamReader.fromBuffer(buffer);
+        reader.pdtRegistry = this.pdtRegistry;
+        return await this.#readFromReader(reader);
+    }
+    /**
+     * Stream results from a StreamReader, yielding each value as it's deserialized.
+     * Used by the streaming Connection.stream() path.
+     *
+     * Note: In the GraphBinary v4 streaming protocol, the status (including error codes)
+     * is sent *after* all result data. This means values are yielded to the consumer as
+     * they arrive, and a server error is only thrown after all values have been yielded.
+     * Consumers should be aware that partial results may have been processed before a
+     * ResponseError is thrown.
+     *
+     * @param {StreamReader} reader
+     * @returns {AsyncGenerator<any>}
+     */
+    async *readResponseStream(reader) {
+        reader.pdtRegistry = this.pdtRegistry;
+        // {version}
+        const version = await reader.readUInt8();
         if (version !== 0x84) {
             throw new Error(`Unsupported version '${version}'.`);
         }
-        cursor = cursor.slice(1); // skip version
-        // {bulked} is a Byte: 0x00 = not bulked, 0x01 = bulked
-        const bulked = cursor[0] === 0x01;
-        cursor = cursor.slice(1);
-        // {result_data} stream - read values until marker
-        const data = [];
-        while (cursor[0] !== 0xfd) {
-            const { v, len: valueLen } = this.ioc.anySerializer.deserialize(cursor);
-            cursor = cursor.slice(valueLen);
+        // {bulked}
+        const bulked = (await reader.readUInt8()) === 0x01;
+        // {result_data} stream — yield values until EndOfStream marker
+        while (true) {
+            const value = await this.ioc.anySerializer.deserialize(reader);
+            if (value === END_OF_STREAM) {
+                break;
+            }
             if (bulked) {
-                const { v: bulk, len: bulkLen } = this.ioc.longSerializer.deserialize(cursor, true);
-                cursor = cursor.slice(bulkLen);
-                data.push({ v, bulk: Number(bulk) });
+                const bulk = await this.ioc.longSerializer.deserialize(reader);
+                yield new Traverser(value, Number(bulk));
             }
             else {
-                data.push(v);
+                yield value;
             }
         }
-        // Skip marker [0xFD, 0x00, 0x00]
-        cursor = cursor.slice(3);
-        // {status_code} is an Int bare
-        const { v: code, len: codeLen } = this.ioc.intSerializer.deserialize(cursor, false);
-        cursor = cursor.slice(codeLen);
-        // {status_message} is nullable
-        let message = null;
-        if (cursor[0] === 0x00) {
-            cursor = cursor.slice(1);
-            ({ v: message, len } = this.ioc.stringSerializer.deserialize(cursor, false));
-            cursor = cursor.slice(len);
+        // {status_code} {status_message} {exception}
+        const status = await this.#readStatus(reader);
+        if (status.code &&
+            status.code !== StatusCode.SUCCESS &&
+            status.code !== StatusCode.NO_CONTENT &&
+            status.code !== StatusCode.PARTIAL_CONTENT) {
+            throw new ResponseError(`Server error: ${status.message || 'Unknown error'} (${status.code})`, {
+                code: status.code,
+                message: status.message || '',
+                exception: status.exception,
+            });
         }
-        else {
-            cursor = cursor.slice(1); // skip 0x01 null flag
+        // Attach status to the generator's return value
+        return status;
+    }
+    /**
+     * Internal: read the full response into a collected result (non-streaming).
+     */
+    async #readFromReader(reader) {
+        // {version}
+        const version = await reader.readUInt8();
+        if (version !== 0x84) {
+            throw new Error(`Unsupported version '${version}'.`);
         }
-        // {exception} is nullable
-        let exception = null;
-        if (cursor[0] === 0x00) {
-            cursor = cursor.slice(1);
-            ({ v: exception } = this.ioc.stringSerializer.deserialize(cursor, false));
+        // {bulked}
+        const bulked = (await reader.readUInt8()) === 0x01;
+        // {result_data} — collect all values
+        const data = [];
+        while (true) {
+            const value = await this.ioc.anySerializer.deserialize(reader);
+            if (value === END_OF_STREAM) {
+                break;
+            }
+            if (bulked) {
+                const bulk = await this.ioc.longSerializer.deserialize(reader);
+                data.push({ v: value, bulk: Number(bulk) });
+            }
+            else {
+                data.push(value);
+            }
         }
+        // {status}
+        const status = await this.#readStatus(reader);
         return {
-            status: { code, message, exception },
+            status,
             result: { data, bulked },
         };
     }
+    /**
+     * Read the status block: {code:Int bare}{message:nullable String}{exception:nullable String}
+     */
+    async #readStatus(reader) {
+        const code = await reader.readInt32BE();
+        let message = null;
+        const msgFlag = await reader.readUInt8();
+        if (msgFlag === 0x00) {
+            message = await this.ioc.stringSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.STRING);
+        }
+        let exception = null;
+        const excFlag = await reader.readUInt8();
+        if (excFlag === 0x00) {
+            exception = await this.ioc.stringSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.STRING);
+        }
+        return { code, message, exception };
+    }
 }

package/build/esm/structure/io/binary/internals/GraphBinaryWriter.js

@@ -42,13 +42,13 @@ export default class GraphBinaryWriter {
             if (g) {
                 fields.set('g', g);
             }
-            const bindings = requestMessage.getBindings();
-            if (bindings && Object.keys(bindings).length > 0) {
-                fields.set('bindings', bindings);
+            const parameters = requestMessage.getParameters();
+            if (parameters && Object.keys(parameters).length > 0) {
+                fields.set('parameters', parameters);
             }
-            const timeoutMs = requestMessage.getTimeoutMs();
-            if (timeoutMs !== undefined) {
-                fields.set('timeoutMs', timeoutMs);
+            const timeoutMillis = requestMessage.getTimeoutMillis();
+            if (timeoutMillis !== undefined) {
+                fields.set('timeoutMillis', timeoutMillis);
             }
             const materializeProperties = requestMessage.getMaterializeProperties();
             if (materializeProperties) {

package/build/esm/structure/io/binary/internals/GraphSerializer.d.ts

@@ -0,0 +1,22 @@
+export default class GraphSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): value is Graph;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    /**
+     * Async deserialization of graph value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Graph>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Graph>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Graph|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Graph | null>;
+}
+import { Graph } from '../../../graph.js';
+import { Buffer } from 'buffer';

package/build/esm/structure/io/binary/internals/GraphSerializer.js

@@ -0,0 +1,181 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+import { Buffer } from 'buffer';
+import { Graph, Vertex, Edge, VertexProperty } from '../../../graph.js';
+export default class GraphSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.GRAPH] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof Graph;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.GRAPH, 0x01]);
+            }
+            // value-only null fallback: zero vertices + zero edges
+            const zeroInt = [0x00, 0x00, 0x00, 0x00];
+            return Buffer.from([...zeroInt, ...zeroInt]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.GRAPH, 0x00]));
+        }
+        const vertices = item.vertices ? Array.from(item.vertices.values()) : [];
+        const edges = item.edges ? Array.from(item.edges.values()) : [];
+        // {vertex_count}
+        bufs.push(this.ioc.intSerializer.serialize(vertices.length, false));
+        // vertices
+        for (const v of vertices) {
+            // {id}
+            bufs.push(this.ioc.anySerializer.serialize(v.id));
+            // {label} as list (value-only)
+            const vLabels = v.labels instanceof Set ? Array.from(v.labels) : [v.label];
+            bufs.push(this.ioc.listSerializer.serialize(vLabels, false));
+            const vps = Array.isArray(v.properties) ? v.properties : [];
+            // {vp_count}
+            bufs.push(this.ioc.intSerializer.serialize(vps.length, false));
+            for (const vp of vps) {
+                // {vp_id}
+                bufs.push(this.ioc.anySerializer.serialize(vp.id));
+                // {vp_label} as 1-element list (value-only)
+                bufs.push(this.ioc.listSerializer.serialize([vp.label], false));
+                // {vp_value}
+                bufs.push(this.ioc.anySerializer.serialize(vp.value));
+                // {parent} (always null)
+                bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+                // {meta_props} as value-only List<Property>
+                const metaProps = Array.isArray(vp.properties) ? vp.properties : [];
+                bufs.push(this.ioc.listSerializer.serialize(metaProps, false));
+            }
+        }
+        // {edge_count}
+        bufs.push(this.ioc.intSerializer.serialize(edges.length, false));
+        // edges
+        for (const e of edges) {
+            // {id}
+            bufs.push(this.ioc.anySerializer.serialize(e.id));
+            // {label} as list (value-only)
+            const eLabels = e.labels instanceof Set ? Array.from(e.labels) : [e.label];
+            bufs.push(this.ioc.listSerializer.serialize(eLabels, false));
+            // {inV_id}
+            bufs.push(this.ioc.anySerializer.serialize(e.inV && e.inV.id));
+            // {inV_label} (always null placeholder, fully-qualified)
+            bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+            // {outV_id}
+            bufs.push(this.ioc.anySerializer.serialize(e.outV && e.outV.id));
+            // {outV_label} (always null placeholder, fully-qualified)
+            bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+            // {parent} (always null)
+            bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+            // {edge_props} as value-only List<Property>
+            const props = Array.isArray(e.properties) ? e.properties : [];
+            bufs.push(this.ioc.listSerializer.serialize(props, false));
+        }
+        return Buffer.concat(bufs);
+    }
+    /**
+     * Async deserialization of graph value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Graph>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const graph = new Graph();
+        // {vertex_count} bare int
+        const vertexCount = await this.ioc.intSerializer.deserializeBare(reader);
+        for (let i = 0; i < vertexCount; i++) {
+            // {id} fully qualified
+            const vId = await this.ioc.anySerializer.deserialize(reader);
+            // {label} value-only list - full multi-label list
+            const vLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+            const vLabels = Array.isArray(vLabelList) ? vLabelList : vLabelList ? [vLabelList] : [];
+            const vLabel = vLabels.length > 0 ? vLabels[0] : 'vertex';
+            const vertex = new Vertex(vId, vLabel, [], vLabels);
+            graph.vertices.set(vId, vertex);
+            // {vp_count} bare int
+            const vpCount = await this.ioc.intSerializer.deserializeBare(reader);
+            for (let j = 0; j < vpCount; j++) {
+                // {vp_id} fully qualified
+                const vpId = await this.ioc.anySerializer.deserialize(reader);
+                // {vp_label} value-only list, first element
+                const vpLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+                const vpLabel = Array.isArray(vpLabelList) && vpLabelList.length > 0 ? vpLabelList[0] : vpLabelList;
+                // {vp_value} fully qualified
+                const vpValue = await this.ioc.anySerializer.deserialize(reader);
+                // {parent} fully qualified (always null)
+                await this.ioc.anySerializer.deserialize(reader);
+                // {meta_props} value-only list
+                const metaProps = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+                const vp = new VertexProperty(vpId, vpLabel, vpValue, metaProps || []);
+                vertex.properties.push(vp);
+            }
+        }
+        // {edge_count} bare int
+        const edgeCount = await this.ioc.intSerializer.deserializeBare(reader);
+        for (let i = 0; i < edgeCount; i++) {
+            // {id} fully qualified
+            const eId = await this.ioc.anySerializer.deserialize(reader);
+            // {label} value-only list - full multi-label list
+            const eLabelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+            const eLabels = Array.isArray(eLabelList) ? eLabelList : eLabelList ? [eLabelList] : [];
+            const eLabel = eLabels.length > 0 ? eLabels[0] : 'edge';
+            // {inV_id} fully qualified
+            const inVId = await this.ioc.anySerializer.deserialize(reader);
+            // {inV_label} fully qualified (always null placeholder) — discard
+            await this.ioc.anySerializer.deserialize(reader);
+            // {outV_id} fully qualified
+            const outVId = await this.ioc.anySerializer.deserialize(reader);
+            // {outV_label} fully qualified (always null placeholder) — discard
+            await this.ioc.anySerializer.deserialize(reader);
+            // {parent} fully qualified (always null) — discard
+            await this.ioc.anySerializer.deserialize(reader);
+            // {edge_props} value-only list
+            const edgeProps = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+            // Reuse vertex instances already in graph.vertices, otherwise build stand-ins
+            const inV = graph.vertices.get(inVId) || new Vertex(inVId, '', []);
+            const outV = graph.vertices.get(outVId) || new Vertex(outVId, '', []);
+            const edge = new Edge(eId, outV, eLabel, inV, edgeProps || [], eLabels);
+            graph.edges.set(eId, edge);
+        }
+        return graph;
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Graph|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.GRAPH) {
+            throw new Error(`GraphSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
+        }
+        if (value_flag !== 0x00) {
+            throw new Error(`GraphSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

package/build/esm/structure/io/binary/internals/IntSerializer.d.ts

@@ -5,9 +5,24 @@ export default class IntSerializer {
     ioc: any;
     canBeUsedFor(value: any): boolean;
     serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: any;
-        len: number;
-    };
+    /**
+     * Read a bare int32 value from the StreamReader (no type_code or value_flag).
+     * @param {StreamReader} reader
+     * @returns {Promise<number>}
+     */
+    deserializeBare(reader: StreamReader): Promise<number>;
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<number>;
+    /**
+     * Read a fully-qualified int from the StreamReader (type_code + value_flag + value).
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    deserialize(reader: StreamReader): Promise<number | null>;
 }
 import { Buffer } from 'buffer';

package/build/esm/structure/io/binary/internals/IntSerializer.js

@@ -56,45 +56,40 @@ export default class IntSerializer {
         bufs.push(v);
         return Buffer.concat(bufs);
     }
-    deserialize(buffer, fullyQualifiedFormat = true) {
-        let len = 0;
-        let cursor = buffer;
-        try {
-            if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
-                throw new Error('buffer is missing');
-            }
-            if (buffer.length < 1) {
-                throw new Error('buffer is empty');
-            }
-            if (fullyQualifiedFormat) {
-                const type_code = cursor.readUInt8();
-                len++;
-                if (type_code !== this.ioc.DataType.INT) {
-                    throw new Error('unexpected {type_code}');
-                }
-                cursor = cursor.slice(1);
-                if (cursor.length < 1) {
-                    throw new Error('{value_flag} is missing');
-                }
-                const value_flag = cursor.readUInt8();
-                len++;
-                if (value_flag === 1) {
-                    return { v: null, len };
-                }
-                if (value_flag !== 0) {
-                    throw new Error('unexpected {value_flag}');
-                }
-                cursor = cursor.slice(1);
-            }
-            if (cursor.length < 4) {
-                throw new Error('unexpected {value} length');
-            }
-            len += 4;
-            const v = cursor.readInt32BE();
-            return { v, len };
+    /**
+     * Read a bare int32 value from the StreamReader (no type_code or value_flag).
+     * @param {StreamReader} reader
+     * @returns {Promise<number>}
+     */
+    async deserializeBare(reader) {
+        return await reader.readInt32BE();
+    }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode
+     * @returns {Promise<number>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        return await reader.readInt32BE();
+    }
+    /**
+     * Read a fully-qualified int from the StreamReader (type_code + value_flag + value).
+     * @param {StreamReader} reader
+     * @returns {Promise<number|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.INT) {
+            throw new Error(`IntSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
         }
-        catch (err) {
-            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        if (value_flag !== 0x00) {
+            throw new Error(`IntSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }

package/build/esm/structure/io/binary/internals/LongSerializer.d.ts

@@ -3,9 +3,18 @@ export default class LongSerializer {
     ioc: any;
     canBeUsedFor(): void;
     serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: any;
-        len: number;
-    };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode
+     * @returns {Promise<number|bigint>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<number | bigint>;
+    /**
+     * Read a fully-qualified long from the StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<number|bigint|null>}
+     */
+    deserialize(reader: StreamReader): Promise<number | bigint | null>;
 }
 import { Buffer } from 'buffer';

package/build/esm/structure/io/binary/internals/LongSerializer.js

@@ -44,49 +44,36 @@ export default class LongSerializer {
         bufs.push(v);
         return Buffer.concat(bufs);
     }
-    deserialize(buffer, fullyQualifiedFormat = true) {
-        let len = 0;
-        let cursor = buffer;
-        try {
-            if (buffer === undefined || buffer === null || !(buffer instanceof Buffer)) {
-                throw new Error('buffer is missing');
-            }
-            if (buffer.length < 1) {
-                throw new Error('buffer is empty');
-            }
-            if (fullyQualifiedFormat) {
-                const type_code = cursor.readUInt8();
-                len++;
-                if (type_code !== this.ioc.DataType.LONG) {
-                    throw new Error('unexpected {type_code}');
-                }
-                cursor = cursor.slice(1);
-                if (cursor.length < 1) {
-                    throw new Error('{value_flag} is missing');
-                }
-                const value_flag = cursor.readUInt8();
-                len++;
-                if (value_flag === 1) {
-                    return { v: null, len };
-                }
-                if (value_flag !== 0) {
-                    throw new Error('unexpected {value_flag}');
-                }
-                cursor = cursor.slice(1);
-            }
-            if (cursor.length < 8) {
-                throw new Error('unexpected {value} length');
-            }
-            len += 8;
-            let v = cursor.readBigInt64BE();
-            if (v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER) {
-                v = Number(v);
-            }
-            // Values outside safe integer range stay as BigInt to preserve precision.
-            return { v, len };
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer
+     * @param {number} typeCode
+     * @returns {Promise<number|bigint>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        let v = await reader.readBigInt64BE();
+        if (v >= Number.MIN_SAFE_INTEGER && v <= Number.MAX_SAFE_INTEGER) {
+            v = Number(v);
+        }
+        return v;
+    }
+    /**
+     * Read a fully-qualified long from the StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<number|bigint|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.LONG) {
+            throw new Error(`LongSerializer: unexpected {type_code}=0x${type_code.toString(16)}`);
+        }
+        const value_flag = await reader.readUInt8();
+        if (value_flag === 0x01) {
+            return null;
         }
-        catch (err) {
-            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        if (value_flag !== 0x00) {
+            throw new Error(`LongSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
         }
+        return this.deserializeValue(reader, value_flag, type_code);
     }
 }

package/build/esm/structure/io/binary/internals/MapSerializer.d.ts

@@ -3,11 +3,18 @@ export default class MapSerializer {
     ioc: any;
     canBeUsedFor(value: any): boolean;
     serialize(item: any, fullyQualifiedFormat?: boolean): any;
-    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
-        v: null;
-        len: number;
-    } | {
-        v: Map<any, any>;
-        len: number;
-    };
+    /**
+     * Async deserialization of map value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Map>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Map<any, any>>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Map|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Map<any, any> | null>;
 }