vxrn 2.13.10 → 2.14.0

package/dist/utils/nativeSourceContract.native.js

@@ -1562,12 +1562,13 @@ function nativeSourceContract(file, source) {
 	}));
 	declarations.push(...views.map(function(view) {
 		return `export declare function ${view.name}(props: {${view.props.map(function(prop) {
-			return ` ${prop.name}${prop.optional ? "?" : ""}: ${prop.type}`;
-		}).join(";")} }): ReactElement`;
+			return ` ${prop.name}${prop.optional ? "?" : ""}: ${prop.type};`;
+		}).join("")} style?: StyleProp<ViewStyle> }): ReactElement`;
 	}));
 	if (defaultView) {
 		declarations.unshift("export default function SwiftPackage(props: Record<string, unknown>): ReactElement");
 	}
+	if (views.length > 0) declarations.unshift("import type { StyleProp, ViewStyle } from 'react-native'");
 	if (defaultView || views.length > 0) declarations.unshift("import type { ReactElement } from 'react'");
 	var declaration = `${GENERATED_HEADER}${declarations.join("\n\n")}
 `;
@@ -1939,18 +1940,151 @@ function renderSwiftSourceGlue(packageId, contracts) {
 		];
 	};
 	var renderViews = function renderViews2() {
+		var notLinked2 = "    default: throw NSError(domain: \"OneNativeSource\", code: 1, userInfo: [NSLocalizedDescriptionKey: \"swift view \\(name) is not linked; rebuild the app\"])";
+		var fieldsOf = function fieldsOf2(view) {
+			return view.props.filter(function(prop) {
+				return !prop.callback || prop.optional;
+			}).map(function(prop, index) {
+				var type = prop.callback ? "Bool?" : prop.nativeType;
+				var optional = type.endsWith("?");
+				var list = /^\[(.*)\]\??$/.exec(type);
+				return {
+					name: prop.name,
+					type,
+					optional,
+					list: list && !list[1].includes(":") ? list[1] : null,
+					key: `p${index}`
+				};
+			});
+		};
 		return [
-			"  private static func missing(_ path: String) throws -> Any {",
-			"    throw NSError(domain: \"OneNativeSource\", code: 2, userInfo: [NSLocalizedDescriptionKey: \"\\(path): required\"])",
+			"  private struct OneListPatch<E: Decodable>: Decodable {",
+			"    let length: Int",
+			"    let set: [(Int, E)]",
+			"    private struct Entry: Decodable {",
+			"      let index: Int",
+			"      let value: E",
+			"      init(from decoder: Decoder) throws {",
+			"        var c = try decoder.unkeyedContainer()",
+			"        index = try c.decode(Int.self)",
+			"        value = try c.decode(E.self)",
+			"      }",
+			"    }",
+			"    private enum CodingKeys: String, CodingKey { case length, set }",
+			"    init(from decoder: Decoder) throws {",
+			"      let c = try decoder.container(keyedBy: CodingKeys.self)",
+			"      length = try c.decode(Int.self, forKey: .length)",
+			"      set = try c.decode([Entry].self, forKey: .set).map { ($0.index, $0.value) }",
+			"    }",
 			"  }",
-			"  static func view(_ name: String, _ propsJson: String, _ emit: @escaping (String, String) -> Void) throws -> AnyView {",
-			"    guard let props = try JSONSerialization.jsonObject(with: Data(propsJson.utf8)) as? [String: Any] else {",
-			"      throw NSError(domain: \"OneNativeSource\", code: 2, userInfo: [NSLocalizedDescriptionKey: \"props must be a JSON object\"])",
+			"  private nonisolated static func patch<E>(_ list: inout [E], _ patch: OneListPatch<E>) -> Bool {",
+			"    if patch.length < 0 { return false }",
+			"    if list.count > patch.length { list.removeLast(list.count - patch.length) }",
+			"    for (index, value) in patch.set {",
+			"      if index < list.count { list[index] = value } else if index == list.count && index < patch.length { list.append(value) } else { return false }",
 			"    }",
+			"    return list.count == patch.length",
+			"  }",
+			"  private nonisolated static func missing(_ prop: String) -> Error {",
+			"    NSError(domain: \"OneNativeSource\", code: 1, userInfo: [NSLocalizedDescriptionKey: \"missing prop \\(prop)\"])",
+			"  }",
+			...views.flatMap(function(view) {
+				var fields = fieldsOf(view);
+				var lists = fields.filter(function(field) {
+					return field.list;
+				});
+				return [
+					...lists.length > 0 ? [
+						`  private struct Lists_${view.name}: Decodable {`,
+						...lists.map(function(field) {
+							return `    let ${field.key}: OneListPatch<${field.list}>?`;
+						}),
+						`    private enum CodingKeys: String, CodingKey { ${lists.map(function(field) {
+							return `case ${field.key} = ${JSON.stringify(field.name)}`;
+						}).join("; ")} }`,
+						"  }"
+					] : [],
+					`  private struct Doc_${view.name}: Decodable {`,
+					"    let seq: Int",
+					"    let base: Int?",
+					...lists.length > 0 ? [`    let lists: Lists_${view.name}?`] : [],
+					...fields.map(function(field) {
+						return `    let ${field.key}: Optional<${field.type}>`;
+					}),
+					`    private enum CodingKeys: String, CodingKey { ${[
+						"case seq = \"$seq\"",
+						"case base = \"$base\"",
+						"case lists = \"$lists\"",
+						...fields.map(function(field) {
+							return `case ${field.key} = ${JSON.stringify(field.name)}`;
+						})
+					].join("; ")} }`,
+					"    init(from decoder: Decoder) throws {",
+					"      let c = try decoder.container(keyedBy: CodingKeys.self)",
+					"      seq = try c.decodeIfPresent(Int.self, forKey: .seq) ?? 0",
+					"      base = try c.decodeIfPresent(Int.self, forKey: .base)",
+					...lists.length > 0 ? [`      lists = try c.decodeIfPresent(Lists_${view.name}.self, forKey: .lists)`] : [],
+					...fields.map(function(field) {
+						return `      ${field.key} = try c.contains(.${field.key}) ? Optional<${field.type}>.some(c.decode(${field.type}.self, forKey: .${field.key})) : Optional<${field.type}>.none`;
+					}),
+					"    }",
+					"  }",
+					`  private final class Held_${view.name} {`,
+					"    var oneSeq: Int",
+					...fields.map(function(field) {
+						return `    var \`${field.name}\`: ${field.type}`;
+					}),
+					`    init(_ d: Doc_${view.name}) throws {`,
+					"      oneSeq = d.seq",
+					...fields.flatMap(function(field) {
+						return field.optional ? [`      \`${field.name}\` = d.${field.key}.flatMap { $0 }`] : [`      guard let ${field.key} = d.${field.key} else { throw ${bodyName}.missing(${JSON.stringify(field.name)}) }`, `      \`${field.name}\` = ${field.key}`];
+					}),
+					"    }",
+					`    func apply(_ d: Doc_${view.name}) -> Bool {`,
+					"      if d.base != oneSeq { return false }",
+					...lists.flatMap(function(field) {
+						return [
+							`      var ${field.key} = \`${field.name}\``,
+							`      if let v = d.${field.key} { ${field.key} = v }`,
+							`      if let p = d.lists?.${field.key} {`,
+							...field.optional ? [
+								`        guard var items = ${field.key} else { return false }`,
+								`        if !${bodyName}.patch(&items, p) { return false }`,
+								`        ${field.key} = items`
+							] : [`        if !${bodyName}.patch(&${field.key}, p) { return false }`],
+							"      }"
+						];
+					}),
+					...fields.map(function(field) {
+						return field.list ? `      \`${field.name}\` = ${field.key}` : `      if let v = d.${field.key} { \`${field.name}\` = v }`;
+					}),
+					"      oneSeq = d.seq",
+					"      return true",
+					"    }",
+					"  }"
+				];
+			}),
+			"  static func update(_ held: AnyObject?, _ name: String, _ text: String) throws -> AnyObject? {",
+			"    let data = Data(text.utf8)",
 			"    switch name {",
 			...views.flatMap(function(view) {
 				return [
 					`    case ${JSON.stringify(view.name)}:`,
+					`      let doc = try decode(Doc_${view.name}.self, from: data)`,
+					`      if doc.base == nil { return try Held_${view.name}(doc) }`,
+					`      guard let h = held as? Held_${view.name}, h.apply(doc) else { return nil }`,
+					"      return h"
+				];
+			}),
+			notLinked2,
+			"    }",
+			"  }",
+			"  static func build(_ held: AnyObject, _ name: String, _ emit: @escaping (String, String) -> Void) throws -> AnyView {",
+			"    switch name {",
+			...views.flatMap(function(view) {
+				return [
+					`    case ${JSON.stringify(view.name)}:`,
+					`      guard ${fieldsOf(view).length > 0 ? "let props = held as?" : "held is"} Held_${view.name} else { throw NSError(domain: "OneNativeSource", code: 1, userInfo: [NSLocalizedDescriptionKey: "props of another view for \\(name)"]) }`,
 					`      return AnyView(${view.name}(`,
 					...view.props.map(function(prop, index) {
 						var comma = index === view.props.length - 1 ? "" : ",";
@@ -1962,16 +2096,19 @@ function renderSwiftSourceGlue(packageId, contracts) {
 							var lambda = `{ (${params}) -> Void in emit(${key}, args([${prop.callback.map(function(_, n) {
 								return `a${n}`;
 							}).join(", ")}])) }`;
-							return `        ${prop.name}: ${prop.optional ? `(props[${key}] as? Bool) == true ? ${lambda} : nil` : lambda}${comma}`;
+							return `        ${prop.name}: ${prop.optional ? `props.\`${prop.name}\` == true ? ${lambda} : nil` : lambda}${comma}`;
 						}
-						var input = prop.optional ? `props[${key}] ?? NSNull()` : `props[${key}] ?? missing(${JSON.stringify(`props.${prop.name}`)})`;
-						return `        ${prop.name}: try decode(${input}, as: ${prop.nativeType}.self)${comma}`;
+						return `        ${prop.name}: props.\`${prop.name}\`${comma}`;
 					}),
 					"      ))"
 				];
 			}),
