Conformance harness part A

[fangmobile]

Implement conformance harness - Part A in #59
a2ui-json related test cases will fail until #70 is merged.

a second batch of tests fail due to other non conformance
Draft for now.

all changes to 4 files in Sources/A2UISwiftUICore are "addition", to meet the conformance suite requirements.

Errors.swift

Adds two error types mirroring the Python reference validator: A2uiIntegrityError (code INTEGRITY_ERROR) for structural violations of the component graph, and A2uiRecursionError (code RECURSION_ERROR) for recursion/depth-limit violations. They exist so the new A2uiPayloadValidator can throw the same error taxonomy the conformance suite asserts on.
Related cases: validator.yaml — integrity cases such as test_validate_duplicate_ids_v09, test_validate_missing_root_v09, test_validate_dangling_references_v09; recursion cases such as test_validate_self_reference_v09 and test_validate_function_call_recursion*.

Transport/A2UIResponseParser.swift (new)

Non-streaming counterpart to the stream parser, mirroring upstream Python parser.py. Provides parseFull (splits a complete agent response into text / a2ui parts, throwing a strict A2uiParseError on malformed JSON since the whole payload is available up front), fixPayload (repairs common LLM JSON damage — trailing commas, auto-wrapping a bare object into an array), and hasA2uiParts (detects whether a response contains any A2UI block).
Related cases: the entire parser.yaml suite — 9 parse_full cases (e.g. test_parse_response_with_text_and_tags, test_parse_response_multiple_blocks, test_parse_response_invalid_json), 7 fix_payload cases (e.g. test_fix_payload_trailing_comma_list, test_fix_payload_auto_wrap), 3 has_parts cases.

Transport/A2UIStreamParser.swift

Previously the parser buffered an entire block and only decoded it when the close tag arrived. The upstream Python streaming.py state machine instead emits incrementally ("sniff & cut"): messages are yielded as each top-level array element completes, partial components are yielded early when safe, and the conformance suite asserts on that per-chunk event granularity. This change ports that behavior: incremental brace/string scanning, auto-closing unterminated strings only on catalog-cuttable keys, holding back partial components missing catalog-required fields, seen-component reachability yields gated on the Row loading placeholder, per-key data-model deltas, and cycle/self-reference detection. A new A2UIStreamParserConfig carries the catalog-derived cuttable keys and required-field map.
Related cases: all 76 process_chunk cases in streaming_parser.yaml — e.g. test_incremental_yielding, test_partial_json_and_incremental_yielding, test_waiting_for_root_component, test_circular_reference_detection, test_multiple_a2ui_blocks.

Validation/A2uiPayloadValidator.swift (new)

Semantic (graph/topology) pre-flight validator that sits above the per-message Codable envelope decode, mirroring Python validating/{validator,integrity_checker,topology_analyzer}.py. Enforces: duplicate component ids, root reachability, dangling references, orphaned components, self-references and cycles, functionCall nesting depth, global logical and data-model depth limits, JSON-Pointer path syntax, and catalog-declared property schemas. It is stateful across validate calls so incremental updates (payloads without createSurface) can reference ids delivered in earlier steps while still enforcing the always-on rules.

Related cases:

all 45 validate cases in validator.yaml — e.g. test_validator_0_9, test_custom_catalog_0_9, test_validate_duplicate_ids_v09, test_validate_orphaned_component_v09, and the test_incremental_update_* series.

Test suite green with agent related tests skipped. (not for renderers)

[gemini-code-assist]

Code Review

This pull request introduces a new test target, A2UIConformanceTests, which includes a custom YAML parser, a test harness, and several conformance test suites to validate the A2UI specification. The review feedback primarily focuses on enhancing the custom YAML parser to correctly decode escape sequences in quoted strings and to robustly support Windows-style line endings (\r\n) across sequence and mapping checks. Additionally, it is recommended to replace a hardcoded sleep in the test harness with a deterministic wait loop to prevent test flakiness on slower CI environments.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

