json-as 1.4.0 → 1.5.0

package/lib/as-bs.ts

@@ -40,15 +40,13 @@ export namespace bs {
    * Using bit shifts for efficiency: alpha = 1/8, so (1 - alpha) = 7/8
    * @param newSize - The new size to incorporate into the average
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline function updateTypicalSize(newSize: usize): void {
+  function updateTypicalSize(newSize: usize): void {
     // EMA: typicalSize = (newSize >> 3) + typicalSize - (typicalSize >> 3)
     // Simplified: typicalSize += (newSize - typicalSize) >> 3
     typicalSize += (newSize - typicalSize) >> EMA_ALPHA_SHIFT;
   }
 
-  // @ts-expect-error: @inline is a valid decorator
-  @inline function renewBuffer(newSize: usize): void {
+  function renewBuffer(newSize: usize): void {
     const oldPtr = buffer;
     const relOffset = offset - oldPtr;
     const newPtr = heap.realloc(oldPtr, newSize);
@@ -57,8 +55,7 @@ export namespace bs {
     bufferSize = newSize;
   }
 
-  // @ts-expect-error: @inline is a valid decorator
-  @inline function reserve(requiredSize: usize, extra: usize): void {
+  function reserve(requiredSize: usize, extra: usize): void {
     if (requiredSize <= bufferSize) return;
     // Grow aggressively (2x) to minimize realloc frequency in hot serialization paths.
     let next = bufferSize << 1;
@@ -67,8 +64,7 @@ export namespace bs {
     renewBuffer(next);
   }
 
-  // @ts-expect-error: @inline is a valid decorator
-  @inline function finalizeDynamicOutput(len: usize): void {
+  function finalizeDynamicOutput(len: usize): void {
     counter += 1;
     updateTypicalSize(len);
     if ((counter & SHRINK_EVERY_N_MASK) == 0 && bufferSize > typicalSize << 2) {
@@ -83,8 +79,7 @@ export namespace bs {
   /**
    * Stores the state of the buffer, allowing further changes to be reset
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function saveState(): void {
+  export function saveState(): void {
     pauseOffsets.push(offset - buffer);
     pauseStackSizes.push(stackSize);
   }
@@ -93,8 +88,7 @@ export namespace bs {
    * Resets the buffer to the state it was in when `pause()` was called.
    * This allows for changes made after the pause to be discarded.
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function loadState(): void {
+  export function loadState(): void {
     const length = pauseOffsets.length;
     if (length == 0) return;
     const index = length - 1;
@@ -109,8 +103,7 @@ export namespace bs {
    * serialize/deserialize op mid-flight: a partial run can leave `offset`
    * advanced and the pause stacks non-empty, which would corrupt the next op.
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function reset(): void {
+  export function reset(): void {
     offset = buffer;
     stackSize = 0;
     pauseOffsets.length = 0;
@@ -122,8 +115,7 @@ export namespace bs {
    * If necessary, reallocates the buffer to the exact new size.
    * @param size - The size to propose.
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function ensureSize(size: u32): void {
+  export function ensureSize(size: u32): void {
     reserve(offset - buffer + usize(size), MIN_BUFFER_SIZE);
   }
 
@@ -132,8 +124,7 @@ export namespace bs {
    * If necessary, reallocates the buffer to the exact new size.
    * @param size - The size to propose.w
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function proposeSize(size: u32): void {
+  export function proposeSize(size: u32): void {
     stackSize += size;
     reserve(stackSize, 0);
   }
@@ -143,8 +134,7 @@ export namespace bs {
    * If necessary, reallocates the buffer to the exact new size.
    * @param size - The size to grow by.
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function growSize(size: u32): void {
+  export function growSize(size: u32): void {
     stackSize += size;
     reserve(stackSize, MIN_BUFFER_SIZE);
   }
@@ -153,8 +143,7 @@ export namespace bs {
    * Resizes the buffer to the specified size.
    * @param newSize - The new buffer size.
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function resize(newSize: u32): void {
+  export function resize(newSize: u32): void {
     const oldPtr = buffer;
     const relOffset = offset - oldPtr;
     const newPtr = heap.realloc(buffer, newSize);
@@ -168,8 +157,7 @@ export namespace bs {
    * finalization. Keeps enough capacity for the recent typical output size while
    * releasing clearly excess memory.
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function shrink(): void {
+  export function shrink(): void {
     let next = typicalSize << 1;
     if (next < MIN_BUFFER_SIZE) next = MIN_BUFFER_SIZE;
     if (bufferSize > next) {
@@ -184,8 +172,7 @@ export namespace bs {
    * Copies the buffer's content to a new object of a specified type. Does not shrink the buffer.
    * @returns The new object containing the buffer's content.
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function cpyOut<T>(): T {
+  export function cpyOut<T>(): T {
     if (pauseOffsets.length == 0) {
       const len = offset - buffer;
       // @ts-expect-error: __new is a runtime builtin
@@ -214,8 +201,7 @@ export namespace bs {
    * Note: this restores only `offset`. Deserialization paths do not currently depend on
    * `stackSize`, which is tracked for serialization growth heuristics.
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function sliceOut<T>(start: usize): T {
+  export function sliceOut<T>(start: usize): T {
     const sliceStart = buffer + start;
     const len = offset - sliceStart;
     // @ts-expect-error: __new is a runtime builtin
@@ -229,8 +215,7 @@ export namespace bs {
    * Copies the slice starting at a caller-provided relative buffer offset into a string field
    * and restores `offset` back to that slice start.
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function toField(start: usize, dstFieldPtr: usize): void {
+  export function toField(start: usize, dstFieldPtr: usize): void {
     const sliceStart = buffer + start;
     const byteLength = <u32>(offset - sliceStart);
     if (byteLength == 0) {
@@ -265,8 +250,7 @@ export namespace bs {
    * adaptive buffer management - shrinks buffer when consistently oversized.
    * @returns The new object containing the buffer's content.
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function out<T>(): T {
+  export function out<T>(): T {
     let out: usize;
     if (cacheOutput === 0) {
       const len = offset - buffer;
@@ -296,8 +280,7 @@ export namespace bs {
    * can pass an empty/uninitialized target on the first call. Mirrors the reuse
    * policy of `toField`, but for the top-level return value.
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export function outTo<T>(target: usize): T {
+  export function outTo<T>(target: usize): T {
     if (target < __heap_base) return out<T>();
     let len: usize;
     let src: usize;
@@ -309,7 +292,7 @@ export namespace bs {
       src = cacheOutput;
     }
     let dst = target;
-    if (changetype<OBJECT>(target - TOTAL_OVERHEAD).rtSize != len) {
+    if (changetype<OBJECT>(target - TOTAL_OVERHEAD).rtSize != <u32>len) {
       // @ts-expect-error: __renew is a runtime builtin
       dst = __renew(target, len);
     }
@@ -371,12 +354,9 @@ export namespace bs {
  * avoiding re-serialization of previously seen strings.
  */
 export namespace sc {
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export const ENTRY_KEY = offsetof<sc.Entry>("key");
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export const ENTRY_PTR = offsetof<sc.Entry>("ptr");
-  // @ts-expect-error: @inline is a valid decorator
-  @inline export const ENTRY_LEN = offsetof<sc.Entry>("len");
+  export const ENTRY_KEY = offsetof<sc.Entry>("key");
+  export const ENTRY_PTR = offsetof<sc.Entry>("ptr");
+  export const ENTRY_LEN = offsetof<sc.Entry>("len");
 
   // @ts-expect-error: JSON_CACHE may not be defined. If so, it will default to false.
   export const CACHE_ENABLED: bool = isDefined(JSON_CACHE) ? JSON_CACHE : false;
@@ -425,8 +405,7 @@ export namespace sc {
    * Uses pointer address shifted right by 4 bits (aligned to 16-byte boundaries)
    * masked to fit within cache size.
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline
+
   export function indexFor(ptr: usize): usize {
     return (ptr >> 4) & CACHE_MASK;
   }
@@ -437,8 +416,7 @@ export namespace sc {
    * @param key - The string pointer to look up
    * @returns true if cache hit, false if cache miss
    */
-  // @ts-expect-error: @inline is a valid decorator
-  @inline
+
   export function tryEmitCached(key: usize): bool {
     const e = unchecked(entries[indexFor(key)]);
     if (e.key == key) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "json-as",
-  "version": "1.4.0",
-  "author": "Jairus Tanaka",
+  "version": "1.5.0",
+  "author": "Jairus Tanaka <me@jairus.dev>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/JairusSW/json-as.git"
@@ -11,15 +11,15 @@
   "devDependencies": {
     "@assemblyscript/wasi-shim": "^0.1.0",
     "@eslint/js": "^10.0.1",
-    "@types/node": "^25.9.1",
+    "@types/node": "^25.9.2",
     "as-heap-analyzer": "^1.2.0",
     "as-test": "^1.6.0",
-    "assemblyscript": "^0.28.17",
+    "assemblyscript": "^0.28.18",
     "assemblyscript-json": "^1.1.0",
     "assemblyscript-prettier": "^3.0.4",
     "chartjs-node-canvas": "^5.0.0",
     "chartjs-plugin-datalabels": "^2.2.0",
-    "eslint": "^10.4.0",
+    "eslint": "^10.4.1",
     "fast-json-parse": "^1.0.3",
     "fast-json-stringify": "^6.4.0",
     "husky": "^9.1.7",
@@ -29,7 +29,7 @@
     "tinybench": "^6.0.2",
     "try-as": "^1.1.4",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.60.0"
+    "typescript-eslint": "^8.60.1"
   },
   "bugs": {
     "url": "https://github.com/JairusSW/json-as/issues"
@@ -98,6 +98,7 @@
     "test:ci": "ast test --parallel --clean --enable try-as",
     "test:coverage": "ast test --enable coverage --enable try-as",
     "bench": "bash -c 'bash ./scripts/run-bench.as.sh \"$@\" && { arg=\"${1:-}\"; if [ -z \"$arg\" ] || [ \"${arg#custom/}\" = \"$arg\" ]; then bash ./scripts/run-bench.js.sh \"$@\"; fi; } && bash ./scripts/build-charts.sh' --",
+    "bench:all": "bash ./scripts/bench-all.sh",
     "bench:as": "bash ./scripts/run-bench.as.sh",
     "bench:js": "bash ./scripts/run-bench.js.sh",
     "charts": "bun run charts:build && bun run charts:serve",
@@ -115,6 +116,9 @@
     "run:playground": "wasmtime ./build/playground.wasm",
     "run:pg": "npm run run:playground",
     "playground": "npm run build:playground && npm run run:playground",
+    "build:playground:tmp": "asc assembly/playground.tmp.ts -o ./build/playground.tmp.wasm --textFile ./build/playground.tmp.wat -O3 --noAssert --uncheckedBehavior always --runtime incremental --enable bulk-memory --enable simd --use JSON_MODE=1 --exportStart start --exportRuntime",
+    "playground:tmp": "npm run build:playground:tmp && v8 --no-liftoff --module ./bench/runners/assemblyscript.js -- playground.tmp.wasm",
+    "pg:tmp": "npm run playground:tmp",
     "play": "npm run playground",
     "pg": "npm run playground",
     "bench:wasmer": "wasmer ./build/bench.wasm --llvm",
@@ -132,5 +136,8 @@
     "prepare": "husky"
   },
   "type": "module",
-  "types": "assembly/index.ts"
+  "types": "assembly/index.ts",
+  "dependencies": {
+    "xjb-as": "^0.1.0"
+  }
 }

package/transform/lib/index.js

@@ -310,6 +310,7 @@ export class JSONTransform extends Visitor {
             }) ??
                 false));
         let __hasLazy = false;
+        const __lazyValInits = new Map();
         for (let i = node.members.length - 1; i >= 0; i--) {
             const fd = node.members[i];
             if (fd.kind !== NodeKind.FieldDeclaration ||
@@ -340,7 +341,7 @@ export class JSONTransform extends Visitor {
                 continue;
             if (hasCustomSerde)
                 throwError("Lazy fields (@lazy / JSON.Lazy<T> / @json({ lazy })) are not supported " +
-                    "on a class with a custom @serializer/@deserializer — the custom methods " +
+                    "on a class with a custom @serializer/@deserializer - the custom methods " +
                     "bypass the generated (de)serializer, so the deferred slot is never filled. " +
                     "Remove the lazy marker or the custom (de)serializer.", fd.range);
             const fname = fd.name.text;
@@ -356,6 +357,13 @@ export class JSONTransform extends Visitor {
                     : "null";
             const fdInit = fd.initializer;
             const fieldDefault = fdInit ? toString(fdInit) : null;
+            const refDefault = fieldDefault != null
+                ? fieldDefault
+                : !storesScalar && baseT == T && !baseT.startsWith("StaticArray<")
+                    ? baseT == "string" || baseT == "String"
+                        ? '""'
+                        : `new ${baseT}()`
+                    : null;
             __hasLazy = true;
             const omitIfDeco = decos?.find((d) => d.name.text === "omitif");
             lazyInner.set("__" + fname + "_lz", {
@@ -397,8 +405,8 @@ export class JSONTransform extends Visitor {
                         `  this.__${fname}_lz = ((<u64>0xffffffff) << 32) | ${encVal("value")};\n}`,
                 ]
                 : [
-                    `@alias(${key}) private __${fname}_lz: u64 = ${fieldDefault != null ? "u64.MAX_VALUE" : "0"};`,
-                    `private __${fname}_val: ${valueType} = ${fieldDefault ?? valueDefault};`,
+                    `@alias(${key}) private __${fname}_lz: u64 = ${refDefault != null ? "u64.MAX_VALUE" : "0"};`,
+                    `private __${fname}_val: ${valueType} = ${refDefault ?? valueDefault};`,
                     `get ${fname}(): ${T} {\n` +
                         `  const __lz = this.__${fname}_lz;\n` +
                         `  if (__lz != 0 && __lz != u64.MAX_VALUE) {\n` +
@@ -411,6 +419,9 @@ export class JSONTransform extends Visitor {
                         `  this.__${fname}_lz = u64.MAX_VALUE;\n}`,
                 ]).map((src) => SimpleParser.parseClassMember(src, node));
             node.members.splice(i, 1, ...lowered);
+            if (!packScalar && refDefault != null) {
+                __lazyValInits.set(`__${fname}_lz`, `  store<${valueType}>(changetype<usize>(this), ${refDefault}, offsetof<this>(${JSON.stringify(`__${fname}_val`)}));\n`);
+            }
         }
         if (__hasLazy) {
             node.members.push(SimpleParser.parseClassMember(`private __src: string = "";`, node), SimpleParser.parseClassMember(`__SET_SRC(s: string): void { this.__src = s; }`, node));
@@ -569,7 +580,7 @@ export class JSONTransform extends Visitor {
             else if (isString(type) || isPrimitive(type)) {
                 return types;
             }
-            else if (["JSON.Box", "JSON.Obj", "JSON.Value", "JSON.Raw"].includes(type)) {
+            else if (["JSON.Box", "JSON.Obj", "JSON.Arr", "JSON.Value", "JSON.Raw"].includes(type)) {
                 return types;
             }
             else if (node.isGeneric &&
@@ -665,9 +676,9 @@ export class JSONTransform extends Visitor {
         this.visitedClasses.add(fullClassPath);
         const requestedFastPath = USE_FAST_PATH;
         let SERIALIZE = "__SERIALIZE(ptr: usize): void {\n";
-        let INITIALIZE = "@inline __INITIALIZE(): this {\n";
+        let INITIALIZE = " __INITIALIZE(): this {\n";
         let DESERIALIZE = "__DESERIALIZE_SLOW<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n";
-        let DESERIALIZE_FAST = "@inline __DESERIALIZE_FAST<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n";
+        let DESERIALIZE_FAST = "__DESERIALIZE_FAST<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n";
         let DESERIALIZE_CUSTOM = "";
         let SERIALIZE_CUSTOM = "";
         if (DEBUG > 0)
@@ -773,8 +784,7 @@ export class JSONTransform extends Visitor {
             if (!deserializer.decorators.some((v) => v.name.text == "inline")) {
                 deserializer.decorators.push(Node.createDecorator(Node.createIdentifierExpression("inline", deserializer.range), null, deserializer.range));
             }
-            DESERIALIZE_CUSTOM +=
-                "  @inline __DESERIALIZE_CUSTOM(data: string): this {\n";
+            DESERIALIZE_CUSTOM += "  __DESERIALIZE_CUSTOM(data: string): this {\n";
             DESERIALIZE_CUSTOM +=
                 "    return this." + deserializer.name.text + "(data);\n";
             DESERIALIZE_CUSTOM += "  }\n";
@@ -841,6 +851,10 @@ export class JSONTransform extends Visitor {
                             this.schema.static = false;
                             break;
                         }
+                        case "optional": {
+                            mem.flags.set(PropertyFlags.Optional, null);
+                            break;
+                        }
                         case "omitnull": {
                             if (isPrimitive(type)) {
                                 throwError("@omitnull cannot be used on primitive types!", member.range);
@@ -857,11 +871,11 @@ export class JSONTransform extends Visitor {
             }
             this.schema.members.push(mem);
         }
-        if (!this.schema.static)
-            this.schema.members = sortMembers(this.schema.members);
+        this.schema.members = sortMembers(this.schema.members);
         const hasOmitIfMembers = this.schema.members.some((v) => v.flags.has(PropertyFlags.OmitIf));
         const hasOmitNullMembers = this.schema.members.some((v) => v.flags.has(PropertyFlags.OmitNull));
-        const hasOptionalMembers = hasOmitIfMembers || hasOmitNullMembers;
+        const hasExplicitOptionalMembers = this.schema.members.some((v) => v.flags.has(PropertyFlags.Optional));
+        const hasOptionalMembers = hasOmitIfMembers || hasOmitNullMembers || hasExplicitOptionalMembers;
         const hasLazyMembers = this.schema.members.some((v) => v.flags.has(PropertyFlags.Lazy));
         const supportsFastOptionalPath = requestedFastPath && hasOptionalMembers;
         const hasTypeParams = !!node.typeParameters && node.typeParameters.length > 0;
@@ -942,12 +956,10 @@ export class JSONTransform extends Visitor {
             const aliasName = JSON.stringify(member.alias || member.name);
             const realName = member.name;
             if (member.value) {
-                if (member.value != "null" &&
-                    member.value != "0" &&
-                    member.value != "0.0" &&
-                    member.value != "false") {
-                    INITIALIZE += `  store<${member.type}>(changetype<usize>(this), ${member.value}, offsetof<this>(${JSON.stringify(member.name)}));\n`;
-                }
+                INITIALIZE += `  store<${member.type}>(changetype<usize>(this), ${member.value}, offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                const __valInit = __lazyValInits.get(member.name);
+                if (__valInit)
+                    INITIALIZE += __valInit;
             }
             else if (member.generic) {
                 INITIALIZE += `  if (isManaged<nonnull<${member.type}>>() || isReference<nonnull<${member.type}>>()) {\n`;
@@ -974,6 +986,9 @@ export class JSONTransform extends Visitor {
                     INITIALIZE += `  store<${member.type}>(changetype<usize>(this), "", offsetof<this>(${JSON.stringify(member.name)}));\n`;
                 }
             }
+            else {
+                INITIALIZE += `  store<${member.type}>(changetype<usize>(this), null, offsetof<this>(${JSON.stringify(member.name)}));\n`;
+            }
             const SIMD_ENABLED = this.program.options.hasFeature(16);
             if (!isRegular &&
                 !member.flags.has(PropertyFlags.OmitIf) &&
@@ -1116,7 +1131,7 @@ export class JSONTransform extends Visitor {
                     type.startsWith("JSON.Box<") ||
                     isEnum(type, this.sources.get(this.schema.node.range.source), this.parser))
                     sortedMembers.number.push(member);
-                else if (isArray(type))
+                else if (isArray(type) || type == "JSON.Arr" || type == "Arr")
                     sortedMembers.array.push(member);
                 else
                     sortedMembers.object.push(member);
@@ -1337,9 +1352,18 @@ export class JSONTransform extends Visitor {
                     out.push(`  if (changetype<usize>(value) == 0) {`);
                     out.push(`    value = changetype<${resolvedType}>(__new(offsetof<nonnull<${resolvedType}>>(), idof<nonnull<${resolvedType}>>()));`);
                     out.push(`    store<${resolvedType}>(${outPtr}, value, ${fieldOffset});`);
+                    out.push(`    changetype<nonnull<${resolvedType}>>(value).__INITIALIZE();`);
                     out.push("  }");
-                    out.push(`  ${srcPtr} = changetype<nonnull<${resolvedType}>>(value).__DESERIALIZE_FAST<${resolvedType}>(${valuePtr}, srcEnd, value);`);
-                    out.push(`  if (!${srcPtr}) break;`);
+                    out.push(`  const __fe = changetype<nonnull<${resolvedType}>>(value).__DESERIALIZE_FAST<${resolvedType}>(${valuePtr}, srcEnd, value);`);
+                    out.push(`  if (__fe) {`);
+                    out.push(`    ${srcPtr} = __fe;`);
+                    out.push(`  } else {`);
+                    out.push(`    const __ve = JSON.Util.scanValueEnd<${resolvedType}>(${valuePtr}, srcEnd);`);
+                    out.push(`    if (!__ve) break;`);
+                    out.push(`    changetype<nonnull<${resolvedType}>>(value).__INITIALIZE();`);
+                    out.push(`    changetype<nonnull<${resolvedType}>>(value).__DESERIALIZE_SLOW<${resolvedType}>(${valuePtr}, __ve, value);`);
+                    out.push(`    ${srcPtr} = __ve;`);
+                    out.push(`  }`);
                     if (member.node.type.isNullable) {
                         out.push("  }");
                     }
@@ -1454,13 +1478,24 @@ export class JSONTransform extends Visitor {
                     out.push("      if (changetype<usize>(item) == 0) {");
                     out.push(`        item = changetype<${valueType}>(__new(offsetof<nonnull<${valueType}>>(), idof<nonnull<${valueType}>>()));`);
                     out.push("        unchecked((value[index] = item));");
+                    out.push(`        changetype<nonnull<${valueType}>>(item).__INITIALIZE();`);
                     out.push("      }");
                     out.push("    } else {");
                     out.push(`      item = changetype<${valueType}>(__new(offsetof<nonnull<${valueType}>>(), idof<nonnull<${valueType}>>()));`);
                     out.push("      value.push(item);");
+                    out.push(`      changetype<nonnull<${valueType}>>(item).__INITIALIZE();`);
                     out.push("    }");
-                    out.push(`    ${srcPtr} = changetype<nonnull<${valueType}>>(item).__DESERIALIZE_FAST<${valueType}>(${srcPtr}, srcEnd, item);`);
-                    out.push(`    if (!${srcPtr}) break;`);
+                    out.push(`    const __es = ${srcPtr};`);
+                    out.push(`    const __ee = changetype<nonnull<${valueType}>>(item).__DESERIALIZE_FAST<${valueType}>(${srcPtr}, srcEnd, item);`);
+                    out.push(`    if (__ee) {`);
+                    out.push(`      ${srcPtr} = __ee;`);
+                    out.push(`    } else {`);
+                    out.push(`      const __ve = JSON.Util.scanValueEnd<${valueType}>(__es, srcEnd);`);
+                    out.push(`      if (!__ve) break;`);
+                    out.push(`      changetype<nonnull<${valueType}>>(item).__INITIALIZE();`);
+                    out.push(`      changetype<nonnull<${valueType}>>(item).__DESERIALIZE_SLOW<${valueType}>(__es, __ve, item);`);
+                    out.push(`      ${srcPtr} = __ve;`);
+                    out.push(`    }`);
                     out.push("    index++;");
                     out.push(`    ${srcPtr} = JSON.Util.skipWhitespace(${srcPtr}, srcEnd);`);
                     out.push(`    const code = load<u16>(${srcPtr});`);
@@ -1481,7 +1516,7 @@ export class JSONTransform extends Visitor {
                     out.push("}");
                     return out;
                 }
-                out.push(`  ${srcPtr} = __deserializeArrayField_SWAR<${resolvedType}>(${valuePtr}, srcEnd, ${outPtr}, ${fieldOffset});`);
+                out.push(`  ${srcPtr} = __deserializeArrayField_SWAR<nonnull<${resolvedType}>>(${valuePtr}, srcEnd, ${outPtr}, ${fieldOffset});`);
                 out.push(`  if (!${srcPtr}) break;`);
                 if (member.node.type.isNullable) {
                     out.push("  }");
@@ -1502,6 +1537,7 @@ export class JSONTransform extends Visitor {
             }
             else if (resolvedType == "JSON.Value" ||
                 resolvedType == "JSON.Obj" ||
+                resolvedType == "JSON.Arr" ||
                 isEnum(resolvedType, this.sources.get(this.schema.node.range.source), this.parser)) {
                 out.push("break;");
             }
@@ -1531,29 +1567,8 @@ export class JSONTransform extends Visitor {
             }
             return calls;
         };
-        const chunkFastBlocksOptional = (blocks, tag, callIndent, needsKp) => {
-            if (blocks.length <= FAST_CHUNK_SIZE)
-                return blocks.join("");
-            let calls = "";
-            for (let c = 0; c < blocks.length; c += FAST_CHUNK_SIZE) {
-                const name = `__DESERIALIZE_FAST_${tag}_${fastChunkId++}`;
-                const body = blocks
-                    .slice(c, c + FAST_CHUNK_SIZE)
-                    .join("")
-                    .replace(/\bbreak;/g, "return 0;");
-                fastChunkMethods.push(`${name}(srcStart: usize, srcEnd: usize, dst: usize, seenAny: bool): u64 {\n` +
-                    (needsKp ? "  let kp: usize = 0;\n" : "") +
-                    `${body}\n` +
-                    `  return (<u64>srcStart) | ((<u64>(seenAny ? 1 : 0)) << 32);\n}`);
-                calls +=
-                    `${callIndent}{\n` +
-                        `${callIndent}  const __r = this.${name}(srcStart, srcEnd, dst, seenAny);\n` +
-                        `${callIndent}  if (__r == 0) break;\n` +
-                        `${callIndent}  srcStart = <usize>(<u32>__r);\n` +
-                        `${callIndent}  seenAny = (<u32>(__r >>> 32)) != 0;\n` +
-                        `${callIndent}}\n`;
-            }
-            return calls;
+        const chunkFastBlocksOptional = (blocks, _tag, _callIndent, _needsKp) => {
+            return blocks.join("");
         };
         DESERIALIZE_FAST += indent + "const start = srcStart;\n";
         DESERIALIZE_FAST += indent + "const dst = changetype<usize>(out);\n";
@@ -2520,9 +2535,9 @@ export class JSONTransform extends Visitor {
             .find((s) => s.name == name) || null);
     }
     generateEmptyMethods(node) {
-        const SERIALIZE_EMPTY = "@inline __SERIALIZE(ptr: usize): void {\n  bs.proposeSize(4);\n  store<u32>(bs.offset, 8192123);\n  bs.offset += 4;\n}";
-        const INITIALIZE_EMPTY = "@inline __INITIALIZE(): this {\n  return this;\n}";
-        const DESERIALIZE_SLOW_EMPTY = "@inline __DESERIALIZE_SLOW<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n  return srcEnd;\n}";
+        const SERIALIZE_EMPTY = "__SERIALIZE(ptr: usize): void {\n  bs.proposeSize(4);\n  store<u32>(bs.offset, 8192123);\n  bs.offset += 4;\n}";
+        const INITIALIZE_EMPTY = "__INITIALIZE(): this {\n  return this;\n}";
+        const DESERIALIZE_SLOW_EMPTY = "__DESERIALIZE_SLOW<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n  return srcEnd;\n}";
         if (DEBUG > 0) {
             console.log(SERIALIZE_EMPTY);
             console.log(INITIALIZE_EMPTY);
@@ -2698,9 +2713,11 @@ export class JSONTransform extends Visitor {
             "Date",
             "JSON.Value",
             "JSON.Obj",
+            "JSON.Arr",
             "JSON.Raw",
             "Value",
             "Obj",
+            "Arr",
             "Raw",
             ...this.schemas
                 .get(this.schema.node.range.source.internalPath)
@@ -2729,6 +2746,8 @@ var JSONMode;
     JSONMode[JSONMode["NAIVE"] = 2] = "NAIVE";
 })(JSONMode || (JSONMode = {}));
 let MODE = JSONMode.SWAR;
+let MODE_TEXT = "SWAR";
+const STAGES = process.env["JSON_STAGES"] !== undefined;
 export default class Transformer extends Transform {
     afterInitialize(program) {
         if (program.options.hasFeature(16))
@@ -2749,6 +2768,21 @@ export default class Transformer extends Transform {
                 }
             }
         }
+        switch (MODE) {
+            case JSONMode.SWAR:
+                MODE_TEXT = "SWAR";
+                break;
+            case JSONMode.SIMD:
+                MODE_TEXT = "SIMD";
+                break;
+            case JSONMode.NAIVE:
+                MODE_TEXT = "NAIVE";
+                break;
+        }
+        if (STAGES)
+            console.log("[transform]: Finished initializing transformer in " +
+                MODE_TEXT +
+                " mode");
         program.registerConstantInteger("JSON_MODE", Type.i32, i64_new(MODE));
         if (JSON_CACHE_CONFIG.enabled) {
             program.registerConstantInteger("JSON_CACHE", Type.bool, i64_one);
@@ -2757,6 +2791,8 @@ export default class Transformer extends Transform {
     }
     afterParse(parser) {
         const transformer = new JSONTransform();
+        if (STAGES)
+            console.log("[transform]: Walking AST and generating schemas");
         const sources = parser.sources
             .filter((source) => {
             const p = source.internalPath;
@@ -2812,23 +2848,12 @@ export default class Transformer extends Transform {
                 source.sourceKind = 2;
             }
         }
+        if (STAGES)
+            console.log("[transform]: Finished generating " +
+                transformer.schemas.size +
+                " schemas");
     }
 }
-function sortMembers(members) {
-    return members.sort((a, b) => {
-        const aMove = a.flags.has(PropertyFlags.OmitIf) || a.flags.has(PropertyFlags.OmitNull);
-        const bMove = b.flags.has(PropertyFlags.OmitIf) || b.flags.has(PropertyFlags.OmitNull);
-        if (aMove && !bMove) {
-            return -1;
-        }
-        else if (!aMove && bMove) {
-            return 1;
-        }
-        else {
-            return 0;
-        }
-    });
-}
 function toU16(data, offset = 0) {
     return data.charCodeAt(offset + 0);
 }
@@ -3011,6 +3036,8 @@ function lazyTypeCost(type, source, parser) {
         base === "Value" ||
         base === "JSON.Obj" ||
         base === "Obj" ||
+        base === "JSON.Arr" ||
+        base === "Arr" ||
         base === "JSON.Raw" ||
         base === "Raw")
         return 15;
@@ -3076,6 +3103,8 @@ function estimatedSerializedByteSize(type, source, parser) {
         }
         else if (baseType == "JSON.Obj" ||
             baseType == "Obj" ||
+            baseType == "JSON.Arr" ||
+            baseType == "Arr" ||
             baseType == "JSON.Raw" ||
             baseType == "Raw" ||
             baseType == "JSON.Value" ||
@@ -3134,6 +3163,21 @@ export function stripNull(type) {
     }
     return type;
 }
+function sortMembers(members) {
+    return members.sort((a, b) => {
+        const aMove = a.flags.has(PropertyFlags.OmitIf) || a.flags.has(PropertyFlags.OmitNull);
+        const bMove = b.flags.has(PropertyFlags.OmitIf) || b.flags.has(PropertyFlags.OmitNull);
+        if (aMove && !bMove) {
+            return -1;
+        }
+        else if (!aMove && bMove) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    });
+}
 function getComparison(data) {
     switch (data.length << 1) {
         case 2: {

package/transform/lib/types.d.ts

@@ -6,7 +6,8 @@ export declare enum PropertyFlags {
     OmitIf = 1,
     Raw = 2,
     Custom = 3,
-    Lazy = 4
+    Lazy = 4,
+    Optional = 5
 }
 export declare class Property {
     name: string;