pivot to strict rfc

Author: simbo1905

.github/workflows/ci.yml

@@ -39,7 +39,7 @@ jobs:
                       for k in totals: totals[k]+=int(r.get(k,'0'))
                   except Exception:
                       pass
-          exp_tests=466
+          exp_tests=468
           exp_skipped=0
           if totals['tests']!=exp_tests or totals['skipped']!=exp_skipped:
               print(f"Unexpected test totals: {totals} != expected tests={exp_tests}, skipped={exp_skipped}")

AGENTS.md

@@ -222,11 +222,21 @@ The property test logs at FINEST level:
 ### Issue Management
 - Use the native tooling for the remote (for example `gh` for GitHub).
 - Create issues in the repository tied to the `origin` remote unless instructed otherwise; if another remote is required, ask for its name.
-- Tickets and issues must state only “what” and “why,” leaving “how” for later discussion.
+- Tickets and issues must state only "what" and "why," leaving "how" for later discussion.
 - Comments may discuss implementation details.
 - Label tickets as `Ready` once actionable; if a ticket lacks that label, request confirmation before proceeding.
 - Limit tidy-up issues to an absolute minimum (no more than two per PR).
 
+### Creating GitHub Issues
+- **Title requirements**: No issue numbers, no special characters, no quotes, no shell metacharacters
+- **Body requirements**: Write issue body to a file first, then use --body-file flag
+- **Example workflow**:
+  ```bash
+  echo "Issue description here" > /tmp/issue_body.md
+  gh issue create --title "Brief description of bug" --body-file /tmp/issue_body.md
+  ```
+- **Never use --body flag** with complex content - always use --body-file to avoid shell escaping issues
+
 ### Commit Requirements
 - Commit messages start with `Issue #<issue number> <short description>`.
 - Include a link to the referenced issue when possible.

json-java21-jtd/src/main/java/json/java21/jtd/Jtd.java

