gremlin 3.8.1 → 4.0.0-beta.3

package/{.prettierrc.js → build/esm/structure/io/binary/internals/StubSerializer.js}

@@ -16,14 +16,15 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-
-module.exports = {
-  singleQuote: true,
-  printWidth: 120,
-  trailingComma: 'all',
-  bracketSpacing: true,
-  arrowParens: 'always',
-  semi: true,
-  tabWidth: 2,
-  useTabs: false,
-};
+export default class StubSerializer {
+    constructor(ioc, typeCode, typeName) {
+        this.ioc = ioc;
+        this.typeCode = typeCode;
+        this.typeName = typeName;
+        this.ioc.serializers[typeCode] = this;
+    }
+    // eslint-disable-next-line require-await
+    async deserializeValue(reader, valueFlag, typeCode) {
+        throw new Error(`${this.typeName} deserialization is not yet implemented`);
+    }
+}

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

@@ -0,0 +1,54 @@
+/**
+ * GraphBinary serializer for the Tree type (0x2b).
+ *
+ * Wire format (authoritative from Java TreeSerializer):
+ *   value = {int length} then length x ( {fully-qualified key} {bare child Tree} )
+ * A child Tree is written bare: just {int length}{entries...}, with no type-id
+ * and no value-flag, recursively. A leaf is length 0. The child is never null,
+ * but a key may be null.
+ */
+export default class TreeSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): value is Tree;
+    serialize(item: any, fullyQualifiedFormat?: boolean): any;
+    /**
+     * Serializes the bare value of a Tree: {int length} then, for each root key, a
+     * fully-qualified key followed by a bare child Tree (recursive).
+     *
+     * Uses only the public read API ({@link Tree#rootNodes} / {@link Tree#childAt})
+     * so it never touches the Tree's private backing. Keys returned by rootNodes()
+     * are already deduped, so each is written exactly once.
+     * @param {Tree} tree
+     * @returns {Buffer}
+     */
+    _serializeValue(tree: Tree): Buffer;
+    /**
+     * Async deserialization of tree value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Tree>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<Tree>;
+    /**
+     * Reads a bare tree value: {int length} then length x ( fully-qualified key,
+     * bare child tree ). The child recursion reads bare values (no type_code,
+     * no value_flag).
+     *
+     * Duplicate sibling keys are collapsed via {@link Tree#getOrCreateChild} +
+     * {@link Tree#addTree} (a server emitting
+     * the same sibling key twice yields a single merged entry, not duplicates).
+     * @param {StreamReader} reader
+     * @returns {Promise<Tree>}
+     */
+    _readTreeValue(reader: StreamReader): Promise<Tree>;
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Tree|null>}
+     */
+    deserialize(reader: StreamReader): Promise<Tree | null>;
+}
+import { Tree } from '../../../graph.js';
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,136 @@
+/*
+ *  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 { Tree } from '../../../graph.js';
+/**
+ * GraphBinary serializer for the Tree type (0x2b).
+ *
+ * Wire format (authoritative from Java TreeSerializer):
+ *   value = {int length} then length x ( {fully-qualified key} {bare child Tree} )
+ * A child Tree is written bare: just {int length}{entries...}, with no type-id
+ * and no value-flag, recursively. A leaf is length 0. The child is never null,
+ * but a key may be null.
+ */
+export default class TreeSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.TREE] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof Tree;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.TREE, 0x01]);
+            }
+            // bare null -> empty tree (length 0)
+            return this.ioc.intSerializer.serialize(0, false);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.TREE, 0x00]));
+        }
+        bufs.push(this._serializeValue(item));
+        return Buffer.concat(bufs);
+    }
+    /**
+     * Serializes the bare value of a Tree: {int length} then, for each root key, a
+     * fully-qualified key followed by a bare child Tree (recursive).
+     *
+     * Uses only the public read API ({@link Tree#rootNodes} / {@link Tree#childAt})
+     * so it never touches the Tree's private backing. Keys returned by rootNodes()
+     * are already deduped, so each is written exactly once.
+     * @param {Tree} tree
+     * @returns {Buffer}
+     */
+    _serializeValue(tree) {
+        const keys = tree.rootNodes();
+        let length = keys.length;
+        if (length < 0) {
+            length = 0;
+        }
+        else if (length > this.ioc.intSerializer.INT32_MAX) {
+            length = this.ioc.intSerializer.INT32_MAX;
+        }
+        const bufs = [this.ioc.intSerializer.serialize(length, false)];
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            // fully-qualified key
+            bufs.push(this.ioc.anySerializer.serialize(key));
+            // bare child tree (no type_code, no value_flag)
+            bufs.push(this._serializeValue(tree.childAt(key)));
+        }
+        return Buffer.concat(bufs);
+    }
+    /**
+     * Async deserialization of tree value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Tree>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        return await this._readTreeValue(reader);
+    }
+    /**
+     * Reads a bare tree value: {int length} then length x ( fully-qualified key,
+     * bare child tree ). The child recursion reads bare values (no type_code,
+     * no value_flag).
+     *
+     * Duplicate sibling keys are collapsed via {@link Tree#getOrCreateChild} +
+     * {@link Tree#addTree} (a server emitting
+     * the same sibling key twice yields a single merged entry, not duplicates).
+     * @param {StreamReader} reader
+     * @returns {Promise<Tree>}
+     */
+    async _readTreeValue(reader) {
+        const length = await this.ioc.intSerializer.deserializeBare(reader);
+        const tree = new Tree();
+        for (let i = 0; i < length; i++) {
+            // {fully-qualified key} - read with type_code + value_flag.
+            const key = await this.ioc.anySerializer.deserialize(reader);
+            // {bare child tree} - never null, no type_code / value_flag
+            const child = await this._readTreeValue(reader);
+            // Merge into any existing entry for this key so duplicate sibling keys
+            // collapse into a single entry.
+            tree.getOrCreateChild(key).addTree(child);
+        }
+        return tree;
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Tree|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.TREE) {
+            throw new Error(`TreeSerializer: 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(`TreeSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,13 @@
+export default class UnspecifiedNullSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): boolean;
+    serialize(item: any): Buffer<ArrayBuffer>;
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer (always 0x01 for null)
+     * @returns {Promise<null>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number): Promise<null>;
+}
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,44 @@
+/*
+ *  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.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+export default class UnspecifiedNullSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.UNSPECIFIED_NULL] = this;
+    }
+    canBeUsedFor(value) {
+        return value === null || value === undefined;
+    }
+    serialize(item) {
+        // fullyQualifiedFormat always is true
+        return Buffer.from([this.ioc.DataType.UNSPECIFIED_NULL, 0x01]);
+    }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag - already consumed by AnySerializer (always 0x01 for null)
+     * @returns {Promise<null>}
+     */
+    // eslint-disable-next-line require-await
+    async deserializeValue(reader, valueFlag) {
+        throw new Error('UnspecifiedNull should always have value_flag=0x01');
+    }
+}

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

