gremlin 3.8.0 → 4.0.0-beta.2

package/build/cjs/structure/io/binary/internals/EnumSerializer.cjs

@@ -0,0 +1,127 @@
+"use strict";
+/*
+ *  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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+const traversal_js_1 = require("../../../../process/traversal.cjs");
+class EnumSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        // process/traversal.js:toEnum() lowercases element names (e.g. OUT => out) for end users' convenience
+        // but we need original mapping as is for wire format lookup
+        const to_orig_enum = (obj) => {
+            const r = {};
+            Object.values(obj).forEach((e) => (r[e.elementName] = e));
+            return r;
+        };
+        this.types = {
+            Direction: { code: ioc.DataType.DIRECTION, enum: to_orig_enum(traversal_js_1.direction) },
+            Merge: { code: ioc.DataType.MERGE, enum: to_orig_enum(traversal_js_1.merge) },
+            T: { code: ioc.DataType.T, enum: to_orig_enum(traversal_js_1.t) },
+        };
+        this.ioc.serializers[ioc.DataType.DIRECTION] = this;
+        this.ioc.serializers[ioc.DataType.MERGE] = this;
+        this.ioc.serializers[ioc.DataType.T] = this;
+    }
+    canBeUsedFor(value) {
+        return (value instanceof traversal_js_1.EnumValue &&
+            (value.typeName === 'Direction' || value.typeName === 'Merge' || value.typeName === 'T'));
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        const type = this.types[item.typeName];
+        if (item.elementName === undefined || item.elementName === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([type.code, 0x01]);
+            }
+            return this.ioc.stringSerializer.serialize(null, false);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([type.code, 0x00]));
+        }
+        bufs.push(this.ioc.stringSerializer.serialize(item.elementName, true));
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.Buffer)) {
+                throw new Error('buffer is missing');
+            }
+            if (buffer.length < 1) {
+                throw new Error('buffer is empty');
+            }
+            let typeName;
+            if (fullyQualifiedFormat) {
+                const type_code = cursor.readUInt8();
+                len++;
+                if (type_code === this.ioc.DataType.DIRECTION) {
+                    typeName = 'Direction';
+                }
+                else if (type_code === this.ioc.DataType.MERGE) {
+                    typeName = 'Merge';
+                }
+                else if (type_code === this.ioc.DataType.T) {
+                    typeName = 'T';
+                }
+                else {
+                    throw new Error(`unexpected {type_code}=${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);
+            }
+            let elementName, elementName_len;
+            try {
+                ({ v: elementName, len: elementName_len } = this.ioc.stringSerializer.deserialize(cursor, true));
+                len += elementName_len;
+            }
+            catch (err) {
+                err.message = 'elementName: ' + err.message;
+                throw err;
+            }
+            let v;
+            if (typeName) {
+                v = this.types[typeName].enum[elementName];
+            }
+            else {
+                v = new traversal_js_1.EnumValue(undefined, elementName);
+            }
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = EnumSerializer;

package/build/cjs/structure/io/binary/internals/EnumSerializer.d.cts

@@ -0,0 +1,24 @@
+export default class EnumSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    types: {
+        Direction: {
+            code: any;
+            enum: {};
+        };
+        Merge: {
+            code: any;
+            enum: {};
+        };
+        T: {
+            code: any;
+            enum: {};
+        };
+    };
+    canBeUsedFor(value: any): boolean;
+    serialize(item: any, fullyQualifiedFormat?: boolean): any;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: any;
+        len: number;
+    };
+}

package/build/cjs/structure/io/binary/internals/FloatSerializer.cjs

@@ -0,0 +1,91 @@
+"use strict";
+/*
+ *  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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+class FloatSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.FLOAT] = this;
+    }
+    canBeUsedFor(value) {
+        // it's not expected to be used
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.FLOAT, 0x01]);
+            }
+            return buffer_1.Buffer.from([0x00, 0x00, 0x00, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.FLOAT, 0x00]));
+        }
+        const v = buffer_1.Buffer.alloc(4);
+        v.writeFloatBE(item);
+        bufs.push(v);
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.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.FLOAT) {
+                    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.readFloatBE();
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = FloatSerializer;

package/build/cjs/structure/io/binary/internals/FloatSerializer.d.cts

@@ -0,0 +1,11 @@
+export default class FloatSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): void;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: any;
+        len: number;
+    };
+}
+import { Buffer } from 'buffer';

package/build/cjs/structure/io/binary/internals/GraphBinaryReader.cjs

@@ -0,0 +1,97 @@
+"use strict";
+/*
+ *  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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+/**
+ * GraphBinary reader.
+ */
+class GraphBinaryReader {
+    constructor(ioc) {
+        this.ioc = ioc;
+    }
+    get mimeType() {
+        return 'application/vnd.graphbinary-v4.0';
+    }
+    readResponse(buffer) {
+        if (buffer === undefined || buffer === null) {
+            throw new Error('Buffer is missing.');
+        }
+        if (!(buffer instanceof buffer_1.Buffer)) {
+            throw new Error('Not an instance of Buffer.');
+        }
+        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];
+        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);
+            if (bulked) {
+                const { v: bulk, len: bulkLen } = this.ioc.longSerializer.deserialize(cursor, true);
+                cursor = cursor.slice(bulkLen);
+                data.push({ v, bulk: Number(bulk) });
+            }
+            else {
+                data.push(v);
+            }
+        }
+        // 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);
+        }
+        else {
+            cursor = cursor.slice(1); // skip 0x01 null flag
+        }
+        // {exception} is nullable
+        let exception = null;
+        if (cursor[0] === 0x00) {
+            cursor = cursor.slice(1);
+            ({ v: exception } = this.ioc.stringSerializer.deserialize(cursor, false));
+        }
+        return {
+            status: { code, message, exception },
+            result: { data, bulked },
+        };
+    }
+}
+exports.default = GraphBinaryReader;