@@ -18,6 +18,9 @@ public class Jtd {
   /// Top-level definitions map for ref resolution
   private final Map<String, JtdSchema> definitions = new java.util.HashMap<>();
 
+  /// Raw definition values for context-aware ref resolution
+  private final Map<String, JsonValue> rawDefinitions = new java.util.HashMap<>();
+  
   /// Stack frame for iterative validation with path and offset tracking
   record Frame(JtdSchema schema, JsonValue instance, String ptr, Crumbs crumbs, String discriminatorKey) {
     /// Constructor for normal validation without discriminator context
@@ -282,6 +285,11 @@ void pushChildFrames(Frame frame, java.util.Deque<Frame> stack) {
 
   /// Compiles a JsonValue into a JtdSchema based on RFC 8927 rules
   JtdSchema compileSchema(JsonValue schema) {
+    return compileSchema(schema, false); // Default: not from ref resolution
+  }
+  
+  /// Compiles a JsonValue into a JtdSchema with context-aware handling of {}
+  JtdSchema compileSchema(JsonValue schema, boolean fromRef) {
     if (!(schema instanceof JsonObject obj)) {
       throw new IllegalArgumentException("Schema must be an object");
     }
@@ -299,17 +307,20 @@ JtdSchema compileSchema(JsonValue schema) {
       JsonObject defsObj = (JsonObject) obj.members().get("definitions");
       for (String key : defsObj.members().keySet()) {
         if (definitions.get(key) == null) {
-          JtdSchema compiled = compileSchema(defsObj.members().get(key));
+          JsonValue rawDef = defsObj.members().get(key);
+          rawDefinitions.put(key, rawDef); // Store raw definition for context-aware ref resolution
+          // Compile definitions with fromRef=true for compatibility mode
+          JtdSchema compiled = compileSchema(rawDef, true);
           definitions.put(key, compiled);
         }
       }
     }
 
-    return compileObjectSchema(obj);
+    return compileObjectSchema(obj, fromRef);
   }
 
-  /// Compiles an object schema according to RFC 8927
-  JtdSchema compileObjectSchema(JsonObject obj) {
+  /// Compiles an object schema according to RFC 8927 with context-aware handling
+  JtdSchema compileObjectSchema(JsonObject obj, boolean fromRef) {
     // Check for mutually-exclusive schema forms
     List<String> forms = new ArrayList<>();
     Map<String, JsonValue> members = obj.members();
@@ -336,8 +347,17 @@ JtdSchema compileObjectSchema(JsonObject obj) {
     // Parse the specific schema form
     JtdSchema schema;
 
-    if (forms.isEmpty()) {
-      // Empty schema - accepts any value
+    // Context-aware handling of {} - RFC vs compatibility mode
+    if (forms.isEmpty() && obj.members().isEmpty()) {
+      if (fromRef) {
+        // Compatibility mode: {} from ref resolution behaves as EmptySchema (accept anything)
+        schema = new JtdSchema.EmptySchema();
+      } else {
+        // RFC mode: {} at root or direct context behaves as PropertiesSchema (no properties allowed)
+        schema = new JtdSchema.PropertiesSchema(Map.of(), Map.of(), false);
+      }
+    } else if (forms.isEmpty()) {
+      // Empty schema with no explicit form - default to EmptySchema for backwards compatibility
       schema = new JtdSchema.EmptySchema();
     } else {
       String form = forms.getFirst();
@@ -483,6 +503,11 @@ JtdSchema compileDiscriminatorSchema(JsonObject obj) {
     return new JtdSchema.DiscriminatorSchema(discStr.value(), mapping);
   }
 
+  /// Gets raw definition value for context-aware ref resolution
+  JsonValue getRawDefinition(String ref) {
+    return rawDefinitions.get(ref);
+  }
+  
   /// Extracts and stores top-level definitions for ref resolution
   private Map<String, JtdSchema> parsePropertySchemas(JsonObject propsObj) {
     Map<String, JtdSchema> schemas = new java.util.HashMap<>();

json-java21-jtd/src/test/java/json/java21/jtd/TestRfc8927.java

@@ -640,4 +640,67 @@ public void testNestedElementsPropertiesRejectsAdditionalProperties() throws Exc
       .as("Should have validation errors for additional property")
       .isNotEmpty();
   }
+
+  /// Test case for Issue #98: Empty properties schema should reject additional properties
+  /// Schema: {} (empty object with no properties defined)
+  /// Document: {"extraProperty":"extra-value"} (object with extra property)
+  /// Expected: Invalid (additionalProperties defaults to false when no properties defined)
+  /// Actual: Currently valid (bug - incorrectly treated as EmptySchema)
+  @Test
+  public void testEmptyPropertiesSchemaRejectsAdditionalProperties() throws Exception {
+    JsonValue schema = Json.parse("{}");
+    JsonValue document = Json.parse("{\"extraProperty\":\"extra-value\"}");
+    
+    LOG.info(() -> "Testing empty properties schema - should reject additional properties");
+    LOG.fine(() -> "Schema: " + schema);
+    LOG.fine(() -> "Document: " + document);
+    
+    Jtd validator = new Jtd();
+    Jtd.Result result = validator.validate(schema, document);
+    
+    LOG.fine(() -> "Validation result: " + (result.isValid() ? "VALID" : "INVALID"));
+    if (!result.isValid()) {
+      LOG.fine(() -> "Errors: " + result.errors());
+    }
+    
+    // This should fail because {} means no properties are allowed
+    // and additionalProperties defaults to false per RFC 8927
+    assertThat(result.isValid())
+      .as("Empty properties schema should reject additional properties")
+      .isFalse();
+    assertThat(result.errors())
+      .as("Should have validation errors for additional property")
+      .isNotEmpty();
+  }
+
+  /// Test case for Issue #98: {} ambiguity between RFC and ref resolution
+  /// Tests that {} behaves correctly in different contexts:
+  /// 1. Root {} -> PropertiesSchema (no properties allowed) per RFC 8927
+  /// 2. {} from ref resolution -> EmptySchema (accept anything) for compatibility
+  @Test
+  public void testEmptySchemaContextSensitiveBehavior() throws Exception {
+    // Case 1: RFC root {} -> PropertiesSchema (no props allowed)
+    JsonValue schema1 = Json.parse("{}");
+    JsonValue doc1 = Json.parse("{\"extra\":\"x\"}");
+    Jtd.Result result1 = new Jtd().validate(schema1, doc1);
+    assertThat(result1.isValid())
+      .as("Root {} should reject additional properties per RFC 8927")
+      .isFalse();
+
+    // Case 2: {} from ref -> EmptySchema (accept anything)
+    JsonValue schema2 = Json.parse("""
+      {
+        "definitions": {
+          "foo": { "ref": "bar" },
+          "bar": {}
+        },
+        "ref": "foo"
+      }
+      """);
+    JsonValue doc2 = Json.parse("true");
+    Jtd.Result result2 = new Jtd().validate(schema2, doc2);
+    assertThat(result2.isValid())
+      .as("{} resolved from $ref should accept anything (compatibility mode)")
+      .isTrue();
+  }
 }