From 6d8f06ab49579be01963e5648d607ba6e6de72a5 Mon Sep 17 00:00:00 2001 From: Sebastian Lorenz Date: Sat, 14 Nov 2026 17:38:48 +0000 Subject: [PATCH 01/11] Add effect/encoding/FlatBuffers Schema-less FlatBuffers reading and writing. Table, Vector and Struct read fields from the bytes on demand. Every read is bounds-checked, and decode returns a Result with a FlatBuffersError on malformed input. Builder follows the official builder algorithm (alignment, vtable dedup, force defaults, file identifier and size prefix). The fixtures hold 311 builder-call sequences together with the bytes the official Python flatbuffers 25.12.19 builder writes for them. The tests check that our bytes are identical, read every value back, and fuzz corrupted buffers. --- .changeset/encoding-flatbuffers.md | 5 + packages/effect/src/encoding/FlatBuffers.ts | 914 ++++++++++++++++++ packages/effect/src/encoding/index.ts | 6 + .../effect/test/encoding/FlatBuffers.test.ts | 471 +++++++++ .../test/fixtures/flatbuffers/README.md | 13 + .../test/fixtures/flatbuffers/generate.py | 327 +++++++ .../test/fixtures/flatbuffers/gold.json | 1 + 7 files changed, 1737 insertions(+) create mode 100644 .changeset/encoding-flatbuffers.md create mode 100644 packages/effect/src/encoding/FlatBuffers.ts create mode 100644 packages/effect/test/encoding/FlatBuffers.test.ts create mode 100644 packages/effect/test/fixtures/flatbuffers/README.md create mode 100644 packages/effect/test/fixtures/flatbuffers/generate.py create mode 100644 packages/effect/test/fixtures/flatbuffers/gold.json diff --git a/.changeset/encoding-flatbuffers.md b/.changeset/encoding-flatbuffers.md new file mode 100644 index 00000000000..b77e1556f32 --- /dev/null +++ b/.changeset/encoding-flatbuffers.md @@ -0,0 +1,5 @@ +--- +"effect": patch +--- + +Add `effect/encoding/FlatBuffers` for reading and writing FlatBuffers without a schema compiler. Reads are bounds-checked and lazy, and `decode` returns a `Result`. The builder produces the same bytes as the official FlatBuffers builders. diff --git a/packages/effect/src/encoding/FlatBuffers.ts b/packages/effect/src/encoding/FlatBuffers.ts new file mode 100644 index 00000000000..d65c91509dd --- /dev/null +++ b/packages/effect/src/encoding/FlatBuffers.ts @@ -0,0 +1,914 @@ +/** + * Reads and writes the FlatBuffers binary format: tables, structs, vectors, + * strings and unions, read in place without parsing the whole buffer. + * + * **Mental model** + * + * - A FlatBuffer is a tree of tables. A table's fields are numbered slots; + * a small vtable records where each present field is, so absent fields cost + * nothing and read as their default. + * - This module knows nothing about schemas. The caller decides what each + * slot holds, as code generated from a `.fbs` schema does: read slot 0 as + * a string, slot 1 as a table, and so on. + * - {@link Builder} writes a buffer back to front, children first: create + * strings, vectors and child tables, then the table that refers to them, + * and {@link Builder.finish} with the root table. The bytes it produces + * are the bytes the official FlatBuffers builders produce for the same + * calls. + * - {@link root} gives the root {@link Table} of a buffer; its accessors read + * from the bytes on demand. {@link decode} runs a reading function and + * returns a `Result`. + * + * **Example** (Writing and reading a table) + * + * ```ts import.meta.vitest + * import { FlatBuffers } from "effect/encoding" + * import { Result } from "effect" + * + * // table Monster { name: string; hp: short = 100; inventory: [ubyte]; } + * const builder = FlatBuffers.make() + * const name = builder.createString("Orc") + * const inventory = builder.createBytes(Uint8Array.of(1, 2, 3)) + * builder.startTable(3) + * builder.addFieldOffset(0, name) + * builder.addFieldInt16(1, 300, 100) + * builder.addFieldOffset(2, inventory) + * const bytes = builder.finish(builder.endTable(), { identifier: "MONS" }) + * + * const monster = FlatBuffers.decode(bytes, (root) => ({ + * name: root.string(0), + * hp: root.int16(1, 100), + * inventory: root.bytes(2)?.length + * }), { identifier: "MONS" }) + * + * Result.getOrThrow(monster) // => { name: "Orc", hp: 300, inventory: 3 } + * ``` + * + * **Details** + * + * Every read is bounds-checked: malformed or hostile input throws a + * {@link FlatBuffersError} (or makes {@link decode} fail) instead of reading + * outside the buffer. Strings must be valid UTF-8. 64-bit integers are + * `bigint`s. + * + * @stability experimental + * @since 4.1.5 + */ +import * as Data from "../Data.ts" +import * as Predicate from "../Predicate.ts" +import * as Result from "../Result.ts" + +const FlatBuffersErrorTypeId = "~effect/encoding/FlatBuffers/FlatBuffersError" + +/** + * Error raised for a malformed buffer or a misused {@link Builder}. + * + * **Details** + * + * The `kind` field identifies the failure: + * + * - `OutOfBounds`: an offset, length or value lies outside the buffer. + * - `InvalidVtable`: a table's vtable has an impossible size. + * - `InvalidUtf8`: a string is not valid UTF-8. + * - `Identifier`: the buffer's file identifier is not the expected one. + * - `Usage`: the builder was called out of order (a table inside a table, a + * struct that isn't the last thing written, an identifier that isn't four + * bytes) or the buffer would exceed 2 GiB. + * + * @stability experimental + * @category errors + * @since 4.1.5 + */ +export class FlatBuffersError extends Data.TaggedError("FlatBuffersError")<{ + readonly kind: "OutOfBounds" | "InvalidVtable" | "InvalidUtf8" | "Identifier" | "Usage" + readonly message: string +}> { + /** + * Marks this value as a FlatBuffers error for runtime guards. + * + * @stability experimental + * @since 4.1.5 + */ + readonly [FlatBuffersErrorTypeId] = FlatBuffersErrorTypeId +} + +/** + * Checks whether a value is a {@link FlatBuffersError}. + * + * @stability experimental + * @category guards + * @since 4.1.5 + */ +export const isFlatBuffersError = (u: unknown): u is FlatBuffersError => + Predicate.hasProperty(u, FlatBuffersErrorTypeId) + +const fail = (kind: FlatBuffersError["kind"], message: string): never => { + throw new FlatBuffersError({ kind, message }) +} + +const utf8 = new TextDecoder("utf-8", { fatal: true }) +const encoder = new TextEncoder() + +const check = (view: DataView, at: number, size: number): void => { + if (at < 0 || size < 0 || at + size > view.byteLength) { + fail("OutOfBounds", `${size} bytes at ${at} lie outside the ${view.byteLength}-byte buffer`) + } +} + +/** The absolute position a uoffset at `at` points to. */ +const indirect = (view: DataView, at: number): number => { + check(view, at, 4) + return at + view.getUint32(at, true) +} + +const readString = (bytes: Uint8Array, view: DataView, start: number): string => { + check(view, start, 4) + const length = view.getUint32(start, true) + check(view, start + 4, length) + try { + return utf8.decode(bytes.subarray(start + 4, start + 4 + length)) + } catch { + return fail("InvalidUtf8", `the string at ${start} is not valid UTF-8`) + } +} + +// ----------------------------------------------------------------------------- +// Reading +// ----------------------------------------------------------------------------- + +/** + * Reads fields at fixed byte offsets: the fields of a struct, stored inline + * in a table or a vector. + * + * @stability experimental + * @category reading + * @since 4.1.5 + */ +export class Struct { + /** The whole buffer. */ + readonly buffer: Uint8Array + /** Where the struct starts in {@link buffer}. */ + readonly position: number + private readonly view: DataView + + constructor(buffer: Uint8Array, view: DataView, position: number) { + this.buffer = buffer + this.view = view + this.position = position + } + + private at(offset: number, size: number): number { + const at = this.position + offset + check(this.view, at, size) + return at + } + + /** The `bool` at byte `offset` of the struct. */ + bool(offset: number): boolean { + return this.view.getUint8(this.at(offset, 1)) !== 0 + } + /** The `byte` at byte `offset` of the struct. */ + int8(offset: number): number { + return this.view.getInt8(this.at(offset, 1)) + } + /** The `ubyte` at byte `offset` of the struct. */ + uint8(offset: number): number { + return this.view.getUint8(this.at(offset, 1)) + } + /** The `short` at byte `offset` of the struct. */ + int16(offset: number): number { + return this.view.getInt16(this.at(offset, 2), true) + } + /** The `ushort` at byte `offset` of the struct. */ + uint16(offset: number): number { + return this.view.getUint16(this.at(offset, 2), true) + } + /** The `int` at byte `offset` of the struct. */ + int32(offset: number): number { + return this.view.getInt32(this.at(offset, 4), true) + } + /** The `uint` at byte `offset` of the struct. */ + uint32(offset: number): number { + return this.view.getUint32(this.at(offset, 4), true) + } + /** The `long` at byte `offset` of the struct. */ + int64(offset: number): bigint { + return this.view.getBigInt64(this.at(offset, 8), true) + } + /** The `ulong` at byte `offset` of the struct. */ + uint64(offset: number): bigint { + return this.view.getBigUint64(this.at(offset, 8), true) + } + /** The `float` at byte `offset` of the struct. */ + float32(offset: number): number { + return this.view.getFloat32(this.at(offset, 4), true) + } + /** The `double` at byte `offset` of the struct. */ + float64(offset: number): number { + return this.view.getFloat64(this.at(offset, 8), true) + } + /** The struct nested at byte `offset` of this struct. */ + struct(offset: number): Struct { + return new Struct(this.buffer, this.view, this.position + offset) + } +} + +/** + * The elements of a vector. Accessors take the element index; the caller + * picks the accessor of the vector's element type. + * + * @stability experimental + * @category reading + * @since 4.1.5 + */ +export class Vector { + /** The whole buffer. */ + readonly buffer: Uint8Array + /** Where the first element starts in {@link buffer}. */ + readonly position: number + /** The number of elements. */ + readonly length: number + private readonly view: DataView + + constructor(buffer: Uint8Array, view: DataView, position: number, length: number) { + this.buffer = buffer + this.view = view + this.position = position + this.length = length + } + + private at(index: number, size: number): number { + if (!Number.isInteger(index) || index < 0 || index >= this.length) { + fail("OutOfBounds", `index ${index} is outside the vector of length ${this.length}`) + } + const at = this.position + index * size + check(this.view, at, size) + return at + } + + /** Element `index` of a `[bool]` vector. */ + bool(index: number): boolean { + return this.view.getUint8(this.at(index, 1)) !== 0 + } + /** Element `index` of a `[byte]` vector. */ + int8(index: number): number { + return this.view.getInt8(this.at(index, 1)) + } + /** Element `index` of a `[ubyte]` vector. */ + uint8(index: number): number { + return this.view.getUint8(this.at(index, 1)) + } + /** Element `index` of a `[short]` vector. */ + int16(index: number): number { + return this.view.getInt16(this.at(index, 2), true) + } + /** Element `index` of a `[ushort]` vector. */ + uint16(index: number): number { + return this.view.getUint16(this.at(index, 2), true) + } + /** Element `index` of an `[int]` vector. */ + int32(index: number): number { + return this.view.getInt32(this.at(index, 4), true) + } + /** Element `index` of a `[uint]` vector. */ + uint32(index: number): number { + return this.view.getUint32(this.at(index, 4), true) + } + /** Element `index` of a `[long]` vector. */ + int64(index: number): bigint { + return this.view.getBigInt64(this.at(index, 8), true) + } + /** Element `index` of a `[ulong]` vector. */ + uint64(index: number): bigint { + return this.view.getBigUint64(this.at(index, 8), true) + } + /** Element `index` of a `[float]` vector. */ + float32(index: number): number { + return this.view.getFloat32(this.at(index, 4), true) + } + /** Element `index` of a `[double]` vector. */ + float64(index: number): number { + return this.view.getFloat64(this.at(index, 8), true) + } + /** Element `index` of a `[string]` vector. */ + string(index: number): string { + return readString(this.buffer, this.view, indirect(this.view, this.at(index, 4))) + } + /** Element `index` of a vector of tables. */ + table(index: number): Table { + return new Table(this.buffer, this.view, indirect(this.view, this.at(index, 4))) + } + /** Element `index` of a vector of structs of `size` bytes. */ + struct(index: number, size: number): Struct { + return new Struct(this.buffer, this.view, this.at(index, size)) + } +} + +/** + * A table: fields by slot number, read on demand. Absent fields read as + * the given default. + * + * @stability experimental + * @category reading + * @since 4.1.5 + */ +export class Table { + /** The whole buffer. */ + readonly buffer: Uint8Array + /** Where the table starts in {@link buffer}. */ + readonly position: number + private readonly view: DataView + private readonly vtable: number + private readonly vtableSize: number + + constructor(buffer: Uint8Array, view: DataView, position: number) { + this.buffer = buffer + this.view = view + this.position = position + check(view, position, 4) + const vtable = position - view.getInt32(position, true) + check(view, vtable, 4) + const vtableSize = view.getUint16(vtable, true) + if (vtableSize < 4 || (vtableSize & 1) !== 0) fail("InvalidVtable", `vtable at ${vtable} has size ${vtableSize}`) + check(view, vtable, vtableSize) + this.vtable = vtable + this.vtableSize = vtableSize + } + + /** The position of field `slot`, or -1 when it is absent. */ + private field(slot: number, size: number): number { + const entry = 4 + slot * 2 + if (!Number.isInteger(slot) || slot < 0 || entry >= this.vtableSize) return -1 + const relative = this.view.getUint16(this.vtable + entry, true) + if (relative === 0) return -1 + const at = this.position + relative + check(this.view, at, size) + return at + } + + /** Whether field `slot` is present. */ + has(slot: number): boolean { + return this.field(slot, 0) !== -1 + } + /** The `bool` in `slot`. */ + bool(slot: number, fallback = false): boolean { + const at = this.field(slot, 1) + return at === -1 ? fallback : this.view.getUint8(at) !== 0 + } + /** The `byte` in `slot`. */ + int8(slot: number, fallback = 0): number { + const at = this.field(slot, 1) + return at === -1 ? fallback : this.view.getInt8(at) + } + /** The `ubyte` in `slot`. */ + uint8(slot: number, fallback = 0): number { + const at = this.field(slot, 1) + return at === -1 ? fallback : this.view.getUint8(at) + } + /** The `short` in `slot`. */ + int16(slot: number, fallback = 0): number { + const at = this.field(slot, 2) + return at === -1 ? fallback : this.view.getInt16(at, true) + } + /** The `ushort` in `slot`. */ + uint16(slot: number, fallback = 0): number { + const at = this.field(slot, 2) + return at === -1 ? fallback : this.view.getUint16(at, true) + } + /** The `int` in `slot`. */ + int32(slot: number, fallback = 0): number { + const at = this.field(slot, 4) + return at === -1 ? fallback : this.view.getInt32(at, true) + } + /** The `uint` in `slot`. */ + uint32(slot: number, fallback = 0): number { + const at = this.field(slot, 4) + return at === -1 ? fallback : this.view.getUint32(at, true) + } + /** The `long` in `slot`. */ + int64(slot: number, fallback: bigint = BigInt(0)): bigint { + const at = this.field(slot, 8) + return at === -1 ? fallback : this.view.getBigInt64(at, true) + } + /** The `ulong` in `slot`. */ + uint64(slot: number, fallback: bigint = BigInt(0)): bigint { + const at = this.field(slot, 8) + return at === -1 ? fallback : this.view.getBigUint64(at, true) + } + /** The `float` in `slot`. */ + float32(slot: number, fallback = 0): number { + const at = this.field(slot, 4) + return at === -1 ? fallback : this.view.getFloat32(at, true) + } + /** The `double` in `slot`. */ + float64(slot: number, fallback = 0): number { + const at = this.field(slot, 8) + return at === -1 ? fallback : this.view.getFloat64(at, true) + } + /** The `string` in `slot`. */ + string(slot: number): string | undefined { + const at = this.field(slot, 4) + return at === -1 ? undefined : readString(this.buffer, this.view, indirect(this.view, at)) + } + /** The table in `slot` (also the value of a union). */ + table(slot: number): Table | undefined { + const at = this.field(slot, 4) + return at === -1 ? undefined : new Table(this.buffer, this.view, indirect(this.view, at)) + } + /** The struct of `size` bytes stored inline in `slot`. */ + struct(slot: number, size: number): Struct | undefined { + const at = this.field(slot, size) + return at === -1 ? undefined : new Struct(this.buffer, this.view, at) + } + /** The vector in `slot`, whose elements are `elementSize` bytes wide (4 for strings and tables). */ + vector(slot: number, elementSize: number): Vector | undefined { + const at = this.field(slot, 4) + if (at === -1) return undefined + const start = indirect(this.view, at) + check(this.view, start, 4) + const length = this.view.getUint32(start, true) + check(this.view, start + 4, length * elementSize) + return new Vector(this.buffer, this.view, start + 4, length) + } + /** The `[ubyte]` (or `[byte]`) vector in `slot`, as a view of the buffer (also a nested FlatBuffer). */ + bytes(slot: number): Uint8Array | undefined { + const v = this.vector(slot, 1) + return v === undefined ? undefined : this.buffer.subarray(v.position, v.position + v.length) + } +} + +/** + * Options of a buffer: an expected file identifier, and whether the buffer + * starts with its size. + * + * @stability experimental + * @category models + * @since 4.1.5 + */ +export interface Options { + /** The four-character file identifier the buffer must carry. */ + readonly identifier?: string | undefined + /** Whether the buffer starts with its size (`FinishSizePrefixed`). */ + readonly sizePrefixed?: boolean | undefined +} + +const identifierBytes = (identifier: string): Uint8Array => { + const bytes = encoder.encode(identifier) + return bytes.length === 4 + ? bytes + : fail("Usage", `a file identifier is four bytes, got ${JSON.stringify(identifier)}`) +} + +/** + * The buffer's file identifier (the four bytes after the root offset), or + * `undefined` when the buffer is too short to have one. + * + * @stability experimental + * @category reading + * @since 4.1.5 + */ +export const identifier = (bytes: Uint8Array, options?: Pick): string | undefined => { + const at = options?.sizePrefixed ? 8 : 4 + if (bytes.length < at + 4) return undefined + return String.fromCharCode(...bytes.subarray(at, at + 4)) +} + +/** + * The root table of a buffer. Throws a {@link FlatBuffersError} when the + * buffer is malformed or carries another file identifier; its accessors + * throw for malformed fields. + * + * @stability experimental + * @category reading + * @since 4.1.5 + */ +export const root = (bytes: Uint8Array, options?: Options): Table => { + let data = bytes + if (options?.sizePrefixed) { + if (bytes.length < 4) fail("OutOfBounds", "a size-prefixed buffer needs at least 4 bytes") + const size = new DataView(bytes.buffer, bytes.byteOffset, 4).getUint32(0, true) + if (size > bytes.length - 4) { + fail("OutOfBounds", `the size prefix ${size} exceeds the ${bytes.length - 4} bytes after it`) + } + data = bytes.subarray(4, 4 + size) + } + if (options?.identifier !== undefined) { + const expected = identifierBytes(options.identifier) + const actual = data.subarray(4, 8) + if (actual.length !== 4 || actual.some((b, i) => b !== expected[i])) { + fail("Identifier", `expected file identifier ${JSON.stringify(options.identifier)}`) + } + } + const view = new DataView(data.buffer, data.byteOffset, data.byteLength) + check(view, 0, 4) + return new Table(data, view, view.getUint32(0, true)) +} + +/** + * Reads a buffer with `read`, which gets the root table. Malformed input + * becomes a failed `Result` instead of an exception. + * + * @stability experimental + * @category reading + * @since 4.1.5 + */ +export const decode = ( + bytes: Uint8Array, + read: (root: Table) => A, + options?: Options +): Result.Result => { + try { + return Result.succeed(read(root(bytes, options))) + } catch (cause) { + if (isFlatBuffersError(cause)) return Result.fail(cause) + throw cause + } +} + +// ----------------------------------------------------------------------------- +// Writing +// ----------------------------------------------------------------------------- + +/** + * The position of something written by a {@link Builder} (a string, vector + * or table), counted from the end of the buffer. + * + * @stability experimental + * @category models + * @since 4.1.5 + */ +export type Offset = number + +const MAX_SIZE = 2 ** 31 + +/** + * Writes a FlatBuffer back to front, as the official builders do: the same + * calls give the same bytes. + * + * **Details** + * + * Children come first: create strings, vectors and child tables, keep their + * {@link Offset}s, then start the table that refers to them. Between + * {@link startTable} and {@link endTable}, add fields with the `addField*` + * methods; a scalar equal to its default is not written (unless + * `forceDefaults`). Identical vtables are written once and shared. + * + * Structs are written in place: write their fields last to first with the + * `add*` methods (and {@link pad}) right before the call that refers to + * them, {@link addFieldStruct} for a table field or inside a vector. + * + * Integers are written modulo their width; 64-bit values are `bigint`s. + * + * @stability experimental + * @category writing + * @since 4.1.5 + */ +export class Builder { + private bytes: Uint8Array + private view: DataView + /** Index of the first written byte: data is `bytes[head..]`. */ + private head: number + private minAlign = 1 + private vtable: Array | undefined = undefined + private objectEnd = 0 + private readonly vtables = new Map() + private nested = false + private vectorLength = 0 + private sharedStrings: Map | undefined = undefined + private readonly forceDefaults: boolean + + constructor(options?: { readonly initialSize?: number | undefined; readonly forceDefaults?: boolean | undefined }) { + const size = Math.max(1, options?.initialSize ?? 1024) + this.bytes = new Uint8Array(size) + this.view = new DataView(this.bytes.buffer) + this.head = size + this.forceDefaults = options?.forceDefaults ?? false + } + + /** The current position, counted from the end of the buffer. */ + get offset(): Offset { + return this.bytes.length - this.head + } + + private grow(): void { + if (this.bytes.length >= MAX_SIZE) fail("Usage", "a FlatBuffer can't grow beyond 2 GiB") + const size = Math.min(this.bytes.length * 2, MAX_SIZE) + const next = new Uint8Array(size) + next.set(this.bytes, size - this.bytes.length) + this.head += size - this.bytes.length + this.bytes = next + this.view = new DataView(next.buffer) + } + + /** Writes `n` zero bytes. */ + pad(n: number): void { + for (let i = 0; i < n; i++) this.bytes[--this.head] = 0 + } + + /** + * Pads so that a value of `size` bytes, written after `additional` more + * bytes, is aligned to `size`; makes room for both. + */ + prep(size: number, additional: number): void { + if (size > this.minAlign) this.minAlign = size + const alignSize = (~(this.bytes.length - this.head + additional) + 1) & (size - 1) + while (this.head < alignSize + size + additional) this.grow() + this.pad(alignSize) + } + + /** Writes a `bool`. */ + addBool(value: boolean): void { + this.prep(1, 0) + this.view.setUint8(--this.head, value ? 1 : 0) + } + /** Writes a `byte`. */ + addInt8(value: number): void { + this.prep(1, 0) + this.view.setInt8(--this.head, value) + } + /** Writes a `ubyte`. */ + addUint8(value: number): void { + this.prep(1, 0) + this.view.setUint8(--this.head, value) + } + /** Writes a `short`. */ + addInt16(value: number): void { + this.prep(2, 0) + this.view.setInt16(this.head -= 2, value, true) + } + /** Writes a `ushort`. */ + addUint16(value: number): void { + this.prep(2, 0) + this.view.setUint16(this.head -= 2, value, true) + } + /** Writes an `int`. */ + addInt32(value: number): void { + this.prep(4, 0) + this.view.setInt32(this.head -= 4, value, true) + } + /** Writes a `uint`. */ + addUint32(value: number): void { + this.prep(4, 0) + this.view.setUint32(this.head -= 4, value, true) + } + /** Writes a `long`. */ + addInt64(value: bigint): void { + this.prep(8, 0) + this.view.setBigInt64(this.head -= 8, value, true) + } + /** Writes a `ulong`. */ + addUint64(value: bigint): void { + this.prep(8, 0) + this.view.setBigUint64(this.head -= 8, value, true) + } + /** Writes a `float`. */ + addFloat32(value: number): void { + this.prep(4, 0) + this.view.setFloat32(this.head -= 4, value, true) + } + /** Writes a `double`. */ + addFloat64(value: number): void { + this.prep(8, 0) + this.view.setFloat64(this.head -= 8, value, true) + } + /** Writes an offset to `target`, something written earlier. */ + addOffset(target: Offset): void { + this.prep(4, 0) + const relative = this.offset - target + 4 + if (target > this.offset) fail("Usage", `offset ${target} points past the current position ${this.offset}`) + this.view.setUint32(this.head -= 4, relative, true) + } + + private notNested(what: string): void { + if (this.nested) fail("Usage", `${what} inside a table or vector that isn't finished`) + } + + /** Writes a string (UTF-8, or the given bytes) and returns its offset. */ + createString(value: string | Uint8Array): Offset { + this.notNested("createString") + const bytes = typeof value === "string" ? encoder.encode(value) : value + this.prep(4, bytes.length + 1) + this.bytes[--this.head] = 0 + this.head -= bytes.length + this.bytes.set(bytes, this.head) + this.view.setUint32(this.head -= 4, bytes.length, true) + return this.offset + } + + /** Like {@link createString}, but writes each distinct string once. */ + createSharedString(value: string): Offset { + this.sharedStrings ??= new Map() + const existing = this.sharedStrings.get(value) + if (existing !== undefined) return existing + const offset = this.createString(value) + this.sharedStrings.set(value, offset) + return offset + } + + /** Writes a `[ubyte]` vector of the given bytes and returns its offset. */ + createBytes(value: Uint8Array): Offset { + this.notNested("createBytes") + this.prep(4, value.length) + this.head -= value.length + this.bytes.set(value, this.head) + this.view.setUint32(this.head -= 4, value.length, true) + return this.offset + } + + /** + * Starts a vector of `length` elements of `elementSize` bytes, aligned to + * `alignment`. Write the elements last to first, then {@link endVector}. + */ + startVector(elementSize: number, length: number, alignment: number): void { + this.notNested("startVector") + this.nested = true + this.vectorLength = length + this.prep(4, elementSize * length) + this.prep(alignment, elementSize * length) + } + + /** Finishes the vector started with {@link startVector} and returns its offset. */ + endVector(): Offset { + if (!this.nested || this.vtable !== undefined) fail("Usage", "endVector without startVector") + this.nested = false + this.view.setUint32(this.head -= 4, this.vectorLength, true) + return this.offset + } + + /** Writes a vector of offsets (strings, tables or vectors) and returns its offset. */ + createOffsetVector(targets: ReadonlyArray): Offset { + this.startVector(4, targets.length, 4) + for (let i = targets.length - 1; i >= 0; i--) this.addOffset(targets[i]) + return this.endVector() + } + + /** Starts a table with `fields` slots. Add fields, then {@link endTable}. */ + startTable(fields: number): void { + this.notNested("startTable") + this.nested = true + this.vtable = new Array(fields).fill(0) + this.objectEnd = this.offset + } + + private slot(slot: number): void { + if (this.vtable === undefined) fail("Usage", "a field outside startTable/endTable") + if (slot < 0 || slot >= this.vtable!.length) { + fail("Usage", `slot ${slot} is outside the table's ${this.vtable!.length} slots`) + } + this.vtable![slot] = this.offset + } + + /** Adds a `bool` field; skipped when equal to `fallback`. */ + addFieldBool(slot: number, value: boolean, fallback = false): void { + if (value !== fallback || this.forceDefaults) { + this.addBool(value) + this.slot(slot) + } + } + /** Adds a `byte` field; skipped when equal to `fallback`. */ + addFieldInt8(slot: number, value: number, fallback = 0): void { + if (value !== fallback || this.forceDefaults) { + this.addInt8(value) + this.slot(slot) + } + } + /** Adds a `ubyte` field; skipped when equal to `fallback`. */ + addFieldUint8(slot: number, value: number, fallback = 0): void { + if (value !== fallback || this.forceDefaults) { + this.addUint8(value) + this.slot(slot) + } + } + /** Adds a `short` field; skipped when equal to `fallback`. */ + addFieldInt16(slot: number, value: number, fallback = 0): void { + if (value !== fallback || this.forceDefaults) { + this.addInt16(value) + this.slot(slot) + } + } + /** Adds a `ushort` field; skipped when equal to `fallback`. */ + addFieldUint16(slot: number, value: number, fallback = 0): void { + if (value !== fallback || this.forceDefaults) { + this.addUint16(value) + this.slot(slot) + } + } + /** Adds an `int` field; skipped when equal to `fallback`. */ + addFieldInt32(slot: number, value: number, fallback = 0): void { + if (value !== fallback || this.forceDefaults) { + this.addInt32(value) + this.slot(slot) + } + } + /** Adds a `uint` field; skipped when equal to `fallback`. */ + addFieldUint32(slot: number, value: number, fallback = 0): void { + if (value !== fallback || this.forceDefaults) { + this.addUint32(value) + this.slot(slot) + } + } + /** Adds a `long` field; skipped when equal to `fallback`. */ + addFieldInt64(slot: number, value: bigint, fallback: bigint = BigInt(0)): void { + if (value !== fallback || this.forceDefaults) { + this.addInt64(value) + this.slot(slot) + } + } + /** Adds a `ulong` field; skipped when equal to `fallback`. */ + addFieldUint64(slot: number, value: bigint, fallback: bigint = BigInt(0)): void { + if (value !== fallback || this.forceDefaults) { + this.addUint64(value) + this.slot(slot) + } + } + /** Adds a `float` field; skipped when equal to `fallback`. */ + addFieldFloat32(slot: number, value: number, fallback = 0): void { + if (value !== fallback || this.forceDefaults) { + this.addFloat32(value) + this.slot(slot) + } + } + /** Adds a `double` field; skipped when equal to `fallback`. */ + addFieldFloat64(slot: number, value: number, fallback = 0): void { + if (value !== fallback || this.forceDefaults) { + this.addFloat64(value) + this.slot(slot) + } + } + /** Adds a field pointing to a string, vector or table (a union's value too). */ + addFieldOffset(slot: number, target: Offset): void { + if (target !== 0 || this.forceDefaults) { + this.addOffset(target) + this.slot(slot) + } + } + /** + * Adds a struct field. The struct's fields must have just been written: + * `target` is the current {@link offset}. + */ + addFieldStruct(slot: number, target: Offset): void { + if (target !== 0) { + if (target !== this.offset) fail("Usage", "a struct field must be written right before addFieldStruct") + this.slot(slot) + } + } + + /** Finishes the table started with {@link startTable} and returns its offset. */ + endTable(): Offset { + const vtable = this.vtable + if (vtable === undefined) return fail("Usage", "endTable without startTable") + // Placeholder for the offset to the vtable. + this.addInt32(0) + const object = this.offset + let fields = vtable.length + while (fields > 0 && vtable[fields - 1] === 0) fields-- + const objectSize = object - this.objectEnd + const entries = Array.from({ length: fields }, (_, i) => (vtable[i] === 0 ? 0 : object - vtable[i])) + const key = `${objectSize}:${entries.join(",")}` + const existing = this.vtables.get(key) + if (existing === undefined) { + for (let i = fields - 1; i >= 0; i--) this.addInt16(entries[i]) + this.addInt16(objectSize) + this.addInt16((fields + 2) * 2) + this.view.setInt32(this.bytes.length - object, this.offset - object, true) + this.vtables.set(key, this.offset) + } else { + this.head = this.bytes.length - object + this.view.setInt32(this.head, existing - object, true) + } + this.vtable = undefined + this.nested = false + return object + } + + /** + * Writes the root offset (after the file identifier and before the size + * prefix, when given) and returns the finished buffer. + */ + finish(rootTable: Offset, options?: Options): Uint8Array { + this.notNested("finish") + const identifier = options?.identifier === undefined ? undefined : identifierBytes(options.identifier) + this.prep(this.minAlign, 4 + (identifier === undefined ? 0 : 4) + (options?.sizePrefixed ? 4 : 0)) + if (identifier !== undefined) { + this.prep(4, 4) + for (let i = 3; i >= 0; i--) this.bytes[--this.head] = identifier[i] + } + this.addOffset(rootTable) + if (options?.sizePrefixed) this.addInt32(this.bytes.length - this.head) + return this.bytes.slice(this.head) + } +} + +/** + * A new {@link Builder}. `forceDefaults` writes scalar fields even when they + * equal their default; `initialSize` is the first buffer size (it grows as + * needed). + * + * @stability experimental + * @category writing + * @since 4.1.5 + */ +export const make = (options?: { + readonly initialSize?: number | undefined + readonly forceDefaults?: boolean | undefined +}): Builder => new Builder(options) diff --git a/packages/effect/src/encoding/index.ts b/packages/effect/src/encoding/index.ts index dc7605ca67d..24b5f934af2 100644 --- a/packages/effect/src/encoding/index.ts +++ b/packages/effect/src/encoding/index.ts @@ -29,6 +29,12 @@ export * as Csv from "./Csv.ts" */ export * as EncodingError from "./EncodingError.ts" +/** + * @stability experimental + * @since 4.1.5 + */ +export * as FlatBuffers from "./FlatBuffers.ts" + /** * @stability stable * @since 4.0.0 diff --git a/packages/effect/test/encoding/FlatBuffers.test.ts b/packages/effect/test/encoding/FlatBuffers.test.ts new file mode 100644 index 00000000000..22d0227d42d --- /dev/null +++ b/packages/effect/test/encoding/FlatBuffers.test.ts @@ -0,0 +1,471 @@ +import { assert, describe, it } from "@effect/vitest" +import { Result } from "effect" +import * as FlatBuffers from "effect/encoding/FlatBuffers" +import { readFileSync } from "node:fs" + +// Expected bytes were written by the official FlatBuffers Python builder; +// see fixtures/flatbuffers/README.md +type ScalarType = + | "bool" + | "int8" + | "uint8" + | "int16" + | "uint16" + | "int32" + | "uint32" + | "int64" + | "uint64" + | "float32" + | "float64" +type Scalar = boolean | number | string +interface StructDef { + readonly size: number + readonly align: number + readonly fields: ReadonlyArray<{ readonly type: ScalarType; readonly offset: number }> +} +type Field = + | { + readonly slot: number + readonly kind: "scalar" + readonly type: ScalarType + readonly value: Scalar + readonly default: Scalar + } + | { readonly slot: number; readonly kind: "offset"; readonly ref: string } + | { + readonly slot: number + readonly kind: "struct" + readonly struct: StructDef + readonly value: ReadonlyArray + } +type Op = + | { readonly op: "string" | "sharedString"; readonly ref: string; readonly value: string } + | { readonly op: "bytes"; readonly ref: string; readonly value: ReadonlyArray } + | { readonly op: "vector"; readonly ref: string; readonly type: ScalarType; readonly values: ReadonlyArray } + | { readonly op: "offsets"; readonly ref: string; readonly refs: ReadonlyArray } + | { + readonly op: "structs" + readonly ref: string + readonly struct: StructDef + readonly items: ReadonlyArray> + } + | { readonly op: "table"; readonly ref: string; readonly slots: number; readonly fields: ReadonlyArray } +interface Case { + readonly id: string + readonly ops: ReadonlyArray + readonly finish: { readonly root: string; readonly identifier?: string; readonly sizePrefixed?: boolean } + readonly forceDefaults?: boolean + readonly initialSize?: number + readonly bytes: string +} + +const gold: { readonly cases: ReadonlyArray } = JSON.parse( + readFileSync(new URL("../fixtures/flatbuffers/gold.json", import.meta.url), "utf8") +) + +const fromHex = (hex: string) => Uint8Array.from(hex.match(/../g) ?? [], (b) => parseInt(b, 16)) +const toHex = (bytes: Uint8Array) => Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("") + +const SIZE: Record = { + bool: 1, + int8: 1, + uint8: 1, + int16: 2, + uint16: 2, + int32: 4, + uint32: 4, + int64: 8, + uint64: 8, + float32: 4, + float64: 8 +} + +const value = (type: ScalarType, v: Scalar): boolean | number | bigint => + type === "int64" || type === "uint64" ? BigInt(v as string) : typeof v === "string" ? Number(v) : v + +/** The value as the buffer stores it: integers wrap, float32 rounds. */ +const stored = (type: ScalarType, v: Scalar): boolean | number | bigint => { + const x = value(type, v) + return type === "float32" ? Math.fround(x as number) : x +} + +const add = (b: FlatBuffers.Builder, type: ScalarType, v: Scalar) => { + const x = value(type, v) + switch (type) { + case "bool": + return b.addBool(x as boolean) + case "int8": + return b.addInt8(x as number) + case "uint8": + return b.addUint8(x as number) + case "int16": + return b.addInt16(x as number) + case "uint16": + return b.addUint16(x as number) + case "int32": + return b.addInt32(x as number) + case "uint32": + return b.addUint32(x as number) + case "int64": + return b.addInt64(x as bigint) + case "uint64": + return b.addUint64(x as bigint) + case "float32": + return b.addFloat32(x as number) + case "float64": + return b.addFloat64(x as number) + } +} + +const addField = (b: FlatBuffers.Builder, slot: number, type: ScalarType, v: Scalar, d: Scalar) => { + const x = value(type, v) + const fallback = value(type, d) + switch (type) { + case "bool": + return b.addFieldBool(slot, x as boolean, fallback as boolean) + case "int8": + return b.addFieldInt8(slot, x as number, fallback as number) + case "uint8": + return b.addFieldUint8(slot, x as number, fallback as number) + case "int16": + return b.addFieldInt16(slot, x as number, fallback as number) + case "uint16": + return b.addFieldUint16(slot, x as number, fallback as number) + case "int32": + return b.addFieldInt32(slot, x as number, fallback as number) + case "uint32": + return b.addFieldUint32(slot, x as number, fallback as number) + case "int64": + return b.addFieldInt64(slot, x as bigint, fallback as bigint) + case "uint64": + return b.addFieldUint64(slot, x as bigint, fallback as bigint) + case "float32": + return b.addFieldFloat32(slot, x as number, fallback as number) + case "float64": + return b.addFieldFloat64(slot, x as number, fallback as number) + } +} + +/** Writes a struct the way flatc-generated code does: prep, then fields last to first with padding. */ +const writeStruct = (b: FlatBuffers.Builder, def: StructDef, values: ReadonlyArray) => { + b.prep(def.align, def.size) + let end = def.size + for (let i = def.fields.length - 1; i >= 0; i--) { + const field = def.fields[i] + b.pad(end - (field.offset + SIZE[field.type])) + add(b, field.type, values[i]) + end = field.offset + } + b.pad(end) + return b.offset +} + +const build = (c: Case): Uint8Array => { + const b = FlatBuffers.make({ initialSize: c.initialSize, forceDefaults: c.forceDefaults }) + const refs = new Map() + const ref = (name: string) => refs.get(name)! + for (const op of c.ops) { + switch (op.op) { + case "string": + refs.set(op.ref, b.createString(op.value)) + break + case "sharedString": + refs.set(op.ref, b.createSharedString(op.value)) + break + case "bytes": + refs.set(op.ref, b.createBytes(Uint8Array.from(op.value))) + break + case "vector": { + const size = SIZE[op.type] + b.startVector(size, op.values.length, size) + for (let i = op.values.length - 1; i >= 0; i--) add(b, op.type, op.values[i]) + refs.set(op.ref, b.endVector()) + break + } + case "offsets": + refs.set(op.ref, b.createOffsetVector(op.refs.map(ref))) + break + case "structs": + b.startVector(op.struct.size, op.items.length, op.struct.align) + for (let i = op.items.length - 1; i >= 0; i--) writeStruct(b, op.struct, op.items[i]) + refs.set(op.ref, b.endVector()) + break + case "table": + b.startTable(op.slots) + for (const field of op.fields) { + switch (field.kind) { + case "scalar": + addField(b, field.slot, field.type, field.value, field.default) + break + case "offset": + b.addFieldOffset(field.slot, ref(field.ref)) + break + case "struct": + b.addFieldStruct(field.slot, writeStruct(b, field.struct, field.value)) + break + } + } + refs.set(op.ref, b.endTable()) + break + } + } + return b.finish(ref(c.finish.root), c.finish) +} + +const readScalar = ( + reader: Pick, + type: ScalarType, + at: number +): boolean | number | bigint => reader[type](at) + +const readTableScalar = (table: FlatBuffers.Table, type: ScalarType, slot: number, fallback: Scalar) => { + const d = value(type, fallback) + switch (type) { + case "bool": + return table.bool(slot, d as boolean) + case "int64": + return table.int64(slot, d as bigint) + case "uint64": + return table.uint64(slot, d as bigint) + default: + return table[type](slot, d as number) + } +} + +const defined = (a: A | undefined): A => { + assert.isDefined(a) + return a! +} + +const checkStruct = (s: FlatBuffers.Struct, def: StructDef, values: ReadonlyArray) => { + def.fields.forEach((field, i) => + assert.deepStrictEqual(readScalar(s, field.type, field.offset), stored(field.type, values[i])) + ) +} + +/** Reads every value the case wrote back from the buffer. */ +const verify = (c: Case, bytes: Uint8Array) => { + const ops = new Map(c.ops.map((op) => [op.ref, op])) + const checkTable = (table: FlatBuffers.Table, op: Extract) => { + for (const field of op.fields) { + switch (field.kind) { + case "scalar": { + // A value equal to its default isn't written; reading it gives the default back. + const present = c.forceDefaults === true || + value(field.type, field.value) !== value(field.type, field.default) + assert.strictEqual(table.has(field.slot), present) + assert.deepStrictEqual( + readTableScalar(table, field.type, field.slot, field.default), + present ? stored(field.type, field.value) : value(field.type, field.default) + ) + break + } + case "struct": + checkStruct(defined(table.struct(field.slot, field.struct.size)), field.struct, field.value) + break + case "offset": + checkOffset(table, field.slot, ops.get(field.ref)!) + break + } + } + } + const checkOffset = (table: FlatBuffers.Table, slot: number, child: Op) => { + switch (child.op) { + case "string": + case "sharedString": + assert.strictEqual(table.string(slot), child.value) + break + case "bytes": + assert.deepStrictEqual(Array.from(defined(table.bytes(slot))), child.value) + break + case "vector": { + const vector = defined(table.vector(slot, SIZE[child.type])) + assert.deepStrictEqual( + Array.from({ length: vector.length }, (_, i) => vector[child.type](i)), + child.values.map((v) => stored(child.type, v)) + ) + break + } + case "structs": { + const vector = defined(table.vector(slot, child.struct.size)) + assert.strictEqual(vector.length, child.items.length) + child.items.forEach((item, i) => checkStruct(vector.struct(i, child.struct.size), child.struct, item)) + break + } + case "offsets": { + const vector = defined(table.vector(slot, 4)) + assert.strictEqual(vector.length, child.refs.length) + child.refs.forEach((name, i) => { + const element = ops.get(name)! + if (element.op === "table") checkTable(vector.table(i), element) + else if (element.op === "string" || element.op === "sharedString") { + assert.strictEqual(vector.string(i), element.value) + } + }) + break + } + case "table": + checkTable(defined(table.table(slot)), child) + break + } + } + const root = ops.get(c.finish.root)! as Extract + checkTable(FlatBuffers.root(bytes, c.finish), root) + if (c.finish.identifier !== undefined) { + assert.strictEqual(FlatBuffers.identifier(bytes, c.finish), c.finish.identifier) + } +} + +describe("FlatBuffers", () => { + it("builds the bytes the official builder builds", () => { + assert.isAbove(gold.cases.length, 300) + for (const c of gold.cases) { + assert.strictEqual(toHex(build(c)), c.bytes, c.id) + } + }) + + it("reads every value back from the official builder's bytes", () => { + for (const c of gold.cases) { + verify(c, fromHex(c.bytes)) + } + }) + + it("reads absent fields as their defaults", () => { + const b = FlatBuffers.make() + b.startTable(4) + const root = FlatBuffers.root(b.finish(b.endTable())) + assert.strictEqual(root.has(0), false) + assert.strictEqual(root.int32(0, 7), 7) + assert.strictEqual(root.bool(1, true), true) + assert.strictEqual(root.uint64(2, BigInt(9)), BigInt(9)) + assert.strictEqual(root.string(3), undefined) + assert.strictEqual(root.table(3), undefined) + assert.strictEqual(root.vector(3, 1), undefined) + // Slots past the vtable, as written by an older schema, are absent too. + assert.strictEqual(root.float64(100, 1.5), 1.5) + }) + + it("decode returns a failure for malformed input", () => { + const failure = (bytes: Uint8Array, options?: FlatBuffers.Options) => { + const result = FlatBuffers.decode(bytes, (root) => root.string(0), options) + assert.isTrue(Result.isFailure(result)) + return Result.isFailure(result) ? result.failure.kind : undefined + } + assert.strictEqual(failure(new Uint8Array(2)), "OutOfBounds") + assert.strictEqual(failure(Uint8Array.of(0xff, 0xff, 0xff, 0x7f)), "OutOfBounds") + // A vtable of size 1. + assert.strictEqual(failure(Uint8Array.of(8, 0, 0, 0, 1, 0, 4, 0, 4, 0, 0, 0)), "InvalidVtable") + // A string field with an invalid UTF-8 byte. + const b = FlatBuffers.make() + const s = b.createString(Uint8Array.of(0xc3, 0x28)) + b.startTable(1) + b.addFieldOffset(0, s) + assert.strictEqual(failure(b.finish(b.endTable())), "InvalidUtf8") + assert.strictEqual(failure(fromHex(gold.cases[1].bytes), { identifier: "NOPE" }), "Identifier") + assert.strictEqual(failure(Uint8Array.of(0xff, 0, 0, 0, 0, 0, 0, 0), { sizePrefixed: true }), "OutOfBounds") + }) + + it("decode rethrows errors that aren't FlatBuffersErrors", () => { + const bytes = fromHex(gold.cases[0].bytes) + assert.throws(() => + FlatBuffers.decode(bytes, () => { + throw new Error("boom") + }), "boom") + }) + + it("only ever fails with FlatBuffersError on corrupted buffers", () => { + // Deterministic xorshift so failures reproduce. + let seed = 0x2f6b1d3 + const random = () => { + seed ^= seed << 13 + seed ^= seed >>> 17 + seed ^= seed << 5 + return (seed >>> 0) / 0x100000000 + } + let failures = 0 + for (const c of gold.cases) { + const original = fromHex(c.bytes) + for (let round = 0; round < 20; round++) { + const bytes = original.slice(0, random() < 0.2 ? Math.floor(random() * original.length) : original.length) + const flips = 1 + Math.floor(random() * 4) + for (let i = 0; i < flips && bytes.length > 0; i++) { + bytes[Math.floor(random() * bytes.length)] = Math.floor(random() * 256) + } + try { + verify(c, bytes) + } catch (error) { + if (error instanceof Error && error.name === "AssertionError") continue + assert.isTrue(FlatBuffers.isFlatBuffersError(error), `${c.id}: ${String(error)}`) + failures++ + } + } + } + assert.isAbove(failures, 0) + }) + + describe("Builder", () => { + it("rejects nested and out-of-order calls", () => { + const usage = (f: (b: FlatBuffers.Builder) => void) => { + const b = FlatBuffers.make() + try { + f(b) + assert.fail("expected a FlatBuffersError") + } catch (error) { + assert.isTrue(FlatBuffers.isFlatBuffersError(error)) + assert.strictEqual((error as FlatBuffers.FlatBuffersError).kind, "Usage") + } + } + usage((b) => { + b.startTable(1) + b.createString("x") + }) + usage((b) => { + b.startTable(1) + b.startTable(1) + }) + usage((b) => { + b.startVector(1, 1, 1) + b.startTable(1) + }) + usage((b) => b.endTable()) + usage((b) => b.endVector()) + usage((b) => { + b.startTable(1) + b.addFieldInt32(1, 5) + }) + usage((b) => b.addFieldInt32(0, 5)) + usage((b) => { + b.addInt32(1) + const s = b.offset + b.addInt32(2) + b.startTable(1) + b.addFieldStruct(0, s) + }) + usage((b) => { + b.startTable(0) + b.finish(b.endTable(), { identifier: "TOOLONG" }) + }) + usage((b) => b.addOffset(100)) + }) + + it("wraps integers to their width", () => { + const b = FlatBuffers.make() + b.startTable(3) + b.addFieldUint8(0, 256 + 7) + b.addFieldInt16(1, 0x18000) + b.addFieldUint64(2, -BigInt(1)) + const root = FlatBuffers.root(b.finish(b.endTable())) + assert.strictEqual(root.uint8(0), 7) + assert.strictEqual(root.int16(1), -32768) + assert.strictEqual(root.uint64(2), 2n ** 64n - 1n) + }) + + it("returns a copy, leaving the builder's buffer alone", () => { + const b = FlatBuffers.make({ initialSize: 1 }) + b.startTable(0) + const bytes = b.finish(b.endTable()) + assert.strictEqual(bytes.byteOffset, 0) + assert.strictEqual(bytes.buffer.byteLength, bytes.length) + }) + }) +}) diff --git a/packages/effect/test/fixtures/flatbuffers/README.md b/packages/effect/test/fixtures/flatbuffers/README.md new file mode 100644 index 00000000000..a292b349cdf --- /dev/null +++ b/packages/effect/test/fixtures/flatbuffers/README.md @@ -0,0 +1,13 @@ +# FlatBuffers fixtures + +`gold.json` is read by `test/encoding/FlatBuffers.test.ts`. Each case is a +sequence of builder calls and the bytes the official FlatBuffers Python +builder (`flatbuffers` 25.12.19 from PyPI) produces for them: hand-written +cases for each feature, then 300 seeded random cases. + +Regenerate with: + +```sh +pip install flatbuffers==25.12.19 +python test/fixtures/flatbuffers/generate.py +``` diff --git a/packages/effect/test/fixtures/flatbuffers/generate.py b/packages/effect/test/fixtures/flatbuffers/generate.py new file mode 100644 index 00000000000..cfeffa22206 --- /dev/null +++ b/packages/effect/test/fixtures/flatbuffers/generate.py @@ -0,0 +1,327 @@ +""" +Gold corpus for effect/encoding/FlatBuffers: builder op sequences run by the +official FlatBuffers Python builder (pip install flatbuffers), and the bytes +it produces. The TypeScript test replays every op sequence through +FlatBuffers.Builder, expects the same bytes, and reads every value back. + + python test/fixtures/flatbuffers/generate.py # writes gold.json + +Ops (run in order; `ref` names the offset an op returns): + {"op": "string", "ref", "value"} CreateString + {"op": "sharedString", "ref", "value"} CreateSharedString + {"op": "bytes", "ref", "value": [ints]} CreateByteVector + {"op": "vector", "ref", "type", "values"} a vector of scalars + {"op": "offsets", "ref", "refs"} a vector of offsets + {"op": "structs", "ref", "struct", "items"} a vector of structs + {"op": "table", "ref", "slots", "fields"} a table; fields are added in order: + {"slot", "kind": "scalar", "type", "value", "default"} + {"slot", "kind": "offset", "ref"} + {"slot", "kind": "struct", "struct", "value": [field values]} +Structs: {"size", "align", "fields": [{"type", "offset"}]}. +64-bit integers are decimal strings; non-finite floats are "Infinity", +"-Infinity" or "NaN". +""" + +import json +import random +import struct as pystruct +from pathlib import Path + +import flatbuffers +from flatbuffers import number_types as N + +HERE = Path(__file__).parent + +SCALARS = { + "bool": (N.BoolFlags, 1), + "int8": (N.Int8Flags, 1), + "uint8": (N.Uint8Flags, 1), + "int16": (N.Int16Flags, 2), + "uint16": (N.Uint16Flags, 2), + "int32": (N.Int32Flags, 4), + "uint32": (N.Uint32Flags, 4), + "int64": (N.Int64Flags, 8), + "uint64": (N.Uint64Flags, 8), + "float32": (N.Float32Flags, 4), + "float64": (N.Float64Flags, 8), +} +SLOT = { + "bool": "PrependBoolSlot", + "int8": "PrependInt8Slot", + "uint8": "PrependUint8Slot", + "int16": "PrependInt16Slot", + "uint16": "PrependUint16Slot", + "int32": "PrependInt32Slot", + "uint32": "PrependUint32Slot", + "int64": "PrependInt64Slot", + "uint64": "PrependUint64Slot", + "float32": "PrependFloat32Slot", + "float64": "PrependFloat64Slot", +} +PREPEND = {t: "Prepend" + s[len("Prepend"):-len("Slot")] for t, s in SLOT.items()} + + +def py(value, t): + if t in ("int64", "uint64"): + return int(value) + if t in ("float32", "float64") and isinstance(value, str): + return float(value) + return value + + +def write_struct(b, s, values): + b.Prep(s["align"], s["size"]) + fields = s["fields"] + end = s["size"] + for f, v in reversed(list(zip(fields, values))): + size = SCALARS[f["type"]][1] + b.Pad(end - (f["offset"] + size)) + getattr(b, PREPEND[f["type"]])(py(v, f["type"])) + end = f["offset"] + b.Pad(end) + return b.Offset() + + +def run(case): + b = flatbuffers.Builder(case.get("initialSize", 1024)) + if case.get("forceDefaults"): + b.ForceDefaults(True) + refs = {} + for op in case["ops"]: + kind = op["op"] + if kind == "string": + refs[op["ref"]] = b.CreateString(op["value"]) + elif kind == "sharedString": + refs[op["ref"]] = b.CreateSharedString(op["value"]) + elif kind == "bytes": + refs[op["ref"]] = b.CreateByteVector(bytes(op["value"])) + elif kind == "vector": + flags, size = SCALARS[op["type"]] + b.StartVector(size, len(op["values"]), size) + for v in reversed(op["values"]): + getattr(b, PREPEND[op["type"]])(py(v, op["type"])) + refs[op["ref"]] = b.EndVector() + elif kind == "offsets": + b.StartVector(4, len(op["refs"]), 4) + for r in reversed(op["refs"]): + b.PrependUOffsetTRelative(refs[r]) + refs[op["ref"]] = b.EndVector() + elif kind == "structs": + s = op["struct"] + b.StartVector(s["size"], len(op["items"]), s["align"]) + for item in reversed(op["items"]): + write_struct(b, s, item) + refs[op["ref"]] = b.EndVector() + elif kind == "table": + b.StartObject(op["slots"]) + for f in op["fields"]: + if f["kind"] == "scalar": + getattr(b, SLOT[f["type"]])(f["slot"], py(f["value"], f["type"]), py(f["default"], f["type"])) + elif f["kind"] == "offset": + b.PrependUOffsetTRelativeSlot(f["slot"], refs[f["ref"]], 0) + else: + b.PrependStructSlot(f["slot"], write_struct(b, f["struct"], f["value"]), 0) + refs[op["ref"]] = b.EndObject() + else: + raise ValueError(kind) + finish = case["finish"] + identifier = finish.get("identifier") + identifier = identifier.encode() if identifier is not None else None + if finish.get("sizePrefixed"): + b.FinishSizePrefixed(refs[finish["root"]], file_identifier=identifier) + else: + b.Finish(refs[finish["root"]], file_identifier=identifier) + return bytes(b.Output()).hex() + + +# --------------------------------------------------------------------------- +# Cases +# --------------------------------------------------------------------------- + +VEC3 = {"size": 12, "align": 4, "fields": [{"type": "float32", "offset": 0}, {"type": "float32", "offset": 4}, {"type": "float32", "offset": 8}]} +PADDED = {"size": 16, "align": 8, "fields": [{"type": "int8", "offset": 0}, {"type": "int32", "offset": 4}, {"type": "int64", "offset": 8}]} +SMALL = {"size": 4, "align": 2, "fields": [{"type": "uint8", "offset": 0}, {"type": "int16", "offset": 2}]} + + +def spec(): + out = [] + add = lambda id, description, **case: out.append({"id": id, "description": description, **case}) + add("empty-table", "a table without fields", ops=[{"op": "table", "ref": "t", "slots": 0, "fields": []}], finish={"root": "t"}) + add("monster", "strings, scalars, a struct, vectors and a nested table", ops=[ + {"op": "string", "ref": "name", "value": "Orc"}, + {"op": "bytes", "ref": "inventory", "value": [0, 1, 2, 3, 4]}, + {"op": "string", "ref": "sword", "value": "Sword"}, + {"op": "table", "ref": "weapon", "slots": 2, "fields": [ + {"slot": 0, "kind": "offset", "ref": "sword"}, + {"slot": 1, "kind": "scalar", "type": "int16", "value": 3, "default": 0}]}, + {"op": "offsets", "ref": "weapons", "refs": ["weapon"]}, + {"op": "table", "ref": "monster", "slots": 8, "fields": [ + {"slot": 0, "kind": "struct", "struct": VEC3, "value": [1.0, 2.0, 3.0]}, + {"slot": 2, "kind": "scalar", "type": "int16", "value": 300, "default": 100}, + {"slot": 3, "kind": "offset", "ref": "name"}, + {"slot": 5, "kind": "offset", "ref": "inventory"}, + {"slot": 6, "kind": "scalar", "type": "uint8", "value": 2, "default": 0}, + {"slot": 7, "kind": "offset", "ref": "weapons"}]}], + finish={"root": "monster", "identifier": "MONS"}) + add("defaults-skipped", "scalars equal to their default are not written", ops=[ + {"op": "table", "ref": "t", "slots": 3, "fields": [ + {"slot": 0, "kind": "scalar", "type": "int32", "value": 7, "default": 7}, + {"slot": 1, "kind": "scalar", "type": "float64", "value": 0.5, "default": 0.5}, + {"slot": 2, "kind": "scalar", "type": "bool", "value": True, "default": True}]}], finish={"root": "t"}) + add("force-defaults", "forceDefaults writes defaults too", forceDefaults=True, ops=[ + {"op": "table", "ref": "t", "slots": 3, "fields": [ + {"slot": 0, "kind": "scalar", "type": "int32", "value": 7, "default": 7}, + {"slot": 1, "kind": "scalar", "type": "float64", "value": 0.5, "default": 0.5}, + {"slot": 2, "kind": "scalar", "type": "bool", "value": True, "default": True}]}], finish={"root": "t"}) + add("shared-vtables", "tables with the same layout share one vtable", ops=[ + {"op": "table", "ref": "a", "slots": 2, "fields": [{"slot": 0, "kind": "scalar", "type": "int32", "value": 1, "default": 0}]}, + {"op": "table", "ref": "b", "slots": 2, "fields": [{"slot": 0, "kind": "scalar", "type": "int32", "value": 2, "default": 0}]}, + {"op": "table", "ref": "c", "slots": 2, "fields": [{"slot": 1, "kind": "scalar", "type": "int32", "value": 3, "default": 0}]}, + {"op": "offsets", "ref": "all", "refs": ["a", "b", "c"]}, + {"op": "table", "ref": "root", "slots": 1, "fields": [{"slot": 0, "kind": "offset", "ref": "all"}]}], finish={"root": "root"}) + add("extremes", "integer and float extremes", ops=[ + {"op": "table", "ref": "t", "slots": 11, "fields": [ + {"slot": 0, "kind": "scalar", "type": "int8", "value": -128, "default": 0}, + {"slot": 1, "kind": "scalar", "type": "uint8", "value": 255, "default": 0}, + {"slot": 2, "kind": "scalar", "type": "int16", "value": -32768, "default": 0}, + {"slot": 3, "kind": "scalar", "type": "uint16", "value": 65535, "default": 0}, + {"slot": 4, "kind": "scalar", "type": "int32", "value": -2147483648, "default": 0}, + {"slot": 5, "kind": "scalar", "type": "uint32", "value": 4294967295, "default": 0}, + {"slot": 6, "kind": "scalar", "type": "int64", "value": "-9223372036854775808", "default": "0"}, + {"slot": 7, "kind": "scalar", "type": "uint64", "value": "18446744073709551615", "default": "0"}, + {"slot": 8, "kind": "scalar", "type": "float32", "value": -3.4028234663852886e38, "default": 0.0}, + {"slot": 9, "kind": "scalar", "type": "float64", "value": 5e-324, "default": 0.0}, + {"slot": 10, "kind": "scalar", "type": "float64", "value": "Infinity", "default": 0.0}]}], finish={"root": "t"}) + add("strings", "empty, unicode and shared strings", ops=[ + {"op": "string", "ref": "e", "value": ""}, + {"op": "string", "ref": "u", "value": "héllo wörld 😀 ￿"}, + {"op": "sharedString", "ref": "s1", "value": "shared"}, + {"op": "sharedString", "ref": "s2", "value": "shared"}, + {"op": "offsets", "ref": "v", "refs": ["e", "u", "s1", "s2"]}, + {"op": "table", "ref": "t", "slots": 1, "fields": [{"slot": 0, "kind": "offset", "ref": "v"}]}], finish={"root": "t"}) + add("scalar-vectors", "vectors of every scalar type", ops=[ + *[{"op": "vector", "ref": t, "type": t, "values": vals} for t, vals in [ + ("bool", [True, False, True]), ("int8", [-1, 2]), ("uint8", []), ("int16", [-300, 300, 7]), + ("uint16", [65535]), ("int32", [1, -2, 3, -4, 5]), ("uint32", [4000000000]), + ("int64", ["-5", "9007199254740993"]), ("uint64", ["18446744073709551615"]), ("float32", [1.5, -0.25]), + ("float64", [3.141592653589793, -0.0])]], + {"op": "table", "ref": "t", "slots": 11, "fields": [ + {"slot": i, "kind": "offset", "ref": t} for i, t in enumerate( + ["bool", "int8", "uint8", "int16", "uint16", "int32", "uint32", "int64", "uint64", "float32", "float64"])]}], + finish={"root": "t"}) + add("struct-vectors", "vectors of structs with padding", ops=[ + {"op": "structs", "ref": "p", "struct": PADDED, "items": [[1, 2, "3"], [-1, -2, "-3"]]}, + {"op": "structs", "ref": "s", "struct": SMALL, "items": [[255, -1], [0, 2], [7, 300]]}, + {"op": "table", "ref": "t", "slots": 3, "fields": [ + {"slot": 0, "kind": "offset", "ref": "p"}, + {"slot": 1, "kind": "struct", "struct": PADDED, "value": [9, 8, "7"]}, + {"slot": 2, "kind": "offset", "ref": "s"}]}], finish={"root": "t"}) + add("size-prefixed", "a size-prefixed buffer with an identifier", ops=[ + {"op": "string", "ref": "s", "value": "x"}, + {"op": "table", "ref": "t", "slots": 2, "fields": [ + {"slot": 0, "kind": "offset", "ref": "s"}, + {"slot": 1, "kind": "scalar", "type": "int64", "value": "42", "default": "0"}]}], + finish={"root": "t", "identifier": "ABCD", "sizePrefixed": True}) + add("growth", "a small initial size grows", initialSize=1, ops=[ + {"op": "bytes", "ref": "b", "value": list(range(256)) * 4}, + {"op": "table", "ref": "t", "slots": 1, "fields": [{"slot": 0, "kind": "offset", "ref": "b"}]}], finish={"root": "t"}) + return out + + +# --------------------------------------------------------------------------- +# Random cases +# --------------------------------------------------------------------------- + +def random_scalar(rng, t): + if t == "bool": + return rng.random() < 0.5 + if t == "float32": + return rng.choice([0.0, 1.5, -2.25, 1024.0, 3.0e10, -0.5]) + if t == "float64": + return rng.choice([0.0, 0.1, -1e-300, 2.5, 1e300, 123456.789]) + bits = {"int8": 8, "uint8": 8, "int16": 16, "uint16": 16, "int32": 32, "uint32": 32, "int64": 64, "uint64": 64}[t] + signed = not t.startswith("u") + lo, hi = (-(2 ** (bits - 1)), 2 ** (bits - 1) - 1) if signed else (0, 2 ** bits - 1) + v = rng.choice([0, 1, lo, hi, rng.randint(lo, hi), rng.randint(-5, 5) if signed else rng.randint(0, 5)]) + return str(v) if bits == 64 else v + + +STRUCTS = [VEC3, PADDED, SMALL] +TYPES = list(SCALARS) + + +def random_case(rng, index): + ops = [] + counter = [0] + + def ref(): + counter[0] += 1 + return f"r{counter[0]}" + + def table(depth): + slots = rng.randint(0, 8) + fields = [] + for slot in rng.sample(range(slots), rng.randint(0, slots)) if slots else []: + r = rng.random() + if r < 0.45: + t = rng.choice(TYPES) + v = random_scalar(rng, t) + d = v if rng.random() < 0.2 else random_scalar(rng, t) + fields.append({"slot": slot, "kind": "scalar", "type": t, "value": v, "default": d}) + elif r < 0.6: + s = rng.choice(STRUCTS) + fields.append({"slot": slot, "kind": "struct", "struct": s, + "value": [random_scalar(rng, f["type"]) for f in s["fields"]]}) + else: + child = rng.random() + name = ref() + if child < 0.25: + ops.append({"op": "string", "ref": name, "value": rng.choice(["", "a", "héllo", "😀😀", "x" * 40])}) + elif child < 0.4: + ops.append({"op": "bytes", "ref": name, "value": [rng.randint(0, 255) for _ in range(rng.randint(0, 20))]}) + elif child < 0.6: + t = rng.choice(TYPES) + ops.append({"op": "vector", "ref": name, "type": t, + "values": [random_scalar(rng, t) for _ in range(rng.randint(0, 6))]}) + elif child < 0.7: + s = rng.choice(STRUCTS) + ops.append({"op": "structs", "ref": name, "struct": s, + "items": [[random_scalar(rng, f["type"]) for f in s["fields"]] for _ in range(rng.randint(0, 4))]}) + elif child < 0.85 and depth < 3: + name = table(depth + 1) + elif depth < 3: + children = [table(depth + 1) for _ in range(rng.randint(0, 3))] + ops.append({"op": "offsets", "ref": name, "refs": children}) + else: + ops.append({"op": "string", "ref": name, "value": "leaf"}) + fields.append({"slot": slot, "kind": "offset", "ref": name}) + name = ref() + ops.append({"op": "table", "ref": name, "slots": slots, "fields": fields}) + return name + + root = table(0) + finish = {"root": root} + if rng.random() < 0.3: + finish["identifier"] = rng.choice(["ABCD", "MONS", "1234"]) + if rng.random() < 0.2: + finish["sizePrefixed"] = True + case = {"id": f"random/{index:03d}", "description": "seeded random buffer", "ops": ops, "finish": finish} + if rng.random() < 0.15: + case["forceDefaults"] = True + if rng.random() < 0.2: + case["initialSize"] = rng.choice([1, 16, 100]) + return case + + +def main(): + rng = random.Random(20261114) + cases = spec() + [random_case(rng, i) for i in range(300)] + for c in cases: + c["bytes"] = run(c) + header = {"generator": "generate.py", "flatbuffers": flatbuffers.__version__ if hasattr(flatbuffers, "__version__") else "?"} + (HERE / "gold.json").write_text(json.dumps({**header, "cases": cases}, ensure_ascii=False, allow_nan=False, separators=(",", ":")) + "\n") + print(f"{len(cases)} cases, {sum(len(c['bytes']) // 2 for c in cases)} bytes") + + +if __name__ == "__main__": + main() diff --git a/packages/effect/test/fixtures/flatbuffers/gold.json b/packages/effect/test/fixtures/flatbuffers/gold.json new file mode 100644 index 00000000000..64dd87eb029 --- /dev/null +++ b/packages/effect/test/fixtures/flatbuffers/gold.json @@ -0,0 +1 @@ +{"generator":"generate.py","flatbuffers":"25.12.19","cases":[{"id":"empty-table","description":"a table without fields","ops":[{"op":"table","ref":"t","slots":0,"fields":[]}],"finish":{"root":"t"},"bytes":"080000000400040004000000"},{"id":"monster","description":"strings, scalars, a struct, vectors and a nested table","ops":[{"op":"string","ref":"name","value":"Orc"},{"op":"bytes","ref":"inventory","value":[0,1,2,3,4]},{"op":"string","ref":"sword","value":"Sword"},{"op":"table","ref":"weapon","slots":2,"fields":[{"slot":0,"kind":"offset","ref":"sword"},{"slot":1,"kind":"scalar","type":"int16","value":3,"default":0}]},{"op":"offsets","ref":"weapons","refs":["weapon"]},{"op":"table","ref":"monster","slots":8,"fields":[{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.0,2.0,3.0]},{"slot":2,"kind":"scalar","type":"int16","value":300,"default":100},{"slot":3,"kind":"offset","ref":"name"},{"slot":5,"kind":"offset","ref":"inventory"},{"slot":6,"kind":"scalar","type":"uint8","value":2,"default":0},{"slot":7,"kind":"offset","ref":"weapons"}]}],"finish":{"root":"monster","identifier":"MONS"},"bytes":"1c0000004d4f4e5314002400180000001600100000000c000b000400140000002000000000000002400000004800000000002c010000803f0000004000004040010000000c00000008000c00080006000800000000000300040000000500000053776f7264000000050000000001020304000000030000004f726300"},{"id":"defaults-skipped","description":"scalars equal to their default are not written","ops":[{"op":"table","ref":"t","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"int32","value":7,"default":7},{"slot":1,"kind":"scalar","type":"float64","value":0.5,"default":0.5},{"slot":2,"kind":"scalar","type":"bool","value":true,"default":true}]}],"finish":{"root":"t"},"bytes":"080000000400040004000000"},{"id":"force-defaults","description":"forceDefaults writes defaults too","forceDefaults":true,"ops":[{"op":"table","ref":"t","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"int32","value":7,"default":7},{"slot":1,"kind":"scalar","type":"float64","value":0.5,"default":0.5},{"slot":2,"kind":"scalar","type":"bool","value":true,"default":true}]}],"finish":{"root":"t"},"bytes":"1000000000000a0018001400080007000a00000000000001000000000000e03f0000000007000000"},{"id":"shared-vtables","description":"tables with the same layout share one vtable","ops":[{"op":"table","ref":"a","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"int32","value":1,"default":0}]},{"op":"table","ref":"b","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"int32","value":2,"default":0}]},{"op":"table","ref":"c","slots":2,"fields":[{"slot":1,"kind":"scalar","type":"int32","value":3,"default":0}]},{"op":"offsets","ref":"all","refs":["a","b","c"]},{"op":"table","ref":"root","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"all"}]}],"finish":{"root":"root"},"bytes":"04000000c6ffffff040000000300000034000000200000000c00000008000a00000004000800000003000000000006000a000400060000000200000000000600080004000600000001000000"},{"id":"extremes","description":"integer and float extremes","ops":[{"op":"table","ref":"t","slots":11,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":-128,"default":0},{"slot":1,"kind":"scalar","type":"uint8","value":255,"default":0},{"slot":2,"kind":"scalar","type":"int16","value":-32768,"default":0},{"slot":3,"kind":"scalar","type":"uint16","value":65535,"default":0},{"slot":4,"kind":"scalar","type":"int32","value":-2147483648,"default":0},{"slot":5,"kind":"scalar","type":"uint32","value":4294967295,"default":0},{"slot":6,"kind":"scalar","type":"int64","value":"-9223372036854775808","default":"0"},{"slot":7,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"0"},{"slot":8,"kind":"scalar","type":"float32","value":-3.4028234663852886e+38,"default":0.0},{"slot":9,"kind":"scalar","type":"float64","value":5e-324,"default":0.0},{"slot":10,"kind":"scalar","type":"float64","value":"Infinity","default":0.0}]}],"finish":{"root":"t"},"bytes":"240000000000000000001a003c003b003a003800360030002c0024001c0018000c0004001a000000000000000000f07f010000000000000000000000ffff7fffffffffffffffffff0000000000000080ffffffff000000800000ffff0080ff80"},{"id":"strings","description":"empty, unicode and shared strings","ops":[{"op":"string","ref":"e","value":""},{"op":"string","ref":"u","value":"héllo wörld 😀 ￿"},{"op":"sharedString","ref":"s1","value":"shared"},{"op":"sharedString","ref":"s2","value":"shared"},{"op":"offsets","ref":"v","refs":["e","u","s1","s2"]},{"op":"table","ref":"t","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"v"}]}],"finish":{"root":"t"},"bytes":"0c0000000000060008000400060000000400000004000000380000001800000008000000040000000600000073686172656400001600000068c3a96c6c6f2077c3b6726c6420f09f988020efbfbf00000000000000000000"},{"id":"scalar-vectors","description":"vectors of every scalar type","ops":[{"op":"vector","ref":"bool","type":"bool","values":[true,false,true]},{"op":"vector","ref":"int8","type":"int8","values":[-1,2]},{"op":"vector","ref":"uint8","type":"uint8","values":[]},{"op":"vector","ref":"int16","type":"int16","values":[-300,300,7]},{"op":"vector","ref":"uint16","type":"uint16","values":[65535]},{"op":"vector","ref":"int32","type":"int32","values":[1,-2,3,-4,5]},{"op":"vector","ref":"uint32","type":"uint32","values":[4000000000]},{"op":"vector","ref":"int64","type":"int64","values":["-5","9007199254740993"]},{"op":"vector","ref":"uint64","type":"uint64","values":["18446744073709551615"]},{"op":"vector","ref":"float32","type":"float32","values":[1.5,-0.25]},{"op":"vector","ref":"float64","type":"float64","values":[3.141592653589793,-0.0]},{"op":"table","ref":"t","slots":11,"fields":[{"slot":0,"kind":"offset","ref":"bool"},{"slot":1,"kind":"offset","ref":"int8"},{"slot":2,"kind":"offset","ref":"uint8"},{"slot":3,"kind":"offset","ref":"int16"},{"slot":4,"kind":"offset","ref":"uint16"},{"slot":5,"kind":"offset","ref":"int32"},{"slot":6,"kind":"offset","ref":"uint32"},{"slot":7,"kind":"offset","ref":"int64"},{"slot":8,"kind":"offset","ref":"uint64"},{"slot":9,"kind":"offset","ref":"float32"},{"slot":10,"kind":"offset","ref":"float64"}]}],"finish":{"root":"t"},"bytes":"240000000000000000001a0030002c002800240020001c001800140010000c00080004001a0000002c0000003c00000044000000500000006000000064000000780000007c00000084000000840000008800000002000000182d4454fb2109400000000000000080020000000000c03f000080be01000000ffffffffffffffff0000000002000000fbffffffffffffff01000000000020000100000000286bee0500000001000000feffffff03000000fcffffff0500000001000000ffff000003000000d4fe2c01070000000000000002000000ff0200000300000001000100"},{"id":"struct-vectors","description":"vectors of structs with padding","ops":[{"op":"structs","ref":"p","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[1,2,"3"],[-1,-2,"-3"]]},{"op":"structs","ref":"s","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[255,-1],[0,2],[7,300]]},{"op":"table","ref":"t","slots":3,"fields":[{"slot":0,"kind":"offset","ref":"p"},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[9,8,"7"]},{"slot":2,"kind":"offset","ref":"s"}]}],"finish":{"root":"t"},"bytes":"1000000000000a001c001800080004000a00000018000000090000000800000007000000000000001400000003000000ff00ffff0000020007002c010200000001000000020000000300000000000000ff000000fefffffffdffffffffffffff"},{"id":"size-prefixed","description":"a size-prefixed buffer with an identifier","ops":[{"op":"string","ref":"s","value":"x"},{"op":"table","ref":"t","slots":2,"fields":[{"slot":0,"kind":"offset","ref":"s"},{"slot":1,"kind":"scalar","type":"int64","value":"42","default":"0"}]}],"finish":{"root":"t","identifier":"ABCD","sizePrefixed":true},"bytes":"2c00000010000000414243440800140010000400080000002a0000000000000000000000040000000100000078000000"},{"id":"growth","description":"a small initial size grows","initialSize":1,"ops":[{"op":"bytes","ref":"b","value":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255]},{"op":"table","ref":"t","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"b"}]}],"finish":{"root":"t"},"bytes":"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"},{"id":"random/000","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/001","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int32","values":[-2147483648,1,2147483647,0,0,1]},{"op":"vector","ref":"r2","type":"uint8","values":[0]},{"op":"table","ref":"r3","slots":7,"fields":[{"slot":3,"kind":"scalar","type":"uint32","value":3,"default":1},{"slot":5,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"forceDefaults":true,"bytes":"14000000100010000000040000000c0000000800100000000c00000010000000030000000100000000000000060000000000008001000000ffffff7f000000000000000001000000"},{"id":"random/002","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float32","values":[1.5,-0.5,0.0,-0.5,-0.5]},{"op":"bytes","ref":"r2","value":[190,88,6,56,207,90,224,221,59,63,120]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":5,"kind":"scalar","type":"int32","value":2147483647,"default":-4},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,1]},{"slot":4,"kind":"offset","ref":"r1"},{"slot":1,"kind":"scalar","type":"int16","value":32767,"default":32767},{"slot":2,"kind":"offset","ref":"r2"},{"slot":6,"kind":"scalar","type":"uint8","value":1,"default":0}]}],"finish":{"root":"r3"},"initialSize":16,"bytes":"1800000000001200180000000000080010000c00140007001200000000000001100000001c000000ff000100ffffff7f0b000000be580638cf5ae0dd3b3f7800050000000000c03f000000bf00000000000000bf000000bf"},{"id":"random/003","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/004","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/005","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int16","values":[-32768,3]},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":4,"kind":"scalar","type":"uint16","value":0,"default":955},{"slot":6,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,-2147483648,"0"]},{"slot":0,"kind":"offset","ref":"r1"},{"slot":3,"kind":"scalar","type":"uint8","value":0,"default":255}]}],"finish":{"root":"r2"},"bytes":"1c000000000000000000120024000800000000000700220000000c0012000000000000001c0000000100000000000080000000000000000000000000000000000200000000800300"},{"id":"random/006","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[239,32767]}]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"140000000c000000080008000000040008000000ef00ff7f"},{"id":"random/007","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[]},{"op":"table","ref":"r2","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"0c0000000800080000000400080000000400000000000000"},{"id":"random/008","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"bytes":"0c000000080000000400040004000000"},{"id":"random/009","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"uint32","value":4294967295,"default":4294967295}]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/010","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":5,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,0.0,1.5]},{"slot":3,"kind":"scalar","type":"int8","value":0,"default":0},{"slot":2,"kind":"scalar","type":"int32","value":0,"default":0},{"slot":6,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"9223372036854775807"},{"slot":4,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[5,-2147483648,"-9223372036854775808"]}]}],"finish":{"root":"r1"},"bytes":"1400000010002400000000000000000004001800100000000500000000000080000000000000008000000000000010c0000000000000c03f"},{"id":"random/011","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[0,-2147483648,"0"],[-128,-2,"0"],[-43,-1489072046,"-3611457050369711258"]]},{"op":"table","ref":"r2","slots":4,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,1.5,0.0]}]}],"finish":{"root":"r2","identifier":"MONS","sizePrefixed":true},"bytes":"5c000000140000004d4f4e5300000a0014000000100004000a000000000080440000c03f0000000004000000030000000000000000000080000000000000000080000000feffffff0000000000000000d500000052903ea76623226ff286e1cd"},{"id":"random/012","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/013","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int32","values":[-2147483648,2147483647,1,1,-2147483648]},{"op":"table","ref":"r2","slots":6,"fields":[{"slot":1,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","identifier":"1234","sizePrefixed":true},"bytes":"300000001000000031323334080008000000040008000000040000000500000000000080ffffff7f010000000100000000000080"},{"id":"random/014","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int8","values":[-128,1,1]},{"op":"table","ref":"r3","slots":5,"fields":[]},{"op":"table","ref":"r5","slots":6,"fields":[{"slot":0,"kind":"scalar","type":"uint32","value":4294967295,"default":4294967295},{"slot":5,"kind":"scalar","type":"int32","value":-2147483648,"default":2147483647},{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[72,0]}]},{"op":"table","ref":"r6","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":0}]},{"op":"string","ref":"r7","value":"😀😀"},{"op":"table","ref":"r8","slots":5,"fields":[{"slot":0,"kind":"offset","ref":"r7"},{"slot":3,"kind":"scalar","type":"int64","value":"-9223372036854775808","default":"-9223372036854775808"},{"slot":2,"kind":"scalar","type":"uint64","value":"0","default":"0"},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,0,"-2"]}]},{"op":"offsets","ref":"r4","refs":["r5","r6","r8"]},{"op":"table","ref":"r9","slots":8,"fields":[{"slot":5,"kind":"scalar","type":"int8","value":-128,"default":-128},{"slot":4,"kind":"scalar","type":"uint8","value":1,"default":0},{"slot":6,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,2147483647,"0"]},{"slot":2,"kind":"scalar","type":"int64","value":"-9223372036854775808","default":"-793879338900255131"},{"slot":7,"kind":"scalar","type":"uint64","value":"1","default":"18446744073709551615"},{"slot":3,"kind":"offset","ref":"r4"},{"slot":0,"kind":"scalar","type":"float64","value":2.5,"default":123456.789}]},{"op":"table","ref":"r10","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":0}]},{"op":"offsets","ref":"r2","refs":["r3","r9","r10"]},{"op":"string","ref":"r11","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"string","ref":"r12","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"bytes","ref":"r13","value":[219,132,163,230,117,73,35,75,172,11,174,57,44,132,154,99]},{"op":"table","ref":"r14","slots":8,"fields":[{"slot":3,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"},{"slot":5,"kind":"offset","ref":"r11"},{"slot":6,"kind":"scalar","type":"int32","value":1,"default":4},{"slot":7,"kind":"offset","ref":"r12"},{"slot":4,"kind":"offset","ref":"r13"}]}],"finish":{"root":"r14"},"initialSize":1,"bytes":"1c0000000000000014001c000000140000001800040010000c00080014000000180000002800000001000000500000007c0000004401000010000000db84a3e67549234bac0bae392c849a6328000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000028000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000003000000c400000020000000040000004cffffff14003800040000001c001000370000002400140014000000000000000000044000000000280000000100000000000000000000000000008001000000ffffff7f00000000000000000000000103000000540000003c0000000c00000008001c0018000400080000007f00000000000000feffffffffffffff000000000400000008000000f09f9880f09f988000000000e0ffffff10000c0000000000040000000000080010000000480000000000008004000400040000000300000080010100"},{"id":"random/015","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":0,"kind":"scalar","type":"float32","value":-0.5,"default":30000000000.0},{"slot":3,"kind":"scalar","type":"int16","value":-32768,"default":0}]}],"finish":{"root":"r1"},"bytes":"100000000c000c0008000000000006000c00000000000080000000bf"},{"id":"random/016","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/017","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"table","ref":"r2","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-11,1,"1"]}]}],"finish":{"root":"r2"},"bytes":"0c00000008001c000400180008000000f5000000010000000100000000000000000000000400000008000000f09f9880f09f988000000000"},{"id":"random/018","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[-2.25,-0.5,1024.0],[1.5,30000000000.0,-2.25],[0.0,1024.0,30000000000.0]]},{"op":"bytes","ref":"r3","value":[4,140,65,69,132,7]},{"op":"table","ref":"r4","slots":8,"fields":[{"slot":1,"kind":"offset","ref":"r3"},{"slot":0,"kind":"scalar","type":"float64","value":-1e-300,"default":1e+300},{"slot":6,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,2147483647,"9223372036854775807"]},{"slot":3,"kind":"scalar","type":"int32","value":-2147483648,"default":1}]},{"op":"table","ref":"r5","slots":5,"fields":[]},{"op":"string","ref":"r6","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r7","slots":8,"fields":[{"slot":4,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"4"},{"slot":2,"kind":"scalar","type":"float32","value":30000000000.0,"default":30000000000.0},{"slot":1,"kind":"scalar","type":"uint8","value":255,"default":4},{"slot":5,"kind":"scalar","type":"uint8","value":1,"default":255},{"slot":3,"kind":"offset","ref":"r6"}]},{"op":"offsets","ref":"r2","refs":["r4","r5","r7"]},{"op":"table","ref":"r8","slots":8,"fields":[{"slot":5,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r8"},"initialSize":100,"bytes":"180000000000000010000c000000040000000000000008001000000008000000b8000000030000008000000064000000140000001000180000000b00000004000c000a001000000014000000000001ffffffffffffffffff0000000028000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000004000600040000000000120024001800200000000400000000000800120000000000008001000000ffffff7fffffffffffffff7f59f3f8c21f6ea5810400000006000000048c41458407000003000000000010c0000000bf000080440000c03f7684df50000010c000000000000080447684df50"},{"id":"random/019","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD"},"forceDefaults":true,"bytes":"0c000000414243440400040004000000"},{"id":"random/020","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"forceDefaults":true,"bytes":"0c000000313233340400040004000000"},{"id":"random/021","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[76,30671]},{"slot":0,"kind":"scalar","type":"float32","value":-2.25,"default":-2.25}]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"bytes":"1c0000001000000000000a000c000400000008000a000000000010c04c00cf77"},{"id":"random/022","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"initialSize":1,"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/023","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int16","values":[32767,1,32767,32767,3]},{"op":"table","ref":"r2","slots":4,"fields":[{"slot":0,"kind":"scalar","type":"int32","value":-2147483648,"default":-2147483648},{"slot":1,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":3,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"float32","value":0.0,"default":0.0}]}],"finish":{"root":"r2"},"bytes":"100000000c000c0000000b00000004000c000000080000000000000105000000ff7f0100ff7fff7f03000000"},{"id":"random/024","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":6,"fields":[]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":5,"kind":"scalar","type":"int64","value":"1","default":"0"},{"slot":0,"kind":"scalar","type":"int32","value":-1,"default":933303417},{"slot":2,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3","sizePrefixed":true},"bytes":"34000000180000000000000010001400080000000400000000000c001000000014000000ffffffff01000000000000000400040004000000"},{"id":"random/025","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/026","description":"seeded random buffer","ops":[{"op":"table","ref":"r3","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":127,"default":-5}]},{"op":"string","ref":"r4","value":""},{"op":"table","ref":"r5","slots":5,"fields":[{"slot":2,"kind":"offset","ref":"r3"},{"slot":1,"kind":"scalar","type":"int32","value":-4,"default":458575612},{"slot":0,"kind":"scalar","type":"bool","value":false,"default":true},{"slot":4,"kind":"offset","ref":"r4"},{"slot":3,"kind":"scalar","type":"float64","value":0.1,"default":123456.789}]},{"op":"string","ref":"r6","value":"a"},{"op":"table","ref":"r7","slots":7,"fields":[{"slot":3,"kind":"offset","ref":"r5"},{"slot":2,"kind":"scalar","type":"float64","value":-1e-300,"default":-1e-300},{"slot":1,"kind":"offset","ref":"r6"}]}],"finish":{"root":"r7"},"bytes":"14000000000000000c000c0000000400000008000c00000008000000180000000100000061000e002000170018001c00040010000e0000009a9999999999b93f000000001000000000000000fcffffff10000000000000000000060008000700060000000000007f"},{"id":"random/027","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[-0.5,0.0,-2.25],[-2.25,-2.25,-2.25],[30000000000.0,1024.0,0.0]]},{"op":"bytes","ref":"r2","value":[239,70,187,98,57,103,145,190,68,170,244,74,116,15,178]},{"op":"table","ref":"r4","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-2]}]},{"op":"bytes","ref":"r5","value":[243,125,24,76,228,66,188,179,9,13,61,105,116,141]},{"op":"offsets","ref":"r6","refs":[]},{"op":"bytes","ref":"r7","value":[163,157,100,114,228]},{"op":"table","ref":"r8","slots":8,"fields":[{"slot":6,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[0.0,1.5,30000000000.0]},{"slot":2,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,-2147483648,"2"]},{"slot":7,"kind":"offset","ref":"r2"},{"slot":4,"kind":"offset","ref":"r4"},{"slot":1,"kind":"offset","ref":"r5"},{"slot":5,"kind":"offset","ref":"r6"},{"slot":3,"kind":"offset","ref":"r7"}]}],"finish":{"root":"r8","sizePrefixed":true},"forceDefaults":true,"bytes":"c40000001c000000000000001400380018000c0028000400100008002c00140014000000340000003c0000003c00000054000000580000008000000000000080020000000000000058000000000000000000c03f7684df5005000000a39d6472e4000000000000000e000000f37d184ce442bcb3090d3d69748d00000800080000000400080000000000feff0f000000ef46bb62396791be44aaf44a740fb20003000000000000bf00000000000010c0000010c0000010c0000010c07684df500000804400000000"},{"id":"random/028","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/029","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[117,134,225]},{"op":"vector","ref":"r2","type":"float64","values":[1e+300,0.1,2.5,0.0]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,-2.25,30000000000.0]},{"slot":0,"kind":"offset","ref":"r1"},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[2,3]},{"slot":5,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"initialSize":16,"bytes":"180000000000000010001c000c0010000000080000000400100000001800000002000300340000007684df50000010c07684df50040000009c7500883ce4377e9a9999999999b93f00000000000004400000000000000000030000007586e100"},{"id":"random/030","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r1","refs":[]},{"op":"vector","ref":"r2","type":"uint64","values":["0","1"]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":5,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,2147483647,"9223372036854775807"]},{"slot":2,"kind":"scalar","type":"uint8","value":1,"default":1},{"slot":0,"kind":"offset","ref":"r2"},{"slot":4,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,0.0,-0.5]},{"slot":3,"kind":"scalar","type":"uint16","value":0,"default":60821}]}],"finish":{"root":"r3","sizePrefixed":true},"bytes":"5c0000001400000010002c0014002800000006000800180010000000000000000000804400000000000000bf1800000080000000ffffff7fffffffffffffff7f1c00000002000000000000000000000001000000000000000000000000000000"},{"id":"random/031","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"uint8","value":112,"default":255},{"slot":2,"kind":"scalar","type":"uint16","value":65535,"default":1}]}],"finish":{"root":"r1"},"bytes":"1000000000000a0008000700000004000a000000ffff0070"},{"id":"random/032","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"initialSize":100,"bytes":"080000000400040004000000"},{"id":"random/033","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r1","refs":[]},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":6,"kind":"scalar","type":"float32","value":-2.25,"default":-2.25},{"slot":2,"kind":"offset","ref":"r1"},{"slot":5,"kind":"scalar","type":"int32","value":-2147483648,"default":-2147483648}]}],"finish":{"root":"r2"},"bytes":"1000000000000a0008000000000004000a0000000400000000000000"},{"id":"random/034","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"a"},{"op":"table","ref":"r3","slots":2,"fields":[]},{"op":"offsets","ref":"r2","refs":["r3"]},{"op":"bytes","ref":"r4","value":[212,248,212]},{"op":"table","ref":"r5","slots":6,"fields":[{"slot":5,"kind":"offset","ref":"r1"},{"slot":3,"kind":"scalar","type":"uint64","value":"2","default":"0"},{"slot":1,"kind":"scalar","type":"bool","value":true,"default":true},{"slot":0,"kind":"offset","ref":"r2"},{"slot":4,"kind":"offset","ref":"r4"}]}],"finish":{"root":"r5"},"bytes":"1400000010001c000800000000000c000400180010000000180000001c0000000200000000000000000000001c00000003000000d4f8d400010000000800000004000400040000000100000061000000"},{"id":"random/035","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"table","ref":"r2","slots":3,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","sizePrefixed":true},"bytes":"240000000c0000000000060008000400060000000400000008000000f09f9880f09f988000000000"},{"id":"random/036","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/037","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/038","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":3,"kind":"scalar","type":"float32","value":-2.25,"default":0.0},{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,1]},{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,1]}]}],"finish":{"root":"r1"},"bytes":"14000000100010000000000008000c00000004001000000000000100ff000100000010c0"},{"id":"random/039","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[-0.5,-2.25,-0.5],[1.5,1.5,30000000000.0],[-2.25,-2.25,30000000000.0]]},{"op":"bytes","ref":"r2","value":[136,124,8]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"forceDefaults":true,"bytes":"0c00000008000c000400080008000000080000000c00000003000000887c080003000000000000bf000010c0000000bf0000c03f0000c03f7684df50000010c0000010c07684df50"},{"id":"random/040","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[1.5,1.5,0.0],[-0.5,-0.5,30000000000.0],[-2.25,30000000000.0,1024.0],[1024.0,1.5,-2.25]]},{"op":"vector","ref":"r2","type":"int32","values":[0,-2147483648,0,2147483647]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"bytes":"0c00000008000c000400080008000000080000001800000004000000000000000000008000000000ffffff7f040000000000c03f0000c03f00000000000000bf000000bf7684df50000010c07684df5000008044000080440000c03f000010c0"},{"id":"random/041","description":"seeded random buffer","ops":[{"op":"vector","ref":"r2","type":"int32","values":[-1465634326,-2147483648,390819286,-2147483648,1,-908329708]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":0,"kind":"offset","ref":"r2"}]},{"op":"table","ref":"r4","slots":4,"fields":[{"slot":0,"kind":"offset","ref":"r3"},{"slot":2,"kind":"scalar","type":"float32","value":1.5,"default":1024.0},{"slot":3,"kind":"scalar","type":"uint16","value":1,"default":65535}]}],"finish":{"root":"r4"},"bytes":"100000000c0012000c000000080006000c000000000001000000c03f0c0000000000060008000400060000000400000006000000ea31a4a800000080d66d4b17000000800100000014fddbc9"},{"id":"random/042","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[]},{"op":"string","ref":"r2","value":"a"},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":2,"kind":"offset","ref":"r1"},{"slot":5,"kind":"scalar","type":"float64","value":1e+300,"default":-1e-300},{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,1]},{"slot":3,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[4,1,"-3"]},{"slot":1,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"bytes":"180000000000000010002c0000000400280008001c00200010000000280000000400000001000000fdffffffffffffff00000000ff0001009c7500883ce4377e0c000000010000006100000000000000"},{"id":"random/043","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[]},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":3,"kind":"scalar","type":"int16","value":1,"default":-5},{"slot":2,"kind":"scalar","type":"uint16","value":42714,"default":1},{"slot":6,"kind":"offset","ref":"r1"},{"slot":1,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":4,"kind":"scalar","type":"uint16","value":1,"default":1},{"slot":0,"kind":"scalar","type":"float64","value":0.1,"default":123456.789},{"slot":5,"kind":"scalar","type":"float64","value":2.5,"default":123456.789}]}],"finish":{"root":"r2"},"forceDefaults":true,"initialSize":1,"bytes":"1c000000000000000000120020000c0017001c001e001400040018001200000000000000000004409a9999999999b93f0100000108000000daa6010000000000"},{"id":"random/044","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"héllo"},{"op":"table","ref":"r3","slots":1,"fields":[]},{"op":"table","ref":"r5","slots":0,"fields":[]},{"op":"bytes","ref":"r6","value":[37,179,112,86,43,101,123,154,148]},{"op":"string","ref":"r8","value":"héllo"},{"op":"string","ref":"r9","value":"😀😀"},{"op":"table","ref":"r10","slots":8,"fields":[{"slot":1,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"6045071339010855667"},{"slot":6,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,2147483647,"0"]},{"slot":7,"kind":"scalar","type":"float64","value":2.5,"default":1e+300},{"slot":5,"kind":"offset","ref":"r8"},{"slot":3,"kind":"offset","ref":"r9"},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,0,"1"]}]},{"op":"table","ref":"r11","slots":5,"fields":[]},{"op":"table","ref":"r12","slots":3,"fields":[{"slot":2,"kind":"scalar","type":"uint16","value":65535,"default":1},{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[43,-4603]}]},{"op":"offsets","ref":"r7","refs":["r10","r11","r12"]},{"op":"table","ref":"r13","slots":8,"fields":[{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,2]},{"slot":0,"kind":"offset","ref":"r1"},{"slot":3,"kind":"offset","ref":"r3"},{"slot":2,"kind":"scalar","type":"uint8","value":0,"default":5},{"slot":1,"kind":"offset","ref":"r5"},{"slot":5,"kind":"scalar","type":"int64","value":"0","default":"-9223372036854775808"},{"slot":6,"kind":"offset","ref":"r6"},{"slot":7,"kind":"offset","ref":"r7"}]}],"finish":{"root":"r13"},"bytes":"1c0000000000000014002800200014001b001c0024000c00080004001400000024000000bc0000000000000000000000c000000000000000c0000000c000000001000200030000003c000000200000001000000000000a000c00060000000a000a00000000002b0005eeffff78ffffff1400400004003400000014000000180024001c0014000000800000000000000001000000000000002c00000038000000000000000000044001000000ffffff7f0000000000000000ffffffffffffffff0000000008000000f09f9880f09f9880000000000600000068c3a96c6c6f00000900000025b370562b657b9a94000000fcffffff04000400040000000600000068c3a96c6c6f0000"},{"id":"random/045","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[110,121,134,172,105]},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":0,"kind":"scalar","type":"uint8","value":1,"default":0},{"slot":4,"kind":"scalar","type":"uint8","value":19,"default":255},{"slot":3,"kind":"scalar","type":"uint32","value":0,"default":0},{"slot":2,"kind":"scalar","type":"int32","value":2147483647,"default":1},{"slot":7,"kind":"scalar","type":"int32","value":1,"default":-2147483648},{"slot":5,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","identifier":"MONS"},"initialSize":16,"bytes":"1c0000004d4f4e5314001400130000000c0000001200040000000800140000001000000001000000ffffff7f00001301050000006e7986ac69000000"},{"id":"random/046","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"bytes":"0c000000080000000400040004000000"},{"id":"random/047","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r2","slots":3,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"int16","value":0,"default":32767}]}],"finish":{"root":"r2"},"bytes":"1000000000000a000c000800000006000a0000000000000004000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/048","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"string","ref":"r3","value":"héllo"},{"op":"table","ref":"r4","slots":6,"fields":[{"slot":3,"kind":"scalar","type":"bool","value":true,"default":true},{"slot":5,"kind":"offset","ref":"r3"},{"slot":4,"kind":"scalar","type":"int16","value":-17984,"default":-11254}]},{"op":"table","ref":"r5","slots":3,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"offset","ref":"r4"},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[29,1,"-2"]}]}],"finish":{"root":"r5","identifier":"ABCD","sizePrefixed":true},"forceDefaults":true,"initialSize":100,"bytes":"9400000018000000414243440000000000000a00200004001c0018000a0000001d00000001000000feffffffffffffff000000001800000030000000100010000000000000000f0006000800100000000000c0b908000000000000010600000068c3a96c6c6f0000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/049","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/050","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":1,"kind":"scalar","type":"uint64","value":"1","default":"1"},{"slot":0,"kind":"scalar","type":"float32","value":0.0,"default":30000000000.0},{"slot":3,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,-0.5,1024.0]},{"slot":4,"kind":"scalar","type":"int64","value":"8563110158723745480","default":"0"}]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"1c000000313233340000000000000e001c001800000000000c0004000e000000c88644ef5147d676000010c0000000bf0000804400000000"},{"id":"random/051","description":"seeded random buffer","ops":[{"op":"string","ref":"r2","value":"😀😀"},{"op":"table","ref":"r4","slots":7,"fields":[{"slot":6,"kind":"scalar","type":"uint16","value":64756,"default":0},{"slot":5,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,0,"4"]}]},{"op":"offsets","ref":"r3","refs":["r4"]},{"op":"table","ref":"r5","slots":6,"fields":[{"slot":5,"kind":"scalar","type":"int16","value":-32768,"default":-32768},{"slot":2,"kind":"offset","ref":"r2"},{"slot":4,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[0,-1,"6538881519274462406"]},{"slot":3,"kind":"scalar","type":"float32","value":30000000000.0,"default":1024.0},{"slot":0,"kind":"offset","ref":"r3"}]},{"op":"offsets","ref":"r1","refs":["r5"]},{"op":"table","ref":"r6","slots":6,"fields":[{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,0]},{"slot":3,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r6"},"bytes":"100000000c000c0008000000000004000c0000000800000000000000010000001400000000000e00240004000000200008000c000e000000200000007684df5000000000ffffffffc68cb8e818c6be5a000000003c0000000100000018000000000012001c000000000000000000000004001a00120000007f000000000000000400000000000000000000000000f4fc08000000f09f9880f09f988000000000"},{"id":"random/052","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":1,"kind":"scalar","type":"float64","value":-1e-300,"default":2.5}]}],"finish":{"root":"r1"},"bytes":"0c00000008000c00000004000800000059f3f8c21f6ea581"},{"id":"random/053","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[220,207,212,104,225,27,88,118,247,191,254]},{"op":"vector","ref":"r2","type":"int32","values":[5,2147483647,2147483647]},{"op":"bytes","ref":"r3","value":[100,108,21,156,55,21,241,63,17,23,157,159,228,38,30,249,242,170,229,48]},{"op":"table","ref":"r4","slots":8,"fields":[{"slot":6,"kind":"offset","ref":"r1"},{"slot":4,"kind":"offset","ref":"r2"},{"slot":7,"kind":"offset","ref":"r3"},{"slot":1,"kind":"scalar","type":"float32","value":1024.0,"default":-0.5},{"slot":0,"kind":"scalar","type":"float64","value":1e+300,"default":1e+300}]}],"finish":{"root":"r4"},"bytes":"180000001400140000000400000000000c0000001000080014000000000080440c000000200000002c00000014000000646c159c3715f13f11179d9fe4261ef9f2aae5300300000005000000ffffff7fffffff7f0b000000dccfd468e11b5876f7bffe00"},{"id":"random/054","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[4,0]},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-1]}]}],"finish":{"root":"r1"},"bytes":"100000000c000c0000000000080004000c0000000000ffff04000000"},{"id":"random/055","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"initialSize":16,"bytes":"080000000400040004000000"},{"id":"random/056","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[0,0,"5"],[127,0,"1"],[0,0,"1"],[1,0,"-8547371398078408929"]]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":1,"kind":"scalar","type":"float32","value":1.5,"default":-0.5},{"slot":2,"kind":"scalar","type":"int32","value":0,"default":0},{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"initialSize":1,"bytes":"100000000000000008000c000400080008000000080000000000c03f04000000000000000000000005000000000000007f0000000000000001000000000000000000000000000000010000000000000001000000000000001fd733d6ffa26189"},{"id":"random/057","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[]},{"op":"table","ref":"r4","slots":6,"fields":[{"slot":2,"kind":"scalar","type":"int32","value":2147483647,"default":-2147483648}]},{"op":"offsets","ref":"r3","refs":["r4"]},{"op":"table","ref":"r6","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"0"}]},{"op":"table","ref":"r7","slots":8,"fields":[]},{"op":"table","ref":"r8","slots":8,"fields":[]},{"op":"offsets","ref":"r5","refs":["r6","r7","r8"]},{"op":"table","ref":"r9","slots":5,"fields":[{"slot":4,"kind":"scalar","type":"uint16","value":27044,"default":0},{"slot":0,"kind":"offset","ref":"r3"},{"slot":2,"kind":"offset","ref":"r5"}]},{"op":"structs","ref":"r10","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[255,-5],[1,-32768]]},{"op":"table","ref":"r11","slots":8,"fields":[{"slot":2,"kind":"scalar","type":"int16","value":1,"default":1},{"slot":1,"kind":"scalar","type":"uint64","value":"8079638945094630260","default":"0"},{"slot":0,"kind":"offset","ref":"r1"},{"slot":3,"kind":"scalar","type":"uint64","value":"5023101958615304620","default":"0"},{"slot":6,"kind":"offset","ref":"r9"},{"slot":4,"kind":"offset","ref":"r10"},{"slot":5,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,1024.0,30000000000.0]},{"slot":7,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,-32768]}]}],"finish":{"root":"r11"},"bytes":"1c000000000000001400340028002c0000001c00140008001800040014000000ff000080000010c0000080447684df502000000038000000ac89d5299ea4b545000000008800000074fbc613d0a4207002000000ff00fbff0100008000000e00100008000000040000000e000e0000000c0000003c0000000000a4690300000024000000140000000800000004000400040000000400060004000000000006000c00040006000000ffffffffffffff7f010000001000000000000a0008000000000004000a000000ffffff7f00000000"},{"id":"random/058","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"a"},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,-0.5,0.0]},{"slot":3,"kind":"offset","ref":"r1"},{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[13,-32768]}]}],"finish":{"root":"r2"},"bytes":"1400000000000e001800000000000c00080004000e0000000d0000801000000000008044000000bf000000000100000061000000"},{"id":"random/059","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":""},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":2,"kind":"scalar","type":"int16","value":32767,"default":0},{"slot":6,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,1]},{"slot":3,"kind":"scalar","type":"float64","value":123456.789,"default":0.0},{"slot":4,"kind":"scalar","type":"int8","value":1,"default":-26},{"slot":7,"kind":"scalar","type":"uint32","value":2,"default":4294967295},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,1,"-9223372036854775808"]},{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,30000000000.0,0.0]},{"slot":5,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"1c0000000000000014003c00140008003a002c002b000400360024001400000038000000000080447684df5000000000800000000100000000000000000000800200000000000001c976be9f0c24fe400000ff000100ff7f0000000000000000"},{"id":"random/060","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/061","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r2","refs":[]},{"op":"structs","ref":"r3","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[1,0],[0,32767]]},{"op":"vector","ref":"r4","type":"uint16","values":[5,31189,0,65535,65535,65535]},{"op":"table","ref":"r6","slots":6,"fields":[]},{"op":"table","ref":"r7","slots":5,"fields":[{"slot":3,"kind":"scalar","type":"int8","value":-1,"default":127},{"slot":4,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,-0.5,0.0]}]},{"op":"vector","ref":"r8","type":"float64","values":[0.0,2.5]},{"op":"structs","ref":"r9","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[0,32767],[2,-32768]]},{"op":"table","ref":"r10","slots":7,"fields":[{"slot":5,"kind":"scalar","type":"int16","value":0,"default":0},{"slot":6,"kind":"offset","ref":"r8"},{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,1.5,-0.5]},{"slot":1,"kind":"offset","ref":"r9"},{"slot":4,"kind":"scalar","type":"uint16","value":65535,"default":65535},{"slot":3,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,-2147483648,"1"]},{"slot":2,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"9223372036854775807"}]},{"op":"offsets","ref":"r5","refs":["r6","r7","r10"]},{"op":"table","ref":"r11","slots":8,"fields":[{"slot":1,"kind":"scalar","type":"int32","value":-1327754628,"default":-1327754628},{"slot":5,"kind":"offset","ref":"r2"},{"slot":3,"kind":"offset","ref":"r3"},{"slot":2,"kind":"offset","ref":"r4"},{"slot":0,"kind":"offset","ref":"r5"}]},{"op":"table","ref":"r12","slots":4,"fields":[{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,764924856,"-9223372036854775808"]},{"slot":0,"kind":"offset","ref":"r11"}]}],"finish":{"root":"r12"},"bytes":"1000000000000a001c000400000008000a0000002800000001000000b8d3972d000000000000008000000000100014000400000008000c00000010001000000010000000ac000000b8000000c000000003000000980000007c00000018000000000012002c001c0018000000040000000000280012000000010000000000008001000000000000000000000014000000000010c00000c03f000000bf10000000020000000000ff7f0200008002000000000000000000000000000000000004400000000000000e001400000000000000130004000e000000000010c0000000bf00000000000000ff0400040004000000060000000500d5790000ffffffffffff02000000010000000000ff7f00000000"},{"id":"random/062","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":1,"kind":"scalar","type":"int16","value":-32768,"default":32767}]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"0c00000008000800000006000800000000000080"},{"id":"random/063","description":"seeded random buffer","ops":[{"op":"table","ref":"r3","slots":0,"fields":[]},{"op":"bytes","ref":"r4","value":[75]},{"op":"bytes","ref":"r6","value":[]},{"op":"table","ref":"r7","slots":7,"fields":[{"slot":6,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":4,"kind":"offset","ref":"r6"},{"slot":5,"kind":"scalar","type":"uint64","value":"1","default":"18446744073709551615"}]},{"op":"bytes","ref":"r8","value":[126,158,9,167]},{"op":"offsets","ref":"r9","refs":[]},{"op":"table","ref":"r10","slots":8,"fields":[{"slot":4,"kind":"offset","ref":"r3"},{"slot":1,"kind":"scalar","type":"int8","value":1,"default":5},{"slot":0,"kind":"scalar","type":"int8","value":4,"default":-128},{"slot":7,"kind":"offset","ref":"r4"},{"slot":5,"kind":"offset","ref":"r7"},{"slot":3,"kind":"offset","ref":"r8"},{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-32768]},{"slot":6,"kind":"offset","ref":"r9"}]},{"op":"vector","ref":"r11","type":"uint32","values":[0,0,233383629,3,4,4294967295]},{"op":"table","ref":"r13","slots":7,"fields":[{"slot":2,"kind":"scalar","type":"float32","value":30000000000.0,"default":30000000000.0},{"slot":5,"kind":"scalar","type":"int8","value":-96,"default":30}]},{"op":"table","ref":"r14","slots":7,"fields":[{"slot":6,"kind":"scalar","type":"int32","value":-2147483648,"default":-2147483648},{"slot":4,"kind":"offset","ref":"r10"},{"slot":5,"kind":"offset","ref":"r11"},{"slot":3,"kind":"offset","ref":"r13"}]}],"finish":{"root":"r14","identifier":"MONS"},"bytes":"180000004d4f4e531000100000000000000004000c000800100000001c000000200000004c0000001000080000000000000000000000070010000000000000a0060000000000000000000000cd26e90d0300000004000000ffffffff140020001a001b0008000c001c00100004001400140000001c00000000000080180000002c0000003c000000000004014000000000000000040000007e9e09a71000100000000000000000000c0004001000000001000000000000000400000000000000010000004b0000000400040004000000"},{"id":"random/064","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/065","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[{"slot":1,"kind":"scalar","type":"float32","value":1.5,"default":-0.5}]}],"finish":{"root":"r1"},"bytes":"0c0000000800080000000400080000000000c03f"},{"id":"random/066","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/067","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[7,154,249,30,6,87,167,36,112,210,33,83,174,173,101,220,25]},{"op":"table","ref":"r2","slots":6,"fields":[{"slot":2,"kind":"offset","ref":"r1"},{"slot":4,"kind":"scalar","type":"uint8","value":1,"default":3}]}],"finish":{"root":"r2"},"bytes":"1400000000000e000c00000000000800000007000e000000000000010400000011000000079af91e0657a72470d22153aead65dc19000000"},{"id":"random/068","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float32","values":[1024.0,-0.5,-0.5,1024.0]},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"int64","value":"-4567134134327905034","default":"-4567134134327905034"}]}],"finish":{"root":"r2","sizePrefixed":true},"bytes":"280000000c000000080008000000040008000000040000000400000000008044000000bf000000bf00008044"},{"id":"random/069","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"forceDefaults":true,"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/070","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"bytes","ref":"r2","value":[207,73,8,193,195,217,214,2,125,46,136,227,128,150,98,6,197,121,24]},{"op":"table","ref":"r3","slots":5,"fields":[{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,-2147483648,"-9223372036854775808"]},{"slot":3,"kind":"offset","ref":"r1"},{"slot":4,"kind":"scalar","type":"int8","value":1,"default":1},{"slot":1,"kind":"scalar","type":"float64","value":0.1,"default":0.1},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"bytes":"14000000000000000c001c00040000000c0008000c000000180000002c0000007f00000000000080000000000000008013000000cf4908c1c3d9d6027d2e88e380966206c579180008000000f09f9880f09f988000000000"},{"id":"random/071","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"initialSize":100,"bytes":"080000000400040004000000"},{"id":"random/072","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":7,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[0.0,0.0,1024.0]},{"slot":0,"kind":"offset","ref":"r1"},{"slot":6,"kind":"scalar","type":"int8","value":0,"default":-116},{"slot":1,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":5,"kind":"scalar","type":"float64","value":2.5,"default":2.5},{"slot":4,"kind":"scalar","type":"int8","value":-34,"default":1},{"slot":3,"kind":"scalar","type":"int64","value":"1","default":"-9223372036854775808"},{"slot":2,"kind":"scalar","type":"uint64","value":"1","default":"18446744073709551615"}]}],"finish":{"root":"r2"},"initialSize":16,"bytes":"1c0000000000000014002c001c001a0004000c00190000001b00200014000000010000000000000001000000000000000000000000de01001000000000000000000000000000804408000000f09f9880f09f988000000000"},{"id":"random/073","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint8","values":[0,255]},{"op":"vector","ref":"r2","type":"uint16","values":[1,3032,38990]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":4,"kind":"scalar","type":"float32","value":30000000000.0,"default":1.5},{"slot":1,"kind":"scalar","type":"uint8","value":2,"default":0},{"slot":6,"kind":"offset","ref":"r1"},{"slot":0,"kind":"scalar","type":"uint32","value":0,"default":0},{"slot":5,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":7,"kind":"offset","ref":"r2"},{"slot":3,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"0"},{"slot":2,"kind":"scalar","type":"uint32","value":3452364287,"default":0}]}],"finish":{"root":"r3"},"initialSize":1,"bytes":"180000001400240000001f0004000800200000001800140014000000ffe5c6cdffffffffffffffff000000001000000018000000000000027684df50030000000100d80b4e9800000200000000ff0000"},{"id":"random/074","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"vector","ref":"r2","type":"uint64","values":["14158488149308489519","1","0","18446744073709551615","10305294252643763994","18446744073709551615"]},{"op":"string","ref":"r3","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r4","slots":4,"fields":[{"slot":3,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"},{"slot":2,"kind":"offset","ref":"r3"}]}],"finish":{"root":"r4","sizePrefixed":true},"bytes":"94000000100000000c0010000000080004000c000c0000000c0000003800000068000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000060000002f3f1cf8f40d7dc401000000000000000000000000000000ffffffffffffffff1ac7b4e285c2038fffffffffffffffff08000000f09f9880f09f988000000000"},{"id":"random/075","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"initialSize":100,"bytes":"0c000000313233340400040004000000"},{"id":"random/076","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/077","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/078","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"initialSize":1,"bytes":"0c000000080000000400040004000000"},{"id":"random/079","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[{"slot":6,"kind":"scalar","type":"float32","value":0.0,"default":-2.25}]}],"finish":{"root":"r1"},"initialSize":100,"bytes":"1800000000001200080000000000000000000000000004001200000000000000"},{"id":"random/080","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,32767]},{"slot":0,"kind":"scalar","type":"bool","value":false,"default":true}]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"initialSize":1,"bytes":"180000000c00000008000c000700080008000000000000000000ff7f"},{"id":"random/081","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/082","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/083","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":4,"kind":"scalar","type":"uint64","value":"2","default":"1"},{"slot":3,"kind":"scalar","type":"float32","value":1024.0,"default":-0.5},{"slot":0,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"18446744073709551615"}]}],"finish":{"root":"r2"},"initialSize":16,"bytes":"180000000000000000000e001800000014000000040008000e000000000080440200000000000000000000000400000008000000f09f9880f09f988000000000"},{"id":"random/084","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/085","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":1e+300,"default":0.1},{"slot":1,"kind":"scalar","type":"int32","value":-2147483648,"default":0}]}],"finish":{"root":"r1","identifier":"1234"},"initialSize":1,"bytes":"1000000031323334080010000800040008000000000000809c7500883ce4377e"},{"id":"random/086","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[{"slot":1,"kind":"scalar","type":"int16","value":-7072,"default":1}]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"1000000031323334080008000000060008000000000060e4"},{"id":"random/087","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":2.5,"default":2.5}]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/088","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float64","values":[1e+300,123456.789,2.5,0.1]},{"op":"table","ref":"r2","slots":6,"fields":[{"slot":5,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,30000000000.0,1.5]},{"slot":1,"kind":"scalar","type":"uint32","value":3423742006,"default":0},{"slot":2,"kind":"offset","ref":"r1"},{"slot":3,"kind":"scalar","type":"int8","value":1,"default":-128},{"slot":4,"kind":"scalar","type":"int32","value":3,"default":3},{"slot":0,"kind":"scalar","type":"uint32","value":3397338529,"default":3}]}],"finish":{"root":"r2"},"initialSize":100,"bytes":"1400000010002000040010000c000b000000140010000000a1457fca0000000114000000362812cc000080447684df500000c03f040000009c7500883ce4377ec976be9f0c24fe4000000000000004409a9999999999b93f"},{"id":"random/089","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[-2.25,1024.0,1024.0],[-0.5,0.0,30000000000.0],[1.5,1024.0,-0.5]]},{"op":"bytes","ref":"r2","value":[32,115,171,166,232,129,176,154,88,76,94,192,180,201,177,251,89]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":3,"kind":"offset","ref":"r1"},{"slot":5,"kind":"offset","ref":"r2"},{"slot":0,"kind":"scalar","type":"float32","value":30000000000.0,"default":-0.5}]}],"finish":{"root":"r3"},"initialSize":100,"bytes":"14000000100010000400000000000c0000000800100000007684df50080000001c000000110000002073aba6e881b09a584c5ec0b4c9b1fb5900000003000000000010c00000804400008044000000bf000000007684df500000c03f00008044000000bf"},{"id":"random/090","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int64","values":[]},{"op":"table","ref":"r2","slots":4,"fields":[{"slot":3,"kind":"offset","ref":"r1"},{"slot":0,"kind":"scalar","type":"int32","value":2147483647,"default":1}]}],"finish":{"root":"r2"},"bytes":"100000000c000c0004000000000008000c000000ffffff7f0400000000000000"},{"id":"random/091","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":""},{"op":"table","ref":"r2","slots":4,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"0c000000000006000800040006000000040000000000000000000000"},{"id":"random/092","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":0.0,"default":2.5},{"slot":1,"kind":"scalar","type":"uint16","value":65535,"default":65535}]}],"finish":{"root":"r1"},"bytes":"0c000000000006000c000400060000000000000000000000"},{"id":"random/093","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[30000000000.0,1024.0,30000000000.0],[0.0,-2.25,-2.25],[1024.0,0.0,30000000000.0]]},{"op":"bytes","ref":"r2","value":[106,68,173,0,241,103,70]},{"op":"table","ref":"r3","slots":4,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":2,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3","sizePrefixed":true},"bytes":"500000001000000000000a000c000800000004000a0000000800000010000000070000006a44ad00f1674600030000007684df50000080447684df5000000000000010c0000010c000008044000000007684df50"},{"id":"random/094","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"vector","ref":"r2","type":"bool","values":[true]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,0,"0"]},{"slot":4,"kind":"offset","ref":"r1"},{"slot":5,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3","sizePrefixed":true},"bytes":"6c000000180000000000000010001c00000000000c0000000800040010000000180000001c0000007f0000000000000000000000000000000100000001000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/095","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[60,254,187,10,132]},{"op":"bytes","ref":"r2","value":[136,229,241,79,140]},{"op":"table","ref":"r3","slots":4,"fields":[{"slot":3,"kind":"scalar","type":"bool","value":true,"default":true},{"slot":2,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"bytes":"1000000000000a000c000000040008000a00000008000000100000000500000088e5f14f8c000000050000003cfebb0a84000000"},{"id":"random/096","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":1,"kind":"scalar","type":"float32","value":-0.5,"default":1.5}]}],"finish":{"root":"r1"},"bytes":"0c000000080008000000040008000000000000bf"},{"id":"random/097","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint8","values":[0]},{"op":"bytes","ref":"r2","value":[32,10,84,73,172,67,43,68,34,169,201,86,40,65,48,226]},{"op":"string","ref":"r3","value":"héllo"},{"op":"table","ref":"r4","slots":6,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":0.0,"default":0.0},{"slot":3,"kind":"offset","ref":"r1"},{"slot":2,"kind":"offset","ref":"r2"},{"slot":4,"kind":"offset","ref":"r3"},{"slot":5,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,-1792467994,"0"]}]}],"finish":{"root":"r4","identifier":"1234"},"forceDefaults":true,"bytes":"1c000000313233340000000010002c00240000001c002000180004001000000001000000e61b2995000000000000000000000000140000001c0000002c00000000000000000000000600000068c3a96c6c6f000010000000200a5449ac432b4422a9c956284130e20100000000000000"},{"id":"random/098","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":2,"fields":[]},{"op":"table","ref":"r3","slots":5,"fields":[{"slot":4,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,1024.0,1.5]},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"forceDefaults":true,"bytes":"1400000000000e001400040000000000000008000e00000014000000000010c0000080440000c03f0400040004000000"},{"id":"random/099","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":1,"fields":[]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"bytes":"0c000000080008000000040008000000080000000400040004000000"},{"id":"random/100","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"0c000000414243440400040004000000"},{"id":"random/101","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":5,"fields":[{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,-2.25,1024.0]},{"slot":3,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":0,"kind":"scalar","type":"uint16","value":65535,"default":65535}]},{"op":"table","ref":"r4","slots":1,"fields":[]},{"op":"string","ref":"r5","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"bytes","ref":"r6","value":[144,240,34,112,9,247]},{"op":"table","ref":"r7","slots":4,"fields":[{"slot":2,"kind":"scalar","type":"int8","value":127,"default":1},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[70,0]},{"slot":1,"kind":"offset","ref":"r5"},{"slot":0,"kind":"offset","ref":"r6"}]},{"op":"table","ref":"r8","slots":8,"fields":[{"slot":0,"kind":"scalar","type":"bool","value":true,"default":true},{"slot":6,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[4,1,"-4"]}]},{"op":"offsets","ref":"r3","refs":["r4","r7","r8"]},{"op":"table","ref":"r9","slots":7,"fields":[{"slot":2,"kind":"scalar","type":"int32","value":0,"default":0},{"slot":1,"kind":"offset","ref":"r3"},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,32767]},{"slot":4,"kind":"scalar","type":"int64","value":"-3","default":"1"},{"slot":6,"kind":"scalar","type":"uint64","value":"0","default":"18446744073709551615"}]},{"op":"table","ref":"r10","slots":3,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2","r9","r10"]},{"op":"table","ref":"r11","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r11"},"bytes":"0c0000000000060008000400060000000400000003000000e8000000200000000400000038ffffff000012001c0000001800000014000c0000000400120000000000000000000000fdffffffffffffffff00ff7f0400000003000000940000003c000000180000000000120014000000000000000000000000000400120000000400000001000000fcffffffffffffff0c0014000400080013000e000c0000001000000018000000000046000000007f0600000090f0227009f70000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000040006000400000000000a0010000000000004000a0000000000c03f000010c000008044"},{"id":"random/102","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"héllo"},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":6,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[247,-32768]},{"slot":4,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"uint64","value":"0","default":"5"}]}],"finish":{"root":"r2","identifier":"1234"},"bytes":"1c0000003132333400000000100018000000000004000000100014001000000000000000000000000000000008000000f70000800600000068c3a96c6c6f0000"},{"id":"random/103","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":2,"fields":[]},{"op":"table","ref":"r3","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int64","value":"1","default":"1"}]},{"op":"table","ref":"r4","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":11,"default":1}]},{"op":"offsets","ref":"r1","refs":["r2","r3","r4"]},{"op":"table","ref":"r5","slots":2,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r5","identifier":"1234"},"bytes":"1000000031323334000006000800040006000000040000000300000024000000180000000c0000000000060008000700060000000000000bfcffffff0400040004000000"},{"id":"random/104","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/105","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":4,"fields":[{"slot":2,"kind":"scalar","type":"int8","value":3,"default":1},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[2,1,"-1"]},{"slot":0,"kind":"scalar","type":"int8","value":127,"default":-2}]},{"op":"vector","ref":"r3","type":"int64","values":["-9223372036854775808","9223372036854775807","3"]},{"op":"table","ref":"r4","slots":5,"fields":[{"slot":2,"kind":"offset","ref":"r2"},{"slot":3,"kind":"scalar","type":"uint32","value":4294967295,"default":4294967295},{"slot":1,"kind":"offset","ref":"r3"},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,2147483647,"-9043881866141191216"]},{"slot":4,"kind":"scalar","type":"bool","value":false,"default":false}]}],"finish":{"root":"r4","identifier":"MONS"},"bytes":"140000004d4f4e5300000a002000040018001c000a00000001000000ffffff7fd0b30efa5bad7d82000000000800000030000000030000000000000000000080ffffffffffffff7f03000000000000000000000000000a002000070008001f000a0000000000007f0200000001000000ffffffffffffffff0000000000000003"},{"id":"random/106","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[]},{"op":"table","ref":"r4","slots":3,"fields":[{"slot":1,"kind":"scalar","type":"bool","value":false,"default":false}]},{"op":"offsets","ref":"r3","refs":["r4"]},{"op":"table","ref":"r6","slots":1,"fields":[]},{"op":"table","ref":"r7","slots":2,"fields":[{"slot":0,"kind":"offset","ref":"r3"},{"slot":1,"kind":"offset","ref":"r6"}]},{"op":"table","ref":"r8","slots":7,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":1,"kind":"scalar","type":"int64","value":"-1","default":"1"},{"slot":6,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[161,0]},{"slot":4,"kind":"offset","ref":"r7"},{"slot":3,"kind":"scalar","type":"uint16","value":65535,"default":39465}]}],"finish":{"root":"r8","sizePrefixed":true},"bytes":"640000001c00000000000000000012001c001800100000000600080000000c00120000000000ffff1c000000a1000000ffffffffffffffff2c00000008000c0008000400080000000800000008000000f4ffffff0100000008000000040004000400000000000000"},{"id":"random/107","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/108","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":0}]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"0c00000000000600080006000600000000000000"},{"id":"random/109","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"vector","ref":"r2","type":"int16","values":[-11292]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,0]},{"slot":3,"kind":"scalar","type":"uint64","value":"0","default":"0"},{"slot":2,"kind":"scalar","type":"float64","value":-1e-300,"default":2.5},{"slot":0,"kind":"offset","ref":"r1"},{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,-17457]},{"slot":7,"kind":"scalar","type":"int8","value":127,"default":127},{"slot":4,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3","sizePrefixed":true},"bytes":"4c00000014000000100020000c0008001000000004001c00100000001c000000ff00cfbb1c00000059f3f8c21f6ea581000000000000000001000000e4d3000008000000f09f9880f09f988000000000"},{"id":"random/110","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/111","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r1","refs":[]},{"op":"vector","ref":"r2","type":"int64","values":[]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[3,32767]},{"slot":1,"kind":"scalar","type":"int16","value":32767,"default":1},{"slot":3,"kind":"offset","ref":"r1"},{"slot":5,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"initialSize":100,"bytes":"18000000000000001000140000000e0010000800000004001000000010000000140000000000ff7f0300ff7f000000000000000000000000"},{"id":"random/112","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"int16","value":0,"default":11618}]}],"finish":{"root":"r1"},"bytes":"0c00000000000600080006000600000000000000"},{"id":"random/113","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[5,18462]}]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"18000000100000000c00080000000000000004000c00000005001e48"},{"id":"random/114","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[241,57,130,203,165,201,205,213,22,150,215,200,44,236,40,90,160,62,107,91]},{"op":"table","ref":"r2","slots":6,"fields":[{"slot":5,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":4,"kind":"scalar","type":"int8","value":0,"default":127},{"slot":1,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":3,"kind":"scalar","type":"int8","value":-5,"default":-5},{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"1400000000000e000c0004000000000000000b000e000000080000000000000014000000f13982cba5c9cdd51696d7c82cec285aa03e6b5b"},{"id":"random/115","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/116","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,30000000000.0,1024.0]},{"slot":3,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"1"},{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,1.5,1.5]},{"slot":2,"kind":"scalar","type":"int64","value":"1","default":"1"}]}],"finish":{"root":"r1"},"bytes":"100000000c00280004001c00000010000c000000000080440000c03f0000c03fffffffffffffffff00000000000080447684df5000008044"},{"id":"random/117","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":3,"kind":"scalar","type":"int8","value":-128,"default":-12}]}],"finish":{"root":"r1"},"bytes":"100000000c00080000000000000007000c00000000000080"},{"id":"random/118","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/119","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":4,"kind":"scalar","type":"int64","value":"504813266877027642","default":"7068633031628675414"},{"slot":3,"kind":"scalar","type":"int64","value":"1","default":"-1"},{"slot":1,"kind":"scalar","type":"float64","value":0.1,"default":-1e-300},{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,-2147483648,"9223372036854775807"]}]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"44000000180000000000000000000e002c000000140004001c0024000e0000008000000000000080ffffffffffffff7f9a9999999999b93f01000000000000003a151cdafd740107"},{"id":"random/120","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-24,1805052154,"-9223372036854775808"]}]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"240000001000000000000000080014000000040008000000e8000000fae8966b0000000000000080"},{"id":"random/121","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[253,247,39,15,133]},{"op":"structs","ref":"r2","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[1024.0,30000000000.0,1024.0],[-2.25,1.5,-2.25]]},{"op":"bytes","ref":"r3","value":[99,138,202,136,10]},{"op":"table","ref":"r4","slots":7,"fields":[{"slot":3,"kind":"scalar","type":"int16","value":32767,"default":-32768},{"slot":0,"kind":"offset","ref":"r1"},{"slot":6,"kind":"offset","ref":"r2"},{"slot":5,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":2,"kind":"scalar","type":"float64","value":2.5,"default":0.1},{"slot":1,"kind":"offset","ref":"r3"}]}],"finish":{"root":"r4"},"bytes":"18000000000012001c001400040008001a000000000010001200000018000000000000000000044018000000300000000000ff7f05000000638aca880a00000002000000000080447684df5000008044000010c00000c03f000010c005000000fdf7270f85000000"},{"id":"random/122","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint16","values":[4,1,65535,65535,4,24399]},{"op":"string","ref":"r3","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"string","ref":"r4","value":"a"},{"op":"table","ref":"r5","slots":5,"fields":[{"slot":2,"kind":"scalar","type":"uint16","value":0,"default":30221},{"slot":0,"kind":"offset","ref":"r3"},{"slot":1,"kind":"offset","ref":"r4"},{"slot":4,"kind":"scalar","type":"uint32","value":1,"default":1}]},{"op":"vector","ref":"r6","type":"bool","values":[true,true,false,false,false,false]},{"op":"table","ref":"r7","slots":8,"fields":[{"slot":6,"kind":"scalar","type":"uint16","value":65535,"default":1},{"slot":7,"kind":"offset","ref":"r1"},{"slot":4,"kind":"offset","ref":"r5"},{"slot":5,"kind":"scalar","type":"int8","value":0,"default":1},{"slot":3,"kind":"scalar","type":"int8","value":1,"default":0},{"slot":2,"kind":"scalar","type":"uint16","value":53788,"default":0},{"slot":1,"kind":"offset","ref":"r6"}]}],"finish":{"root":"r7","identifier":"MONS"},"bytes":"1c0000004d4f4e53140018000000040008000a000c000b001600100014000000140000001cd2010020000000640000000000ffff060000000101000000000a001000080004000e000a0000000c000000100000000000000001000000610000002800000078787878787878787878787878787878787878787878787878787878787878787878787878787878000000000600000004000100ffffffff04004f5f"},{"id":"random/123","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/124","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r1","refs":[]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":1,"kind":"scalar","type":"int64","value":"-9223372036854775808","default":"5"},{"slot":0,"kind":"offset","ref":"r1"},{"slot":4,"kind":"scalar","type":"uint16","value":0,"default":1}]}],"finish":{"root":"r2"},"bytes":"1400000000000e00180008000c000000000006000e000000000000001000000000000000000000800000000000000000"},{"id":"random/125","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/126","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"bool","value":true,"default":true},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,2147483647,"1"]}]}],"finish":{"root":"r1","identifier":"ABCD"},"forceDefaults":true,"bytes":"14000000414243440000000008001c001b0004000800000080000000ffffff7f01000000000000000000000000000001"},{"id":"random/127","description":"seeded random buffer","ops":[{"op":"table","ref":"r3","slots":1,"fields":[]},{"op":"string","ref":"r4","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"structs","ref":"r5","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[0,0]]},{"op":"table","ref":"r6","slots":8,"fields":[{"slot":5,"kind":"offset","ref":"r3"},{"slot":2,"kind":"offset","ref":"r4"},{"slot":7,"kind":"scalar","type":"uint8","value":1,"default":0},{"slot":6,"kind":"scalar","type":"int32","value":2147483647,"default":2147483647},{"slot":3,"kind":"offset","ref":"r5"},{"slot":4,"kind":"scalar","type":"float64","value":123456.789,"default":123456.789},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[0,-2147483648,"1"]}]},{"op":"vector","ref":"r7","type":"int32","values":[1,0,-2147483648,0]},{"op":"bytes","ref":"r8","value":[]},{"op":"table","ref":"r9","slots":4,"fields":[{"slot":3,"kind":"scalar","type":"int16","value":30961,"default":-32768},{"slot":0,"kind":"offset","ref":"r6"},{"slot":2,"kind":"offset","ref":"r7"},{"slot":1,"kind":"offset","ref":"r8"}]}],"finish":{"root":"r9"},"forceDefaults":true,"bytes":"14000000000000000c0014000c000400080012000c0000001000000010000000340000000000f17800000000040000000100000000000000000000800000000014003400000004002c0020001400300024002b001400000000000000000000800100000000000000c976be9f0c24fe400000000014000000ffffff7f00000001100000004000000001000000000000002800000078787878787878787878787878787878787878787878787878787878787878787878787878787878000000000400040004000000"},{"id":"random/128","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[{"slot":3,"kind":"scalar","type":"int8","value":127,"default":1}]}],"finish":{"root":"r1"},"bytes":"100000000c00080000000000000007000c0000000000007f"},{"id":"random/129","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":2,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2"]},{"op":"string","ref":"r3","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r4","slots":5,"fields":[{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-32768]},{"slot":0,"kind":"offset","ref":"r1"},{"slot":3,"kind":"offset","ref":"r3"}]}],"finish":{"root":"r4","identifier":"1234"},"bytes":"180000003132333400000e00100008000000000004000c000e0000000c000000380000000000008028000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000001000000080000000400040004000000"},{"id":"random/130","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[4,-32768]},{"slot":4,"kind":"scalar","type":"int8","value":0,"default":-1},{"slot":0,"kind":"scalar","type":"uint8","value":1,"default":0}]}],"finish":{"root":"r1"},"bytes":"1400000000000e000c00060008000000000007000e0000000000010004000080"},{"id":"random/131","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[127,-2147483648,"9223372036854775807"]]},{"op":"structs","ref":"r2","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[0,0],[185,-9117],[174,-1]]},{"op":"structs","ref":"r3","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[]},{"op":"string","ref":"r4","value":"héllo"},{"op":"table","ref":"r5","slots":5,"fields":[{"slot":1,"kind":"scalar","type":"uint8","value":0,"default":225},{"slot":2,"kind":"offset","ref":"r1"},{"slot":4,"kind":"offset","ref":"r2"},{"slot":0,"kind":"offset","ref":"r3"},{"slot":3,"kind":"offset","ref":"r4"}]}],"finish":{"root":"r5"},"bytes":"180000000000000000000e00180008001700100004000c000e000000140000001c000000200000002c000000000000000600000068c3a96c6c6f000000000000000000000300000000000000b90063dcae00ffff010000007f00000000000080ffffffffffffff7f"},{"id":"random/132","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/133","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,0,"1"]}]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"140000004142434400000a0014000000000004000a0000007f000000000000000100000000000000"},{"id":"random/134","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"initialSize":100,"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/135","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/136","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-1]},{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":0}]}],"finish":{"root":"r1"},"bytes":"0c0000000800080000000400080000000000ffff"},{"id":"random/137","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/138","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[228,166,174,251,239,169,140,203,91,11,100,242]},{"op":"table","ref":"r3","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":0,"default":-128}]},{"op":"table","ref":"r5","slots":2,"fields":[]},{"op":"table","ref":"r6","slots":5,"fields":[]},{"op":"offsets","ref":"r4","refs":["r5","r6"]},{"op":"vector","ref":"r7","type":"uint32","values":[0,1446668982,1,5,0]},{"op":"vector","ref":"r8","type":"uint64","values":["1","18132632241393339564","1","0"]},{"op":"table","ref":"r9","slots":8,"fields":[{"slot":4,"kind":"scalar","type":"float32","value":-0.5,"default":30000000000.0},{"slot":7,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r3"},{"slot":2,"kind":"offset","ref":"r4"},{"slot":6,"kind":"offset","ref":"r7"},{"slot":1,"kind":"offset","ref":"r8"},{"slot":3,"kind":"scalar","type":"int16","value":-32768,"default":-32768}]}],"finish":{"root":"r9"},"bytes":"1800000014001c00100004000c000000180000000800140014000000180000003c000000500000007000000074000000000000bf040000000100000000000000ac8c0be7f30ca4fb01000000000000000000000000000000000000000500000000000000b66a3a5601000000050000000000000002000000140000000800000004000400040000000400060004000000000006000800070006000000000000000c000000e4a6aefbefa98ccb5b0b64f2"},{"id":"random/139","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,1.5,1.5]}]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"1000000000000a0010000000000004000a0000007684df500000c03f0000c03f"},{"id":"random/140","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"initialSize":100,"bytes":"080000000400040004000000"},{"id":"random/141","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r2","value":[152,58,140,226,89,199,218,210,220,110,21,53,49,247,58,175,119,176,182,47]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,1]},{"slot":1,"kind":"scalar","type":"int16","value":1,"default":32767},{"slot":2,"kind":"scalar","type":"float64","value":0.1,"default":1e+300},{"slot":0,"kind":"scalar","type":"uint64","value":"15285301357472413677","default":"0"},{"slot":4,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,-2.25,1.5]},{"slot":3,"kind":"offset","ref":"r2"}]},{"op":"string","ref":"r4","value":"a"},{"op":"string","ref":"r5","value":"😀😀"},{"op":"table","ref":"r6","slots":4,"fields":[{"slot":3,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-0.5,-0.5,-0.5]},{"slot":1,"kind":"offset","ref":"r3"},{"slot":0,"kind":"offset","ref":"r4"},{"slot":2,"kind":"offset","ref":"r5"}]}],"finish":{"root":"r6"},"bytes":"100000000c001c0008000c00040010000c000000180000002400000038000000000000bf000000bf000000bf08000000f09f9880f09f988000000000010000006100000010002c00140026001c0004000800280010000000280000000000c03f000010c00000c03fed77f080994c20d49a9999999999b93f000001000000010014000000983a8ce259c7dad2dc6e153531f73aaf77b0b62f"},{"id":"random/142","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"0c000000414243440400040004000000"},{"id":"random/143","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/144","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[247,45,31]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,-2147483648,"0"]},{"slot":2,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,30000000000.0,0.0]}]}],"finish":{"root":"r2"},"bytes":"140000000000000000000a0024000400140010000a0000007684df507684df5000000000140000000100000000000080000000000000000003000000f72d1f00"},{"id":"random/145","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":8,"fields":[{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,0]}]},{"op":"offsets","ref":"r1","refs":["r2"]},{"op":"table","ref":"r3","slots":4,"fields":[{"slot":2,"kind":"scalar","type":"uint8","value":2,"default":0},{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[0.0,30000000000.0,-2.25]},{"slot":1,"kind":"offset","ref":"r1"},{"slot":3,"kind":"scalar","type":"bool","value":false,"default":false}]}],"finish":{"root":"r3"},"initialSize":16,"bytes":"1000000000000a0018000800040017000a00000014000000000000007684df50000010c00000000201000000140000001000080000000000000000000000040010000000ff000000"},{"id":"random/146","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/147","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[55,154,180,53,6,221,117]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":1,"kind":"scalar","type":"int32","value":2147483647,"default":-628324057},{"slot":4,"kind":"scalar","type":"uint8","value":2,"default":0},{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[78,-2]},{"slot":3,"kind":"scalar","type":"int64","value":"0","default":"9223372036854775807"}]}],"finish":{"root":"r2"},"bytes":"1400000000000e0020001c0018001200040017000e00000000000000000000000000000000004e00feff0002ffffff7f0400000007000000379ab43506dd7500"},{"id":"random/148","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[92,-3,"-9223372036854775808"],[1,-2147483648,"0"],[0,-132643231,"0"]]},{"op":"vector","ref":"r2","type":"uint16","values":[0,5,65535]},{"op":"table","ref":"r3","slots":4,"fields":[{"slot":3,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,1.5,-2.25]},{"slot":1,"kind":"offset","ref":"r2"},{"slot":2,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"14453407541935986082"}]}],"finish":{"root":"r3"},"bytes":"14000000000000000c00240014001000040020000c000000ffffffffffffffff00000000140000000000c03f0000c03f000010c0100000000300000000000500ffff0000030000005c000000fdffffff00000000000000800100000000000080000000000000000000000000610618f80000000000000000"},{"id":"random/149","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":3,"kind":"scalar","type":"uint32","value":1,"default":1941985431}]}],"finish":{"root":"r1"},"bytes":"100000000c00080000000000000004000c00000001000000"},{"id":"random/150","description":"seeded random buffer","ops":[{"op":"table","ref":"r3","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"uint32","value":2058575980,"default":0}]},{"op":"table","ref":"r4","slots":5,"fields":[{"slot":1,"kind":"scalar","type":"bool","value":false,"default":true},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,0,"-5"]},{"slot":3,"kind":"offset","ref":"r3"},{"slot":2,"kind":"scalar","type":"float64","value":123456.789,"default":0.1}]},{"op":"table","ref":"r5","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"float32","value":-0.5,"default":1.5},{"slot":2,"kind":"scalar","type":"int32","value":0,"default":0}]},{"op":"offsets","ref":"r1","refs":["r4","r5"]},{"op":"bytes","ref":"r6","value":[228,160,91,132,93,157,38,221,40,238,156,86,94,205,166,207,143]},{"op":"table","ref":"r7","slots":7,"fields":[{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-2]},{"slot":3,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r6"},{"slot":1,"kind":"scalar","type":"int16","value":-32768,"default":-32768}]}],"finish":{"root":"r7"},"bytes":"1400000010001000040000000000080000000c00100000000c000000200000000000feff11000000e4a05b845d9d26dd28ee9c565ecda6cf8f000000020000001c00000004000000c6ffffff000000bf0c00260014002500040010000c000000c976be9f0c24fe40000000001c0000007f00000000000000fbffffffffffffff0000060008000400060000006c60b37a"},{"id":"random/151","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":48,"default":-128},{"slot":5,"kind":"scalar","type":"uint16","value":59500,"default":0}]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"1c0000001400000010000800070000000000000000000400100000006ce80030"},{"id":"random/152","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":4,"fields":[]},{"op":"table","ref":"r4","slots":5,"fields":[{"slot":2,"kind":"scalar","type":"int16","value":32767,"default":-32768},{"slot":0,"kind":"scalar","type":"float64","value":-1e-300,"default":0.0}]},{"op":"table","ref":"r5","slots":8,"fields":[{"slot":4,"kind":"offset","ref":"r2"},{"slot":1,"kind":"offset","ref":"r4"}]}],"finish":{"root":"r5","sizePrefixed":true},"bytes":"4c000000180000000000000000000e000e00000004000000000008000e000000140000002800000000000a0014000400000012000a00000059f3f8c21f6ea581000000000000ff7f0400040004000000"},{"id":"random/153","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/154","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/155","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/156","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,1,"2884219402163209332"]}]}],"finish":{"root":"r1","identifier":"1234"},"forceDefaults":true,"bytes":"140000003132333400000000080014000000040008000000010000000100000074443ad843ce0628"},{"id":"random/157","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/158","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":4,"kind":"scalar","type":"float32","value":1.5,"default":1.5}]}],"finish":{"root":"r1"},"initialSize":100,"bytes":"080000000400040004000000"},{"id":"random/159","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float64","values":[]},{"op":"table","ref":"r2","slots":4,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,16800]}]}],"finish":{"root":"r2"},"bytes":"100000000000000008000c0004000800080000000100a0410400000000000000"},{"id":"random/160","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"vector","ref":"r2","type":"int8","values":[-128]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3","identifier":"1234"},"bytes":"100000003132333408000c000400080008000000080000000c0000000100000080000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/161","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"2"}]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"bytes":"1c0000001000000000000000000006000c00040006000000ffffffffffffffff"},{"id":"random/162","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/163","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/164","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":8,"fields":[{"slot":2,"kind":"scalar","type":"uint32","value":5,"default":0},{"slot":7,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,1,"4"]},{"slot":0,"kind":"scalar","type":"int32","value":-2147483648,"default":-2147483648},{"slot":5,"kind":"scalar","type":"int32","value":-5,"default":-5}]},{"op":"table","ref":"r3","slots":3,"fields":[{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,-0.5,-2.25]}]},{"op":"offsets","ref":"r1","refs":["r2","r3"]},{"op":"table","ref":"r4","slots":6,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":4,"kind":"scalar","type":"uint32","value":0,"default":1},{"slot":2,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":1,"kind":"scalar","type":"uint8","value":3,"default":5},{"slot":3,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,0.0,-0.5]},{"slot":5,"kind":"scalar","type":"float64","value":2.5,"default":2.5}]}],"finish":{"root":"r4","sizePrefixed":true},"bytes":"8c000000180000000000000000000e001c00180013000000040014000e0000000000c03f00000000000000bf00000003000000000400000002000000380000001000000000000a0010000000000004000a0000007684df50000000bf000010c014001c000000000018000000000000000000040014000000010000000100000004000000000000000000000005000000"},{"id":"random/165","description":"seeded random buffer","ops":[{"op":"table","ref":"r3","slots":0,"fields":[]},{"op":"table","ref":"r4","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":0.1,"default":0.1},{"slot":1,"kind":"offset","ref":"r3"}]},{"op":"bytes","ref":"r5","value":[105,164,93,234,171,61,247,98,230,234,188,231,49,194,166,176,63,53]},{"op":"table","ref":"r6","slots":3,"fields":[{"slot":2,"kind":"offset","ref":"r4"},{"slot":0,"kind":"offset","ref":"r5"}]}],"finish":{"root":"r6"},"initialSize":100,"bytes":"1000000000000a000c000400000008000a00000008000000240000001200000069a45deaab3df762e6eabce731c2a6b03f350000080008000000040008000000080000000400040004000000"},{"id":"random/166","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":1,"kind":"scalar","type":"int32","value":1,"default":-2147483648}]}],"finish":{"root":"r1"},"bytes":"0c00000008000800000004000800000001000000"},{"id":"random/167","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[{"slot":1,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"9223372036854775807"}]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"0c000000414243440400040004000000"},{"id":"random/168","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":1,"fields":[]},{"op":"table","ref":"r3","slots":5,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[2,-16786]},{"slot":4,"kind":"scalar","type":"int16","value":32767,"default":32767},{"slot":0,"kind":"scalar","type":"uint16","value":65535,"default":1},{"slot":3,"kind":"offset","ref":"r2"},{"slot":2,"kind":"scalar","type":"uint32","value":4,"default":4114774665}]}],"finish":{"root":"r3","identifier":"MONS"},"bytes":"140000004d4f4e530c0014000e001000040008000c00000004000000100000000000ffff02006ebe0400040004000000"},{"id":"random/169","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/170","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r1","refs":[]},{"op":"table","ref":"r2","slots":3,"fields":[{"slot":1,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","identifier":"1234"},"bytes":"10000000313233340800080000000400080000000400000000000000"},{"id":"random/171","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[{"slot":5,"kind":"scalar","type":"int8","value":1,"default":41},{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-0.5,30000000000.0,-0.5]},{"slot":7,"kind":"scalar","type":"int64","value":"4","default":"9223372036854775807"},{"slot":1,"kind":"scalar","type":"int16","value":1,"default":2},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,1]},{"slot":6,"kind":"scalar","type":"uint64","value":"0","default":"0"}]}],"finish":{"root":"r1"},"bytes":"1c000000000000001400240000000a00140006000000230000000c001400000000000000010001000400000000000000000000bf7684df50000000bf00000001"},{"id":"random/172","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":""},{"op":"string","ref":"r2","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r3","slots":7,"fields":[{"slot":1,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":2,"kind":"scalar","type":"float64","value":1e+300,"default":-1e-300},{"slot":6,"kind":"scalar","type":"int16","value":-31993,"default":1},{"slot":5,"kind":"offset","ref":"r1"},{"slot":3,"kind":"offset","ref":"r2"},{"slot":4,"kind":"scalar","type":"uint8","value":112,"default":255}]}],"finish":{"root":"r3","identifier":"1234"},"initialSize":1,"bytes":"1c00000031323334000012002400000023001400080007000c00120012000000000000701c00000048000000000007839c7500883ce4377e00000000000000012800000078787878787878787878787878787878787878787878787878787878787878787878787878787878000000000000000000000000"},{"id":"random/173","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":4,"kind":"scalar","type":"uint16","value":1,"default":0}]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"180000003132333400000e000800000000000000000006000e00000000000100"},{"id":"random/174","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[{"slot":1,"kind":"scalar","type":"int8","value":-128,"default":-128}]}],"finish":{"root":"r1"},"initialSize":100,"bytes":"080000000400040004000000"},{"id":"random/175","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD","sizePrefixed":true},"bytes":"100000000c000000414243440400040004000000"},{"id":"random/176","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":6,"fields":[]},{"op":"table","ref":"r3","slots":0,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2","r3"]},{"op":"table","ref":"r4","slots":3,"fields":[{"slot":2,"kind":"scalar","type":"float32","value":-0.5,"default":-0.5},{"slot":1,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r4"},"bytes":"0c00000008000800000004000800000004000000020000001000000004000000fcffffff0400040004000000"},{"id":"random/177","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"table","ref":"r2","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","identifier":"MONS","sizePrefixed":true},"forceDefaults":true,"bytes":"28000000100000004d4f4e530000060008000400060000000400000008000000f09f9880f09f988000000000"},{"id":"random/178","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int16","values":[0]},{"op":"table","ref":"r2","slots":4,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"forceDefaults":true,"initialSize":100,"bytes":"0c000000000006000800040006000000040000000100000000000000"},{"id":"random/179","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":""},{"op":"table","ref":"r2","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","sizePrefixed":true},"forceDefaults":true,"bytes":"1c0000000c000000000006000800040006000000040000000000000000000000"},{"id":"random/180","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":0,"kind":"scalar","type":"uint8","value":0,"default":1},{"slot":1,"kind":"scalar","type":"int32","value":2147483647,"default":5},{"slot":3,"kind":"scalar","type":"bool","value":false,"default":true}]}],"finish":{"root":"r1"},"initialSize":16,"bytes":"100000000c0010000f000800000007000c00000000000000ffffff7f00000000"},{"id":"random/181","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":3,"fields":[{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-32768]},{"slot":2,"kind":"scalar","type":"uint64","value":"2","default":"18446744073709551615"}]},{"op":"offsets","ref":"r1","refs":["r2"]},{"op":"table","ref":"r3","slots":4,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"uint32","value":3712163936,"default":1},{"slot":3,"kind":"scalar","type":"uint64","value":"0","default":"0"}]}],"finish":{"root":"r3","sizePrefixed":true},"bytes":"440000001000000000000a000c000800000004000a000000602043dd04000000010000001000000000000a0014001000000004000a00000002000000000000000000000000000080"},{"id":"random/182","description":"seeded random buffer","ops":[{"op":"string","ref":"r2","value":"😀😀"},{"op":"table","ref":"r3","slots":3,"fields":[{"slot":1,"kind":"offset","ref":"r2"}]},{"op":"offsets","ref":"r1","refs":["r3"]},{"op":"table","ref":"r4","slots":5,"fields":[{"slot":4,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r4","identifier":"MONS","sizePrefixed":true},"bytes":"48000000180000004d4f4e5300000e000800000000000000000004000e00000004000000010000000c0000000800080000000400080000000400000008000000f09f9880f09f988000000000"},{"id":"random/183","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":1,"default":1}]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/184","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":4,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","identifier":"1234"},"bytes":"180000003132333400000e000800000000000000000004000e00000004000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/185","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/186","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":3,"fields":[{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,0.0,1.5]}]},{"op":"bytes","ref":"r3","value":[3,207,182,6,239,6,200,22,221,7,48,142,38,78,143,6,23]},{"op":"table","ref":"r4","slots":4,"fields":[{"slot":3,"kind":"scalar","type":"uint8","value":4,"default":245},{"slot":1,"kind":"offset","ref":"r3"},{"slot":2,"kind":"scalar","type":"uint64","value":"0","default":"0"}]},{"op":"offsets","ref":"r1","refs":["r2","r4"]},{"op":"table","ref":"r5","slots":6,"fields":[{"slot":4,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r5","sizePrefixed":true},"bytes":"700000001400000000000e000800000000000000000004000e000000040000000200000040000000100000000c000c000000040000000b000c00000008000000000000041100000003cfb606ef06c816dd07308e264e8f0617000a0010000000000004000a0000000000c03f000000000000c03f"},{"id":"random/187","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":3,"kind":"scalar","type":"int8","value":81,"default":1},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,-1744766744,"-2212841975032665067"]},{"slot":1,"kind":"scalar","type":"uint16","value":17247,"default":0}]}],"finish":{"root":"r1"},"forceDefaults":true,"initialSize":100,"bytes":"100000000c0020000800060000001f000c00000000005f4380000000e8f8009815ac1aa6f2674ae10000000000000051"},{"id":"random/188","description":"seeded random buffer","ops":[{"op":"table","ref":"r3","slots":7,"fields":[]},{"op":"bytes","ref":"r4","value":[137,29,73,73,101,172,180,27]},{"op":"table","ref":"r5","slots":2,"fields":[{"slot":0,"kind":"offset","ref":"r3"},{"slot":1,"kind":"offset","ref":"r4"}]},{"op":"table","ref":"r6","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r5"}]}],"finish":{"root":"r6","identifier":"MONS"},"bytes":"100000004d4f4e530000060008000400060000000c00000008000c000800040008000000080000001400000008000000891d494965acb41b0400040004000000"},{"id":"random/189","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int16","value":2,"default":2}]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/190","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"1234","sizePrefixed":true},"bytes":"100000000c000000313233340400040004000000"},{"id":"random/191","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/192","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":5,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2"]},{"op":"table","ref":"r3","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r3","sizePrefixed":true},"forceDefaults":true,"bytes":"240000000c0000000000060008000400060000000400000001000000080000000400040004000000"},{"id":"random/193","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[62,-32768]},{"slot":0,"kind":"scalar","type":"uint32","value":1409082684,"default":1},{"slot":5,"kind":"offset","ref":"r1"},{"slot":6,"kind":"scalar","type":"float32","value":-0.5,"default":-2.25}]}],"finish":{"root":"r2"},"forceDefaults":true,"initialSize":100,"bytes":"180000000000120014000c0000000000000010000800040012000000000000bf0c0000003ce5fc533e000080280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/194","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/195","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/196","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint64","values":[]},{"op":"structs","ref":"r3","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[255,1],[0,5261],[163,10487],[1,1]]},{"op":"table","ref":"r5","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,4]}]},{"op":"bytes","ref":"r6","value":[125,140,108,172,173,28,152,98]},{"op":"table","ref":"r7","slots":8,"fields":[{"slot":1,"kind":"offset","ref":"r3"},{"slot":5,"kind":"scalar","type":"uint16","value":0,"default":0},{"slot":0,"kind":"scalar","type":"int32","value":-2147483648,"default":-2147483648},{"slot":4,"kind":"scalar","type":"float32","value":-0.5,"default":1024.0},{"slot":6,"kind":"offset","ref":"r5"},{"slot":3,"kind":"offset","ref":"r6"},{"slot":7,"kind":"scalar","type":"int8","value":121,"default":1}]},{"op":"offsets","ref":"r2","refs":["r7"]},{"op":"table","ref":"r8","slots":7,"fields":[{"slot":4,"kind":"offset","ref":"r1"},{"slot":2,"kind":"offset","ref":"r2"},{"slot":0,"kind":"scalar","type":"int32","value":2147483647,"default":2147483647}]}],"finish":{"root":"r8","identifier":"MONS","sizePrefixed":true},"initialSize":1,"bytes":"8c000000180000004d4f4e5300000e000c00000000000400000008000e00000008000000680000000100000018000000140018000000140000000800100000000c00070014000000000000791000000020000000000000bf20000000080000007d8c6cacad1c98620800080000000400080000000100040004000000ff00010000008d14a300f7280100010000000000"},{"id":"random/197","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float64","values":[0.1,0.1]},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":64178},{"slot":7,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[116,1]},{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,-2.25,1.5]},{"slot":4,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,1024.0,-2.25]},{"slot":6,"kind":"scalar","type":"float64","value":1e+300,"default":123456.789},{"slot":3,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"180000001400340032000000200004001400000008002e0014000000300000009c7500883ce4377e00000000000010c000008044000010c0000010c0000010c00000c03f0000740001000000020000009a9999999999b93f9a9999999999b93f"},{"id":"random/198","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/199","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/200","description":"seeded random buffer","ops":[{"op":"string","ref":"r2","value":"héllo"},{"op":"vector","ref":"r3","type":"int8","values":[1,2,0,4,0]},{"op":"string","ref":"r4","value":"😀😀"},{"op":"table","ref":"r6","slots":0,"fields":[]},{"op":"table","ref":"r8","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int16","value":0,"default":0}]},{"op":"offsets","ref":"r7","refs":["r8"]},{"op":"table","ref":"r9","slots":8,"fields":[{"slot":2,"kind":"offset","ref":"r2"},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,32767]},{"slot":1,"kind":"offset","ref":"r3"},{"slot":4,"kind":"offset","ref":"r4"},{"slot":7,"kind":"offset","ref":"r6"},{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":1},{"slot":5,"kind":"offset","ref":"r7"}]},{"op":"table","ref":"r10","slots":5,"fields":[{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,3,"-3500227939524854769"]},{"slot":3,"kind":"scalar","type":"float32","value":0.0,"default":0.0},{"slot":1,"kind":"offset","ref":"r9"}]}],"finish":{"root":"r10"},"bytes":"1000000000000a0018000000040008000a0000002800000001000000030000000f3cb9e73bb16ccf140020000a0014001c0018001000040000000c00140000001c000000000000002400000024000000300000000000ff7f340000000100000004000000fcffffff040004000400000008000000f09f9880f09f9880000000000500000001020004000000000600000068c3a96c6c6f0000"},{"id":"random/201","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD","sizePrefixed":true},"initialSize":16,"bytes":"100000000c000000414243440400040004000000"},{"id":"random/202","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/203","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint64","values":[]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[213,-4]}]}],"finish":{"root":"r2","sizePrefixed":true},"forceDefaults":true,"bytes":"1c0000000c00000008000c000800040008000000d500fcff0400000000000000"},{"id":"random/204","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"vector","ref":"r2","type":"int16","values":[0,0]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[13,0]},{"slot":2,"kind":"scalar","type":"int32","value":1496848895,"default":1496848895},{"slot":4,"kind":"offset","ref":"r2"},{"slot":5,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,-998315870,"1"]}]}],"finish":{"root":"r3"},"initialSize":100,"bytes":"14000000100024000000200000001c00180004001000000080000000a2e87ec40100000000000000000000000c0000000d0000000c000000020000000000000008000000f09f9880f09f988000000000"},{"id":"random/205","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[239,218,252,221,162,70,77,185,31,28,246,136,131,244,216,177,232,103,252,149]},{"op":"bytes","ref":"r3","value":[233,164,245,130,227,24]},{"op":"table","ref":"r4","slots":8,"fields":[{"slot":6,"kind":"scalar","type":"uint32","value":4294967295,"default":3780233721},{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[169,2]},{"slot":3,"kind":"scalar","type":"int32","value":2147483647,"default":2147483647},{"slot":7,"kind":"scalar","type":"float32","value":1024.0,"default":-0.5},{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,2147483647,"1"]},{"slot":1,"kind":"scalar","type":"int8","value":-21,"default":-4},{"slot":4,"kind":"offset","ref":"r3"}]},{"op":"vector","ref":"r5","type":"uint8","values":[1,255,0,2,1,4]},{"op":"table","ref":"r6","slots":8,"fields":[{"slot":3,"kind":"scalar","type":"int32","value":1,"default":0},{"slot":2,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r4"},{"slot":5,"kind":"offset","ref":"r5"},{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,0]}]}],"finish":{"root":"r6"},"bytes":"14000000100018000c00000010001400040008001000000001000000100000002c0000005c000000010000000600000001ff0002010400001400280000000b000c0000000400200024001c001400000024000000000000eb7f000000ffffff7f010000000000000000008044a9000200ffffffff06000000e9a4f582e318000014000000efdafcdda2464db91f1cf68883f4d8b1e867fc95"},{"id":"random/206","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/207","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"forceDefaults":true,"bytes":"0c000000313233340400040004000000"},{"id":"random/208","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[173,32767],[0,32767],[0,0],[255,0]]},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":3,"kind":"scalar","type":"float64","value":0.1,"default":123456.789},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,1,"4"]},{"slot":6,"kind":"offset","ref":"r1"},{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,1024.0,1.5]},{"slot":4,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[0,2147483647,"-3023422619598557359"]}]}],"finish":{"root":"r2","identifier":"MONS"},"bytes":"1c0000004d4f4e5300001200400024001400000034000400000020001200000000000000ffffff7f516ff27025a50ad67684df50000080440000c03f200000007f0000000100000004000000000000009a9999999999b93f0000000004000000ad00ff7f0000ff7f00000000ff000000"},{"id":"random/209","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int64","value":"0","default":"1"}]}],"finish":{"root":"r1"},"bytes":"0c000000000006000c000400060000000000000000000000"},{"id":"random/210","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"vector","ref":"r2","type":"int8","values":[1,-128,-128,-128,-128,-4]},{"op":"string","ref":"r3","value":"a"},{"op":"table","ref":"r4","slots":8,"fields":[{"slot":0,"kind":"scalar","type":"int32","value":-2147483648,"default":1},{"slot":3,"kind":"scalar","type":"int64","value":"1","default":"9223372036854775807"},{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,10311]},{"slot":7,"kind":"offset","ref":"r1"},{"slot":4,"kind":"offset","ref":"r2"},{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,-0.5,-2.25]},{"slot":6,"kind":"offset","ref":"r3"}]}],"finish":{"root":"r4"},"bytes":"1800000014002c00280008000000200014001c00040018001400000028000000000010c0000000bf000010c02000000028000000000047280100000000000000000000800100000061000000060000000180808080fc000008000000f09f9880f09f988000000000"},{"id":"random/211","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"a"},{"op":"table","ref":"r2","slots":3,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"uint16","value":1,"default":1}]}],"finish":{"root":"r2"},"bytes":"0c000000080008000000040008000000040000000100000061000000"},{"id":"random/212","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[233,98,53,79]},{"op":"structs","ref":"r3","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[0.0,-2.25,1024.0],[0.0,0.0,30000000000.0],[1024.0,1024.0,-0.5]]},{"op":"bytes","ref":"r4","value":[182,69,229,250,154]},{"op":"bytes","ref":"r6","value":[]},{"op":"table","ref":"r7","slots":6,"fields":[{"slot":0,"kind":"offset","ref":"r6"},{"slot":5,"kind":"scalar","type":"int16","value":0,"default":0},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,23057]},{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,1]},{"slot":4,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[0,1812926561,"9223372036854775807"]},{"slot":2,"kind":"scalar","type":"int8","value":-17,"default":-17}]},{"op":"table","ref":"r8","slots":7,"fields":[{"slot":2,"kind":"scalar","type":"float64","value":0.0,"default":123456.789},{"slot":4,"kind":"offset","ref":"r3"},{"slot":1,"kind":"scalar","type":"float32","value":0.0,"default":-0.5},{"slot":0,"kind":"scalar","type":"int8","value":0,"default":1},{"slot":3,"kind":"offset","ref":"r4"},{"slot":5,"kind":"offset","ref":"r7"}]},{"op":"table","ref":"r9","slots":7,"fields":[{"slot":5,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":6,"kind":"scalar","type":"int8","value":3,"default":-128},{"slot":4,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"int8","value":1,"default":1},{"slot":3,"kind":"scalar","type":"int8","value":-128,"default":-60},{"slot":0,"kind":"offset","ref":"r8"},{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[46,-32768]}]}],"finish":{"root":"r9","sizePrefixed":true},"bytes":"dc0000001c000000000000000000120018000800040000000f00100017001600120000002e0000802000000000000080a800000000000301100026000f001000180008001400040010000000300000005400000000000000000000005400000000000000000000000000000000000e0024002000180000001c0004000e0000000000000061100f6cffffffffffffff7f00000000000001000100115a040000000000000005000000b645e5fa9a0000000300000000000000000010c00000804400000000000000007684df500000804400008044000000bf04000000e962354f"},{"id":"random/213","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/214","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":3,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2"]},{"op":"table","ref":"r3","slots":3,"fields":[{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,1.5,1024.0]},{"slot":2,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r3"},"bytes":"1000000000000a0014000800000004000a000000100000007684df500000c03f0000804401000000080000000400040004000000"},{"id":"random/215","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/216","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[103,165,7,131,180]},{"op":"bytes","ref":"r2","value":[248,172,179,201,57,207,246]},{"op":"table","ref":"r3","slots":7,"fields":[{"slot":2,"kind":"offset","ref":"r1"},{"slot":3,"kind":"offset","ref":"r2"},{"slot":6,"kind":"scalar","type":"uint32","value":0,"default":1},{"slot":5,"kind":"scalar","type":"float64","value":2.5,"default":-1e-300},{"slot":4,"kind":"scalar","type":"uint32","value":0,"default":0},{"slot":1,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"-6649914928462325071"}]}],"finish":{"root":"r3"},"bytes":"1c000000000000000000120024000000040020001c0000000c00180012000000ffffffffffffff7f00000000000004400000000000000000080000001000000007000000f8acb3c939cff6000500000067a50783b4000000"},{"id":"random/217","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/218","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":127,"default":127}]}],"finish":{"root":"r1","sizePrefixed":true},"initialSize":100,"bytes":"0c000000080000000400040004000000"},{"id":"random/219","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"forceDefaults":true,"bytes":"0c000000313233340400040004000000"},{"id":"random/220","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"vector","ref":"r3","type":"uint8","values":[150]},{"op":"bytes","ref":"r4","value":[53,138,141,118,143,51,77,137,20,228,202,26,67,214,232]},{"op":"table","ref":"r6","slots":1,"fields":[]},{"op":"table","ref":"r7","slots":7,"fields":[{"slot":6,"kind":"scalar","type":"int32","value":680190986,"default":2147483647},{"slot":2,"kind":"scalar","type":"int64","value":"1","default":"-9222034732693503256"},{"slot":5,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,-2147483648,"1"]},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[88,0]}]},{"op":"offsets","ref":"r5","refs":["r6","r7"]},{"op":"offsets","ref":"r8","refs":[]},{"op":"table","ref":"r9","slots":8,"fields":[{"slot":3,"kind":"offset","ref":"r3"},{"slot":1,"kind":"offset","ref":"r4"},{"slot":5,"kind":"offset","ref":"r5"},{"slot":0,"kind":"scalar","type":"uint8","value":255,"default":0},{"slot":6,"kind":"offset","ref":"r8"}]},{"op":"vector","ref":"r10","type":"uint32","values":[4294967295,0,1,1]},{"op":"bytes","ref":"r11","value":[57,225,89,89,200,118,16,31,93,240,117,140,111,229,160,11,182,71,193,117]},{"op":"table","ref":"r12","slots":6,"fields":[{"slot":3,"kind":"scalar","type":"float32","value":1.5,"default":1.5},{"slot":4,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":2,"kind":"offset","ref":"r10"},{"slot":5,"kind":"offset","ref":"r11"}]},{"op":"vector","ref":"r13","type":"int64","values":["0","0","0","-1806902922529096715"]},{"op":"string","ref":"r14","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r15","slots":3,"fields":[{"slot":2,"kind":"offset","ref":"r13"},{"slot":0,"kind":"scalar","type":"int64","value":"1","default":"-6725400761758911181"},{"slot":1,"kind":"offset","ref":"r14"}]},{"op":"offsets","ref":"r2","refs":["r9","r12","r15"]},{"op":"bytes","ref":"r16","value":[26,87,35,60,57,115,248,28,199,17,4,29,170,11,218]},{"op":"table","ref":"r18","slots":2,"fields":[]},{"op":"bytes","ref":"r19","value":[134,27,33,239,73,221,188,231]},{"op":"table","ref":"r20","slots":8,"fields":[{"slot":5,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r2"},{"slot":1,"kind":"offset","ref":"r16"},{"slot":6,"kind":"scalar","type":"uint64","value":"0","default":"0"},{"slot":2,"kind":"offset","ref":"r18"},{"slot":3,"kind":"scalar","type":"float64","value":1e+300,"default":-1e-300},{"slot":4,"kind":"offset","ref":"r19"}]}],"finish":{"root":"r20","identifier":"ABCD"},"forceDefaults":true,"bytes":"200000004142434400000000000012003000280024001400080004002c001800120000002c0000009c7500883ce4377e00000000280000000000000000000000000000001c0000002c0000009401000008000000861b21ef49ddbce7a0feffff0f0000001a57233c3973f81cc711041daa0bda0003000000e40000008c0000001000000000000a0014000800040010000a0000001000000001000000000000003400000028000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000004000000000000000000000000000000000000000000000000000000f5bb09875d97ece61000140000000000080010000f000400100000001000000024000000000000010000c03f1400000039e15959c876101f5df0758c6fe5a00bb647c17504000000ffffffff0000000001000000010000000000120018000b0010000000140000000c0004001200000014000000000000ff10000000580000006800000000000000020000004400000018000000000012002400000000001800040000000800200012000000580000000100000000000080010000000000000001000000000000000ae48a2804000400040000000f000000358a8d768f334d8914e4ca1a43d6e8000100000096000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/221","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint32","values":[2,5]},{"op":"bytes","ref":"r2","value":[15,157,119,75,47,184,189]},{"op":"table","ref":"r3","slots":5,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"offset","ref":"r2"},{"slot":0,"kind":"scalar","type":"int8","value":0,"default":0}]}],"finish":{"root":"r3"},"bytes":"1000000000000a000c000000080004000a0000000800000010000000070000000f9d774b2fb8bd00020000000200000005000000"},{"id":"random/222","description":"seeded random buffer","ops":[{"op":"vector","ref":"r2","type":"float32","values":[1.5,1024.0,1024.0]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":7,"kind":"offset","ref":"r2"},{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,0]}]},{"op":"structs","ref":"r4","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[]},{"op":"bytes","ref":"r5","value":[19,55,181,93,12,164,70,252,99,23,224,147,236,154]},{"op":"table","ref":"r6","slots":7,"fields":[{"slot":4,"kind":"offset","ref":"r3"},{"slot":3,"kind":"offset","ref":"r4"},{"slot":2,"kind":"scalar","type":"int32","value":1,"default":-572788278},{"slot":6,"kind":"scalar","type":"bool","value":false,"default":true},{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,-32768]},{"slot":1,"kind":"offset","ref":"r5"},{"slot":0,"kind":"scalar","type":"int8","value":1,"default":1}]}],"finish":{"root":"r6"},"bytes":"18000000000012001c00000004001000140018000a000f0012000000180000000000ff0000800000010000001c000000300000000e0000001337b55d0ca446fc6317e093ec9a00000000000014000c0004000000000000000000000000000800140000000100000004000000030000000000c03f0000804400008044"},{"id":"random/223","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/224","description":"seeded random buffer","ops":[{"op":"string","ref":"r2","value":"a"},{"op":"vector","ref":"r3","type":"int64","values":["1"]},{"op":"table","ref":"r4","slots":4,"fields":[{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,-2.25,1024.0]},{"slot":2,"kind":"scalar","type":"uint32","value":1424990256,"default":4294967295},{"slot":0,"kind":"offset","ref":"r2"},{"slot":3,"kind":"offset","ref":"r3"}]},{"op":"bytes","ref":"r5","value":[221,5,185,6,217,198,49,121,88,16]},{"op":"table","ref":"r6","slots":7,"fields":[{"slot":5,"kind":"offset","ref":"r4"},{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,32767]},{"slot":6,"kind":"scalar","type":"uint32","value":4294967295,"default":4294967295},{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,0]},{"slot":1,"kind":"scalar","type":"int8","value":1,"default":1},{"slot":2,"kind":"offset","ref":"r5"}]}],"finish":{"root":"r6","identifier":"1234"},"initialSize":100,"bytes":"18000000313233341000140008000000040000000c001000100000001000000001000000ff00ff7f200000000a000000dd05b906d9c63179581000000c001c00080010000c0004000c000000180000002000000030a0ef54000010c0000010c0000080440100000001000000000000000100000061000000"},{"id":"random/225","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":0,"fields":[]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":6,"kind":"scalar","type":"int64","value":"-9223372036854775808","default":"-2984729464301590009"},{"slot":5,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"forceDefaults":true,"initialSize":100,"bytes":"180000000000120010000000000000000000000004000800120000001000000000000000000000800400040004000000"},{"id":"random/226","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/227","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float64","values":[0.0,-1e-300,123456.789]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-0.5,1.5,-2.25]},{"slot":2,"kind":"offset","ref":"r1"},{"slot":4,"kind":"scalar","type":"bool","value":true,"default":true}]}],"finish":{"root":"r2"},"bytes":"1000000000000a0014000800000004000a00000010000000000000bf0000c03f000010c003000000000000000000000059f3f8c21f6ea581c976be9f0c24fe40"},{"id":"random/228","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[2,32767]},{"slot":0,"kind":"scalar","type":"int64","value":"8782373936976511166","default":"1"}]}],"finish":{"root":"r1"},"bytes":"0c000000080014000400100008000000be40228e9042e179000000000200ff7f"},{"id":"random/229","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/230","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[84,-32768]},{"slot":0,"kind":"scalar","type":"float32","value":1.5,"default":1.5}]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"140000004142434400000a0008000000000004000a00000054000080"},{"id":"random/231","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":5,"fields":[{"slot":2,"kind":"scalar","type":"int32","value":4,"default":-5},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,32767]}]},{"op":"table","ref":"r3","slots":1,"fields":[]},{"op":"table","ref":"r4","slots":2,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2","r3","r4"]},{"op":"table","ref":"r5","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[4,2147483647,"-9223372036854775808"]}]}],"finish":{"root":"r5"},"bytes":"0c00000008001800040014000800000004000000ffffff7f00000000000000800400000003000000240000001000000004000000fcffffff04000400040000000c000c0000000000080004000c0000000100ff7f04000000"},{"id":"random/232","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"bytes":"0c000000080000000400040004000000"},{"id":"random/233","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[1.5,30000000000.0,30000000000.0],[-0.5,0.0,1024.0]]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"scalar","type":"int16","value":4,"default":32767},{"slot":0,"kind":"scalar","type":"float32","value":1024.0,"default":0.0}]},{"op":"table","ref":"r4","slots":5,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,0]},{"slot":3,"kind":"offset","ref":"r3"},{"slot":0,"kind":"scalar","type":"uint16","value":51991,"default":35781}]}],"finish":{"root":"r4"},"bytes":"1400000000000e00140006001000000008000c000e000000000017cb14000000ff0000001800000008000c0004000a00080000000000804400000400020000000000c03f7684df507684df50000000bf0000000000008044"},{"id":"random/234","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/235","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":-128,"default":33}]}],"finish":{"root":"r1"},"bytes":"0c00000000000600080007000600000000000080"},{"id":"random/236","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"bool","values":[false]},{"op":"table","ref":"r2","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"0c000000000006000800040006000000040000000100000000000000"},{"id":"random/237","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"float32","value":-2.25,"default":-2.25}]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/238","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/239","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[191]},{"op":"string","ref":"r2","value":"😀😀"},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":7,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,0.0,-0.5]},{"slot":4,"kind":"offset","ref":"r2"},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[0,5,"2"]},{"slot":3,"kind":"scalar","type":"uint32","value":1,"default":1}]}],"finish":{"root":"r3","identifier":"1234"},"bytes":"1c0000003132333414002c001c000400000000001800000000002800140000000000000005000000020000000000000000000000140000007684df5000000000000000bf1400000008000000f09f9880f09f98800000000001000000bf000000"},{"id":"random/240","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint64","values":["0","18446744073709551615","1","18446744073709551615","0","2"]},{"op":"vector","ref":"r2","type":"int8","values":[-16,0,1,127,0,4]},{"op":"table","ref":"r3","slots":7,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":6,"kind":"offset","ref":"r2"},{"slot":2,"kind":"scalar","type":"int8","value":0,"default":-128}]}],"finish":{"root":"r3"},"forceDefaults":true,"bytes":"180000000000120010000c000000070000000000000008001200000000000000080000001000000006000000f000017f00040000060000000000000000000000ffffffffffffffff0100000000000000ffffffffffffffff00000000000000000200000000000000"},{"id":"random/241","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/242","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":""},{"op":"table","ref":"r2","slots":2,"fields":[{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,30000000000.0,-2.25]},{"slot":1,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"forceDefaults":true,"initialSize":1,"bytes":"0c00000008001400080004000800000010000000000080447684df50000010c00000000000000000"},{"id":"random/243","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD"},"forceDefaults":true,"initialSize":1,"bytes":"0c000000414243440400040004000000"},{"id":"random/244","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"a"},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"0c000000000006000800040006000000040000000100000061000000"},{"id":"random/245","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":0.0,"default":123456.789},{"slot":2,"kind":"scalar","type":"uint16","value":0,"default":0}]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"140000004142434400000000000006000c000400060000000000000000000000"},{"id":"random/246","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,-0.5,0.0]},{"slot":0,"kind":"scalar","type":"bool","value":true,"default":true}]}],"finish":{"root":"r1"},"bytes":"0c0000000800100000000400080000000000c03f000000bf00000000"},{"id":"random/247","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float64","values":[]},{"op":"bytes","ref":"r2","value":[137,206,253,240,227,225]},{"op":"bytes","ref":"r3","value":[180,20,169,210,207,27,56,61,98,253,37,69,101]},{"op":"bytes","ref":"r5","value":[35,76,222,126,132,32,176,6,134,30,240,80,207,126,206,13,146,160]},{"op":"table","ref":"r6","slots":5,"fields":[{"slot":0,"kind":"offset","ref":"r5"}]},{"op":"table","ref":"r7","slots":8,"fields":[{"slot":0,"kind":"scalar","type":"uint32","value":4294967295,"default":4},{"slot":7,"kind":"offset","ref":"r1"},{"slot":4,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,-0.5,-0.5]},{"slot":3,"kind":"offset","ref":"r2"},{"slot":1,"kind":"offset","ref":"r3"},{"slot":6,"kind":"scalar","type":"uint64","value":"0","default":"0"},{"slot":5,"kind":"scalar","type":"int16","value":1,"default":1},{"slot":2,"kind":"offset","ref":"r6"}]}],"finish":{"root":"r7","identifier":"1234"},"bytes":"200000003132333400000000140026002000080004000c001000000000001c00140000002800000044000000540000000000c03f000000bf000000bf50000000ffffffff0000060008000400060000000400000012000000234cde7e8420b006861ef050cf7ece0d92a000000d000000b414a9d2cf1b383d62fd2545650000000600000089cefdf0e3e1000000000000"},{"id":"random/248","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/249","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"offsets","ref":"r2","refs":[]},{"op":"string","ref":"r3","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r4","slots":4,"fields":[{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,1024.0,30000000000.0]},{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"offset","ref":"r2"},{"slot":3,"kind":"offset","ref":"r3"}]}],"finish":{"root":"r4"},"bytes":"100000000c001c0010000c00080004000c0000001800000044000000440000000000c03f000080447684df502800000078787878787878787878787878787878787878787878787878787878787878787878787878787878000000000000000008000000f09f9880f09f988000000000"},{"id":"random/250","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[{"slot":4,"kind":"scalar","type":"uint32","value":716284033,"default":0}]}],"finish":{"root":"r1"},"bytes":"1400000000000e000800000000000000000004000e00000081a0b12a"},{"id":"random/251","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD","sizePrefixed":true},"bytes":"100000000c000000414243440400040004000000"},{"id":"random/252","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[153,42,210]},{"op":"table","ref":"r2","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":0,"default":-128},{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"uint32","value":4294967295,"default":0}]}],"finish":{"root":"r2","identifier":"ABCD","sizePrefixed":true},"bytes":"2c000000140000004142434400000a0010000f00080004000a000000ffffffff080000000000000003000000992ad200"},{"id":"random/253","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r2","value":[229,193,133,53,44,105,118,209,158,57,52,236,16,26,60,111,98,248]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r2"},{"slot":0,"kind":"scalar","type":"uint32","value":0,"default":3}]},{"op":"offsets","ref":"r1","refs":["r3"]},{"op":"table","ref":"r4","slots":3,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":1,"kind":"scalar","type":"int16","value":0,"default":0},{"slot":2,"kind":"scalar","type":"float64","value":123456.789,"default":123456.789}]}],"finish":{"root":"r4","sizePrefixed":true},"bytes":"480000000c00000000000600080004000600000004000000010000000c00000008000c000400080008000000000000000400000012000000e5c185352c6976d19e3934ec101a3c6f62f80000"},{"id":"random/254","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":1,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":2,"kind":"scalar","type":"uint32","value":1,"default":4294967295}]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"140000003132333400000a000c0000000b0004000a0000000100000000000001"},{"id":"random/255","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/256","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/257","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint32","values":[]},{"op":"bytes","ref":"r2","value":[133,30,162,241,110,114,114,68,172,167,236,77,19,241,253,166,70,199,93]},{"op":"vector","ref":"r3","type":"uint32","values":[0,1,4294967295,712026974,1494562774]},{"op":"structs","ref":"r4","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[-13,2006865758,"1"],[0,-2147483648,"0"],[127,2,"9223372036854775807"]]},{"op":"table","ref":"r5","slots":6,"fields":[{"slot":4,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"},{"slot":5,"kind":"offset","ref":"r3"},{"slot":2,"kind":"offset","ref":"r4"},{"slot":3,"kind":"scalar","type":"uint16","value":0,"default":0},{"slot":0,"kind":"scalar","type":"int16","value":-32768,"default":0}]}],"finish":{"root":"r5","identifier":"1234"},"forceDefaults":true,"bytes":"1c000000313233340000000010001800040010000800060014000c0010000000008000001000000044000000580000006c00000003000000f30000005e579e770100000000000000000000000000008000000000000000007f00000002000000ffffffffffffff7f00000000050000000000000001000000ffffffff5eab702ad637155913000000851ea2f16e727244aca7ec4d13f1fda646c75d0000000000"},{"id":"random/258","description":"seeded random buffer","ops":[{"op":"string","ref":"r2","value":"😀😀"},{"op":"string","ref":"r4","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"bytes","ref":"r5","value":[69,185,232,255,133,57,214,243,79,43,79,161,193]},{"op":"table","ref":"r6","slots":7,"fields":[{"slot":4,"kind":"scalar","type":"float32","value":-2.25,"default":-2.25},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,2147483647,"-3"]},{"slot":2,"kind":"offset","ref":"r4"},{"slot":5,"kind":"scalar","type":"float32","value":1.5,"default":1.5},{"slot":0,"kind":"offset","ref":"r5"}]},{"op":"table","ref":"r7","slots":7,"fields":[{"slot":4,"kind":"offset","ref":"r2"},{"slot":5,"kind":"offset","ref":"r6"},{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,32767]},{"slot":3,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-0.5,30000000000.0,1.5]}]},{"op":"offsets","ref":"r1","refs":["r7"]},{"op":"table","ref":"r8","slots":4,"fields":[{"slot":0,"kind":"scalar","type":"int16","value":-32768,"default":32767},{"slot":1,"kind":"offset","ref":"r1"},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[2,32767]}]}],"finish":{"root":"r8","sizePrefixed":true},"bytes":"d4000000100000000c0010000e000800000004000c0000000200ff7f0800000000000080010000001400000010001e0000001000000004001800140010000000000000bf7684df500000c03f0000ff7f140000007400000000000a00200004000c0008000a0000001c0000002c0000007f000000ffffff7ffdffffffffffffff000000000d00000045b9e8ff8539d6f34f2b4fa1c100000028000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000008000000f09f9880f09f988000000000"},{"id":"random/259","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/260","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"initialSize":16,"bytes":"080000000400040004000000"},{"id":"random/261","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"scalar","type":"bool","value":false,"default":false}]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/262","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"a"},{"op":"vector","ref":"r2","type":"bool","values":[false]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":3,"kind":"scalar","type":"uint64","value":"0","default":"1"},{"slot":1,"kind":"offset","ref":"r1"},{"slot":6,"kind":"scalar","type":"uint8","value":0,"default":0},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3","identifier":"MONS"},"initialSize":1,"bytes":"140000004d4f4e530c0014000400080000000c000c0000001000000014000000000000000000000001000000000000000100000061000000"},{"id":"random/263","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"forceDefaults":true,"bytes":"0c000000313233340400040004000000"},{"id":"random/264","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":""},{"op":"vector","ref":"r2","type":"int8","values":[127,1,-128,127,1,-1]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"forceDefaults":true,"bytes":"0c00000008000c0008000400080000000800000010000000060000007f01807f01ff00000000000000000000"},{"id":"random/265","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/266","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[43,131,160,226,147,105,185,246,252,106]},{"op":"vector","ref":"r2","type":"int16","values":[-4,32767,-1,0]},{"op":"table","ref":"r4","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":0.1,"default":2.5}]},{"op":"table","ref":"r6","slots":6,"fields":[{"slot":3,"kind":"scalar","type":"int8","value":-14,"default":-64},{"slot":1,"kind":"scalar","type":"bool","value":false,"default":true},{"slot":4,"kind":"scalar","type":"int32","value":0,"default":0}]},{"op":"table","ref":"r7","slots":8,"fields":[{"slot":4,"kind":"scalar","type":"int64","value":"-5787421106715939664","default":"-5787421106715939664"},{"slot":7,"kind":"scalar","type":"uint32","value":1,"default":1},{"slot":3,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"},{"slot":0,"kind":"offset","ref":"r4"},{"slot":5,"kind":"offset","ref":"r6"},{"slot":6,"kind":"scalar","type":"uint32","value":0,"default":0}]}],"finish":{"root":"r7","identifier":"ABCD","sizePrefixed":true},"bytes":"740000001c00000041424344000000001000140008000c000000100000000400100000001c0000002400000030000000380000000c00060000000400000005000c00000000f2060010000400060000009a9999999999b93f0000000004000000fcffff7fffff00000a0000002b83a0e29369b9f6fc6a0000"},{"id":"random/267","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/268","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[255,-4]]},{"op":"string","ref":"r3","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"offsets","ref":"r4","refs":[]},{"op":"table","ref":"r5","slots":5,"fields":[{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,-32768]},{"slot":0,"kind":"offset","ref":"r3"},{"slot":4,"kind":"offset","ref":"r4"},{"slot":3,"kind":"scalar","type":"uint32","value":3089035471,"default":0}]},{"op":"string","ref":"r6","value":""},{"op":"table","ref":"r8","slots":2,"fields":[]},{"op":"bytes","ref":"r9","value":[8,147,225,41,138,207,166,242,123,142,69,22,90,251,152,131,72]},{"op":"table","ref":"r10","slots":8,"fields":[{"slot":2,"kind":"scalar","type":"uint32","value":1,"default":2},{"slot":6,"kind":"scalar","type":"uint8","value":44,"default":0},{"slot":3,"kind":"offset","ref":"r6"},{"slot":4,"kind":"scalar","type":"uint16","value":17894,"default":4},{"slot":5,"kind":"scalar","type":"int32","value":2147483647,"default":0},{"slot":7,"kind":"offset","ref":"r8"},{"slot":1,"kind":"scalar","type":"uint8","value":99,"default":116},{"slot":0,"kind":"offset","ref":"r9"}]},{"op":"offsets","ref":"r2","refs":["r5","r10"]},{"op":"table","ref":"r11","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r11","identifier":"MONS"},"initialSize":1,"bytes":"100000004d4f4e5308000c00040008000800000008000000c40000000200000074000000180000001400240004000b0020001800160010001f000c0014000000200000000000006334000000ffffff7f0000e6452c0000000000002c01000000110000000893e1298acfa6f27b8e45165afb98834800000004000400040000000000000000000e0014000c0000001000040008000e000000cff01eb80c0000000c000000010000800000000028000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000001000000ff00fcff"},{"id":"random/269","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/270","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/271","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,-2147483648,"-9223372036854775808"]}]}],"finish":{"root":"r1","identifier":"ABCD","sizePrefixed":true},"bytes":"24000000100000004142434408001400000004000800000001000000000000800000000000000080"},{"id":"random/272","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r2","value":[153,122,54,219,188,33,194,240,255,193,93,74]},{"op":"vector","ref":"r3","type":"float64","values":[0.0,0.1]},{"op":"table","ref":"r4","slots":8,"fields":[{"slot":2,"kind":"scalar","type":"uint32","value":0,"default":0},{"slot":7,"kind":"scalar","type":"float32","value":30000000000.0,"default":1.5},{"slot":6,"kind":"scalar","type":"uint16","value":1,"default":1},{"slot":5,"kind":"offset","ref":"r2"},{"slot":4,"kind":"scalar","type":"float32","value":1.5,"default":1.5},{"slot":1,"kind":"offset","ref":"r3"}]},{"op":"table","ref":"r5","slots":7,"fields":[{"slot":2,"kind":"offset","ref":"r4"},{"slot":4,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,0,"1"]}]}],"finish":{"root":"r5","identifier":"1234"},"bytes":"1c000000313233340000000000000e001c00000000001800000004000e0000008000000000000000010000000000000000000000180000001400100000000400000000000000080000000c00140000000c0000001c0000007684df500200000000000000000000009a9999999999b93f0c000000997a36dbbc21c2f0ffc15d4a"},{"id":"random/273","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":0}]}],"finish":{"root":"r1","identifier":"ABCD","sizePrefixed":true},"bytes":"100000000c000000414243440400040004000000"},{"id":"random/274","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":2,"kind":"scalar","type":"uint8","value":255,"default":1},{"slot":0,"kind":"scalar","type":"float32","value":30000000000.0,"default":30000000000.0},{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[119,32767]}]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"1000000000000a001000080004000f000a0000007700ff7f7684df50000000ff"},{"id":"random/275","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"scalar","type":"int8","value":124,"default":5},{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-4]}]},{"op":"table","ref":"r4","slots":8,"fields":[{"slot":5,"kind":"offset","ref":"r1"},{"slot":3,"kind":"offset","ref":"r3"}]}],"finish":{"root":"r4"},"bytes":"1400000010000c0000000000000004000000080010000000100000001800000008000c0006000b000800000000000000fcff007c00000000"},{"id":"random/276","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/277","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int16","values":[]},{"op":"string","ref":"r2","value":"a"},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":4,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"bytes":"1400000000000e000c00000008000000000004000e000000080000000c000000010000006100000000000000"},{"id":"random/278","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[25,86,157,36]},{"op":"table","ref":"r2","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"0c000000000006000800040006000000040000000400000019569d24"},{"id":"random/279","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/280","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"bool","value":false,"default":false}]}],"finish":{"root":"r1","identifier":"ABCD"},"forceDefaults":true,"bytes":"100000004142434400000600080007000600000000000000"},{"id":"random/281","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"initialSize":16,"bytes":"0c000000080000000400040004000000"},{"id":"random/282","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r1","refs":[]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":2,"kind":"offset","ref":"r1"},{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,32767]},{"slot":0,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"-8037091822361004774"}]}],"finish":{"root":"r2"},"bytes":"1400000000000e001800040000001400000010000e000000ffffffffffffff7f000000000000ff7f0400000000000000"},{"id":"random/283","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[19,90,95,150,193,148,59,27,200,18,7]},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":5,"kind":"scalar","type":"uint64","value":"2023395951970458373","default":"18446744073709551615"},{"slot":3,"kind":"scalar","type":"bool","value":false,"default":true},{"slot":6,"kind":"scalar","type":"int16","value":32767,"default":1},{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"uint16","value":0,"default":1}]}],"finish":{"root":"r2"},"bytes":"180000000000120018000000080006000f00000010000c00120000000000000010000000ff7f0000059b29dde58b141c0b000000135a5f96c1943b1bc8120700"},{"id":"random/284","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/285","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[{"slot":2,"kind":"scalar","type":"uint8","value":0,"default":0}]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"bytes":"180000001000000000000a0008000000000007000a00000000000000"},{"id":"random/286","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/287","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int16","value":-32768,"default":0}]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"0c00000000000600080006000600000000000080"},{"id":"random/288","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"scalar","type":"int64","value":"-9223372036854775808","default":"239844259110824918"},{"slot":0,"kind":"scalar","type":"float32","value":1024.0,"default":-0.5}]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"100000004d4f4e53080010000400080008000000000080440000000000000080"},{"id":"random/289","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/290","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"initialSize":100,"bytes":"0c000000080000000400040004000000"},{"id":"random/291","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/292","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"0c000000414243440400040004000000"},{"id":"random/293","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":0,"kind":"scalar","type":"uint8","value":0,"default":3},{"slot":1,"kind":"scalar","type":"uint8","value":255,"default":0},{"slot":2,"kind":"scalar","type":"uint8","value":255,"default":1}]}],"finish":{"root":"r1"},"initialSize":16,"bytes":"1000000000000a0008000700060005000a00000000ffff00"},{"id":"random/294","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"string","ref":"r2","value":"héllo"},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":4,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"},{"slot":5,"kind":"scalar","type":"int64","value":"3959821641074866621","default":"0"}]}],"finish":{"root":"r3","sizePrefixed":true},"forceDefaults":true,"initialSize":100,"bytes":"4c00000018000000000000001000180000001000000000001400040010000000bdf92b72cd1cf4360000000008000000100000000600000068c3a96c6c6f000008000000f09f9880f09f988000000000"},{"id":"random/295","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":7,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":0,"default":127}]},{"op":"table","ref":"r4","slots":2,"fields":[]},{"op":"string","ref":"r6","value":""},{"op":"structs","ref":"r7","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[-128,-2147483648,"0"],[-4,-154767893,"-9223372036854775808"],[5,2147483647,"9223372036854775807"],[0,2147483647,"5351728431980867761"]]},{"op":"table","ref":"r9","slots":4,"fields":[{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,32767]},{"slot":0,"kind":"scalar","type":"int16","value":32043,"default":32767}]},{"op":"string","ref":"r10","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r11","slots":8,"fields":[{"slot":3,"kind":"offset","ref":"r6"},{"slot":4,"kind":"offset","ref":"r7"},{"slot":7,"kind":"offset","ref":"r9"},{"slot":0,"kind":"scalar","type":"int32","value":2147483647,"default":667497958},{"slot":1,"kind":"offset","ref":"r10"},{"slot":2,"kind":"scalar","type":"uint16","value":1,"default":3}]},{"op":"table","ref":"r12","slots":6,"fields":[{"slot":5,"kind":"offset","ref":"r4"},{"slot":2,"kind":"scalar","type":"int32","value":-2147483648,"default":-2147483648},{"slot":3,"kind":"scalar","type":"float64","value":0.0,"default":0.0},{"slot":0,"kind":"scalar","type":"uint8","value":0,"default":171},{"slot":4,"kind":"offset","ref":"r11"},{"slot":1,"kind":"scalar","type":"uint16","value":0,"default":0}]},{"op":"table","ref":"r13","slots":5,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2","r12","r13"]},{"op":"bytes","ref":"r15","value":[57,236,217,53,135,208,132,80,121,122,27,51,107,38,126,175,85,129,197,37]},{"op":"structs","ref":"r16","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[1024.0,-0.5,1024.0],[1.5,-2.25,1.5],[30000000000.0,-0.5,0.0]]},{"op":"table","ref":"r17","slots":7,"fields":[{"slot":1,"kind":"offset","ref":"r15"},{"slot":3,"kind":"offset","ref":"r16"},{"slot":5,"kind":"scalar","type":"float64","value":0.1,"default":-1e-300}]},{"op":"offsets","ref":"r18","refs":[]},{"op":"table","ref":"r19","slots":7,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":5,"kind":"scalar","type":"int32","value":-2147483648,"default":1},{"slot":3,"kind":"offset","ref":"r17"},{"slot":6,"kind":"scalar","type":"uint32","value":2,"default":2},{"slot":2,"kind":"offset","ref":"r18"},{"slot":4,"kind":"scalar","type":"uint8","value":0,"default":0},{"slot":1,"kind":"scalar","type":"float32","value":30000000000.0,"default":1024.0}]}],"finish":{"root":"r19"},"initialSize":100,"bytes":"1800000000000000100018001400040008000c0000001000100000007684df501000000020000000000000806c00000000000000100014000000100000000c0000000400100000009a9999999999b93f080000002c0000000300000000008044000000bf000080440000c03f000010c00000c03f7684df50000000bf000000001400000039ecd93587d08450797a1b336b267eaf5581c525030000000401000020000000080000000400040004000000100010000b0000000000000004000c00100000002000000000000000c800000014001c000c000800060018001400000000001000140000000000010014000000ffffff7f440000004c0000008c000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000a000c000600000008000a00000000002b7d0000ff7f0400000080000000000000800000000000000000fc000000eb6dc6f6000000000000008005000000ffffff7fffffffffffffff7f00000000ffffff7fb1f0937aa728454a0000000000000000040006000400000000000600080007000600000000000000"},{"id":"random/296","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[-128,1,"0"],[-128,2147483647,"1"]]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":2,"kind":"offset","ref":"r1"},{"slot":1,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"9223372036854775807"}]}],"finish":{"root":"r2"},"bytes":"140000000000000000000a0008000000000004000a00000004000000020000008000000001000000000000000000000080000000ffffff7f0100000000000000"},{"id":"random/297","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/298","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":4,"kind":"scalar","type":"int32","value":1,"default":1354460790}]}],"finish":{"root":"r1"},"bytes":"1400000000000e000800000000000000000004000e00000001000000"},{"id":"random/299","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"}]} From 80584ac78ece87c3adfdce7fe56253b68c11b7d7 Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Sat, 14 Nov 2026 17:51:09 +0000 Subject: [PATCH 02/11] test(encoding): focus FlatBuffers tests on inline oracle bytes --- .../effect/test/encoding/FlatBuffers.test.ts | 550 +++++------------- .../test/fixtures/flatbuffers/README.md | 13 - .../test/fixtures/flatbuffers/generate.py | 327 ----------- .../test/fixtures/flatbuffers/gold.json | 1 - 4 files changed, 146 insertions(+), 745 deletions(-) delete mode 100644 packages/effect/test/fixtures/flatbuffers/README.md delete mode 100644 packages/effect/test/fixtures/flatbuffers/generate.py delete mode 100644 packages/effect/test/fixtures/flatbuffers/gold.json diff --git a/packages/effect/test/encoding/FlatBuffers.test.ts b/packages/effect/test/encoding/FlatBuffers.test.ts index 22d0227d42d..d9f70845658 100644 --- a/packages/effect/test/encoding/FlatBuffers.test.ts +++ b/packages/effect/test/encoding/FlatBuffers.test.ts @@ -1,346 +1,128 @@ import { assert, describe, it } from "@effect/vitest" import { Result } from "effect" import * as FlatBuffers from "effect/encoding/FlatBuffers" -import { readFileSync } from "node:fs" - -// Expected bytes were written by the official FlatBuffers Python builder; -// see fixtures/flatbuffers/README.md -type ScalarType = - | "bool" - | "int8" - | "uint8" - | "int16" - | "uint16" - | "int32" - | "uint32" - | "int64" - | "uint64" - | "float32" - | "float64" -type Scalar = boolean | number | string -interface StructDef { - readonly size: number - readonly align: number - readonly fields: ReadonlyArray<{ readonly type: ScalarType; readonly offset: number }> -} -type Field = - | { - readonly slot: number - readonly kind: "scalar" - readonly type: ScalarType - readonly value: Scalar - readonly default: Scalar - } - | { readonly slot: number; readonly kind: "offset"; readonly ref: string } - | { - readonly slot: number - readonly kind: "struct" - readonly struct: StructDef - readonly value: ReadonlyArray - } -type Op = - | { readonly op: "string" | "sharedString"; readonly ref: string; readonly value: string } - | { readonly op: "bytes"; readonly ref: string; readonly value: ReadonlyArray } - | { readonly op: "vector"; readonly ref: string; readonly type: ScalarType; readonly values: ReadonlyArray } - | { readonly op: "offsets"; readonly ref: string; readonly refs: ReadonlyArray } - | { - readonly op: "structs" - readonly ref: string - readonly struct: StructDef - readonly items: ReadonlyArray> - } - | { readonly op: "table"; readonly ref: string; readonly slots: number; readonly fields: ReadonlyArray } -interface Case { - readonly id: string - readonly ops: ReadonlyArray - readonly finish: { readonly root: string; readonly identifier?: string; readonly sizePrefixed?: boolean } - readonly forceDefaults?: boolean - readonly initialSize?: number - readonly bytes: string -} - -const gold: { readonly cases: ReadonlyArray } = JSON.parse( - readFileSync(new URL("../fixtures/flatbuffers/gold.json", import.meta.url), "utf8") -) const fromHex = (hex: string) => Uint8Array.from(hex.match(/../g) ?? [], (b) => parseInt(b, 16)) const toHex = (bytes: Uint8Array) => Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("") -const SIZE: Record = { - bool: 1, - int8: 1, - uint8: 1, - int16: 2, - uint16: 2, - int32: 4, - uint32: 4, - int64: 8, - uint64: 8, - float32: 4, - float64: 8 -} - -const value = (type: ScalarType, v: Scalar): boolean | number | bigint => - type === "int64" || type === "uint64" ? BigInt(v as string) : typeof v === "string" ? Number(v) : v - -/** The value as the buffer stores it: integers wrap, float32 rounds. */ -const stored = (type: ScalarType, v: Scalar): boolean | number | bigint => { - const x = value(type, v) - return type === "float32" ? Math.fround(x as number) : x -} - -const add = (b: FlatBuffers.Builder, type: ScalarType, v: Scalar) => { - const x = value(type, v) - switch (type) { - case "bool": - return b.addBool(x as boolean) - case "int8": - return b.addInt8(x as number) - case "uint8": - return b.addUint8(x as number) - case "int16": - return b.addInt16(x as number) - case "uint16": - return b.addUint16(x as number) - case "int32": - return b.addInt32(x as number) - case "uint32": - return b.addUint32(x as number) - case "int64": - return b.addInt64(x as bigint) - case "uint64": - return b.addUint64(x as bigint) - case "float32": - return b.addFloat32(x as number) - case "float64": - return b.addFloat64(x as number) - } -} - -const addField = (b: FlatBuffers.Builder, slot: number, type: ScalarType, v: Scalar, d: Scalar) => { - const x = value(type, v) - const fallback = value(type, d) - switch (type) { - case "bool": - return b.addFieldBool(slot, x as boolean, fallback as boolean) - case "int8": - return b.addFieldInt8(slot, x as number, fallback as number) - case "uint8": - return b.addFieldUint8(slot, x as number, fallback as number) - case "int16": - return b.addFieldInt16(slot, x as number, fallback as number) - case "uint16": - return b.addFieldUint16(slot, x as number, fallback as number) - case "int32": - return b.addFieldInt32(slot, x as number, fallback as number) - case "uint32": - return b.addFieldUint32(slot, x as number, fallback as number) - case "int64": - return b.addFieldInt64(slot, x as bigint, fallback as bigint) - case "uint64": - return b.addFieldUint64(slot, x as bigint, fallback as bigint) - case "float32": - return b.addFieldFloat32(slot, x as number, fallback as number) - case "float64": - return b.addFieldFloat64(slot, x as number, fallback as number) - } -} - -/** Writes a struct the way flatc-generated code does: prep, then fields last to first with padding. */ -const writeStruct = (b: FlatBuffers.Builder, def: StructDef, values: ReadonlyArray) => { - b.prep(def.align, def.size) - let end = def.size - for (let i = def.fields.length - 1; i >= 0; i--) { - const field = def.fields[i] - b.pad(end - (field.offset + SIZE[field.type])) - add(b, field.type, values[i]) - end = field.offset - } - b.pad(end) +// The expected bytes were written by the official FlatBuffers Python builder +// (`flatbuffers` 25.12.19 from PyPI) making the same calls as the builders below. +const MONSTER = "1c0000004d4f4e53140028001c0000001a00140010000c00080007001400000000000001200000004400000078000000" + + "8000000000002c010000803f00000040000040400200000001000000020000000300000000000000ff000000feffffff" + + "fdffffffffffffff00000000020000001c00000004000000f4ffffff000005001800000008000c000800060008000000" + + "00000300040000000500000053776f7264000000050000000001020304000000030000004f726300" +const PREFIXED = "4c000000100000004142434408000c000800040008000000070000000400000028000000787878787878787878787878" + + "7878787878787878787878787878787878787878787878787878787800000000" + +// struct { a: byte; b: int; c: long }, as flatc-generated code writes it. +const addPadded = (b: FlatBuffers.Builder, a: number, x: number, y: bigint) => { + b.prep(8, 16) + b.addInt64(y) + b.addInt32(x) + b.pad(3) + b.addInt8(a) return b.offset } -const build = (c: Case): Uint8Array => { - const b = FlatBuffers.make({ initialSize: c.initialSize, forceDefaults: c.forceDefaults }) - const refs = new Map() - const ref = (name: string) => refs.get(name)! - for (const op of c.ops) { - switch (op.op) { - case "string": - refs.set(op.ref, b.createString(op.value)) - break - case "sharedString": - refs.set(op.ref, b.createSharedString(op.value)) - break - case "bytes": - refs.set(op.ref, b.createBytes(Uint8Array.from(op.value))) - break - case "vector": { - const size = SIZE[op.type] - b.startVector(size, op.values.length, size) - for (let i = op.values.length - 1; i >= 0; i--) add(b, op.type, op.values[i]) - refs.set(op.ref, b.endVector()) - break - } - case "offsets": - refs.set(op.ref, b.createOffsetVector(op.refs.map(ref))) - break - case "structs": - b.startVector(op.struct.size, op.items.length, op.struct.align) - for (let i = op.items.length - 1; i >= 0; i--) writeStruct(b, op.struct, op.items[i]) - refs.set(op.ref, b.endVector()) - break - case "table": - b.startTable(op.slots) - for (const field of op.fields) { - switch (field.kind) { - case "scalar": - addField(b, field.slot, field.type, field.value, field.default) - break - case "offset": - b.addFieldOffset(field.slot, ref(field.ref)) - break - case "struct": - b.addFieldStruct(field.slot, writeStruct(b, field.struct, field.value)) - break - } - } - refs.set(op.ref, b.endTable()) - break - } - } - return b.finish(ref(c.finish.root), c.finish) -} - -const readScalar = ( - reader: Pick, - type: ScalarType, - at: number -): boolean | number | bigint => reader[type](at) - -const readTableScalar = (table: FlatBuffers.Table, type: ScalarType, slot: number, fallback: Scalar) => { - const d = value(type, fallback) - switch (type) { - case "bool": - return table.bool(slot, d as boolean) - case "int64": - return table.int64(slot, d as bigint) - case "uint64": - return table.uint64(slot, d as bigint) - default: - return table[type](slot, d as number) - } -} - -const defined = (a: A | undefined): A => { - assert.isDefined(a) - return a! +const buildMonster = () => { + const b = FlatBuffers.make() + const name = b.createString("Orc") + const inventory = b.createBytes(Uint8Array.of(0, 1, 2, 3, 4)) + const weapons = [3, 5].map((damage) => { + const sword = b.createSharedString("Sword") + b.startTable(2) + b.addFieldOffset(0, sword) + b.addFieldInt16(1, damage) + return b.endTable() + }) + const weaponVector = b.createOffsetVector(weapons) + b.startVector(16, 2, 8) + addPadded(b, -1, -2, BigInt(-3)) + addPadded(b, 1, 2, BigInt(3)) + const path = b.endVector() + b.startTable(8) + b.prep(4, 12) + b.addFloat32(3) + b.addFloat32(2) + b.addFloat32(1) + b.addFieldStruct(0, b.offset) + b.addFieldInt16(1, 100, 100) + b.addFieldInt16(2, 300, 100) + b.addFieldOffset(3, name) + b.addFieldOffset(4, inventory) + b.addFieldOffset(5, weaponVector) + b.addFieldOffset(6, path) + b.addFieldBool(7, true) + return b.finish(b.endTable(), { identifier: "MONS" }) } -const checkStruct = (s: FlatBuffers.Struct, def: StructDef, values: ReadonlyArray) => { - def.fields.forEach((field, i) => - assert.deepStrictEqual(readScalar(s, field.type, field.offset), stored(field.type, values[i])) - ) +const buildPrefixed = () => { + const b = FlatBuffers.make({ initialSize: 1, forceDefaults: true }) + const s = b.createString("x".repeat(40)) + b.startTable(2) + b.addFieldOffset(0, s) + b.addFieldInt32(1, 7, 7) + return b.finish(b.endTable(), { identifier: "ABCD", sizePrefixed: true }) } -/** Reads every value the case wrote back from the buffer. */ -const verify = (c: Case, bytes: Uint8Array) => { - const ops = new Map(c.ops.map((op) => [op.ref, op])) - const checkTable = (table: FlatBuffers.Table, op: Extract) => { - for (const field of op.fields) { - switch (field.kind) { - case "scalar": { - // A value equal to its default isn't written; reading it gives the default back. - const present = c.forceDefaults === true || - value(field.type, field.value) !== value(field.type, field.default) - assert.strictEqual(table.has(field.slot), present) - assert.deepStrictEqual( - readTableScalar(table, field.type, field.slot, field.default), - present ? stored(field.type, field.value) : value(field.type, field.default) - ) - break - } - case "struct": - checkStruct(defined(table.struct(field.slot, field.struct.size)), field.struct, field.value) - break - case "offset": - checkOffset(table, field.slot, ops.get(field.ref)!) - break - } - } - } - const checkOffset = (table: FlatBuffers.Table, slot: number, child: Op) => { - switch (child.op) { - case "string": - case "sharedString": - assert.strictEqual(table.string(slot), child.value) - break - case "bytes": - assert.deepStrictEqual(Array.from(defined(table.bytes(slot))), child.value) - break - case "vector": { - const vector = defined(table.vector(slot, SIZE[child.type])) - assert.deepStrictEqual( - Array.from({ length: vector.length }, (_, i) => vector[child.type](i)), - child.values.map((v) => stored(child.type, v)) - ) - break - } - case "structs": { - const vector = defined(table.vector(slot, child.struct.size)) - assert.strictEqual(vector.length, child.items.length) - child.items.forEach((item, i) => checkStruct(vector.struct(i, child.struct.size), child.struct, item)) - break - } - case "offsets": { - const vector = defined(table.vector(slot, 4)) - assert.strictEqual(vector.length, child.refs.length) - child.refs.forEach((name, i) => { - const element = ops.get(name)! - if (element.op === "table") checkTable(vector.table(i), element) - else if (element.op === "string" || element.op === "sharedString") { - assert.strictEqual(vector.string(i), element.value) - } - }) - break - } - case "table": - checkTable(defined(table.table(slot)), child) - break - } - } - const root = ops.get(c.finish.root)! as Extract - checkTable(FlatBuffers.root(bytes, c.finish), root) - if (c.finish.identifier !== undefined) { - assert.strictEqual(FlatBuffers.identifier(bytes, c.finish), c.finish.identifier) +const readMonster = (root: FlatBuffers.Table) => { + const pos = root.struct(0, 12) + const weapons = root.vector(5, 4) + const path = root.vector(6, 16) + return { + pos: pos && [pos.float32(0), pos.float32(4), pos.float32(8)], + mana: [root.has(1), root.int16(1, 100)], + hp: root.int16(2, 100), + name: root.string(3), + inventory: root.bytes(4) && Array.from(root.bytes(4)!), + weapons: weapons && Array.from({ length: weapons.length }, (_, i) => { + const weapon = weapons.table(i) + return [weapon.string(0), weapon.int16(1)] + }), + path: path && Array.from({ length: path.length }, (_, i) => { + const s = path.struct(i, 16) + return [s.int8(0), s.int32(4), s.int64(8)] + }), + flag: root.bool(7) } } describe("FlatBuffers", () => { it("builds the bytes the official builder builds", () => { - assert.isAbove(gold.cases.length, 300) - for (const c of gold.cases) { - assert.strictEqual(toHex(build(c)), c.bytes, c.id) - } + assert.strictEqual(toHex(buildMonster()), MONSTER) + assert.strictEqual(toHex(buildPrefixed()), PREFIXED) }) - it("reads every value back from the official builder's bytes", () => { - for (const c of gold.cases) { - verify(c, fromHex(c.bytes)) - } + it("reads the official builder's bytes", () => { + const monster = fromHex(MONSTER) + assert.strictEqual(FlatBuffers.identifier(monster), "MONS") + assert.deepStrictEqual(readMonster(FlatBuffers.root(monster, { identifier: "MONS" })), { + pos: [1, 2, 3], + mana: [false, 100], + hp: 300, + name: "Orc", + inventory: [0, 1, 2, 3, 4], + weapons: [["Sword", 3], ["Sword", 5]], + path: [[1, 2, BigInt(3)], [-1, -2, BigInt(-3)]], + flag: true + }) + + const prefixed = fromHex(PREFIXED) + assert.strictEqual(FlatBuffers.identifier(prefixed, { sizePrefixed: true }), "ABCD") + const root = FlatBuffers.root(prefixed, { identifier: "ABCD", sizePrefixed: true }) + assert.strictEqual(root.string(0), "x".repeat(40)) + assert.isTrue(root.has(1)) + assert.strictEqual(root.int32(1), 7) }) it("reads absent fields as their defaults", () => { const b = FlatBuffers.make() - b.startTable(4) + b.startTable(1) const root = FlatBuffers.root(b.finish(b.endTable())) - assert.strictEqual(root.has(0), false) assert.strictEqual(root.int32(0, 7), 7) - assert.strictEqual(root.bool(1, true), true) - assert.strictEqual(root.uint64(2, BigInt(9)), BigInt(9)) - assert.strictEqual(root.string(3), undefined) - assert.strictEqual(root.table(3), undefined) - assert.strictEqual(root.vector(3, 1), undefined) + assert.strictEqual(root.string(0), undefined) + assert.strictEqual(root.table(0), undefined) + assert.strictEqual(root.vector(0, 1), undefined) // Slots past the vtable, as written by an older schema, are absent too. assert.strictEqual(root.float64(100, 1.5), 1.5) }) @@ -361,111 +143,71 @@ describe("FlatBuffers", () => { b.startTable(1) b.addFieldOffset(0, s) assert.strictEqual(failure(b.finish(b.endTable())), "InvalidUtf8") - assert.strictEqual(failure(fromHex(gold.cases[1].bytes), { identifier: "NOPE" }), "Identifier") + assert.strictEqual(failure(fromHex(MONSTER), { identifier: "NOPE" }), "Identifier") assert.strictEqual(failure(Uint8Array.of(0xff, 0, 0, 0, 0, 0, 0, 0), { sizePrefixed: true }), "OutOfBounds") }) it("decode rethrows errors that aren't FlatBuffersErrors", () => { - const bytes = fromHex(gold.cases[0].bytes) assert.throws(() => - FlatBuffers.decode(bytes, () => { + FlatBuffers.decode(fromHex(MONSTER), () => { throw new Error("boom") }), "boom") }) - it("only ever fails with FlatBuffersError on corrupted buffers", () => { - // Deterministic xorshift so failures reproduce. - let seed = 0x2f6b1d3 - const random = () => { - seed ^= seed << 13 - seed ^= seed >>> 17 - seed ^= seed << 5 - return (seed >>> 0) / 0x100000000 - } - let failures = 0 - for (const c of gold.cases) { - const original = fromHex(c.bytes) - for (let round = 0; round < 20; round++) { - const bytes = original.slice(0, random() < 0.2 ? Math.floor(random() * original.length) : original.length) - const flips = 1 + Math.floor(random() * 4) - for (let i = 0; i < flips && bytes.length > 0; i++) { - bytes[Math.floor(random() * bytes.length)] = Math.floor(random() * 256) - } - try { - verify(c, bytes) - } catch (error) { - if (error instanceof Error && error.name === "AssertionError") continue - assert.isTrue(FlatBuffers.isFlatBuffersError(error), `${c.id}: ${String(error)}`) - failures++ - } + it("only fails with FlatBuffersError on truncated or corrupted buffers", () => { + const monster = fromHex(MONSTER) + for (let i = 0; i < monster.length; i++) { + // Only the last byte, the NUL after "Orc", is not needed to read the buffer. + if (i < monster.length - 1) { + assert.isTrue(Result.isFailure(FlatBuffers.decode(monster.subarray(0, i), readMonster)), `truncated at ${i}`) } + const corrupted = monster.slice() + corrupted[i] ^= 0xff + // decode rethrows anything that isn't a FlatBuffersError. + FlatBuffers.decode(corrupted, readMonster) } - assert.isAbove(failures, 0) }) - describe("Builder", () => { - it("rejects nested and out-of-order calls", () => { - const usage = (f: (b: FlatBuffers.Builder) => void) => { - const b = FlatBuffers.make() - try { - f(b) - assert.fail("expected a FlatBuffersError") - } catch (error) { - assert.isTrue(FlatBuffers.isFlatBuffersError(error)) - assert.strictEqual((error as FlatBuffers.FlatBuffersError).kind, "Usage") - } + it("Builder rejects nested and out-of-order calls", () => { + const usage = (f: (b: FlatBuffers.Builder) => void) => { + try { + f(FlatBuffers.make()) + assert.fail("expected a FlatBuffersError") + } catch (error) { + assert.isTrue(FlatBuffers.isFlatBuffersError(error)) + assert.strictEqual((error as FlatBuffers.FlatBuffersError).kind, "Usage") } - usage((b) => { - b.startTable(1) - b.createString("x") - }) - usage((b) => { - b.startTable(1) - b.startTable(1) - }) - usage((b) => { - b.startVector(1, 1, 1) - b.startTable(1) - }) - usage((b) => b.endTable()) - usage((b) => b.endVector()) - usage((b) => { - b.startTable(1) - b.addFieldInt32(1, 5) - }) - usage((b) => b.addFieldInt32(0, 5)) - usage((b) => { - b.addInt32(1) - const s = b.offset - b.addInt32(2) - b.startTable(1) - b.addFieldStruct(0, s) - }) - usage((b) => { - b.startTable(0) - b.finish(b.endTable(), { identifier: "TOOLONG" }) - }) - usage((b) => b.addOffset(100)) + } + usage((b) => { + b.startTable(1) + b.createString("x") }) - - it("wraps integers to their width", () => { - const b = FlatBuffers.make() - b.startTable(3) - b.addFieldUint8(0, 256 + 7) - b.addFieldInt16(1, 0x18000) - b.addFieldUint64(2, -BigInt(1)) - const root = FlatBuffers.root(b.finish(b.endTable())) - assert.strictEqual(root.uint8(0), 7) - assert.strictEqual(root.int16(1), -32768) - assert.strictEqual(root.uint64(2), 2n ** 64n - 1n) + usage((b) => { + b.startTable(1) + b.startTable(1) }) - - it("returns a copy, leaving the builder's buffer alone", () => { - const b = FlatBuffers.make({ initialSize: 1 }) + usage((b) => { + b.startVector(1, 1, 1) + b.startTable(1) + }) + usage((b) => b.endTable()) + usage((b) => b.endVector()) + usage((b) => { + b.startTable(1) + b.addFieldInt32(1, 5) + }) + usage((b) => b.addFieldInt32(0, 5)) + usage((b) => { + b.addInt32(1) + const s = b.offset + b.addInt32(2) + b.startTable(1) + b.addFieldStruct(0, s) + }) + usage((b) => { b.startTable(0) - const bytes = b.finish(b.endTable()) - assert.strictEqual(bytes.byteOffset, 0) - assert.strictEqual(bytes.buffer.byteLength, bytes.length) + b.finish(b.endTable(), { identifier: "TOOLONG" }) }) + usage((b) => b.addOffset(100)) }) }) diff --git a/packages/effect/test/fixtures/flatbuffers/README.md b/packages/effect/test/fixtures/flatbuffers/README.md deleted file mode 100644 index a292b349cdf..00000000000 --- a/packages/effect/test/fixtures/flatbuffers/README.md +++ /dev/null @@ -1,13 +0,0 @@ -# FlatBuffers fixtures - -`gold.json` is read by `test/encoding/FlatBuffers.test.ts`. Each case is a -sequence of builder calls and the bytes the official FlatBuffers Python -builder (`flatbuffers` 25.12.19 from PyPI) produces for them: hand-written -cases for each feature, then 300 seeded random cases. - -Regenerate with: - -```sh -pip install flatbuffers==25.12.19 -python test/fixtures/flatbuffers/generate.py -``` diff --git a/packages/effect/test/fixtures/flatbuffers/generate.py b/packages/effect/test/fixtures/flatbuffers/generate.py deleted file mode 100644 index cfeffa22206..00000000000 --- a/packages/effect/test/fixtures/flatbuffers/generate.py +++ /dev/null @@ -1,327 +0,0 @@ -""" -Gold corpus for effect/encoding/FlatBuffers: builder op sequences run by the -official FlatBuffers Python builder (pip install flatbuffers), and the bytes -it produces. The TypeScript test replays every op sequence through -FlatBuffers.Builder, expects the same bytes, and reads every value back. - - python test/fixtures/flatbuffers/generate.py # writes gold.json - -Ops (run in order; `ref` names the offset an op returns): - {"op": "string", "ref", "value"} CreateString - {"op": "sharedString", "ref", "value"} CreateSharedString - {"op": "bytes", "ref", "value": [ints]} CreateByteVector - {"op": "vector", "ref", "type", "values"} a vector of scalars - {"op": "offsets", "ref", "refs"} a vector of offsets - {"op": "structs", "ref", "struct", "items"} a vector of structs - {"op": "table", "ref", "slots", "fields"} a table; fields are added in order: - {"slot", "kind": "scalar", "type", "value", "default"} - {"slot", "kind": "offset", "ref"} - {"slot", "kind": "struct", "struct", "value": [field values]} -Structs: {"size", "align", "fields": [{"type", "offset"}]}. -64-bit integers are decimal strings; non-finite floats are "Infinity", -"-Infinity" or "NaN". -""" - -import json -import random -import struct as pystruct -from pathlib import Path - -import flatbuffers -from flatbuffers import number_types as N - -HERE = Path(__file__).parent - -SCALARS = { - "bool": (N.BoolFlags, 1), - "int8": (N.Int8Flags, 1), - "uint8": (N.Uint8Flags, 1), - "int16": (N.Int16Flags, 2), - "uint16": (N.Uint16Flags, 2), - "int32": (N.Int32Flags, 4), - "uint32": (N.Uint32Flags, 4), - "int64": (N.Int64Flags, 8), - "uint64": (N.Uint64Flags, 8), - "float32": (N.Float32Flags, 4), - "float64": (N.Float64Flags, 8), -} -SLOT = { - "bool": "PrependBoolSlot", - "int8": "PrependInt8Slot", - "uint8": "PrependUint8Slot", - "int16": "PrependInt16Slot", - "uint16": "PrependUint16Slot", - "int32": "PrependInt32Slot", - "uint32": "PrependUint32Slot", - "int64": "PrependInt64Slot", - "uint64": "PrependUint64Slot", - "float32": "PrependFloat32Slot", - "float64": "PrependFloat64Slot", -} -PREPEND = {t: "Prepend" + s[len("Prepend"):-len("Slot")] for t, s in SLOT.items()} - - -def py(value, t): - if t in ("int64", "uint64"): - return int(value) - if t in ("float32", "float64") and isinstance(value, str): - return float(value) - return value - - -def write_struct(b, s, values): - b.Prep(s["align"], s["size"]) - fields = s["fields"] - end = s["size"] - for f, v in reversed(list(zip(fields, values))): - size = SCALARS[f["type"]][1] - b.Pad(end - (f["offset"] + size)) - getattr(b, PREPEND[f["type"]])(py(v, f["type"])) - end = f["offset"] - b.Pad(end) - return b.Offset() - - -def run(case): - b = flatbuffers.Builder(case.get("initialSize", 1024)) - if case.get("forceDefaults"): - b.ForceDefaults(True) - refs = {} - for op in case["ops"]: - kind = op["op"] - if kind == "string": - refs[op["ref"]] = b.CreateString(op["value"]) - elif kind == "sharedString": - refs[op["ref"]] = b.CreateSharedString(op["value"]) - elif kind == "bytes": - refs[op["ref"]] = b.CreateByteVector(bytes(op["value"])) - elif kind == "vector": - flags, size = SCALARS[op["type"]] - b.StartVector(size, len(op["values"]), size) - for v in reversed(op["values"]): - getattr(b, PREPEND[op["type"]])(py(v, op["type"])) - refs[op["ref"]] = b.EndVector() - elif kind == "offsets": - b.StartVector(4, len(op["refs"]), 4) - for r in reversed(op["refs"]): - b.PrependUOffsetTRelative(refs[r]) - refs[op["ref"]] = b.EndVector() - elif kind == "structs": - s = op["struct"] - b.StartVector(s["size"], len(op["items"]), s["align"]) - for item in reversed(op["items"]): - write_struct(b, s, item) - refs[op["ref"]] = b.EndVector() - elif kind == "table": - b.StartObject(op["slots"]) - for f in op["fields"]: - if f["kind"] == "scalar": - getattr(b, SLOT[f["type"]])(f["slot"], py(f["value"], f["type"]), py(f["default"], f["type"])) - elif f["kind"] == "offset": - b.PrependUOffsetTRelativeSlot(f["slot"], refs[f["ref"]], 0) - else: - b.PrependStructSlot(f["slot"], write_struct(b, f["struct"], f["value"]), 0) - refs[op["ref"]] = b.EndObject() - else: - raise ValueError(kind) - finish = case["finish"] - identifier = finish.get("identifier") - identifier = identifier.encode() if identifier is not None else None - if finish.get("sizePrefixed"): - b.FinishSizePrefixed(refs[finish["root"]], file_identifier=identifier) - else: - b.Finish(refs[finish["root"]], file_identifier=identifier) - return bytes(b.Output()).hex() - - -# --------------------------------------------------------------------------- -# Cases -# --------------------------------------------------------------------------- - -VEC3 = {"size": 12, "align": 4, "fields": [{"type": "float32", "offset": 0}, {"type": "float32", "offset": 4}, {"type": "float32", "offset": 8}]} -PADDED = {"size": 16, "align": 8, "fields": [{"type": "int8", "offset": 0}, {"type": "int32", "offset": 4}, {"type": "int64", "offset": 8}]} -SMALL = {"size": 4, "align": 2, "fields": [{"type": "uint8", "offset": 0}, {"type": "int16", "offset": 2}]} - - -def spec(): - out = [] - add = lambda id, description, **case: out.append({"id": id, "description": description, **case}) - add("empty-table", "a table without fields", ops=[{"op": "table", "ref": "t", "slots": 0, "fields": []}], finish={"root": "t"}) - add("monster", "strings, scalars, a struct, vectors and a nested table", ops=[ - {"op": "string", "ref": "name", "value": "Orc"}, - {"op": "bytes", "ref": "inventory", "value": [0, 1, 2, 3, 4]}, - {"op": "string", "ref": "sword", "value": "Sword"}, - {"op": "table", "ref": "weapon", "slots": 2, "fields": [ - {"slot": 0, "kind": "offset", "ref": "sword"}, - {"slot": 1, "kind": "scalar", "type": "int16", "value": 3, "default": 0}]}, - {"op": "offsets", "ref": "weapons", "refs": ["weapon"]}, - {"op": "table", "ref": "monster", "slots": 8, "fields": [ - {"slot": 0, "kind": "struct", "struct": VEC3, "value": [1.0, 2.0, 3.0]}, - {"slot": 2, "kind": "scalar", "type": "int16", "value": 300, "default": 100}, - {"slot": 3, "kind": "offset", "ref": "name"}, - {"slot": 5, "kind": "offset", "ref": "inventory"}, - {"slot": 6, "kind": "scalar", "type": "uint8", "value": 2, "default": 0}, - {"slot": 7, "kind": "offset", "ref": "weapons"}]}], - finish={"root": "monster", "identifier": "MONS"}) - add("defaults-skipped", "scalars equal to their default are not written", ops=[ - {"op": "table", "ref": "t", "slots": 3, "fields": [ - {"slot": 0, "kind": "scalar", "type": "int32", "value": 7, "default": 7}, - {"slot": 1, "kind": "scalar", "type": "float64", "value": 0.5, "default": 0.5}, - {"slot": 2, "kind": "scalar", "type": "bool", "value": True, "default": True}]}], finish={"root": "t"}) - add("force-defaults", "forceDefaults writes defaults too", forceDefaults=True, ops=[ - {"op": "table", "ref": "t", "slots": 3, "fields": [ - {"slot": 0, "kind": "scalar", "type": "int32", "value": 7, "default": 7}, - {"slot": 1, "kind": "scalar", "type": "float64", "value": 0.5, "default": 0.5}, - {"slot": 2, "kind": "scalar", "type": "bool", "value": True, "default": True}]}], finish={"root": "t"}) - add("shared-vtables", "tables with the same layout share one vtable", ops=[ - {"op": "table", "ref": "a", "slots": 2, "fields": [{"slot": 0, "kind": "scalar", "type": "int32", "value": 1, "default": 0}]}, - {"op": "table", "ref": "b", "slots": 2, "fields": [{"slot": 0, "kind": "scalar", "type": "int32", "value": 2, "default": 0}]}, - {"op": "table", "ref": "c", "slots": 2, "fields": [{"slot": 1, "kind": "scalar", "type": "int32", "value": 3, "default": 0}]}, - {"op": "offsets", "ref": "all", "refs": ["a", "b", "c"]}, - {"op": "table", "ref": "root", "slots": 1, "fields": [{"slot": 0, "kind": "offset", "ref": "all"}]}], finish={"root": "root"}) - add("extremes", "integer and float extremes", ops=[ - {"op": "table", "ref": "t", "slots": 11, "fields": [ - {"slot": 0, "kind": "scalar", "type": "int8", "value": -128, "default": 0}, - {"slot": 1, "kind": "scalar", "type": "uint8", "value": 255, "default": 0}, - {"slot": 2, "kind": "scalar", "type": "int16", "value": -32768, "default": 0}, - {"slot": 3, "kind": "scalar", "type": "uint16", "value": 65535, "default": 0}, - {"slot": 4, "kind": "scalar", "type": "int32", "value": -2147483648, "default": 0}, - {"slot": 5, "kind": "scalar", "type": "uint32", "value": 4294967295, "default": 0}, - {"slot": 6, "kind": "scalar", "type": "int64", "value": "-9223372036854775808", "default": "0"}, - {"slot": 7, "kind": "scalar", "type": "uint64", "value": "18446744073709551615", "default": "0"}, - {"slot": 8, "kind": "scalar", "type": "float32", "value": -3.4028234663852886e38, "default": 0.0}, - {"slot": 9, "kind": "scalar", "type": "float64", "value": 5e-324, "default": 0.0}, - {"slot": 10, "kind": "scalar", "type": "float64", "value": "Infinity", "default": 0.0}]}], finish={"root": "t"}) - add("strings", "empty, unicode and shared strings", ops=[ - {"op": "string", "ref": "e", "value": ""}, - {"op": "string", "ref": "u", "value": "héllo wörld 😀 ￿"}, - {"op": "sharedString", "ref": "s1", "value": "shared"}, - {"op": "sharedString", "ref": "s2", "value": "shared"}, - {"op": "offsets", "ref": "v", "refs": ["e", "u", "s1", "s2"]}, - {"op": "table", "ref": "t", "slots": 1, "fields": [{"slot": 0, "kind": "offset", "ref": "v"}]}], finish={"root": "t"}) - add("scalar-vectors", "vectors of every scalar type", ops=[ - *[{"op": "vector", "ref": t, "type": t, "values": vals} for t, vals in [ - ("bool", [True, False, True]), ("int8", [-1, 2]), ("uint8", []), ("int16", [-300, 300, 7]), - ("uint16", [65535]), ("int32", [1, -2, 3, -4, 5]), ("uint32", [4000000000]), - ("int64", ["-5", "9007199254740993"]), ("uint64", ["18446744073709551615"]), ("float32", [1.5, -0.25]), - ("float64", [3.141592653589793, -0.0])]], - {"op": "table", "ref": "t", "slots": 11, "fields": [ - {"slot": i, "kind": "offset", "ref": t} for i, t in enumerate( - ["bool", "int8", "uint8", "int16", "uint16", "int32", "uint32", "int64", "uint64", "float32", "float64"])]}], - finish={"root": "t"}) - add("struct-vectors", "vectors of structs with padding", ops=[ - {"op": "structs", "ref": "p", "struct": PADDED, "items": [[1, 2, "3"], [-1, -2, "-3"]]}, - {"op": "structs", "ref": "s", "struct": SMALL, "items": [[255, -1], [0, 2], [7, 300]]}, - {"op": "table", "ref": "t", "slots": 3, "fields": [ - {"slot": 0, "kind": "offset", "ref": "p"}, - {"slot": 1, "kind": "struct", "struct": PADDED, "value": [9, 8, "7"]}, - {"slot": 2, "kind": "offset", "ref": "s"}]}], finish={"root": "t"}) - add("size-prefixed", "a size-prefixed buffer with an identifier", ops=[ - {"op": "string", "ref": "s", "value": "x"}, - {"op": "table", "ref": "t", "slots": 2, "fields": [ - {"slot": 0, "kind": "offset", "ref": "s"}, - {"slot": 1, "kind": "scalar", "type": "int64", "value": "42", "default": "0"}]}], - finish={"root": "t", "identifier": "ABCD", "sizePrefixed": True}) - add("growth", "a small initial size grows", initialSize=1, ops=[ - {"op": "bytes", "ref": "b", "value": list(range(256)) * 4}, - {"op": "table", "ref": "t", "slots": 1, "fields": [{"slot": 0, "kind": "offset", "ref": "b"}]}], finish={"root": "t"}) - return out - - -# --------------------------------------------------------------------------- -# Random cases -# --------------------------------------------------------------------------- - -def random_scalar(rng, t): - if t == "bool": - return rng.random() < 0.5 - if t == "float32": - return rng.choice([0.0, 1.5, -2.25, 1024.0, 3.0e10, -0.5]) - if t == "float64": - return rng.choice([0.0, 0.1, -1e-300, 2.5, 1e300, 123456.789]) - bits = {"int8": 8, "uint8": 8, "int16": 16, "uint16": 16, "int32": 32, "uint32": 32, "int64": 64, "uint64": 64}[t] - signed = not t.startswith("u") - lo, hi = (-(2 ** (bits - 1)), 2 ** (bits - 1) - 1) if signed else (0, 2 ** bits - 1) - v = rng.choice([0, 1, lo, hi, rng.randint(lo, hi), rng.randint(-5, 5) if signed else rng.randint(0, 5)]) - return str(v) if bits == 64 else v - - -STRUCTS = [VEC3, PADDED, SMALL] -TYPES = list(SCALARS) - - -def random_case(rng, index): - ops = [] - counter = [0] - - def ref(): - counter[0] += 1 - return f"r{counter[0]}" - - def table(depth): - slots = rng.randint(0, 8) - fields = [] - for slot in rng.sample(range(slots), rng.randint(0, slots)) if slots else []: - r = rng.random() - if r < 0.45: - t = rng.choice(TYPES) - v = random_scalar(rng, t) - d = v if rng.random() < 0.2 else random_scalar(rng, t) - fields.append({"slot": slot, "kind": "scalar", "type": t, "value": v, "default": d}) - elif r < 0.6: - s = rng.choice(STRUCTS) - fields.append({"slot": slot, "kind": "struct", "struct": s, - "value": [random_scalar(rng, f["type"]) for f in s["fields"]]}) - else: - child = rng.random() - name = ref() - if child < 0.25: - ops.append({"op": "string", "ref": name, "value": rng.choice(["", "a", "héllo", "😀😀", "x" * 40])}) - elif child < 0.4: - ops.append({"op": "bytes", "ref": name, "value": [rng.randint(0, 255) for _ in range(rng.randint(0, 20))]}) - elif child < 0.6: - t = rng.choice(TYPES) - ops.append({"op": "vector", "ref": name, "type": t, - "values": [random_scalar(rng, t) for _ in range(rng.randint(0, 6))]}) - elif child < 0.7: - s = rng.choice(STRUCTS) - ops.append({"op": "structs", "ref": name, "struct": s, - "items": [[random_scalar(rng, f["type"]) for f in s["fields"]] for _ in range(rng.randint(0, 4))]}) - elif child < 0.85 and depth < 3: - name = table(depth + 1) - elif depth < 3: - children = [table(depth + 1) for _ in range(rng.randint(0, 3))] - ops.append({"op": "offsets", "ref": name, "refs": children}) - else: - ops.append({"op": "string", "ref": name, "value": "leaf"}) - fields.append({"slot": slot, "kind": "offset", "ref": name}) - name = ref() - ops.append({"op": "table", "ref": name, "slots": slots, "fields": fields}) - return name - - root = table(0) - finish = {"root": root} - if rng.random() < 0.3: - finish["identifier"] = rng.choice(["ABCD", "MONS", "1234"]) - if rng.random() < 0.2: - finish["sizePrefixed"] = True - case = {"id": f"random/{index:03d}", "description": "seeded random buffer", "ops": ops, "finish": finish} - if rng.random() < 0.15: - case["forceDefaults"] = True - if rng.random() < 0.2: - case["initialSize"] = rng.choice([1, 16, 100]) - return case - - -def main(): - rng = random.Random(20261114) - cases = spec() + [random_case(rng, i) for i in range(300)] - for c in cases: - c["bytes"] = run(c) - header = {"generator": "generate.py", "flatbuffers": flatbuffers.__version__ if hasattr(flatbuffers, "__version__") else "?"} - (HERE / "gold.json").write_text(json.dumps({**header, "cases": cases}, ensure_ascii=False, allow_nan=False, separators=(",", ":")) + "\n") - print(f"{len(cases)} cases, {sum(len(c['bytes']) // 2 for c in cases)} bytes") - - -if __name__ == "__main__": - main() diff --git a/packages/effect/test/fixtures/flatbuffers/gold.json b/packages/effect/test/fixtures/flatbuffers/gold.json deleted file mode 100644 index 64dd87eb029..00000000000 --- a/packages/effect/test/fixtures/flatbuffers/gold.json +++ /dev/null @@ -1 +0,0 @@ -{"generator":"generate.py","flatbuffers":"25.12.19","cases":[{"id":"empty-table","description":"a table without fields","ops":[{"op":"table","ref":"t","slots":0,"fields":[]}],"finish":{"root":"t"},"bytes":"080000000400040004000000"},{"id":"monster","description":"strings, scalars, a struct, vectors and a nested table","ops":[{"op":"string","ref":"name","value":"Orc"},{"op":"bytes","ref":"inventory","value":[0,1,2,3,4]},{"op":"string","ref":"sword","value":"Sword"},{"op":"table","ref":"weapon","slots":2,"fields":[{"slot":0,"kind":"offset","ref":"sword"},{"slot":1,"kind":"scalar","type":"int16","value":3,"default":0}]},{"op":"offsets","ref":"weapons","refs":["weapon"]},{"op":"table","ref":"monster","slots":8,"fields":[{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.0,2.0,3.0]},{"slot":2,"kind":"scalar","type":"int16","value":300,"default":100},{"slot":3,"kind":"offset","ref":"name"},{"slot":5,"kind":"offset","ref":"inventory"},{"slot":6,"kind":"scalar","type":"uint8","value":2,"default":0},{"slot":7,"kind":"offset","ref":"weapons"}]}],"finish":{"root":"monster","identifier":"MONS"},"bytes":"1c0000004d4f4e5314002400180000001600100000000c000b000400140000002000000000000002400000004800000000002c010000803f0000004000004040010000000c00000008000c00080006000800000000000300040000000500000053776f7264000000050000000001020304000000030000004f726300"},{"id":"defaults-skipped","description":"scalars equal to their default are not written","ops":[{"op":"table","ref":"t","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"int32","value":7,"default":7},{"slot":1,"kind":"scalar","type":"float64","value":0.5,"default":0.5},{"slot":2,"kind":"scalar","type":"bool","value":true,"default":true}]}],"finish":{"root":"t"},"bytes":"080000000400040004000000"},{"id":"force-defaults","description":"forceDefaults writes defaults too","forceDefaults":true,"ops":[{"op":"table","ref":"t","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"int32","value":7,"default":7},{"slot":1,"kind":"scalar","type":"float64","value":0.5,"default":0.5},{"slot":2,"kind":"scalar","type":"bool","value":true,"default":true}]}],"finish":{"root":"t"},"bytes":"1000000000000a0018001400080007000a00000000000001000000000000e03f0000000007000000"},{"id":"shared-vtables","description":"tables with the same layout share one vtable","ops":[{"op":"table","ref":"a","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"int32","value":1,"default":0}]},{"op":"table","ref":"b","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"int32","value":2,"default":0}]},{"op":"table","ref":"c","slots":2,"fields":[{"slot":1,"kind":"scalar","type":"int32","value":3,"default":0}]},{"op":"offsets","ref":"all","refs":["a","b","c"]},{"op":"table","ref":"root","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"all"}]}],"finish":{"root":"root"},"bytes":"04000000c6ffffff040000000300000034000000200000000c00000008000a00000004000800000003000000000006000a000400060000000200000000000600080004000600000001000000"},{"id":"extremes","description":"integer and float extremes","ops":[{"op":"table","ref":"t","slots":11,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":-128,"default":0},{"slot":1,"kind":"scalar","type":"uint8","value":255,"default":0},{"slot":2,"kind":"scalar","type":"int16","value":-32768,"default":0},{"slot":3,"kind":"scalar","type":"uint16","value":65535,"default":0},{"slot":4,"kind":"scalar","type":"int32","value":-2147483648,"default":0},{"slot":5,"kind":"scalar","type":"uint32","value":4294967295,"default":0},{"slot":6,"kind":"scalar","type":"int64","value":"-9223372036854775808","default":"0"},{"slot":7,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"0"},{"slot":8,"kind":"scalar","type":"float32","value":-3.4028234663852886e+38,"default":0.0},{"slot":9,"kind":"scalar","type":"float64","value":5e-324,"default":0.0},{"slot":10,"kind":"scalar","type":"float64","value":"Infinity","default":0.0}]}],"finish":{"root":"t"},"bytes":"240000000000000000001a003c003b003a003800360030002c0024001c0018000c0004001a000000000000000000f07f010000000000000000000000ffff7fffffffffffffffffff0000000000000080ffffffff000000800000ffff0080ff80"},{"id":"strings","description":"empty, unicode and shared strings","ops":[{"op":"string","ref":"e","value":""},{"op":"string","ref":"u","value":"héllo wörld 😀 ￿"},{"op":"sharedString","ref":"s1","value":"shared"},{"op":"sharedString","ref":"s2","value":"shared"},{"op":"offsets","ref":"v","refs":["e","u","s1","s2"]},{"op":"table","ref":"t","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"v"}]}],"finish":{"root":"t"},"bytes":"0c0000000000060008000400060000000400000004000000380000001800000008000000040000000600000073686172656400001600000068c3a96c6c6f2077c3b6726c6420f09f988020efbfbf00000000000000000000"},{"id":"scalar-vectors","description":"vectors of every scalar type","ops":[{"op":"vector","ref":"bool","type":"bool","values":[true,false,true]},{"op":"vector","ref":"int8","type":"int8","values":[-1,2]},{"op":"vector","ref":"uint8","type":"uint8","values":[]},{"op":"vector","ref":"int16","type":"int16","values":[-300,300,7]},{"op":"vector","ref":"uint16","type":"uint16","values":[65535]},{"op":"vector","ref":"int32","type":"int32","values":[1,-2,3,-4,5]},{"op":"vector","ref":"uint32","type":"uint32","values":[4000000000]},{"op":"vector","ref":"int64","type":"int64","values":["-5","9007199254740993"]},{"op":"vector","ref":"uint64","type":"uint64","values":["18446744073709551615"]},{"op":"vector","ref":"float32","type":"float32","values":[1.5,-0.25]},{"op":"vector","ref":"float64","type":"float64","values":[3.141592653589793,-0.0]},{"op":"table","ref":"t","slots":11,"fields":[{"slot":0,"kind":"offset","ref":"bool"},{"slot":1,"kind":"offset","ref":"int8"},{"slot":2,"kind":"offset","ref":"uint8"},{"slot":3,"kind":"offset","ref":"int16"},{"slot":4,"kind":"offset","ref":"uint16"},{"slot":5,"kind":"offset","ref":"int32"},{"slot":6,"kind":"offset","ref":"uint32"},{"slot":7,"kind":"offset","ref":"int64"},{"slot":8,"kind":"offset","ref":"uint64"},{"slot":9,"kind":"offset","ref":"float32"},{"slot":10,"kind":"offset","ref":"float64"}]}],"finish":{"root":"t"},"bytes":"240000000000000000001a0030002c002800240020001c001800140010000c00080004001a0000002c0000003c00000044000000500000006000000064000000780000007c00000084000000840000008800000002000000182d4454fb2109400000000000000080020000000000c03f000080be01000000ffffffffffffffff0000000002000000fbffffffffffffff01000000000020000100000000286bee0500000001000000feffffff03000000fcffffff0500000001000000ffff000003000000d4fe2c01070000000000000002000000ff0200000300000001000100"},{"id":"struct-vectors","description":"vectors of structs with padding","ops":[{"op":"structs","ref":"p","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[1,2,"3"],[-1,-2,"-3"]]},{"op":"structs","ref":"s","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[255,-1],[0,2],[7,300]]},{"op":"table","ref":"t","slots":3,"fields":[{"slot":0,"kind":"offset","ref":"p"},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[9,8,"7"]},{"slot":2,"kind":"offset","ref":"s"}]}],"finish":{"root":"t"},"bytes":"1000000000000a001c001800080004000a00000018000000090000000800000007000000000000001400000003000000ff00ffff0000020007002c010200000001000000020000000300000000000000ff000000fefffffffdffffffffffffff"},{"id":"size-prefixed","description":"a size-prefixed buffer with an identifier","ops":[{"op":"string","ref":"s","value":"x"},{"op":"table","ref":"t","slots":2,"fields":[{"slot":0,"kind":"offset","ref":"s"},{"slot":1,"kind":"scalar","type":"int64","value":"42","default":"0"}]}],"finish":{"root":"t","identifier":"ABCD","sizePrefixed":true},"bytes":"2c00000010000000414243440800140010000400080000002a0000000000000000000000040000000100000078000000"},{"id":"growth","description":"a small initial size grows","initialSize":1,"ops":[{"op":"bytes","ref":"b","value":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255]},{"op":"table","ref":"t","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"b"}]}],"finish":{"root":"t"},"bytes":"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"},{"id":"random/000","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/001","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int32","values":[-2147483648,1,2147483647,0,0,1]},{"op":"vector","ref":"r2","type":"uint8","values":[0]},{"op":"table","ref":"r3","slots":7,"fields":[{"slot":3,"kind":"scalar","type":"uint32","value":3,"default":1},{"slot":5,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"forceDefaults":true,"bytes":"14000000100010000000040000000c0000000800100000000c00000010000000030000000100000000000000060000000000008001000000ffffff7f000000000000000001000000"},{"id":"random/002","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float32","values":[1.5,-0.5,0.0,-0.5,-0.5]},{"op":"bytes","ref":"r2","value":[190,88,6,56,207,90,224,221,59,63,120]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":5,"kind":"scalar","type":"int32","value":2147483647,"default":-4},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,1]},{"slot":4,"kind":"offset","ref":"r1"},{"slot":1,"kind":"scalar","type":"int16","value":32767,"default":32767},{"slot":2,"kind":"offset","ref":"r2"},{"slot":6,"kind":"scalar","type":"uint8","value":1,"default":0}]}],"finish":{"root":"r3"},"initialSize":16,"bytes":"1800000000001200180000000000080010000c00140007001200000000000001100000001c000000ff000100ffffff7f0b000000be580638cf5ae0dd3b3f7800050000000000c03f000000bf00000000000000bf000000bf"},{"id":"random/003","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/004","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/005","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int16","values":[-32768,3]},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":4,"kind":"scalar","type":"uint16","value":0,"default":955},{"slot":6,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,-2147483648,"0"]},{"slot":0,"kind":"offset","ref":"r1"},{"slot":3,"kind":"scalar","type":"uint8","value":0,"default":255}]}],"finish":{"root":"r2"},"bytes":"1c000000000000000000120024000800000000000700220000000c0012000000000000001c0000000100000000000080000000000000000000000000000000000200000000800300"},{"id":"random/006","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[239,32767]}]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"140000000c000000080008000000040008000000ef00ff7f"},{"id":"random/007","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[]},{"op":"table","ref":"r2","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"0c0000000800080000000400080000000400000000000000"},{"id":"random/008","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"bytes":"0c000000080000000400040004000000"},{"id":"random/009","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"uint32","value":4294967295,"default":4294967295}]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/010","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":5,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,0.0,1.5]},{"slot":3,"kind":"scalar","type":"int8","value":0,"default":0},{"slot":2,"kind":"scalar","type":"int32","value":0,"default":0},{"slot":6,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"9223372036854775807"},{"slot":4,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[5,-2147483648,"-9223372036854775808"]}]}],"finish":{"root":"r1"},"bytes":"1400000010002400000000000000000004001800100000000500000000000080000000000000008000000000000010c0000000000000c03f"},{"id":"random/011","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[0,-2147483648,"0"],[-128,-2,"0"],[-43,-1489072046,"-3611457050369711258"]]},{"op":"table","ref":"r2","slots":4,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,1.5,0.0]}]}],"finish":{"root":"r2","identifier":"MONS","sizePrefixed":true},"bytes":"5c000000140000004d4f4e5300000a0014000000100004000a000000000080440000c03f0000000004000000030000000000000000000080000000000000000080000000feffffff0000000000000000d500000052903ea76623226ff286e1cd"},{"id":"random/012","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/013","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int32","values":[-2147483648,2147483647,1,1,-2147483648]},{"op":"table","ref":"r2","slots":6,"fields":[{"slot":1,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","identifier":"1234","sizePrefixed":true},"bytes":"300000001000000031323334080008000000040008000000040000000500000000000080ffffff7f010000000100000000000080"},{"id":"random/014","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int8","values":[-128,1,1]},{"op":"table","ref":"r3","slots":5,"fields":[]},{"op":"table","ref":"r5","slots":6,"fields":[{"slot":0,"kind":"scalar","type":"uint32","value":4294967295,"default":4294967295},{"slot":5,"kind":"scalar","type":"int32","value":-2147483648,"default":2147483647},{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[72,0]}]},{"op":"table","ref":"r6","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":0}]},{"op":"string","ref":"r7","value":"😀😀"},{"op":"table","ref":"r8","slots":5,"fields":[{"slot":0,"kind":"offset","ref":"r7"},{"slot":3,"kind":"scalar","type":"int64","value":"-9223372036854775808","default":"-9223372036854775808"},{"slot":2,"kind":"scalar","type":"uint64","value":"0","default":"0"},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,0,"-2"]}]},{"op":"offsets","ref":"r4","refs":["r5","r6","r8"]},{"op":"table","ref":"r9","slots":8,"fields":[{"slot":5,"kind":"scalar","type":"int8","value":-128,"default":-128},{"slot":4,"kind":"scalar","type":"uint8","value":1,"default":0},{"slot":6,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,2147483647,"0"]},{"slot":2,"kind":"scalar","type":"int64","value":"-9223372036854775808","default":"-793879338900255131"},{"slot":7,"kind":"scalar","type":"uint64","value":"1","default":"18446744073709551615"},{"slot":3,"kind":"offset","ref":"r4"},{"slot":0,"kind":"scalar","type":"float64","value":2.5,"default":123456.789}]},{"op":"table","ref":"r10","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":0}]},{"op":"offsets","ref":"r2","refs":["r3","r9","r10"]},{"op":"string","ref":"r11","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"string","ref":"r12","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"bytes","ref":"r13","value":[219,132,163,230,117,73,35,75,172,11,174,57,44,132,154,99]},{"op":"table","ref":"r14","slots":8,"fields":[{"slot":3,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"},{"slot":5,"kind":"offset","ref":"r11"},{"slot":6,"kind":"scalar","type":"int32","value":1,"default":4},{"slot":7,"kind":"offset","ref":"r12"},{"slot":4,"kind":"offset","ref":"r13"}]}],"finish":{"root":"r14"},"initialSize":1,"bytes":"1c0000000000000014001c000000140000001800040010000c00080014000000180000002800000001000000500000007c0000004401000010000000db84a3e67549234bac0bae392c849a6328000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000028000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000003000000c400000020000000040000004cffffff14003800040000001c001000370000002400140014000000000000000000044000000000280000000100000000000000000000000000008001000000ffffff7f00000000000000000000000103000000540000003c0000000c00000008001c0018000400080000007f00000000000000feffffffffffffff000000000400000008000000f09f9880f09f988000000000e0ffffff10000c0000000000040000000000080010000000480000000000008004000400040000000300000080010100"},{"id":"random/015","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":0,"kind":"scalar","type":"float32","value":-0.5,"default":30000000000.0},{"slot":3,"kind":"scalar","type":"int16","value":-32768,"default":0}]}],"finish":{"root":"r1"},"bytes":"100000000c000c0008000000000006000c00000000000080000000bf"},{"id":"random/016","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/017","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"table","ref":"r2","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-11,1,"1"]}]}],"finish":{"root":"r2"},"bytes":"0c00000008001c000400180008000000f5000000010000000100000000000000000000000400000008000000f09f9880f09f988000000000"},{"id":"random/018","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[-2.25,-0.5,1024.0],[1.5,30000000000.0,-2.25],[0.0,1024.0,30000000000.0]]},{"op":"bytes","ref":"r3","value":[4,140,65,69,132,7]},{"op":"table","ref":"r4","slots":8,"fields":[{"slot":1,"kind":"offset","ref":"r3"},{"slot":0,"kind":"scalar","type":"float64","value":-1e-300,"default":1e+300},{"slot":6,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,2147483647,"9223372036854775807"]},{"slot":3,"kind":"scalar","type":"int32","value":-2147483648,"default":1}]},{"op":"table","ref":"r5","slots":5,"fields":[]},{"op":"string","ref":"r6","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r7","slots":8,"fields":[{"slot":4,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"4"},{"slot":2,"kind":"scalar","type":"float32","value":30000000000.0,"default":30000000000.0},{"slot":1,"kind":"scalar","type":"uint8","value":255,"default":4},{"slot":5,"kind":"scalar","type":"uint8","value":1,"default":255},{"slot":3,"kind":"offset","ref":"r6"}]},{"op":"offsets","ref":"r2","refs":["r4","r5","r7"]},{"op":"table","ref":"r8","slots":8,"fields":[{"slot":5,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r8"},"initialSize":100,"bytes":"180000000000000010000c000000040000000000000008001000000008000000b8000000030000008000000064000000140000001000180000000b00000004000c000a001000000014000000000001ffffffffffffffffff0000000028000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000004000600040000000000120024001800200000000400000000000800120000000000008001000000ffffff7fffffffffffffff7f59f3f8c21f6ea5810400000006000000048c41458407000003000000000010c0000000bf000080440000c03f7684df50000010c000000000000080447684df50"},{"id":"random/019","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD"},"forceDefaults":true,"bytes":"0c000000414243440400040004000000"},{"id":"random/020","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"forceDefaults":true,"bytes":"0c000000313233340400040004000000"},{"id":"random/021","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[76,30671]},{"slot":0,"kind":"scalar","type":"float32","value":-2.25,"default":-2.25}]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"bytes":"1c0000001000000000000a000c000400000008000a000000000010c04c00cf77"},{"id":"random/022","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"initialSize":1,"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/023","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int16","values":[32767,1,32767,32767,3]},{"op":"table","ref":"r2","slots":4,"fields":[{"slot":0,"kind":"scalar","type":"int32","value":-2147483648,"default":-2147483648},{"slot":1,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":3,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"float32","value":0.0,"default":0.0}]}],"finish":{"root":"r2"},"bytes":"100000000c000c0000000b00000004000c000000080000000000000105000000ff7f0100ff7fff7f03000000"},{"id":"random/024","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":6,"fields":[]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":5,"kind":"scalar","type":"int64","value":"1","default":"0"},{"slot":0,"kind":"scalar","type":"int32","value":-1,"default":933303417},{"slot":2,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3","sizePrefixed":true},"bytes":"34000000180000000000000010001400080000000400000000000c001000000014000000ffffffff01000000000000000400040004000000"},{"id":"random/025","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/026","description":"seeded random buffer","ops":[{"op":"table","ref":"r3","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":127,"default":-5}]},{"op":"string","ref":"r4","value":""},{"op":"table","ref":"r5","slots":5,"fields":[{"slot":2,"kind":"offset","ref":"r3"},{"slot":1,"kind":"scalar","type":"int32","value":-4,"default":458575612},{"slot":0,"kind":"scalar","type":"bool","value":false,"default":true},{"slot":4,"kind":"offset","ref":"r4"},{"slot":3,"kind":"scalar","type":"float64","value":0.1,"default":123456.789}]},{"op":"string","ref":"r6","value":"a"},{"op":"table","ref":"r7","slots":7,"fields":[{"slot":3,"kind":"offset","ref":"r5"},{"slot":2,"kind":"scalar","type":"float64","value":-1e-300,"default":-1e-300},{"slot":1,"kind":"offset","ref":"r6"}]}],"finish":{"root":"r7"},"bytes":"14000000000000000c000c0000000400000008000c00000008000000180000000100000061000e002000170018001c00040010000e0000009a9999999999b93f000000001000000000000000fcffffff10000000000000000000060008000700060000000000007f"},{"id":"random/027","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[-0.5,0.0,-2.25],[-2.25,-2.25,-2.25],[30000000000.0,1024.0,0.0]]},{"op":"bytes","ref":"r2","value":[239,70,187,98,57,103,145,190,68,170,244,74,116,15,178]},{"op":"table","ref":"r4","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-2]}]},{"op":"bytes","ref":"r5","value":[243,125,24,76,228,66,188,179,9,13,61,105,116,141]},{"op":"offsets","ref":"r6","refs":[]},{"op":"bytes","ref":"r7","value":[163,157,100,114,228]},{"op":"table","ref":"r8","slots":8,"fields":[{"slot":6,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[0.0,1.5,30000000000.0]},{"slot":2,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,-2147483648,"2"]},{"slot":7,"kind":"offset","ref":"r2"},{"slot":4,"kind":"offset","ref":"r4"},{"slot":1,"kind":"offset","ref":"r5"},{"slot":5,"kind":"offset","ref":"r6"},{"slot":3,"kind":"offset","ref":"r7"}]}],"finish":{"root":"r8","sizePrefixed":true},"forceDefaults":true,"bytes":"c40000001c000000000000001400380018000c0028000400100008002c00140014000000340000003c0000003c00000054000000580000008000000000000080020000000000000058000000000000000000c03f7684df5005000000a39d6472e4000000000000000e000000f37d184ce442bcb3090d3d69748d00000800080000000400080000000000feff0f000000ef46bb62396791be44aaf44a740fb20003000000000000bf00000000000010c0000010c0000010c0000010c07684df500000804400000000"},{"id":"random/028","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/029","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[117,134,225]},{"op":"vector","ref":"r2","type":"float64","values":[1e+300,0.1,2.5,0.0]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,-2.25,30000000000.0]},{"slot":0,"kind":"offset","ref":"r1"},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[2,3]},{"slot":5,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"initialSize":16,"bytes":"180000000000000010001c000c0010000000080000000400100000001800000002000300340000007684df50000010c07684df50040000009c7500883ce4377e9a9999999999b93f00000000000004400000000000000000030000007586e100"},{"id":"random/030","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r1","refs":[]},{"op":"vector","ref":"r2","type":"uint64","values":["0","1"]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":5,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,2147483647,"9223372036854775807"]},{"slot":2,"kind":"scalar","type":"uint8","value":1,"default":1},{"slot":0,"kind":"offset","ref":"r2"},{"slot":4,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,0.0,-0.5]},{"slot":3,"kind":"scalar","type":"uint16","value":0,"default":60821}]}],"finish":{"root":"r3","sizePrefixed":true},"bytes":"5c0000001400000010002c0014002800000006000800180010000000000000000000804400000000000000bf1800000080000000ffffff7fffffffffffffff7f1c00000002000000000000000000000001000000000000000000000000000000"},{"id":"random/031","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"uint8","value":112,"default":255},{"slot":2,"kind":"scalar","type":"uint16","value":65535,"default":1}]}],"finish":{"root":"r1"},"bytes":"1000000000000a0008000700000004000a000000ffff0070"},{"id":"random/032","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"initialSize":100,"bytes":"080000000400040004000000"},{"id":"random/033","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r1","refs":[]},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":6,"kind":"scalar","type":"float32","value":-2.25,"default":-2.25},{"slot":2,"kind":"offset","ref":"r1"},{"slot":5,"kind":"scalar","type":"int32","value":-2147483648,"default":-2147483648}]}],"finish":{"root":"r2"},"bytes":"1000000000000a0008000000000004000a0000000400000000000000"},{"id":"random/034","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"a"},{"op":"table","ref":"r3","slots":2,"fields":[]},{"op":"offsets","ref":"r2","refs":["r3"]},{"op":"bytes","ref":"r4","value":[212,248,212]},{"op":"table","ref":"r5","slots":6,"fields":[{"slot":5,"kind":"offset","ref":"r1"},{"slot":3,"kind":"scalar","type":"uint64","value":"2","default":"0"},{"slot":1,"kind":"scalar","type":"bool","value":true,"default":true},{"slot":0,"kind":"offset","ref":"r2"},{"slot":4,"kind":"offset","ref":"r4"}]}],"finish":{"root":"r5"},"bytes":"1400000010001c000800000000000c000400180010000000180000001c0000000200000000000000000000001c00000003000000d4f8d400010000000800000004000400040000000100000061000000"},{"id":"random/035","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"table","ref":"r2","slots":3,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","sizePrefixed":true},"bytes":"240000000c0000000000060008000400060000000400000008000000f09f9880f09f988000000000"},{"id":"random/036","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/037","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/038","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":3,"kind":"scalar","type":"float32","value":-2.25,"default":0.0},{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,1]},{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,1]}]}],"finish":{"root":"r1"},"bytes":"14000000100010000000000008000c00000004001000000000000100ff000100000010c0"},{"id":"random/039","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[-0.5,-2.25,-0.5],[1.5,1.5,30000000000.0],[-2.25,-2.25,30000000000.0]]},{"op":"bytes","ref":"r2","value":[136,124,8]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"forceDefaults":true,"bytes":"0c00000008000c000400080008000000080000000c00000003000000887c080003000000000000bf000010c0000000bf0000c03f0000c03f7684df50000010c0000010c07684df50"},{"id":"random/040","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[1.5,1.5,0.0],[-0.5,-0.5,30000000000.0],[-2.25,30000000000.0,1024.0],[1024.0,1.5,-2.25]]},{"op":"vector","ref":"r2","type":"int32","values":[0,-2147483648,0,2147483647]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"bytes":"0c00000008000c000400080008000000080000001800000004000000000000000000008000000000ffffff7f040000000000c03f0000c03f00000000000000bf000000bf7684df50000010c07684df5000008044000080440000c03f000010c0"},{"id":"random/041","description":"seeded random buffer","ops":[{"op":"vector","ref":"r2","type":"int32","values":[-1465634326,-2147483648,390819286,-2147483648,1,-908329708]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":0,"kind":"offset","ref":"r2"}]},{"op":"table","ref":"r4","slots":4,"fields":[{"slot":0,"kind":"offset","ref":"r3"},{"slot":2,"kind":"scalar","type":"float32","value":1.5,"default":1024.0},{"slot":3,"kind":"scalar","type":"uint16","value":1,"default":65535}]}],"finish":{"root":"r4"},"bytes":"100000000c0012000c000000080006000c000000000001000000c03f0c0000000000060008000400060000000400000006000000ea31a4a800000080d66d4b17000000800100000014fddbc9"},{"id":"random/042","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[]},{"op":"string","ref":"r2","value":"a"},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":2,"kind":"offset","ref":"r1"},{"slot":5,"kind":"scalar","type":"float64","value":1e+300,"default":-1e-300},{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,1]},{"slot":3,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[4,1,"-3"]},{"slot":1,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"bytes":"180000000000000010002c0000000400280008001c00200010000000280000000400000001000000fdffffffffffffff00000000ff0001009c7500883ce4377e0c000000010000006100000000000000"},{"id":"random/043","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[]},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":3,"kind":"scalar","type":"int16","value":1,"default":-5},{"slot":2,"kind":"scalar","type":"uint16","value":42714,"default":1},{"slot":6,"kind":"offset","ref":"r1"},{"slot":1,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":4,"kind":"scalar","type":"uint16","value":1,"default":1},{"slot":0,"kind":"scalar","type":"float64","value":0.1,"default":123456.789},{"slot":5,"kind":"scalar","type":"float64","value":2.5,"default":123456.789}]}],"finish":{"root":"r2"},"forceDefaults":true,"initialSize":1,"bytes":"1c000000000000000000120020000c0017001c001e001400040018001200000000000000000004409a9999999999b93f0100000108000000daa6010000000000"},{"id":"random/044","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"héllo"},{"op":"table","ref":"r3","slots":1,"fields":[]},{"op":"table","ref":"r5","slots":0,"fields":[]},{"op":"bytes","ref":"r6","value":[37,179,112,86,43,101,123,154,148]},{"op":"string","ref":"r8","value":"héllo"},{"op":"string","ref":"r9","value":"😀😀"},{"op":"table","ref":"r10","slots":8,"fields":[{"slot":1,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"6045071339010855667"},{"slot":6,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,2147483647,"0"]},{"slot":7,"kind":"scalar","type":"float64","value":2.5,"default":1e+300},{"slot":5,"kind":"offset","ref":"r8"},{"slot":3,"kind":"offset","ref":"r9"},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,0,"1"]}]},{"op":"table","ref":"r11","slots":5,"fields":[]},{"op":"table","ref":"r12","slots":3,"fields":[{"slot":2,"kind":"scalar","type":"uint16","value":65535,"default":1},{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[43,-4603]}]},{"op":"offsets","ref":"r7","refs":["r10","r11","r12"]},{"op":"table","ref":"r13","slots":8,"fields":[{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,2]},{"slot":0,"kind":"offset","ref":"r1"},{"slot":3,"kind":"offset","ref":"r3"},{"slot":2,"kind":"scalar","type":"uint8","value":0,"default":5},{"slot":1,"kind":"offset","ref":"r5"},{"slot":5,"kind":"scalar","type":"int64","value":"0","default":"-9223372036854775808"},{"slot":6,"kind":"offset","ref":"r6"},{"slot":7,"kind":"offset","ref":"r7"}]}],"finish":{"root":"r13"},"bytes":"1c0000000000000014002800200014001b001c0024000c00080004001400000024000000bc0000000000000000000000c000000000000000c0000000c000000001000200030000003c000000200000001000000000000a000c00060000000a000a00000000002b0005eeffff78ffffff1400400004003400000014000000180024001c0014000000800000000000000001000000000000002c00000038000000000000000000044001000000ffffff7f0000000000000000ffffffffffffffff0000000008000000f09f9880f09f9880000000000600000068c3a96c6c6f00000900000025b370562b657b9a94000000fcffffff04000400040000000600000068c3a96c6c6f0000"},{"id":"random/045","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[110,121,134,172,105]},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":0,"kind":"scalar","type":"uint8","value":1,"default":0},{"slot":4,"kind":"scalar","type":"uint8","value":19,"default":255},{"slot":3,"kind":"scalar","type":"uint32","value":0,"default":0},{"slot":2,"kind":"scalar","type":"int32","value":2147483647,"default":1},{"slot":7,"kind":"scalar","type":"int32","value":1,"default":-2147483648},{"slot":5,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","identifier":"MONS"},"initialSize":16,"bytes":"1c0000004d4f4e5314001400130000000c0000001200040000000800140000001000000001000000ffffff7f00001301050000006e7986ac69000000"},{"id":"random/046","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"bytes":"0c000000080000000400040004000000"},{"id":"random/047","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r2","slots":3,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"int16","value":0,"default":32767}]}],"finish":{"root":"r2"},"bytes":"1000000000000a000c000800000006000a0000000000000004000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/048","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"string","ref":"r3","value":"héllo"},{"op":"table","ref":"r4","slots":6,"fields":[{"slot":3,"kind":"scalar","type":"bool","value":true,"default":true},{"slot":5,"kind":"offset","ref":"r3"},{"slot":4,"kind":"scalar","type":"int16","value":-17984,"default":-11254}]},{"op":"table","ref":"r5","slots":3,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"offset","ref":"r4"},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[29,1,"-2"]}]}],"finish":{"root":"r5","identifier":"ABCD","sizePrefixed":true},"forceDefaults":true,"initialSize":100,"bytes":"9400000018000000414243440000000000000a00200004001c0018000a0000001d00000001000000feffffffffffffff000000001800000030000000100010000000000000000f0006000800100000000000c0b908000000000000010600000068c3a96c6c6f0000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/049","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/050","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":1,"kind":"scalar","type":"uint64","value":"1","default":"1"},{"slot":0,"kind":"scalar","type":"float32","value":0.0,"default":30000000000.0},{"slot":3,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,-0.5,1024.0]},{"slot":4,"kind":"scalar","type":"int64","value":"8563110158723745480","default":"0"}]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"1c000000313233340000000000000e001c001800000000000c0004000e000000c88644ef5147d676000010c0000000bf0000804400000000"},{"id":"random/051","description":"seeded random buffer","ops":[{"op":"string","ref":"r2","value":"😀😀"},{"op":"table","ref":"r4","slots":7,"fields":[{"slot":6,"kind":"scalar","type":"uint16","value":64756,"default":0},{"slot":5,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,0,"4"]}]},{"op":"offsets","ref":"r3","refs":["r4"]},{"op":"table","ref":"r5","slots":6,"fields":[{"slot":5,"kind":"scalar","type":"int16","value":-32768,"default":-32768},{"slot":2,"kind":"offset","ref":"r2"},{"slot":4,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[0,-1,"6538881519274462406"]},{"slot":3,"kind":"scalar","type":"float32","value":30000000000.0,"default":1024.0},{"slot":0,"kind":"offset","ref":"r3"}]},{"op":"offsets","ref":"r1","refs":["r5"]},{"op":"table","ref":"r6","slots":6,"fields":[{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,0]},{"slot":3,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r6"},"bytes":"100000000c000c0008000000000004000c0000000800000000000000010000001400000000000e00240004000000200008000c000e000000200000007684df5000000000ffffffffc68cb8e818c6be5a000000003c0000000100000018000000000012001c000000000000000000000004001a00120000007f000000000000000400000000000000000000000000f4fc08000000f09f9880f09f988000000000"},{"id":"random/052","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":1,"kind":"scalar","type":"float64","value":-1e-300,"default":2.5}]}],"finish":{"root":"r1"},"bytes":"0c00000008000c00000004000800000059f3f8c21f6ea581"},{"id":"random/053","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[220,207,212,104,225,27,88,118,247,191,254]},{"op":"vector","ref":"r2","type":"int32","values":[5,2147483647,2147483647]},{"op":"bytes","ref":"r3","value":[100,108,21,156,55,21,241,63,17,23,157,159,228,38,30,249,242,170,229,48]},{"op":"table","ref":"r4","slots":8,"fields":[{"slot":6,"kind":"offset","ref":"r1"},{"slot":4,"kind":"offset","ref":"r2"},{"slot":7,"kind":"offset","ref":"r3"},{"slot":1,"kind":"scalar","type":"float32","value":1024.0,"default":-0.5},{"slot":0,"kind":"scalar","type":"float64","value":1e+300,"default":1e+300}]}],"finish":{"root":"r4"},"bytes":"180000001400140000000400000000000c0000001000080014000000000080440c000000200000002c00000014000000646c159c3715f13f11179d9fe4261ef9f2aae5300300000005000000ffffff7fffffff7f0b000000dccfd468e11b5876f7bffe00"},{"id":"random/054","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[4,0]},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-1]}]}],"finish":{"root":"r1"},"bytes":"100000000c000c0000000000080004000c0000000000ffff04000000"},{"id":"random/055","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"initialSize":16,"bytes":"080000000400040004000000"},{"id":"random/056","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[0,0,"5"],[127,0,"1"],[0,0,"1"],[1,0,"-8547371398078408929"]]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":1,"kind":"scalar","type":"float32","value":1.5,"default":-0.5},{"slot":2,"kind":"scalar","type":"int32","value":0,"default":0},{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"initialSize":1,"bytes":"100000000000000008000c000400080008000000080000000000c03f04000000000000000000000005000000000000007f0000000000000001000000000000000000000000000000010000000000000001000000000000001fd733d6ffa26189"},{"id":"random/057","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[]},{"op":"table","ref":"r4","slots":6,"fields":[{"slot":2,"kind":"scalar","type":"int32","value":2147483647,"default":-2147483648}]},{"op":"offsets","ref":"r3","refs":["r4"]},{"op":"table","ref":"r6","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"0"}]},{"op":"table","ref":"r7","slots":8,"fields":[]},{"op":"table","ref":"r8","slots":8,"fields":[]},{"op":"offsets","ref":"r5","refs":["r6","r7","r8"]},{"op":"table","ref":"r9","slots":5,"fields":[{"slot":4,"kind":"scalar","type":"uint16","value":27044,"default":0},{"slot":0,"kind":"offset","ref":"r3"},{"slot":2,"kind":"offset","ref":"r5"}]},{"op":"structs","ref":"r10","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[255,-5],[1,-32768]]},{"op":"table","ref":"r11","slots":8,"fields":[{"slot":2,"kind":"scalar","type":"int16","value":1,"default":1},{"slot":1,"kind":"scalar","type":"uint64","value":"8079638945094630260","default":"0"},{"slot":0,"kind":"offset","ref":"r1"},{"slot":3,"kind":"scalar","type":"uint64","value":"5023101958615304620","default":"0"},{"slot":6,"kind":"offset","ref":"r9"},{"slot":4,"kind":"offset","ref":"r10"},{"slot":5,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,1024.0,30000000000.0]},{"slot":7,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,-32768]}]}],"finish":{"root":"r11"},"bytes":"1c000000000000001400340028002c0000001c00140008001800040014000000ff000080000010c0000080447684df502000000038000000ac89d5299ea4b545000000008800000074fbc613d0a4207002000000ff00fbff0100008000000e00100008000000040000000e000e0000000c0000003c0000000000a4690300000024000000140000000800000004000400040000000400060004000000000006000c00040006000000ffffffffffffff7f010000001000000000000a0008000000000004000a000000ffffff7f00000000"},{"id":"random/058","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"a"},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,-0.5,0.0]},{"slot":3,"kind":"offset","ref":"r1"},{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[13,-32768]}]}],"finish":{"root":"r2"},"bytes":"1400000000000e001800000000000c00080004000e0000000d0000801000000000008044000000bf000000000100000061000000"},{"id":"random/059","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":""},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":2,"kind":"scalar","type":"int16","value":32767,"default":0},{"slot":6,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,1]},{"slot":3,"kind":"scalar","type":"float64","value":123456.789,"default":0.0},{"slot":4,"kind":"scalar","type":"int8","value":1,"default":-26},{"slot":7,"kind":"scalar","type":"uint32","value":2,"default":4294967295},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,1,"-9223372036854775808"]},{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,30000000000.0,0.0]},{"slot":5,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"1c0000000000000014003c00140008003a002c002b000400360024001400000038000000000080447684df5000000000800000000100000000000000000000800200000000000001c976be9f0c24fe400000ff000100ff7f0000000000000000"},{"id":"random/060","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/061","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r2","refs":[]},{"op":"structs","ref":"r3","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[1,0],[0,32767]]},{"op":"vector","ref":"r4","type":"uint16","values":[5,31189,0,65535,65535,65535]},{"op":"table","ref":"r6","slots":6,"fields":[]},{"op":"table","ref":"r7","slots":5,"fields":[{"slot":3,"kind":"scalar","type":"int8","value":-1,"default":127},{"slot":4,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,-0.5,0.0]}]},{"op":"vector","ref":"r8","type":"float64","values":[0.0,2.5]},{"op":"structs","ref":"r9","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[0,32767],[2,-32768]]},{"op":"table","ref":"r10","slots":7,"fields":[{"slot":5,"kind":"scalar","type":"int16","value":0,"default":0},{"slot":6,"kind":"offset","ref":"r8"},{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,1.5,-0.5]},{"slot":1,"kind":"offset","ref":"r9"},{"slot":4,"kind":"scalar","type":"uint16","value":65535,"default":65535},{"slot":3,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,-2147483648,"1"]},{"slot":2,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"9223372036854775807"}]},{"op":"offsets","ref":"r5","refs":["r6","r7","r10"]},{"op":"table","ref":"r11","slots":8,"fields":[{"slot":1,"kind":"scalar","type":"int32","value":-1327754628,"default":-1327754628},{"slot":5,"kind":"offset","ref":"r2"},{"slot":3,"kind":"offset","ref":"r3"},{"slot":2,"kind":"offset","ref":"r4"},{"slot":0,"kind":"offset","ref":"r5"}]},{"op":"table","ref":"r12","slots":4,"fields":[{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,764924856,"-9223372036854775808"]},{"slot":0,"kind":"offset","ref":"r11"}]}],"finish":{"root":"r12"},"bytes":"1000000000000a001c000400000008000a0000002800000001000000b8d3972d000000000000008000000000100014000400000008000c00000010001000000010000000ac000000b8000000c000000003000000980000007c00000018000000000012002c001c0018000000040000000000280012000000010000000000008001000000000000000000000014000000000010c00000c03f000000bf10000000020000000000ff7f0200008002000000000000000000000000000000000004400000000000000e001400000000000000130004000e000000000010c0000000bf00000000000000ff0400040004000000060000000500d5790000ffffffffffff02000000010000000000ff7f00000000"},{"id":"random/062","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":1,"kind":"scalar","type":"int16","value":-32768,"default":32767}]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"0c00000008000800000006000800000000000080"},{"id":"random/063","description":"seeded random buffer","ops":[{"op":"table","ref":"r3","slots":0,"fields":[]},{"op":"bytes","ref":"r4","value":[75]},{"op":"bytes","ref":"r6","value":[]},{"op":"table","ref":"r7","slots":7,"fields":[{"slot":6,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":4,"kind":"offset","ref":"r6"},{"slot":5,"kind":"scalar","type":"uint64","value":"1","default":"18446744073709551615"}]},{"op":"bytes","ref":"r8","value":[126,158,9,167]},{"op":"offsets","ref":"r9","refs":[]},{"op":"table","ref":"r10","slots":8,"fields":[{"slot":4,"kind":"offset","ref":"r3"},{"slot":1,"kind":"scalar","type":"int8","value":1,"default":5},{"slot":0,"kind":"scalar","type":"int8","value":4,"default":-128},{"slot":7,"kind":"offset","ref":"r4"},{"slot":5,"kind":"offset","ref":"r7"},{"slot":3,"kind":"offset","ref":"r8"},{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-32768]},{"slot":6,"kind":"offset","ref":"r9"}]},{"op":"vector","ref":"r11","type":"uint32","values":[0,0,233383629,3,4,4294967295]},{"op":"table","ref":"r13","slots":7,"fields":[{"slot":2,"kind":"scalar","type":"float32","value":30000000000.0,"default":30000000000.0},{"slot":5,"kind":"scalar","type":"int8","value":-96,"default":30}]},{"op":"table","ref":"r14","slots":7,"fields":[{"slot":6,"kind":"scalar","type":"int32","value":-2147483648,"default":-2147483648},{"slot":4,"kind":"offset","ref":"r10"},{"slot":5,"kind":"offset","ref":"r11"},{"slot":3,"kind":"offset","ref":"r13"}]}],"finish":{"root":"r14","identifier":"MONS"},"bytes":"180000004d4f4e531000100000000000000004000c000800100000001c000000200000004c0000001000080000000000000000000000070010000000000000a0060000000000000000000000cd26e90d0300000004000000ffffffff140020001a001b0008000c001c00100004001400140000001c00000000000080180000002c0000003c000000000004014000000000000000040000007e9e09a71000100000000000000000000c0004001000000001000000000000000400000000000000010000004b0000000400040004000000"},{"id":"random/064","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/065","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[{"slot":1,"kind":"scalar","type":"float32","value":1.5,"default":-0.5}]}],"finish":{"root":"r1"},"bytes":"0c0000000800080000000400080000000000c03f"},{"id":"random/066","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/067","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[7,154,249,30,6,87,167,36,112,210,33,83,174,173,101,220,25]},{"op":"table","ref":"r2","slots":6,"fields":[{"slot":2,"kind":"offset","ref":"r1"},{"slot":4,"kind":"scalar","type":"uint8","value":1,"default":3}]}],"finish":{"root":"r2"},"bytes":"1400000000000e000c00000000000800000007000e000000000000010400000011000000079af91e0657a72470d22153aead65dc19000000"},{"id":"random/068","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float32","values":[1024.0,-0.5,-0.5,1024.0]},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"int64","value":"-4567134134327905034","default":"-4567134134327905034"}]}],"finish":{"root":"r2","sizePrefixed":true},"bytes":"280000000c000000080008000000040008000000040000000400000000008044000000bf000000bf00008044"},{"id":"random/069","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"forceDefaults":true,"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/070","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"bytes","ref":"r2","value":[207,73,8,193,195,217,214,2,125,46,136,227,128,150,98,6,197,121,24]},{"op":"table","ref":"r3","slots":5,"fields":[{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,-2147483648,"-9223372036854775808"]},{"slot":3,"kind":"offset","ref":"r1"},{"slot":4,"kind":"scalar","type":"int8","value":1,"default":1},{"slot":1,"kind":"scalar","type":"float64","value":0.1,"default":0.1},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"bytes":"14000000000000000c001c00040000000c0008000c000000180000002c0000007f00000000000080000000000000008013000000cf4908c1c3d9d6027d2e88e380966206c579180008000000f09f9880f09f988000000000"},{"id":"random/071","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"initialSize":100,"bytes":"080000000400040004000000"},{"id":"random/072","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":7,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[0.0,0.0,1024.0]},{"slot":0,"kind":"offset","ref":"r1"},{"slot":6,"kind":"scalar","type":"int8","value":0,"default":-116},{"slot":1,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":5,"kind":"scalar","type":"float64","value":2.5,"default":2.5},{"slot":4,"kind":"scalar","type":"int8","value":-34,"default":1},{"slot":3,"kind":"scalar","type":"int64","value":"1","default":"-9223372036854775808"},{"slot":2,"kind":"scalar","type":"uint64","value":"1","default":"18446744073709551615"}]}],"finish":{"root":"r2"},"initialSize":16,"bytes":"1c0000000000000014002c001c001a0004000c00190000001b00200014000000010000000000000001000000000000000000000000de01001000000000000000000000000000804408000000f09f9880f09f988000000000"},{"id":"random/073","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint8","values":[0,255]},{"op":"vector","ref":"r2","type":"uint16","values":[1,3032,38990]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":4,"kind":"scalar","type":"float32","value":30000000000.0,"default":1.5},{"slot":1,"kind":"scalar","type":"uint8","value":2,"default":0},{"slot":6,"kind":"offset","ref":"r1"},{"slot":0,"kind":"scalar","type":"uint32","value":0,"default":0},{"slot":5,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":7,"kind":"offset","ref":"r2"},{"slot":3,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"0"},{"slot":2,"kind":"scalar","type":"uint32","value":3452364287,"default":0}]}],"finish":{"root":"r3"},"initialSize":1,"bytes":"180000001400240000001f0004000800200000001800140014000000ffe5c6cdffffffffffffffff000000001000000018000000000000027684df50030000000100d80b4e9800000200000000ff0000"},{"id":"random/074","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"vector","ref":"r2","type":"uint64","values":["14158488149308489519","1","0","18446744073709551615","10305294252643763994","18446744073709551615"]},{"op":"string","ref":"r3","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r4","slots":4,"fields":[{"slot":3,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"},{"slot":2,"kind":"offset","ref":"r3"}]}],"finish":{"root":"r4","sizePrefixed":true},"bytes":"94000000100000000c0010000000080004000c000c0000000c0000003800000068000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000060000002f3f1cf8f40d7dc401000000000000000000000000000000ffffffffffffffff1ac7b4e285c2038fffffffffffffffff08000000f09f9880f09f988000000000"},{"id":"random/075","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"initialSize":100,"bytes":"0c000000313233340400040004000000"},{"id":"random/076","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/077","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/078","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"initialSize":1,"bytes":"0c000000080000000400040004000000"},{"id":"random/079","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[{"slot":6,"kind":"scalar","type":"float32","value":0.0,"default":-2.25}]}],"finish":{"root":"r1"},"initialSize":100,"bytes":"1800000000001200080000000000000000000000000004001200000000000000"},{"id":"random/080","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,32767]},{"slot":0,"kind":"scalar","type":"bool","value":false,"default":true}]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"initialSize":1,"bytes":"180000000c00000008000c000700080008000000000000000000ff7f"},{"id":"random/081","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/082","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/083","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":4,"kind":"scalar","type":"uint64","value":"2","default":"1"},{"slot":3,"kind":"scalar","type":"float32","value":1024.0,"default":-0.5},{"slot":0,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"18446744073709551615"}]}],"finish":{"root":"r2"},"initialSize":16,"bytes":"180000000000000000000e001800000014000000040008000e000000000080440200000000000000000000000400000008000000f09f9880f09f988000000000"},{"id":"random/084","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/085","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":1e+300,"default":0.1},{"slot":1,"kind":"scalar","type":"int32","value":-2147483648,"default":0}]}],"finish":{"root":"r1","identifier":"1234"},"initialSize":1,"bytes":"1000000031323334080010000800040008000000000000809c7500883ce4377e"},{"id":"random/086","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[{"slot":1,"kind":"scalar","type":"int16","value":-7072,"default":1}]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"1000000031323334080008000000060008000000000060e4"},{"id":"random/087","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":2.5,"default":2.5}]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/088","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float64","values":[1e+300,123456.789,2.5,0.1]},{"op":"table","ref":"r2","slots":6,"fields":[{"slot":5,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,30000000000.0,1.5]},{"slot":1,"kind":"scalar","type":"uint32","value":3423742006,"default":0},{"slot":2,"kind":"offset","ref":"r1"},{"slot":3,"kind":"scalar","type":"int8","value":1,"default":-128},{"slot":4,"kind":"scalar","type":"int32","value":3,"default":3},{"slot":0,"kind":"scalar","type":"uint32","value":3397338529,"default":3}]}],"finish":{"root":"r2"},"initialSize":100,"bytes":"1400000010002000040010000c000b000000140010000000a1457fca0000000114000000362812cc000080447684df500000c03f040000009c7500883ce4377ec976be9f0c24fe4000000000000004409a9999999999b93f"},{"id":"random/089","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[-2.25,1024.0,1024.0],[-0.5,0.0,30000000000.0],[1.5,1024.0,-0.5]]},{"op":"bytes","ref":"r2","value":[32,115,171,166,232,129,176,154,88,76,94,192,180,201,177,251,89]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":3,"kind":"offset","ref":"r1"},{"slot":5,"kind":"offset","ref":"r2"},{"slot":0,"kind":"scalar","type":"float32","value":30000000000.0,"default":-0.5}]}],"finish":{"root":"r3"},"initialSize":100,"bytes":"14000000100010000400000000000c0000000800100000007684df50080000001c000000110000002073aba6e881b09a584c5ec0b4c9b1fb5900000003000000000010c00000804400008044000000bf000000007684df500000c03f00008044000000bf"},{"id":"random/090","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int64","values":[]},{"op":"table","ref":"r2","slots":4,"fields":[{"slot":3,"kind":"offset","ref":"r1"},{"slot":0,"kind":"scalar","type":"int32","value":2147483647,"default":1}]}],"finish":{"root":"r2"},"bytes":"100000000c000c0004000000000008000c000000ffffff7f0400000000000000"},{"id":"random/091","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":""},{"op":"table","ref":"r2","slots":4,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"0c000000000006000800040006000000040000000000000000000000"},{"id":"random/092","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":0.0,"default":2.5},{"slot":1,"kind":"scalar","type":"uint16","value":65535,"default":65535}]}],"finish":{"root":"r1"},"bytes":"0c000000000006000c000400060000000000000000000000"},{"id":"random/093","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[30000000000.0,1024.0,30000000000.0],[0.0,-2.25,-2.25],[1024.0,0.0,30000000000.0]]},{"op":"bytes","ref":"r2","value":[106,68,173,0,241,103,70]},{"op":"table","ref":"r3","slots":4,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":2,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3","sizePrefixed":true},"bytes":"500000001000000000000a000c000800000004000a0000000800000010000000070000006a44ad00f1674600030000007684df50000080447684df5000000000000010c0000010c000008044000000007684df50"},{"id":"random/094","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"vector","ref":"r2","type":"bool","values":[true]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,0,"0"]},{"slot":4,"kind":"offset","ref":"r1"},{"slot":5,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3","sizePrefixed":true},"bytes":"6c000000180000000000000010001c00000000000c0000000800040010000000180000001c0000007f0000000000000000000000000000000100000001000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/095","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[60,254,187,10,132]},{"op":"bytes","ref":"r2","value":[136,229,241,79,140]},{"op":"table","ref":"r3","slots":4,"fields":[{"slot":3,"kind":"scalar","type":"bool","value":true,"default":true},{"slot":2,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"bytes":"1000000000000a000c000000040008000a00000008000000100000000500000088e5f14f8c000000050000003cfebb0a84000000"},{"id":"random/096","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":1,"kind":"scalar","type":"float32","value":-0.5,"default":1.5}]}],"finish":{"root":"r1"},"bytes":"0c000000080008000000040008000000000000bf"},{"id":"random/097","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint8","values":[0]},{"op":"bytes","ref":"r2","value":[32,10,84,73,172,67,43,68,34,169,201,86,40,65,48,226]},{"op":"string","ref":"r3","value":"héllo"},{"op":"table","ref":"r4","slots":6,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":0.0,"default":0.0},{"slot":3,"kind":"offset","ref":"r1"},{"slot":2,"kind":"offset","ref":"r2"},{"slot":4,"kind":"offset","ref":"r3"},{"slot":5,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,-1792467994,"0"]}]}],"finish":{"root":"r4","identifier":"1234"},"forceDefaults":true,"bytes":"1c000000313233340000000010002c00240000001c002000180004001000000001000000e61b2995000000000000000000000000140000001c0000002c00000000000000000000000600000068c3a96c6c6f000010000000200a5449ac432b4422a9c956284130e20100000000000000"},{"id":"random/098","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":2,"fields":[]},{"op":"table","ref":"r3","slots":5,"fields":[{"slot":4,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,1024.0,1.5]},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"forceDefaults":true,"bytes":"1400000000000e001400040000000000000008000e00000014000000000010c0000080440000c03f0400040004000000"},{"id":"random/099","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":1,"fields":[]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"bytes":"0c000000080008000000040008000000080000000400040004000000"},{"id":"random/100","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"0c000000414243440400040004000000"},{"id":"random/101","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":5,"fields":[{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,-2.25,1024.0]},{"slot":3,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":0,"kind":"scalar","type":"uint16","value":65535,"default":65535}]},{"op":"table","ref":"r4","slots":1,"fields":[]},{"op":"string","ref":"r5","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"bytes","ref":"r6","value":[144,240,34,112,9,247]},{"op":"table","ref":"r7","slots":4,"fields":[{"slot":2,"kind":"scalar","type":"int8","value":127,"default":1},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[70,0]},{"slot":1,"kind":"offset","ref":"r5"},{"slot":0,"kind":"offset","ref":"r6"}]},{"op":"table","ref":"r8","slots":8,"fields":[{"slot":0,"kind":"scalar","type":"bool","value":true,"default":true},{"slot":6,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[4,1,"-4"]}]},{"op":"offsets","ref":"r3","refs":["r4","r7","r8"]},{"op":"table","ref":"r9","slots":7,"fields":[{"slot":2,"kind":"scalar","type":"int32","value":0,"default":0},{"slot":1,"kind":"offset","ref":"r3"},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,32767]},{"slot":4,"kind":"scalar","type":"int64","value":"-3","default":"1"},{"slot":6,"kind":"scalar","type":"uint64","value":"0","default":"18446744073709551615"}]},{"op":"table","ref":"r10","slots":3,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2","r9","r10"]},{"op":"table","ref":"r11","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r11"},"bytes":"0c0000000000060008000400060000000400000003000000e8000000200000000400000038ffffff000012001c0000001800000014000c0000000400120000000000000000000000fdffffffffffffffff00ff7f0400000003000000940000003c000000180000000000120014000000000000000000000000000400120000000400000001000000fcffffffffffffff0c0014000400080013000e000c0000001000000018000000000046000000007f0600000090f0227009f70000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000040006000400000000000a0010000000000004000a0000000000c03f000010c000008044"},{"id":"random/102","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"héllo"},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":6,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[247,-32768]},{"slot":4,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"uint64","value":"0","default":"5"}]}],"finish":{"root":"r2","identifier":"1234"},"bytes":"1c0000003132333400000000100018000000000004000000100014001000000000000000000000000000000008000000f70000800600000068c3a96c6c6f0000"},{"id":"random/103","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":2,"fields":[]},{"op":"table","ref":"r3","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int64","value":"1","default":"1"}]},{"op":"table","ref":"r4","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":11,"default":1}]},{"op":"offsets","ref":"r1","refs":["r2","r3","r4"]},{"op":"table","ref":"r5","slots":2,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r5","identifier":"1234"},"bytes":"1000000031323334000006000800040006000000040000000300000024000000180000000c0000000000060008000700060000000000000bfcffffff0400040004000000"},{"id":"random/104","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/105","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":4,"fields":[{"slot":2,"kind":"scalar","type":"int8","value":3,"default":1},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[2,1,"-1"]},{"slot":0,"kind":"scalar","type":"int8","value":127,"default":-2}]},{"op":"vector","ref":"r3","type":"int64","values":["-9223372036854775808","9223372036854775807","3"]},{"op":"table","ref":"r4","slots":5,"fields":[{"slot":2,"kind":"offset","ref":"r2"},{"slot":3,"kind":"scalar","type":"uint32","value":4294967295,"default":4294967295},{"slot":1,"kind":"offset","ref":"r3"},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,2147483647,"-9043881866141191216"]},{"slot":4,"kind":"scalar","type":"bool","value":false,"default":false}]}],"finish":{"root":"r4","identifier":"MONS"},"bytes":"140000004d4f4e5300000a002000040018001c000a00000001000000ffffff7fd0b30efa5bad7d82000000000800000030000000030000000000000000000080ffffffffffffff7f03000000000000000000000000000a002000070008001f000a0000000000007f0200000001000000ffffffffffffffff0000000000000003"},{"id":"random/106","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[]},{"op":"table","ref":"r4","slots":3,"fields":[{"slot":1,"kind":"scalar","type":"bool","value":false,"default":false}]},{"op":"offsets","ref":"r3","refs":["r4"]},{"op":"table","ref":"r6","slots":1,"fields":[]},{"op":"table","ref":"r7","slots":2,"fields":[{"slot":0,"kind":"offset","ref":"r3"},{"slot":1,"kind":"offset","ref":"r6"}]},{"op":"table","ref":"r8","slots":7,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":1,"kind":"scalar","type":"int64","value":"-1","default":"1"},{"slot":6,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[161,0]},{"slot":4,"kind":"offset","ref":"r7"},{"slot":3,"kind":"scalar","type":"uint16","value":65535,"default":39465}]}],"finish":{"root":"r8","sizePrefixed":true},"bytes":"640000001c00000000000000000012001c001800100000000600080000000c00120000000000ffff1c000000a1000000ffffffffffffffff2c00000008000c0008000400080000000800000008000000f4ffffff0100000008000000040004000400000000000000"},{"id":"random/107","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/108","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":0}]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"0c00000000000600080006000600000000000000"},{"id":"random/109","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"vector","ref":"r2","type":"int16","values":[-11292]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,0]},{"slot":3,"kind":"scalar","type":"uint64","value":"0","default":"0"},{"slot":2,"kind":"scalar","type":"float64","value":-1e-300,"default":2.5},{"slot":0,"kind":"offset","ref":"r1"},{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,-17457]},{"slot":7,"kind":"scalar","type":"int8","value":127,"default":127},{"slot":4,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3","sizePrefixed":true},"bytes":"4c00000014000000100020000c0008001000000004001c00100000001c000000ff00cfbb1c00000059f3f8c21f6ea581000000000000000001000000e4d3000008000000f09f9880f09f988000000000"},{"id":"random/110","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/111","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r1","refs":[]},{"op":"vector","ref":"r2","type":"int64","values":[]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[3,32767]},{"slot":1,"kind":"scalar","type":"int16","value":32767,"default":1},{"slot":3,"kind":"offset","ref":"r1"},{"slot":5,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"initialSize":100,"bytes":"18000000000000001000140000000e0010000800000004001000000010000000140000000000ff7f0300ff7f000000000000000000000000"},{"id":"random/112","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"int16","value":0,"default":11618}]}],"finish":{"root":"r1"},"bytes":"0c00000000000600080006000600000000000000"},{"id":"random/113","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[5,18462]}]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"18000000100000000c00080000000000000004000c00000005001e48"},{"id":"random/114","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[241,57,130,203,165,201,205,213,22,150,215,200,44,236,40,90,160,62,107,91]},{"op":"table","ref":"r2","slots":6,"fields":[{"slot":5,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":4,"kind":"scalar","type":"int8","value":0,"default":127},{"slot":1,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":3,"kind":"scalar","type":"int8","value":-5,"default":-5},{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"1400000000000e000c0004000000000000000b000e000000080000000000000014000000f13982cba5c9cdd51696d7c82cec285aa03e6b5b"},{"id":"random/115","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/116","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,30000000000.0,1024.0]},{"slot":3,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"1"},{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,1.5,1.5]},{"slot":2,"kind":"scalar","type":"int64","value":"1","default":"1"}]}],"finish":{"root":"r1"},"bytes":"100000000c00280004001c00000010000c000000000080440000c03f0000c03fffffffffffffffff00000000000080447684df5000008044"},{"id":"random/117","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":3,"kind":"scalar","type":"int8","value":-128,"default":-12}]}],"finish":{"root":"r1"},"bytes":"100000000c00080000000000000007000c00000000000080"},{"id":"random/118","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/119","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":4,"kind":"scalar","type":"int64","value":"504813266877027642","default":"7068633031628675414"},{"slot":3,"kind":"scalar","type":"int64","value":"1","default":"-1"},{"slot":1,"kind":"scalar","type":"float64","value":0.1,"default":-1e-300},{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,-2147483648,"9223372036854775807"]}]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"44000000180000000000000000000e002c000000140004001c0024000e0000008000000000000080ffffffffffffff7f9a9999999999b93f01000000000000003a151cdafd740107"},{"id":"random/120","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-24,1805052154,"-9223372036854775808"]}]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"240000001000000000000000080014000000040008000000e8000000fae8966b0000000000000080"},{"id":"random/121","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[253,247,39,15,133]},{"op":"structs","ref":"r2","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[1024.0,30000000000.0,1024.0],[-2.25,1.5,-2.25]]},{"op":"bytes","ref":"r3","value":[99,138,202,136,10]},{"op":"table","ref":"r4","slots":7,"fields":[{"slot":3,"kind":"scalar","type":"int16","value":32767,"default":-32768},{"slot":0,"kind":"offset","ref":"r1"},{"slot":6,"kind":"offset","ref":"r2"},{"slot":5,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":2,"kind":"scalar","type":"float64","value":2.5,"default":0.1},{"slot":1,"kind":"offset","ref":"r3"}]}],"finish":{"root":"r4"},"bytes":"18000000000012001c001400040008001a000000000010001200000018000000000000000000044018000000300000000000ff7f05000000638aca880a00000002000000000080447684df5000008044000010c00000c03f000010c005000000fdf7270f85000000"},{"id":"random/122","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint16","values":[4,1,65535,65535,4,24399]},{"op":"string","ref":"r3","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"string","ref":"r4","value":"a"},{"op":"table","ref":"r5","slots":5,"fields":[{"slot":2,"kind":"scalar","type":"uint16","value":0,"default":30221},{"slot":0,"kind":"offset","ref":"r3"},{"slot":1,"kind":"offset","ref":"r4"},{"slot":4,"kind":"scalar","type":"uint32","value":1,"default":1}]},{"op":"vector","ref":"r6","type":"bool","values":[true,true,false,false,false,false]},{"op":"table","ref":"r7","slots":8,"fields":[{"slot":6,"kind":"scalar","type":"uint16","value":65535,"default":1},{"slot":7,"kind":"offset","ref":"r1"},{"slot":4,"kind":"offset","ref":"r5"},{"slot":5,"kind":"scalar","type":"int8","value":0,"default":1},{"slot":3,"kind":"scalar","type":"int8","value":1,"default":0},{"slot":2,"kind":"scalar","type":"uint16","value":53788,"default":0},{"slot":1,"kind":"offset","ref":"r6"}]}],"finish":{"root":"r7","identifier":"MONS"},"bytes":"1c0000004d4f4e53140018000000040008000a000c000b001600100014000000140000001cd2010020000000640000000000ffff060000000101000000000a001000080004000e000a0000000c000000100000000000000001000000610000002800000078787878787878787878787878787878787878787878787878787878787878787878787878787878000000000600000004000100ffffffff04004f5f"},{"id":"random/123","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"0c000000313233340400040004000000"},{"id":"random/124","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r1","refs":[]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":1,"kind":"scalar","type":"int64","value":"-9223372036854775808","default":"5"},{"slot":0,"kind":"offset","ref":"r1"},{"slot":4,"kind":"scalar","type":"uint16","value":0,"default":1}]}],"finish":{"root":"r2"},"bytes":"1400000000000e00180008000c000000000006000e000000000000001000000000000000000000800000000000000000"},{"id":"random/125","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/126","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"bool","value":true,"default":true},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,2147483647,"1"]}]}],"finish":{"root":"r1","identifier":"ABCD"},"forceDefaults":true,"bytes":"14000000414243440000000008001c001b0004000800000080000000ffffff7f01000000000000000000000000000001"},{"id":"random/127","description":"seeded random buffer","ops":[{"op":"table","ref":"r3","slots":1,"fields":[]},{"op":"string","ref":"r4","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"structs","ref":"r5","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[0,0]]},{"op":"table","ref":"r6","slots":8,"fields":[{"slot":5,"kind":"offset","ref":"r3"},{"slot":2,"kind":"offset","ref":"r4"},{"slot":7,"kind":"scalar","type":"uint8","value":1,"default":0},{"slot":6,"kind":"scalar","type":"int32","value":2147483647,"default":2147483647},{"slot":3,"kind":"offset","ref":"r5"},{"slot":4,"kind":"scalar","type":"float64","value":123456.789,"default":123456.789},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[0,-2147483648,"1"]}]},{"op":"vector","ref":"r7","type":"int32","values":[1,0,-2147483648,0]},{"op":"bytes","ref":"r8","value":[]},{"op":"table","ref":"r9","slots":4,"fields":[{"slot":3,"kind":"scalar","type":"int16","value":30961,"default":-32768},{"slot":0,"kind":"offset","ref":"r6"},{"slot":2,"kind":"offset","ref":"r7"},{"slot":1,"kind":"offset","ref":"r8"}]}],"finish":{"root":"r9"},"forceDefaults":true,"bytes":"14000000000000000c0014000c000400080012000c0000001000000010000000340000000000f17800000000040000000100000000000000000000800000000014003400000004002c0020001400300024002b001400000000000000000000800100000000000000c976be9f0c24fe400000000014000000ffffff7f00000001100000004000000001000000000000002800000078787878787878787878787878787878787878787878787878787878787878787878787878787878000000000400040004000000"},{"id":"random/128","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[{"slot":3,"kind":"scalar","type":"int8","value":127,"default":1}]}],"finish":{"root":"r1"},"bytes":"100000000c00080000000000000007000c0000000000007f"},{"id":"random/129","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":2,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2"]},{"op":"string","ref":"r3","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r4","slots":5,"fields":[{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-32768]},{"slot":0,"kind":"offset","ref":"r1"},{"slot":3,"kind":"offset","ref":"r3"}]}],"finish":{"root":"r4","identifier":"1234"},"bytes":"180000003132333400000e00100008000000000004000c000e0000000c000000380000000000008028000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000001000000080000000400040004000000"},{"id":"random/130","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[4,-32768]},{"slot":4,"kind":"scalar","type":"int8","value":0,"default":-1},{"slot":0,"kind":"scalar","type":"uint8","value":1,"default":0}]}],"finish":{"root":"r1"},"bytes":"1400000000000e000c00060008000000000007000e0000000000010004000080"},{"id":"random/131","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[127,-2147483648,"9223372036854775807"]]},{"op":"structs","ref":"r2","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[0,0],[185,-9117],[174,-1]]},{"op":"structs","ref":"r3","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[]},{"op":"string","ref":"r4","value":"héllo"},{"op":"table","ref":"r5","slots":5,"fields":[{"slot":1,"kind":"scalar","type":"uint8","value":0,"default":225},{"slot":2,"kind":"offset","ref":"r1"},{"slot":4,"kind":"offset","ref":"r2"},{"slot":0,"kind":"offset","ref":"r3"},{"slot":3,"kind":"offset","ref":"r4"}]}],"finish":{"root":"r5"},"bytes":"180000000000000000000e00180008001700100004000c000e000000140000001c000000200000002c000000000000000600000068c3a96c6c6f000000000000000000000300000000000000b90063dcae00ffff010000007f00000000000080ffffffffffffff7f"},{"id":"random/132","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/133","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,0,"1"]}]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"140000004142434400000a0014000000000004000a0000007f000000000000000100000000000000"},{"id":"random/134","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"initialSize":100,"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/135","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/136","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-1]},{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":0}]}],"finish":{"root":"r1"},"bytes":"0c0000000800080000000400080000000000ffff"},{"id":"random/137","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/138","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[228,166,174,251,239,169,140,203,91,11,100,242]},{"op":"table","ref":"r3","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":0,"default":-128}]},{"op":"table","ref":"r5","slots":2,"fields":[]},{"op":"table","ref":"r6","slots":5,"fields":[]},{"op":"offsets","ref":"r4","refs":["r5","r6"]},{"op":"vector","ref":"r7","type":"uint32","values":[0,1446668982,1,5,0]},{"op":"vector","ref":"r8","type":"uint64","values":["1","18132632241393339564","1","0"]},{"op":"table","ref":"r9","slots":8,"fields":[{"slot":4,"kind":"scalar","type":"float32","value":-0.5,"default":30000000000.0},{"slot":7,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r3"},{"slot":2,"kind":"offset","ref":"r4"},{"slot":6,"kind":"offset","ref":"r7"},{"slot":1,"kind":"offset","ref":"r8"},{"slot":3,"kind":"scalar","type":"int16","value":-32768,"default":-32768}]}],"finish":{"root":"r9"},"bytes":"1800000014001c00100004000c000000180000000800140014000000180000003c000000500000007000000074000000000000bf040000000100000000000000ac8c0be7f30ca4fb01000000000000000000000000000000000000000500000000000000b66a3a5601000000050000000000000002000000140000000800000004000400040000000400060004000000000006000800070006000000000000000c000000e4a6aefbefa98ccb5b0b64f2"},{"id":"random/139","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,1.5,1.5]}]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"1000000000000a0010000000000004000a0000007684df500000c03f0000c03f"},{"id":"random/140","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"initialSize":100,"bytes":"080000000400040004000000"},{"id":"random/141","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r2","value":[152,58,140,226,89,199,218,210,220,110,21,53,49,247,58,175,119,176,182,47]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,1]},{"slot":1,"kind":"scalar","type":"int16","value":1,"default":32767},{"slot":2,"kind":"scalar","type":"float64","value":0.1,"default":1e+300},{"slot":0,"kind":"scalar","type":"uint64","value":"15285301357472413677","default":"0"},{"slot":4,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,-2.25,1.5]},{"slot":3,"kind":"offset","ref":"r2"}]},{"op":"string","ref":"r4","value":"a"},{"op":"string","ref":"r5","value":"😀😀"},{"op":"table","ref":"r6","slots":4,"fields":[{"slot":3,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-0.5,-0.5,-0.5]},{"slot":1,"kind":"offset","ref":"r3"},{"slot":0,"kind":"offset","ref":"r4"},{"slot":2,"kind":"offset","ref":"r5"}]}],"finish":{"root":"r6"},"bytes":"100000000c001c0008000c00040010000c000000180000002400000038000000000000bf000000bf000000bf08000000f09f9880f09f988000000000010000006100000010002c00140026001c0004000800280010000000280000000000c03f000010c00000c03fed77f080994c20d49a9999999999b93f000001000000010014000000983a8ce259c7dad2dc6e153531f73aaf77b0b62f"},{"id":"random/142","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"0c000000414243440400040004000000"},{"id":"random/143","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/144","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[247,45,31]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,-2147483648,"0"]},{"slot":2,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,30000000000.0,0.0]}]}],"finish":{"root":"r2"},"bytes":"140000000000000000000a0024000400140010000a0000007684df507684df5000000000140000000100000000000080000000000000000003000000f72d1f00"},{"id":"random/145","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":8,"fields":[{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,0]}]},{"op":"offsets","ref":"r1","refs":["r2"]},{"op":"table","ref":"r3","slots":4,"fields":[{"slot":2,"kind":"scalar","type":"uint8","value":2,"default":0},{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[0.0,30000000000.0,-2.25]},{"slot":1,"kind":"offset","ref":"r1"},{"slot":3,"kind":"scalar","type":"bool","value":false,"default":false}]}],"finish":{"root":"r3"},"initialSize":16,"bytes":"1000000000000a0018000800040017000a00000014000000000000007684df50000010c00000000201000000140000001000080000000000000000000000040010000000ff000000"},{"id":"random/146","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/147","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[55,154,180,53,6,221,117]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":1,"kind":"scalar","type":"int32","value":2147483647,"default":-628324057},{"slot":4,"kind":"scalar","type":"uint8","value":2,"default":0},{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[78,-2]},{"slot":3,"kind":"scalar","type":"int64","value":"0","default":"9223372036854775807"}]}],"finish":{"root":"r2"},"bytes":"1400000000000e0020001c0018001200040017000e00000000000000000000000000000000004e00feff0002ffffff7f0400000007000000379ab43506dd7500"},{"id":"random/148","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[92,-3,"-9223372036854775808"],[1,-2147483648,"0"],[0,-132643231,"0"]]},{"op":"vector","ref":"r2","type":"uint16","values":[0,5,65535]},{"op":"table","ref":"r3","slots":4,"fields":[{"slot":3,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,1.5,-2.25]},{"slot":1,"kind":"offset","ref":"r2"},{"slot":2,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"14453407541935986082"}]}],"finish":{"root":"r3"},"bytes":"14000000000000000c00240014001000040020000c000000ffffffffffffffff00000000140000000000c03f0000c03f000010c0100000000300000000000500ffff0000030000005c000000fdffffff00000000000000800100000000000080000000000000000000000000610618f80000000000000000"},{"id":"random/149","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":3,"kind":"scalar","type":"uint32","value":1,"default":1941985431}]}],"finish":{"root":"r1"},"bytes":"100000000c00080000000000000004000c00000001000000"},{"id":"random/150","description":"seeded random buffer","ops":[{"op":"table","ref":"r3","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"uint32","value":2058575980,"default":0}]},{"op":"table","ref":"r4","slots":5,"fields":[{"slot":1,"kind":"scalar","type":"bool","value":false,"default":true},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,0,"-5"]},{"slot":3,"kind":"offset","ref":"r3"},{"slot":2,"kind":"scalar","type":"float64","value":123456.789,"default":0.1}]},{"op":"table","ref":"r5","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"float32","value":-0.5,"default":1.5},{"slot":2,"kind":"scalar","type":"int32","value":0,"default":0}]},{"op":"offsets","ref":"r1","refs":["r4","r5"]},{"op":"bytes","ref":"r6","value":[228,160,91,132,93,157,38,221,40,238,156,86,94,205,166,207,143]},{"op":"table","ref":"r7","slots":7,"fields":[{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-2]},{"slot":3,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r6"},{"slot":1,"kind":"scalar","type":"int16","value":-32768,"default":-32768}]}],"finish":{"root":"r7"},"bytes":"1400000010001000040000000000080000000c00100000000c000000200000000000feff11000000e4a05b845d9d26dd28ee9c565ecda6cf8f000000020000001c00000004000000c6ffffff000000bf0c00260014002500040010000c000000c976be9f0c24fe40000000001c0000007f00000000000000fbffffffffffffff0000060008000400060000006c60b37a"},{"id":"random/151","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":48,"default":-128},{"slot":5,"kind":"scalar","type":"uint16","value":59500,"default":0}]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"1c0000001400000010000800070000000000000000000400100000006ce80030"},{"id":"random/152","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":4,"fields":[]},{"op":"table","ref":"r4","slots":5,"fields":[{"slot":2,"kind":"scalar","type":"int16","value":32767,"default":-32768},{"slot":0,"kind":"scalar","type":"float64","value":-1e-300,"default":0.0}]},{"op":"table","ref":"r5","slots":8,"fields":[{"slot":4,"kind":"offset","ref":"r2"},{"slot":1,"kind":"offset","ref":"r4"}]}],"finish":{"root":"r5","sizePrefixed":true},"bytes":"4c000000180000000000000000000e000e00000004000000000008000e000000140000002800000000000a0014000400000012000a00000059f3f8c21f6ea581000000000000ff7f0400040004000000"},{"id":"random/153","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/154","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/155","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/156","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,1,"2884219402163209332"]}]}],"finish":{"root":"r1","identifier":"1234"},"forceDefaults":true,"bytes":"140000003132333400000000080014000000040008000000010000000100000074443ad843ce0628"},{"id":"random/157","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/158","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":4,"kind":"scalar","type":"float32","value":1.5,"default":1.5}]}],"finish":{"root":"r1"},"initialSize":100,"bytes":"080000000400040004000000"},{"id":"random/159","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float64","values":[]},{"op":"table","ref":"r2","slots":4,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,16800]}]}],"finish":{"root":"r2"},"bytes":"100000000000000008000c0004000800080000000100a0410400000000000000"},{"id":"random/160","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"vector","ref":"r2","type":"int8","values":[-128]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3","identifier":"1234"},"bytes":"100000003132333408000c000400080008000000080000000c0000000100000080000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/161","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"uint64","value":"18446744073709551615","default":"2"}]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"bytes":"1c0000001000000000000000000006000c00040006000000ffffffffffffffff"},{"id":"random/162","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/163","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/164","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":8,"fields":[{"slot":2,"kind":"scalar","type":"uint32","value":5,"default":0},{"slot":7,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,1,"4"]},{"slot":0,"kind":"scalar","type":"int32","value":-2147483648,"default":-2147483648},{"slot":5,"kind":"scalar","type":"int32","value":-5,"default":-5}]},{"op":"table","ref":"r3","slots":3,"fields":[{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,-0.5,-2.25]}]},{"op":"offsets","ref":"r1","refs":["r2","r3"]},{"op":"table","ref":"r4","slots":6,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":4,"kind":"scalar","type":"uint32","value":0,"default":1},{"slot":2,"kind":"scalar","type":"bool","value":false,"default":false},{"slot":1,"kind":"scalar","type":"uint8","value":3,"default":5},{"slot":3,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,0.0,-0.5]},{"slot":5,"kind":"scalar","type":"float64","value":2.5,"default":2.5}]}],"finish":{"root":"r4","sizePrefixed":true},"bytes":"8c000000180000000000000000000e001c00180013000000040014000e0000000000c03f00000000000000bf00000003000000000400000002000000380000001000000000000a0010000000000004000a0000007684df50000000bf000010c014001c000000000018000000000000000000040014000000010000000100000004000000000000000000000005000000"},{"id":"random/165","description":"seeded random buffer","ops":[{"op":"table","ref":"r3","slots":0,"fields":[]},{"op":"table","ref":"r4","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":0.1,"default":0.1},{"slot":1,"kind":"offset","ref":"r3"}]},{"op":"bytes","ref":"r5","value":[105,164,93,234,171,61,247,98,230,234,188,231,49,194,166,176,63,53]},{"op":"table","ref":"r6","slots":3,"fields":[{"slot":2,"kind":"offset","ref":"r4"},{"slot":0,"kind":"offset","ref":"r5"}]}],"finish":{"root":"r6"},"initialSize":100,"bytes":"1000000000000a000c000400000008000a00000008000000240000001200000069a45deaab3df762e6eabce731c2a6b03f350000080008000000040008000000080000000400040004000000"},{"id":"random/166","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":1,"kind":"scalar","type":"int32","value":1,"default":-2147483648}]}],"finish":{"root":"r1"},"bytes":"0c00000008000800000004000800000001000000"},{"id":"random/167","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[{"slot":1,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"9223372036854775807"}]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"0c000000414243440400040004000000"},{"id":"random/168","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":1,"fields":[]},{"op":"table","ref":"r3","slots":5,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[2,-16786]},{"slot":4,"kind":"scalar","type":"int16","value":32767,"default":32767},{"slot":0,"kind":"scalar","type":"uint16","value":65535,"default":1},{"slot":3,"kind":"offset","ref":"r2"},{"slot":2,"kind":"scalar","type":"uint32","value":4,"default":4114774665}]}],"finish":{"root":"r3","identifier":"MONS"},"bytes":"140000004d4f4e530c0014000e001000040008000c00000004000000100000000000ffff02006ebe0400040004000000"},{"id":"random/169","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/170","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r1","refs":[]},{"op":"table","ref":"r2","slots":3,"fields":[{"slot":1,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","identifier":"1234"},"bytes":"10000000313233340800080000000400080000000400000000000000"},{"id":"random/171","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[{"slot":5,"kind":"scalar","type":"int8","value":1,"default":41},{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-0.5,30000000000.0,-0.5]},{"slot":7,"kind":"scalar","type":"int64","value":"4","default":"9223372036854775807"},{"slot":1,"kind":"scalar","type":"int16","value":1,"default":2},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,1]},{"slot":6,"kind":"scalar","type":"uint64","value":"0","default":"0"}]}],"finish":{"root":"r1"},"bytes":"1c000000000000001400240000000a00140006000000230000000c001400000000000000010001000400000000000000000000bf7684df50000000bf00000001"},{"id":"random/172","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":""},{"op":"string","ref":"r2","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r3","slots":7,"fields":[{"slot":1,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":2,"kind":"scalar","type":"float64","value":1e+300,"default":-1e-300},{"slot":6,"kind":"scalar","type":"int16","value":-31993,"default":1},{"slot":5,"kind":"offset","ref":"r1"},{"slot":3,"kind":"offset","ref":"r2"},{"slot":4,"kind":"scalar","type":"uint8","value":112,"default":255}]}],"finish":{"root":"r3","identifier":"1234"},"initialSize":1,"bytes":"1c00000031323334000012002400000023001400080007000c00120012000000000000701c00000048000000000007839c7500883ce4377e00000000000000012800000078787878787878787878787878787878787878787878787878787878787878787878787878787878000000000000000000000000"},{"id":"random/173","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":4,"kind":"scalar","type":"uint16","value":1,"default":0}]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"180000003132333400000e000800000000000000000006000e00000000000100"},{"id":"random/174","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[{"slot":1,"kind":"scalar","type":"int8","value":-128,"default":-128}]}],"finish":{"root":"r1"},"initialSize":100,"bytes":"080000000400040004000000"},{"id":"random/175","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD","sizePrefixed":true},"bytes":"100000000c000000414243440400040004000000"},{"id":"random/176","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":6,"fields":[]},{"op":"table","ref":"r3","slots":0,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2","r3"]},{"op":"table","ref":"r4","slots":3,"fields":[{"slot":2,"kind":"scalar","type":"float32","value":-0.5,"default":-0.5},{"slot":1,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r4"},"bytes":"0c00000008000800000004000800000004000000020000001000000004000000fcffffff0400040004000000"},{"id":"random/177","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"table","ref":"r2","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","identifier":"MONS","sizePrefixed":true},"forceDefaults":true,"bytes":"28000000100000004d4f4e530000060008000400060000000400000008000000f09f9880f09f988000000000"},{"id":"random/178","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int16","values":[0]},{"op":"table","ref":"r2","slots":4,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"forceDefaults":true,"initialSize":100,"bytes":"0c000000000006000800040006000000040000000100000000000000"},{"id":"random/179","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":""},{"op":"table","ref":"r2","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","sizePrefixed":true},"forceDefaults":true,"bytes":"1c0000000c000000000006000800040006000000040000000000000000000000"},{"id":"random/180","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":0,"kind":"scalar","type":"uint8","value":0,"default":1},{"slot":1,"kind":"scalar","type":"int32","value":2147483647,"default":5},{"slot":3,"kind":"scalar","type":"bool","value":false,"default":true}]}],"finish":{"root":"r1"},"initialSize":16,"bytes":"100000000c0010000f000800000007000c00000000000000ffffff7f00000000"},{"id":"random/181","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":3,"fields":[{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-32768]},{"slot":2,"kind":"scalar","type":"uint64","value":"2","default":"18446744073709551615"}]},{"op":"offsets","ref":"r1","refs":["r2"]},{"op":"table","ref":"r3","slots":4,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"uint32","value":3712163936,"default":1},{"slot":3,"kind":"scalar","type":"uint64","value":"0","default":"0"}]}],"finish":{"root":"r3","sizePrefixed":true},"bytes":"440000001000000000000a000c000800000004000a000000602043dd04000000010000001000000000000a0014001000000004000a00000002000000000000000000000000000080"},{"id":"random/182","description":"seeded random buffer","ops":[{"op":"string","ref":"r2","value":"😀😀"},{"op":"table","ref":"r3","slots":3,"fields":[{"slot":1,"kind":"offset","ref":"r2"}]},{"op":"offsets","ref":"r1","refs":["r3"]},{"op":"table","ref":"r4","slots":5,"fields":[{"slot":4,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r4","identifier":"MONS","sizePrefixed":true},"bytes":"48000000180000004d4f4e5300000e000800000000000000000004000e00000004000000010000000c0000000800080000000400080000000400000008000000f09f9880f09f988000000000"},{"id":"random/183","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":1,"default":1}]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/184","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":4,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2","identifier":"1234"},"bytes":"180000003132333400000e000800000000000000000004000e00000004000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/185","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/186","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":3,"fields":[{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,0.0,1.5]}]},{"op":"bytes","ref":"r3","value":[3,207,182,6,239,6,200,22,221,7,48,142,38,78,143,6,23]},{"op":"table","ref":"r4","slots":4,"fields":[{"slot":3,"kind":"scalar","type":"uint8","value":4,"default":245},{"slot":1,"kind":"offset","ref":"r3"},{"slot":2,"kind":"scalar","type":"uint64","value":"0","default":"0"}]},{"op":"offsets","ref":"r1","refs":["r2","r4"]},{"op":"table","ref":"r5","slots":6,"fields":[{"slot":4,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r5","sizePrefixed":true},"bytes":"700000001400000000000e000800000000000000000004000e000000040000000200000040000000100000000c000c000000040000000b000c00000008000000000000041100000003cfb606ef06c816dd07308e264e8f0617000a0010000000000004000a0000000000c03f000000000000c03f"},{"id":"random/187","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":3,"kind":"scalar","type":"int8","value":81,"default":1},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,-1744766744,"-2212841975032665067"]},{"slot":1,"kind":"scalar","type":"uint16","value":17247,"default":0}]}],"finish":{"root":"r1"},"forceDefaults":true,"initialSize":100,"bytes":"100000000c0020000800060000001f000c00000000005f4380000000e8f8009815ac1aa6f2674ae10000000000000051"},{"id":"random/188","description":"seeded random buffer","ops":[{"op":"table","ref":"r3","slots":7,"fields":[]},{"op":"bytes","ref":"r4","value":[137,29,73,73,101,172,180,27]},{"op":"table","ref":"r5","slots":2,"fields":[{"slot":0,"kind":"offset","ref":"r3"},{"slot":1,"kind":"offset","ref":"r4"}]},{"op":"table","ref":"r6","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r5"}]}],"finish":{"root":"r6","identifier":"MONS"},"bytes":"100000004d4f4e530000060008000400060000000c00000008000c000800040008000000080000001400000008000000891d494965acb41b0400040004000000"},{"id":"random/189","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int16","value":2,"default":2}]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/190","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"1234","sizePrefixed":true},"bytes":"100000000c000000313233340400040004000000"},{"id":"random/191","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/192","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":5,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2"]},{"op":"table","ref":"r3","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r3","sizePrefixed":true},"forceDefaults":true,"bytes":"240000000c0000000000060008000400060000000400000001000000080000000400040004000000"},{"id":"random/193","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[62,-32768]},{"slot":0,"kind":"scalar","type":"uint32","value":1409082684,"default":1},{"slot":5,"kind":"offset","ref":"r1"},{"slot":6,"kind":"scalar","type":"float32","value":-0.5,"default":-2.25}]}],"finish":{"root":"r2"},"forceDefaults":true,"initialSize":100,"bytes":"180000000000120014000c0000000000000010000800040012000000000000bf0c0000003ce5fc533e000080280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/194","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/195","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/196","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint64","values":[]},{"op":"structs","ref":"r3","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[255,1],[0,5261],[163,10487],[1,1]]},{"op":"table","ref":"r5","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,4]}]},{"op":"bytes","ref":"r6","value":[125,140,108,172,173,28,152,98]},{"op":"table","ref":"r7","slots":8,"fields":[{"slot":1,"kind":"offset","ref":"r3"},{"slot":5,"kind":"scalar","type":"uint16","value":0,"default":0},{"slot":0,"kind":"scalar","type":"int32","value":-2147483648,"default":-2147483648},{"slot":4,"kind":"scalar","type":"float32","value":-0.5,"default":1024.0},{"slot":6,"kind":"offset","ref":"r5"},{"slot":3,"kind":"offset","ref":"r6"},{"slot":7,"kind":"scalar","type":"int8","value":121,"default":1}]},{"op":"offsets","ref":"r2","refs":["r7"]},{"op":"table","ref":"r8","slots":7,"fields":[{"slot":4,"kind":"offset","ref":"r1"},{"slot":2,"kind":"offset","ref":"r2"},{"slot":0,"kind":"scalar","type":"int32","value":2147483647,"default":2147483647}]}],"finish":{"root":"r8","identifier":"MONS","sizePrefixed":true},"initialSize":1,"bytes":"8c000000180000004d4f4e5300000e000c00000000000400000008000e00000008000000680000000100000018000000140018000000140000000800100000000c00070014000000000000791000000020000000000000bf20000000080000007d8c6cacad1c98620800080000000400080000000100040004000000ff00010000008d14a300f7280100010000000000"},{"id":"random/197","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float64","values":[0.1,0.1]},{"op":"table","ref":"r2","slots":8,"fields":[{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":64178},{"slot":7,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[116,1]},{"slot":2,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,-2.25,1.5]},{"slot":4,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,1024.0,-2.25]},{"slot":6,"kind":"scalar","type":"float64","value":1e+300,"default":123456.789},{"slot":3,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"180000001400340032000000200004001400000008002e0014000000300000009c7500883ce4377e00000000000010c000008044000010c0000010c0000010c00000c03f0000740001000000020000009a9999999999b93f9a9999999999b93f"},{"id":"random/198","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/199","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/200","description":"seeded random buffer","ops":[{"op":"string","ref":"r2","value":"héllo"},{"op":"vector","ref":"r3","type":"int8","values":[1,2,0,4,0]},{"op":"string","ref":"r4","value":"😀😀"},{"op":"table","ref":"r6","slots":0,"fields":[]},{"op":"table","ref":"r8","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int16","value":0,"default":0}]},{"op":"offsets","ref":"r7","refs":["r8"]},{"op":"table","ref":"r9","slots":8,"fields":[{"slot":2,"kind":"offset","ref":"r2"},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,32767]},{"slot":1,"kind":"offset","ref":"r3"},{"slot":4,"kind":"offset","ref":"r4"},{"slot":7,"kind":"offset","ref":"r6"},{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":1},{"slot":5,"kind":"offset","ref":"r7"}]},{"op":"table","ref":"r10","slots":5,"fields":[{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,3,"-3500227939524854769"]},{"slot":3,"kind":"scalar","type":"float32","value":0.0,"default":0.0},{"slot":1,"kind":"offset","ref":"r9"}]}],"finish":{"root":"r10"},"bytes":"1000000000000a0018000000040008000a0000002800000001000000030000000f3cb9e73bb16ccf140020000a0014001c0018001000040000000c00140000001c000000000000002400000024000000300000000000ff7f340000000100000004000000fcffffff040004000400000008000000f09f9880f09f9880000000000500000001020004000000000600000068c3a96c6c6f0000"},{"id":"random/201","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD","sizePrefixed":true},"initialSize":16,"bytes":"100000000c000000414243440400040004000000"},{"id":"random/202","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/203","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint64","values":[]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[213,-4]}]}],"finish":{"root":"r2","sizePrefixed":true},"forceDefaults":true,"bytes":"1c0000000c00000008000c000800040008000000d500fcff0400000000000000"},{"id":"random/204","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"vector","ref":"r2","type":"int16","values":[0,0]},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[13,0]},{"slot":2,"kind":"scalar","type":"int32","value":1496848895,"default":1496848895},{"slot":4,"kind":"offset","ref":"r2"},{"slot":5,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,-998315870,"1"]}]}],"finish":{"root":"r3"},"initialSize":100,"bytes":"14000000100024000000200000001c00180004001000000080000000a2e87ec40100000000000000000000000c0000000d0000000c000000020000000000000008000000f09f9880f09f988000000000"},{"id":"random/205","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[239,218,252,221,162,70,77,185,31,28,246,136,131,244,216,177,232,103,252,149]},{"op":"bytes","ref":"r3","value":[233,164,245,130,227,24]},{"op":"table","ref":"r4","slots":8,"fields":[{"slot":6,"kind":"scalar","type":"uint32","value":4294967295,"default":3780233721},{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[169,2]},{"slot":3,"kind":"scalar","type":"int32","value":2147483647,"default":2147483647},{"slot":7,"kind":"scalar","type":"float32","value":1024.0,"default":-0.5},{"slot":2,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,2147483647,"1"]},{"slot":1,"kind":"scalar","type":"int8","value":-21,"default":-4},{"slot":4,"kind":"offset","ref":"r3"}]},{"op":"vector","ref":"r5","type":"uint8","values":[1,255,0,2,1,4]},{"op":"table","ref":"r6","slots":8,"fields":[{"slot":3,"kind":"scalar","type":"int32","value":1,"default":0},{"slot":2,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r4"},{"slot":5,"kind":"offset","ref":"r5"},{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,0]}]}],"finish":{"root":"r6"},"bytes":"14000000100018000c00000010001400040008001000000001000000100000002c0000005c000000010000000600000001ff0002010400001400280000000b000c0000000400200024001c001400000024000000000000eb7f000000ffffff7f010000000000000000008044a9000200ffffffff06000000e9a4f582e318000014000000efdafcdda2464db91f1cf68883f4d8b1e867fc95"},{"id":"random/206","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/207","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"forceDefaults":true,"bytes":"0c000000313233340400040004000000"},{"id":"random/208","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[173,32767],[0,32767],[0,0],[255,0]]},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":3,"kind":"scalar","type":"float64","value":0.1,"default":123456.789},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,1,"4"]},{"slot":6,"kind":"offset","ref":"r1"},{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,1024.0,1.5]},{"slot":4,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[0,2147483647,"-3023422619598557359"]}]}],"finish":{"root":"r2","identifier":"MONS"},"bytes":"1c0000004d4f4e5300001200400024001400000034000400000020001200000000000000ffffff7f516ff27025a50ad67684df50000080440000c03f200000007f0000000100000004000000000000009a9999999999b93f0000000004000000ad00ff7f0000ff7f00000000ff000000"},{"id":"random/209","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int64","value":"0","default":"1"}]}],"finish":{"root":"r1"},"bytes":"0c000000000006000c000400060000000000000000000000"},{"id":"random/210","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"vector","ref":"r2","type":"int8","values":[1,-128,-128,-128,-128,-4]},{"op":"string","ref":"r3","value":"a"},{"op":"table","ref":"r4","slots":8,"fields":[{"slot":0,"kind":"scalar","type":"int32","value":-2147483648,"default":1},{"slot":3,"kind":"scalar","type":"int64","value":"1","default":"9223372036854775807"},{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,10311]},{"slot":7,"kind":"offset","ref":"r1"},{"slot":4,"kind":"offset","ref":"r2"},{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,-0.5,-2.25]},{"slot":6,"kind":"offset","ref":"r3"}]}],"finish":{"root":"r4"},"bytes":"1800000014002c00280008000000200014001c00040018001400000028000000000010c0000000bf000010c02000000028000000000047280100000000000000000000800100000061000000060000000180808080fc000008000000f09f9880f09f988000000000"},{"id":"random/211","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"a"},{"op":"table","ref":"r2","slots":3,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"uint16","value":1,"default":1}]}],"finish":{"root":"r2"},"bytes":"0c000000080008000000040008000000040000000100000061000000"},{"id":"random/212","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[233,98,53,79]},{"op":"structs","ref":"r3","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[0.0,-2.25,1024.0],[0.0,0.0,30000000000.0],[1024.0,1024.0,-0.5]]},{"op":"bytes","ref":"r4","value":[182,69,229,250,154]},{"op":"bytes","ref":"r6","value":[]},{"op":"table","ref":"r7","slots":6,"fields":[{"slot":0,"kind":"offset","ref":"r6"},{"slot":5,"kind":"scalar","type":"int16","value":0,"default":0},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,23057]},{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,1]},{"slot":4,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[0,1812926561,"9223372036854775807"]},{"slot":2,"kind":"scalar","type":"int8","value":-17,"default":-17}]},{"op":"table","ref":"r8","slots":7,"fields":[{"slot":2,"kind":"scalar","type":"float64","value":0.0,"default":123456.789},{"slot":4,"kind":"offset","ref":"r3"},{"slot":1,"kind":"scalar","type":"float32","value":0.0,"default":-0.5},{"slot":0,"kind":"scalar","type":"int8","value":0,"default":1},{"slot":3,"kind":"offset","ref":"r4"},{"slot":5,"kind":"offset","ref":"r7"}]},{"op":"table","ref":"r9","slots":7,"fields":[{"slot":5,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":6,"kind":"scalar","type":"int8","value":3,"default":-128},{"slot":4,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"int8","value":1,"default":1},{"slot":3,"kind":"scalar","type":"int8","value":-128,"default":-60},{"slot":0,"kind":"offset","ref":"r8"},{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[46,-32768]}]}],"finish":{"root":"r9","sizePrefixed":true},"bytes":"dc0000001c000000000000000000120018000800040000000f00100017001600120000002e0000802000000000000080a800000000000301100026000f001000180008001400040010000000300000005400000000000000000000005400000000000000000000000000000000000e0024002000180000001c0004000e0000000000000061100f6cffffffffffffff7f00000000000001000100115a040000000000000005000000b645e5fa9a0000000300000000000000000010c00000804400000000000000007684df500000804400008044000000bf04000000e962354f"},{"id":"random/213","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/214","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":3,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2"]},{"op":"table","ref":"r3","slots":3,"fields":[{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,1.5,1024.0]},{"slot":2,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r3"},"bytes":"1000000000000a0014000800000004000a000000100000007684df500000c03f0000804401000000080000000400040004000000"},{"id":"random/215","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/216","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[103,165,7,131,180]},{"op":"bytes","ref":"r2","value":[248,172,179,201,57,207,246]},{"op":"table","ref":"r3","slots":7,"fields":[{"slot":2,"kind":"offset","ref":"r1"},{"slot":3,"kind":"offset","ref":"r2"},{"slot":6,"kind":"scalar","type":"uint32","value":0,"default":1},{"slot":5,"kind":"scalar","type":"float64","value":2.5,"default":-1e-300},{"slot":4,"kind":"scalar","type":"uint32","value":0,"default":0},{"slot":1,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"-6649914928462325071"}]}],"finish":{"root":"r3"},"bytes":"1c000000000000000000120024000000040020001c0000000c00180012000000ffffffffffffff7f00000000000004400000000000000000080000001000000007000000f8acb3c939cff6000500000067a50783b4000000"},{"id":"random/217","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/218","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":127,"default":127}]}],"finish":{"root":"r1","sizePrefixed":true},"initialSize":100,"bytes":"0c000000080000000400040004000000"},{"id":"random/219","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"forceDefaults":true,"bytes":"0c000000313233340400040004000000"},{"id":"random/220","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"vector","ref":"r3","type":"uint8","values":[150]},{"op":"bytes","ref":"r4","value":[53,138,141,118,143,51,77,137,20,228,202,26,67,214,232]},{"op":"table","ref":"r6","slots":1,"fields":[]},{"op":"table","ref":"r7","slots":7,"fields":[{"slot":6,"kind":"scalar","type":"int32","value":680190986,"default":2147483647},{"slot":2,"kind":"scalar","type":"int64","value":"1","default":"-9222034732693503256"},{"slot":5,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,-2147483648,"1"]},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[88,0]}]},{"op":"offsets","ref":"r5","refs":["r6","r7"]},{"op":"offsets","ref":"r8","refs":[]},{"op":"table","ref":"r9","slots":8,"fields":[{"slot":3,"kind":"offset","ref":"r3"},{"slot":1,"kind":"offset","ref":"r4"},{"slot":5,"kind":"offset","ref":"r5"},{"slot":0,"kind":"scalar","type":"uint8","value":255,"default":0},{"slot":6,"kind":"offset","ref":"r8"}]},{"op":"vector","ref":"r10","type":"uint32","values":[4294967295,0,1,1]},{"op":"bytes","ref":"r11","value":[57,225,89,89,200,118,16,31,93,240,117,140,111,229,160,11,182,71,193,117]},{"op":"table","ref":"r12","slots":6,"fields":[{"slot":3,"kind":"scalar","type":"float32","value":1.5,"default":1.5},{"slot":4,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":2,"kind":"offset","ref":"r10"},{"slot":5,"kind":"offset","ref":"r11"}]},{"op":"vector","ref":"r13","type":"int64","values":["0","0","0","-1806902922529096715"]},{"op":"string","ref":"r14","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r15","slots":3,"fields":[{"slot":2,"kind":"offset","ref":"r13"},{"slot":0,"kind":"scalar","type":"int64","value":"1","default":"-6725400761758911181"},{"slot":1,"kind":"offset","ref":"r14"}]},{"op":"offsets","ref":"r2","refs":["r9","r12","r15"]},{"op":"bytes","ref":"r16","value":[26,87,35,60,57,115,248,28,199,17,4,29,170,11,218]},{"op":"table","ref":"r18","slots":2,"fields":[]},{"op":"bytes","ref":"r19","value":[134,27,33,239,73,221,188,231]},{"op":"table","ref":"r20","slots":8,"fields":[{"slot":5,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r2"},{"slot":1,"kind":"offset","ref":"r16"},{"slot":6,"kind":"scalar","type":"uint64","value":"0","default":"0"},{"slot":2,"kind":"offset","ref":"r18"},{"slot":3,"kind":"scalar","type":"float64","value":1e+300,"default":-1e-300},{"slot":4,"kind":"offset","ref":"r19"}]}],"finish":{"root":"r20","identifier":"ABCD"},"forceDefaults":true,"bytes":"200000004142434400000000000012003000280024001400080004002c001800120000002c0000009c7500883ce4377e00000000280000000000000000000000000000001c0000002c0000009401000008000000861b21ef49ddbce7a0feffff0f0000001a57233c3973f81cc711041daa0bda0003000000e40000008c0000001000000000000a0014000800040010000a0000001000000001000000000000003400000028000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000004000000000000000000000000000000000000000000000000000000f5bb09875d97ece61000140000000000080010000f000400100000001000000024000000000000010000c03f1400000039e15959c876101f5df0758c6fe5a00bb647c17504000000ffffffff0000000001000000010000000000120018000b0010000000140000000c0004001200000014000000000000ff10000000580000006800000000000000020000004400000018000000000012002400000000001800040000000800200012000000580000000100000000000080010000000000000001000000000000000ae48a2804000400040000000f000000358a8d768f334d8914e4ca1a43d6e8000100000096000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000000"},{"id":"random/221","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint32","values":[2,5]},{"op":"bytes","ref":"r2","value":[15,157,119,75,47,184,189]},{"op":"table","ref":"r3","slots":5,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"offset","ref":"r2"},{"slot":0,"kind":"scalar","type":"int8","value":0,"default":0}]}],"finish":{"root":"r3"},"bytes":"1000000000000a000c000000080004000a0000000800000010000000070000000f9d774b2fb8bd00020000000200000005000000"},{"id":"random/222","description":"seeded random buffer","ops":[{"op":"vector","ref":"r2","type":"float32","values":[1.5,1024.0,1024.0]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":7,"kind":"offset","ref":"r2"},{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,0]}]},{"op":"structs","ref":"r4","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[]},{"op":"bytes","ref":"r5","value":[19,55,181,93,12,164,70,252,99,23,224,147,236,154]},{"op":"table","ref":"r6","slots":7,"fields":[{"slot":4,"kind":"offset","ref":"r3"},{"slot":3,"kind":"offset","ref":"r4"},{"slot":2,"kind":"scalar","type":"int32","value":1,"default":-572788278},{"slot":6,"kind":"scalar","type":"bool","value":false,"default":true},{"slot":5,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,-32768]},{"slot":1,"kind":"offset","ref":"r5"},{"slot":0,"kind":"scalar","type":"int8","value":1,"default":1}]}],"finish":{"root":"r6"},"bytes":"18000000000012001c00000004001000140018000a000f0012000000180000000000ff0000800000010000001c000000300000000e0000001337b55d0ca446fc6317e093ec9a00000000000014000c0004000000000000000000000000000800140000000100000004000000030000000000c03f0000804400008044"},{"id":"random/223","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/224","description":"seeded random buffer","ops":[{"op":"string","ref":"r2","value":"a"},{"op":"vector","ref":"r3","type":"int64","values":["1"]},{"op":"table","ref":"r4","slots":4,"fields":[{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-2.25,-2.25,1024.0]},{"slot":2,"kind":"scalar","type":"uint32","value":1424990256,"default":4294967295},{"slot":0,"kind":"offset","ref":"r2"},{"slot":3,"kind":"offset","ref":"r3"}]},{"op":"bytes","ref":"r5","value":[221,5,185,6,217,198,49,121,88,16]},{"op":"table","ref":"r6","slots":7,"fields":[{"slot":5,"kind":"offset","ref":"r4"},{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,32767]},{"slot":6,"kind":"scalar","type":"uint32","value":4294967295,"default":4294967295},{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,0]},{"slot":1,"kind":"scalar","type":"int8","value":1,"default":1},{"slot":2,"kind":"offset","ref":"r5"}]}],"finish":{"root":"r6","identifier":"1234"},"initialSize":100,"bytes":"18000000313233341000140008000000040000000c001000100000001000000001000000ff00ff7f200000000a000000dd05b906d9c63179581000000c001c00080010000c0004000c000000180000002000000030a0ef54000010c0000010c0000080440100000001000000000000000100000061000000"},{"id":"random/225","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":0,"fields":[]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":6,"kind":"scalar","type":"int64","value":"-9223372036854775808","default":"-2984729464301590009"},{"slot":5,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"forceDefaults":true,"initialSize":100,"bytes":"180000000000120010000000000000000000000004000800120000001000000000000000000000800400040004000000"},{"id":"random/226","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/227","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float64","values":[0.0,-1e-300,123456.789]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-0.5,1.5,-2.25]},{"slot":2,"kind":"offset","ref":"r1"},{"slot":4,"kind":"scalar","type":"bool","value":true,"default":true}]}],"finish":{"root":"r2"},"bytes":"1000000000000a0014000800000004000a00000010000000000000bf0000c03f000010c003000000000000000000000059f3f8c21f6ea581c976be9f0c24fe40"},{"id":"random/228","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[2,32767]},{"slot":0,"kind":"scalar","type":"int64","value":"8782373936976511166","default":"1"}]}],"finish":{"root":"r1"},"bytes":"0c000000080014000400100008000000be40228e9042e179000000000200ff7f"},{"id":"random/229","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/230","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[84,-32768]},{"slot":0,"kind":"scalar","type":"float32","value":1.5,"default":1.5}]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"140000004142434400000a0008000000000004000a00000054000080"},{"id":"random/231","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":5,"fields":[{"slot":2,"kind":"scalar","type":"int32","value":4,"default":-5},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,32767]}]},{"op":"table","ref":"r3","slots":1,"fields":[]},{"op":"table","ref":"r4","slots":2,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2","r3","r4"]},{"op":"table","ref":"r5","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[4,2147483647,"-9223372036854775808"]}]}],"finish":{"root":"r5"},"bytes":"0c00000008001800040014000800000004000000ffffff7f00000000000000800400000003000000240000001000000004000000fcffffff04000400040000000c000c0000000000080004000c0000000100ff7f04000000"},{"id":"random/232","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"bytes":"0c000000080000000400040004000000"},{"id":"random/233","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[1.5,30000000000.0,30000000000.0],[-0.5,0.0,1024.0]]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"scalar","type":"int16","value":4,"default":32767},{"slot":0,"kind":"scalar","type":"float32","value":1024.0,"default":0.0}]},{"op":"table","ref":"r4","slots":5,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[255,0]},{"slot":3,"kind":"offset","ref":"r3"},{"slot":0,"kind":"scalar","type":"uint16","value":51991,"default":35781}]}],"finish":{"root":"r4"},"bytes":"1400000000000e00140006001000000008000c000e000000000017cb14000000ff0000001800000008000c0004000a00080000000000804400000400020000000000c03f7684df507684df50000000bf0000000000008044"},{"id":"random/234","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/235","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":-128,"default":33}]}],"finish":{"root":"r1"},"bytes":"0c00000000000600080007000600000000000080"},{"id":"random/236","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"bool","values":[false]},{"op":"table","ref":"r2","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"0c000000000006000800040006000000040000000100000000000000"},{"id":"random/237","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"float32","value":-2.25,"default":-2.25}]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/238","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/239","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[191]},{"op":"string","ref":"r2","value":"😀😀"},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":7,"kind":"offset","ref":"r1"},{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[30000000000.0,0.0,-0.5]},{"slot":4,"kind":"offset","ref":"r2"},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[0,5,"2"]},{"slot":3,"kind":"scalar","type":"uint32","value":1,"default":1}]}],"finish":{"root":"r3","identifier":"1234"},"bytes":"1c0000003132333414002c001c000400000000001800000000002800140000000000000005000000020000000000000000000000140000007684df5000000000000000bf1400000008000000f09f9880f09f98800000000001000000bf000000"},{"id":"random/240","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint64","values":["0","18446744073709551615","1","18446744073709551615","0","2"]},{"op":"vector","ref":"r2","type":"int8","values":[-16,0,1,127,0,4]},{"op":"table","ref":"r3","slots":7,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":6,"kind":"offset","ref":"r2"},{"slot":2,"kind":"scalar","type":"int8","value":0,"default":-128}]}],"finish":{"root":"r3"},"forceDefaults":true,"bytes":"180000000000120010000c000000070000000000000008001200000000000000080000001000000006000000f000017f00040000060000000000000000000000ffffffffffffffff0100000000000000ffffffffffffffff00000000000000000200000000000000"},{"id":"random/241","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/242","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":""},{"op":"table","ref":"r2","slots":2,"fields":[{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1024.0,30000000000.0,-2.25]},{"slot":1,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"forceDefaults":true,"initialSize":1,"bytes":"0c00000008001400080004000800000010000000000080447684df50000010c00000000000000000"},{"id":"random/243","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD"},"forceDefaults":true,"initialSize":1,"bytes":"0c000000414243440400040004000000"},{"id":"random/244","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"a"},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"0c000000000006000800040006000000040000000100000061000000"},{"id":"random/245","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":0.0,"default":123456.789},{"slot":2,"kind":"scalar","type":"uint16","value":0,"default":0}]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"140000004142434400000000000006000c000400060000000000000000000000"},{"id":"random/246","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,-0.5,0.0]},{"slot":0,"kind":"scalar","type":"bool","value":true,"default":true}]}],"finish":{"root":"r1"},"bytes":"0c0000000800100000000400080000000000c03f000000bf00000000"},{"id":"random/247","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"float64","values":[]},{"op":"bytes","ref":"r2","value":[137,206,253,240,227,225]},{"op":"bytes","ref":"r3","value":[180,20,169,210,207,27,56,61,98,253,37,69,101]},{"op":"bytes","ref":"r5","value":[35,76,222,126,132,32,176,6,134,30,240,80,207,126,206,13,146,160]},{"op":"table","ref":"r6","slots":5,"fields":[{"slot":0,"kind":"offset","ref":"r5"}]},{"op":"table","ref":"r7","slots":8,"fields":[{"slot":0,"kind":"scalar","type":"uint32","value":4294967295,"default":4},{"slot":7,"kind":"offset","ref":"r1"},{"slot":4,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,-0.5,-0.5]},{"slot":3,"kind":"offset","ref":"r2"},{"slot":1,"kind":"offset","ref":"r3"},{"slot":6,"kind":"scalar","type":"uint64","value":"0","default":"0"},{"slot":5,"kind":"scalar","type":"int16","value":1,"default":1},{"slot":2,"kind":"offset","ref":"r6"}]}],"finish":{"root":"r7","identifier":"1234"},"bytes":"200000003132333400000000140026002000080004000c001000000000001c00140000002800000044000000540000000000c03f000000bf000000bf50000000ffffffff0000060008000400060000000400000012000000234cde7e8420b006861ef050cf7ece0d92a000000d000000b414a9d2cf1b383d62fd2545650000000600000089cefdf0e3e1000000000000"},{"id":"random/248","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/249","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"offsets","ref":"r2","refs":[]},{"op":"string","ref":"r3","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r4","slots":4,"fields":[{"slot":0,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[1.5,1024.0,30000000000.0]},{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"offset","ref":"r2"},{"slot":3,"kind":"offset","ref":"r3"}]}],"finish":{"root":"r4"},"bytes":"100000000c001c0010000c00080004000c0000001800000044000000440000000000c03f000080447684df502800000078787878787878787878787878787878787878787878787878787878787878787878787878787878000000000000000008000000f09f9880f09f988000000000"},{"id":"random/250","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[{"slot":4,"kind":"scalar","type":"uint32","value":716284033,"default":0}]}],"finish":{"root":"r1"},"bytes":"1400000000000e000800000000000000000004000e00000081a0b12a"},{"id":"random/251","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD","sizePrefixed":true},"bytes":"100000000c000000414243440400040004000000"},{"id":"random/252","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[153,42,210]},{"op":"table","ref":"r2","slots":3,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":0,"default":-128},{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"uint32","value":4294967295,"default":0}]}],"finish":{"root":"r2","identifier":"ABCD","sizePrefixed":true},"bytes":"2c000000140000004142434400000a0010000f00080004000a000000ffffffff080000000000000003000000992ad200"},{"id":"random/253","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r2","value":[229,193,133,53,44,105,118,209,158,57,52,236,16,26,60,111,98,248]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r2"},{"slot":0,"kind":"scalar","type":"uint32","value":0,"default":3}]},{"op":"offsets","ref":"r1","refs":["r3"]},{"op":"table","ref":"r4","slots":3,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":1,"kind":"scalar","type":"int16","value":0,"default":0},{"slot":2,"kind":"scalar","type":"float64","value":123456.789,"default":123456.789}]}],"finish":{"root":"r4","sizePrefixed":true},"bytes":"480000000c00000000000600080004000600000004000000010000000c00000008000c000400080008000000000000000400000012000000e5c185352c6976d19e3934ec101a3c6f62f80000"},{"id":"random/254","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":1,"kind":"scalar","type":"bool","value":true,"default":false},{"slot":2,"kind":"scalar","type":"uint32","value":1,"default":4294967295}]}],"finish":{"root":"r1","identifier":"1234"},"bytes":"140000003132333400000a000c0000000b0004000a0000000100000000000001"},{"id":"random/255","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/256","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/257","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"uint32","values":[]},{"op":"bytes","ref":"r2","value":[133,30,162,241,110,114,114,68,172,167,236,77,19,241,253,166,70,199,93]},{"op":"vector","ref":"r3","type":"uint32","values":[0,1,4294967295,712026974,1494562774]},{"op":"structs","ref":"r4","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[-13,2006865758,"1"],[0,-2147483648,"0"],[127,2,"9223372036854775807"]]},{"op":"table","ref":"r5","slots":6,"fields":[{"slot":4,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"},{"slot":5,"kind":"offset","ref":"r3"},{"slot":2,"kind":"offset","ref":"r4"},{"slot":3,"kind":"scalar","type":"uint16","value":0,"default":0},{"slot":0,"kind":"scalar","type":"int16","value":-32768,"default":0}]}],"finish":{"root":"r5","identifier":"1234"},"forceDefaults":true,"bytes":"1c000000313233340000000010001800040010000800060014000c0010000000008000001000000044000000580000006c00000003000000f30000005e579e770100000000000000000000000000008000000000000000007f00000002000000ffffffffffffff7f00000000050000000000000001000000ffffffff5eab702ad637155913000000851ea2f16e727244aca7ec4d13f1fda646c75d0000000000"},{"id":"random/258","description":"seeded random buffer","ops":[{"op":"string","ref":"r2","value":"😀😀"},{"op":"string","ref":"r4","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"bytes","ref":"r5","value":[69,185,232,255,133,57,214,243,79,43,79,161,193]},{"op":"table","ref":"r6","slots":7,"fields":[{"slot":4,"kind":"scalar","type":"float32","value":-2.25,"default":-2.25},{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[127,2147483647,"-3"]},{"slot":2,"kind":"offset","ref":"r4"},{"slot":5,"kind":"scalar","type":"float32","value":1.5,"default":1.5},{"slot":0,"kind":"offset","ref":"r5"}]},{"op":"table","ref":"r7","slots":7,"fields":[{"slot":4,"kind":"offset","ref":"r2"},{"slot":5,"kind":"offset","ref":"r6"},{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,32767]},{"slot":3,"kind":"struct","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"value":[-0.5,30000000000.0,1.5]}]},{"op":"offsets","ref":"r1","refs":["r7"]},{"op":"table","ref":"r8","slots":4,"fields":[{"slot":0,"kind":"scalar","type":"int16","value":-32768,"default":32767},{"slot":1,"kind":"offset","ref":"r1"},{"slot":3,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[2,32767]}]}],"finish":{"root":"r8","sizePrefixed":true},"bytes":"d4000000100000000c0010000e000800000004000c0000000200ff7f0800000000000080010000001400000010001e0000001000000004001800140010000000000000bf7684df500000c03f0000ff7f140000007400000000000a00200004000c0008000a0000001c0000002c0000007f000000ffffff7ffdffffffffffffff000000000d00000045b9e8ff8539d6f34f2b4fa1c100000028000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000008000000f09f9880f09f988000000000"},{"id":"random/259","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/260","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"initialSize":16,"bytes":"080000000400040004000000"},{"id":"random/261","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"scalar","type":"bool","value":false,"default":false}]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/262","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"a"},{"op":"vector","ref":"r2","type":"bool","values":[false]},{"op":"table","ref":"r3","slots":8,"fields":[{"slot":3,"kind":"scalar","type":"uint64","value":"0","default":"1"},{"slot":1,"kind":"offset","ref":"r1"},{"slot":6,"kind":"scalar","type":"uint8","value":0,"default":0},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3","identifier":"MONS"},"initialSize":1,"bytes":"140000004d4f4e530c0014000400080000000c000c0000001000000014000000000000000000000001000000000000000100000061000000"},{"id":"random/263","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[]}],"finish":{"root":"r1","identifier":"1234"},"forceDefaults":true,"bytes":"0c000000313233340400040004000000"},{"id":"random/264","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":""},{"op":"vector","ref":"r2","type":"int8","values":[127,1,-128,127,1,-1]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"forceDefaults":true,"bytes":"0c00000008000c0008000400080000000800000010000000060000007f01807f01ff00000000000000000000"},{"id":"random/265","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/266","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[43,131,160,226,147,105,185,246,252,106]},{"op":"vector","ref":"r2","type":"int16","values":[-4,32767,-1,0]},{"op":"table","ref":"r4","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"float64","value":0.1,"default":2.5}]},{"op":"table","ref":"r6","slots":6,"fields":[{"slot":3,"kind":"scalar","type":"int8","value":-14,"default":-64},{"slot":1,"kind":"scalar","type":"bool","value":false,"default":true},{"slot":4,"kind":"scalar","type":"int32","value":0,"default":0}]},{"op":"table","ref":"r7","slots":8,"fields":[{"slot":4,"kind":"scalar","type":"int64","value":"-5787421106715939664","default":"-5787421106715939664"},{"slot":7,"kind":"scalar","type":"uint32","value":1,"default":1},{"slot":3,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"},{"slot":0,"kind":"offset","ref":"r4"},{"slot":5,"kind":"offset","ref":"r6"},{"slot":6,"kind":"scalar","type":"uint32","value":0,"default":0}]}],"finish":{"root":"r7","identifier":"ABCD","sizePrefixed":true},"bytes":"740000001c00000041424344000000001000140008000c000000100000000400100000001c0000002400000030000000380000000c00060000000400000005000c00000000f2060010000400060000009a9999999999b93f0000000004000000fcffff7fffff00000a0000002b83a0e29369b9f6fc6a0000"},{"id":"random/267","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/268","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"items":[[255,-4]]},{"op":"string","ref":"r3","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"offsets","ref":"r4","refs":[]},{"op":"table","ref":"r5","slots":5,"fields":[{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[1,-32768]},{"slot":0,"kind":"offset","ref":"r3"},{"slot":4,"kind":"offset","ref":"r4"},{"slot":3,"kind":"scalar","type":"uint32","value":3089035471,"default":0}]},{"op":"string","ref":"r6","value":""},{"op":"table","ref":"r8","slots":2,"fields":[]},{"op":"bytes","ref":"r9","value":[8,147,225,41,138,207,166,242,123,142,69,22,90,251,152,131,72]},{"op":"table","ref":"r10","slots":8,"fields":[{"slot":2,"kind":"scalar","type":"uint32","value":1,"default":2},{"slot":6,"kind":"scalar","type":"uint8","value":44,"default":0},{"slot":3,"kind":"offset","ref":"r6"},{"slot":4,"kind":"scalar","type":"uint16","value":17894,"default":4},{"slot":5,"kind":"scalar","type":"int32","value":2147483647,"default":0},{"slot":7,"kind":"offset","ref":"r8"},{"slot":1,"kind":"scalar","type":"uint8","value":99,"default":116},{"slot":0,"kind":"offset","ref":"r9"}]},{"op":"offsets","ref":"r2","refs":["r5","r10"]},{"op":"table","ref":"r11","slots":2,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":0,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r11","identifier":"MONS"},"initialSize":1,"bytes":"100000004d4f4e5308000c00040008000800000008000000c40000000200000074000000180000001400240004000b0020001800160010001f000c0014000000200000000000006334000000ffffff7f0000e6452c0000000000002c01000000110000000893e1298acfa6f27b8e45165afb98834800000004000400040000000000000000000e0014000c0000001000040008000e000000cff01eb80c0000000c000000010000800000000028000000787878787878787878787878787878787878787878787878787878787878787878787878787878780000000001000000ff00fcff"},{"id":"random/269","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/270","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"bytes":"0c000000080000000400040004000000"},{"id":"random/271","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":1,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[1,-2147483648,"-9223372036854775808"]}]}],"finish":{"root":"r1","identifier":"ABCD","sizePrefixed":true},"bytes":"24000000100000004142434408001400000004000800000001000000000000800000000000000080"},{"id":"random/272","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r2","value":[153,122,54,219,188,33,194,240,255,193,93,74]},{"op":"vector","ref":"r3","type":"float64","values":[0.0,0.1]},{"op":"table","ref":"r4","slots":8,"fields":[{"slot":2,"kind":"scalar","type":"uint32","value":0,"default":0},{"slot":7,"kind":"scalar","type":"float32","value":30000000000.0,"default":1.5},{"slot":6,"kind":"scalar","type":"uint16","value":1,"default":1},{"slot":5,"kind":"offset","ref":"r2"},{"slot":4,"kind":"scalar","type":"float32","value":1.5,"default":1.5},{"slot":1,"kind":"offset","ref":"r3"}]},{"op":"table","ref":"r5","slots":7,"fields":[{"slot":2,"kind":"offset","ref":"r4"},{"slot":4,"kind":"struct","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"value":[-128,0,"1"]}]}],"finish":{"root":"r5","identifier":"1234"},"bytes":"1c000000313233340000000000000e001c00000000001800000004000e0000008000000000000000010000000000000000000000180000001400100000000400000000000000080000000c00140000000c0000001c0000007684df500200000000000000000000009a9999999999b93f0c000000997a36dbbc21c2f0ffc15d4a"},{"id":"random/273","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"uint16","value":0,"default":0}]}],"finish":{"root":"r1","identifier":"ABCD","sizePrefixed":true},"bytes":"100000000c000000414243440400040004000000"},{"id":"random/274","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":3,"fields":[{"slot":2,"kind":"scalar","type":"uint8","value":255,"default":1},{"slot":0,"kind":"scalar","type":"float32","value":30000000000.0,"default":30000000000.0},{"slot":1,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[119,32767]}]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"1000000000000a001000080004000f000a0000007700ff7f7684df50000000ff"},{"id":"random/275","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[]},{"op":"table","ref":"r3","slots":2,"fields":[{"slot":1,"kind":"scalar","type":"int8","value":124,"default":5},{"slot":0,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,-4]}]},{"op":"table","ref":"r4","slots":8,"fields":[{"slot":5,"kind":"offset","ref":"r1"},{"slot":3,"kind":"offset","ref":"r3"}]}],"finish":{"root":"r4"},"bytes":"1400000010000c0000000000000004000000080010000000100000001800000008000c0006000b000800000000000000fcff007c00000000"},{"id":"random/276","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/277","description":"seeded random buffer","ops":[{"op":"vector","ref":"r1","type":"int16","values":[]},{"op":"string","ref":"r2","value":"a"},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":1,"kind":"offset","ref":"r1"},{"slot":4,"kind":"offset","ref":"r2"}]}],"finish":{"root":"r3"},"bytes":"1400000000000e000c00000008000000000004000e000000080000000c000000010000006100000000000000"},{"id":"random/278","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[25,86,157,36]},{"op":"table","ref":"r2","slots":1,"fields":[{"slot":0,"kind":"offset","ref":"r1"}]}],"finish":{"root":"r2"},"bytes":"0c000000000006000800040006000000040000000400000019569d24"},{"id":"random/279","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/280","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"bool","value":false,"default":false}]}],"finish":{"root":"r1","identifier":"ABCD"},"forceDefaults":true,"bytes":"100000004142434400000600080007000600000000000000"},{"id":"random/281","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"initialSize":16,"bytes":"0c000000080000000400040004000000"},{"id":"random/282","description":"seeded random buffer","ops":[{"op":"offsets","ref":"r1","refs":[]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":2,"kind":"offset","ref":"r1"},{"slot":4,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,32767]},{"slot":0,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"-8037091822361004774"}]}],"finish":{"root":"r2"},"bytes":"1400000000000e001800040000001400000010000e000000ffffffffffffff7f000000000000ff7f0400000000000000"},{"id":"random/283","description":"seeded random buffer","ops":[{"op":"bytes","ref":"r1","value":[19,90,95,150,193,148,59,27,200,18,7]},{"op":"table","ref":"r2","slots":7,"fields":[{"slot":5,"kind":"scalar","type":"uint64","value":"2023395951970458373","default":"18446744073709551615"},{"slot":3,"kind":"scalar","type":"bool","value":false,"default":true},{"slot":6,"kind":"scalar","type":"int16","value":32767,"default":1},{"slot":1,"kind":"offset","ref":"r1"},{"slot":2,"kind":"scalar","type":"uint16","value":0,"default":1}]}],"finish":{"root":"r2"},"bytes":"180000000000120018000000080006000f00000010000c00120000000000000010000000ff7f0000059b29dde58b141c0b000000135a5f96c1943b1bc8120700"},{"id":"random/284","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":7,"fields":[]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"0c0000004d4f4e530400040004000000"},{"id":"random/285","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[{"slot":2,"kind":"scalar","type":"uint8","value":0,"default":0}]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"bytes":"180000001000000000000a0008000000000007000a00000000000000"},{"id":"random/286","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/287","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[{"slot":0,"kind":"scalar","type":"int16","value":-32768,"default":0}]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"0c00000000000600080006000600000000000080"},{"id":"random/288","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":2,"fields":[{"slot":1,"kind":"scalar","type":"int64","value":"-9223372036854775808","default":"239844259110824918"},{"slot":0,"kind":"scalar","type":"float32","value":1024.0,"default":-0.5}]}],"finish":{"root":"r1","identifier":"MONS"},"bytes":"100000004d4f4e53080010000400080008000000000080440000000000000080"},{"id":"random/289","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"},{"id":"random/290","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","sizePrefixed":true},"forceDefaults":true,"initialSize":100,"bytes":"0c000000080000000400040004000000"},{"id":"random/291","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":8,"fields":[]}],"finish":{"root":"r1"},"initialSize":1,"bytes":"080000000400040004000000"},{"id":"random/292","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":6,"fields":[]}],"finish":{"root":"r1","identifier":"ABCD"},"bytes":"0c000000414243440400040004000000"},{"id":"random/293","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":4,"fields":[{"slot":0,"kind":"scalar","type":"uint8","value":0,"default":3},{"slot":1,"kind":"scalar","type":"uint8","value":255,"default":0},{"slot":2,"kind":"scalar","type":"uint8","value":255,"default":1}]}],"finish":{"root":"r1"},"initialSize":16,"bytes":"1000000000000a0008000700060005000a00000000ffff00"},{"id":"random/294","description":"seeded random buffer","ops":[{"op":"string","ref":"r1","value":"😀😀"},{"op":"string","ref":"r2","value":"héllo"},{"op":"table","ref":"r3","slots":6,"fields":[{"slot":4,"kind":"offset","ref":"r1"},{"slot":1,"kind":"offset","ref":"r2"},{"slot":5,"kind":"scalar","type":"int64","value":"3959821641074866621","default":"0"}]}],"finish":{"root":"r3","sizePrefixed":true},"forceDefaults":true,"initialSize":100,"bytes":"4c00000018000000000000001000180000001000000000001400040010000000bdf92b72cd1cf4360000000008000000100000000600000068c3a96c6c6f000008000000f09f9880f09f988000000000"},{"id":"random/295","description":"seeded random buffer","ops":[{"op":"table","ref":"r2","slots":7,"fields":[{"slot":0,"kind":"scalar","type":"int8","value":0,"default":127}]},{"op":"table","ref":"r4","slots":2,"fields":[]},{"op":"string","ref":"r6","value":""},{"op":"structs","ref":"r7","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[-128,-2147483648,"0"],[-4,-154767893,"-9223372036854775808"],[5,2147483647,"9223372036854775807"],[0,2147483647,"5351728431980867761"]]},{"op":"table","ref":"r9","slots":4,"fields":[{"slot":2,"kind":"struct","struct":{"size":4,"align":2,"fields":[{"type":"uint8","offset":0},{"type":"int16","offset":2}]},"value":[0,32767]},{"slot":0,"kind":"scalar","type":"int16","value":32043,"default":32767}]},{"op":"string","ref":"r10","value":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},{"op":"table","ref":"r11","slots":8,"fields":[{"slot":3,"kind":"offset","ref":"r6"},{"slot":4,"kind":"offset","ref":"r7"},{"slot":7,"kind":"offset","ref":"r9"},{"slot":0,"kind":"scalar","type":"int32","value":2147483647,"default":667497958},{"slot":1,"kind":"offset","ref":"r10"},{"slot":2,"kind":"scalar","type":"uint16","value":1,"default":3}]},{"op":"table","ref":"r12","slots":6,"fields":[{"slot":5,"kind":"offset","ref":"r4"},{"slot":2,"kind":"scalar","type":"int32","value":-2147483648,"default":-2147483648},{"slot":3,"kind":"scalar","type":"float64","value":0.0,"default":0.0},{"slot":0,"kind":"scalar","type":"uint8","value":0,"default":171},{"slot":4,"kind":"offset","ref":"r11"},{"slot":1,"kind":"scalar","type":"uint16","value":0,"default":0}]},{"op":"table","ref":"r13","slots":5,"fields":[]},{"op":"offsets","ref":"r1","refs":["r2","r12","r13"]},{"op":"bytes","ref":"r15","value":[57,236,217,53,135,208,132,80,121,122,27,51,107,38,126,175,85,129,197,37]},{"op":"structs","ref":"r16","struct":{"size":12,"align":4,"fields":[{"type":"float32","offset":0},{"type":"float32","offset":4},{"type":"float32","offset":8}]},"items":[[1024.0,-0.5,1024.0],[1.5,-2.25,1.5],[30000000000.0,-0.5,0.0]]},{"op":"table","ref":"r17","slots":7,"fields":[{"slot":1,"kind":"offset","ref":"r15"},{"slot":3,"kind":"offset","ref":"r16"},{"slot":5,"kind":"scalar","type":"float64","value":0.1,"default":-1e-300}]},{"op":"offsets","ref":"r18","refs":[]},{"op":"table","ref":"r19","slots":7,"fields":[{"slot":0,"kind":"offset","ref":"r1"},{"slot":5,"kind":"scalar","type":"int32","value":-2147483648,"default":1},{"slot":3,"kind":"offset","ref":"r17"},{"slot":6,"kind":"scalar","type":"uint32","value":2,"default":2},{"slot":2,"kind":"offset","ref":"r18"},{"slot":4,"kind":"scalar","type":"uint8","value":0,"default":0},{"slot":1,"kind":"scalar","type":"float32","value":30000000000.0,"default":1024.0}]}],"finish":{"root":"r19"},"initialSize":100,"bytes":"1800000000000000100018001400040008000c0000001000100000007684df501000000020000000000000806c00000000000000100014000000100000000c0000000400100000009a9999999999b93f080000002c0000000300000000008044000000bf000080440000c03f000010c00000c03f7684df50000000bf000000001400000039ecd93587d08450797a1b336b267eaf5581c525030000000401000020000000080000000400040004000000100010000b0000000000000004000c00100000002000000000000000c800000014001c000c000800060018001400000000001000140000000000010014000000ffffff7f440000004c0000008c000000280000007878787878787878787878787878787878787878787878787878787878787878787878787878787800000a000c000600000008000a00000000002b7d0000ff7f0400000080000000000000800000000000000000fc000000eb6dc6f6000000000000008005000000ffffff7fffffffffffffff7f00000000ffffff7fb1f0937aa728454a0000000000000000040006000400000000000600080007000600000000000000"},{"id":"random/296","description":"seeded random buffer","ops":[{"op":"structs","ref":"r1","struct":{"size":16,"align":8,"fields":[{"type":"int8","offset":0},{"type":"int32","offset":4},{"type":"int64","offset":8}]},"items":[[-128,1,"0"],[-128,2147483647,"1"]]},{"op":"table","ref":"r2","slots":5,"fields":[{"slot":2,"kind":"offset","ref":"r1"},{"slot":1,"kind":"scalar","type":"int64","value":"9223372036854775807","default":"9223372036854775807"}]}],"finish":{"root":"r2"},"bytes":"140000000000000000000a0008000000000004000a00000004000000020000008000000001000000000000000000000080000000ffffff7f0100000000000000"},{"id":"random/297","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":0,"fields":[]}],"finish":{"root":"r1"},"bytes":"080000000400040004000000"},{"id":"random/298","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":5,"fields":[{"slot":4,"kind":"scalar","type":"int32","value":1,"default":1354460790}]}],"finish":{"root":"r1"},"bytes":"1400000000000e000800000000000000000004000e00000001000000"},{"id":"random/299","description":"seeded random buffer","ops":[{"op":"table","ref":"r1","slots":1,"fields":[]}],"finish":{"root":"r1"},"forceDefaults":true,"bytes":"080000000400040004000000"}]} From 3948e0756faf960ed3ec45aa9f27a70c1074dc42 Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Sat, 14 Nov 2026 17:59:13 +0000 Subject: [PATCH 03/11] refactor(encoding): harden FlatBuffers reads and builder limits Vectors and structs carry their size and reject reads outside it, tables fail past maxDepth with a Limit error, decode rethrows Usage errors, and the builder rejects tables a vtable can't address, a second finish and non-power-of-two alignments. Table, Vector and Struct become interfaces, make becomes makeBuilder and the shared Options interface is inlined. --- packages/effect/src/encoding/FlatBuffers.ts | 458 ++++++++++++------ .../effect/test/encoding/FlatBuffers.test.ts | 100 +++- 2 files changed, 374 insertions(+), 184 deletions(-) diff --git a/packages/effect/src/encoding/FlatBuffers.ts b/packages/effect/src/encoding/FlatBuffers.ts index d65c91509dd..d5011ea83c0 100644 --- a/packages/effect/src/encoding/FlatBuffers.ts +++ b/packages/effect/src/encoding/FlatBuffers.ts @@ -26,7 +26,7 @@ * import { Result } from "effect" * * // table Monster { name: string; hp: short = 100; inventory: [ubyte]; } - * const builder = FlatBuffers.make() + * const builder = FlatBuffers.makeBuilder() * const name = builder.createString("Orc") * const inventory = builder.createBytes(Uint8Array.of(1, 2, 3)) * builder.startTable(3) @@ -48,7 +48,8 @@ * * Every read is bounds-checked: malformed or hostile input throws a * {@link FlatBuffersError} (or makes {@link decode} fail) instead of reading - * outside the buffer. Strings must be valid UTF-8. 64-bit integers are + * outside the buffer or the vector or struct being read. Tables nested deeper + * than `maxDepth` fail too. Strings must be valid UTF-8. 64-bit integers are * `bigint`s. * * @stability experimental @@ -71,16 +72,19 @@ const FlatBuffersErrorTypeId = "~effect/encoding/FlatBuffers/FlatBuffersError" * - `InvalidVtable`: a table's vtable has an impossible size. * - `InvalidUtf8`: a string is not valid UTF-8. * - `Identifier`: the buffer's file identifier is not the expected one. - * - `Usage`: the builder was called out of order (a table inside a table, a - * struct that isn't the last thing written, an identifier that isn't four - * bytes) or the buffer would exceed 2 GiB. + * - `Limit`: tables are nested deeper than `maxDepth`. + * - `Usage`: a bug in the caller: the builder was called out of order (a + * table inside a table, a struct that isn't the last thing written, an + * identifier that isn't four bytes), a table or buffer would outgrow the + * format, or a read doesn't match the shape it asked for (a vector read at + * another width, a struct read past its size). * * @stability experimental * @category errors * @since 4.1.5 */ export class FlatBuffersError extends Data.TaggedError("FlatBuffersError")<{ - readonly kind: "OutOfBounds" | "InvalidVtable" | "InvalidUtf8" | "Identifier" | "Usage" + readonly kind: "OutOfBounds" | "InvalidVtable" | "InvalidUtf8" | "Identifier" | "Limit" | "Usage" readonly message: string }> { /** @@ -106,9 +110,21 @@ const fail = (kind: FlatBuffersError["kind"], message: string): never => { throw new FlatBuffersError({ kind, message }) } +const positive = (name: string, n: number): void => { + if (!Number.isInteger(n) || n < 1) fail("Usage", `${name} must be a positive integer, got ${n}`) +} + const utf8 = new TextDecoder("utf-8", { fatal: true }) +const lenientUtf8 = new TextDecoder() const encoder = new TextEncoder() +/** The buffer every reader of one {@link root} shares. */ +interface Source { + readonly bytes: Uint8Array + readonly view: DataView + readonly maxDepth: number +} + const check = (view: DataView, at: number, size: number): void => { if (at < 0 || size < 0 || at + size > view.byteLength) { fail("OutOfBounds", `${size} bytes at ${at} lie outside the ${view.byteLength}-byte buffer`) @@ -121,12 +137,12 @@ const indirect = (view: DataView, at: number): number => { return at + view.getUint32(at, true) } -const readString = (bytes: Uint8Array, view: DataView, start: number): string => { - check(view, start, 4) - const length = view.getUint32(start, true) - check(view, start + 4, length) +const readString = (source: Source, start: number): string => { + check(source.view, start, 4) + const length = source.view.getUint32(start, true) + check(source.view, start + 4, length) try { - return utf8.decode(bytes.subarray(start + 4, start + 4 + length)) + return utf8.decode(source.bytes.subarray(start + 4, start + 4 + length)) } catch { return fail("InvalidUtf8", `the string at ${start} is not valid UTF-8`) } @@ -138,169 +154,223 @@ const readString = (bytes: Uint8Array, view: DataView, start: number): string => /** * Reads fields at fixed byte offsets: the fields of a struct, stored inline - * in a table or a vector. + * in a table or a vector. Reads outside the struct's size throw a `Usage` + * {@link FlatBuffersError}. * * @stability experimental * @category reading * @since 4.1.5 */ -export class Struct { +export interface Struct { /** The whole buffer. */ readonly buffer: Uint8Array /** Where the struct starts in {@link buffer}. */ readonly position: number - private readonly view: DataView + /** The `bool` at byte `offset` of the struct. */ + bool(offset: number): boolean + /** The `byte` at byte `offset` of the struct. */ + int8(offset: number): number + /** The `ubyte` at byte `offset` of the struct. */ + uint8(offset: number): number + /** The `short` at byte `offset` of the struct. */ + int16(offset: number): number + /** The `ushort` at byte `offset` of the struct. */ + uint16(offset: number): number + /** The `int` at byte `offset` of the struct. */ + int32(offset: number): number + /** The `uint` at byte `offset` of the struct. */ + uint32(offset: number): number + /** The `long` at byte `offset` of the struct. */ + int64(offset: number): bigint + /** The `ulong` at byte `offset` of the struct. */ + uint64(offset: number): bigint + /** The `float` at byte `offset` of the struct. */ + float32(offset: number): number + /** The `double` at byte `offset` of the struct. */ + float64(offset: number): number + /** The struct of `size` bytes nested at byte `offset` of this struct. */ + struct(offset: number, size: number): Struct +} + +class StructImpl implements Struct { + readonly position: number + private readonly source: Source + private readonly size: number - constructor(buffer: Uint8Array, view: DataView, position: number) { - this.buffer = buffer - this.view = view + /** The caller has checked that the struct lies inside the buffer. */ + constructor(source: Source, position: number, size: number) { + this.source = source this.position = position + this.size = size + } + + get buffer(): Uint8Array { + return this.source.bytes } private at(offset: number, size: number): number { - const at = this.position + offset - check(this.view, at, size) - return at + if (!Number.isInteger(offset) || offset < 0 || offset + size > this.size) { + fail("Usage", `${size} bytes at ${offset} lie outside the ${this.size}-byte struct`) + } + return this.position + offset } - /** The `bool` at byte `offset` of the struct. */ bool(offset: number): boolean { - return this.view.getUint8(this.at(offset, 1)) !== 0 + return this.source.view.getUint8(this.at(offset, 1)) !== 0 } - /** The `byte` at byte `offset` of the struct. */ int8(offset: number): number { - return this.view.getInt8(this.at(offset, 1)) + return this.source.view.getInt8(this.at(offset, 1)) } - /** The `ubyte` at byte `offset` of the struct. */ uint8(offset: number): number { - return this.view.getUint8(this.at(offset, 1)) + return this.source.view.getUint8(this.at(offset, 1)) } - /** The `short` at byte `offset` of the struct. */ int16(offset: number): number { - return this.view.getInt16(this.at(offset, 2), true) + return this.source.view.getInt16(this.at(offset, 2), true) } - /** The `ushort` at byte `offset` of the struct. */ uint16(offset: number): number { - return this.view.getUint16(this.at(offset, 2), true) + return this.source.view.getUint16(this.at(offset, 2), true) } - /** The `int` at byte `offset` of the struct. */ int32(offset: number): number { - return this.view.getInt32(this.at(offset, 4), true) + return this.source.view.getInt32(this.at(offset, 4), true) } - /** The `uint` at byte `offset` of the struct. */ uint32(offset: number): number { - return this.view.getUint32(this.at(offset, 4), true) + return this.source.view.getUint32(this.at(offset, 4), true) } - /** The `long` at byte `offset` of the struct. */ int64(offset: number): bigint { - return this.view.getBigInt64(this.at(offset, 8), true) + return this.source.view.getBigInt64(this.at(offset, 8), true) } - /** The `ulong` at byte `offset` of the struct. */ uint64(offset: number): bigint { - return this.view.getBigUint64(this.at(offset, 8), true) + return this.source.view.getBigUint64(this.at(offset, 8), true) } - /** The `float` at byte `offset` of the struct. */ float32(offset: number): number { - return this.view.getFloat32(this.at(offset, 4), true) + return this.source.view.getFloat32(this.at(offset, 4), true) } - /** The `double` at byte `offset` of the struct. */ float64(offset: number): number { - return this.view.getFloat64(this.at(offset, 8), true) + return this.source.view.getFloat64(this.at(offset, 8), true) } - /** The struct nested at byte `offset` of this struct. */ - struct(offset: number): Struct { - return new Struct(this.buffer, this.view, this.position + offset) + struct(offset: number, size: number): Struct { + positive("size", size) + return new StructImpl(this.source, this.at(offset, size), size) } } /** * The elements of a vector. Accessors take the element index; the caller - * picks the accessor of the vector's element type. + * picks the accessor of the vector's element type, whose width must be the + * `elementSize` given to {@link Table.vector} (4 for strings and tables). * * @stability experimental * @category reading * @since 4.1.5 */ -export class Vector { +export interface Vector { /** The whole buffer. */ readonly buffer: Uint8Array /** Where the first element starts in {@link buffer}. */ readonly position: number /** The number of elements. */ readonly length: number - private readonly view: DataView + /** Element `index` of a `[bool]` vector. */ + bool(index: number): boolean + /** Element `index` of a `[byte]` vector. */ + int8(index: number): number + /** Element `index` of a `[ubyte]` vector. */ + uint8(index: number): number + /** Element `index` of a `[short]` vector. */ + int16(index: number): number + /** Element `index` of a `[ushort]` vector. */ + uint16(index: number): number + /** Element `index` of an `[int]` vector. */ + int32(index: number): number + /** Element `index` of an `[uint]` vector. */ + uint32(index: number): number + /** Element `index` of a `[long]` vector. */ + int64(index: number): bigint + /** Element `index` of a `[ulong]` vector. */ + uint64(index: number): bigint + /** Element `index` of a `[float]` vector. */ + float32(index: number): number + /** Element `index` of a `[double]` vector. */ + float64(index: number): number + /** Element `index` of a `[string]` vector. */ + string(index: number): string + /** Element `index` of a vector of tables. */ + table(index: number): Table + /** Element `index` of a vector of structs. */ + struct(index: number): Struct +} + +class VectorImpl implements Vector { + readonly position: number + readonly length: number + private readonly source: Source + private readonly elementSize: number + private readonly depth: number - constructor(buffer: Uint8Array, view: DataView, position: number, length: number) { - this.buffer = buffer - this.view = view + /** The caller has checked that all `length` elements lie inside the buffer. */ + constructor(source: Source, position: number, length: number, elementSize: number, depth: number) { + this.source = source this.position = position this.length = length + this.elementSize = elementSize + this.depth = depth + } + + get buffer(): Uint8Array { + return this.source.bytes } private at(index: number, size: number): number { + if (size !== this.elementSize) { + fail("Usage", `a ${size}-byte read from a vector of ${this.elementSize}-byte elements`) + } if (!Number.isInteger(index) || index < 0 || index >= this.length) { fail("OutOfBounds", `index ${index} is outside the vector of length ${this.length}`) } - const at = this.position + index * size - check(this.view, at, size) - return at + return this.position + index * size } - /** Element `index` of a `[bool]` vector. */ bool(index: number): boolean { - return this.view.getUint8(this.at(index, 1)) !== 0 + return this.source.view.getUint8(this.at(index, 1)) !== 0 } - /** Element `index` of a `[byte]` vector. */ int8(index: number): number { - return this.view.getInt8(this.at(index, 1)) + return this.source.view.getInt8(this.at(index, 1)) } - /** Element `index` of a `[ubyte]` vector. */ uint8(index: number): number { - return this.view.getUint8(this.at(index, 1)) + return this.source.view.getUint8(this.at(index, 1)) } - /** Element `index` of a `[short]` vector. */ int16(index: number): number { - return this.view.getInt16(this.at(index, 2), true) + return this.source.view.getInt16(this.at(index, 2), true) } - /** Element `index` of a `[ushort]` vector. */ uint16(index: number): number { - return this.view.getUint16(this.at(index, 2), true) + return this.source.view.getUint16(this.at(index, 2), true) } - /** Element `index` of an `[int]` vector. */ int32(index: number): number { - return this.view.getInt32(this.at(index, 4), true) + return this.source.view.getInt32(this.at(index, 4), true) } - /** Element `index` of a `[uint]` vector. */ uint32(index: number): number { - return this.view.getUint32(this.at(index, 4), true) + return this.source.view.getUint32(this.at(index, 4), true) } - /** Element `index` of a `[long]` vector. */ int64(index: number): bigint { - return this.view.getBigInt64(this.at(index, 8), true) + return this.source.view.getBigInt64(this.at(index, 8), true) } - /** Element `index` of a `[ulong]` vector. */ uint64(index: number): bigint { - return this.view.getBigUint64(this.at(index, 8), true) + return this.source.view.getBigUint64(this.at(index, 8), true) } - /** Element `index` of a `[float]` vector. */ float32(index: number): number { - return this.view.getFloat32(this.at(index, 4), true) + return this.source.view.getFloat32(this.at(index, 4), true) } - /** Element `index` of a `[double]` vector. */ float64(index: number): number { - return this.view.getFloat64(this.at(index, 8), true) + return this.source.view.getFloat64(this.at(index, 8), true) } - /** Element `index` of a `[string]` vector. */ string(index: number): string { - return readString(this.buffer, this.view, indirect(this.view, this.at(index, 4))) + return readString(this.source, indirect(this.source.view, this.at(index, 4))) } - /** Element `index` of a vector of tables. */ table(index: number): Table { - return new Table(this.buffer, this.view, indirect(this.view, this.at(index, 4))) + return new TableImpl(this.source, indirect(this.source.view, this.at(index, 4)), this.depth + 1) } - /** Element `index` of a vector of structs of `size` bytes. */ - struct(index: number, size: number): Struct { - return new Struct(this.buffer, this.view, this.at(index, size)) + struct(index: number): Struct { + return new StructImpl(this.source, this.at(index, this.elementSize), this.elementSize) } } @@ -312,146 +382,161 @@ export class Vector { * @category reading * @since 4.1.5 */ -export class Table { +export interface Table { /** The whole buffer. */ readonly buffer: Uint8Array /** Where the table starts in {@link buffer}. */ readonly position: number - private readonly view: DataView + /** Whether field `slot` is present. */ + has(slot: number): boolean + /** The `bool` in `slot`, or `fallback` when it is absent. */ + bool(slot: number, fallback?: boolean): boolean + /** The `byte` in `slot`, or `fallback` when it is absent. */ + int8(slot: number, fallback?: number): number + /** The `ubyte` in `slot`, or `fallback` when it is absent. */ + uint8(slot: number, fallback?: number): number + /** The `short` in `slot`, or `fallback` when it is absent. */ + int16(slot: number, fallback?: number): number + /** The `ushort` in `slot`, or `fallback` when it is absent. */ + uint16(slot: number, fallback?: number): number + /** The `int` in `slot`, or `fallback` when it is absent. */ + int32(slot: number, fallback?: number): number + /** The `uint` in `slot`, or `fallback` when it is absent. */ + uint32(slot: number, fallback?: number): number + /** The `long` in `slot`, or `fallback` when it is absent. */ + int64(slot: number, fallback?: bigint): bigint + /** The `ulong` in `slot`, or `fallback` when it is absent. */ + uint64(slot: number, fallback?: bigint): bigint + /** The `float` in `slot`, or `fallback` when it is absent. */ + float32(slot: number, fallback?: number): number + /** The `double` in `slot`, or `fallback` when it is absent. */ + float64(slot: number, fallback?: number): number + /** The `string` in `slot`. */ + string(slot: number): string | undefined + /** The table in `slot` (also the value of a union). */ + table(slot: number): Table | undefined + /** The struct of `size` bytes stored inline in `slot`. */ + struct(slot: number, size: number): Struct | undefined + /** The vector in `slot`, whose elements are `elementSize` bytes wide (4 for strings and tables). */ + vector(slot: number, elementSize: number): Vector | undefined + /** The `[ubyte]` (or `[byte]`) vector in `slot`, as a view of the buffer (also a nested FlatBuffer). */ + bytes(slot: number): Uint8Array | undefined +} + +class TableImpl implements Table { + readonly position: number + private readonly source: Source + private readonly depth: number private readonly vtable: number private readonly vtableSize: number - constructor(buffer: Uint8Array, view: DataView, position: number) { - this.buffer = buffer - this.view = view - this.position = position + constructor(source: Source, position: number, depth: number) { + if (depth > source.maxDepth) fail("Limit", `tables are nested deeper than maxDepth (${source.maxDepth})`) + const view = source.view check(view, position, 4) const vtable = position - view.getInt32(position, true) check(view, vtable, 4) const vtableSize = view.getUint16(vtable, true) if (vtableSize < 4 || (vtableSize & 1) !== 0) fail("InvalidVtable", `vtable at ${vtable} has size ${vtableSize}`) check(view, vtable, vtableSize) + this.source = source + this.position = position + this.depth = depth this.vtable = vtable this.vtableSize = vtableSize } + get buffer(): Uint8Array { + return this.source.bytes + } + /** The position of field `slot`, or -1 when it is absent. */ private field(slot: number, size: number): number { const entry = 4 + slot * 2 if (!Number.isInteger(slot) || slot < 0 || entry >= this.vtableSize) return -1 - const relative = this.view.getUint16(this.vtable + entry, true) + const relative = this.source.view.getUint16(this.vtable + entry, true) if (relative === 0) return -1 const at = this.position + relative - check(this.view, at, size) + check(this.source.view, at, size) return at } - /** Whether field `slot` is present. */ has(slot: number): boolean { return this.field(slot, 0) !== -1 } - /** The `bool` in `slot`. */ bool(slot: number, fallback = false): boolean { const at = this.field(slot, 1) - return at === -1 ? fallback : this.view.getUint8(at) !== 0 + return at === -1 ? fallback : this.source.view.getUint8(at) !== 0 } - /** The `byte` in `slot`. */ int8(slot: number, fallback = 0): number { const at = this.field(slot, 1) - return at === -1 ? fallback : this.view.getInt8(at) + return at === -1 ? fallback : this.source.view.getInt8(at) } - /** The `ubyte` in `slot`. */ uint8(slot: number, fallback = 0): number { const at = this.field(slot, 1) - return at === -1 ? fallback : this.view.getUint8(at) + return at === -1 ? fallback : this.source.view.getUint8(at) } - /** The `short` in `slot`. */ int16(slot: number, fallback = 0): number { const at = this.field(slot, 2) - return at === -1 ? fallback : this.view.getInt16(at, true) + return at === -1 ? fallback : this.source.view.getInt16(at, true) } - /** The `ushort` in `slot`. */ uint16(slot: number, fallback = 0): number { const at = this.field(slot, 2) - return at === -1 ? fallback : this.view.getUint16(at, true) + return at === -1 ? fallback : this.source.view.getUint16(at, true) } - /** The `int` in `slot`. */ int32(slot: number, fallback = 0): number { const at = this.field(slot, 4) - return at === -1 ? fallback : this.view.getInt32(at, true) + return at === -1 ? fallback : this.source.view.getInt32(at, true) } - /** The `uint` in `slot`. */ uint32(slot: number, fallback = 0): number { const at = this.field(slot, 4) - return at === -1 ? fallback : this.view.getUint32(at, true) + return at === -1 ? fallback : this.source.view.getUint32(at, true) } - /** The `long` in `slot`. */ int64(slot: number, fallback: bigint = BigInt(0)): bigint { const at = this.field(slot, 8) - return at === -1 ? fallback : this.view.getBigInt64(at, true) + return at === -1 ? fallback : this.source.view.getBigInt64(at, true) } - /** The `ulong` in `slot`. */ uint64(slot: number, fallback: bigint = BigInt(0)): bigint { const at = this.field(slot, 8) - return at === -1 ? fallback : this.view.getBigUint64(at, true) + return at === -1 ? fallback : this.source.view.getBigUint64(at, true) } - /** The `float` in `slot`. */ float32(slot: number, fallback = 0): number { const at = this.field(slot, 4) - return at === -1 ? fallback : this.view.getFloat32(at, true) + return at === -1 ? fallback : this.source.view.getFloat32(at, true) } - /** The `double` in `slot`. */ float64(slot: number, fallback = 0): number { const at = this.field(slot, 8) - return at === -1 ? fallback : this.view.getFloat64(at, true) + return at === -1 ? fallback : this.source.view.getFloat64(at, true) } - /** The `string` in `slot`. */ string(slot: number): string | undefined { const at = this.field(slot, 4) - return at === -1 ? undefined : readString(this.buffer, this.view, indirect(this.view, at)) + return at === -1 ? undefined : readString(this.source, indirect(this.source.view, at)) } - /** The table in `slot` (also the value of a union). */ table(slot: number): Table | undefined { const at = this.field(slot, 4) - return at === -1 ? undefined : new Table(this.buffer, this.view, indirect(this.view, at)) + return at === -1 ? undefined : new TableImpl(this.source, indirect(this.source.view, at), this.depth + 1) } - /** The struct of `size` bytes stored inline in `slot`. */ struct(slot: number, size: number): Struct | undefined { + positive("size", size) const at = this.field(slot, size) - return at === -1 ? undefined : new Struct(this.buffer, this.view, at) + return at === -1 ? undefined : new StructImpl(this.source, at, size) } - /** The vector in `slot`, whose elements are `elementSize` bytes wide (4 for strings and tables). */ vector(slot: number, elementSize: number): Vector | undefined { + positive("elementSize", elementSize) const at = this.field(slot, 4) if (at === -1) return undefined - const start = indirect(this.view, at) - check(this.view, start, 4) - const length = this.view.getUint32(start, true) - check(this.view, start + 4, length * elementSize) - return new Vector(this.buffer, this.view, start + 4, length) + const start = indirect(this.source.view, at) + check(this.source.view, start, 4) + const length = this.source.view.getUint32(start, true) + check(this.source.view, start + 4, length * elementSize) + return new VectorImpl(this.source, start + 4, length, elementSize, this.depth) } - /** The `[ubyte]` (or `[byte]`) vector in `slot`, as a view of the buffer (also a nested FlatBuffer). */ bytes(slot: number): Uint8Array | undefined { const v = this.vector(slot, 1) - return v === undefined ? undefined : this.buffer.subarray(v.position, v.position + v.length) + return v === undefined ? undefined : this.source.bytes.subarray(v.position, v.position + v.length) } } -/** - * Options of a buffer: an expected file identifier, and whether the buffer - * starts with its size. - * - * @stability experimental - * @category models - * @since 4.1.5 - */ -export interface Options { - /** The four-character file identifier the buffer must carry. */ - readonly identifier?: string | undefined - /** Whether the buffer starts with its size (`FinishSizePrefixed`). */ - readonly sizePrefixed?: boolean | undefined -} - const identifierBytes = (identifier: string): Uint8Array => { const bytes = encoder.encode(identifier) return bytes.length === 4 @@ -460,17 +545,25 @@ const identifierBytes = (identifier: string): Uint8Array => { } /** - * The buffer's file identifier (the four bytes after the root offset), or - * `undefined` when the buffer is too short to have one. + * The four bytes where a file identifier goes (after the root offset), + * decoded as UTF-8, or `undefined` when the buffer is too short. + * + * **Details** + * + * A buffer doesn't record whether it has an identifier: without one, these + * bytes belong to the root table. Compare the result with the identifier you + * expect, or pass `identifier` to {@link root} or {@link decode}. * * @stability experimental * @category reading * @since 4.1.5 */ -export const identifier = (bytes: Uint8Array, options?: Pick): string | undefined => { +export const identifier = ( + bytes: Uint8Array, + options?: { readonly sizePrefixed?: boolean | undefined } +): string | undefined => { const at = options?.sizePrefixed ? 8 : 4 - if (bytes.length < at + 4) return undefined - return String.fromCharCode(...bytes.subarray(at, at + 4)) + return bytes.length < at + 4 ? undefined : lenientUtf8.decode(bytes.subarray(at, at + 4)) } /** @@ -478,11 +571,26 @@ export const identifier = (bytes: Uint8Array, options?: Pick { +export const root = (bytes: Uint8Array, options?: { + readonly identifier?: string | undefined + readonly sizePrefixed?: boolean | undefined + readonly maxDepth?: number | undefined +}): Table => { + const maxDepth = options?.maxDepth ?? 64 + positive("maxDepth", maxDepth) + const expected = options?.identifier === undefined ? undefined : identifierBytes(options.identifier) let data = bytes if (options?.sizePrefixed) { if (bytes.length < 4) fail("OutOfBounds", "a size-prefixed buffer needs at least 4 bytes") @@ -492,21 +600,33 @@ export const root = (bytes: Uint8Array, options?: Options): Table => { } data = bytes.subarray(4, 4 + size) } - if (options?.identifier !== undefined) { - const expected = identifierBytes(options.identifier) + if (expected !== undefined) { const actual = data.subarray(4, 8) if (actual.length !== 4 || actual.some((b, i) => b !== expected[i])) { - fail("Identifier", `expected file identifier ${JSON.stringify(options.identifier)}`) + fail("Identifier", `expected file identifier ${JSON.stringify(options!.identifier)}`) } } const view = new DataView(data.buffer, data.byteOffset, data.byteLength) check(view, 0, 4) - return new Table(data, view, view.getUint32(0, true)) + return new TableImpl({ bytes: data, view, maxDepth }, view.getUint32(0, true), 1) } /** * Reads a buffer with `read`, which gets the root table. Malformed input - * becomes a failed `Result` instead of an exception. + * becomes a failed `Result` instead of an exception; options are those of + * {@link root}. + * + * **Details** + * + * Reads are lazy, so only the reads made inside `read` are covered: a + * {@link Table} or {@link Vector} returned from it can still throw later. + * `Usage` errors are bugs in the caller (a misshapen identifier, a read of + * the wrong width) and are thrown, as are errors that aren't + * {@link FlatBuffersError}s. + * + * Many offsets may point at one string or vector, so what a reader + * materialises is not bounded by the size of the buffer: 1,000 offsets to + * one 100 KB string decode to 100 MB. Cap what you read from untrusted input. * * @stability experimental * @category reading @@ -515,12 +635,16 @@ export const root = (bytes: Uint8Array, options?: Options): Table => { export const decode = ( bytes: Uint8Array, read: (root: Table) => A, - options?: Options + options?: { + readonly identifier?: string | undefined + readonly sizePrefixed?: boolean | undefined + readonly maxDepth?: number | undefined + } ): Result.Result => { try { return Result.succeed(read(root(bytes, options))) } catch (cause) { - if (isFlatBuffersError(cause)) return Result.fail(cause) + if (isFlatBuffersError(cause) && cause.kind !== "Usage") return Result.fail(cause) throw cause } } @@ -540,6 +664,8 @@ export const decode = ( export type Offset = number const MAX_SIZE = 2 ** 31 +/** The most slots whose vtable (two bytes each, plus four) fits its 16-bit size. */ +const MAX_SLOTS = 32765 /** * Writes a FlatBuffer back to front, as the official builders do: the same @@ -573,6 +699,7 @@ export class Builder { private objectEnd = 0 private readonly vtables = new Map() private nested = false + private finished = false private vectorLength = 0 private sharedStrings: Map | undefined = undefined private readonly forceDefaults: boolean @@ -602,6 +729,7 @@ export class Builder { /** Writes `n` zero bytes. */ pad(n: number): void { + while (this.head < n) this.grow() for (let i = 0; i < n; i++) this.bytes[--this.head] = 0 } @@ -610,6 +738,7 @@ export class Builder { * bytes, is aligned to `size`; makes room for both. */ prep(size: number, additional: number): void { + if (size < 1 || (size & (size - 1)) !== 0) fail("Usage", `an alignment must be a power of two, got ${size}`) if (size > this.minAlign) this.minAlign = size const alignSize = (~(this.bytes.length - this.head + additional) + 1) & (size - 1) while (this.head < alignSize + size + additional) this.grow() @@ -745,6 +874,9 @@ export class Builder { /** Starts a table with `fields` slots. Add fields, then {@link endTable}. */ startTable(fields: number): void { this.notNested("startTable") + if (!Number.isInteger(fields) || fields < 0 || fields > MAX_SLOTS) { + fail("Usage", `a table has 0 to ${MAX_SLOTS} slots, got ${fields}`) + } this.nested = true this.vtable = new Array(fields).fill(0) this.objectEnd = this.offset @@ -863,6 +995,9 @@ export class Builder { let fields = vtable.length while (fields > 0 && vtable[fields - 1] === 0) fields-- const objectSize = object - this.objectEnd + if (objectSize > 0xffff) { + fail("Usage", `a table's inline data is ${objectSize} bytes, over the 65535 a vtable can address`) + } const entries = Array.from({ length: fields }, (_, i) => (vtable[i] === 0 ? 0 : object - vtable[i])) const key = `${objectSize}:${entries.join(",")}` const existing = this.vtables.get(key) @@ -883,10 +1018,14 @@ export class Builder { /** * Writes the root offset (after the file identifier and before the size - * prefix, when given) and returns the finished buffer. + * prefix, when given) and returns the finished buffer. Call it once. */ - finish(rootTable: Offset, options?: Options): Uint8Array { + finish(rootTable: Offset, options?: { + readonly identifier?: string | undefined + readonly sizePrefixed?: boolean | undefined + }): Uint8Array { this.notNested("finish") + if (this.finished) fail("Usage", "finish called twice") const identifier = options?.identifier === undefined ? undefined : identifierBytes(options.identifier) this.prep(this.minAlign, 4 + (identifier === undefined ? 0 : 4) + (options?.sizePrefixed ? 4 : 0)) if (identifier !== undefined) { @@ -895,6 +1034,7 @@ export class Builder { } this.addOffset(rootTable) if (options?.sizePrefixed) this.addInt32(this.bytes.length - this.head) + this.finished = true return this.bytes.slice(this.head) } } @@ -908,7 +1048,7 @@ export class Builder { * @category writing * @since 4.1.5 */ -export const make = (options?: { +export const makeBuilder = (options?: { readonly initialSize?: number | undefined readonly forceDefaults?: boolean | undefined }): Builder => new Builder(options) diff --git a/packages/effect/test/encoding/FlatBuffers.test.ts b/packages/effect/test/encoding/FlatBuffers.test.ts index d9f70845658..63a2f609d7c 100644 --- a/packages/effect/test/encoding/FlatBuffers.test.ts +++ b/packages/effect/test/encoding/FlatBuffers.test.ts @@ -25,7 +25,7 @@ const addPadded = (b: FlatBuffers.Builder, a: number, x: number, y: bigint) => { } const buildMonster = () => { - const b = FlatBuffers.make() + const b = FlatBuffers.makeBuilder() const name = b.createString("Orc") const inventory = b.createBytes(Uint8Array.of(0, 1, 2, 3, 4)) const weapons = [3, 5].map((damage) => { @@ -57,7 +57,7 @@ const buildMonster = () => { } const buildPrefixed = () => { - const b = FlatBuffers.make({ initialSize: 1, forceDefaults: true }) + const b = FlatBuffers.makeBuilder({ initialSize: 1, forceDefaults: true }) const s = b.createString("x".repeat(40)) b.startTable(2) b.addFieldOffset(0, s) @@ -80,13 +80,24 @@ const readMonster = (root: FlatBuffers.Table) => { return [weapon.string(0), weapon.int16(1)] }), path: path && Array.from({ length: path.length }, (_, i) => { - const s = path.struct(i, 16) + const s = path.struct(i) return [s.int8(0), s.int32(4), s.int64(8)] }), flag: root.bool(7) } } +const usage = (f: () => unknown) => { + try { + f() + } catch (error) { + assert.isTrue(FlatBuffers.isFlatBuffersError(error)) + assert.strictEqual((error as FlatBuffers.FlatBuffersError).kind, "Usage") + return + } + assert.fail("expected a Usage FlatBuffersError") +} + describe("FlatBuffers", () => { it("builds the bytes the official builder builds", () => { assert.strictEqual(toHex(buildMonster()), MONSTER) @@ -116,7 +127,7 @@ describe("FlatBuffers", () => { }) it("reads absent fields as their defaults", () => { - const b = FlatBuffers.make() + const b = FlatBuffers.makeBuilder() b.startTable(1) const root = FlatBuffers.root(b.finish(b.endTable())) assert.strictEqual(root.int32(0, 7), 7) @@ -128,7 +139,7 @@ describe("FlatBuffers", () => { }) it("decode returns a failure for malformed input", () => { - const failure = (bytes: Uint8Array, options?: FlatBuffers.Options) => { + const failure = (bytes: Uint8Array, options?: Parameters[2]) => { const result = FlatBuffers.decode(bytes, (root) => root.string(0), options) assert.isTrue(Result.isFailure(result)) return Result.isFailure(result) ? result.failure.kind : undefined @@ -138,7 +149,7 @@ describe("FlatBuffers", () => { // A vtable of size 1. assert.strictEqual(failure(Uint8Array.of(8, 0, 0, 0, 1, 0, 4, 0, 4, 0, 0, 0)), "InvalidVtable") // A string field with an invalid UTF-8 byte. - const b = FlatBuffers.make() + const b = FlatBuffers.makeBuilder() const s = b.createString(Uint8Array.of(0xc3, 0x28)) b.startTable(1) b.addFieldOffset(0, s) @@ -168,46 +179,85 @@ describe("FlatBuffers", () => { } }) - it("Builder rejects nested and out-of-order calls", () => { - const usage = (f: (b: FlatBuffers.Builder) => void) => { - try { - f(FlatBuffers.make()) - assert.fail("expected a FlatBuffersError") - } catch (error) { - assert.isTrue(FlatBuffers.isFlatBuffersError(error)) - assert.strictEqual((error as FlatBuffers.FlatBuffersError).kind, "Usage") - } + it("fails tables nested deeper than maxDepth", () => { + const b = FlatBuffers.makeBuilder() + let table = 0 + for (let i = 0; i < 65; i++) { + b.startTable(1) + b.addFieldOffset(0, table) + table = b.endTable() } - usage((b) => { + const bytes = b.finish(table) + const depth = (t: FlatBuffers.Table): number => 1 + (t.table(0) === undefined ? 0 : depth(t.table(0)!)) + const result = FlatBuffers.decode(bytes, depth) + assert.isTrue(Result.isFailure(result) && result.failure.kind === "Limit") + assert.deepStrictEqual(FlatBuffers.decode(bytes, depth, { maxDepth: 65 }), Result.succeed(65)) + }) + + it("throws for reads that don't match the shape asked for, even inside decode", () => { + const monster = fromHex(MONSTER) + const root = FlatBuffers.root(monster) + usage(() => FlatBuffers.decode(monster, (root) => root.vector(4, 1)!.int32(0))) + usage(() => root.vector(4, 0)) + usage(() => root.struct(0, 12)!.float32(12)) + usage(() => root.struct(0, 12)!.float32(-4)) + usage(() => root.struct(0, 12)!.float32(NaN)) + usage(() => FlatBuffers.decode(monster, (root) => root.has(0), { identifier: "TOOLONG" })) + }) + + it("reads back a UTF-8 file identifier", () => { + const b = FlatBuffers.makeBuilder() + b.startTable(0) + assert.strictEqual(FlatBuffers.identifier(b.finish(b.endTable(), { identifier: "é12" })), "é12") + }) + + it("Builder rejects misuse", () => { + const builder = (f: (b: FlatBuffers.Builder) => void) => usage(() => f(FlatBuffers.makeBuilder())) + builder((b) => { b.startTable(1) b.createString("x") }) - usage((b) => { + builder((b) => { b.startTable(1) b.startTable(1) }) - usage((b) => { + builder((b) => { b.startVector(1, 1, 1) b.startTable(1) }) - usage((b) => b.endTable()) - usage((b) => b.endVector()) - usage((b) => { + builder((b) => b.endTable()) + builder((b) => b.endVector()) + builder((b) => { b.startTable(1) b.addFieldInt32(1, 5) }) - usage((b) => b.addFieldInt32(0, 5)) - usage((b) => { + builder((b) => b.addFieldInt32(0, 5)) + builder((b) => { b.addInt32(1) const s = b.offset b.addInt32(2) b.startTable(1) b.addFieldStruct(0, s) }) - usage((b) => { + builder((b) => { b.startTable(0) b.finish(b.endTable(), { identifier: "TOOLONG" }) }) - usage((b) => b.addOffset(100)) + builder((b) => b.addOffset(100)) + builder((b) => b.startTable(32766)) + builder((b) => { + // 64 KiB of inline data is more than a vtable entry can address. + b.startTable(1) + b.pad(0x10000) + b.addFieldInt32(0, 1) + b.endTable() + }) + builder((b) => { + b.startTable(0) + const table = b.endTable() + b.finish(table) + b.finish(table) + }) + builder((b) => b.startVector(1, 1, 3)) }) }) From 97ce51f49927192aeae87d6e63b3b7f2c76c2af7 Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Sat, 14 Nov 2026 18:12:25 +0000 Subject: [PATCH 04/11] fix(encoding): keep FlatBuffers BOMs, null references and integer arguments intact Strings decode through the shared BOM-preserving UTF-8 decoder and identifier() keeps a leading U+FEFF. addFieldOffset skips a null target even with forceDefaults, as the C++ builder does. The builder rejects non-integer slots, vector lengths, element sizes and alignments, and readers reject negative or fractional slots while slots past the vtable stay absent. --- packages/effect/src/encoding/FlatBuffers.ts | 47 ++++++++++++------- .../effect/test/encoding/FlatBuffers.test.ts | 30 ++++++++++-- 2 files changed, 57 insertions(+), 20 deletions(-) diff --git a/packages/effect/src/encoding/FlatBuffers.ts b/packages/effect/src/encoding/FlatBuffers.ts index d5011ea83c0..c4d20e8a18f 100644 --- a/packages/effect/src/encoding/FlatBuffers.ts +++ b/packages/effect/src/encoding/FlatBuffers.ts @@ -56,6 +56,7 @@ * @since 4.1.5 */ import * as Data from "../Data.ts" +import * as Utf8 from "../internal/utf8.ts" import * as Predicate from "../Predicate.ts" import * as Result from "../Result.ts" @@ -74,10 +75,12 @@ const FlatBuffersErrorTypeId = "~effect/encoding/FlatBuffers/FlatBuffersError" * - `Identifier`: the buffer's file identifier is not the expected one. * - `Limit`: tables are nested deeper than `maxDepth`. * - `Usage`: a bug in the caller: the builder was called out of order (a - * table inside a table, a struct that isn't the last thing written, an - * identifier that isn't four bytes), a table or buffer would outgrow the - * format, or a read doesn't match the shape it asked for (a vector read at - * another width, a struct read past its size). + * table inside a table, a struct that isn't the last thing written), got an + * invalid argument (a slot, length or alignment that isn't a valid integer, + * an identifier that isn't four bytes), a table or buffer would outgrow the + * format, or a read doesn't match the shape it asked for (a negative or + * fractional slot, a vector read at another width, a struct read past its + * size). * * @stability experimental * @category errors @@ -114,8 +117,8 @@ const positive = (name: string, n: number): void => { if (!Number.isInteger(n) || n < 1) fail("Usage", `${name} must be a positive integer, got ${n}`) } -const utf8 = new TextDecoder("utf-8", { fatal: true }) -const lenientUtf8 = new TextDecoder() +// Keeps a leading U+FEFF, which is part of the identifier. +const lenientUtf8 = new TextDecoder("utf-8", { ignoreBOM: true }) const encoder = new TextEncoder() /** The buffer every reader of one {@link root} shares. */ @@ -141,11 +144,8 @@ const readString = (source: Source, start: number): string => { check(source.view, start, 4) const length = source.view.getUint32(start, true) check(source.view, start + 4, length) - try { - return utf8.decode(source.bytes.subarray(start + 4, start + 4 + length)) - } catch { - return fail("InvalidUtf8", `the string at ${start} is not valid UTF-8`) - } + return Utf8.decode(source.bytes, start + 4, start + 4 + length) ?? + fail("InvalidUtf8", `the string at ${start} is not valid UTF-8`) } // ----------------------------------------------------------------------------- @@ -376,7 +376,8 @@ class VectorImpl implements Vector { /** * A table: fields by slot number, read on demand. Absent fields read as - * the given default. + * the given default, including slots past the end of the table's vtable + * (fields added to the schema after the buffer was written). * * @stability experimental * @category reading @@ -452,8 +453,10 @@ class TableImpl implements Table { /** The position of field `slot`, or -1 when it is absent. */ private field(slot: number, size: number): number { + if (!Number.isInteger(slot) || slot < 0) fail("Usage", `a slot is a non-negative integer, got ${slot}`) const entry = 4 + slot * 2 - if (!Number.isInteger(slot) || slot < 0 || entry >= this.vtableSize) return -1 + // A slot past the vtable was added after the buffer was written: absent. + if (entry >= this.vtableSize) return -1 const relative = this.source.view.getUint16(this.vtable + entry, true) if (relative === 0) return -1 const at = this.position + relative @@ -738,7 +741,9 @@ export class Builder { * bytes, is aligned to `size`; makes room for both. */ prep(size: number, additional: number): void { - if (size < 1 || (size & (size - 1)) !== 0) fail("Usage", `an alignment must be a power of two, got ${size}`) + if (!Number.isInteger(size) || size < 1 || (size & (size - 1)) !== 0) { + fail("Usage", `an alignment must be a power of two, got ${size}`) + } if (size > this.minAlign) this.minAlign = size const alignSize = (~(this.bytes.length - this.head + additional) + 1) & (size - 1) while (this.head < alignSize + size + additional) this.grow() @@ -850,6 +855,10 @@ export class Builder { */ startVector(elementSize: number, length: number, alignment: number): void { this.notNested("startVector") + positive("elementSize", elementSize) + if (!Number.isInteger(length) || length < 0 || length > 0xffffffff) { + fail("Usage", `a vector length is a 32-bit unsigned integer, got ${length}`) + } this.nested = true this.vectorLength = length this.prep(4, elementSize * length) @@ -884,7 +893,7 @@ export class Builder { private slot(slot: number): void { if (this.vtable === undefined) fail("Usage", "a field outside startTable/endTable") - if (slot < 0 || slot >= this.vtable!.length) { + if (!Number.isInteger(slot) || slot < 0 || slot >= this.vtable!.length) { fail("Usage", `slot ${slot} is outside the table's ${this.vtable!.length} slots`) } this.vtable![slot] = this.offset @@ -967,9 +976,13 @@ export class Builder { this.slot(slot) } } - /** Adds a field pointing to a string, vector or table (a union's value too). */ + /** + * Adds a field pointing to a string, vector or table (a union's value too). + * A `target` of 0 (nothing) leaves the field absent, even with + * `forceDefaults`. + */ addFieldOffset(slot: number, target: Offset): void { - if (target !== 0 || this.forceDefaults) { + if (target !== 0) { this.addOffset(target) this.slot(slot) } diff --git a/packages/effect/test/encoding/FlatBuffers.test.ts b/packages/effect/test/encoding/FlatBuffers.test.ts index 63a2f609d7c..ede9f63d5a3 100644 --- a/packages/effect/test/encoding/FlatBuffers.test.ts +++ b/packages/effect/test/encoding/FlatBuffers.test.ts @@ -202,13 +202,30 @@ describe("FlatBuffers", () => { usage(() => root.struct(0, 12)!.float32(12)) usage(() => root.struct(0, 12)!.float32(-4)) usage(() => root.struct(0, 12)!.float32(NaN)) + usage(() => root.int32(-1)) + usage(() => root.has(0.5)) usage(() => FlatBuffers.decode(monster, (root) => root.has(0), { identifier: "TOOLONG" })) }) - it("reads back a UTF-8 file identifier", () => { + it("keeps UTF-8 strings and identifiers intact, byte order mark included", () => { const b = FlatBuffers.makeBuilder() - b.startTable(0) - assert.strictEqual(FlatBuffers.identifier(b.finish(b.endTable(), { identifier: "é12" })), "é12") + const s = b.createString("\ufeffhello") + b.startTable(1) + b.addFieldOffset(0, s) + const bytes = b.finish(b.endTable(), { identifier: "\ufeffA" }) + assert.strictEqual(FlatBuffers.root(bytes).string(0), "\ufeffhello") + assert.strictEqual(FlatBuffers.identifier(bytes), "\ufeffA") + }) + + it("forceDefaults writes scalar defaults but leaves absent references absent", () => { + const b = FlatBuffers.makeBuilder({ forceDefaults: true }) + b.startTable(2) + b.addFieldOffset(0, 0) + b.addFieldInt32(1, 0) + const root = FlatBuffers.root(b.finish(b.endTable())) + assert.isFalse(root.has(0)) + assert.strictEqual(root.string(0), undefined) + assert.isTrue(root.has(1)) }) it("Builder rejects misuse", () => { @@ -259,5 +276,12 @@ describe("FlatBuffers", () => { b.finish(table) }) builder((b) => b.startVector(1, 1, 3)) + builder((b) => b.startVector(1, 1, 1.5)) + builder((b) => b.startVector(1, -1, 1)) + builder((b) => b.startVector(1, 0.5, 1)) + builder((b) => { + b.startTable(1) + b.addFieldInt32(0.5, 111) + }) }) }) From 73258c5e399dab406ca414ff85035fff8161c269 Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Sat, 14 Nov 2026 18:36:01 +0000 Subject: [PATCH 05/11] refactor(encoding): simplify FlatBuffers builder state and tests Derive the builder's nested state from the open table or vector, patch the vtable offset in one place, and let fail() narrow so the non-null assertions go away. Tests use the Hex module and the shared throws helper. No behaviour change. --- packages/effect/src/encoding/FlatBuffers.ts | 57 +++++++++---------- .../effect/test/encoding/FlatBuffers.test.ts | 32 +++++------ 2 files changed, 41 insertions(+), 48 deletions(-) diff --git a/packages/effect/src/encoding/FlatBuffers.ts b/packages/effect/src/encoding/FlatBuffers.ts index c4d20e8a18f..65b85391582 100644 --- a/packages/effect/src/encoding/FlatBuffers.ts +++ b/packages/effect/src/encoding/FlatBuffers.ts @@ -109,7 +109,7 @@ export class FlatBuffersError extends Data.TaggedError("FlatBuffersError")<{ export const isFlatBuffersError = (u: unknown): u is FlatBuffersError => Predicate.hasProperty(u, FlatBuffersErrorTypeId) -const fail = (kind: FlatBuffersError["kind"], message: string): never => { +function fail(kind: FlatBuffersError["kind"], message: string): never { throw new FlatBuffersError({ kind, message }) } @@ -606,12 +606,11 @@ export const root = (bytes: Uint8Array, options?: { if (expected !== undefined) { const actual = data.subarray(4, 8) if (actual.length !== 4 || actual.some((b, i) => b !== expected[i])) { - fail("Identifier", `expected file identifier ${JSON.stringify(options!.identifier)}`) + fail("Identifier", `expected file identifier ${JSON.stringify(options?.identifier)}`) } } const view = new DataView(data.buffer, data.byteOffset, data.byteLength) - check(view, 0, 4) - return new TableImpl({ bytes: data, view, maxDepth }, view.getUint32(0, true), 1) + return new TableImpl({ bytes: data, view, maxDepth }, indirect(view, 0), 1) } /** @@ -701,10 +700,9 @@ export class Builder { private vtable: Array | undefined = undefined private objectEnd = 0 private readonly vtables = new Map() - private nested = false + private vectorLength: number | undefined = undefined private finished = false - private vectorLength = 0 - private sharedStrings: Map | undefined = undefined + private readonly sharedStrings = new Map() private readonly forceDefaults: boolean constructor(options?: { readonly initialSize?: number | undefined; readonly forceDefaults?: boolean | undefined }) { @@ -814,7 +812,9 @@ export class Builder { } private notNested(what: string): void { - if (this.nested) fail("Usage", `${what} inside a table or vector that isn't finished`) + if (this.vtable !== undefined || this.vectorLength !== undefined) { + fail("Usage", `${what} inside a table or vector that isn't finished`) + } } /** Writes a string (UTF-8, or the given bytes) and returns its offset. */ @@ -831,7 +831,6 @@ export class Builder { /** Like {@link createString}, but writes each distinct string once. */ createSharedString(value: string): Offset { - this.sharedStrings ??= new Map() const existing = this.sharedStrings.get(value) if (existing !== undefined) return existing const offset = this.createString(value) @@ -859,7 +858,6 @@ export class Builder { if (!Number.isInteger(length) || length < 0 || length > 0xffffffff) { fail("Usage", `a vector length is a 32-bit unsigned integer, got ${length}`) } - this.nested = true this.vectorLength = length this.prep(4, elementSize * length) this.prep(alignment, elementSize * length) @@ -867,9 +865,10 @@ export class Builder { /** Finishes the vector started with {@link startVector} and returns its offset. */ endVector(): Offset { - if (!this.nested || this.vtable !== undefined) fail("Usage", "endVector without startVector") - this.nested = false - this.view.setUint32(this.head -= 4, this.vectorLength, true) + const length = this.vectorLength + if (length === undefined) fail("Usage", "endVector without startVector") + this.vectorLength = undefined + this.view.setUint32(this.head -= 4, length, true) return this.offset } @@ -886,17 +885,16 @@ export class Builder { if (!Number.isInteger(fields) || fields < 0 || fields > MAX_SLOTS) { fail("Usage", `a table has 0 to ${MAX_SLOTS} slots, got ${fields}`) } - this.nested = true this.vtable = new Array(fields).fill(0) this.objectEnd = this.offset } private slot(slot: number): void { if (this.vtable === undefined) fail("Usage", "a field outside startTable/endTable") - if (!Number.isInteger(slot) || slot < 0 || slot >= this.vtable!.length) { - fail("Usage", `slot ${slot} is outside the table's ${this.vtable!.length} slots`) + if (!Number.isInteger(slot) || slot < 0 || slot >= this.vtable.length) { + fail("Usage", `slot ${slot} is outside the table's ${this.vtable.length} slots`) } - this.vtable![slot] = this.offset + this.vtable[slot] = this.offset } /** Adds a `bool` field; skipped when equal to `fallback`. */ @@ -1001,31 +999,28 @@ export class Builder { /** Finishes the table started with {@link startTable} and returns its offset. */ endTable(): Offset { const vtable = this.vtable - if (vtable === undefined) return fail("Usage", "endTable without startTable") + if (vtable === undefined) fail("Usage", "endTable without startTable") // Placeholder for the offset to the vtable. this.addInt32(0) const object = this.offset - let fields = vtable.length - while (fields > 0 && vtable[fields - 1] === 0) fields-- const objectSize = object - this.objectEnd if (objectSize > 0xffff) { fail("Usage", `a table's inline data is ${objectSize} bytes, over the 65535 a vtable can address`) } - const entries = Array.from({ length: fields }, (_, i) => (vtable[i] === 0 ? 0 : object - vtable[i])) + // Trailing absent fields are left out of the vtable. + while (vtable.length > 0 && vtable[vtable.length - 1] === 0) vtable.pop() + const entries = vtable.map((at) => (at === 0 ? 0 : object - at)) const key = `${objectSize}:${entries.join(",")}` - const existing = this.vtables.get(key) - if (existing === undefined) { - for (let i = fields - 1; i >= 0; i--) this.addInt16(entries[i]) + let shared = this.vtables.get(key) + if (shared === undefined) { + for (let i = entries.length - 1; i >= 0; i--) this.addInt16(entries[i]) this.addInt16(objectSize) - this.addInt16((fields + 2) * 2) - this.view.setInt32(this.bytes.length - object, this.offset - object, true) - this.vtables.set(key, this.offset) - } else { - this.head = this.bytes.length - object - this.view.setInt32(this.head, existing - object, true) + this.addInt16((entries.length + 2) * 2) + shared = this.offset + this.vtables.set(key, shared) } + this.view.setInt32(this.bytes.length - object, shared - object, true) this.vtable = undefined - this.nested = false return object } diff --git a/packages/effect/test/encoding/FlatBuffers.test.ts b/packages/effect/test/encoding/FlatBuffers.test.ts index ede9f63d5a3..f53b5756b7f 100644 --- a/packages/effect/test/encoding/FlatBuffers.test.ts +++ b/packages/effect/test/encoding/FlatBuffers.test.ts @@ -1,9 +1,10 @@ import { assert, describe, it } from "@effect/vitest" +import { throws } from "@effect/vitest/utils" import { Result } from "effect" import * as FlatBuffers from "effect/encoding/FlatBuffers" +import * as Hex from "effect/encoding/Hex" -const fromHex = (hex: string) => Uint8Array.from(hex.match(/../g) ?? [], (b) => parseInt(b, 16)) -const toHex = (bytes: Uint8Array) => Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("") +const fromHex = (hex: string) => Result.getOrThrow(Hex.decode(hex)) // The expected bytes were written by the official FlatBuffers Python builder // (`flatbuffers` 25.12.19 from PyPI) making the same calls as the builders below. @@ -67,6 +68,7 @@ const buildPrefixed = () => { const readMonster = (root: FlatBuffers.Table) => { const pos = root.struct(0, 12) + const inventory = root.bytes(4) const weapons = root.vector(5, 4) const path = root.vector(6, 16) return { @@ -74,7 +76,7 @@ const readMonster = (root: FlatBuffers.Table) => { mana: [root.has(1), root.int16(1, 100)], hp: root.int16(2, 100), name: root.string(3), - inventory: root.bytes(4) && Array.from(root.bytes(4)!), + inventory: inventory && Array.from(inventory), weapons: weapons && Array.from({ length: weapons.length }, (_, i) => { const weapon = weapons.table(i) return [weapon.string(0), weapon.int16(1)] @@ -87,21 +89,15 @@ const readMonster = (root: FlatBuffers.Table) => { } } -const usage = (f: () => unknown) => { - try { - f() - } catch (error) { - assert.isTrue(FlatBuffers.isFlatBuffersError(error)) - assert.strictEqual((error as FlatBuffers.FlatBuffersError).kind, "Usage") - return - } - assert.fail("expected a Usage FlatBuffersError") -} +const usage = (f: () => unknown) => + throws(f, (error) => { + assert.strictEqual(FlatBuffers.isFlatBuffersError(error) && error.kind, "Usage") + }) describe("FlatBuffers", () => { it("builds the bytes the official builder builds", () => { - assert.strictEqual(toHex(buildMonster()), MONSTER) - assert.strictEqual(toHex(buildPrefixed()), PREFIXED) + assert.strictEqual(Hex.encode(buildMonster()), MONSTER) + assert.strictEqual(Hex.encode(buildPrefixed()), PREFIXED) }) it("reads the official builder's bytes", () => { @@ -141,7 +137,6 @@ describe("FlatBuffers", () => { it("decode returns a failure for malformed input", () => { const failure = (bytes: Uint8Array, options?: Parameters[2]) => { const result = FlatBuffers.decode(bytes, (root) => root.string(0), options) - assert.isTrue(Result.isFailure(result)) return Result.isFailure(result) ? result.failure.kind : undefined } assert.strictEqual(failure(new Uint8Array(2)), "OutOfBounds") @@ -188,7 +183,10 @@ describe("FlatBuffers", () => { table = b.endTable() } const bytes = b.finish(table) - const depth = (t: FlatBuffers.Table): number => 1 + (t.table(0) === undefined ? 0 : depth(t.table(0)!)) + const depth = (t: FlatBuffers.Table): number => { + const child = t.table(0) + return child === undefined ? 1 : 1 + depth(child) + } const result = FlatBuffers.decode(bytes, depth) assert.isTrue(Result.isFailure(result) && result.failure.kind === "Limit") assert.deepStrictEqual(FlatBuffers.decode(bytes, depth, { maxDepth: 65 }), Result.succeed(65)) From 98d06f68116eb44731cc98d5de3dadad82684ecd Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Sat, 14 Nov 2026 18:39:50 +0000 Subject: [PATCH 06/11] docs: clarify FlatBuffers contracts and release note --- .changeset/encoding-flatbuffers.md | 2 +- packages/effect/src/encoding/FlatBuffers.ts | 69 +++++++++------------ 2 files changed, 31 insertions(+), 40 deletions(-) diff --git a/.changeset/encoding-flatbuffers.md b/.changeset/encoding-flatbuffers.md index b77e1556f32..192806a840c 100644 --- a/.changeset/encoding-flatbuffers.md +++ b/.changeset/encoding-flatbuffers.md @@ -2,4 +2,4 @@ "effect": patch --- -Add `effect/encoding/FlatBuffers` for reading and writing FlatBuffers without a schema compiler. Reads are bounds-checked and lazy, and `decode` returns a `Result`. The builder produces the same bytes as the official FlatBuffers builders. +Add experimental `effect/encoding/FlatBuffers` support for reading and writing FlatBuffers without a schema compiler or runtime dependency. diff --git a/packages/effect/src/encoding/FlatBuffers.ts b/packages/effect/src/encoding/FlatBuffers.ts index 65b85391582..69d716273c4 100644 --- a/packages/effect/src/encoding/FlatBuffers.ts +++ b/packages/effect/src/encoding/FlatBuffers.ts @@ -4,7 +4,7 @@ * * **Mental model** * - * - A FlatBuffer is a tree of tables. A table's fields are numbered slots; + * - A FlatBuffer links tables through offsets. Fields are numbered slots; * a small vtable records where each present field is, so absent fields cost * nothing and read as their default. * - This module knows nothing about schemas. The caller decides what each @@ -12,9 +12,7 @@ * a string, slot 1 as a table, and so on. * - {@link Builder} writes a buffer back to front, children first: create * strings, vectors and child tables, then the table that refers to them, - * and {@link Builder.finish} with the root table. The bytes it produces - * are the bytes the official FlatBuffers builders produce for the same - * calls. + * and call {@link Builder.finish} with the root table. * - {@link root} gives the root {@link Table} of a buffer; its accessors read * from the bytes on demand. {@link decode} runs a reading function and * returns a `Result`. @@ -46,11 +44,10 @@ * * **Details** * - * Every read is bounds-checked: malformed or hostile input throws a - * {@link FlatBuffersError} (or makes {@link decode} fail) instead of reading - * outside the buffer or the vector or struct being read. Tables nested deeper - * than `maxDepth` fail too. Strings must be valid UTF-8. 64-bit integers are - * `bigint`s. + * Reads are bounds-checked, not a complete schema verification. Invalid reads + * throw a {@link FlatBuffersError}; {@link decode} catches data errors made + * inside its callback. Table nesting is limited by `maxDepth`. Strings must + * be valid UTF-8, and 64-bit integers are `bigint`s. * * @stability experimental * @since 4.1.5 @@ -63,7 +60,7 @@ import * as Result from "../Result.ts" const FlatBuffersErrorTypeId = "~effect/encoding/FlatBuffers/FlatBuffersError" /** - * Error raised for a malformed buffer or a misused {@link Builder}. + * Error raised for malformed data, excessive nesting or reader/builder misuse. * * **Details** * @@ -74,13 +71,9 @@ const FlatBuffersErrorTypeId = "~effect/encoding/FlatBuffers/FlatBuffersError" * - `InvalidUtf8`: a string is not valid UTF-8. * - `Identifier`: the buffer's file identifier is not the expected one. * - `Limit`: tables are nested deeper than `maxDepth`. - * - `Usage`: a bug in the caller: the builder was called out of order (a - * table inside a table, a struct that isn't the last thing written), got an - * invalid argument (a slot, length or alignment that isn't a valid integer, - * an identifier that isn't four bytes), a table or buffer would outgrow the - * format, or a read doesn't match the shape it asked for (a negative or - * fractional slot, a vector read at another width, a struct read past its - * size). + * - `Usage`: invalid arguments, out-of-order builder calls, format size + * limits, or reads outside the declared struct size or at the wrong vector width. + * {@link decode} rethrows these caller errors. * * @stability experimental * @category errors @@ -121,7 +114,6 @@ const positive = (name: string, n: number): void => { const lenientUtf8 = new TextDecoder("utf-8", { ignoreBOM: true }) const encoder = new TextEncoder() -/** The buffer every reader of one {@link root} shares. */ interface Source { readonly bytes: Uint8Array readonly view: DataView @@ -455,7 +447,6 @@ class TableImpl implements Table { private field(slot: number, size: number): number { if (!Number.isInteger(slot) || slot < 0) fail("Usage", `a slot is a non-negative integer, got ${slot}`) const entry = 4 + slot * 2 - // A slot past the vtable was added after the buffer was written: absent. if (entry >= this.vtableSize) return -1 const relative = this.source.view.getUint16(this.vtable + entry, true) if (relative === 0) return -1 @@ -548,13 +539,13 @@ const identifierBytes = (identifier: string): Uint8Array => { } /** - * The four bytes where a file identifier goes (after the root offset), - * decoded as UTF-8, or `undefined` when the buffer is too short. + * Returns the four bytes after the root offset decoded as UTF-8, or + * `undefined` when the buffer is too short. * * **Details** * - * A buffer doesn't record whether it has an identifier: without one, these - * bytes belong to the root table. Compare the result with the identifier you + * A buffer does not record whether it has an identifier. Without one, these + * bytes are other buffer data. Compare the result with the identifier you * expect, or pass `identifier` to {@link root} or {@link decode}. * * @stability experimental @@ -570,18 +561,21 @@ export const identifier = ( } /** - * The root table of a buffer. Throws a {@link FlatBuffersError} when the - * buffer is malformed or carries another file identifier; its accessors - * throw for malformed fields. + * Returns the root table, throwing a {@link FlatBuffersError} for invalid + * root data or a mismatched file identifier. Fields are checked on access. * * **Details** * - * `identifier` is the four-character file identifier the buffer must carry, - * and `sizePrefixed` says the buffer starts with its size. Reaching a table - * nested more than `maxDepth` tables deep (default 64, the official - * verifier's default) throws a `Limit` error, so a recursive reader can't - * overflow the stack on hostile input. + * `identifier` must encode to exactly four UTF-8 bytes. `sizePrefixed` reads + * the leading size and confines reads to that payload. `maxDepth` is a + * positive integer (default 64); the root has depth 1, and exceeding the + * limit throws a `Limit` error. * + * **Gotchas** + * + * Raising `maxDepth` can expose recursive readers to stack overflow. + * + * @see decode for reading into a `Result` * @stability experimental * @category reading * @since 4.1.5 @@ -618,13 +612,11 @@ export const root = (bytes: Uint8Array, options?: { * becomes a failed `Result` instead of an exception; options are those of * {@link root}. * - * **Details** + * **Gotchas** * - * Reads are lazy, so only the reads made inside `read` are covered: a + * Reads are lazy, so only reads made inside `read` are covered: a * {@link Table} or {@link Vector} returned from it can still throw later. - * `Usage` errors are bugs in the caller (a misshapen identifier, a read of - * the wrong width) and are thrown, as are errors that aren't - * {@link FlatBuffersError}s. + * `Usage` errors and errors other than {@link FlatBuffersError} are rethrown. * * Many offsets may point at one string or vector, so what a reader * materialises is not bounded by the size of the buffer: 1,000 offsets to @@ -670,8 +662,7 @@ const MAX_SIZE = 2 ** 31 const MAX_SLOTS = 32765 /** - * Writes a FlatBuffer back to front, as the official builders do: the same - * calls give the same bytes. + * Writes FlatBuffers tables, structs, vectors and strings back to front. * * **Details** * @@ -1048,7 +1039,7 @@ export class Builder { } /** - * A new {@link Builder}. `forceDefaults` writes scalar fields even when they + * Creates a {@link Builder}. `forceDefaults` writes scalar fields even when they * equal their default; `initialSize` is the first buffer size (it grows as * needed). * From 6630442aa0d1f71cf86d4497214767d855f3c29b Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Sun, 15 Nov 2026 12:27:09 +0000 Subject: [PATCH 07/11] fix(encoding): reject invalid FlatBuffers builder initialSize --- packages/effect/src/encoding/FlatBuffers.ts | 14 +++++++++++--- packages/effect/test/encoding/FlatBuffers.test.ts | 3 +++ 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/packages/effect/src/encoding/FlatBuffers.ts b/packages/effect/src/encoding/FlatBuffers.ts index 69d716273c4..a09a74286a6 100644 --- a/packages/effect/src/encoding/FlatBuffers.ts +++ b/packages/effect/src/encoding/FlatBuffers.ts @@ -697,7 +697,10 @@ export class Builder { private readonly forceDefaults: boolean constructor(options?: { readonly initialSize?: number | undefined; readonly forceDefaults?: boolean | undefined }) { - const size = Math.max(1, options?.initialSize ?? 1024) + const size = options?.initialSize ?? 1024 + if (!Number.isInteger(size) || size < 1 || size > MAX_SIZE) { + fail("Usage", `initialSize must be an integer from 1 to ${MAX_SIZE}, got ${size}`) + } this.bytes = new Uint8Array(size) this.view = new DataView(this.bytes.buffer) this.head = size @@ -1040,8 +1043,13 @@ export class Builder { /** * Creates a {@link Builder}. `forceDefaults` writes scalar fields even when they - * equal their default; `initialSize` is the first buffer size (it grows as - * needed). + * equal their default; `initialSize` is the first buffer size in bytes (it + * grows as needed). + * + * **Details** + * + * `initialSize` is an integer from 1 to 2^31 (default 1024); other values + * throw a `Usage` {@link FlatBuffersError}. * * @stability experimental * @category writing diff --git a/packages/effect/test/encoding/FlatBuffers.test.ts b/packages/effect/test/encoding/FlatBuffers.test.ts index f53b5756b7f..d7a0e3e129c 100644 --- a/packages/effect/test/encoding/FlatBuffers.test.ts +++ b/packages/effect/test/encoding/FlatBuffers.test.ts @@ -281,5 +281,8 @@ describe("FlatBuffers", () => { b.startTable(1) b.addFieldInt32(0.5, 111) }) + for (const initialSize of [0, 1.5, NaN, Infinity, 2 ** 31 + 1]) { + usage(() => FlatBuffers.makeBuilder({ initialSize })) + } }) }) From bbfa79a9eeba280f9efddf118846ff96056386f2 Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Sun, 15 Nov 2026 19:08:36 +0000 Subject: [PATCH 08/11] Share FlatBuffers struct and vector scalar readers --- packages/effect/src/encoding/FlatBuffers.ts | 180 +++++++++----------- 1 file changed, 76 insertions(+), 104 deletions(-) diff --git a/packages/effect/src/encoding/FlatBuffers.ts b/packages/effect/src/encoding/FlatBuffers.ts index a09a74286a6..123adffd215 100644 --- a/packages/effect/src/encoding/FlatBuffers.ts +++ b/packages/effect/src/encoding/FlatBuffers.ts @@ -121,7 +121,7 @@ interface Source { } const check = (view: DataView, at: number, size: number): void => { - if (at < 0 || size < 0 || at + size > view.byteLength) { + if (at < 0 || at + size > view.byteLength) { fail("OutOfBounds", `${size} bytes at ${at} lie outside the ${view.byteLength}-byte buffer`) } } @@ -132,10 +132,16 @@ const indirect = (view: DataView, at: number): number => { return at + view.getUint32(at, true) } +/** Checks a vector (or string) header at `start` and its elements, and returns its length. */ +const lengthAt = (view: DataView, start: number, elementSize: number): number => { + check(view, start, 4) + const length = view.getUint32(start, true) + check(view, start + 4, length * elementSize) + return length +} + const readString = (source: Source, start: number): string => { - check(source.view, start, 4) - const length = source.view.getUint32(start, true) - check(source.view, start + 4, length) + const length = lengthAt(source.view, start, 1) return Utf8.decode(source.bytes, start + 4, start + 4 + length) ?? fail("InvalidUtf8", `the string at ${start} is not valid UTF-8`) } @@ -144,6 +150,57 @@ const readString = (source: Source, start: number): string => { // Reading // ----------------------------------------------------------------------------- +/** Scalar readers shared by structs and vectors; `at` validates and locates each read. */ +abstract class Scalars { + readonly position: number + protected readonly source: Source + + constructor(source: Source, position: number) { + this.source = source + this.position = position + } + + get buffer(): Uint8Array { + return this.source.bytes + } + + protected abstract at(n: number, size: number): number + + bool(n: number): boolean { + return this.source.view.getUint8(this.at(n, 1)) !== 0 + } + int8(n: number): number { + return this.source.view.getInt8(this.at(n, 1)) + } + uint8(n: number): number { + return this.source.view.getUint8(this.at(n, 1)) + } + int16(n: number): number { + return this.source.view.getInt16(this.at(n, 2), true) + } + uint16(n: number): number { + return this.source.view.getUint16(this.at(n, 2), true) + } + int32(n: number): number { + return this.source.view.getInt32(this.at(n, 4), true) + } + uint32(n: number): number { + return this.source.view.getUint32(this.at(n, 4), true) + } + int64(n: number): bigint { + return this.source.view.getBigInt64(this.at(n, 8), true) + } + uint64(n: number): bigint { + return this.source.view.getBigUint64(this.at(n, 8), true) + } + float32(n: number): number { + return this.source.view.getFloat32(this.at(n, 4), true) + } + float64(n: number): number { + return this.source.view.getFloat64(this.at(n, 8), true) + } +} + /** * Reads fields at fixed byte offsets: the fields of a struct, stored inline * in a table or a vector. Reads outside the struct's size throw a `Usage` @@ -184,62 +241,22 @@ export interface Struct { struct(offset: number, size: number): Struct } -class StructImpl implements Struct { - readonly position: number - private readonly source: Source +class StructImpl extends Scalars implements Struct { private readonly size: number /** The caller has checked that the struct lies inside the buffer. */ constructor(source: Source, position: number, size: number) { - this.source = source - this.position = position + super(source, position) this.size = size } - get buffer(): Uint8Array { - return this.source.bytes - } - - private at(offset: number, size: number): number { + protected at(offset: number, size: number): number { if (!Number.isInteger(offset) || offset < 0 || offset + size > this.size) { fail("Usage", `${size} bytes at ${offset} lie outside the ${this.size}-byte struct`) } return this.position + offset } - bool(offset: number): boolean { - return this.source.view.getUint8(this.at(offset, 1)) !== 0 - } - int8(offset: number): number { - return this.source.view.getInt8(this.at(offset, 1)) - } - uint8(offset: number): number { - return this.source.view.getUint8(this.at(offset, 1)) - } - int16(offset: number): number { - return this.source.view.getInt16(this.at(offset, 2), true) - } - uint16(offset: number): number { - return this.source.view.getUint16(this.at(offset, 2), true) - } - int32(offset: number): number { - return this.source.view.getInt32(this.at(offset, 4), true) - } - uint32(offset: number): number { - return this.source.view.getUint32(this.at(offset, 4), true) - } - int64(offset: number): bigint { - return this.source.view.getBigInt64(this.at(offset, 8), true) - } - uint64(offset: number): bigint { - return this.source.view.getBigUint64(this.at(offset, 8), true) - } - float32(offset: number): number { - return this.source.view.getFloat32(this.at(offset, 4), true) - } - float64(offset: number): number { - return this.source.view.getFloat64(this.at(offset, 8), true) - } struct(offset: number, size: number): Struct { positive("size", size) return new StructImpl(this.source, this.at(offset, size), size) @@ -292,27 +309,20 @@ export interface Vector { struct(index: number): Struct } -class VectorImpl implements Vector { - readonly position: number +class VectorImpl extends Scalars implements Vector { readonly length: number - private readonly source: Source private readonly elementSize: number private readonly depth: number /** The caller has checked that all `length` elements lie inside the buffer. */ constructor(source: Source, position: number, length: number, elementSize: number, depth: number) { - this.source = source - this.position = position + super(source, position) this.length = length this.elementSize = elementSize this.depth = depth } - get buffer(): Uint8Array { - return this.source.bytes - } - - private at(index: number, size: number): number { + protected at(index: number, size: number): number { if (size !== this.elementSize) { fail("Usage", `a ${size}-byte read from a vector of ${this.elementSize}-byte elements`) } @@ -322,39 +332,6 @@ class VectorImpl implements Vector { return this.position + index * size } - bool(index: number): boolean { - return this.source.view.getUint8(this.at(index, 1)) !== 0 - } - int8(index: number): number { - return this.source.view.getInt8(this.at(index, 1)) - } - uint8(index: number): number { - return this.source.view.getUint8(this.at(index, 1)) - } - int16(index: number): number { - return this.source.view.getInt16(this.at(index, 2), true) - } - uint16(index: number): number { - return this.source.view.getUint16(this.at(index, 2), true) - } - int32(index: number): number { - return this.source.view.getInt32(this.at(index, 4), true) - } - uint32(index: number): number { - return this.source.view.getUint32(this.at(index, 4), true) - } - int64(index: number): bigint { - return this.source.view.getBigInt64(this.at(index, 8), true) - } - uint64(index: number): bigint { - return this.source.view.getBigUint64(this.at(index, 8), true) - } - float32(index: number): number { - return this.source.view.getFloat32(this.at(index, 4), true) - } - float64(index: number): number { - return this.source.view.getFloat64(this.at(index, 8), true) - } string(index: number): string { return readString(this.source, indirect(this.source.view, this.at(index, 4))) } @@ -520,9 +497,7 @@ class TableImpl implements Table { const at = this.field(slot, 4) if (at === -1) return undefined const start = indirect(this.source.view, at) - check(this.source.view, start, 4) - const length = this.source.view.getUint32(start, true) - check(this.source.view, start + 4, length * elementSize) + const length = lengthAt(this.source.view, start, elementSize) return new VectorImpl(this.source, start + 4, length, elementSize, this.depth) } bytes(slot: number): Uint8Array | undefined { @@ -531,7 +506,8 @@ class TableImpl implements Table { } } -const identifierBytes = (identifier: string): Uint8Array => { +const identifierBytes = (identifier: string | undefined): Uint8Array | undefined => { + if (identifier === undefined) return undefined const bytes = encoder.encode(identifier) return bytes.length === 4 ? bytes @@ -587,7 +563,7 @@ export const root = (bytes: Uint8Array, options?: { }): Table => { const maxDepth = options?.maxDepth ?? 64 positive("maxDepth", maxDepth) - const expected = options?.identifier === undefined ? undefined : identifierBytes(options.identifier) + const expected = identifierBytes(options?.identifier) let data = bytes if (options?.sizePrefixed) { if (bytes.length < 4) fail("OutOfBounds", "a size-prefixed buffer needs at least 4 bytes") @@ -1028,7 +1004,7 @@ export class Builder { }): Uint8Array { this.notNested("finish") if (this.finished) fail("Usage", "finish called twice") - const identifier = options?.identifier === undefined ? undefined : identifierBytes(options.identifier) + const identifier = identifierBytes(options?.identifier) this.prep(this.minAlign, 4 + (identifier === undefined ? 0 : 4) + (options?.sizePrefixed ? 4 : 0)) if (identifier !== undefined) { this.prep(4, 4) @@ -1042,14 +1018,10 @@ export class Builder { } /** - * Creates a {@link Builder}. `forceDefaults` writes scalar fields even when they - * equal their default; `initialSize` is the first buffer size in bytes (it - * grows as needed). - * - * **Details** - * - * `initialSize` is an integer from 1 to 2^31 (default 1024); other values - * throw a `Usage` {@link FlatBuffersError}. + * Creates a {@link Builder}. `forceDefaults` writes scalar fields even when + * they equal their default. `initialSize` is the first buffer size in bytes, + * an integer from 1 to 2^31 (default 1024); the buffer grows as needed, and + * other values throw a `Usage` {@link FlatBuffersError}. * * @stability experimental * @category writing From d46f0e2594461821a185f7c201e90915cef8ecc1 Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Sun, 15 Nov 2026 19:08:36 +0000 Subject: [PATCH 09/11] Shorten FlatBuffers changeset --- .changeset/encoding-flatbuffers.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.changeset/encoding-flatbuffers.md b/.changeset/encoding-flatbuffers.md index 192806a840c..1346ee20b47 100644 --- a/.changeset/encoding-flatbuffers.md +++ b/.changeset/encoding-flatbuffers.md @@ -2,4 +2,4 @@ "effect": patch --- -Add experimental `effect/encoding/FlatBuffers` support for reading and writing FlatBuffers without a schema compiler or runtime dependency. +Add experimental `effect/encoding/FlatBuffers` for reading and writing FlatBuffers without a schema compiler. From c3503c17e267e3d1775c4dcf7d6a0e7524e3da1e Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Sun, 15 Nov 2026 19:44:17 +0000 Subject: [PATCH 10/11] Map FlatBuffers assertions to focused format tests --- .../test/encoding/FlatBuffers.conformance.md | 75 +++++++++++++ .../effect/test/encoding/FlatBuffers.test.ts | 101 ++++++++++++++++++ 2 files changed, 176 insertions(+) create mode 100644 packages/effect/test/encoding/FlatBuffers.conformance.md diff --git a/packages/effect/test/encoding/FlatBuffers.conformance.md b/packages/effect/test/encoding/FlatBuffers.conformance.md new file mode 100644 index 00000000000..15dba21940a --- /dev/null +++ b/packages/effect/test/encoding/FlatBuffers.conformance.md @@ -0,0 +1,75 @@ +# FlatBuffers assertion reference + +This reference inventories the public low-level encoding boundary in +`FlatBuffers.test.ts` for maintainers. It maps existing regression assertions before +adding focused format examples; it is not a claim of complete FlatBuffers conformance. + +## Authoritative sources + +The upstream Google FlatBuffers documentation is pinned to commit +`569e6cb461738f0aefccbada0f04afefe1a43a1a`, resolved with the GitHub commits API +for `docs/source/internals.md` and read through the contents API at that SHA. + +- [F: FlatBuffer Internals](https://github.com/google/flatbuffers/blob/569e6cb461738f0aefccbada0f04afefe1a43a1a/docs/source/internals.md): + Format components, Offsets, Structs, Tables, Strings and Vectors, Encoding example. + Only the FlatBuffers portion applies, not the separate FlexBuffers format. +- [S: Schemas](https://github.com/google/flatbuffers/blob/569e6cb461738f0aefccbada0f04afefe1a43a1a/docs/source/schema.md): + UTF-8 strings and four-character file identifiers at bytes 4–7. + +`MONSTER` and `PREFIXED` predate this inventory and record their producer as the +official Python builder, PyPI `flatbuffers` 25.12.19. They are interoperability +fixtures, not normative byte layouts or newly regenerated upstream artifacts. +F explicitly allows different valid layouts for identical values. + +## Assertion-to-test map + +All exact test names below are under `describe("FlatBuffers")` in +`FlatBuffers.test.ts`. IDs are stable and appear beside their tests. +**N** denotes a normative format assertion, **I** a particular interoperability +fixture, and **P** a local API/safety policy (not an upstream requirement). + +| ID | Exact test name | Assertion and source / boundary | +| --------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| FB-I01 | builds the bytes the official builder builds | Exact `MONSTER` and size-prefixed `PREFIXED` byte equality with the recorded Python producer, including its field ordering, padding, sharing and default handling. Not a canonical-layout requirement. | +| FB-N01 / FB-I02 | reads the official builder's bytes | F: reads root-relative offsets, inline float32 structs, absent/default int16, present int16, strings, byte vectors, offset-vector tables, padded signed integer structs, and bool from `MONSTER`. S: reads `MONS` identifier. I02: also reads size-prefixed `ABCD`, its string, and explicitly stored scalar default from `PREFIXED`; prefix framing is interoperability coverage here. | +| FB-N02 | reads absent fields as their defaults | F Tables: zero vtable entries and slots beyond the vtable return caller defaults. Undefined reference results are the local API representation of absence. | +| FB-N03 | reads the specification encoding example | F Encoding example: independently transcribed wire bytes yield inline IEEE-754 little-endian floats `[1, 2, 3]`, absent mana/default 150, hp 50 and string `fred`. No local builder supplies the oracle. | +| FB-N04 | reads a vtable after its table | F Tables: a hand-authored root at 4 with signed vtable displacement -8 resolves the vtable at 12, reads int32 value 42, and returns default 7 for an absent later slot. | +| FB-N05 | reads independently encoded binary64 and unsigned scalars | F Format components: hand-authored little-endian binary64 bytes decode to 1.5, positive/negative zero, positive/negative infinity and NaN; uint32 and uint64 preserve high-bit values and their unsigned maxima. Signed zero is distinguished; NaN payload preservation is not asserted. No local builder supplies the oracle. | +| FB-P01 | decode returns a failure for malformed input | Local `OutOfBounds`, `InvalidVtable`, `InvalidUtf8`, and `Identifier` classification for the listed malformed fixtures. S requires UTF-8, but does not prescribe these errors or lazy validation. | +| FB-P02 | decode rethrows errors that aren't FlatBuffersErrors | Local propagation of an arbitrary callback exception. | +| FB-P03 | only fails with FlatBuffersError on truncated or corrupted buffers | Every truncation before the final string terminator fails the selected traversal; every single-byte XOR corruption completes or reports a FlatBuffersError rather than leaking another error. Does not assert every corruption is invalid. | +| FB-P04 | fails tables nested deeper than maxDepth | Local default depth limit rejects a 65-table chain; configured limit 65 reads it. | +| FB-P05 | throws for reads that don't match the shape asked for, even inside decode | Local Usage errors for mismatched vector width, zero width, out-of-range/negative/NaN struct reads, invalid slots and identifier arguments. | +| FB-P06 | keeps UTF-8 strings and identifiers intact, byte order mark included | Local BOM preservation in strings and a four-UTF-8-byte identifier. This non-ASCII identifier is not evidence of S's four-character identifier requirement. | +| FB-P07 | forceDefaults writes scalar defaults but leaves absent references absent | Local builder option writes scalar zero while zero offset remains absent. | +| FB-P08 | Builder rejects misuse | Local Usage errors for nesting/state/finish misuse, non-inline structs, invalid offsets, slots, identifier length, sizes and alignments. Includes rejecting 64-KiB inline data / excessive slot count that exceed F's uint16 vtable representation. | + +## Exclusions and gaps + +- No full-buffer verifier claim: traversal checks only requested fields. The + truncation test deliberately does not require the final string NUL to be read. + F requires NUL-terminated strings; writer termination is covered by fixture + parity, but reader rejection of a missing/nonzero terminator is not asserted. +- Scalar coverage remains selective: FB-N05 covers binary64 special values and + high-bit unsigned values, not every scalar-width edge value or NaN payload. +- Existing fixtures exercise some sharing, padding and vector layouts; they do + not exhaust alternate field orders, all alignments, empty vectors/strings, + repeated-offset aliases or all valid table/vtable sharing arrangements. +- No schema compiler, schema evolution suite, union discriminator validation, + required/key fields, sorted-vector lookup, reflection, 64-bit offsets or + FlexBuffers coverage. These are not inferred from low-level table reads. +- Size-prefixed framing is mapped only to the recorded producer fixture, not + elevated to a requirement from the pinned format document. No broad cross-language + or producer-version compatibility claim is made. + +## Validation + +Run from the repository root: + +```sh +nix develop -c pnpm test --run packages/effect/test/encoding/FlatBuffers.test.ts +``` + +The suite retains all existing regressions and adds only three independent +format-reader examples (FB-N03, FB-N04 and FB-N05). No production behavior is changed. diff --git a/packages/effect/test/encoding/FlatBuffers.test.ts b/packages/effect/test/encoding/FlatBuffers.test.ts index d7a0e3e129c..eed0e4bbb4f 100644 --- a/packages/effect/test/encoding/FlatBuffers.test.ts +++ b/packages/effect/test/encoding/FlatBuffers.test.ts @@ -4,6 +4,7 @@ import { Result } from "effect" import * as FlatBuffers from "effect/encoding/FlatBuffers" import * as Hex from "effect/encoding/Hex" +// Assertion IDs and immutable source links: ./FlatBuffers.conformance.md const fromHex = (hex: string) => Result.getOrThrow(Hex.decode(hex)) // The expected bytes were written by the official FlatBuffers Python builder @@ -95,11 +96,102 @@ const usage = (f: () => unknown) => }) describe("FlatBuffers", () => { + // FB-N03: internals.md (Encoding example), transcribed independently of our builder. + it("reads the specification encoding example", () => { + const bytes = fromHex( + "1400000010001600040000001400100000000000" + + "100000000000803f00000040000040400800000032000000" + + "040000006672656400000000" + ) + const root = FlatBuffers.root(bytes) + const pos = root.struct(0, 12)! + assert.deepStrictEqual([pos.float32(0), pos.float32(4), pos.float32(8)], [1, 2, 3]) + assert.isFalse(root.has(1)) + assert.strictEqual(root.int16(1, 150), 150) + assert.strictEqual(root.int16(2), 50) + assert.strictEqual(root.string(3), "fred") + }) + + // FB-N04: internals.md (Tables): subtract the signed offset; vtables may follow objects. + it("reads a vtable after its table", () => { + // Root at 4; table contains -8 and value 42; vtable at 12 has size 6, object size 8, field offset 4. + const root = FlatBuffers.root(fromHex("04000000f8ffffff2a000000060008000400")) + assert.isTrue(root.has(0)) + assert.strictEqual(root.int32(0), 42) + assert.strictEqual(root.int32(1, 7), 7) + }) + + // FB-N05: internals.md (Format components): little-endian IEEE-754 and unsigned scalars. + it("reads independently encoded binary64 and unsigned scalars", () => { + // Root at 16; vtable at 4; fields at table offsets 8 (double), 16 (ulong), 4 (uint). + // All wire values are hand-authored, not produced by the local builder. + const header = "100000000a00180008001000040000000c000000" + const cases = [ + { + double: "000000000000f83f", + expected: 1.5, + uint: "00000080", + ulong: "0000000000000080", + u32: 2147483648, + u64: 9223372036854775808n + }, + { + double: "0000000000000000", + expected: 0, + uint: "ffffffff", + ulong: "ffffffffffffffff", + u32: 4294967295, + u64: 18446744073709551615n + }, + { + double: "0000000000000080", + expected: -0, + uint: "01000080", + ulong: "0100000000000080", + u32: 2147483649, + u64: 9223372036854775809n + }, + { + double: "000000000000f07f", + expected: Infinity, + uint: "00000080", + ulong: "0000000000000080", + u32: 2147483648, + u64: 9223372036854775808n + }, + { + double: "000000000000f0ff", + expected: -Infinity, + uint: "ffffffff", + ulong: "ffffffffffffffff", + u32: 4294967295, + u64: 18446744073709551615n + }, + { + double: "000000000000f87f", + expected: NaN, + uint: "01000080", + ulong: "0100000000000080", + u32: 2147483649, + u64: 9223372036854775809n + } + ] + for (const row of cases) { + const root = FlatBuffers.root(fromHex(header + row.uint + row.double + row.ulong)) + // Object.is distinguishes signed zero and compares NaN without asserting a NaN payload. + assert.isTrue(Object.is(root.float64(0), row.expected), row.double) + assert.strictEqual(root.uint64(1), row.u64) + assert.strictEqual(root.uint32(2), row.u32) + } + }) + + // FB-I01: Python-builder byte parity; not a canonical wire layout. it("builds the bytes the official builder builds", () => { assert.strictEqual(Hex.encode(buildMonster()), MONSTER) assert.strictEqual(Hex.encode(buildPrefixed()), PREFIXED) }) + // FB-N01 / FB-I02: internals.md (Offsets, Structs, Tables, Strings and Vectors); schema.md (identifiers). it("reads the official builder's bytes", () => { const monster = fromHex(MONSTER) assert.strictEqual(FlatBuffers.identifier(monster), "MONS") @@ -122,6 +214,7 @@ describe("FlatBuffers", () => { assert.strictEqual(root.int32(1), 7) }) + // FB-N02: internals.md (Tables): zero and out-of-range vtable entries mean absent. it("reads absent fields as their defaults", () => { const b = FlatBuffers.makeBuilder() b.startTable(1) @@ -134,6 +227,7 @@ describe("FlatBuffers", () => { assert.strictEqual(root.float64(100, 1.5), 1.5) }) + // FB-P01: local error classification; schema.md requires UTF-8, not this error API. it("decode returns a failure for malformed input", () => { const failure = (bytes: Uint8Array, options?: Parameters[2]) => { const result = FlatBuffers.decode(bytes, (root) => root.string(0), options) @@ -153,6 +247,7 @@ describe("FlatBuffers", () => { assert.strictEqual(failure(Uint8Array.of(0xff, 0, 0, 0, 0, 0, 0, 0), { sizePrefixed: true }), "OutOfBounds") }) + // FB-P02: local callback error propagation. it("decode rethrows errors that aren't FlatBuffersErrors", () => { assert.throws(() => FlatBuffers.decode(fromHex(MONSTER), () => { @@ -160,6 +255,7 @@ describe("FlatBuffers", () => { }), "boom") }) + // FB-P03: local bounded-read safety, not full-buffer verification. it("only fails with FlatBuffersError on truncated or corrupted buffers", () => { const monster = fromHex(MONSTER) for (let i = 0; i < monster.length; i++) { @@ -174,6 +270,7 @@ describe("FlatBuffers", () => { } }) + // FB-P04: local configurable traversal limit. it("fails tables nested deeper than maxDepth", () => { const b = FlatBuffers.makeBuilder() let table = 0 @@ -192,6 +289,7 @@ describe("FlatBuffers", () => { assert.deepStrictEqual(FlatBuffers.decode(bytes, depth, { maxDepth: 65 }), Result.succeed(65)) }) + // FB-P05: local shape/argument validation. it("throws for reads that don't match the shape asked for, even inside decode", () => { const monster = fromHex(MONSTER) const root = FlatBuffers.root(monster) @@ -205,6 +303,7 @@ describe("FlatBuffers", () => { usage(() => FlatBuffers.decode(monster, (root) => root.has(0), { identifier: "TOOLONG" })) }) + // FB-P06: local BOM preservation, including a four-byte non-ASCII identifier. it("keeps UTF-8 strings and identifiers intact, byte order mark included", () => { const b = FlatBuffers.makeBuilder() const s = b.createString("\ufeffhello") @@ -215,6 +314,7 @@ describe("FlatBuffers", () => { assert.strictEqual(FlatBuffers.identifier(bytes), "\ufeffA") }) + // FB-P07: local forceDefaults option; absent-reference behavior. it("forceDefaults writes scalar defaults but leaves absent references absent", () => { const b = FlatBuffers.makeBuilder({ forceDefaults: true }) b.startTable(2) @@ -226,6 +326,7 @@ describe("FlatBuffers", () => { assert.isTrue(root.has(1)) }) + // FB-P08: local builder state/argument validation (includes 16-bit vtable capacity). it("Builder rejects misuse", () => { const builder = (f: (b: FlatBuffers.Builder) => void) => usage(() => f(FlatBuffers.makeBuilder())) builder((b) => { From ae79f9947438c875ad421c2b0c341cb0dea4e881 Mon Sep 17 00:00:00 2001 From: Effect Bot Date: Sun, 15 Nov 2026 20:18:46 +0000 Subject: [PATCH 11/11] Correct FlatBuffers absence and presence assertion mapping --- packages/effect/test/encoding/FlatBuffers.conformance.md | 4 ++-- packages/effect/test/encoding/FlatBuffers.test.ts | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/packages/effect/test/encoding/FlatBuffers.conformance.md b/packages/effect/test/encoding/FlatBuffers.conformance.md index 15dba21940a..e4e6bef063f 100644 --- a/packages/effect/test/encoding/FlatBuffers.conformance.md +++ b/packages/effect/test/encoding/FlatBuffers.conformance.md @@ -32,7 +32,7 @@ fixture, and **P** a local API/safety policy (not an upstream requirement). | --------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | FB-I01 | builds the bytes the official builder builds | Exact `MONSTER` and size-prefixed `PREFIXED` byte equality with the recorded Python producer, including its field ordering, padding, sharing and default handling. Not a canonical-layout requirement. | | FB-N01 / FB-I02 | reads the official builder's bytes | F: reads root-relative offsets, inline float32 structs, absent/default int16, present int16, strings, byte vectors, offset-vector tables, padded signed integer structs, and bool from `MONSTER`. S: reads `MONS` identifier. I02: also reads size-prefixed `ABCD`, its string, and explicitly stored scalar default from `PREFIXED`; prefix framing is interoperability coverage here. | -| FB-N02 | reads absent fields as their defaults | F Tables: zero vtable entries and slots beyond the vtable return caller defaults. Undefined reference results are the local API representation of absence. | +| FB-N02 | reads absent fields as their defaults | F Tables: slots beyond the trimmed four-byte vtable return caller defaults. Zero-entry defaults are exercised by FB-N01 and FB-N03. Undefined reference results are the local API representation of absence. | | FB-N03 | reads the specification encoding example | F Encoding example: independently transcribed wire bytes yield inline IEEE-754 little-endian floats `[1, 2, 3]`, absent mana/default 150, hp 50 and string `fred`. No local builder supplies the oracle. | | FB-N04 | reads a vtable after its table | F Tables: a hand-authored root at 4 with signed vtable displacement -8 resolves the vtable at 12, reads int32 value 42, and returns default 7 for an absent later slot. | | FB-N05 | reads independently encoded binary64 and unsigned scalars | F Format components: hand-authored little-endian binary64 bytes decode to 1.5, positive/negative zero, positive/negative infinity and NaN; uint32 and uint64 preserve high-bit values and their unsigned maxima. Signed zero is distinguished; NaN payload preservation is not asserted. No local builder supplies the oracle. | @@ -42,7 +42,7 @@ fixture, and **P** a local API/safety policy (not an upstream requirement). | FB-P04 | fails tables nested deeper than maxDepth | Local default depth limit rejects a 65-table chain; configured limit 65 reads it. | | FB-P05 | throws for reads that don't match the shape asked for, even inside decode | Local Usage errors for mismatched vector width, zero width, out-of-range/negative/NaN struct reads, invalid slots and identifier arguments. | | FB-P06 | keeps UTF-8 strings and identifiers intact, byte order mark included | Local BOM preservation in strings and a four-UTF-8-byte identifier. This non-ASCII identifier is not evidence of S's four-character identifier requirement. | -| FB-P07 | forceDefaults writes scalar defaults but leaves absent references absent | Local builder option writes scalar zero while zero offset remains absent. | +| FB-P07 | forceDefaults writes scalar defaults but leaves absent references absent | Local builder option keeps the default-valued scalar slot present while zero reference offsets remain absent; this test checks presence, not the stored scalar value. | | FB-P08 | Builder rejects misuse | Local Usage errors for nesting/state/finish misuse, non-inline structs, invalid offsets, slots, identifier length, sizes and alignments. Includes rejecting 64-KiB inline data / excessive slot count that exceed F's uint16 vtable representation. | ## Exclusions and gaps diff --git a/packages/effect/test/encoding/FlatBuffers.test.ts b/packages/effect/test/encoding/FlatBuffers.test.ts index eed0e4bbb4f..d91eb54a8b3 100644 --- a/packages/effect/test/encoding/FlatBuffers.test.ts +++ b/packages/effect/test/encoding/FlatBuffers.test.ts @@ -214,7 +214,7 @@ describe("FlatBuffers", () => { assert.strictEqual(root.int32(1), 7) }) - // FB-N02: internals.md (Tables): zero and out-of-range vtable entries mean absent. + // FB-N02: internals.md (Tables): slots beyond the trimmed vtable mean absent. it("reads absent fields as their defaults", () => { const b = FlatBuffers.makeBuilder() b.startTable(1)