docs: update README and CHANGELOG with all fork improvements

README.md:
- Update AnyOf section: now generates untagged enums (not broken
  flattened structs)
- Add If/Then/Else section
- Add Not schema section
- Add JSON Schema 2020-12 Support section with keyword mapping table
- Add External References section with API examples
- Remove "Bounded numbers" from WIP (now fixed)

CHANGELOG.adoc:
- Add comprehensive unreleased section covering all 19 issues fixed
- Document all new features: 2020-12 support, external refs,
  if/then/else, new APIs

Author: ndreno

CHANGELOG.adoc

@@ -11,9 +11,30 @@
 
 // cargo-release: next header goes here (do not change this line)
 
-== Unreleased changes (release date TBD)
-
-https://github.com/oxidecomputer/typify/compare/v0.6.1\...HEAD[Full list of commits]
+== Unreleased changes (barbacane-dev fork)
+
+=== Bug fixes
+* fix untagged enum variant ordering: Integer now comes before Number to prevent unreachable deserialization (#991)
+* generate `Default` impl for structs where all required fields have explicit defaults (#918)
+* generate `TryFrom` instead of `From` for bounded integer newtypes, enforcing min/max constraints (#986)
+* render integer `minimum`/`maximum` as integers (not floats) in doc comments (#843)
+* handle special characters in enum variant names (`=`, `>`, `≥`, etc.) without panicking (#948)
+* replace broken `anyOf` flattened struct with proper untagged enum generation (#414, #895, #710, #790)
+* replace `patternProperties` and `propertyNames` assertion panics with best-effort behavior (#882)
+* select smallest integer type for bounded ranges (e.g., `[1..32]` → `NonZeroU8`) (#975)
+* replace panics in `not` schema handling with graceful fallback to `serde_json::Value` (#954, #489, #435)
+* replace panics in `ref_key()` and `convert_reference()` with proper error returns
+
+=== New features
+* JSON Schema `if`/`then`/`else` support via transformation to `oneOf` (#480)
+* JSON Schema 2020-12 and 2019-09 support via automatic normalization (#579)
+** `$defs`, `prefixItems`, `dependentRequired`, `dependentSchemas`, `unevaluatedProperties`, `$dynamicRef`
+* external `$ref` support: reference schemas in other files (#201, #933)
+* non-`$defs` internal `$ref` support: reference any JSON Pointer path (#828)
+* new API: `TypeSpace::add_schema_from_value()` — auto-detects and normalizes any JSON Schema draft
+* new API: `TypeSpace::add_schema_with_externals()` — handles multi-file schema bundles
+
+https://github.com/barbacane-dev/typify/compare/v0.6.1\...HEAD[Full list of commits]
 
 == 0.6.1 (released 2026-02-10)
 

README.md

@@ -93,12 +93,11 @@ this generation is an area of active work.
 
 ### AnyOf
 
-The `anyOf` construct is much trickier. If can be close to an `enum` (`oneOf`),
-but where no particular variant might be canonical or unique for particular
-data. While today we (imprecisely) model these as structs with optional,
-flattened members, this is one of the weaker areas of code generation.
-
-Issues describing example schemas and desired output are welcome and helpful.
+The `anyOf` construct maps to a Rust `#[serde(untagged)]` enum, similar to
+`oneOf`. Typify runs the same enum detection pipeline (external, internal,
+adjacent, untagged tagging) for `anyOf` schemas. This correctly handles
+`anyOf` with primitive types (strings, integers), mixed object/primitive
+schemas, and overlapping object properties.
 
 ### AdditionalProperties
 
@@ -123,6 +122,57 @@ named properties **and** a flattened map of additional properties by using a
 value for `additionalProperties` that is equivalent to `true` or absent with
 regard to validation, by using some e.g. `{}`.
 
+### If / Then / Else
+
+JSON Schema's `if`/`then`/`else` construct is transformed into a `oneOf`:
+the `then` branch becomes `allOf(if, then)` and the `else` branch becomes
+`allOf(not(if), else)`. The result is a Rust enum with variants for each
+branch.
+
+### Not
+
+The `not` construct is supported for schemas with enumerated values (creating
+a "deny list" newtype that rejects those values). For more complex `not`
+schemas (e.g., `not: { type: "object" }`), typify falls back to
+`serde_json::Value`.
+
+### JSON Schema 2020-12 Support
+
+Typify supports JSON Schema 2020-12 (and 2019-09) via automatic
+normalization. When a schema declares `"$schema":
+"https://json-schema.org/draft/2020-12/schema"`, the following keywords are
+transparently converted to their draft-07 equivalents before processing:
+
+| 2020-12 keyword | Transformed to |
+|-----------------|---------------|
+| `$defs` | `definitions` |
+| `prefixItems` + `items` | `items` (array) + `additionalItems` |
+| `$ref` alongside other keywords | `allOf` wrapping |
+| `dependentRequired` | `dependencies` (array form) |
+| `dependentSchemas` | `dependencies` (schema form) |
+| `unevaluatedProperties` | `additionalProperties` (best-effort) |
+| `$dynamicRef` | `$ref` (best-effort) |
+
+Use `add_schema_from_value()` instead of `add_root_schema()` to enable
+auto-detection and normalization.
+
+### External References
+
+Typify supports `$ref` pointing to external files (e.g.,
+`"$ref": "other-file.json#/definitions/Foo"`). External schemas are bundled
+into the root schema's definitions before processing.
+
+Use `add_schema_with_externals()` to provide a map of external schemas:
+
+```rust
+let mut externals = BTreeMap::new();
+externals.insert("types.json".to_string(), types_json_value);
+type_space.add_schema_with_externals(main_schema_value, externals)?;
+```
+
+Non-standard internal references (e.g., `$ref: "#/properties/foo"`) are also
+automatically resolved.
+
 ## Rust -> Schema -> Rust
 
 Schemas derived from Rust types may include an extension that provides
@@ -337,20 +387,6 @@ JSON schema can express a wide variety of types. Some of them are easy to model
 in Rust; others aren't. There's a lot of work to be done to handle esoteric
 types. Examples from users are very helpful in this regard.
 
-### Bounded numbers
-
-Bounded numbers aren't very well handled. Consider, for example, the schema:
-
-```json
-{
-  "type": "integer",
-  "minimum": 1,
-  "maximum": 6
-}
-```
-
-The resulting types won't enforce those value constraints.
-
 ### Configurable dependencies
 
 A string schema with `format` set to `uuid` will result in the `uuid::Uuid`