feat(typia): align lenient parse recovery with TS parity (#336)

## Summary
- align Rust `typia` lenient JSON EOF recovery with upstream TS behavior
- add upstream parse parity test coverage (66 mapped parse cases)
- expand runtime `validate`/`stringify` boundary tests
- sync typia contracts/docs with parity baseline and explicit exclusions

## Details
- update `crates/typia/src/lenient_json.rs` to recover truncated EOF
inputs without parser-token errors
- keep syntax/token violations and depth guard as failures
- add `crates/typia/tests/llm_json_parse_parity.rs` with table-driven
parity checks
- update `crates/typia/tests/llm_data_runtime.rs` expectations for
recovery semantics
- update docs:
  - `docs/crates-typia-core-foundation.md`
  - `docs/project-typia.md`
  - `crates/typia/README.md`

## Explicit parity exclusions
- JS `undefined` expectations
- non-finite numbers (`Infinity`, `-Infinity`)
- lone-surrogate code-unit expectations

## Validation
- `cargo test -p typia`
- `cargo test`

Author: kdy1

crates/typia/README.md

@@ -48,6 +48,23 @@ Supported recovery behaviors:
 - unicode escapes (including surrogate-pair decoding)
 - depth guard (`MAX_DEPTH = 512`)
 
+Current parse parity baseline for lenient behavior:
+
+- `samchon/typia` `master` parse suite at commit
+  `29a02742661d476ce5ef5414fe32acc7e97c0e6c`
+
+Important parity exclusions:
+
+- JS `undefined`-dependent expectations
+- non-finite numbers (`Infinity`, `-Infinity`)
+- lone-surrogate code-unit expectations
+
+Additional EOF recovery contract:
+
+- incomplete/truncated but structurally recoverable inputs are accepted by the
+  lenient parser (for example: unclosed object/array/string, key-only EOF, and
+  key-colon EOF), while token/syntax violations still surface failures.
+
 ## Local Validation
 
 Run from repository root:

crates/typia/src/lenient_json.rs

@@ -234,11 +234,6 @@ impl<'a> LenientJsonParser<'a> {
 
             self.skip_whitespace();
             if self.pos >= self.chars.len() {
-                self.errors.push(LlmJsonParseError {
-                    path: path.to_owned(),
-                    expected: "':'".to_owned(),
-                    description: "end of input".to_owned(),
-                });
                 self.depth -= 1;
                 return Some(Value::Object(result));
             }
@@ -256,11 +251,6 @@ impl<'a> LenientJsonParser<'a> {
 
             self.skip_whitespace();
             if self.pos >= self.chars.len() {
-                self.errors.push(LlmJsonParseError {
-                    path: format!("{path}.{key}"),
-                    expected: "JSON value".to_owned(),
-                    description: "end of input".to_owned(),
-                });
                 self.depth -= 1;
                 return Some(Value::Object(result));
             }
@@ -275,11 +265,6 @@ impl<'a> LenientJsonParser<'a> {
             }
         }
 
-        self.errors.push(LlmJsonParseError {
-            path: path.to_owned(),
-            expected: "'}'".to_owned(),
-            description: "end of input".to_owned(),
-        });
         self.depth -= 1;
         Some(Value::Object(result))
     }
@@ -332,16 +317,11 @@ impl<'a> LenientJsonParser<'a> {
             }
         }
 
-        self.errors.push(LlmJsonParseError {
-            path: path.to_owned(),
-            expected: "']'".to_owned(),
-            description: "end of input".to_owned(),
-        });
         self.depth -= 1;
         Some(Value::Array(result))
     }
 
-    fn parse_string(&mut self, path: &str) -> String {
+    fn parse_string(&mut self, _path: &str) -> String {
         self.pos += 1;
         let mut result = String::new();
         let mut escaped = false;
@@ -417,11 +397,6 @@ impl<'a> LenientJsonParser<'a> {
             self.pos += 1;
         }
 
-        self.errors.push(LlmJsonParseError {
-            path: path.to_owned(),
-            expected: "closing quote".to_owned(),
-            description: "end of input".to_owned(),
-        });
         result
     }
 

crates/typia/tests/llm_data_runtime.rs

@@ -125,19 +125,20 @@ fn parse_unicode_surrogate_pair() {
 }
 
 #[test]
-fn parse_incomplete_json_reports_failure_with_partial_data() {
+fn parse_incomplete_json_recovers_to_success() {
     let result = User::parse(r#"{"id":1,"name":"alice""#);
 
     match result {
-        LlmJsonParseResult::Failure { data, errors, .. } => {
-            assert!(data.is_some(), "expected partial data");
-            assert!(!errors.is_empty(), "expected parser errors");
-            assert!(
-                errors.iter().any(|error| error.expected.contains("'}'")),
-                "expected missing object terminator error"
+        LlmJsonParseResult::Success { data } => {
+            assert_eq!(
+                data,
+                User {
+                    id: 1,
+                    name: "alice".to_owned(),
+                }
             );
         }
-        other => panic!("expected failure, got {other:?}"),
+        other => panic!("expected success, got {other:?}"),
     }
 }
 
@@ -213,3 +214,45 @@ fn validate_and_stringify_use_serde() {
     let encoded = validated.stringify().expect("stringify should succeed");
     assert_eq!(encoded, r#"{"id":42,"name":"eve"}"#);
 }
+
+#[test]
+fn validate_reports_missing_required_field() {
+    let value = typia::serde_json::json!({
+        "id": 7
+    });
+
+    let error = User::validate(value).expect_err("validation should fail");
+    assert!(
+        error.to_string().contains("missing field"),
+        "expected missing field error"
+    );
+}
+
+#[test]
+fn validate_reports_type_mismatch() {
+    let value = typia::serde_json::json!({
+        "id": "not-a-number",
+        "name": "eve"
+    });
+
+    let error = User::validate(value).expect_err("validation should fail");
+    assert!(
+        error.to_string().contains("invalid type"),
+        "expected invalid type error"
+    );
+}
+
+#[test]
+fn stringify_roundtrip_through_validate() {
+    let user = User {
+        id: 9,
+        name: "frank".to_owned(),
+    };
+
+    let encoded = user.stringify().expect("stringify should succeed");
+    let decoded: typia::serde_json::Value =
+        typia::serde_json::from_str(&encoded).expect("must be valid JSON");
+
+    let validated = User::validate(decoded).expect("validation should succeed");
+    assert_eq!(validated, user);
+}