json-as 1.3.0 → 1.3.2

package/transform/lib/index.js

@@ -19,10 +19,63 @@ function needsReferenceLoad(type) {
 }
 function getSerializeCall(type, realName) {
     if (type == "ArrayBuffer") {
-        return `JSON.__serializeArrayBuffer(load<ArrayBuffer>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
+        return `JSON.__serialize<ArrayBuffer>(load<ArrayBuffer>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
     }
     return needsReferenceLoad(type) ? `JSON.__serialize<${type}>(changetype<${type}>(load<usize>(ptr, offsetof<this>(${JSON.stringify(realName)}))));\n` : `JSON.__serialize<${type}>(load<${type}>(ptr, offsetof<this>(${JSON.stringify(realName)})));\n`;
 }
+const CUSTOM_JSON_KINDS = new Set(["any", "string", "number", "object", "array", "boolean", "null", "any | null", "string | null", "number | null", "object | null", "array | null", "boolean | null"]);
+function parseCustomJsonKind(method, decoratorName) {
+    const decorator = method.decorators?.find((v) => v.name.text.toLowerCase() == decoratorName);
+    if (!decorator || !decorator.args || decorator.args.length == 0)
+        return "any";
+    if (decorator.args.length > 1)
+        throwError(`@${decoratorName} accepts at most one argument`, decorator.range);
+    const arg = decorator.args[0];
+    if (arg.kind != 16 || arg.literalKind != 2) {
+        throwError(`@${decoratorName} argument must be a string literal like @${decoratorName}("string")`, arg.range);
+    }
+    const kind = arg.value;
+    if (!CUSTOM_JSON_KINDS.has(kind)) {
+        throwError(`Unsupported @${decoratorName} JSON type '${kind}'. Expected one of: any, string, number, object, array, boolean, null`, arg.range);
+    }
+    return kind;
+}
+function addMemberToCustomBucket(sortedMembers, member, kind) {
+    const isNullable = kind.endsWith(" | null");
+    const baseKind = isNullable ? kind.slice(0, kind.length - 7) : kind;
+    if (isNullable)
+        sortedMembers.null.push(member);
+    switch (baseKind) {
+        case "string":
+            sortedMembers.string.push(member);
+            break;
+        case "number":
+            sortedMembers.number.push(member);
+            break;
+        case "boolean":
+            sortedMembers.boolean.push(member);
+            break;
+        case "null":
+            if (!isNullable)
+                sortedMembers.null.push(member);
+            break;
+        case "array":
+            sortedMembers.array.push(member);
+            break;
+        case "object":
+            sortedMembers.object.push(member);
+            break;
+        default:
+            sortedMembers.string.push(member);
+            sortedMembers.number.push(member);
+            sortedMembers.object.push(member);
+            sortedMembers.array.push(member);
+            sortedMembers.boolean.push(member);
+            if (!isNullable)
+                sortedMembers.null.push(member);
+            break;
+    }
+}
 export class JSONTransform extends Visitor {
     static SN = new JSONTransform();
     program;
@@ -34,6 +87,46 @@ export class JSONTransform extends Visitor {
     imports = [];
     simdStatements = [];
     visitedClasses = new Set();
+    collectInheritedFieldMembers(node, source, members, visited = new Set()) {
+        if (!node.extendsType)
+            return;
+        const extendsName = source.resolveExtendsName(node);
+        if (!extendsName || visited.has(extendsName))
+            return;
+        visited.add(extendsName);
+        let baseDecl = source.getClass(extendsName);
+        let baseSource = baseDecl ? source : null;
+        if (!baseDecl) {
+            const imported = source.getImportedClass(extendsName, this.parser);
+            if (imported) {
+                baseDecl = imported;
+                baseSource = this.sources.get(imported.range.source);
+            }
+        }
+        if (!baseDecl) {
+            const available = source.getAvailableClass(extendsName, this.parser);
+            if (available) {
+                baseDecl = available;
+                baseSource = this.sources.get(available.range.source);
+            }
+        }
+        if (!baseDecl || !baseSource)
+            return;
+        const isDecoratedBase = !!baseDecl.decorators?.some((decorator) => {
+            const name = decorator.name.text;
+            return name === "json" || name === "serializable";
+        });
+        if (isDecoratedBase)
+            return;
+        this.collectInheritedFieldMembers(baseDecl, baseSource, members, visited);
+        const inheritedMembers = baseDecl.members.filter((v) => v.kind === 54 && !v.is(32) && !v.is(512) && !v.is(1024) && !v.decorators?.some((decorator) => decorator.name.text === "omit"));
+        for (let i = inheritedMembers.length - 1; i >= 0; i--) {
+            const inherited = inheritedMembers[i];
+            if (!members.some((member) => member.name.text == inherited.name.text)) {
+                members.unshift(inherited);
+            }
+        }
+    }
     visitClassDeclarationRef(node) {
         if (!node.decorators?.length ||
             !node.decorators.some((decorator) => {
@@ -88,13 +181,14 @@ export class JSONTransform extends Visitor {
             return;
         if (!this.schemas.has(source.internalPath))
             this.schemas.set(source.internalPath, []);
-        const members = [...node.members.filter((v) => v.kind === 54 && v.flags !== 32 && v.flags !== 512 && v.flags !== 1024 && !v.decorators?.some((decorator) => decorator.name.text === "omit"))];
+        const members = [...node.members.filter((v) => v.kind === 54 && !v.is(32) && !v.is(512) && !v.is(1024) && !v.decorators?.some((decorator) => decorator.name.text === "omit"))];
         const serializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "serializer") && !v.name.text.startsWith("__try"))];
         const deserializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "deserializer") && !v.name.text.startsWith("__try"))];
         const schema = new Schema();
         schema.node = node;
         schema.name = source.getQualifiedName(node);
         if (node.extendsType) {
+            this.collectInheritedFieldMembers(node, source, members);
             const extendsName = source.resolveExtendsName(node);
             if (!schema.parent) {
                 const depSearch = schema.deps.find((v) => v.name == extendsName);
@@ -140,6 +234,30 @@ export class JSONTransform extends Visitor {
                             schema.deps.push(schem);
                             schema.parent = schem;
                         }
+                        else {
+                            const availableSearch = source.getAvailableClass(extendsName, this.parser);
+                            if (availableSearch) {
+                                if (DEBUG > 0)
+                                    console.log("Found " + availableSearch.name.text + " from available sources for " + source.internalPath);
+                                const availableSource = this.sources.get(availableSearch.range.source);
+                                if (availableSearch.decorators?.some((decorator) => {
+                                    const name = decorator.name.text;
+                                    return name === "json" || name === "serializable";
+                                })) {
+                                    if (!this.visitedClasses.has(availableSource.getFullPath(availableSearch))) {
+                                        this.visitClassDeclarationRef(availableSearch);
+                                        this.schemas.get(availableSource.internalPath).push(this.schema);
+                                        this.visitClassDeclaration(node);
+                                        return;
+                                    }
+                                    const schem = this.schemas.get(availableSource.internalPath)?.find((s) => s.name == extendsName);
+                                    if (schem) {
+                                        schema.deps.push(schem);
+                                        schema.parent = schem;
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
             }
@@ -240,7 +358,7 @@ export class JSONTransform extends Visitor {
         this.schema = schema;
         this.visitedClasses.add(fullClassPath);
         const codegenMode = getCodegenMode(this.program);
-        const useFastPath = USE_FAST_PATH && codegenMode !== JSONMode.NAIVE;
+        const requestedFastPath = USE_FAST_PATH && codegenMode !== JSONMode.NAIVE;
         let SERIALIZE = "__SERIALIZE(ptr: usize): void {\n";
         let INITIALIZE = "@inline __INITIALIZE(): this {\n";
         let DESERIALIZE = "__DESERIALIZE_SLOW<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n";
@@ -256,7 +374,9 @@ export class JSONTransform extends Visitor {
         if (serializers.length) {
             this.schema.custom = true;
             const serializer = serializers[0];
+            const serializerJsonKind = parseCustomJsonKind(serializer, "serializer");
             const hasCall = CustomTransform.hasCall(serializer);
+            this.schema.customJsonKind = serializerJsonKind;
             CustomTransform.visit(serializer);
             if (serializer.signature.parameters.length > 1)
                 throwError("Found too many parameters in custom serializer for " + this.schema.name + ", but serializers can only accept one parameter of type '" + this.schema.name + "'!", serializer.signature.parameters[1].range);
@@ -268,9 +388,16 @@ export class JSONTransform extends Visitor {
                 serializer.decorators.push(Node.createDecorator(Node.createIdentifierExpression("inline", serializer.range), null, serializer.range));
             }
             SERIALIZE_CUSTOM += "  __SERIALIZE(ptr: usize): void {\n";
-            SERIALIZE_CUSTOM += "    const data = this." + serializer.name.text + "(" + (serializer.signature.parameters.length ? "this" : "") + ");\n";
-            if (hasCall)
-                SERIALIZE_CUSTOM += "    bs.resetState();\n";
+            if (hasCall) {
+                SERIALIZE_CUSTOM += "    const savedOffset = bs.offset;\n";
+                SERIALIZE_CUSTOM += "    const savedStackSize = bs.stackSize;\n";
+            }
+            SERIALIZE_CUSTOM += "    const self = changetype<this>(ptr);\n";
+            SERIALIZE_CUSTOM += "    const data = self." + serializer.name.text + "(" + (serializer.signature.parameters.length ? "self" : "") + ");\n";
+            if (hasCall) {
+                SERIALIZE_CUSTOM += "    bs.offset = savedOffset;\n";
+                SERIALIZE_CUSTOM += "    bs.stackSize = savedStackSize;\n";
+            }
             SERIALIZE_CUSTOM += "    const dataSize = data.length << 1;\n";
             SERIALIZE_CUSTOM += "    memory.copy(bs.offset, changetype<usize>(data), dataSize);\n";
             SERIALIZE_CUSTOM += "    bs.offset += dataSize;\n";
@@ -279,6 +406,12 @@ export class JSONTransform extends Visitor {
         if (deserializers.length) {
             this.schema.custom = true;
             const deserializer = deserializers[0];
+            const deserializerJsonKind = parseCustomJsonKind(deserializer, "deserializer");
+            if (this.schema.customJsonKind != "any" && deserializerJsonKind != "any" && this.schema.customJsonKind != deserializerJsonKind) {
+                throwError(`@serializer and @deserializer JSON types for ${this.schema.name} must match`, deserializer.range);
+            }
+            if (this.schema.customJsonKind == "any")
+                this.schema.customJsonKind = deserializerJsonKind;
             if (!deserializer.signature.parameters.length)
                 throwError("Could not find any parameters in custom deserializer for " + this.schema.name + ". Deserializers must have one parameter like 'deserializer(data: string): " + this.schema.name + " {}'", deserializer.range);
             if (deserializer.signature.parameters.length > 1)
@@ -290,10 +423,8 @@ 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 += "  __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n";
-            DESERIALIZE_CUSTOM += "    const data = inline.always(this." + deserializer.name.text + "(JSON.Util.ptrToStr(srcStart, srcEnd)));\n";
-            DESERIALIZE_CUSTOM += "    memory.copy(changetype<usize>(out), changetype<usize>(data), offsetof<nonnull<__JSON_T>>());\n";
-            DESERIALIZE_CUSTOM += "    return srcEnd;\n";
+            DESERIALIZE_CUSTOM += "  @inline __DESERIALIZE_CUSTOM(data: string): this {\n";
+            DESERIALIZE_CUSTOM += "    return inline.always(this." + deserializer.name.text + "(data));\n";
             DESERIALIZE_CUSTOM += "  }\n";
         }
         if (!members.length && !deserializers.length && !serializers.length) {
@@ -316,6 +447,7 @@ export class JSONTransform extends Visitor {
             mem.value = value;
             mem.node = member;
             mem.byteSize = sizeof(mem.type);
+            mem.custom = schema.deps.some((dep) => dep?.name == stripNull(type) && dep.custom);
             this.schema.byteSize += mem.byteSize;
             if (member.decorators) {
                 for (const decorator of member.decorators) {
@@ -354,6 +486,12 @@ export class JSONTransform extends Visitor {
         }
         if (!this.schema.static)
             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 supportsFastOptionalPath = requestedFastPath && hasOptionalMembers;
+        const hasTypeParams = !!node.typeParameters && node.typeParameters.length > 0;
+        const useFastPath = requestedFastPath && !hasTypeParams && (this.schema.static || supportsFastOptionalPath);
         indent = "  ";
         if (this.schema.static == false) {
             if (this.schema.members.some((v) => v.flags.has(PropertyFlags.OmitNull))) {
@@ -371,36 +509,34 @@ export class JSONTransform extends Visitor {
             const aliasName = JSON.stringify(member.alias || member.name);
             const realName = member.name;
             const isLast = i == this.schema.members.length - 1;
-            if (!useFastPath) {
-                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`;
-                    }
+            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`;
                 }
-                else if (member.generic) {
-                    INITIALIZE += `  if (isManaged<nonnull<${member.type}>>() || isReference<nonnull<${member.type}>>()) {\n`;
-                    INITIALIZE += `    store<${member.type}>(changetype<usize>(this), changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())), offsetof<this>(${JSON.stringify(member.name)}));\n`;
-                    INITIALIZE += `    if (isDefined(this.${member.name}.__INITIALIZE)) changetype<nonnull<${member.type}>>(this.${member.name}).__INITIALIZE();\n`;
-                    INITIALIZE += `  }\n`;
+            }
+            else if (member.generic) {
+                INITIALIZE += `  if (isManaged<nonnull<${member.type}>>() || isReference<nonnull<${member.type}>>()) {\n`;
+                INITIALIZE += `    store<${member.type}>(changetype<usize>(this), changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())), offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                INITIALIZE += `    if (isDefined(this.${member.name}.__INITIALIZE)) changetype<nonnull<${member.type}>>(this.${member.name}).__INITIALIZE();\n`;
+                INITIALIZE += `  }\n`;
+            }
+            else if (!member.node.type.isNullable) {
+                if (this.getSchema(member.type)) {
+                    INITIALIZE += `  store<${member.type}>(changetype<usize>(this), changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())).__INITIALIZE(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
                 }
-                else if (!member.node.type.isNullable) {
-                    if (this.getSchema(member.type)) {
-                        INITIALIZE += `  store<${member.type}>(changetype<usize>(this), changetype<nonnull<${member.type}>>(__new(offsetof<nonnull<${member.type}>>(), idof<nonnull<${member.type}>>())).__INITIALIZE(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
-                    }
-                    else if (member.type.startsWith("Array<")) {
-                        INITIALIZE += `  store<${member.type}>(changetype<usize>(this), [], offsetof<this>(${JSON.stringify(member.name)}));\n`;
-                    }
-                    else if (member.type.startsWith("Map<")) {
-                        INITIALIZE += `  store<${member.type}>(changetype<usize>(this), new ${member.type}(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
-                    }
-                    else if (member.type.startsWith("Set<")) {
-                        INITIALIZE += `  store<${member.type}>(changetype<usize>(this), new ${member.type}(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
-                    }
-                    else if (member.type.startsWith("StaticArray<")) {
-                    }
-                    else if (member.type == "string" || member.type == "String") {
-                        INITIALIZE += `  store<${member.type}>(changetype<usize>(this), "", offsetof<this>(${JSON.stringify(member.name)}));\n`;
-                    }
+                else if (member.type.startsWith("Array<")) {
+                    INITIALIZE += `  store<${member.type}>(changetype<usize>(this), [], offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                }
+                else if (member.type.startsWith("Map<")) {
+                    INITIALIZE += `  store<${member.type}>(changetype<usize>(this), new ${member.type}(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                }
+                else if (member.type.startsWith("Set<")) {
+                    INITIALIZE += `  store<${member.type}>(changetype<usize>(this), new ${member.type}(), offsetof<this>(${JSON.stringify(member.name)}));\n`;
+                }
+                else if (member.type.startsWith("StaticArray<")) {
+                }
+                else if (member.type == "string" || member.type == "String") {
+                    INITIALIZE += `  store<${member.type}>(changetype<usize>(this), "", offsetof<this>(${JSON.stringify(member.name)}));\n`;
                 }
             }
             const SIMD_ENABLED = this.program.options.hasFeature(16);
@@ -482,19 +618,20 @@ export class JSONTransform extends Visitor {
         };
         for (const member of this.schema.members) {
             const type = stripNull(member.type);
-            if (member.custom || member.generic) {
-                sortedMembers.string.push(member);
-                sortedMembers.number.push(member);
-                sortedMembers.object.push(member);
-                sortedMembers.array.push(member);
-                sortedMembers.boolean.push(member);
-                sortedMembers.null.push(member);
+            const customDep = this.schema.deps.find((dep) => dep && (dep.name == type || dep.name.endsWith("." + type)) && dep.custom);
+            const isCustomType = member.custom || !!customDep;
+            if (isCustomType || member.generic) {
+                addMemberToCustomBucket(sortedMembers, member, member.generic ? "any" : customDep?.customJsonKind || "any");
+                if (member.node.type.isNullable)
+                    sortedMembers.null.push(member);
             }
             else {
                 if (member.node.type.isNullable)
                     sortedMembers.null.push(member);
-                if (isString(type) || type == "JSON.Raw")
+                if (isString(type) || type == "Date")
                     sortedMembers.string.push(member);
+                else if (type == "JSON.Raw")
+                    sortedMembers.object.push(member);
                 else if (isBoolean(type) || type.startsWith("JSON.Box<bool"))
                     sortedMembers.boolean.push(member);
                 else if (isPrimitive(type) || type.startsWith("JSON.Box<") || isEnum(type, this.sources.get(this.schema.node.range.source), this.parser))
@@ -534,21 +671,15 @@ export class JSONTransform extends Visitor {
         const FLOAT_TYPES = ["f32", "f64"];
         const INTEGER_TYPES = [...UNSIGNED_INTEGER_TYPES, ...SIGNED_INTEGER_TYPES];
         const STRING_FIELD_DESERIALIZER = codegenMode === JSONMode.SIMD ? "deserializeStringField_SIMD" : "deserializeStringField_SWAR";
-        const getArrayValueType = (type) => {
-            if (type.startsWith("Array<") || type.startsWith("StaticArray<")) {
-                return stripNull(type.slice(type.indexOf("<") + 1, -1).trim());
-            }
-            return null;
-        };
-        const getDeserializer = (type, srcPtr, outPtr, member, keyOffset = 0) => {
+        const getDeserializer = (type, srcPtr, outPtr, member, keyOffset = 0, fastPath = false) => {
             const out = [];
             const resolvedType = stripNull(type);
+            const resolvedSchema = this.getSchema(resolvedType);
             const fieldOffset = `offsetof<this>(${JSON.stringify(member.name)})`;
-            const fieldPtr = `${outPtr} + offsetof<this>(${JSON.stringify(member.name)})`;
             const valuePtr = keyOffset ? `${srcPtr} + ${keyOffset}` : srcPtr;
             if (INTEGER_TYPES.includes(resolvedType)) {
                 const helper = SIGNED_INTEGER_TYPES.includes(resolvedType) ? "deserializeIntegerField" : "deserializeUnsignedField";
-                out.push(`${srcPtr} = ${helper}<${resolvedType}>(${valuePtr}, srcEnd, ${fieldPtr});`);
+                out.push(`${srcPtr} = ${helper}<${resolvedType}>(${valuePtr}, srcEnd, ${outPtr}, ${fieldOffset});`);
             }
             else if (["string", "String"].includes(resolvedType)) {
                 out.push("{");
@@ -558,125 +689,69 @@ export class JSONTransform extends Visitor {
                     out.push(`    ${srcPtr} = ${valuePtr} + 8;`);
                     out.push("  } else {");
                 }
-                out.push(`  ${srcPtr} = ${STRING_FIELD_DESERIALIZER}<${member.type}>(${valuePtr}, srcEnd, ${fieldPtr});`);
+                out.push(`  ${srcPtr} = ${STRING_FIELD_DESERIALIZER}<${member.type}>(${valuePtr}, srcEnd, ${outPtr} + ${fieldOffset});`);
                 if (member.node.type.isNullable) {
                     out.push("  }");
                 }
                 out.push("}");
             }
-            else if (isBoolean(resolvedType)) {
-                out.push("{");
-                out.push(`  if (load<u64>(${srcPtr}) == 28429475166421108) {`);
-                out.push(`    store<${resolvedType}>(${outPtr}, true, ${fieldOffset});`);
-                out.push(`    ${srcPtr} += 8;`);
-                out.push("  } else if (load<u64>(" + srcPtr + ") == 32370086184550502 && load<u16>(" + srcPtr + ", 8) == 101) {");
-                out.push(`    store<${resolvedType}>(${outPtr}, false, ${fieldOffset});`);
-                out.push(`    ${srcPtr} += 10;`);
-                out.push("  } else break;");
-                out.push("}");
-            }
-            else if (FLOAT_TYPES.includes(resolvedType)) {
-                out.push(`${srcPtr} = deserializeFloatField<${resolvedType}>(${valuePtr}, srcEnd, ${fieldPtr});`);
-            }
-            else if (this.getSchema(resolvedType)) {
+            else if (resolvedType == "Date") {
                 out.push("{");
                 if (member.node.type.isNullable) {
-                    out.push(`  if (load<u64>(${srcPtr}) == 30399761348886638) {`);
-                    out.push(`    store<${resolvedType}>(${outPtr}, changetype<${resolvedType}>(0), ${fieldOffset});`);
-                    out.push(`    ${srcPtr} += 8;`);
+                    out.push(`  if (load<u64>(${valuePtr}) == 30399761348886638) {`);
+                    out.push(`    store<${member.type}>(${outPtr}, changetype<${member.type}>(0), ${fieldOffset});`);
+                    out.push(`    ${srcPtr} = ${valuePtr} + 8;`);
                     out.push("  } else {");
                 }
-                out.push(`  let value = load<${resolvedType}>(${outPtr}, ${fieldOffset});`);
-                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(`  if (load<u16>(${valuePtr}) != 0x22) break;`);
+                out.push(`  let dateEnd = ${valuePtr} + 2;`);
+                out.push(`  while (dateEnd < srcEnd) {`);
+                out.push("    if (load<u16>(dateEnd) == 0x22 && load<u16>(dateEnd - 2) != 0x5c) break;");
+                out.push("    dateEnd += 2;");
                 out.push("  }");
-                out.push(`  ${srcPtr} = changetype<nonnull<${resolvedType}>>(value).__DESERIALIZE<${resolvedType}>(${srcPtr}, srcEnd, value);`);
+                out.push("  if (dateEnd >= srcEnd) break;");
+                out.push(`  store<${resolvedType}>(${outPtr}, JSON.__deserialize<${resolvedType}>(${valuePtr}, dateEnd + 2), ${fieldOffset});`);
+                out.push(`  ${srcPtr} = dateEnd + 2;`);
                 if (member.node.type.isNullable) {
                     out.push("  }");
                 }
                 out.push("}");
             }
-            else if (resolvedType.startsWith("Array<")) {
-                const valueType = getArrayValueType(resolvedType);
-                if (valueType && ["string", "String"].includes(valueType)) {
-                    out.push("{");
-                    out.push(`  if (load<u16>(${srcPtr}) != 0x5b) break;`);
-                    out.push(`  let value = load<${resolvedType}>(${outPtr}, ${fieldOffset});`);
-                    out.push("  if (changetype<usize>(value) == 0) {");
-                    out.push(`    value = [];`);
-                    out.push(`    store<${resolvedType}>(${outPtr}, value, ${fieldOffset});`);
-                    out.push("  }");
-                    out.push("  let index = 0;");
-                    out.push(`  ${srcPtr} += 2;`);
-                    out.push(`  if (load<u16>(${srcPtr}) == 0x5d) {`);
-                    out.push("    value.length = 0;");
-                    out.push(`    ${srcPtr} += 2;`);
-                    out.push("  } else while (true) {");
-                    out.push('    if (index >= value.length) value.push("");');
-                    out.push(`    ${srcPtr} = ${STRING_FIELD_DESERIALIZER}<${valueType}>(${srcPtr}, srcEnd, value.dataStart + ((<usize>index) << alignof<${valueType}>()));`);
-                    out.push("    index++;");
-                    out.push(`    const code = load<u16>(${srcPtr});`);
-                    out.push("    if (code == 0x2c) {");
-                    out.push(`      ${srcPtr} += 2;`);
-                    out.push("      continue;");
-                    out.push("    }");
-                    out.push("    if (code == 0x5d) {");
-                    out.push("      value.length = index;");
-                    out.push(`      ${srcPtr} += 2;`);
-                    out.push("      break;");
-                    out.push("    }");
-                    out.push("    break;");
-                    out.push("  }");
-                    out.push("}");
-                }
-                else if (valueType && this.getSchema(valueType)) {
-                    out.push("{");
-                    out.push(`  if (load<u16>(${srcPtr}) != 0x5b) break;`);
-                    out.push(`  let value = load<${resolvedType}>(${outPtr}, ${fieldOffset});`);
-                    out.push("  if (changetype<usize>(value) == 0) {");
-                    out.push(`    value = [];`);
-                    out.push(`    store<${resolvedType}>(${outPtr}, value, ${fieldOffset});`);
-                    out.push("  }");
-                    out.push("  let index = 0;");
-                    out.push(`  ${srcPtr} += 2;`);
-                    out.push(`  if (load<u16>(${srcPtr}) == 0x5d) {`);
-                    out.push("    value.length = 0;");
-                    out.push(`    ${srcPtr} += 2;`);
-                    out.push("  } else while (true) {");
-                    out.push(`    let item: ${valueType};`);
-                    out.push("    if (index < value.length) {");
-                    out.push("      item = unchecked(value[index]);");
-                    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("      }");
-                    out.push("    } else {");
-                    out.push(`      item = changetype<${valueType}>(__new(offsetof<nonnull<${valueType}>>(), idof<nonnull<${valueType}>>()));`);
-                    out.push("      value.push(item);");
-                    out.push("    }");
-                    out.push(`    ${srcPtr} = changetype<nonnull<${valueType}>>(item).__DESERIALIZE<${valueType}>(${srcPtr}, srcEnd, item);`);
-                    out.push("    index++;");
-                    out.push(`    const code = load<u16>(${srcPtr});`);
-                    out.push("    if (code == 0x2c) {");
-                    out.push(`      ${srcPtr} += 2;`);
-                    out.push("      continue;");
-                    out.push("    }");
-                    out.push("    if (code == 0x5d) {");
-                    out.push("      value.length = index;");
-                    out.push(`      ${srcPtr} += 2;`);
-                    out.push("      break;");
-                    out.push("    }");
-                    out.push("    break;");
-                    out.push("  }");
-                    out.push("}");
+            else if (resolvedType.startsWith("JSON.Box<") || resolvedType.startsWith("Box<")) {
+                const innerType = resolvedType.slice(resolvedType.indexOf("<") + 1, -1).trim();
+                out.push("{");
+                if (member.node.type.isNullable) {
+                    out.push(`  if (load<u64>(${valuePtr}) == 30399761348886638) {`);
+                    out.push(`    store<${member.type}>(${outPtr}, changetype<${member.type}>(0), ${fieldOffset});`);
+                    out.push(`    ${srcPtr} = ${valuePtr} + 8;`);
+                    out.push("  } else {");
+                }
+                if (innerType == "bool" || innerType == "boolean") {
+                    out.push(`    if (load<u64>(${valuePtr}) == 28429475166421108) {`);
+                    out.push(`      store<${resolvedType}>(${outPtr}, changetype<${resolvedType}>(JSON.Box.from<${innerType}>(true)), ${fieldOffset});`);
+                    out.push(`      ${srcPtr} = ${valuePtr} + 8;`);
+                    out.push("    } else if (load<u64>(" + valuePtr + ") == 32370086184550502 && load<u16>(" + valuePtr + ", 8) == 101) {");
+                    out.push(`      store<${resolvedType}>(${outPtr}, changetype<${resolvedType}>(JSON.Box.from<${innerType}>(false)), ${fieldOffset});`);
+                    out.push(`      ${srcPtr} = ${valuePtr} + 10;`);
+                    out.push("    } else break;");
                 }
                 else {
-                    out.push(`${srcPtr} = deserializeArrayField_SWAR<${resolvedType}>(${srcPtr}, srcEnd, ${fieldPtr});`);
-                    out.push(`if (!${srcPtr}) break;`);
+                    out.push(`    let boxEnd = ${valuePtr};`);
+                    out.push("    while (boxEnd < srcEnd) {");
+                    out.push("      const code = load<u16>(boxEnd);");
+                    out.push("      if (code == 0x2c || code == 0x7d) break;");
+                    out.push("      boxEnd += 2;");
+                    out.push("    }");
+                    out.push(`    if (boxEnd <= ${valuePtr}) break;`);
+                    out.push(`    store<${resolvedType}>(${outPtr}, changetype<${resolvedType}>(JSON.Box.from<${innerType}>(JSON.__deserialize<${innerType}>(${valuePtr}, boxEnd))), ${fieldOffset});`);
+                    out.push(`    ${srcPtr} = boxEnd;`);
                 }
+                if (member.node.type.isNullable) {
+                    out.push("  }");
+                }
+                out.push("}");
             }
-            else {
+            else if (resolvedType == "JSON.Raw") {
                 out.push("{");
                 out.push(`  const valueStart = ${srcPtr};`);
                 out.push("  let depth: i32 = 0;");
@@ -708,41 +783,212 @@ export class JSONTransform extends Visitor {
                 out.push(`    ${srcPtr} += 2;`);
                 out.push("  }");
                 out.push(`  if (inString || depth != 0 || ${srcPtr} <= valueStart) break;`);
-                out.push(`  store<${resolvedType}>(${outPtr}, JSON.__deserialize<${resolvedType}>(valueStart, ${srcPtr}), ${fieldOffset});`);
+                out.push(`  store<${member.type}>(${outPtr}, JSON.Raw.from(JSON.Util.ptrToStr(valueStart, ${srcPtr})), ${fieldOffset});`);
+                out.push("}");
+            }
+            else if (isBoolean(resolvedType)) {
+                out.push(`if (load<u64>(${srcPtr}) == 28429475166421108) {`);
+                out.push(`  store<${resolvedType}>(${outPtr}, true, ${fieldOffset});`);
+                out.push(`  ${srcPtr} += 8;`);
+                out.push("} else if (load<u64>(" + srcPtr + ") == 32370086184550502 && load<u16>(" + srcPtr + ", 8) == 101) {");
+                out.push(`  store<${resolvedType}>(${outPtr}, false, ${fieldOffset});`);
+                out.push(`  ${srcPtr} += 10;`);
+                out.push("} else break;");
+            }
+            else if (FLOAT_TYPES.includes(resolvedType)) {
+                out.push(`${srcPtr} = deserializeFloatField<${resolvedType}>(${valuePtr}, srcEnd, ${outPtr}, ${fieldOffset});`);
+            }
+            else if (resolvedSchema && !resolvedSchema.custom) {
+                if (fastPath) {
+                    out.push("break;");
+                    return out;
+                }
+                out.push("{");
+                if (member.node.type.isNullable) {
+                    out.push(`  if (load<u64>(${srcPtr}) == 30399761348886638) {`);
+                    out.push(`    store<${resolvedType}>(${outPtr}, changetype<${resolvedType}>(0), ${fieldOffset});`);
+                    out.push(`    ${srcPtr} += 8;`);
+                    out.push("  } else {");
+                }
+                out.push(`  let value = load<${resolvedType}>(${outPtr}, ${fieldOffset});`);
+                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("  }");
+                out.push(`  const valueStart = ${valuePtr};`);
+                out.push(`  const valueEnd = JSON.Util.scanValueEnd(valueStart, srcEnd);`);
+                out.push("  if (!valueEnd) break;");
+                if (fastPath) {
+                    out.push(`  ${srcPtr} = changetype<nonnull<${resolvedType}>>(value).__DESERIALIZE_FAST<${resolvedType}>(valueStart, valueEnd, value);`);
+                }
+                else {
+                    out.push(`  ${srcPtr} = changetype<nonnull<${resolvedType}>>(value).__DESERIALIZE_SLOW<${resolvedType}>(valueStart, valueEnd, value);`);
+                }
+                if (member.node.type.isNullable) {
+                    out.push("  }");
+                }
                 out.push("}");
             }
+            else if (resolvedType.startsWith("Array<")) {
+                out.push("{");
+                if (member.node.type.isNullable) {
+                    out.push(`  if (load<u64>(${valuePtr}) == 30399761348886638) {`);
+                    out.push(`    store<${member.type}>(${outPtr}, changetype<${member.type}>(0), ${fieldOffset});`);
+                    out.push(`    ${srcPtr} = ${valuePtr} + 8;`);
+                    out.push("  } else {");
+                }
+                out.push(`  if (load<u16>(${valuePtr}) == 0x5b && load<u16>(${valuePtr}, 2) == 0x5d) {`);
+                out.push(`    let value = load<${resolvedType}>(${outPtr}, ${fieldOffset});`);
+                if (member.node.type.isNullable) {
+                    out.push(`    if (changetype<usize>(value) == 0) {`);
+                    out.push(`      value = changetype<${resolvedType}>(instantiate<nonnull<${resolvedType}>>());`);
+                    out.push(`      store<${resolvedType}>(${outPtr}, value, ${fieldOffset});`);
+                    out.push("    }");
+                }
+                out.push("    value.length = 0;");
+                out.push(`    ${srcPtr} = ${valuePtr} + 4;`);
+                out.push("  } else {");
+                if (member.node.type.isNullable) {
+                    out.push(`    ${srcPtr} = deserializeArrayField_SWAR<${resolvedType}>(${valuePtr}, srcEnd, ${outPtr}, ${fieldOffset});`);
+                }
+                else {
+                    out.push(`    ${srcPtr} = deserializeArrayInto_SWAR<${resolvedType}>(${valuePtr}, srcEnd, load<${resolvedType}>(${outPtr}, ${fieldOffset}));`);
+                }
+                out.push(`    if (!${srcPtr}) break;`);
+                out.push("  }");
+                if (member.node.type.isNullable) {
+                    out.push("  }");
+                }
+                out.push("}");
+            }
+            else if (resolvedType.startsWith("Map<")) {
+                if (member.node.type.isNullable) {
+                    out.push(`${srcPtr} = deserializeMapField<${resolvedType}>(${srcPtr}, srcEnd, ${outPtr}, ${fieldOffset});`);
+                }
+                else {
+                    out.push(`${srcPtr} = deserializeMapInto<${resolvedType}>(${srcPtr}, srcEnd, load<${resolvedType}>(${outPtr}, ${fieldOffset}));`);
+                }
+                out.push(`if (!${srcPtr}) break;`);
+            }
+            else if (resolvedType.startsWith("Set<")) {
+                if (member.node.type.isNullable) {
+                    out.push(`${srcPtr} = deserializeSetField<${resolvedType}>(${srcPtr}, srcEnd, ${outPtr}, ${fieldOffset});`);
+                }
+                else {
+                    out.push(`${srcPtr} = deserializeSetInto<${resolvedType}>(${srcPtr}, srcEnd, load<${resolvedType}>(${outPtr}, ${fieldOffset}));`);
+                }
+                out.push(`if (!${srcPtr}) break;`);
+            }
+            else if (resolvedType.startsWith("StaticArray<")) {
+                out.push(`${srcPtr} = deserializeStaticArrayField<${resolvedType}>(${srcPtr}, srcEnd, ${outPtr}, ${fieldOffset});`);
+                out.push(`if (!${srcPtr}) break;`);
+            }
+            else if (resolvedType == "JSON.Value" || resolvedType == "JSON.Obj" || isEnum(resolvedType, this.sources.get(this.schema.node.range.source), this.parser)) {
+                out.push("break;");
+            }
+            else {
+                out.push("break;");
+            }
             return out;
         };
         indent = "  ";
-        DESERIALIZE_FAST += indent + "const dst = changetype<usize>(out);\n";
+        DESERIALIZE_FAST += indent + "const start = srcStart;\n";
         DESERIALIZE_FAST += indent + "do {\n";
         indent += "  ";
-        for (let i = 0; i < this.schema.members.length; i++) {
-            const member = this.schema.members[i];
-            const key = JSON.stringify(member.alias || member.name);
-            if (key.length <= 2)
-                throw new Error("Key cannot be empty!");
-            const keySection = (i == 0 ? "{" : ",") + key + ":";
-            DESERIALIZE_FAST += indent + `if ( // ${keySection}\n${(indent += "  ")}${getComparisions(keySection, "srcStart", "!=").join("\n" + indent + "|| ")}\n${(indent = indent.slice(0, -2))}) break;\n`;
-            const keyOffset = keySection.length << 1;
-            const resolvedType = stripNull(member.type);
-            const inlineStringValue = ["string", "String"].includes(resolvedType);
-            if (!inlineStringValue) {
-                DESERIALIZE_FAST += indent + `srcStart += ${keyOffset};\n\n`;
-            }
-            const deserializer = getDeserializer(member.type, "srcStart", "dst", member, inlineStringValue ? keyOffset : 0);
-            if (!deserializer.length) {
-                DESERIALIZE_FAST += indent + "break;\n\n";
-                continue;
+        if (supportsFastOptionalPath) {
+            DESERIALIZE_FAST += indent + "if (load<u16>(srcStart) !== 0x7b) break; // {\n";
+            DESERIALIZE_FAST += indent + "srcStart += 2;\n";
+            DESERIALIZE_FAST += indent + "let seenAny = false;\n\n";
+            for (let i = 0; i < this.schema.members.length; i++) {
+                const member = this.schema.members[i];
+                const key = JSON.stringify(member.alias || member.name);
+                if (key.length <= 2)
+                    throw new Error("Key cannot be empty!");
+                const firstKeySection = key + ":";
+                const nextKeySection = "," + key + ":";
+                const firstKeyOffset = firstKeySection.length << 1;
+                const nextKeyOffset = nextKeySection.length << 1;
+                const resolvedType = stripNull(member.type);
+                const inlineStringValue = ["string", "String"].includes(resolvedType);
+                const deserializerFirst = getDeserializer(member.type, "srcStart", "changetype<usize>(out)", member, inlineStringValue ? firstKeyOffset : 0, true);
+                const deserializerNext = getDeserializer(member.type, "srcStart", "changetype<usize>(out)", member, inlineStringValue ? nextKeyOffset : 0, true);
+                const isOptional = member.flags.has(PropertyFlags.OmitNull) || member.flags.has(PropertyFlags.OmitIf);
+                if (!deserializerFirst.length || !deserializerNext.length) {
+                    DESERIALIZE_FAST += indent + "break;\n\n";
+                    continue;
+                }
+                DESERIALIZE_FAST += indent + "if (!seenAny) {\n";
+                indent += "  ";
+                DESERIALIZE_FAST += indent + `if ( // ${firstKeySection}\n${(indent += "  ")}${getComparisions(firstKeySection, "srcStart", "!=").join("\n" + indent + "|| ")}\n${(indent = indent.slice(0, -2))}) {\n`;
+                indent += "  ";
+                if (isOptional) {
+                    DESERIALIZE_FAST += indent + "// optional @omitnull field omitted\n";
+                }
+                else {
+                    DESERIALIZE_FAST += indent + "break;\n";
+                }
+                indent = indent.slice(0, -2);
+                DESERIALIZE_FAST += indent + "} else {\n";
+                indent += "  ";
+                if (!inlineStringValue)
+                    DESERIALIZE_FAST += indent + `srcStart += ${firstKeyOffset};\n`;
+                DESERIALIZE_FAST += indent + deserializerFirst.join("\n" + indent) + "\n";
+                DESERIALIZE_FAST += indent + "seenAny = true;\n";
+                indent = indent.slice(0, -2);
+                DESERIALIZE_FAST += indent + "}\n";
+                indent = indent.slice(0, -2);
+                DESERIALIZE_FAST += indent + "} else {\n";
+                indent += "  ";
+                DESERIALIZE_FAST += indent + `if ( // ${nextKeySection}\n${(indent += "  ")}${getComparisions(nextKeySection, "srcStart", "!=").join("\n" + indent + "|| ")}\n${(indent = indent.slice(0, -2))}) {\n`;
+                indent += "  ";
+                if (isOptional) {
+                    DESERIALIZE_FAST += indent + "// optional @omitnull field omitted\n";
+                }
+                else {
+                    DESERIALIZE_FAST += indent + "break;\n";
+                }
+                indent = indent.slice(0, -2);
+                DESERIALIZE_FAST += indent + "} else {\n";
+                indent += "  ";
+                if (!inlineStringValue)
+                    DESERIALIZE_FAST += indent + `srcStart += ${nextKeyOffset};\n`;
+                DESERIALIZE_FAST += indent + deserializerNext.join("\n" + indent) + "\n";
+                indent = indent.slice(0, -2);
+                DESERIALIZE_FAST += indent + "}\n";
+                indent = indent.slice(0, -2);
+                DESERIALIZE_FAST += indent + "}\n\n";
+            }
+        }
+        else {
+            for (let i = 0; i < this.schema.members.length; i++) {
+                const member = this.schema.members[i];
+                const key = JSON.stringify(member.alias || member.name);
+                if (key.length <= 2)
+                    throw new Error("Key cannot be empty!");
+                const keySection = (i == 0 ? "{" : ",") + key + ":";
+                DESERIALIZE_FAST += indent + `if ( // ${keySection}\n${(indent += "  ")}${getComparisions(keySection, "srcStart", "!=").join("\n" + indent + "|| ")}\n${(indent = indent.slice(0, -2))}) break;\n`;
+                const keyOffset = keySection.length << 1;
+                const resolvedType = stripNull(member.type);
+                const inlineStringValue = ["string", "String"].includes(resolvedType);
+                if (!inlineStringValue) {
+                    DESERIALIZE_FAST += indent + `srcStart += ${keyOffset};\n\n`;
+                }
+                const deserializer = getDeserializer(member.type, "srcStart", "changetype<usize>(out)", member, inlineStringValue ? keyOffset : 0, true);
+                if (!deserializer.length) {
+                    DESERIALIZE_FAST += indent + "break;\n\n";
+                    continue;
+                }
+                DESERIALIZE_FAST += indent + deserializer.join("\n" + indent) + "\n\n";
             }
-            DESERIALIZE_FAST += indent + deserializer.join("\n" + indent) + "\n\n";
         }
         DESERIALIZE_FAST += indent + "if (load<u16>(srcStart) !== 0x7d) break; // }\n";
         DESERIALIZE_FAST += indent + "srcStart += 2;\n";
         DESERIALIZE_FAST += indent + "return srcStart;\n";
         indent = indent.slice(0, -2);
         DESERIALIZE_FAST += indent + "} while (false);\n\n";
-        DESERIALIZE_FAST += indent + 'throw new Error("Failed to parse JSON ");';
+        DESERIALIZE_FAST += indent + "if (isDefined(out.__INITIALIZE)) out.__INITIALIZE();\n";
+        DESERIALIZE_FAST += indent + "const end = JSON.Util.scanValueEnd(start, srcEnd);\n";
+        DESERIALIZE_FAST += indent + "return out.__DESERIALIZE_SLOW(start, end ? end : srcEnd, out);";
         indent = indent.slice(0, -2);
         DESERIALIZE_FAST += indent + "}";
         DESERIALIZE += indent + "  let keyStart: usize = 0;\n";
@@ -976,7 +1222,7 @@ export class JSONTransform extends Visitor {
                 generateConsts(group);
                 const first = group[0];
                 const fName = first.alias || first.name;
-                DESERIALIZE += indent + "            if (" + (first.generic ? "isDefined(out.__DESERIALIZE) &&" : "") + getComparison(fName) + ") { // " + fName + "\n";
+                DESERIALIZE += indent + "            if (" + getComparison(fName) + ") { // " + fName + "\n";
                 DESERIALIZE += indent + "              store<" + first.type + ">(changetype<usize>(out), JSON.__deserialize<" + first.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(first.name) + "));\n";
                 DESERIALIZE += indent + "              keyStart = 0;\n";
                 DESERIALIZE += indent + "              break;\n";
@@ -984,7 +1230,7 @@ export class JSONTransform extends Visitor {
                 for (let i = 1; i < group.length; i++) {
                     const mem = group[i];
                     const memName = mem.alias || mem.name;
-                    DESERIALIZE += indent + " else if (" + (mem.generic ? "isDefined(out.__DESERIALIZE) &&" : "") + getComparison(memName) + ") { // " + memName + "\n";
+                    DESERIALIZE += indent + " else if (" + getComparison(memName) + ") { // " + memName + "\n";
                     DESERIALIZE += indent + "              store<" + mem.type + ">(changetype<usize>(out), JSON.__deserialize<" + mem.type + ">(lastIndex, srcStart), offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
                     DESERIALIZE += indent + "              keyStart = 0;\n";
                     DESERIALIZE += indent + "              break;\n";
@@ -1075,7 +1321,20 @@ export class JSONTransform extends Visitor {
                 const first = group[0];
                 const fName = first.alias || first.name;
                 DESERIALIZE += indent + "          if (" + (first.generic ? "isBoolean<" + first.type + ">() && " : "") + getComparison(fName) + ") { // " + fName + "\n";
-                DESERIALIZE += indent + "            store<boolean>(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
+                if (first.type.startsWith("JSON.Box<bool") || first.type.startsWith("JSON.Box<boolean") || first.type.startsWith("Box<bool") || first.type.startsWith("Box<boolean")) {
+                    DESERIALIZE +=
+                        indent +
+                            "            store<" +
+                            first.type +
+                            ">(changetype<usize>(out), changetype<" +
+                            first.type +
+                            ">(JSON.Box.from<bool>(true)), offsetof<this>(" +
+                            JSON.stringify(first.name) +
+                            "));\n";
+                }
+                else {
+                    DESERIALIZE += indent + "            store<boolean>(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
+                }
                 DESERIALIZE += indent + "            srcStart += 2;\n";
                 DESERIALIZE += indent + "            keyStart = 0;\n";
                 DESERIALIZE += indent + "            break;\n";
@@ -1084,7 +1343,20 @@ export class JSONTransform extends Visitor {
                     const mem = group[i];
                     const memName = mem.alias || mem.name;
                     DESERIALIZE += indent + " else if (" + (mem.generic ? "isBoolean<" + mem.type + ">() && " : "") + getComparison(memName) + ") { // " + memName + "\n";
-                    DESERIALIZE += indent + "            store<boolean>(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
+                    if (mem.type.startsWith("JSON.Box<bool") || mem.type.startsWith("JSON.Box<boolean") || mem.type.startsWith("Box<bool") || mem.type.startsWith("Box<boolean")) {
+                        DESERIALIZE +=
+                            indent +
+                                "            store<" +
+                                mem.type +
+                                ">(changetype<usize>(out), changetype<" +
+                                mem.type +
+                                ">(JSON.Box.from<bool>(true)), offsetof<this>(" +
+                                JSON.stringify(mem.name) +
+                                "));\n";
+                    }
+                    else {
+                        DESERIALIZE += indent + "            store<boolean>(changetype<usize>(out), true, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
+                    }
                     DESERIALIZE += indent + "            srcStart += 2;\n";
                     DESERIALIZE += indent + "            keyStart = 0;\n";
                     DESERIALIZE += indent + "            break;\n";
@@ -1119,7 +1391,20 @@ export class JSONTransform extends Visitor {
                 const first = group[0];
                 const fName = first.alias || first.name;
                 DESERIALIZE += indent + "          if (" + (first.generic ? "isBoolean<" + first.type + ">() && " : "") + getComparison(fName) + ") { // " + fName + "\n";
-                DESERIALIZE += indent + "            store<boolean>(changetype<usize>(out), false, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
+                if (first.type.startsWith("JSON.Box<bool") || first.type.startsWith("JSON.Box<boolean") || first.type.startsWith("Box<bool") || first.type.startsWith("Box<boolean")) {
+                    DESERIALIZE +=
+                        indent +
+                            "            store<" +
+                            first.type +
+                            ">(changetype<usize>(out), changetype<" +
+                            first.type +
+                            ">(JSON.Box.from<bool>(false)), offsetof<this>(" +
+                            JSON.stringify(first.name) +
+                            "));\n";
+                }
+                else {
+                    DESERIALIZE += indent + "            store<boolean>(changetype<usize>(out), false, offsetof<this>(" + JSON.stringify(first.name) + "));\n";
+                }
                 DESERIALIZE += indent + "            srcStart += 2;\n";
                 DESERIALIZE += indent + "            keyStart = 0;\n";
                 DESERIALIZE += indent + "            break;\n";
@@ -1128,7 +1413,20 @@ export class JSONTransform extends Visitor {
                     const mem = group[i];
                     const memName = mem.alias || mem.name;
                     DESERIALIZE += indent + " else if (" + (mem.generic ? "isBoolean<" + mem.type + ">() && " : "") + getComparison(memName) + ") { // " + memName + "\n";
-                    DESERIALIZE += indent + "            store<boolean>(changetype<usize>(out), false, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
+                    if (mem.type.startsWith("JSON.Box<bool") || mem.type.startsWith("JSON.Box<boolean") || mem.type.startsWith("Box<bool") || mem.type.startsWith("Box<boolean")) {
+                        DESERIALIZE +=
+                            indent +
+                                "            store<" +
+                                mem.type +
+                                ">(changetype<usize>(out), changetype<" +
+                                mem.type +
+                                ">(JSON.Box.from<bool>(false)), offsetof<this>(" +
+                                JSON.stringify(mem.name) +
+                                "));\n";
+                    }
+                    else {
+                        DESERIALIZE += indent + "            store<boolean>(changetype<usize>(out), false, offsetof<this>(" + JSON.stringify(mem.name) + "));\n";
+                    }
                     DESERIALIZE += indent + "            srcStart += 2;\n";
                     DESERIALIZE += indent + "            keyStart = 0;\n";
                     DESERIALIZE += indent + "            break;\n";
@@ -1209,27 +1507,26 @@ export class JSONTransform extends Visitor {
         SERIALIZE += indent + "bs.offset += 2;\n";
         SERIALIZE += "}";
         SERIALIZE = SERIALIZE.slice(0, 32) + indent + "bs.proposeSize(" + this.schema.byteSize + ");\n" + SERIALIZE.slice(32);
-        if (!useFastPath) {
-            INITIALIZE += "  return this;\n";
-            INITIALIZE += "}";
-        }
+        INITIALIZE += "  return this;\n";
+        INITIALIZE += "}";
         if (DEBUG > 0) {
             console.log(SERIALIZE_CUSTOM || SERIALIZE);
-            if (!useFastPath)
-                console.log(INITIALIZE);
+            console.log(INITIALIZE);
             console.log(DESERIALIZE_CUSTOM || DESERIALIZE);
         }
-        const DESERIALIZE_DIRECT = useFastPath ? DESERIALIZE_FAST.replace("@inline __DESERIALIZE_FAST<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {", "@inline __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {") : DESERIALIZE.replace("__DESERIALIZE_SLOW<__JSON_T>", "__DESERIALIZE<__JSON_T>");
         const SERIALIZE_METHOD = SimpleParser.parseClassMember(SERIALIZE_CUSTOM || SERIALIZE, node);
-        const INITIALIZE_METHOD = !useFastPath ? SimpleParser.parseClassMember(INITIALIZE, node) : null;
-        const DESERIALIZE_METHOD = SimpleParser.parseClassMember(DESERIALIZE_CUSTOM || DESERIALIZE_DIRECT, node);
+        const INITIALIZE_METHOD = SimpleParser.parseClassMember(INITIALIZE, node);
+        const DESERIALIZE_CUSTOM_METHOD = DESERIALIZE_CUSTOM ? SimpleParser.parseClassMember(DESERIALIZE_CUSTOM, node) : null;
+        const DESERIALIZE_SLOW_METHOD = SimpleParser.parseClassMember(DESERIALIZE, node);
         const DESERIALIZE_FAST_METHOD = useFastPath ? SimpleParser.parseClassMember(DESERIALIZE_FAST, node) : null;
         if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
             node.members.push(SERIALIZE_METHOD);
-        if (!useFastPath && INITIALIZE_METHOD && !node.members.find((v) => v.name.text == "__INITIALIZE"))
+        if (INITIALIZE_METHOD && !node.members.find((v) => v.name.text == "__INITIALIZE"))
             node.members.push(INITIALIZE_METHOD);
-        if (!node.members.find((v) => v.name.text == "__DESERIALIZE"))
-            node.members.push(DESERIALIZE_METHOD);
+        if (DESERIALIZE_CUSTOM_METHOD && !node.members.find((v) => v.name.text == "__DESERIALIZE_CUSTOM"))
+            node.members.push(DESERIALIZE_CUSTOM_METHOD);
+        if (!DESERIALIZE_CUSTOM && DESERIALIZE_SLOW_METHOD && !node.members.find((v) => v.name.text == "__DESERIALIZE_SLOW"))
+            node.members.push(DESERIALIZE_SLOW_METHOD);
         if (!DESERIALIZE_CUSTOM && useFastPath && DESERIALIZE_FAST_METHOD && !node.members.find((v) => v.name.text == "__DESERIALIZE_FAST"))
             node.members.push(DESERIALIZE_FAST_METHOD);
         super.visitClassDeclaration(node);
@@ -1241,23 +1538,21 @@ export class JSONTransform extends Visitor {
     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_EMPTY = "@inline __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n  return srcEnd;\n}";
-        const useFastPath = USE_FAST_PATH && getCodegenMode(this.program) !== JSONMode.NAIVE;
+        const DESERIALIZE_SLOW_EMPTY = "@inline __DESERIALIZE_SLOW<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): usize {\n  return srcEnd;\n}";
         if (DEBUG > 0) {
             console.log(SERIALIZE_EMPTY);
-            if (!useFastPath)
-                console.log(INITIALIZE_EMPTY);
-            console.log(DESERIALIZE_EMPTY);
+            console.log(INITIALIZE_EMPTY);
+            console.log(DESERIALIZE_SLOW_EMPTY);
         }
         const SERIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(SERIALIZE_EMPTY, node);
-        const INITIALIZE_METHOD_EMPTY = !useFastPath ? SimpleParser.parseClassMember(INITIALIZE_EMPTY, node) : null;
-        const DESERIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(DESERIALIZE_EMPTY, node);
+        const INITIALIZE_METHOD_EMPTY = SimpleParser.parseClassMember(INITIALIZE_EMPTY, node);
+        const DESERIALIZE_SLOW_METHOD_EMPTY = SimpleParser.parseClassMember(DESERIALIZE_SLOW_EMPTY, node);
         if (!node.members.find((v) => v.name.text == "__SERIALIZE"))
             node.members.push(SERIALIZE_METHOD_EMPTY);
-        if (!useFastPath && INITIALIZE_METHOD_EMPTY && !node.members.find((v) => v.name.text == "__INITIALIZE"))
+        if (INITIALIZE_METHOD_EMPTY && !node.members.find((v) => v.name.text == "__INITIALIZE"))
             node.members.push(INITIALIZE_METHOD_EMPTY);
-        if (!node.members.find((v) => v.name.text == "__DESERIALIZE"))
-            node.members.push(DESERIALIZE_METHOD_EMPTY);
+        if (!node.members.find((v) => v.name.text == "__DESERIALIZE_SLOW"))
+            node.members.push(DESERIALIZE_SLOW_METHOD_EMPTY);
     }
     visitImportStatement(node) {
         super.visitImportStatement(node);
@@ -1271,15 +1566,6 @@ export class JSONTransform extends Visitor {
         this.baseCWD = this.baseCWD.replaceAll("/", path.sep);
         const baseDir = path.resolve(fileURLToPath(import.meta.url), "..", "..", "..");
         let fromPath = node.range.source.normalizedPath.replaceAll("/", path.sep);
-        const isLib = path.dirname(baseDir).endsWith("node_modules");
-        if (!isLib && !this.parser.sources.some((s) => s.normalizedPath.startsWith("assembly/index"))) {
-            const newPath = path.join(baseDir, "assembly", "index.ts");
-            this.parser.parseFile(readFileSync(newPath).toString(), newPath, false);
-        }
-        else if (isLib && !this.parser.sources.some((s) => s.normalizedPath.startsWith("~lib/json-as/assembly/index"))) {
-            const newPath = "~lib/json-as/assembly/index.ts";
-            this.parser.parseFile(readFileSync(path.join(baseDir, "assembly", "index.ts")).toString(), newPath, false);
-        }
         fromPath = fromPath.startsWith("~lib") ? fromPath.slice(5) : path.join(this.baseCWD, fromPath);
         const bsImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "bs" || d.name.text == "bs"));
         const jsonImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "JSON" || d.name.text == "JSON"));
@@ -1287,14 +1573,28 @@ export class JSONTransform extends Visitor {
         const deserializeIntegerFieldImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeIntegerField" || d.name.text == "deserializeIntegerField"));
         const deserializeUnsignedFieldImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeUnsignedField" || d.name.text == "deserializeUnsignedField"));
         const deserializeFloatFieldImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeFloatField" || d.name.text == "deserializeFloatField"));
+        const scanValueEndImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "scanValueEnd" || d.name.text == "scanValueEnd"));
         const deserializeArrayField_SWARImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeArrayField_SWAR" || d.name.text == "deserializeArrayField_SWAR"));
+        const deserializeArrayInto_SWARImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeArrayInto_SWAR" || d.name.text == "deserializeArrayInto_SWAR"));
+        const deserializeMapFieldImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeMapField" || d.name.text == "deserializeMapField"));
+        const deserializeMapIntoImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeMapInto" || d.name.text == "deserializeMapInto"));
+        const deserializeSetFieldImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeSetField" || d.name.text == "deserializeSetField"));
+        const deserializeSetIntoImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeSetInto" || d.name.text == "deserializeSetInto"));
+        const deserializeStaticArrayFieldImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeStaticArrayField" || d.name.text == "deserializeStaticArrayField"));
         const deserializeStringFieldSWARImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeStringField_SWAR" || d.name.text == "deserializeStringField_SWAR"));
         const deserializeStringFieldSIMDImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "deserializeStringField_SIMD" || d.name.text == "deserializeStringField_SIMD"));
         const sourceText = readFileSync(fromPath).toString();
         const hasLocalDeserializeIntegerField = /\bdeserializeIntegerField\b/.test(sourceText);
         const hasLocalDeserializeUnsignedField = /\bdeserializeUnsignedField\b/.test(sourceText);
         const hasLocalDeserializeFloatField = /\bdeserializeFloatField\b/.test(sourceText);
+        const hasLocalScanValueEnd = /\bscanValueEnd\b/.test(sourceText);
         const hasLocaldeserializeArrayField_SWAR = /\bdeserializeArrayField_SWAR\b/.test(sourceText);
+        const hasLocaldeserializeArrayInto_SWAR = /\bdeserializeArrayInto_SWAR\b/.test(sourceText);
+        const hasLocaldeserializeMapField = /\bdeserializeMapField\b/.test(sourceText);
+        const hasLocaldeserializeMapInto = /\bdeserializeMapInto\b/.test(sourceText);
+        const hasLocaldeserializeSetField = /\bdeserializeSetField\b/.test(sourceText);
+        const hasLocaldeserializeSetInto = /\bdeserializeSetInto\b/.test(sourceText);
+        const hasLocaldeserializeStaticArrayField = /\bdeserializeStaticArrayField\b/.test(sourceText);
         const hasLocalDeserializeStringFieldSWAR = /\bdeserializeStringField_SWAR\b/.test(sourceText);
         const hasLocalDeserializeStringFieldSIMD = /\bdeserializeStringField_SIMD\b/.test(sourceText);
         let baseRel = path.posix.join(...path.relative(path.dirname(fromPath), path.join(baseDir)).split(path.sep));
@@ -1323,19 +1623,25 @@ export class JSONTransform extends Visitor {
                 console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
         }
         if (!deserializeIntegerFieldImport && !hasLocalDeserializeIntegerField) {
-            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeIntegerField", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "integer"), node.range), node.range);
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeIntegerField", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "simple", "integer"), node.range), node.range);
             node.range.source.statements.unshift(replaceNode);
             if (DEBUG > 0)
                 console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
         }
         if (!deserializeUnsignedFieldImport && !hasLocalDeserializeUnsignedField) {
-            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeUnsignedField", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "unsigned"), node.range), node.range);
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeUnsignedField", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "simple", "unsigned"), node.range), node.range);
             node.range.source.statements.unshift(replaceNode);
             if (DEBUG > 0)
                 console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
         }
         if (!deserializeFloatFieldImport && !hasLocalDeserializeFloatField) {
-            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeFloatField", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "float"), node.range), node.range);
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeFloatField", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "simple", "float"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
+        if (!scanValueEndImport && !hasLocalScanValueEnd) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("scanValueEnd", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "swar", "array", "shared"), node.range), node.range);
             node.range.source.statements.unshift(replaceNode);
             if (DEBUG > 0)
                 console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
@@ -1346,6 +1652,42 @@ export class JSONTransform extends Visitor {
             if (DEBUG > 0)
                 console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
         }
+        if (!deserializeArrayInto_SWARImport && !hasLocaldeserializeArrayInto_SWAR) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeArrayInto_SWAR", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "swar", "array"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
+        if (!deserializeMapFieldImport && !hasLocaldeserializeMapField) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeMapField", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "simple", "map"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
+        if (!deserializeMapIntoImport && !hasLocaldeserializeMapInto) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeMapInto", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "simple", "map"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
+        if (!deserializeSetFieldImport && !hasLocaldeserializeSetField) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeSetField", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "simple", "set"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
+        if (!deserializeSetIntoImport && !hasLocaldeserializeSetInto) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeSetInto", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "simple", "set"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
+        if (!deserializeStaticArrayFieldImport && !hasLocaldeserializeStaticArrayField) {
+            const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeStaticArrayField", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "simple", "staticarray"), node.range), node.range);
+            node.range.source.statements.unshift(replaceNode);
+            if (DEBUG > 0)
+                console.log("Added import: " + toString(replaceNode) + " to " + node.range.source.normalizedPath + "\n");
+        }
         const codegenMode = getCodegenMode(this.program);
         if (codegenMode !== JSONMode.SIMD && !deserializeStringFieldSWARImport && !hasLocalDeserializeStringFieldSWAR) {
             const replaceNode = Node.createImportStatement([Node.createImportDeclaration(Node.createIdentifierExpression("deserializeStringField_SWAR", node.range, false), null, node.range)], Node.createStringLiteralExpression(path.posix.join(baseRel, "assembly", "deserialize", "swar", "string"), node.range), node.range);
@@ -1456,11 +1798,7 @@ export default class Transformer extends Transform {
         }
     }
     afterParse(parser) {
-        const transformer = JSONTransform.SN;
-        transformer.schemas = new Map();
-        transformer.sources = new SourceSet();
-        transformer.visitedClasses = new Set();
-        transformer.simdStatements = [];
+        const transformer = new JSONTransform();
         const sources = parser.sources
             .filter((source) => {
             const p = source.internalPath;