feat(json): keep extra top-level keys instead of dropping them

render() only emitted the known TOP_LEVEL_KEYS, so a future document with an
additional top-level field would silently lose it. Append any extra keys after
the fixed ordering (metadata first), preserving detect_file_type behavior.
Add tests for the extra-key guard and the manual --language override.

Author: vee1e

floss/render/json.py

@@ -59,7 +59,16 @@ def sort_nested(obj):
 TOP_LEVEL_KEYS = ("metadata", "analysis", "strings", "layout")
 
 
-def render(doc: ResultDocument) -> str:
-    data = dataclasses.asdict(doc)
-    top = {key: sort_nested(data[key]) for key in TOP_LEVEL_KEYS if key in data}
+def _render_dict(data: dict) -> str:
+    """serialize a results-document dict with fixed top-level ordering."""
+    # keep the fixed top-level ordering (metadata first so the document stays
+    # detectable from its leading bytes), then append any future/extra keys so
+    # they are never silently dropped
+    extra_keys = [key for key in data if key not in TOP_LEVEL_KEYS]
+    ordered_keys = list(TOP_LEVEL_KEYS) + extra_keys
+    top = {key: sort_nested(data[key]) for key in ordered_keys if key in data}
     return json.dumps(top, cls=FlossJSONEncoder, sort_keys=False)
+
+
+def render(doc: ResultDocument) -> str:
+    return _render_dict(dataclasses.asdict(doc))

tests/test_cli_args.py

@@ -113,6 +113,36 @@ def test_language_extraction_independent_of_static():
     assert len(results.strings.static_strings) == 0
 
 
+def test_manual_language_override_wins_over_auto_detect():
+    """--language go must be honored even when auto-detection returns unknown."""
+    from pathlib import Path
+
+    from floss.results import Analysis
+    from floss.pipeline import Options, analyze
+
+    # a C binary, so auto-detection yields unknown; forcing go must stick
+    sample = Path(__file__).parent / "data" / "src" / "decode-in-place" / "bin" / "test-decode-in-place.exe"
+
+    results = analyze(
+        Options(
+            sample=sample,
+            min_length=4,
+            language="go",
+            analysis=Analysis(
+                enable_static_strings=False,
+                enable_stack_strings=False,
+                enable_tight_strings=False,
+                enable_decoded_strings=False,
+                enable_language_strings=True,
+            ),
+            prompt_deobfuscation=False,
+        )
+    )
+    assert results is not None
+    assert results.metadata.language == "go"
+    assert results.metadata.language_selected == "go"
+
+
 def test_expand_string_types():
     from floss.utils import expand_string_types
 

tests/test_results_json_roundtrip.py

@@ -16,6 +16,7 @@
 
 import json
 import tempfile
+import dataclasses
 from pathlib import Path
 
 import floss.utils
@@ -154,3 +155,25 @@ def test_rendered_document_is_detectable(tmp_path):
     p.write_text(floss.render.json.render(doc))
 
     assert floss.utils.detect_file_type(p) is floss.utils.FileType.RESULTS
+
+
+def test_json_render_keeps_extra_top_level_keys():
+    """future/extra top-level fields must not be silently dropped."""
+    from floss.render import json as render_json
+
+    doc = ResultDocument(
+        metadata=Metadata(file_path="sample.exe", min_length=4),
+        analysis=Analysis(),
+        strings=Strings(),
+        layout=None,
+    )
+    data = dataclasses.asdict(doc)
+    # simulate a future document gaining an extra top-level field
+    data["future_field"] = {"a": 1}
+
+    raw = render_json._render_dict(data)
+    obj = json.loads(raw)
+    assert obj["future_field"] == {"a": 1}
+    # ordering preserved: metadata first, extras appended after known keys
+    assert list(obj.keys())[0] == "metadata"
+    assert list(obj.keys())[-1] == "future_field"