hecks 2.8.0 → 3.0.0

data/rust/parser/src/emit.rs

@@ -0,0 +1,953 @@
+//! JSON writer matching `JSON.pretty_generate(Exporter.call(...))` byte-for-byte for json 2.7.2.
+//! Walks `ir::Bluebook` in Ruby's `to_h` key order into a `JsonValue` tree for `write`.
+
+use std::fmt::Write as _;
+
+use crate::ir;
+use crate::ruby_value;
+
+/// A minimal hand-rolled JSON value (no serde: the crate is std-only).
+#[derive(Debug, Clone)]
+pub enum JsonValue {
+    Null,
+    Bool(bool),
+    Number(String),
+    String(String),
+    Array(Vec<JsonValue>),
+    Object(Vec<(String, JsonValue)>),
+}
+
+impl JsonValue {
+    fn str(s: impl Into<String>) -> JsonValue {
+        JsonValue::String(s.into())
+    }
+
+    fn opt_str(s: &Option<String>) -> JsonValue {
+        match s {
+            Some(text) => JsonValue::String(text.clone()),
+            None => JsonValue::Null,
+        }
+    }
+
+    fn strings(items: &[String]) -> JsonValue {
+        JsonValue::Array(items.iter().map(|s| JsonValue::String(s.clone())).collect())
+    }
+}
+
+pub fn write(value: &JsonValue) -> String {
+    let mut out = String::new();
+    write_value(&mut out, value, 0);
+    out
+}
+
+/// The pinned `Expression::CanonicalForm.table` rules from projection.json, in Ruby's field
+/// order; `position` is a string.
+fn canonical_form_table() -> JsonValue {
+    JsonValue::Array(vec![
+        JsonValue::Object(vec![
+            (
+                "strategy".to_string(),
+                JsonValue::str("collapse_whitespace"),
+            ),
+            ("source_token".to_string(), JsonValue::str("")),
+            ("replacement".to_string(), JsonValue::str("")),
+            ("boundary".to_string(), JsonValue::str("none")),
+            ("position".to_string(), JsonValue::str("1")),
+        ]),
+        JsonValue::Object(vec![
+            ("strategy".to_string(), JsonValue::str("replace")),
+            ("source_token".to_string(), JsonValue::str(".length")),
+            ("replacement".to_string(), JsonValue::str(".size")),
+            ("boundary".to_string(), JsonValue::str("word")),
+            ("position".to_string(), JsonValue::str("2")),
+        ]),
+    ])
+}
+
+/// `IR::Bluebook#to_h`; field order is pinned there.
+pub fn bluebook_json(bb: &ir::Bluebook) -> JsonValue {
+    JsonValue::Object(vec![
+        (
+            "ir_version".to_string(),
+            JsonValue::Number(bb.ir_version.to_string()),
+        ),
+        ("name".to_string(), JsonValue::str(bb.name.clone())),
+        ("version".to_string(), JsonValue::opt_str(&bb.version)),
+        ("vision".to_string(), JsonValue::opt_str(&bb.vision)),
+        (
+            "classification".to_string(),
+            JsonValue::opt_str(&bb.classification),
+        ),
+        (
+            "formerly_known_as".to_string(),
+            JsonValue::opt_str(&bb.formerly_known_as),
+        ),
+        ("namespace".to_string(), JsonValue::opt_str(&bb.namespace)),
+        (
+            "aggregates".to_string(),
+            JsonValue::Array(bb.aggregates.iter().map(aggregate_json).collect()),
+        ),
+        (
+            "read_models".to_string(),
+            JsonValue::Array(bb.read_models.iter().map(read_model_json).collect()),
+        ),
+        (
+            "policies".to_string(),
+            JsonValue::Array(bb.policies.iter().map(policy_json).collect()),
+        ),
+        (
+            "process_managers".to_string(),
+            JsonValue::Array(
+                bb.process_managers
+                    .iter()
+                    .map(process_manager_json)
+                    .collect(),
+            ),
+        ),
+        (
+            "attaches_to".to_string(),
+            JsonValue::strings(&bb.attaches_to),
+        ),
+        (
+            "provides".to_string(),
+            JsonValue::Array(
+                bb.provides
+                    .iter()
+                    .map(|row| {
+                        JsonValue::Object(vec![
+                            (
+                                "capability".to_string(),
+                                JsonValue::str(row.capability.clone()),
+                            ),
+                            ("key".to_string(), JsonValue::str(row.key.clone())),
+                            ("verb".to_string(), JsonValue::str(row.verb.clone())),
+                        ])
+                    })
+                    .collect(),
+            ),
+        ),
+        ("canonical_form".to_string(), canonical_form_table()),
+    ])
+}
+
+/// `IR::Aggregate#to_h` (lib/hecks/bluebook/ir/aggregate.rb).
+fn aggregate_json(a: &ir::Aggregate) -> JsonValue {
+    JsonValue::Object(vec![
+        ("name".to_string(), JsonValue::str(a.name.clone())),
+        (
+            "description".to_string(),
+            JsonValue::opt_str(&a.description),
+        ),
+        (
+            "identified_by".to_string(),
+            JsonValue::strings(&a.identified_by),
+        ),
+        (
+            "attributes".to_string(),
+            JsonValue::Array(a.attributes.iter().map(attribute_json).collect()),
+        ),
+        (
+            "value_objects".to_string(),
+            JsonValue::Array(a.value_objects.iter().map(value_object_json).collect()),
+        ),
+        (
+            "commands".to_string(),
+            JsonValue::Array(a.commands.iter().map(command_json).collect()),
+        ),
+        (
+            "invariants".to_string(),
+            JsonValue::Array(a.invariants.iter().map(given_json).collect()),
+        ),
+        (
+            "preconditions".to_string(),
+            JsonValue::Array(a.preconditions.iter().map(given_json).collect()),
+        ),
+        (
+            "projected_fields".to_string(),
+            JsonValue::Array(
+                a.projected_fields
+                    .iter()
+                    .map(projected_field_json)
+                    .collect(),
+            ),
+        ),
+        (
+            "lifecycle".to_string(),
+            a.lifecycle
+                .as_ref()
+                .map(lifecycle_json)
+                .unwrap_or(JsonValue::Null),
+        ),
+        (
+            "entities".to_string(),
+            JsonValue::Array(a.entities.iter().map(entity_json).collect()),
+        ),
+        (
+            "queries".to_string(),
+            JsonValue::Array(a.queries.iter().map(query_json).collect()),
+        ),
+        (
+            "ports".to_string(),
+            JsonValue::Array(a.ports.iter().map(domain_port_json).collect()),
+        ),
+        (
+            "provenance".to_string(),
+            a.provenance
+                .as_ref()
+                .map(ruby_value_json)
+                .unwrap_or(JsonValue::Null),
+        ),
+    ])
+}
+
+/// `IR::Attribute#to_h` (lib/hecks/bluebook/ir/attribute.rb).
+fn attribute_json(a: &ir::Attribute) -> JsonValue {
+    JsonValue::Object(vec![
+        ("name".to_string(), JsonValue::str(a.name.clone())),
+        ("type".to_string(), JsonValue::str(a.type_name.clone())),
+        ("list".to_string(), JsonValue::Bool(a.list)),
+        (
+            "default".to_string(),
+            a.default
+                .as_ref()
+                .map(ruby_value_json)
+                .unwrap_or(JsonValue::Null),
+        ),
+        ("optional".to_string(), JsonValue::Bool(a.optional)),
+        ("pattern".to_string(), JsonValue::opt_str(&a.pattern)),
+        ("admits".to_string(), JsonValue::opt_str(&a.admits)),
+        (
+            "relationship".to_string(),
+            JsonValue::opt_str(&a.relationship),
+        ),
+    ])
+}
+
+/// `IR::ValueObject#to_h` (lib/hecks/bluebook/ir/value_object.rb).
+fn value_object_json(v: &ir::ValueObject) -> JsonValue {
+    JsonValue::Object(vec![
+        ("name".to_string(), JsonValue::str(v.name.clone())),
+        (
+            "attributes".to_string(),
+            JsonValue::Array(v.attributes.iter().map(attribute_json).collect()),
+        ),
+        (
+            "invariants".to_string(),
+            JsonValue::Array(v.invariants.iter().map(given_json).collect()),
+        ),
+        ("closed_set".to_string(), JsonValue::Bool(v.closed_set)),
+        (
+            "members".to_string(),
+            JsonValue::Array(
+                v.members
+                    .iter()
+                    .map(|member| {
+                        JsonValue::Array(
+                            member
+                                .iter()
+                                .map(|(field, value)| {
+                                    JsonValue::Array(vec![
+                                        JsonValue::str(field.clone()),
+                                        ruby_value_json(value),
+                                    ])
+                                })
+                                .collect(),
+                        )
+                    })
+                    .collect(),
+            ),
+        ),
+    ])
+}
+
+/// `{description:, canonical:}`, shared by `givens:`, `ensures:` and `invariants:`.
+fn given_json(g: &ir::Given) -> JsonValue {
+    JsonValue::Object(vec![
+        (
+            "description".to_string(),
+            JsonValue::opt_str(&g.description),
+        ),
+        ("canonical".to_string(), JsonValue::str(g.canonical.clone())),
+        // The structured form of the same text, as `AstJson.rule_row` emits beside `canonical`.
+        ("ast".to_string(), crate::expr::ast_json::emit_predicate(&g.canonical)),
+    ])
+}
+
+/// `IR::Aggregate#to_h`'s `projected_fields:` entry: `{name:, reference:, remote_field:}`.
+fn projected_field_json(f: &ir::ProjectedField) -> JsonValue {
+    JsonValue::Object(vec![
+        ("name".to_string(), JsonValue::str(f.name.clone())),
+        ("reference".to_string(), JsonValue::str(f.reference.clone())),
+        (
+            "remote_field".to_string(),
+            JsonValue::str(f.remote_field.clone()),
+        ),
+    ])
+}
+
+/// `IR::Command#to_h` (lib/hecks/bluebook/ir/command.rb).
+fn command_json(c: &ir::Command) -> JsonValue {
+    JsonValue::Object(vec![
+        ("name".to_string(), JsonValue::str(c.name.clone())),
+        ("role".to_string(), JsonValue::opt_str(&c.role)),
+        ("goal".to_string(), JsonValue::opt_str(&c.goal)),
+        ("references".to_string(), JsonValue::opt_str(&c.references)),
+        (
+            "attributes".to_string(),
+            JsonValue::Array(c.attributes.iter().map(attribute_json).collect()),
+        ),
+        (
+            "givens".to_string(),
+            JsonValue::Array(c.givens.iter().map(given_json).collect()),
+        ),
+        (
+            "ensures".to_string(),
+            JsonValue::Array(c.ensures.iter().map(given_json).collect()),
+        ),
+        (
+            "mutations".to_string(),
+            JsonValue::Array(c.mutations.iter().map(mutation_json).collect()),
+        ),
+        ("emits".to_string(), JsonValue::strings(&c.emits)),
+        ("from".to_string(), command_from_json(&c.from)),
+        (
+            "provenance".to_string(),
+            c.provenance
+                .as_ref()
+                .map(ruby_value_json)
+                .unwrap_or(JsonValue::Null),
+        ),
+    ])
+}
+
+/// `ir::CommandFrom`: a bare JSON string for one state, an array for several, `null` for none.
+fn command_from_json(from: &Option<ir::CommandFrom>) -> JsonValue {
+    match from {
+        None => JsonValue::Null,
+        Some(ir::CommandFrom::Single(state)) => JsonValue::str(state.clone()),
+        Some(ir::CommandFrom::Multiple(states)) => JsonValue::strings(states),
+    }
+}
+
+/// `IR::Mutation#to_h` (lib/hecks/bluebook/ir/command.rb).
+fn mutation_json(m: &ir::Mutation) -> JsonValue {
+    match m {
+        // Ruby's `Mutation#to_h` emits `sign: ""` for append too; key order is significant.
+        ir::Mutation::Append { target, fields } => JsonValue::Object(vec![
+            ("target".to_string(), JsonValue::str(target.clone())),
+            ("op".to_string(), JsonValue::str("append")),
+            ("sign".to_string(), JsonValue::str("")),
+            (
+                "fields".to_string(),
+                JsonValue::Object(
+                    fields
+                        .iter()
+                        .map(|(k, v)| (k.clone(), JsonValue::str(v.clone())))
+                        .collect(),
+                ),
+            ),
+        ]),
+        // Same shape as Append (sign ""), but the target is a dotted "Entity.Command" string.
+        ir::Mutation::Delegate { target, fields } => JsonValue::Object(vec![
+            ("target".to_string(), JsonValue::str(target.clone())),
+            ("op".to_string(), JsonValue::str("delegate")),
+            ("sign".to_string(), JsonValue::str("")),
+            (
+                "fields".to_string(),
+                JsonValue::Object(
+                    fields
+                        .iter()
+                        .map(|(k, v)| (k.clone(), JsonValue::str(v.clone())))
+                        .collect(),
+                ),
+            ),
+        ]),
+        // Same shape as Append, with sign always "".
+        ir::Mutation::Correction { target, fields } => JsonValue::Object(vec![
+            ("target".to_string(), JsonValue::str(target.clone())),
+            ("op".to_string(), JsonValue::str("corrects")),
+            ("sign".to_string(), JsonValue::str("")),
+            (
+                "fields".to_string(),
+                JsonValue::Object(
+                    fields
+                        .iter()
+                        .map(|(k, v)| (k.clone(), JsonValue::str(v.clone())))
+                        .collect(),
+                ),
+            ),
+        ]),
+        ir::Mutation::Other {
+            target,
+            op,
+            sign,
+            source,
+        } => JsonValue::Object(vec![
+            ("target".to_string(), JsonValue::str(target.clone())),
+            ("op".to_string(), JsonValue::str(op.clone())),
+            ("sign".to_string(), JsonValue::str(sign.clone())),
+            ("source".to_string(), mutation_source_json(source)),
+        ]),
+    }
+}
+
+fn mutation_source_json(source: &Option<ir::MutationSource>) -> JsonValue {
+    match source {
+        Some(ir::MutationSource::Argument(name)) => JsonValue::Object(vec![
+            ("kind".to_string(), JsonValue::str("argument")),
+            ("name".to_string(), JsonValue::str(name.clone())),
+        ]),
+        Some(ir::MutationSource::Literal(value)) => JsonValue::Object(vec![
+            ("kind".to_string(), JsonValue::str("literal")),
+            ("value".to_string(), ruby_value_json(value)),
+        ]),
+        Some(ir::MutationSource::State(name)) => JsonValue::Object(vec![
+            ("kind".to_string(), JsonValue::str("state")),
+            ("name".to_string(), JsonValue::str(name.clone())),
+        ]),
+        None => JsonValue::Null,
+    }
+}
+
+/// `IR::Lifecycle#to_h`; `transitions:` arrives already expanded, one row per `from_state`.
+fn lifecycle_json(l: &ir::Lifecycle) -> JsonValue {
+    JsonValue::Object(vec![
+        ("field".to_string(), JsonValue::str(l.field.clone())),
+        ("default".to_string(), JsonValue::str(l.default.clone())),
+        (
+            "transitions".to_string(),
+            JsonValue::Array(
+                l.transitions
+                    .iter()
+                    .map(|t| {
+                        JsonValue::Object(vec![
+                            ("command".to_string(), JsonValue::str(t.command.clone())),
+                            ("to_state".to_string(), JsonValue::str(t.to_state.clone())),
+                            ("from_state".to_string(), JsonValue::opt_str(&t.from_state)),
+                        ])
+                    })
+                    .collect(),
+            ),
+        ),
+    ])
+}
+
+/// `IR::Query#to_h` merged with `query_options_json`, which appends only the declared
+/// options in Ruby's fixed order.
+fn query_json(q: &ir::Query) -> JsonValue {
+    let mut pairs = vec![
+        ("name".to_string(), JsonValue::str(q.name.clone())),
+        (
+            "description".to_string(),
+            JsonValue::opt_str(&q.description),
+        ),
+        (
+            "attributes".to_string(),
+            JsonValue::Array(q.attributes.iter().map(attribute_json).collect()),
+        ),
+        (
+            "wheres".to_string(),
+            JsonValue::Array(q.wheres.iter().map(where_clause_json).collect()),
+        ),
+        ("order_by".to_string(), order_by_json(&q.order_by)),
+        ("limit".to_string(), limit_json(&q.limit)),
+    ];
+    pairs.extend(query_options_json(&q.options));
+    // `returns` follows the options, only when declared (`Query#to_h`).
+    if let Some(returns) = &q.returns {
+        pairs.push(("returns".to_string(), JsonValue::str(returns.clone())));
+    }
+    JsonValue::Object(pairs)
+}
+
+// `target:` is appended only when set (`WhereClause#to_h`'s own "absent, not null" convention,
+// ADR 0055) so every existing golden IR fixture for a construct that never declares `on:` stays
+// byte-identical.
+fn where_clause_json(w: &ir::WhereClause) -> JsonValue {
+    let mut pairs = vec![
+        ("field".to_string(), JsonValue::str(w.field.clone())),
+        ("op".to_string(), JsonValue::str(w.op.clone())),
+        ("value".to_string(), JsonValue::str(w.value.clone())),
+    ];
+    if let Some(target) = &w.target {
+        pairs.push(("target".to_string(), JsonValue::str(target.clone())));
+    }
+    JsonValue::Object(pairs)
+}
+
+fn order_by_json(order_by: &Option<ir::OrderBy>) -> JsonValue {
+    order_by
+        .as_ref()
+        .map(|o| {
+            let mut pairs = vec![
+                ("field".to_string(), JsonValue::str(o.field.clone())),
+                ("direction".to_string(), JsonValue::str(o.direction.clone())),
+            ];
+            if let Some(target) = &o.target {
+                pairs.push(("target".to_string(), JsonValue::str(target.clone())));
+            }
+            JsonValue::Object(pairs)
+        })
+        .unwrap_or(JsonValue::Null)
+}
+
+fn limit_json(limit: &Option<ir::LimitSpec>) -> JsonValue {
+    limit
+        .as_ref()
+        .map(|l| {
+            let mut pairs = vec![("value".to_string(), JsonValue::str(l.value.clone()))];
+            if let Some(target) = &l.target {
+                pairs.push(("target".to_string(), JsonValue::str(target.clone())));
+            }
+            JsonValue::Object(pairs)
+        })
+        .unwrap_or(JsonValue::Null)
+}
+
+/// `QuerySpecification::Common::Options#extra_options_to_h`, shared by `query_json` and
+/// `read_model_json`: pairs in Ruby's field order, only for the options actually declared.
+fn query_options_json(o: &ir::QueryOptions) -> Vec<(String, JsonValue)> {
+    let mut pairs = Vec::new();
+    if let Some(offset) = &o.offset {
+        let mut offset_pairs = vec![("value".to_string(), JsonValue::str(offset.value.clone()))];
+        if let Some(target) = &offset.target {
+            offset_pairs.push(("target".to_string(), JsonValue::str(target.clone())));
+        }
+        pairs.push(("offset".to_string(), JsonValue::Object(offset_pairs)));
+    }
+    if let Some(value) = &o.cursor {
+        pairs.push((
+            "cursor".to_string(),
+            JsonValue::Object(vec![("value".to_string(), JsonValue::str(value.clone()))]),
+        ));
+    }
+    if let Some(a) = &o.authorization {
+        let mut fields = vec![("policy".to_string(), JsonValue::str(a.policy.clone()))];
+        fields.push((
+            "tenant".to_string(),
+            a.tenant
+                .as_ref()
+                .map(|t| JsonValue::str(t.clone()))
+                .unwrap_or(JsonValue::Null),
+        ));
+        pairs.push(("authorization".to_string(), JsonValue::Object(fields)));
+    }
+    if let Some(mode) = &o.null_semantics {
+        pairs.push((
+            "null_semantics".to_string(),
+            JsonValue::Object(vec![("mode".to_string(), JsonValue::str(mode.clone()))]),
+        ));
+    }
+    if let Some(mode) = &o.inspection {
+        pairs.push((
+            "inspection".to_string(),
+            JsonValue::Object(vec![("mode".to_string(), JsonValue::str(mode.clone()))]),
+        ));
+    }
+    pairs
+}
+
+/// `IR::Entity#to_h` (lib/hecks/bluebook/ir/entity.rb).
+fn entity_json(e: &ir::Entity) -> JsonValue {
+    JsonValue::Object(vec![
+        ("name".to_string(), JsonValue::str(e.name.clone())),
+        (
+            "description".to_string(),
+            JsonValue::opt_str(&e.description),
+        ),
+        (
+            "identified_by".to_string(),
+            JsonValue::strings(&e.identified_by),
+        ),
+        (
+            "attributes".to_string(),
+            JsonValue::Array(e.attributes.iter().map(attribute_json).collect()),
+        ),
+        (
+            "commands".to_string(),
+            JsonValue::Array(e.commands.iter().map(command_json).collect()),
+        ),
+        (
+            "queries".to_string(),
+            JsonValue::Array(e.queries.iter().map(query_json).collect()),
+        ),
+        // Nested entities recurse the same way an aggregate's do.
+        (
+            "entities".to_string(),
+            JsonValue::Array(e.entities.iter().map(entity_json).collect()),
+        ),
+        // Exported for every entity, empty when unused.
+        (
+            "preconditions".to_string(),
+            JsonValue::Array(e.preconditions.iter().map(given_json).collect()),
+        ),
+        // Exported for every entity, empty when unused.
+        (
+            "invariants".to_string(),
+            JsonValue::Array(e.invariants.iter().map(given_json).collect()),
+        ),
+        (
+            "lifecycle".to_string(),
+            e.lifecycle
+                .as_ref()
+                .map(lifecycle_json)
+                .unwrap_or(JsonValue::Null),
+        ),
+    ])
+}
+
+/// `IR::ReadModel#to_h`: `wheres`/`order_by`/`limit`, then `aggregate_heads`/`group_by`,
+/// then `query_options_json`.
+fn read_model_json(r: &ir::ReadModel) -> JsonValue {
+    let mut pairs = vec![
+        ("name".to_string(), JsonValue::str(r.name.clone())),
+        (
+            "description".to_string(),
+            JsonValue::opt_str(&r.description),
+        ),
+        (
+            "reference_name".to_string(),
+            JsonValue::opt_str(&r.reference_name),
+        ),
+        (
+            "reference_target".to_string(),
+            JsonValue::opt_str(&r.reference_target),
+        ),
+        (
+            "query_name".to_string(),
+            JsonValue::str(r.query_name.clone()),
+        ),
+        (
+            "wheres".to_string(),
+            JsonValue::Array(r.wheres.iter().map(where_clause_json).collect()),
+        ),
+        ("order_by".to_string(), order_by_json(&r.order_by)),
+        ("limit".to_string(), limit_json(&r.limit)),
+        (
+            "aggregate_heads".to_string(),
+            JsonValue::Array(
+                r.aggregate_heads
+                    .iter()
+                    .map(|head| {
+                        JsonValue::Object(vec![
+                            (
+                                "aggregate".to_string(),
+                                JsonValue::str(head.aggregate.clone()),
+                            ),
+                            ("as".to_string(), JsonValue::str(head.as_name.clone())),
+                            ("many".to_string(), JsonValue::Bool(head.many)),
+                        ])
+                    })
+                    .collect(),
+            ),
+        ),
+        (
+            "group_by".to_string(),
+            JsonValue::Array(
+                r.group_by
+                    .iter()
+                    .map(|field| {
+                        JsonValue::Object(vec![(
+                            "field".to_string(),
+                            JsonValue::str(field.clone()),
+                        )])
+                    })
+                    .collect(),
+            ),
+        ),
+    ];
+    // Every reduction is pushed only when set, never as a `null` key (ADR 0078).
+    if r.count {
+        pairs.push(("count".to_string(), JsonValue::Bool(true)));
+    }
+    if let Some(field) = &r.median_field {
+        pairs.push(("median_field".to_string(), JsonValue::str(field.clone())));
+    }
+    if let Some(field) = &r.sum_field {
+        pairs.push(("sum_field".to_string(), JsonValue::str(field.clone())));
+    }
+    if let Some(field) = &r.avg_field {
+        pairs.push(("avg_field".to_string(), JsonValue::str(field.clone())));
+    }
+    if let Some(field) = &r.min_field {
+        pairs.push(("min_field".to_string(), JsonValue::str(field.clone())));
+    }
+    if let Some(field) = &r.max_field {
+        pairs.push(("max_field".to_string(), JsonValue::str(field.clone())));
+    }
+    if let Some(field) = &r.percentile_field {
+        pairs.push(("percentile_field".to_string(), JsonValue::str(field.clone())));
+        // Ruby's own `to_h` guards `percentile_at` on `percentile_field`'s presence too.
+        if let Some(at) = &r.percentile_at {
+            pairs.push(("percentile_at".to_string(), JsonValue::Number(at.clone())));
+        }
+    }
+    if let Some(field) = &r.any_field {
+        pairs.push(("any_field".to_string(), JsonValue::str(field.clone())));
+    }
+    if let Some(field) = &r.all_field {
+        pairs.push(("all_field".to_string(), JsonValue::str(field.clone())));
+    }
+    pairs.extend(query_options_json(&r.options));
+    JsonValue::Object(pairs)
+}
+
+/// `IR::ProcessManager#to_h`.
+fn process_manager_json(pm: &ir::ProcessManager) -> JsonValue {
+    JsonValue::Object(vec![
+        ("name".to_string(), JsonValue::str(pm.name.clone())),
+        (
+            "correlates_by".to_string(),
+            JsonValue::str(pm.correlates_by.clone()),
+        ),
+        ("starts_on".to_string(), JsonValue::opt_str(&pm.starts_on)),
+        ("ends_on".to_string(), JsonValue::opt_str(&pm.ends_on)),
+        ("states".to_string(), JsonValue::strings(&pm.states)),
+        (
+            "handlers".to_string(),
+            JsonValue::Array(
+                pm.handlers
+                    .iter()
+                    .map(process_manager_handler_json)
+                    .collect(),
+            ),
+        ),
+    ])
+}
+
+/// `IR::ProcessManagerHandler#to_h`.
+fn process_manager_handler_json(h: &ir::ProcessManagerHandler) -> JsonValue {
+    JsonValue::Object(vec![
+        (
+            "event_type".to_string(),
+            JsonValue::str(h.event_type.clone()),
+        ),
+        (
+            "from_state".to_string(),
+            JsonValue::str(h.from_state.clone()),
+        ),
+        ("to_state".to_string(), JsonValue::str(h.to_state.clone())),
+        (
+            "dispatches".to_string(),
+            JsonValue::Array(h.dispatches.iter().map(dispatch_spec_json).collect()),
+        ),
+    ])
+}
+
+/// `IR::DispatchSpec#to_h`: `with_spec` is an array of `[key, value]` pairs, not an object.
+///
+/// Key order is `command_name`, `with_spec`, `compensates` (Ruby's declaration order, not the
+/// sorted golden fixture's). `compensates` is `null` or a nested dispatch.
+fn dispatch_spec_json(d: &ir::DispatchSpec) -> JsonValue {
+    JsonValue::Object(vec![
+        (
+            "command_name".to_string(),
+            JsonValue::str(d.command_name.clone()),
+        ),
+        (
+            "with_spec".to_string(),
+            JsonValue::Array(
+                d.with_spec
+                    .iter()
+                    .map(|(k, v)| {
+                        JsonValue::Array(vec![JsonValue::str(k.clone()), JsonValue::str(v.clone())])
+                    })
+                    .collect(),
+            ),
+        ),
+        (
+            "compensates".to_string(),
+            match &d.compensates {
+                Some(inner) => dispatch_spec_json(inner),
+                None => JsonValue::Null,
+            },
+        ),
+    ])
+}
+
+/// `Policy#to_h`: attribute declaration order from reaction.bluebook, then `where_ast` last.
+fn policy_json(p: &ir::Policy) -> JsonValue {
+    JsonValue::Object(vec![
+        ("name".to_string(), JsonValue::str(p.name.clone())),
+        ("on_event".to_string(), JsonValue::opt_str(&p.on_event)),
+        (
+            "trigger_command".to_string(),
+            JsonValue::opt_str(&p.trigger_command),
+        ),
+        (
+            "target_domain".to_string(),
+            JsonValue::opt_str(&p.target_domain),
+        ),
+        (
+            "expect_undelivered".to_string(),
+            JsonValue::Bool(p.expect_undelivered),
+        ),
+        ("where".to_string(), JsonValue::opt_str(&p.where_clause)),
+        (
+            "for_each".to_string(),
+            JsonValue::opt_str(&p.for_each_query),
+        ),
+        (
+            "with_spec".to_string(),
+            JsonValue::Array(
+                p.with_spec
+                    .iter()
+                    .map(|(k, v)| {
+                        JsonValue::Array(vec![JsonValue::str(k.clone()), JsonValue::str(v.clone())])
+                    })
+                    .collect(),
+            ),
+        ),
+        // The structured `where` (`AstJson.emit_predicate`); `null` for an unguarded policy.
+        (
+            "where_ast".to_string(),
+            match p.where_clause.as_deref() {
+                Some(w) if !w.is_empty() => crate::expr::ast_json::emit_predicate(w),
+                _ => JsonValue::Null,
+            },
+        ),
+    ])
+}
+
+/// `IR::DomainPort#to_h` / `IR::PortOperation#to_h`.
+fn domain_port_json(p: &ir::DomainPort) -> JsonValue {
+    JsonValue::Object(vec![
+        ("name".to_string(), JsonValue::str(p.name.clone())),
+        (
+            "operations".to_string(),
+            JsonValue::Array(p.operations.iter().map(port_operation_json).collect()),
+        ),
+    ])
+}
+
+fn port_operation_json(op: &ir::PortOperation) -> JsonValue {
+    let mut fields = vec![
+        ("name".to_string(), JsonValue::str(op.name.clone())),
+        (
+            "attributes".to_string(),
+            JsonValue::Array(op.attributes.iter().map(attribute_json).collect()),
+        ),
+        ("emits".to_string(), JsonValue::strings(&op.emits)),
+    ];
+    // Merged in only when present, so domains that never declared one keep byte-identical IR.
+    if let Some(to) = &op.to {
+        fields.push(("to".to_string(), JsonValue::str(to.clone())));
+    }
+    JsonValue::Object(fields)
+}
+
+/// `JSON.generate`'s native encoding of a captured Ruby value, never `Literal.render`ed;
+/// a bare Symbol serializes as its name.
+fn ruby_value_json(value: &ruby_value::Value) -> JsonValue {
+    match value {
+        ruby_value::Value::Nil => JsonValue::Null,
+        ruby_value::Value::Bool(b) => JsonValue::Bool(*b),
+        ruby_value::Value::Int(n) => JsonValue::Number(n.to_string()),
+        ruby_value::Value::Float(f) => {
+            JsonValue::Number(ruby_value::render(&ruby_value::Value::Float(*f)))
+        }
+        ruby_value::Value::Str(text) => JsonValue::String(text.clone()),
+        ruby_value::Value::Symbol(name) => JsonValue::String(name.clone()),
+        ruby_value::Value::Bare(text) => JsonValue::String(text.clone()),
+        ruby_value::Value::Hash(pairs) => JsonValue::Object(
+            pairs
+                .iter()
+                .map(|(k, v)| (k.clone(), ruby_value_json(v)))
+                .collect(),
+        ),
+        ruby_value::Value::Array(items) => {
+            JsonValue::Array(items.iter().map(ruby_value_json).collect())
+        }
+    }
+}
+
+fn indent(out: &mut String, depth: usize) {
+    for _ in 0..depth {
+        out.push_str("  ");
+    }
+}
+
+fn write_value(out: &mut String, value: &JsonValue, depth: usize) {
+    match value {
+        JsonValue::Null => out.push_str("null"),
+        JsonValue::Bool(b) => out.push_str(if *b { "true" } else { "false" }),
+        JsonValue::Number(n) => out.push_str(n),
+        JsonValue::String(s) => write_string(out, s),
+        JsonValue::Array(items) => write_array(out, items, depth),
+        JsonValue::Object(pairs) => write_object(out, pairs, depth),
+    }
+}
+
+fn write_string(out: &mut String, text: &str) {
+    out.push('"');
+    for ch in text.chars() {
+        match ch {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\t' => out.push_str("\\t"),
+            '\r' => out.push_str("\\r"),
+            c if (c as u32) < 0x20 => {
+                let _ = write!(out, "\\u{:04x}", c as u32);
+            }
+            c => out.push(c),
+        }
+    }
+    out.push('"');
+}
+
+fn write_array(out: &mut String, items: &[JsonValue], depth: usize) {
+    if items.is_empty() {
+        // json 2.7.2 renders an empty array as `[`, a blank unindented line, then `]`,
+        // not `[]`.
+        out.push_str("[\n\n");
+        indent(out, depth);
+        out.push(']');
+        return;
+    }
+    out.push_str("[\n");
+    for (idx, item) in items.iter().enumerate() {
+        indent(out, depth + 1);
+        write_value(out, item, depth + 1);
+        if idx + 1 < items.len() {
+            out.push(',');
+        }
+        out.push('\n');
+    }
+    indent(out, depth);
+    out.push(']');
+}
+
+fn write_object(out: &mut String, pairs: &[(String, JsonValue)], depth: usize) {
+    // An empty object needs no special case: a zero-iteration loop already emits the right bytes.
+    out.push_str("{\n");
+    for (idx, (key, val)) in pairs.iter().enumerate() {
+        indent(out, depth + 1);
+        write_string(out, key);
+        out.push_str(": ");
+        write_value(out, val, depth + 1);
+        if idx + 1 < pairs.len() {
+            out.push(',');
+        }
+        out.push('\n');
+    }
+    indent(out, depth);
+    out.push('}');
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn writes_a_top_level_empty_array() {
+        assert_eq!(write(&JsonValue::Array(vec![])), "[\n\n]");
+    }
+
+    #[test]
+    fn writes_an_empty_object_with_no_special_case() {
+        assert_eq!(write(&JsonValue::Object(vec![])), "{\n}");
+        let nested = JsonValue::Object(vec![("a".to_string(), JsonValue::Object(vec![]))]);
+        assert_eq!(write(&nested), "{\n  \"a\": {\n  }\n}");
+    }
+}