-			"    default: throw NSError(domain: \"OneNativeSource\", code: 1, userInfo: [NSLocalizedDescriptionKey: \"swift view \\(name) is not linked; rebuild the app\"])",
+			notLinked2,
 			"    }",
+			"  }",
+			"  static func view(_ name: String, _ propsJson: String, _ emit: @escaping (String, String) -> Void) throws -> AnyView {",
+			"    guard let held = try update(nil, name, propsJson) else { throw NSError(domain: \"OneNativeSource\", code: 1, userInfo: [NSLocalizedDescriptionKey: \"\\(name) needs a full props document\"]) }",
+			"    return try build(held, name, emit)",
 			"  }"
 		];
 	};
@@ -2042,13 +2179,15 @@ function renderSwiftSourceGlue(packageId, contracts) {
 		"    if let date = (try? isoDateFractional.parse(text)) ?? (try? isoDate.parse(text)) { return date }",
 		"    throw DecodingError.dataCorruptedError(in: container, debugDescription: \"expected ISO date\")",
 		"  }",
-		"  private static func decode<T: Decodable>(_ value: Any, as type: T.Type) throws -> T {",
-		"    let data = try JSONSerialization.data(withJSONObject: value, options: [.fragmentsAllowed])",
+		"  private static func decode<T: Decodable>(_ type: T.Type, from data: Data) throws -> T {",
 		"    let decoder = JSONDecoder()",
 		"    decoder.dateDecodingStrategy = .custom { try decodeDate($0) }",
 		"    decoder.dataDecodingStrategy = .base64",
 		"    return try decoder.decode(T.self, from: data)",
 		"  }",
+		"  private static func decode<T: Decodable>(_ value: Any, as type: T.Type) throws -> T {",
+		"    try decode(T.self, from: try JSONSerialization.data(withJSONObject: value, options: [.fragmentsAllowed]))",
+		"  }",
 		"  private static func encode(_ value: any Encodable) throws -> String {",
 		"    let encoder = JSONEncoder()",
 		"    encoder.dateEncodingStrategy = .iso8601",
@@ -2116,6 +2255,8 @@ function renderSwiftSourceGlue(packageId, contracts) {
 			"  public required override init() {}",
 			`  public var contractHash: String { ${bodyName}.hash }`,
 			`  public func view(_ name: String, _ propsJson: String, _ emit: @escaping (String, String) -> Void) throws -> AnyView { try ${bodyName}.view(name, propsJson, emit) }`,
+			`  public func updateView(_ held: AnyObject?, _ name: String, _ document: String) throws -> AnyObject? { try ${bodyName}.update(held, name, document) }`,
+			`  public func buildView(_ held: AnyObject, _ name: String, _ emit: @escaping (String, String) -> Void) throws -> AnyView { try ${bodyName}.build(held, name, emit) }`,
 			"}"
 		] : [],
 		"#endif",
@@ -2126,6 +2267,14 @@ function renderSwiftSourceGlue(packageId, contracts) {
 		source
 	};
 }
+function unboxedZero(type) {
+	if (type === "Int") return "0";
+	if (type === "Long") return "0L";
+	if (type === "Double") return "0.0";
+	if (type === "Float") return "0f";
+	if (type === "Boolean") return "false";
+	return null;
+}
 function renderKotlinSourceGlue(sourceId, contract) {
 	if (contract.language !== "kotlin") throw new Error("kotlin glue received a swift contract");
 	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(sourceId)) throw new Error(`invalid kotlin source id ${sourceId}`);
@@ -2133,6 +2282,8 @@ function renderKotlinSourceGlue(sourceId, contract) {
 		sourceId,
 		contract: contract.hash
 	})).digest("hex");
