json-as 1.0.0-alpha.4 → 1.0.0-beta.10

package/.trunk/configs/.markdownlint.yaml

@@ -0,0 +1,2 @@
+# Prettier friendly markdownlint config (all formatting rules disabled)
+extends: markdownlint/style/prettier

package/.trunk/configs/.shellcheckrc

@@ -0,0 +1,7 @@
+enable=all
+source-path=SCRIPTDIR
+disable=SC2154
+
+# If you're having issues with shellcheck following source, disable the errors via:
+# disable=SC1090
+# disable=SC1091

package/.trunk/configs/.yamllint.yaml

@@ -0,0 +1,7 @@
+rules:
+  quoted-strings:
+    required: only-when-needed
+    extra-allowed: ["{|}"]
+  key-duplicates: {}
+  octal-values:
+    forbid-implicit-octal: true

package/.trunk/trunk.yaml

@@ -0,0 +1,37 @@
+# This file controls the behavior of Trunk: https://docs.trunk.io/cli
+# To learn more about the format of this file, see https://docs.trunk.io/reference/trunk-yaml
+version: 0.1
+cli:
+  version: 1.22.10
+# Trunk provides extensibility via plugins. (https://docs.trunk.io/plugins)
+plugins:
+  sources:
+    - id: trunk
+      ref: v1.6.7
+      uri: https://github.com/trunk-io/plugins
+# Many linters and tools depend on runtimes - configure them here. (https://docs.trunk.io/runtimes)
+runtimes:
+  enabled:
+    - go@1.21.0
+    - node@18.20.5
+    - python@3.10.8
+# This is the section where you manage your linters. (https://docs.trunk.io/check/configuration)
+lint:
+  disabled:
+    - markdownlint
+  enabled:
+    - actionlint@1.7.7
+    - checkov@3.2.377
+    - git-diff-check
+    - prettier@3.5.2
+    - shellcheck@0.10.0
+    - shfmt@3.6.0
+    - trufflehog@3.88.13
+    - yamllint@1.35.1
+actions:
+  disabled:
+    - trunk-announce
+    - trunk-check-pre-push
+    - trunk-fmt-pre-commit
+  enabled:
+    - trunk-upgrade-available

package/CHANGELOG

@@ -1,5 +1,65 @@
 # Change Log
 
