Handle jsonl

[jgindin]

Description

Multi-Format Layout Parser (JSON, JSONL, Single-Object)

• Enhances tryParseJsonArray in utils/json.ts to parse standard JSON arrays ([...]), single JSON objects ({...} → [obj]), and streaming JSON Lines ({...}\n{...}).
• Updates RawFrame and ChatCleaner to use unified JSONL-tolerant parsing and layout snapshot validation.
• Adds comprehensive unit tests covering single objects, multi-line JSONL streams, and malformed edge cases.

Pre-launch Checklist

• I signed the [CLA].
• I read the [Contributors Guide].
• I read the [Style Guide].
• I have added updates to the [CHANGELOG].
• I updated/added relevant documentation.
• My code changes (if any) have tests.
• If my branch is on fork, I have verified that scripts/e2e_test.sh passes.

If you need help, consider asking for advice on the [discussion board].

[github-actions]

⚡ A2UI Composer PR Preview

Your automated preview is successfully live (commit 27b9296):
👉 Launch PR Preview

Note: This environment will be wiped automatically when the PR is merged or closed.

[gemini-code-assist]

Code Review

This pull request refactors the workspace by modularizing several services, including origin verification, payload parsing, error formatting, file ingestion, URL validation, and sharing. It also introduces base classes for selectors, adds event tracking directives, and removes the mock rules debug component. The review feedback focuses on hardening string processing utility methods (such as tryParseJsonArray, parseAndHealJsonLines, and attemptSyntaxHealing) with guard clauses to handle nullish or undefined inputs safely, as well as retaining fallback logic and tests for parsing single JSON objects to ensure backwards compatibility.

[gemini-code-assist]

When refactoring or updating parsing/sanitization logic, do not remove existing fallback blocks (such as those supporting single JSON objects instead of arrays) if doing so would alter existing functionality or risk breaking backwards compatibility. Please retain the fallback logic for single JSON objects. Additionally, we should harden this string processing utility method with a guard clause to safely handle nullish or undefined inputs by returning a safe default (null), per our general rules.

export function tryParseJsonArray(content: string | null | undefined): unknown[] | null {
  if (content == null) {
    return null;
  }
  const trimmed = content.trim();
  if (trimmed.length === 0) {
    return null;
  }

  if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
    try {
      const parsed = JSON.parse(trimmed);
      return [parsed];
    } catch (e) {
      return null;
    }
  }

  if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
    try {
      const parsed = JSON.parse(trimmed);
      if (Array.isArray(parsed)) {
        return parsed;
      }
    } catch (e) {
      // Ignore array parse errors
    }
  }
  return null;
}

References

1. Harden string processing utility methods with guard clauses to safely handle nullish or undefined inputs by returning safe defaults, and ensure corresponding unit tests are added to verify resilience against nullish values.
2. When refactoring or updating parsing/sanitization logic, do not remove existing fallback blocks (such as those supporting single JSON objects instead of arrays) if doing so would alter existing functionality or risk breaking backwards compatibility.

[gemini-code-assist]

We should harden this string processing utility method with a guard clause to safely handle nullish or undefined inputs by returning a safe default ({blocks: [], wasHealed: false}), per our general rules.

export function parseAndHealJsonLines(content: string | null | undefined): ParseResult {
  if (content == null) {
    return {blocks: [], wasHealed: false};
  }
  let wasHealed = false;

  // Attempt full JSON parsing before line-by-line processing
  const parsedArray = tryParseJsonArray(content);
  if (parsedArray) {
    return {blocks: parsedArray, wasHealed: false};
  }

References

1. Harden string processing utility methods with guard clauses to safely handle nullish or undefined inputs by returning safe defaults, and ensure corresponding unit tests are added to verify resilience against nullish values.

[gemini-code-assist]

Harden this string processing utility method with a guard clause to safely handle nullish or undefined inputs by returning a safe default (null), per our general rules.

Suggested change

	export function attemptSyntaxHealing(line: string): unknown | null {
	let patched = line.trim();
	export function attemptSyntaxHealing(line: string | null | undefined): unknown | null {
	if (line == null) {
	return null;
	}
	let patched = line.trim();

References

1. Harden string processing utility methods with guard clauses to safely handle nullish or undefined inputs by returning safe defaults, and ensure corresponding unit tests are added to verify resilience against nullish values.

[gemini-code-assist]

Since we must not remove existing fallback blocks (such as those supporting single JSON objects instead of arrays) to maintain backwards compatibility, we should keep this test verifying that a single JSON object is parsed successfully instead of expecting null.

Suggested change

	it('parses a single JSON object as a single-element array', () => {
	expect(tryParseJsonArray('{"not": "an array"}')).toEqual([{not: 'an array'}]);
	expect(tryParseJsonArray(' {"foo": "bar"} ')).toEqual([{foo: 'bar'}]);
	});
	it('returns a single-element array for a single JSON object', () => {
	expect(tryParseJsonArray('{"not": "an array"}')).toEqual([{"not": "an array"}]);
	expect(tryParseJsonArray(' {"foo": "bar"} ')).toEqual([{"foo": "bar"}]);
	});

References

1. When refactoring or updating parsing/sanitization logic, do not remove existing fallback blocks (such as those supporting single JSON objects instead of arrays) if doing so would alter existing functionality or risk breaking backwards compatibility.