@@ -0,0 +1,19 @@
+export default class UuidSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): void;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<string>}
+     */
+    deserializeValue(reader: StreamReader, valueFlag: number, typeCode: number): Promise<string>;
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<string|null>}
+     */
+    deserialize(reader: StreamReader): Promise<string | null>;
+}
+import { Buffer } from 'buffer';

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

@@ -0,0 +1,90 @@
+/*
+ *  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.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+export default class UuidSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.UUID] = this;
+    }
+    canBeUsedFor(value) {
+        // TODO: any idea to support UUID automatic serialization via AnySerializer in future?
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.UUID, 0x01]);
+            }
+            return Buffer.from([
+                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ]);
+        }
+        const uuid_str = String(item)
+            .replace(/^urn:uuid:/, '')
+            .replace(/[{}-]/g, '');
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.UUID, 0x00]));
+        }
+        const v = Buffer.alloc(16, 0);
+        for (let i = 0; i < 16 && i * 2 < uuid_str.length; i++) {
+            v[i] = parseInt(uuid_str.slice(i * 2, i * 2 + 2), 16);
+        }
+        bufs.push(v);
+        return Buffer.concat(bufs);
+    }
+    /**
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<string>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        const bytes = await reader.readBytes(16);
+        return (bytes.subarray(0, 4).toString('hex') +
+            '-' +
+            bytes.subarray(4, 6).toString('hex') +
+            '-' +
+            bytes.subarray(6, 8).toString('hex') +
+            '-' +
+            bytes.subarray(8, 10).toString('hex') +
+            '-' +
+            bytes.subarray(10, 16).toString('hex'));
+    }
+    /**
+     * @param {StreamReader} reader
+     * @returns {Promise<string|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.UUID) {
+            throw new Error(`UuidSerializer: 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(`UuidSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

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

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

@@ -0,0 +1,102 @@
+/*
+ *  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.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+import { VertexProperty } from '../../../graph.js';
+export default class VertexPropertySerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.VERTEXPROPERTY] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof VertexProperty;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.VERTEXPROPERTY, 0x01]);
+            }
+            return Buffer.concat([
+                this.ioc.unspecifiedNullSerializer.serialize(null), // {id}=null
+                this.ioc.listSerializer.serialize([], false), // {label}=empty list
+                this.ioc.unspecifiedNullSerializer.serialize(null), // {value}=null
+                this.ioc.unspecifiedNullSerializer.serialize(null), // {parent}=null
+                this.ioc.listSerializer.serialize([], true), // {properties}=empty list
+            ]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.VERTEXPROPERTY, 0x00]));
+        }
+        // {id}
+        bufs.push(this.ioc.anySerializer.serialize(item.id));
+        // {label}
+        const labels = Array.isArray(item.label) ? item.label : item.label ? [item.label] : [];
+        bufs.push(this.ioc.listSerializer.serialize(labels, false));
+        // {value}
+        bufs.push(this.ioc.anySerializer.serialize(item.value));
+        // {parent}
+        bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+        // {properties}
+        bufs.push(this.ioc.listSerializer.serialize([], true));
+        return Buffer.concat(bufs);
+    }
+    /**
+     * Async deserialization of vertex property value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<VertexProperty>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        // {id} fully qualified
+        const id = await this.ioc.anySerializer.deserialize(reader);
+        // {label} bare list, extract first element
+        const labelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+        const label = Array.isArray(labelList) && labelList.length > 0 ? labelList[0] : labelList;
+        // {value} fully qualified
+        const value = await this.ioc.anySerializer.deserialize(reader);
+        // {parent} fully qualified (always null in current TinkerPop)
+        await this.ioc.anySerializer.deserialize(reader);
+        // {properties} fully qualified
+        const properties = await this.ioc.anySerializer.deserialize(reader);
+        return new VertexProperty(id, label, value, properties || []);
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<VertexProperty|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.VERTEXPROPERTY) {
+            throw new Error(`VertexPropertySerializer: 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(`VertexPropertySerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

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

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

@@ -0,0 +1,98 @@
+/*
+ *  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.
+ */
+/**
+ * @author Igor Ostapenko
+ */
+import { Buffer } from 'buffer';
+import { Vertex } from '../../../graph.js';
+export default class VertexSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.VERTEX] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof Vertex;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return Buffer.from([this.ioc.DataType.VERTEX, 0x01]);
+            }
+            const id = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+            const label = [0x00, 0x00, 0x00, 0x00]; // empty list
+            const properties = [0x09, 0x00, 0x00, 0x00, 0x00, 0x00]; // empty list
+            return Buffer.from([...id, ...label, ...properties]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(Buffer.from([this.ioc.DataType.VERTEX, 0x00]));
+        }
+        // {id}
+        bufs.push(this.ioc.anySerializer.serialize(item.id));
+        // {label}
+        const labels = item.labels instanceof Set
+            ? Array.from(item.labels)
+            : Array.isArray(item.label)
+                ? item.label
+                : item.label
+                    ? [item.label]
+                    : [];
+        bufs.push(this.ioc.listSerializer.serialize(labels, false));
+        // {properties}
+        bufs.push(this.ioc.listSerializer.serialize([], true));
+        return Buffer.concat(bufs);
+    }
+    /**
+     * Async deserialization of vertex value bytes from a StreamReader.
+     * @param {StreamReader} reader
+     * @param {number} valueFlag
+     * @param {number} typeCode
+     * @returns {Promise<Vertex>}
+     */
+    async deserializeValue(reader, valueFlag, typeCode) {
+        // {id} fully qualified
+        const id = await this.ioc.anySerializer.deserialize(reader);
+        // {label} bare list - full multi-label list
+        const labelList = await this.ioc.listSerializer.deserializeValue(reader, 0x00, this.ioc.DataType.LIST);
+        const labels = Array.isArray(labelList) ? labelList : labelList ? [labelList] : [];
+        const label = labels.length > 0 ? labels[0] : 'vertex';
+        // {properties} fully qualified
+        const properties = await this.ioc.anySerializer.deserialize(reader);
+        return new Vertex(id, label, properties || [], labels);
+    }
+    /**
+     * Async fully-qualified deserialization from a StreamReader.
+     * @param {StreamReader} reader
+     * @returns {Promise<Vertex|null>}
+     */
+    async deserialize(reader) {
+        const type_code = await reader.readUInt8();
+        if (type_code !== this.ioc.DataType.VERTEX) {
+            throw new Error(`VertexSerializer: 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(`VertexSerializer: unexpected {value_flag}=0x${value_flag.toString(16)}`);
+        }
+        return this.deserializeValue(reader, value_flag, type_code);
+    }
+}

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

@@ -0,0 +1,6 @@
+export function des_error({ serializer, args, cursor, err }: {
+    serializer: any;
+    args: any;
+    cursor: any;
+    err: any;
+}): any;