+## 2025-03-04 - 1.0.0-beta.10
+
+- fix: transform not generating the right load operations for keys
+- fix: whitespace not working in objects or struct deserialization
+- fix: JSON.Raw not working when deserializing as Map<string, JSON.Raw>
+
+## 2025-03-03 - 1.0.0-beta.9
+
+- rename: change libs folder to lib
+
+## 2025-03-03 - 1.0.0-beta.8
+
+- docs: add instructions for using `--lib` in README
+
+## 2025-03-03 - 1.0.0-beta.7
+
+- fix: add as-bs to `--lib` section
+- chore: clean up transform
+- refactor: transform should import `~lib/as-bs.ts` instead of relative path
+
+## 2025-03-01 - 1.0.0-beta.6
+
+- fix: import from base directory index.ts
+
+## 2025-03-01 - 1.0.0-beta.5
+
+- fix: revert pull request [#112](https://github.com/JairusSW/json-as/pull/112)
+
+## 2025-02-25 - 1.0.0-beta.4
+
+- fix: warn on presence of invalid types contained in a schema [#112](https://github.com/JairusSW/json-as/pull/112)
+
+## 2025-02-25 - 1.0.0-beta.3
+
+- feat: change `JSON.Raw` to actual class to facilitate proper support without transformations
+- fix: remove old `JSON.Raw` logic from transform code
+
+## 2025-02-25 - 1.0.0-beta.2
+
+- feat: add support for custom serializers and deserializers [#110](https://github.com/JairusSW/json-as/pull/110)
+
+## 2025-02-22 - 1.0.0-beta.1
+
+- perf: add benchmarks for both AssemblyScript and JavaScript
+- docs: publish preliminary benchmark results
+- tests: ensure nested serialization works and add to tests
+- feat: finish arbitrary type implementation
+- feat: introduce `JSON.Obj` to handle objects effectively
+- feat: reimplement arbitrary array deserialization
+- fix: remove brace check on array deserialization
+- feat: introduce native support for `JSON.Obj` transformations
+- feat: implement arbitrary object serialization
+- fix: deserialization of booleans panics on `false`
+- fix: `bs.resize` should be type-safe
+- impl: add `JSON.Obj` type as prototype to handle arbitrary object structures
+- chore: rename static objects (schemas) to structs and name arbitrary objects as `obj`
+- tests: add proper tests for arbitrary types
+- fix: empty method generation using outdated function signature
+- docs: update readme to be more concise
+
 ## 2025-02-13 - 1.0.0-alpha.4
 
 - feat: reintroduce support for `Box<T>`-wrapped primitive types

package/README.md

@@ -6,47 +6,54 @@
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v1.0.0-alpha.4
+    AssemblyScript - v1.0.0-beta.10
   </pre>
 </h5>
 
-## Contents
- - [About](#about)
- - [Installation](#installation)
- - [Usage](#usage)
- - [Examples](#examples)
- - [Performance](#performance)
- - [License](#license)
- - [Contact](#contact)
+## 📝 About
 
-## About
+JSON is the de-facto serialization format of modern web applications, but its serialization and deserialization remain a significant performance bottleneck, especially at scale. Traditional parsing approaches are computationally expensive, adding unnecessary overhead to both clients and servers. This library is designed to mitigate this by leveraging SIMD acceleration and highly optimized transformations.
 
-## Installation
+## 📚 Contents
+
+- [Installation](#-installation)
+- [Usage](#-usage)
+- [Examples](#-examples)
+  - [Omitting Fields](#️-omitting-fields)
+  - [Nullable Primitives](#️-using-nullable-primitives)
+  - [Unknown or Dynamic Data](#-working-with-unknown-or-dynamic-data)
+  - [Using Raw JSON Strings](#️-using-raw-json-strings)
+  - [Custom Serializers](#️-using-custom-serializers-or-deserializers)
+- [Performance](#-performance)
+- [License](#-license)
+- [Contact](#-contact)
+
+## 💾 Installation
 
 ```bash
-npm install json-as@1.0.0-alpha.3
+npm install json-as@1.0.0-beta.10
 ```
 
 Add the `--transform` to your `asc` command (e.g. in package.json)
 
 ```bash
---transform json-as
+--transform json-as/transform --lib json-as/lib
 ```
 
 Alternatively, add it to your `asconfig.json`
 
-```
+```json
 {
-  // ...
   "options": {
-    "transform": ["json-as/transform"]
+    "transform": ["json-as/transform"],
+    "lib": ["json-as/lib"]
   }
 }
 ```
 
 If you'd like to see the code that the transform generates, run with `JSON_DEBUG=true`
 
-## Usage
+## 🪄 Usage
 
 ```js
 import { JSON } from "json-as";
@@ -75,7 +82,7 @@ class Player {
 const player: Player = {
   firstName: "Jairus",
   lastName: "Tanaka",
-  lastActive: [2, 7, 2025],
+  lastActive: [2, 13, 2025],
   age: 18,
   pos: {
     x: 3.4,
@@ -86,56 +93,304 @@ const player: Player = {
 };
 
 const serialized = JSON.stringify<Player>(player);
-const parsed = JSON.parse<Player>(serialized);
+const deserialized = JSON.parse<Player>(serialized);
 
-console.log("Serialized: " + serialized);
-console.log("Parsed: " + JSON.stringify(parsed));
+console.log("Serialized    " + serialized);
+console.log("Deserialized  " + JSON.stringify(deserialized));
 ```
 
-## Examples
+## 🔍 Examples
+
+### 🏷️ Omitting Fields
+
+This library allows selective omission of fields during serialization using the following decorators:
+
+**@omit**
 
-Classes can even have inheritance. Here's a nasty example
+This decorator excludes a field from serialization entirely.
 
 ```js
 @json
-class Base {}
+class Example {
+  name!: string;
+  @omit
+  secret!: string;
+}
+
+const obj = new Example();
+obj.name = "Visible";
+obj.secret = "Hidden";
+
+console.log(JSON.stringify(obj)); // { "name": "Visible" }
+```
 
+**@omitnull**
+
+This decorator omits a field only if its value is null.
+
+```js
 @json
-class Vec1 extends Base {
-  x: f32 = 1.0;
+class Example {
+  name!: string;
+  @omitnull()
+  optionalField!: string | null;
 }
+
+const obj = new Example();
+obj.name = "Present";
+obj.optionalField = null;
+
+console.log(JSON.stringify(obj)); // { "name": "Present" }
+
+@omitif((self: this) => condition)
+
+This decorator omits a field based on a custom predicate function.
+
 @json
-class Vec2 extends Vec1 {
-  y: f32 = 2.0;
+class Example {
+  name!: string;
+  @omitif((self: Example) => self.age < 18)
+  age!: number;
 }
+
+const obj = new Example();
+obj.name = "John";
+obj.age = 16;
+
+console.log(JSON.stringify(obj)); // { "name": "John" }
+```
+
+If age were 18 or higher, it would be included in the serialization.
+
+### 🗳️ Using nullable primitives
+
+AssemblyScript doesn't support using nullable primitive types, so instead, json-as offers the `JSON.Box` class to remedy it.
+
+For example, this schema won't compile in AssemblyScript:
+
+```js
+@json
+class Person {
+  name!: string;
+  age: i32 | null = null;
+}
+```
+
+Instead, use `JSON.Box` to allow nullable primitives:
+
+```js
 @json
-class Vec3 extends Vec2 {
-  z: f32 = 3.0;
+class Person {
+  name: string;
+  age: JSON.Box<i32> | null = null;
+  constructor(name: string) {
+    this.name = name;
+  }
 }
 
-const arr: Base[] = [
-  new Vec1(),
-  new Vec2(),
-  new Vec3()
-];
+const person = new Person("Bob");
+console.log(JSON.stringify(person)); // {"name":"Bob","age":null}
 
-const serialized = JSON.stringify(arr);
-// [{"x":1.0},{"x":1.0,"y":2.0},{"y":2.0,"x":1.0,"z":3.0}]
-const parsed = JSON.parse<Base[]>(serialized);
+person.age = new JSON.Box<i32>(18); // Set age to 18
+console.log(JSON.stringify(person)); // {"name":"Bob","age":18}
 ```
 
-You can also add it to your `asconfig.json`
+### 📤 Working with unknown or dynamic data
 
-```json
-{
-  // ...
-  "options": {
-    "transform": ["json-as/transform"]
+Sometimes it's necessary to work with unknown data or data with dynamic types.
+
+Because AssemblyScript is a statically-typed language, that typically isn't allowed, so json-as provides the `JSON.Value` and `JSON.Obj` types.
+
+Here's a few examples:
+
+**Working with multi-type arrays**
+
+When dealing with arrays that have multiple types within them, eg. `["string",true,null,["array"]]`, use `JSON.Value[]`
+
+```js
+const a1 = JSON.parse<JSON.Value[]>('["string",true,null,["array"]]');
+console.log(JSON.stringify(a[0])); // "string"
+console.log(JSON.stringify(a[1])); // true
+console.log(JSON.stringify(a[2])); // null
+console.log(JSON.stringify(a[3])); // ["array"]
+```
+
+**Working with unknown objects**
+
+When dealing with an object with an unknown structure, use the `JSON.Obj` type
+
+```js
+const o1 = JSON.parse<JSON.Obj>('{"a":3.14,"b":true,"c":[1,2,3],"d":{"x":1,"y":2,"z":3}}');
+
+console.log(o1.keys().join(" ")); // a b c d
+console.log(
+  o1.values()
+  .map<string>((v) => JSON.stringify(v))
+  .join(" ")
+); // 3.14 true [1,2,3] {"x":1,"y":2,"z":3}
+
+const y = o1.get("d").get<JSON.Obj>().get<i32>();
+console.log('o1["d"]["y"] = ' + y.toString()); // o1["d"]["y"] = 2
+```
+
+**Working with dynamic types within a schema**
+
+More often, objects will be completely statically typed except for one or two values.
+
+In such cases, `JSON.Value` can be used to handle fields that may hold different types at runtime.
+
+```js
+@json
+class DynamicObj {
+  id: i32 = 0;
+  name: string = "";
+  data!: JSON.Value; // Can hold any type of value
+}
+
+const obj = new DynamicObj();
+obj.id = 1;
+obj.name = "Example";
+obj.data = JSON.parse<JSON.Value>('{"key":"value"}'); // Assigning an object
+
+console.log(JSON.stringify(obj)); // {"id":1,"name":"Example","data":{"key":"value"}}
+
+obj.data = JSON.Value.from<i32>(42); // Changing to an integer
+console.log(JSON.stringify(obj)); // {"id":1,"name":"Example","data":42}
+
+obj.data = JSON.Value.from("a string"); // Changing to a string
+console.log(JSON.stringify(obj)); // {"id":1,"name":"Example","data":"a string"}
+```
+
+### 🏗️ Using Raw JSON strings
+
+Sometimes its necessary to simply copy a string instead of serializing it.
+
+For example, the following data would typically be serialized as:
+
+```js
+const m1 = new Map<string, string>();
+m1.set('pos', '{"x":1.0,"y":2.0,"z":3.0}');
+
+const a1 = JSON.stringify(m1);
+console.log("a1: " + a1);
+// {"pos":"{\"x\":1.0,\"y\":2.0,\"z\":3.0}"}
+// pos's value (Vec3) is contained within a string... ideally, it should be left alone
+```
+
+If, instead, one wanted to insert Raw JSON into an existing schema/data structure, they could make use of the JSON.Raw type to do so:
+
+```js
+const m1 = new Map<string, JSON.Raw>();
+m1.set('pos', new JSON.Raw('{"x":1.0,"y":2.0,"z":3.0}'));
+
+const a1 = JSON.stringify(m1);
+console.log("a1: " + a1);
+// {"pos":{"x":1.0,"y":2.0,"z":3.0}}
+// Now its properly formatted JSON where pos's value is of type Vec3 not string!
+```
+
+### ⚒️ Using custom serializers or deserializers
+
+This library supports custom serialization and deserialization methods, which can be defined using the `@serializer` and `@deserializer` decorators.
+
+Here's an example of creating a custom data type called `Point` which serializes to `(x,y)`
+
+```js
+@json
+class Point {
+  x: f64 = 0.0;
+  y: f64 = 0.0;
+  constructor(x: f64, y: f64) {
+    this.x = x;
+    this.y = y;
+  }
+
+  @serializer
+  serializer(self: Point): string {
+    return `(${self.x},${self.y})`;
+  }
+
+  @deserializer
+  deserializer(data: string): Point {
+    const dataSize = bytes(data);
+    if (dataSize <= 2) throw new Error("Could not deserialize provided data as type Point");
+
+    const c = data.indexOf(",");
+    const x = data.slice(1, c);
+    const y = data.slice(c + 1, data.length - 1);
+
+    return new Point(
+      f64.parse(x),
+      f64.parse(y)
+    );
   }
 }
 ```
 
-If you use this project in your codebase, consider dropping a [star](https://github.com/JairusSW/as-json). I would really appreciate it!
+The serializer function converts a `Point` instance into a string format `(x,y)`.
+
+The deserializer function parses the string `(x,y)` back into a `Point` instance.
+
+These functions are then wrapped before being consumed by the json-as library:
+
+```js
+@inline __SERIALIZE_CUSTOM(ptr: usize): void {
+  const data = this.serializer(changetype<Point>(ptr));
+  const dataSize = data.length << 1;
+  memory.copy(bs.offset, changetype<usize>(data), dataSize);
+  bs.offset += dataSize;
+}
+
+@inline __DESERIALIZE_CUSTOM(data: string): Point {
+  return this.deserializer(data);
+}
+```
+
+This allows custom serialization while maintaining a generic interface for the library to access.
+
+## ⚡ Performance
+
+The `json-as` library has been optimized to achieve near-gigabyte-per-second JSON processing speeds through SIMD acceleration and highly efficient transformations. Below are some key performance benchmarks to give you an idea of how it performs.
+
+### Raw Performance
+
+Simple
+
+| Test Case          | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
+| ------------------ | --------------------- | ----------------------- | -------------------- | ---------------------- |
+| Vector3 Object     | 32,642,320 ops/s      | 9,736,272 ops/s         | 1,240 MB/s           | 369 MB/s               |
+| Alphabet String    | 4,928,856 ops/s       | 7,567,360 ops/s         | 975 MB/s             | 1,498 MB/s             |
+| Small JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Medium JSON Object | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Large JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+
+SIMD
+
+| Test Case          | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
+| ------------------ | --------------------- | ----------------------- | -------------------- | ---------------------- |
+| Vector3 Object     | 32,642,320 ops/s      | 9,736,272 ops/s         | 1,240 MB/s           | 369 MB/s               |
+| Alphabet String    | 20,368,584 ops/s      | 28,467,424 ops/s        | 3,910 MB/s           | 5,636 MB/s             |
+| Small JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Medium JSON Object | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Large JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+
+JavaScript
+
+| Test Case          | Serialization (ops/s) | Deserialization (ops/s) | Serialization (MB/s) | Deserialization (MB/s) |
+| ------------------ | --------------------- | ----------------------- | -------------------- | ---------------------- |
+| Vector3 Object     | 2,548,013 ops/s       | 1,942,440 ops/s         | 97 MB/s              | 73 MB/s                |
+| Alphabet String    | 3,221,556 ops/s       | 2,716,617 ops/s         | 624 MB/s             | 537 MB/s               |
+| Small JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Medium JSON Object | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+| Large JSON Object  | [Fill Value]          | [Fill Value]            | [Fill Value]         | [Fill Value]           |
+
+### Real-World Usage
+
+| Scenario         | JSON Size (kb) | Serialization Time (ops/s) | Deserialization Time (ops/s) | Throughput (GB/s) |
+| ---------------- | -------------- | -------------------------- | ---------------------------- | ----------------- |
+| Web API Response | [Fill Value]   | [Fill Value]               | [Fill Value]                 | [Fill Value]      |
+| Database Entry   | [Fill Value]   | [Fill Value]               | [Fill Value]                 | [Fill Value]      |
+| File Parsing     | [Fill Value]   | [Fill Value]               | [Fill Value]                 | [Fill Value]      |
 
 ## 📃 License
 
@@ -143,9 +398,9 @@ This project is distributed under an open source license. You can view the full
 
 ## 📫 Contact
 
-Please send all issues to [GitHub Issues](https://github.com/JairusSW/as-json/issues) and to converse, please send me an email at [me@jairus.dev](mailto:me@jairus.dev)
+Please send all issues to [GitHub Issues](https://github.com/JairusSW/json-as/issues) and to converse, please send me an email at [me@jairus.dev](mailto:me@jairus.dev)
 
 - **Email:** Send me inquiries, questions, or requests at [me@jairus.dev](mailto:me@jairus.dev)
-- **GitHub:** Visit the official GitHub repository [Here](https://github.com/JairusSW/as-json)
+- **GitHub:** Visit the official GitHub repository [Here](https://github.com/JairusSW/json-as)
 - **Website:** Visit my official website at [jairus.dev](https://jairus.dev/)
-- **Discord:** Converse with me on [My Discord](discord.com/users/600700584038760448) or on the [AssemblyScript Discord Server](https://discord.gg/assemblyscript/)
+- **Discord:** Contact me at [My Discord](https://discord.com/users/600700584038760448) or on the [AssemblyScript Discord Server](https://discord.gg/assemblyscript/)

package/assembly/__benches__/misc.bench.ts

@@ -0,0 +1,47 @@
+import { bench } from "as-bench/assembly";
+import { JSON } from "..";
+import { Vec3 } from "./schemas";
+import { serializeString_SIMD } from "../serialize/simd/string";
+import { serializeString } from "../serialize/simple/string";
+import { deserializeString } from "../deserialize/simple/string";
+import { bytes } from "../util";
+import { deserializeString_SIMD } from "../deserialize/simd/string";
+
+const vec: Vec3 = {
+  x: 1,
+  y: 2,
+  z: 3
+}
+
+bs.ensureSize(4096);
+// bench("Serialize Vector3", () => {
+//   JSON.stringify(vec);
+// });
+
+// bench("Deserialize Vector3", () => {
+//   JSON.parse<Vec3>('{"x":1,"y":2,"z":3}');
+// });
+
+// bench("Serialize String SIMD", () => {
+//   serializeString_SIMD("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\:;\"'?/>.<,'\"}");
+//   bs.offset = changetype<usize>(bs.buffer);
+//   bs.stackSize = 0;
+// });
+
+// bench("Serialize String", () => {
+//   serializeString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\:;\"'?/>.<,'\"}");
+//   bs.offset = changetype<usize>(bs.buffer);
+//   bs.stackSize = 0;
+// });
+
+const src = '"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\\\:;\\"\'?/>.<,\'\\"}"';
+const srcStart = changetype<usize>(src);
+const srcEnd = srcStart + bytes(src);
+const out = changetype<usize>(new ArrayBuffer(256));
+bench("Deserialize String", () => {
+  deserializeString(srcStart, srcEnd, out);
+});
+
+bench("Deserialize String SIMD", () => {
+  deserializeString_SIMD(srcStart, srcEnd, out);
+})

package/assembly/__benches__/schemas.ts

@@ -0,0 +1,25 @@
+import { JSON } from "..";
+
+@json
+export class Vec3 {
+  public x!: i32;
+  public y!: i32;
+  public z!: i32;
+  __DESERIALIZE(keyStart: usize, keyEnd: usize, valStart: usize, valEnd: usize, ptr: usize): void {
+    switch (load<u16>(keyStart)) {
+      case 120: { // x
+        store<i32>(ptr, JSON.__deserialize<i32>(valStart, valEnd, 0), offsetof<this>("x"));
+        return;
+      }
+      case 121: { // y
+        store<i32>(ptr, JSON.__deserialize<i32>(valStart, valEnd, 0), offsetof<this>("y"));
+        return;
+      }
+      case 122: { // z
+        store<i32>(ptr, JSON.__deserialize<i32>(valStart, valEnd, 0), offsetof<this>("z"));
+        return;
+      }
+    }
+    return;
+  }
+}

package/assembly/__benches__/string.bench.ts

@@ -0,0 +1,23 @@
+import {JSON} from "..";
+import {Vec3} from "./schemas";
+import {bench} from "../custom/bench";
+import {serializeString_SIMD} from "../serialize/simd/string";
+import {deserializeString_SIMD} from "../deserialize/simd/string";
+import {serializeString} from "../serialize/simple/string";
+import {deserializeString} from "../deserialize/simple/string";
+
+const vec: Vec3 = {x: 1, y: 2, z: 3};
+
+bs.ensureSize(4096);
+
+bench(
+  "Serialize String (Simple)",
+  () => {
+    serializeString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~`!@#$%^&*()-_=+{[}]|\\:;\"'?/>.<,'\"}");
+  },
+  25_000_000
+);
+
+// bench("Deserialize String Simple", () => {
+//   deserializeString_SIMD("\"hello world\"")
+// });

package/assembly/__benches__/struct.bench.ts

@@ -0,0 +1,21 @@
+import {JSON} from "..";
+import {Vec3} from "./schemas";
+import {bench} from "./bench";
+
+const vec: Vec3 = {x: 1, y: 2, z: 3};
+
+bs.ensureSize(4096);
+bench(
+  "Serialize Vector3",
+  () => {
+    // JSON.__serialize(vec);
+    // bs.offset = changetype<usize>(bs.buffer);
+    // bs.stackSize = 0;
+    JSON.stringify(vec);
+  },
+  25_000_000
+);
+
+// bench("Deserialize Vector3", () => {
+//   JSON.parse<Vec3>('{"x":1,"y":2,"z":3}');
+// });