+	var readerClass = `OneJsonReader_${sourceId}`;
+	var tokenClass = `OneJsonToken_${sourceId}`;
 	var structsByName = new Map(contract.structs.map(function(entry) {
 		return [entry.name, entry];
 	}));
@@ -2145,6 +2296,23 @@ function renderKotlinSourceGlue(sourceId, contract) {
 	var isDateType = function isDateType2(type) {
 		return type === "Date" || type === "java.util.Date";
 	};
+	var qualifiedType = function qualifiedType1(type) {
+		if (type.endsWith("?")) return `${qualifiedType(type.slice(0, -1))}?`;
+		if (type.startsWith("List<") && type.endsWith(">")) return `List<${qualifiedType(type.slice(5, -1))}>`;
+		if (type.startsWith("Map<String,") && type.endsWith(">")) return `Map<String, ${qualifiedType(type.slice(11, -1))}>`;
+		if (structsByName.has(type) || enumsByName.has(type)) return qualified(type);
+		if (isDateType(type)) return "java.util.Date";
+		if ([
+			"String",
+			"Boolean",
+			"Double",
+			"Float",
+			"Int",
+			"Long",
+			"ByteArray"
+		].includes(type)) return type;
+		throw new Error(`unsupported kotlin glue type ${type}`);
+	};
 	var mentions = function mentions1(type, match) {
 		var rest = type;
 		while (rest.endsWith("?")) rest = rest.slice(0, -1);
@@ -2196,25 +2364,25 @@ function renderKotlinSourceGlue(sourceId, contract) {
 			return leaf === "ByteArray";
 		});
 	});
-	var value = function value1(type, input, path) {
+	var value = function value1(type, reader, path) {
 		if (type.endsWith("?")) {
-			return `(${input}).let { raw -> if (raw == null || raw == JSONObject.NULL) null else ${value(type.slice(0, -1), "raw", path)} }`;
-		}
-		if (type === "String") return `readString(${input}, ${path})`;
-		if (type === "Boolean") return `readBoolean(${input}, ${path})`;
-		if (type === "Double") return `readDouble(${input}, ${path})`;
-		if (type === "Float") return `readDouble(${input}, ${path}).toFloat()`;
-		if (type === "Int") return `readInt(${input}, ${path})`;
-		if (type === "Long") return `readLong(${input}, ${path})`;
-		if (isDateType(type)) return `readDate(${input}, ${path})`;
-		if (type === "ByteArray") return `readData(${input}, ${path})`;
-		if (structsByName.has(type)) return `read${type}(${input}, ${path})`;
-		if (enumsByName.has(type)) return `read${type}(${input}, ${path})`;
+			return `(if (${reader}.peek() == ${tokenClass}.NULL) { ${reader}.nextNull(); null } else ${value(type.slice(0, -1), reader, path)})`;
+		}
+		if (type === "String") return `readString(${reader}, ${path})`;
+		if (type === "Boolean") return `readBoolean(${reader}, ${path})`;
+		if (type === "Double") return `readDouble(${reader}, ${path})`;
+		if (type === "Float") return `readDouble(${reader}, ${path}).toFloat()`;
+		if (type === "Int") return `readInt(${reader}, ${path})`;
+		if (type === "Long") return `readLong(${reader}, ${path})`;
+		if (isDateType(type)) return `readDate(${reader}, ${path})`;
+		if (type === "ByteArray") return `readData(${reader}, ${path})`;
+		if (structsByName.has(type)) return `read${type}(${reader}, ${path})`;
+		if (enumsByName.has(type)) return `read${type}(${reader}, ${path})`;
 		if (type.startsWith("List<") && type.endsWith(">")) {
-			return `readList(${input}, ${path}) { item, itemPath -> ${value(type.slice(5, -1), "item", "itemPath")} }`;
+			return `readList(${reader}, ${path}) { itemReader, itemPath -> ${value(type.slice(5, -1), "itemReader", "itemPath")} }`;
 		}
 		if (type.startsWith("Map<String,") && type.endsWith(">")) {
-			return `readMap(${input}, ${path}) { item, itemPath -> ${value(type.slice(11, -1), "item", "itemPath")} }`;
+			return `readMap(${reader}, ${path}) { itemReader, itemPath -> ${value(type.slice(11, -1), "itemReader", "itemPath")} }`;
 		}
 		throw new Error(`unsupported kotlin glue type ${type}`);
 	};
@@ -2234,17 +2402,45 @@ function renderKotlinSourceGlue(sourceId, contract) {
 		}
 		return `JSONObject.wrap(${accessor})`;
 	};