Inline block sequence items that are quoted strings (e.g., - "value") are currently collected as raw scalars, which means escape sequences (like \\n, \\") are never decoded. We should explicitly parse them using parseDoubleQuotedString() or parseSingleQuotedString().

                let ch = source[pos]
                if ch == "[" {
                    result.append(try parseFlowSequence())
                    consumeRestOfLine()
                } else if ch == "{" {
                    result.append(try parseFlowMapping())
                    consumeRestOfLine()
                } else if ch == "|" || ch == ">" {
                    result.append(try parseBlockScalar(keyIndent: seqIndent + 2))
                } else if lookaheadIsMappingKey(from: pos) {
                    // Inline mapping: first key starts here, continuation lines
                    // are at seqIndent + 2.
                    result.append(try parseInlineBlockMapping(keyIndent: seqIndent + 2))
                } else if ch == "\"" {
                    result.append(try parseDoubleQuotedString())
                    consumeRestOfLine()
                } else if ch == "'" {
                    result.append(parseSingleQuotedString())
                    consumeRestOfLine()
                } else {
                    let raw = collectScalar()
                    result.append(parseScalar(raw))
                    consumeRestOfLine()
                }

[fangmobile]

Fixed — block-sequence items now dispatch to parseDoubleQuotedString()/parseSingleQuotedString() for "/' (YAMLDecoder.swift, commit 6583846).

[gemini-code-assist]

Block mapping values that are quoted strings (e.g., key: "value") are currently collected as raw scalars, which means escape sequences (like \\n, \\") are never decoded. We should explicitly parse them using parseDoubleQuotedString() or parseSingleQuotedString().

            let ch = source[pos]
            if ch == "[" {
                value = try parseFlowSequence()
                consumeRestOfLine()
            } else if ch == "{" {
                value = try parseFlowMapping()
                consumeRestOfLine()
            } else if ch == "|" || ch == ">" {
                value = try parseBlockScalar(keyIndent: mapIndent + 2)
            } else if ch == "\"" {
                value = try parseDoubleQuotedString()
                consumeRestOfLine()
            } else if ch == "'" {
                value = parseSingleQuotedString()
                consumeRestOfLine()
            } else {
                let raw = collectScalar()
                value = parseScalar(raw)
                consumeRestOfLine()
            }

[fangmobile]

Fixed — block-mapping quoted values now dispatch to parseDoubleQuotedString()/parseSingleQuotedString() (YAMLDecoder.swift, commit 6583846).

[gemini-code-assist]

In environments with \r\n (Windows-style) line endings, the lookahead check for mapping keys will fail to recognize keys followed by an empty value or a newline because \r is not handled as a line terminator or whitespace. We should update the loop condition and the whitespace check to include \r.

Suggested change

	while i < source.count && source[i] != "\n" {
	let ch = source[i]
	if ch == ":" {
	let next = (i + 1 < source.count) ? source[i + 1] : "\0"
	if next == " " || next == "\n" || next == "\t" { return true }
	}
	i += 1
	}
	while i < source.count && source[i] != "\n" && source[i] != "\r" {
	let ch = source[i]
	if ch == ":" {
	let next = (i + 1 < source.count) ? source[i + 1] : "\0"
	if next == " " || next == "\n" || next == "\r" || next == "\t" { return true }
	}
	i += 1
	}

[fangmobile]

Fixed differently: rather than patching every individual \r check, YAMLScanner.init now normalizes \r\n/\r → \n once up front (YAML 1.2 §5.4 line-break normalization), so every downstream scan only needs to check \n. Covers this and the other four \r-handling comments below in one place (YAMLDecoder.swift, commit 6583846).

[gemini-code-assist]

When parsing block sequences, a Windows-style newline (\r\n) after a hyphen (-) will not be recognized as a valid sequence entry because \r is not included in the allowed whitespace characters for the next character check.

Suggested change

	let next = (look + 1 < source.count) ? source[look + 1] : "\0"
	guard next == " " || next == "\n" || next == "\t" else { break }
	let next = (look + 1 < source.count) ? source[look + 1] : "\0"
	guard next == " " || next == "\n" || next == "\r" || next == "\t" else { break }

[fangmobile]

Fixed — see the reply on the mapping-key-lookahead comment above: line-ending normalization in YAMLScanner.init handles this case too (commit 6583846).

[gemini-code-assist]

Ensure \r is treated as a newline when checking for empty/newline sequence entries to prevent Windows-style line endings from being parsed as inline content.

Suggested change

	if pos >= source.count || source[pos] == "\n" {
	if pos >= source.count || source[pos] == "\n" || source[pos] == "\r" {

[fangmobile]

Fixed via the same line-ending normalization in YAMLScanner.init (commit 6583846).

[gemini-code-assist]

When checking if a block mapping contains a sequence item, we should also check for \r to support Windows-style line endings.

Suggested change

	if source[look] == "-" {
	let nx = (look + 1 < source.count) ? source[look + 1] : "\0"
	if nx == " " || nx == "\n" { break }
	if source[look] == "-" {
	let nx = (look + 1 < source.count) ? source[look + 1] : "\0"
	if nx == " " || nx == "\n" || nx == "\r" { break }
	}

[fangmobile]

Fixed via the same line-ending normalization in YAMLScanner.init (commit 6583846).

[gemini-code-assist]

In parseKeyValuePair, treat \r as a newline to correctly parse empty values followed by Windows-style line endings.

Suggested change

	if pos >= source.count || source[pos] == "\n" {
	if pos >= source.count || source[pos] == "\n" || source[pos] == "\r" {

[fangmobile]

Fixed via the same line-ending normalization in YAMLScanner.init (commit 6583846).

[gemini-code-assist]

When parsing keys, treat \r as a valid line terminator following a colon to support Windows-style line endings.

            if c == ":" {
                let nx = (pos + 1 < source.count) ? source[pos + 1] : "\0"
                if nx == " " || nx == "\n" || nx == "\r" || nx == "\t" { break }
            }

[fangmobile]

Fixed via the same line-ending normalization in YAMLScanner.init (commit 6583846).

[gemini-code-assist]

Add an eventsCount property to the EventBuffer actor to allow deterministic waiting in tests without exposing the mutable events array directly.

    actor EventBuffer {
        var events: [ParsedEvent] = []
        var eventsCount: Int { events.count }
        func append(_ e: ParsedEvent) { events.append(e) }
        func drain() -> [ParsedEvent] { let r = events; events = []; return r }
    }

[fangmobile]

Addressed with a different shape: kept events private on the actor and added drainStable(expectedCount:), which polls buffer.count (an existing internal accessor) up to the expected count before falling back to the stability-window poll — same deterministic-wait goal without exposing a new public counter (ConformanceHarness.swift, commit 6583846).

[gemini-code-assist]

Using a hardcoded Task.sleep of 10ms to wait for cooperative scheduler tasks is a known source of test flakiness on slower CI runners. Since we know the expected number of events when step.expect is specified, we can implement a deterministic wait loop with a timeout to make the tests both faster and more robust.

Suggested change

	// Sleep briefly to give the cooperative scheduler time to drain events reliably.
	try await Task.sleep(nanoseconds: 10_000_000)
	let events = await buffer.drain()
	await parser.add(input)
	// Wait for expected events if any are specified, otherwise sleep briefly
	let expectedCount = (step.expect as? [Any])?.count ?? 0
	if expectedCount > 0 {
	let start = DispatchTime.now()
	while await buffer.eventsCount < expectedCount {
	if DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds > 1_000_000_000 {
	break
	}
	try? await Task.sleep(nanoseconds: 1_000_000)
	}
	} else {
	try? await Task.sleep(nanoseconds: 10_000_000)
	}
	let events = await buffer.drain()

[fangmobile]

Fixed along the same lines as suggested — drainStable now takes an expectedCount (derived from step.expect's flattened event count) and polls for it before falling back to the fixed sleep, bounded at ~1s (ConformanceHarness.swift, commit 6583846).

[fangmobile]

@BBC6BAE9 Please take a look?

[fangmobile]

@gemini-code-assist[bot] review

[gemini-code-assist]

Code Review

This pull request introduces comprehensive validation and parsing capabilities for v0.9 A2UI payloads, including a new A2uiPayloadValidator for semantic graph and topology checks, an A2UIResponseParser for complete responses, and incremental scanning support in A2UIStreamParser. It also adds a robust suite of conformance tests. The review feedback highlights critical issues to address: a bug on Darwin platforms where NSNumber bridging to Bool breaks numeric type validation, a state leak in A2UIStreamParser when processing deleteSurface messages, and a performance bottleneck caused by $O(N^2)$ string slicing in the stream parser's substring helper.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

On Darwin platforms (iOS/macOS), NSNumber bridges to Bool, which means value is Bool evaluates to true for any numeric NSNumber (e.g., NSNumber(value: 1) or NSNumber(value: 3.14)). This causes isNumber to incorrectly return false for all numbers, breaking validation for numeric properties. To reliably distinguish between booleans and numbers, we should check the CFGetTypeID of the bridged NSNumber first. We can introduce an isBool helper to handle this correctly.

    private func isNumber(_ value: Any) -> Bool {
        if let number = value as? NSNumber {
            // Exclude boolean NSNumbers.
            return CFGetTypeID(number) != CFBooleanGetTypeID()
        }
        return value is Int || value is Double || value is Float
    }

    private func isBool(_ value: Any) -> Bool {
        if let number = value as? NSNumber {
            return CFGetTypeID(number) == CFBooleanGetTypeID()
        }
        return value is Bool
    }

[fangmobile]

Confirmed and fixed. Verified empirically: on Darwin, JSONSerialization-decoded integers 0/1 bridge to is Bool == true (ObjC BOOL/char aliasing) — e.g. {"v":1} decodes to a value where is Bool is true but is Int/is NSNumber are also true. Added isBool(_:) using CFGetTypeID as you suggested, and reworked isNumber to rely solely on CFGetTypeID (dropping the value is Bool early-return, which was the actual source of the misclassification) so integer 0/1 are never excluded from isNumber. Added a regression test (test_booleanProperty_rejectsIntegerZeroOrOne) that fails without this fix.

[gemini-code-assist]

Update validateType to use the new isBool helper to ensure boolean type validation is robust and does not incorrectly match numeric NSNumber values.

    private func validateType(_ value: Any, expected: String) throws {
        let ok: Bool
        switch expected {
        case "string":
            ok = value is String
        case "number", "integer":
            ok = isNumber(value)
        case "boolean":
            ok = isBool(value)
        case "object":
            ok = value is [String: Any]
        case "array":
            ok = value is [Any]
        case "null":
            ok = value is NSNull
        default:
            ok = true
        }
        if !ok {
            throw A2uiValidationError("\(describe(value)) is not of type '\(expected)'")
        }
    }

[fangmobile]

Fixed — validateType's "boolean" case now calls isBool(value).

[gemini-code-assist]

Update describe to use the new isBool helper to prevent numeric NSNumber values (like 1 or 0) from being incorrectly described as "true" or "false" due to Swift's Bool bridging.

Suggested change

	private func describe(_ value: Any) -> String {
	if let string = value as? String { return "'\(string)'" }
	if value is Bool { return "\(value)" }
	if let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() {
	// Print integers without a trailing ".0".
	if number.doubleValue == number.doubleValue.rounded() {
	return "\(number.intValue)"
	}
	return "\(number.doubleValue)"
	}
	if let int = value as? Int { return "\(int)" }
	if let double = value as? Double {
	if double == double.rounded() { return "\(Int(double))" }
	return "\(double)"
	}
	return "\(value)"
	}
	private func describe(_ value: Any) -> String {
	if let string = value as? String { return "'\(string)'" }
	if isBool(value) { return "\(value)" }
	if let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() {
	// Print integers without a trailing ".0".
	if number.doubleValue == number.doubleValue.rounded() {
	return "\(number.intValue)"
	}
	return "\(number.doubleValue)"
	}
	if let int = value as? Int { return "\(int)" }
	if let double = value as? Double {
	if double == double.rounded() { return "\(Int(double))" }
	return "\(double)"
	}
	return "\(value)"
	}

[fangmobile]

Fixed — describe now calls isBool(value) instead of value is Bool.

[gemini-code-assist]

Update jsonEquals to use the new isBool helper to prevent numeric NSNumber values from being incorrectly compared and matched as equal to boolean values.

Suggested change

	private func jsonEquals(_ lhs: Any, _ rhs: Any) -> Bool {
	if let l = lhs as? String, let r = rhs as? String { return l == r }
	if isNumber(lhs) && isNumber(rhs) {
	return (lhs as? NSNumber)?.doubleValue == (rhs as? NSNumber)?.doubleValue
	}
	if let l = lhs as? Bool, let r = rhs as? Bool { return l == r }
	return false
	}
	private func jsonEquals(_ lhs: Any, _ rhs: Any) -> Bool {
	if let l = lhs as? String, let r = rhs as? String { return l == r }
	if isNumber(lhs) && isNumber(rhs) {
	return (lhs as? NSNumber)?.doubleValue == (rhs as? NSNumber)?.doubleValue
	}
	if isBool(lhs) && isBool(rhs) {
	return (lhs as? Bool) == (rhs as? Bool)
	}
	return false
	}

[fangmobile]

Fixed — jsonEquals now uses isBool(lhs) && isBool(rhs) instead of the as? Bool double-cast, consistent with the other three sites.

[gemini-code-assist]

When a deleteSurface message is processed, the parser should clear all cached state associated with that surface (such as startedSurfaces, pendingComponentSurfaces, seenComponents, lastReachableSignature, and yieldedDataModelValues). Failing to do so causes a memory leak and can lead to stale state or incorrect cycle/reachability validation if the same surface ID is reused later in the stream.

Suggested change

	if obj["deleteSurface"] is [String: Any] {
	// A deleteSurface before the surface exists is dropped (upstream `_delete_surface`
	// simply clears state); otherwise emit it.
	let sid = (obj["deleteSurface"] as? [String: Any])?["surfaceId"] as? String
	if let sid, !startedSurfaces.contains(sid) { return }
	emitDecodedOrError(obj)
	return
	}
	if obj["deleteSurface"] is [String: Any] {
	let sid = (obj["deleteSurface"] as? [String: Any])?["surfaceId"] as? String
	if let sid {
	if !startedSurfaces.contains(sid) { return }
	startedSurfaces.remove(sid)
	pendingComponentSurfaces.remove(sid)
	seenComponents.removeValue(forKey: sid)
	lastReachableSignature.removeValue(forKey: sid)
	yieldedDataModelValues.removeValue(forKey: sid)
	}
	emitDecodedOrError(obj)
	return
	}

[fangmobile]

Fixed as suggested — deleteSurface now removes the surface id from startedSurfaces, pendingComponentSurfaces, seenComponents, lastReachableSignature, and yieldedDataModelValues before emitting. Added a regression test (deleteSurfaceClearsReachabilityState) that reuses a surfaceId after delete with an identical component shape — without the fix, the second reachability yield was silently dropped as a dup of the stale pre-delete signature.

[gemini-code-assist]

In Swift, String is not a random-access collection, so s.count and s.index(s.startIndex, offsetBy: offset) are $O(N)$ operations. Since substring is called frequently during streaming, this leads to quadratic time complexity $O(N^2)$ on large inputs, which can cause significant CPU overhead and UI thread lag. Consider refactoring jsonBuffer to be of type [Character] (where count is $O(1)$ and slicing is highly efficient) or storing String.Index directly in braceStack instead of integer offsets.

[fangmobile]

Fixed, though via a narrower change than the suggested String→ full rewrite: converted jsonBuffer to [Character] (O(1) count/indexing, O(k) slicing) and updated its call sites (substring, dropConsumedObject, the two contains(...) key probes). Left buffer (the outer text-mode buffer) as String since its index(offsetBy:) calls are bounded by small tag-prefix lengths, not the full buffer, so they don't have the same quadratic exposure.

[BBC6BAE9]

@BBC6BAE9 Please take a look?

@fangmobile Sorry for the long wait, and thanks for all your hard work. I think it would be best to put this on hold for now and resume the work once WebCore 1.0 is officially released.

[fangmobile]

@BBC6BAE9 Please take a look?

@fangmobile Sorry for the long wait, and thanks for all your hard work. I think it would be best to put this on hold for now and resume the work once WebCore 1.0 is officially released.

Sure. I put it back to draft for now.