package/build/cjs/structure/io/binary/internals/GraphBinaryReader.d.cts

@@ -0,0 +1,19 @@
+/**
+ * GraphBinary reader.
+ */
+export default class GraphBinaryReader {
+    constructor(ioc: any);
+    ioc: any;
+    get mimeType(): string;
+    readResponse(buffer: any): {
+        status: {
+            code: any;
+            message: any;
+            exception: any;
+        };
+        result: {
+            data: any[];
+            bulked: boolean;
+        };
+    };
+}

package/build/cjs/structure/io/binary/internals/GraphBinaryWriter.cjs

@@ -0,0 +1,85 @@
+"use strict";
+/*
+ *  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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+/**
+ * GraphBinary writer.
+ */
+class GraphBinaryWriter {
+    constructor(ioc) {
+        this.ioc = ioc;
+    }
+    get mimeType() {
+        return 'application/vnd.graphbinary-v4.0';
+    }
+    writeRequest(requestMessage) {
+        const fields = new Map();
+        // Extract fields from RequestMessage if it has getter methods
+        if (typeof requestMessage.getLanguage === 'function') {
+            const language = requestMessage.getLanguage();
+            if (language) {
+                fields.set('language', language);
+            }
+            const g = requestMessage.getG();
+            if (g) {
+                fields.set('g', g);
+            }
+            const bindings = requestMessage.getBindings();
+            if (bindings && Object.keys(bindings).length > 0) {
+                fields.set('bindings', bindings);
+            }
+            const timeoutMs = requestMessage.getTimeoutMs();
+            if (timeoutMs !== undefined) {
+                fields.set('timeoutMs', timeoutMs);
+            }
+            const materializeProperties = requestMessage.getMaterializeProperties();
+            if (materializeProperties) {
+                fields.set('materializeProperties', materializeProperties);
+            }
+            const bulkResults = requestMessage.getBulkResults();
+            if (bulkResults !== undefined) {
+                fields.set('bulkResults', bulkResults);
+            }
+            // Add any custom fields
+            const customFields = requestMessage.getFields();
+            if (customFields) {
+                customFields.forEach((v, k) => fields.set(k, v));
+            }
+            const gremlin = requestMessage.getGremlin();
+            const bufs = [
+                buffer_1.Buffer.from([0x84]),
+                this.ioc.mapSerializer.serialize(fields, false),
+                this.ioc.stringSerializer.serialize(gremlin, false),
+            ];
+            return new Uint8Array(buffer_1.Buffer.concat(bufs));
+        }
+        // Legacy path: plain object with { gremlin, fields }
+        const bufs = [
+            buffer_1.Buffer.from([0x84]),
+            this.ioc.mapSerializer.serialize(requestMessage.fields || new Map(), false),
+            this.ioc.stringSerializer.serialize(requestMessage.gremlin, false),
+        ];
+        return new Uint8Array(buffer_1.Buffer.concat(bufs));
+    }
+}
+exports.default = GraphBinaryWriter;

package/build/cjs/structure/io/binary/internals/GraphBinaryWriter.d.cts

@@ -0,0 +1,9 @@
+/**
+ * GraphBinary writer.
+ */
+export default class GraphBinaryWriter {
+    constructor(ioc: any);
+    ioc: any;
+    get mimeType(): string;
+    writeRequest(requestMessage: any): Uint8Array<ArrayBuffer>;
+}

package/build/cjs/structure/io/binary/internals/IntSerializer.cjs

@@ -0,0 +1,103 @@
+"use strict";
+/*
+ *  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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+class IntSerializer {
+    get INT32_MIN() {
+        return -2147483648;
+    }
+    get INT32_MAX() {
+        return 2147483647;
+    }
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.INT] = this;
+    }
+    canBeUsedFor(value) {
+        if (typeof value !== 'number') {
+            return false;
+        }
+        if (value < this.INT32_MIN || value > this.INT32_MAX) {
+            return false;
+        }
+        return true;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.INT, 0x01]);
+            }
+            return buffer_1.Buffer.from([0x00, 0x00, 0x00, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.INT, 0x00]));
+        }
+        const v = buffer_1.Buffer.alloc(4);
+        v.writeInt32BE(item); // if item is not within int32 limits writeInt32BE will error
+        bufs.push(v);
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.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 };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = IntSerializer;

package/build/cjs/structure/io/binary/internals/IntSerializer.d.cts

@@ -0,0 +1,13 @@
+export default class IntSerializer {
+    constructor(ioc: any);
+    get INT32_MIN(): number;
+    get INT32_MAX(): number;
+    ioc: any;
+    canBeUsedFor(value: any): boolean;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: any;
+        len: number;
+    };
+}
+import { Buffer } from 'buffer';

package/build/cjs/structure/io/binary/internals/LongSerializer.cjs

@@ -0,0 +1,95 @@
+"use strict";
+/*
+ *  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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+class LongSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.LONG] = this;
+    }
+    canBeUsedFor() {
+        // it's not expected to be used, see NumberSerializationStrategy
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.LONG, 0x01]);
+            }
+            return buffer_1.Buffer.from([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.LONG, 0x00]));
+        }
+        const v = buffer_1.Buffer.alloc(8);
+        v.writeBigInt64BE(BigInt(item));
+        bufs.push(v);
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.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 };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = LongSerializer;