+	var cap = function cap2(name) {
+		return name.slice(0, 1).toUpperCase() + name.slice(1);
+	};
 	var structHelpers = contract.structs.flatMap(function(struct) {
 		return [
-			`private fun read${struct.name}(value: Any, path: String): ${qualified(struct.name)} {`,
-			"  val obj = value as? JSONObject ?: error(\"$path: expected object\")",
+			`private fun read${struct.name}(reader: ${readerClass}, path: String): ${qualified(struct.name)} {`,
+			`  if (reader.peek() != ${tokenClass}.BEGIN_OBJECT) error("$path: expected object")`,
+			"  reader.beginObject()",
+			...struct.fields.flatMap(function(field) {
+				var declared = qualifiedType(field.nativeType);
+				if (field.optional) return [`  var ${field.name}: ${declared} = ${field.fallback}`];
+				var zero = unboxedZero(field.nativeType);
+				if (zero !== null) return [`  var ${field.name} = ${zero}`, `  var has${cap(field.name)} = false`];
+				var boxed = declared.endsWith("?") ? declared : `${declared}?`;
+				return [`  var ${field.name}: ${boxed} = null`, ...field.nativeType.endsWith("?") ? [`  var has${cap(field.name)} = false`] : []];
+			}),
+			"  while (reader.hasNext()) {",
+			`    when (reader.selectName(${struct.fields.map(function(field) {
+				return JSON.stringify(field.name);
+			}).join(", ")})) {`,
+			...struct.fields.map(function(field, index) {
+				var fieldPath = `"$path.${field.name}"`;
+				var read = `${field.name} = ${value(field.nativeType, "reader", fieldPath)}`;
+				var needsFlag = !field.optional && (field.nativeType.endsWith("?") || unboxedZero(field.nativeType) !== null);
+				return needsFlag ? `      ${index} -> { ${read}; has${cap(field.name)} = true }` : `      ${index} -> ${read}`;
+			}),
+			"      else -> reader.skipValue()",
+			"    }",
+			"  }",
+			"  reader.endObject()",
+			...struct.fields.flatMap(function(field) {
+				return !field.optional && unboxedZero(field.nativeType) !== null ? [`  if (!has${cap(field.name)}) error("$path.${field.name}: required")`] : [];
+			}),
 			`  return ${qualified(struct.name)}(`,
 			...struct.fields.map(function(field) {
-				var _field_fallback;
-				var fieldPath = `"$path.${field.name}"`;
-				var required = `error("$path.${field.name}: required")`;
-				var input = field.optional ? `(if (obj.has(${JSON.stringify(field.name)})) obj.get(${JSON.stringify(field.name)}) else ${(_field_fallback = field.fallback) !== null && _field_fallback !== void 0 ? _field_fallback : required})` : `(obj.opt(${JSON.stringify(field.name)}) ?: ${required})`;
-				return `    ${field.name} = ${value(field.nativeType, input, fieldPath)},`;
+				if (field.optional) return `    ${field.name} = ${field.name},`;
+				if (field.nativeType.endsWith("?")) return `    ${field.name} = (if (has${cap(field.name)}) ${field.name} else error("$path.${field.name}: required")),`;
+				if (unboxedZero(field.nativeType) !== null) return `    ${field.name} = ${field.name},`;
+				return `    ${field.name} = (${field.name} ?: error("$path.${field.name}: required")),`;
 			}),
 			"  )",
 			"}",
@@ -2258,8 +2454,8 @@ function renderKotlinSourceGlue(sourceId, contract) {
 	});
 	var enumHelpers = contract.enums.flatMap(function(entry) {
 		return [
-			`private fun read${entry.name}(value: Any, path: String): ${qualified(entry.name)} {`,
-			"  val text = readString(value, path)",
+			`private fun read${entry.name}(reader: ${readerClass}, path: String): ${qualified(entry.name)} {`,
+			"  val text = readString(reader, path)",
 			`  return try { ${qualified(entry.name)}.valueOf(text) } catch (e: IllegalArgumentException) { error("$path: expected one of ${entry.cases.map(function(item) {
 				return item.name;
 			}).join(", ")}") }`,
@@ -2268,40 +2464,322 @@ function renderKotlinSourceGlue(sourceId, contract) {
 	});
 	var source = [
 		"import androidx.annotation.Keep",
-		...contract.views.length === 0 ? [] : ["import androidx.compose.runtime.Composable", "import dev.onejs.one.OneNativeSourceViewDispatch"],
+		...contract.views.length === 0 ? [] : [
+			"import androidx.compose.runtime.Composable",
+			"import dev.onejs.one.OneNativeSourceKeyedState",
+			"import dev.onejs.one.OneNativeSourceViewDispatch"
+		],
 		"import dev.onejs.one.OneNativeSourceDispatch",
 		...needsEvents ? ["import dev.onejs.one.source.OneNativeSourceEvents"] : [],
 		"import org.json.JSONArray",
 		"import org.json.JSONObject",
 		"",
-		"private fun readString(value: Any, path: String): String = value as? String ?: error(\"$path: expected string\")",
-		"private fun readBoolean(value: Any, path: String): Boolean = value as? Boolean ?: error(\"$path: expected boolean\")",
-		"private fun readDouble(value: Any, path: String): Double {",
-		"  val result = (value as? Number)?.toDouble() ?: error(\"$path: expected number\")",
+		`private enum class ${tokenClass} { BEGIN_OBJECT, END_OBJECT, BEGIN_ARRAY, END_ARRAY, STRING, NUMBER, BOOLEAN, NULL }`,
+		"",
+		"// a forward-only json reader over the props text: values decode straight",
+		"// into typed props in one pass with no intermediate JSONObject. pure",
+		"// kotlin with no java or android imports, so the same glue compiles for",
+		"// kotlin/wasm.",
+		`private class ${readerClass}(private val text: String) {`,
+		"  private var pos = 0",
+		"",
+		"  private fun skipSpace() {",
+		"    while (pos < text.length) {",
+		"      when (text[pos]) {",
+		"        ' ', '\\t', '\\n', '\\r' -> pos++",
+		"        else -> return",
+		"      }",
+		"    }",
+		"  }",
+		"",
+		"  private fun fail(message: String): Nothing = throw IllegalStateException(\"$message near offset $pos\")",
+		"",
+		`  fun peek(): ${tokenClass} {`,
+		"    skipSpace()",
+		"    if (pos >= text.length) fail(\"unexpected end of json\")",
+		"    return when (text[pos]) {",
+		`      '{' -> ${tokenClass}.BEGIN_OBJECT`,
+		`      '}' -> ${tokenClass}.END_OBJECT`,
+		`      '[' -> ${tokenClass}.BEGIN_ARRAY`,
+		`      ']' -> ${tokenClass}.END_ARRAY`,
+		`      '"' -> ${tokenClass}.STRING`,
+		`      't', 'f' -> ${tokenClass}.BOOLEAN`,
+		`      'n' -> ${tokenClass}.NULL`,
+		`      '-', in '0'..'9' -> ${tokenClass}.NUMBER`,
+		"      else -> fail(\"unexpected character\")",
+		"    }",
+		"  }",
+		"",
+		"  private fun expect(char: Char) {",
+		"    skipSpace()",
+		`    if (pos >= text.length || text[pos] != char) fail("expected '$char'")`,
+		"    pos++",
+		"  }",
+		"",
+		"  fun beginObject() = expect('{')",
+		"  fun endObject() = expect('}')",
+		"  fun beginArray() = expect('[')",
+		"  fun endArray() = expect(']')",
+		"",
+		"  // inside an object or array: true when another value follows, consuming",
+		"  // a comma first; false at the closing bracket.",
+		"  fun hasNext(): Boolean {",
+		"    skipSpace()",
+		"    if (pos >= text.length) fail(\"unexpected end of json\")",
+		"    if (text[pos] == ',') {",
+		"      pos++",
+		"      return true",
+		"    }",
+		"    return text[pos] != '}' && text[pos] != ']'",
+		"  }",
+		"",
+		"  fun nextName(): String {",
+		"    skipSpace()",
+		`    if (pos >= text.length || text[pos] != '"') fail("expected a name")`,
+		"    val name = readString()",
+		"    skipSpace()",
+		`    if (pos >= text.length || text[pos] != ':') fail("expected ':'")`,
+		"    pos++",
+		"    return name",
+		"  }",
+		"",
+		"  fun nextString(): String {",
+		"    skipSpace()",
+		`    if (pos >= text.length || text[pos] != '"') fail("expected a string")`,
+		"    return readString()",
+		"  }",
+		"",
+		"  // matches an object name against the expected keys without allocating",
+		"  // it: the index of the match, or -1 for an unknown key. the name and",
+		"  // colon are consumed either way, so the caller skips the value on -1.",
+		"  fun selectName(vararg options: String): Int {",
+		"    skipSpace()",
+		`    if (pos >= text.length || text[pos] != '"') fail("expected a name")`,
+		"    var end = pos + 1",
+		`    while (end < text.length && text[end] != '"' && text[end] != '\\\\') end++`,
+		"    if (end < text.length && text[end] == '\\\\') {",
+		"      val decoded = readString()",
+		"      skipSpace()",
+		`      if (pos >= text.length || text[pos] != ':') fail("expected ':'")`,
+		"      pos++",
+		"      return options.indexOf(decoded)",
+		"    }",
+		"    if (end >= text.length) fail(\"unterminated string\")",
+		"    val length = end - pos - 1",
+		"    var index = -1",
+		"    for (i in options.indices) {",
+		"      if (options[i].length == length && text.regionMatches(pos + 1, options[i], 0, length)) { index = i; break }",
+		"    }",
+		"    pos = end + 1",
+		"    skipSpace()",
+		`    if (pos >= text.length || text[pos] != ':') fail("expected ':'")`,
+		"    pos++",
+		"    return index",
+		"  }",
+		"",
+		"  private fun readString(): String {",
+		"    pos++ // the opening quote",
+		"    var end = pos",
+		`    while (end < text.length && text[end] != '"' && text[end] != '\\\\') end++`,
+		`    if (end < text.length && text[end] == '"') {`,
+		"      val out = text.substring(pos, end)",
+		"      pos = end + 1",
+		"      return out",
+		"    }",
+		"    val out = StringBuilder(text.substring(pos, end))",
+		"    pos = end",
+		"    while (true) {",
+		"      if (pos >= text.length) fail(\"unterminated string\")",
+		"      val char = text[pos++]",
+		`      if (char == '"') return out.toString()`,
+		"      if (char != '\\\\') {",
+		"        out.append(char)",
+		"        continue",
+		"      }",
+		"      if (pos >= text.length) fail(\"unterminated escape\")",
+		"      when (text[pos++]) {",
+		`        '"', '\\\\', '/' -> out.append(text[pos - 1])`,
+		"        'b' -> out.append('\\b')",
+		"        'f' -> out.append('\\u000C')",
+		"        'n' -> out.append('\\n')",
+		"        'r' -> out.append('\\r')",
+		"        't' -> out.append('\\t')",
+		"        'u' -> {",
+		"          if (pos + 4 > text.length) fail(\"bad unicode escape\")",
+		"          var code = 0",
+		"          for (i in 0 until 4) {",
+		"            val digit = text[pos + i].lowercaseChar()",
+		`            val value = if (digit in '0'..'9') digit - '0' else if (digit in 'a'..'f') digit - 'a' + 10 else fail("bad unicode escape")`,
+		"            code = code * 16 + value",
+		"          }",
+		"          pos += 4",
+		"          out.append(code.toChar())",
+		"        }",
+		"        else -> fail(\"bad escape\")",
+		"      }",
+		"    }",
+		"  }",
+		"",
+		"  fun nextDouble(): Double {",
+		"    skipSpace()",
+		"    val start = pos",
+		"    while (pos < text.length && (text[pos] in '0'..'9' || text[pos] == '.' || text[pos] == 'e' || text[pos] == 'E' || text[pos] == '+' || text[pos] == '-')) pos++",
+		"    if (pos == start) fail(\"expected a number\")",
+		"    return text.substring(start, pos).toDoubleOrNull() ?: fail(\"bad number\")",
+		"  }",
+		"",
+		"  // plain-digit fast paths: the value when the token at pos is an integer",
+		"  // in range, null when it needs the double slow path. nothing is",
+		"  // consumed on null, so the caller falls back to nextDouble.",
+		"  fun nextIntOrNull(): Int? {",
+		"    var i = pos",
+		"    val negative = i < text.length && text[i] == '-'",
+		"    if (negative) i++",
+		"    var value = 0L",
+		"    val digits = i",
+		"    while (i < text.length && text[i] in '0'..'9') {",
+		"      value = value * 10 + (text[i] - '0')",
+		"      if (value > 2147483648L) return null",
+		"      i++",
+		"    }",
+		"    if (i == digits) return null",
+		"    if (i < text.length && (text[i] == '.' || text[i] == 'e' || text[i] == 'E')) return null",
+		"    if (!negative && value > 2147483647L) return null",
+		"    pos = i",
+		"    return if (negative) -value.toInt() else value.toInt()",
+		"  }",
+		"",
+		"  fun nextLongOrNull(): Long? {",
+		"    var i = pos",
+		"    val negative = i < text.length && text[i] == '-'",
+		"    if (negative) i++",
+		"    var value = 0L",
+		"    val digits = i",
+		"    while (i < text.length && text[i] in '0'..'9') {",
+		"      val digit = (text[i] - '0').toLong()",
+		"      if (value > (9007199254740991L - digit) / 10) return null",
+		"      value = value * 10 + digit",
+		"      i++",
+		"    }",
+		"    if (i == digits) return null",
+		"    if (i < text.length && (text[i] == '.' || text[i] == 'e' || text[i] == 'E')) return null",
+		"    pos = i",
+		"    return if (negative) -value else value",
+		"  }",
+		"",
+		"  fun nextBoolean(): Boolean {",
+		"    skipSpace()",
+		"    if (text.startsWith(\"true\", pos)) {",
+		"      pos += 4",
+		"      return true",
+		"    }",
+		"    if (text.startsWith(\"false\", pos)) {",
+		"      pos += 5",
+		"      return false",
+		"    }",
+		"    fail(\"expected a boolean\")",
+		"  }",
+		"",
+		"  fun nextNull() {",
+		"    skipSpace()",
+		"    if (!text.startsWith(\"null\", pos)) fail(\"expected null\")",
+		"    pos += 4",
+		"  }",
+		"",
+		"  fun skipValue() {",
+		"    when (peek()) {",
+		`      ${tokenClass}.BEGIN_OBJECT -> {`,
+		"        beginObject()",
+		"        while (hasNext()) {",
+		"          nextName()",
+		"          skipValue()",
+		"        }",
+		"        endObject()",
+		"      }",
+		`      ${tokenClass}.BEGIN_ARRAY -> {`,
+		"        beginArray()",
+		"        while (hasNext()) {",
+		"          skipValue()",
+		"        }",
+		"        endArray()",
+		"      }",
+		`      ${tokenClass}.STRING -> nextString()`,
+		`      ${tokenClass}.NUMBER -> nextDouble()`,
+		`      ${tokenClass}.BOOLEAN -> nextBoolean()`,
+		`      ${tokenClass}.NULL -> nextNull()`,
+		"      else -> fail(\"unexpected value\")",
+		"    }",
+		"  }",
+		"",
+		"  fun endDocument() {",
+		"    skipSpace()",
+		"    if (pos != text.length) fail(\"trailing characters\")",
+		"  }",
+		"}",
+		"",
+		`private fun readString(reader: ${readerClass}, path: String): String {`,
+		`  if (reader.peek() != ${tokenClass}.STRING) error("$path: expected string")`,
+		"  return reader.nextString()",
+		"}",
+		`private fun readBoolean(reader: ${readerClass}, path: String): Boolean {`,
+		`  if (reader.peek() != ${tokenClass}.BOOLEAN) error("$path: expected boolean")`,
+		"  return reader.nextBoolean()",
+		"}",
+		`private fun readDouble(reader: ${readerClass}, path: String): Double {`,
+		`  if (reader.peek() != ${tokenClass}.NUMBER) error("$path: expected number")`,
+		"  val result = reader.nextDouble()",
 		"  if (!result.isFinite()) error(\"$path: expected finite number\")",
 		"  return result",
 		"}",
-		"private fun readInt(value: Any, path: String): Int {",
-		"  val result = readDouble(value, path)",
+		`private fun readInt(reader: ${readerClass}, path: String): Int {`,
+		`  if (reader.peek() != ${tokenClass}.NUMBER) error("$path: expected number")`,
+		"  reader.nextIntOrNull()?.let { return it }",
+		"  val result = readDouble(reader, path)",
 		"  if (result % 1.0 != 0.0 || result < Int.MIN_VALUE || result > Int.MAX_VALUE) error(\"$path: expected Int\")",
 		"  return result.toInt()",
 		"}",
-		"private fun readLong(value: Any, path: String): Long {",
-		"  val result = readDouble(value, path)",
+		`private fun readLong(reader: ${readerClass}, path: String): Long {`,
+		`  if (reader.peek() != ${tokenClass}.NUMBER) error("$path: expected number")`,
+		"  reader.nextLongOrNull()?.let { return it }",
+		"  val result = readDouble(reader, path)",
 		"  if (result % 1.0 != 0.0 || result < -9007199254740991.0 || result > 9007199254740991.0) error(\"$path: expected safe Long\")",
 		"  return result.toLong()",
 		"}",
-		"private fun <T> readList(value: Any, path: String, read: (Any, String) -> T): List<T> {",
-		"  val array = value as? JSONArray ?: error(\"$path: expected array\")",
-		"  return (0 until array.length()).map { index -> read(array.get(index), \"$path[$index]\") }",
+		"// the host sends true for each callback the element passed; any other",
+		"// value reads as absent.",
+		`private fun readOptBoolean(reader: ${readerClass}): Boolean {`,
+		`  if (reader.peek() != ${tokenClass}.BOOLEAN) {`,
+		"    reader.skipValue()",
+		"    return false",
+		"  }",
+		"  return reader.nextBoolean()",
+		"}",
+		`private fun <T> readList(reader: ${readerClass}, path: String, read: (${readerClass}, String) -> T): List<T> {`,
+		`  if (reader.peek() != ${tokenClass}.BEGIN_ARRAY) error("$path: expected array")`,
+		"  reader.beginArray()",
+		"  val result = mutableListOf<T>()",
+		"  var index = 0",
+		"  while (reader.hasNext()) {",
+		"    result.add(read(reader, \"$path[$index]\"))",
+		"    index++",
+		"  }",
+		"  reader.endArray()",
+		"  return result",
 		"}",
-		"private fun <T> readMap(value: Any, path: String, read: (Any, String) -> T): Map<String, T> {",
-		"  val objectValue = value as? JSONObject ?: error(\"$path: expected object\")",
-		"  return objectValue.keys().asSequence().associateWith { key -> read(objectValue.get(key), \"$path.$key\") }",
+		`private fun <T> readMap(reader: ${readerClass}, path: String, read: (${readerClass}, String) -> T): Map<String, T> {`,
+		`  if (reader.peek() != ${tokenClass}.BEGIN_OBJECT) error("$path: expected object")`,
+		"  reader.beginObject()",
+		"  val result = mutableMapOf<String, T>()",
+		"  while (reader.hasNext()) {",
+		"    val key = reader.nextName()",
+		"    result[key] = read(reader, \"$path.$key\")",
+		"  }",
+		"  reader.endObject()",
+		"  return result",
 		"}",
 		...needsDate ? [
-			"private fun readDate(value: Any, path: String): java.util.Date {",
-			"  val text = readString(value, path)",
+			`private fun readDate(reader: ${readerClass}, path: String): java.util.Date {`,
+			"  val text = readString(reader, path)",
 			`  for (pattern in arrayOf("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", "yyyy-MM-dd'T'HH:mm:ss'Z'")) {`,
 			"    try {",
 			"      return java.text.SimpleDateFormat(pattern, java.util.Locale.US).apply { timeZone = java.util.TimeZone.getTimeZone(\"UTC\"); isLenient = false }.parse(text) ?: error(\"$path: expected date\")",
@@ -2313,9 +2791,9 @@ function renderKotlinSourceGlue(sourceId, contract) {
 			`  java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", java.util.Locale.US).apply { timeZone = java.util.TimeZone.getTimeZone("UTC") }.format(value)`
 		] : [],
 		...needsData ? [
-			"private fun readData(value: Any, path: String): ByteArray {",
+			`private fun readData(reader: ${readerClass}, path: String): ByteArray {`,
 			"  try {",
-			"    return android.util.Base64.decode(readString(value, path), android.util.Base64.NO_WRAP)",
+			"    return android.util.Base64.decode(readString(reader, path), android.util.Base64.NO_WRAP)",
 			"  } catch (decodeError: IllegalArgumentException) {",
 			"    error(\"$path: expected base64 data\")",
 			"  }",
@@ -2327,7 +2805,9 @@ function renderKotlinSourceGlue(sourceId, contract) {
 		`@Keep class OneNativeSource_${sourceId}: OneNativeSourceDispatch {`,
 		`  override val contractHash = ${JSON.stringify(hash)}`,
 		"  override suspend fun call(module: String, method: String, argsJson: String): String {",
-		"    val args = JSONArray(argsJson)",
+		`    val reader = ${readerClass}(argsJson)`,
+		`    if (reader.peek() != ${tokenClass}.BEGIN_ARRAY) error("args must be a JSON array")`,
+		"    reader.beginArray()",
 		"    return when (module) {",
 		...contract.modules.flatMap(function(module) {
 			return [
@@ -2343,16 +2823,24 @@ function renderKotlinSourceGlue(sourceId, contract) {
 						}).join("")}.toString()) }`;
 						return [
 							`        ${JSON.stringify(method.name)} -> {`,
-							`          require(args.length() == 0) { "${sourceId}.${module.name}.${method.name} subscribes; it takes no arguments" }`,
+							`          require(!reader.hasNext()) { "${sourceId}.${module.name}.${method.name} subscribes; it takes no arguments" }`,
+							"          reader.endArray()",
+							"          reader.endDocument()",
 							`          ${qualified(module.name)}.${method.name}(${closure})`,
 							"          \"null\"",
 							"        }"
 						];
 					}
-					var lines = [`        ${JSON.stringify(method.name)} -> {`, `          require(args.length() == ${method.parameters.length}) { "${sourceId}.${module.name}.${method.name} expects ${method.parameters.length} arguments" }`];
+					var lines = [`        ${JSON.stringify(method.name)} -> {`];
+					var arityMessage = `${sourceId}.${module.name}.${method.name} expects ${method.parameters.length} arguments`;
 					method.parameters.forEach(function(parameter, index) {
-						lines.push(`          val arg${index} = ${value(parameter.nativeType, `args.get(${index})`, JSON.stringify(`args[${index}]`))}`);
+						lines.push(`          val arg${index} = ${value(parameter.nativeType, "reader", JSON.stringify(`args[${index}]`))}`);
+						if (index < method.parameters.length - 1) {
+							lines.push(`          require(reader.hasNext()) { ${JSON.stringify(arityMessage)} }`);
+						}
 					});
+					lines.push(`          require(!reader.hasNext()) { ${JSON.stringify(arityMessage)} }`);
+					lines.push("          reader.endArray()", "          reader.endDocument()");
 					var call = `${qualified(module.name)}.${method.name}(${method.parameters.map(function(_, index) {
 						return `arg${index}`;
 					}).join(", ")})`;
@@ -2376,27 +2864,223 @@ function renderKotlinSourceGlue(sourceId, contract) {
 		"  }",
 		"}",
 		"",
-		...contract.views.length === 0 ? [] : viewGlue(sourceId, contract, hash, value, encode)
+		...contract.views.length === 0 ? [] : viewGlue(sourceId, contract, hash, value, encode, qualifiedType)
 	].join("\n");
 	return {
 		hash,
 		source
 	};
 }
-function viewGlue(sourceId, contract, hash, value, encode) {
+function viewGlue(sourceId, contract, hash, value, encode, qualifiedType) {
 	var qualifier = contract.packageName ? `${contract.packageName}.` : "";
+	var cap = function cap2(name) {
+		return name.slice(0, 1).toUpperCase() + name.slice(1);
+	};
+	var readerClass = `OneJsonReader_${sourceId}`;
+	var tokenClass = `OneJsonToken_${sourceId}`;
+	var SEQ_KEY = "\"\\$seq\"";
+	var BASE_KEY = "\"\\$base\"";
+	var LISTS_KEY = "\"\\$lists\"";
+	var listElement = function listElement2(type) {
+		var inner = type.endsWith("?") ? type.slice(0, -1) : type;
+		return inner.startsWith("List<") && inner.endsWith(">") ? inner.slice(5, -1) : null;
+	};
+	var holders = contract.views.flatMap(function(view) {
+		return [
+			`private class Held${view.name}_${sourceId} {`,
+			...view.props.flatMap(function(prop) {
+				if (prop.callback) {
+					return prop.nativeType.endsWith("?") ? [`  var has${cap(prop.name)}: Boolean = false`] : [];
+				}
+				var declared = qualifiedType(prop.nativeType);
+				if (prop.optional || prop.nativeType.endsWith("?")) return [`  var ${prop.name}: ${declared} = null`];
+				var zero = unboxedZero(prop.nativeType);
+				if (zero !== null) return [`  var ${prop.name}: ${declared} = ${zero}`];
+				if (prop.nativeType === "String") return [`  var ${prop.name}: String = ""`];
+				return [`  var ${prop.name}: ${declared}? = null`];
+			}),
+			"}"
+		];
+	});
+	var mergers = contract.views.flatMap(function(view) {
+		return view.props.flatMap(function(prop) {
+			if (prop.callback) return [];
+			var elem = listElement(prop.nativeType);
+			if (elem === null) return [];
+			var element = qualifiedType(elem);
+			return [
+				`private fun mergeLists${view.name}${cap(prop.name)}(reader: ${readerClass}, old: List<${element}>?, prop: String): List<${element}>? {`,
+				`  if (reader.peek() != ${tokenClass}.BEGIN_OBJECT) error("lists.$prop: expected object")`,
+				"  reader.beginObject()",
+				"  var length = -1",
+				`  var set: List<Pair<Int, ${element}>>? = null`,
+				"  while (reader.hasNext()) {",
+				"    when (reader.selectName(\"length\", \"set\")) {",
+				`      0 -> length = readInt(reader, "lists.$prop.length")`,
+				`      1 -> set = readList(reader, "lists.$prop.set") { itemReader, itemPath -> itemReader.beginArray(); val si = readInt(itemReader, itemPath); if (!itemReader.hasNext()) error("$itemPath: expected element"); val sv = ${value(elem, "itemReader", "itemPath")}; itemReader.endArray(); si to sv }`,
+				"      else -> reader.skipValue()",
+				"    }",
+				"  }",
+				"  reader.endObject()",
+				"  if (length < 0) error(\"lists.$prop: needs length\")",
+				"  val current = old ?: return null",
+				"  val entries = set ?: emptyList()",
+				"  for (j in 1 until entries.size) require(entries[j].first > entries[j - 1].first) { \"lists.$prop: set out of order\" }",
+				`  val fresh = ArrayList<${element}>(length)`,
+				"  var s = 0",
+				"  for (i in 0 until length) {",
+				"    if (s < entries.size && entries[s].first == i) { fresh.add(entries[s].second); s++ }",
+				"    else if (i < current.size) fresh.add(current[i])",
+				"    else return null",
+				"  }",
+				"  return fresh",
+				"}"
+			];
+		});
+	});
 	return [
+		...holders,
+		...mergers,
+		"",
 		`@Keep class OneNativeSourceViews_${sourceId}: OneNativeSourceViewDispatch {`,
 		`  override val contractHash = ${JSON.stringify(hash)}`,
+		"  override fun apply(view: String, propsJson: String, state: OneNativeSourceKeyedState): Boolean {",
+		`    val reader = ${readerClass}(propsJson)`,
+		`    if (reader.peek() != ${tokenClass}.BEGIN_OBJECT) error("props must be a JSON object")`,
+		"    reader.beginObject()",
+		"    when (view) {",
+		...contract.views.flatMap(function(view) {
+			var holder = `Held${view.name}_${sourceId}`;
+			var lists = view.props.filter(function(prop) {
+				return !prop.callback && listElement(prop.nativeType) !== null;
+			});
+			var options = [
+				SEQ_KEY,
+				BASE_KEY,
+				LISTS_KEY,
+				...view.props.map(function(prop) {
+					return JSON.stringify(prop.name);
+				})
+			].join(", ");
+			return [
+				`      ${JSON.stringify(view.name)} -> {`,
+				`        var held = state.views[${JSON.stringify(view.name)}] as? ${holder}`,
+				"        var seq = -1",
+				"        var hasSeq = false",
+				"        var base = -1",
+				"        var hasBase = false",
+				"        var sawLists = false",
+				...view.props.flatMap(function(prop) {
+					if (prop.callback) {
+						return prop.nativeType.endsWith("?") ? [`        var ${prop.name}Doc: Boolean? = null`] : [];
+					}
+					var declared = qualifiedType(prop.nativeType);
+					if (prop.optional || prop.nativeType.endsWith("?")) {
+						return [`        var ${prop.name}: ${declared} = null`, `        var has${cap(prop.name)} = false`];
+					}
+					var zero = unboxedZero(prop.nativeType);
+					if (zero !== null) return [`        var ${prop.name} = ${zero}`, `        var has${cap(prop.name)} = false`];
+					return [`        var ${prop.name}: ${declared}? = null`];
+				}),
+				...lists.map(function(prop) {
+					return `        var ${prop.name}MergeFailed = false`;
+				}),
+				"        while (reader.hasNext()) {",
+				`          when (reader.selectName(${options})) {`,
+				"            0 -> { seq = readInt(reader, \"seq\"); hasSeq = true }",
+				"            1 -> { base = readInt(reader, \"base\"); hasBase = true }",
+				"            2 -> {",
+				"              sawLists = true",
+				`              if (reader.peek() != ${tokenClass}.BEGIN_OBJECT) error("lists: expected object")`,
+				"              reader.beginObject()",
+				"              while (reader.hasNext()) {",
+				`                when (reader.selectName(${lists.map(function(prop) {
+					return JSON.stringify(prop.name);
+				}).join(", ")})) {`,
+				...lists.map(function(prop, listsIndex) {
+					return `                  ${listsIndex} -> { val merged${cap(prop.name)} = mergeLists${view.name}${cap(prop.name)}(reader, held?.${prop.name}, ${JSON.stringify(prop.name)}); if (merged${cap(prop.name)} == null) ${prop.name}MergeFailed = true else ${prop.name} = merged${cap(prop.name)} }`;
+				}),
+				"                  else -> reader.skipValue()",
+				"                }",
+				"              }",
+				"              reader.endObject()",
+				"            }",
+				...view.props.map(function(prop, index) {
+					var arm = index + 3;
+					if (prop.callback) {
+						return prop.nativeType.endsWith("?") ? `            ${arm} -> ${prop.name}Doc = readOptBoolean(reader)` : `            ${arm} -> reader.skipValue()`;
+					}
+					var path = JSON.stringify(`props.${prop.name}`);
+					var read = `${prop.name} = ${value(prop.nativeType, "reader", path)}`;
+					var needsFlag = prop.optional || prop.nativeType.endsWith("?") || unboxedZero(prop.nativeType) !== null;
+					return needsFlag ? `            ${arm} -> { ${read}; has${cap(prop.name)} = true }` : `            ${arm} -> ${read}`;
+				}),
+				"            else -> reader.skipValue()",
+				"          }",
+				"        }",
+				"        reader.endObject()",
+				"        reader.endDocument()",
+				"        if (hasBase && !hasSeq) error(\"seq: required\")",
+				"        if (sawLists && !hasBase) error(\"lists: needs a change document\")",
+				"        if (!hasBase) {",
+				...view.props.flatMap(function(prop) {
+					if (prop.callback || prop.optional) return [];
+					if (prop.nativeType.endsWith("?") || unboxedZero(prop.nativeType) !== null) {
+						return [`          if (!has${cap(prop.name)}) error("props.${prop.name}: required")`];
+					}
+					return [];
+				}),
+				`          val h = held ?: ${holder}().also { state.views[${JSON.stringify(view.name)}] = it }`,
+				...view.props.flatMap(function(prop) {
+					if (prop.callback) {
+						return prop.nativeType.endsWith("?") ? [`          h.has${cap(prop.name)} = ${prop.name}Doc == true`] : [];
+					}
+					if (prop.optional || prop.nativeType.endsWith("?") || unboxedZero(prop.nativeType) !== null) {
+						return [`          h.${prop.name} = ${prop.name}`];
+					}
+					return [`          h.${prop.name} = (${prop.name} ?: error("props.${prop.name}: required"))`];
+				}),
+				"          if (hasSeq) state.seq = seq",
+				"          state.revision++",
+				"          return true",
+				"        }",
+				"        if (seq == state.seq) return true",
+				"        val h = held",
+				"        if (base == state.seq && h != null) {",
+				...view.props.flatMap(function(prop) {
+					if (prop.callback) {
+						return prop.nativeType.endsWith("?") ? [`            if (${prop.name}Doc != null) h.has${cap(prop.name)} = ${prop.name}Doc`] : [];
+					}
+					var mergeFailed = listElement(prop.nativeType) !== null ? [`            if (${prop.name}MergeFailed) error("lists.${prop.name}: cannot merge")`] : [];
+					if (prop.optional || prop.nativeType.endsWith("?") || unboxedZero(prop.nativeType) !== null) {
+						return [...mergeFailed, `            if (has${cap(prop.name)}) h.${prop.name} = ${prop.name}`];
+					}
+					return [...mergeFailed, `            if (${prop.name} != null) h.${prop.name} = ${prop.name}`];
+				}),
+				"            state.seq = seq",
+				"            state.revision++",
+				"            return true",
+				"          }",
+				"        return false",
+				"      }"
+			];
+		}),
+		"      else -> error(\"composable $view is not linked; rebuild the app\")",
+		"    }",
+		"  }",
 		"  @Composable",
-		"  override fun Content(view: String, propsJson: String, emit: (String, String) -> Unit) {",
-		"    val props = JSONObject(propsJson)",
+		"  override fun Content(view: String, state: OneNativeSourceKeyedState, emit: (String, String) -> Unit) {",
 		"    when (view) {",
 		...contract.views.flatMap(function(view) {
+			var holder = `Held${view.name}_${sourceId}`;
 			return [
-				`      ${JSON.stringify(view.name)} -> ${qualifier}${view.name}(`,
+				`      ${JSON.stringify(view.name)} -> {`,
+				"        // the revision read resubscribes this scope on every apply",
+				"        val revision = state.revision",
+				`        val held = state.views[${JSON.stringify(view.name)}] as? ${holder}`,
+				"        held?.let { h ->",
+				`          ${qualifier}${view.name}(`,
 				...view.props.map(function(prop) {
-					var path = JSON.stringify(`props.${prop.name}`);
 					if (prop.callback) {
 						var args = prop.callback.map(function(_, index) {
 							return `a${index}`;
@@ -2408,12 +3092,16 @@ function viewGlue(sourceId, contract, hash, value, encode) {
 							return `.put(${encode(types[index], arg)})`;
 						}).join("")}.toString())`;
 						var lambda = `{ ${args.length > 0 ? `${args.join(", ")} -> ` : ""}${body} }`;
-						return `        ${prop.name} = ${prop.nativeType.endsWith("?") ? `if (props.optBoolean(${JSON.stringify(prop.name)})) (${lambda}) else null` : lambda},`;
+						return `            ${prop.name} = ${prop.nativeType.endsWith("?") ? `if (h.has${cap(prop.name)}) (${lambda}) else null` : lambda},`;
 					}
-					var input = prop.optional ? `(props.opt(${JSON.stringify(prop.name)}) ?: JSONObject.NULL)` : `(props.opt(${JSON.stringify(prop.name)}) ?: error(${JSON.stringify(`props.${prop.name}: required`)}))`;
-					return `        ${prop.name} = ${value(prop.nativeType, input, path)},`;
+					if (prop.optional || prop.nativeType.endsWith("?") || unboxedZero(prop.nativeType) !== null || prop.nativeType === "String") {
+						return `            ${prop.name} = h.${prop.name},`;
+					}
+					return `            ${prop.name} = h.${prop.name}!!,`;
 				}),
-				"      )"
+				"          )",
+				"        }",
+				"      }"
 			];
 		}),
 		"      else -> error(\"composable $view is not linked; rebuild the app\")",