hecks 3.2.1 → 3.4.0

data/lib/hecks/rust_build/append_optionals.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Hecks
-  module RustBuild
-    # Makes an appended element's field `Option<T>` in the IR when any command sources it from an
-    # optional argument, since Ruby stores the omitted nil without complaint. `ir.json` records
-    # the marking, so it runs before the IR is written or generated from.
-    #
-    # `rust/build/src/optional_pass.rs` is the Ruby-free build's port of this; it looks only at an
-    # aggregate's own value objects, where this reads the domain-wide set.
-    module AppendOptionals
-      # Marks every aggregate in the IR, in place.
-      #
-      # @param tree [Hash] a domain's IR, symbol-keyed
-      # @return [Hash] the same IR
-      def self.mark(tree)
-        domain_wide = by_name(tree[:aggregates].flat_map { |aggregate| aggregate[:value_objects] })
-        tree[:aggregates].each do |aggregate|
-          mark_aggregate(aggregate, domain_wide.merge(by_name(aggregate[:value_objects])))
-        end
-        tree
-      end
-
-      # Resolves an `append` target to its entity or value object, or nil if it is neither. A
-      # local entity wins over a domain-wide value object of the same name: Syntax's local
-      # `Argument` entity shares a name with Command's `Argument` value object.
-      #
-      # @param aggregate [Hash] the aggregate owning the command
-      # @param target_type [String] the appended-to attribute's element type
-      # @param value_objects_by_name [Hash{String => Hash}] the value objects in scope
-      # @return [Hash, nil] the element, or nil
-      def self.element(aggregate, target_type, value_objects_by_name)
-        aggregate[:entities].find { |entity| entity[:name] == target_type } ||
-          value_objects_by_name[target_type]
-      end
-
-      # @param aggregate [Hash] one aggregate of the IR
-      # @param value_objects_by_name [Hash{String => Hash}] the value objects in scope
-      # @return [void]
-      def self.mark_aggregate(aggregate, value_objects_by_name)
-        aggregate[:attributes].each do |target_attr|
-          target = element(aggregate, target_attr[:type], value_objects_by_name)
-          next unless target
-
-          aggregate[:commands].each do |command|
-            appends = command[:mutations].select { |m| append_to?(m, target_attr) }
-            appends.each { |mutation| mark_fields(mutation, command, target) }
-          end
-        end
-      end
-
-      def self.append_to?(mutation, target_attr)
-        mutation[:op].to_s == "append" && mutation[:target].to_s == target_attr[:name].to_s
-      end
-      private_class_method :append_to?
-
-      # A Symbol is an argument name, and an optional one is what this pass wants; anything
-      # else is a literal.
-      def self.mark_fields(mutation, command, target)
-        mutation[:fields].each do |field_name, source|
-          parsed = Hecks::Bluebook::Assembly::Marks.read(source)
-          next unless parsed.is_a?(Symbol)
-
-          source_attr = command[:attributes].find { |attr| attr[:name].to_s == parsed.to_s }
-          next unless source_attr && source_attr[:optional]
-
-          field_attr = target[:attributes].find { |attr| attr[:name].to_s == field_name.to_s }
-          field_attr[:optional] = true if field_attr
-        end
-      end
-      private_class_method :mark_fields
-
-      def self.by_name(value_objects)
-        value_objects.to_h { |value_object| [value_object[:name], value_object] }
-      end
-      private_class_method :by_name
-    end
-  end
-end

data/lib/hecks/rust_build/rust_literal.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Hecks
-  module RustBuild
-    # Rust string literals. Ruby's `String#inspect` escapes for Ruby's own read-back (a
-    # brace-less `\uXXXX`, for one), which is not valid Rust syntax.
-    module RustLiteral
-      # Escapes only what Rust's string-literal grammar needs: backslash, double quote and
-      # control characters.
-      #
-      # @param text [#to_s] the text to embed
-      # @return [String] the quoted literal
-      def self.string(text)
-        escaped = text.to_s.each_char.map { |char| escape(char) }.join
-        "\"#{escaped}\""
-      end
-
-      def self.escape(char)
-        case char
-        when "\\" then "\\\\"
-        when "\"" then "\\\""
-        when "\n" then "\\n"
-        when "\r" then "\\r"
-        when "\t" then "\\t"
-        else
-          code = char.ord
-          code < 0x20 || code == 0x7F ? format("\\u{%x}", code) : char
-        end
-      end
-      private_class_method :escape
-    end
-  end
-end

data/lib/hecks/three_zero/forms.yml

@@ -1,127 +0,0 @@
-# Each bin/ script and exe/hecks route, and the hecks 3.0 form that replaces it: the verb spelling the
-# 3.0 launcher answers to (ADR 0080, section 7), with QualityControl verbs after `hecks quality_control`.
----
-argument_gate_matrix: hecks conformance_run.argument_gate_matrix [--confirm] (writes only with --confirm)
-backfill_era_projections: hecks era.backfill_projections <domain>
-behaviors: hecks operation.run_behaviors subject=<path>
-bench: hecks fuzz_run.bench [domains=pizzas,banking] [targets=] [iterations=1000] [warmup=200]
-  [runs=3] [rust_binary=] [format=markdown] [output=]
-canonicalise: hecks style_run.canonicalise <file.json>
-check_engine_agreement: hecks conformance_run.check_engine_agreement
-check_era: hecks host.check_era <url> expected=era-file [timeout=]
-codemod_hoist_local_givens: hecks codemod_run.hoist_local_givens --confirm
-codemod_implicit_append_fields: hecks codemod_run.drop_implicit_append_fields --confirm
-compact: hecks era.compact <domain> [aggregates=A,B] --confirm
-console: hecks console [subject=<domain>]
-corpus: hecks corpus_run.rust_domains; hecks corpus_run.regen_order; hecks corpus_run.corpus_rust_coverage
-deploy_template_diff: hecks deploy template_comparison.diff before=a.yaml after=b.yaml [--json] [--strict]
-doc_coverage: hecks conformance_run.measure_doc_coverage
-docs: hecks docs [domain-path] [aggregate]
-evolve: hecks language_run.word_status; hecks language_run.propose <word> context=X [body=none] [inner=] [opens=]
-  [fills=]; hecks language_run.admit|deprecate|retire <word> context=X; hecks language_run.rename <word> context=X
-  new_name=Y; hecks language_run.propose_argument <word> context=X kind=K [required=false] [at=N]
-  [named=] [fills=] [pairs_shape=]; hecks language_run.admit_argument|deprecate_argument|retire_argument
-  <word> context=X [at=N] [named=]
-expression_projection: hecks language_run.project_expression_tables [--stdout]
-follow: hecks operation.follow <domain> [aggregate=Name] [since=N] [interval=0.5] [wait=N] [--from-now] [--stream]
-fuzz: hecks fuzz_run.fuzz [domain] [seeds=20] [steps=30] [workers=] [adapter=memory]
-generate: hecks fuzz_run.generate_sequence <domain> [seed=1] [steps=30] [adversarial=0.0]
-hecks_mcp_door: hecks mcp [--stdio]
-hecks_query_ir_mcp: hecks corpus_run.serve_query_ir_mcp
-heki_compact: hecks era.compact_heki <domain> [aggregates=A,B] --confirm
-history: hecks introspection.history <domain>
-ir: hecks ir <domain> [--translations] | hecks ir --meta
-lint_deploy_recipes: hecks deploy makefile_check.lint [makefiles=a,b]
-merge_tail: hecks era.merge_tail <domain> winners=id:old,id:new --confirm
-model_check: hecks model_check [--strict] [--profile client] [<domain> …]
-narrate: hecks narrate [domain-path] [aggregate]
-pattern-cases: hecks test_suite_run.record_pattern_cases
-present: hecks corpus_run.present [port=4567]
-project: hecks operation.refresh_projections subject=<domain>
-project_bootstrap_table: hecks language_run.project_bootstrap_table
-project_cli: hecks project_cli [domain-path …]
-project_deploy: hecks deploy recipe.project <domain> [tenant=] [schema=] [out=] [environment=]
-project_diagrams: hecks project_diagrams <domain-path> <ChapterName>
-project_field_hints: hecks language_run.project_field_hints
-project_glossary: hecks introspection.glossary <domain> chapter=Name
-project_kernel_capabilities: hecks kernel_run.project_kernel_capabilities
-project_model: hecks language_run.project_model
-project_oidc: hecks deploy oidc_manifest.project_oidc [domains=a,b]
-project_parser_table: hecks language_run.project_parser_table
-project_refusal_wording: hecks language_run.project_refusal_wording
-project_reserved_names: hecks language_run.project_reserved_names
-project_rust: hecks build.project_rust <domain>
-project_rust_vocabulary: hecks language_run.project_rust_vocabulary
-project_tenant: hecks deploy tenant.provision <domain_dir> slug=s domain= realm= schema=
-  database= [adapter=PostgresEra]; hecks deploy tenant.reprovision <tenant> directory= database=
-  [adapter=PostgresEra]
-project_vocabulary: hecks language_run.project_vocabulary
-project_wasm: hecks build.build_wasm <domain>
-project_wasm_browser: hecks build.build_browser_wasm <domain>
-qa_concurrency_racer: not user-facing; ProcessPool starts it as hecks quality_control
-  sweep.race domain= database= schema= verb= step_arguments=
-qa_discover_external_domains: hecks quality_control target.discover_external_domains [arguments="--projects-dir
-  ~/Projects --max-depth 3 --known-path PATH …"]
-qa_domain_novelty: hecks quality_control target.judge_novelty <domain> [arguments="--against
-  PATH …"]
-qa_generated_domains: hecks quality_control target.check_generated_domains [arguments="--domains
-  3 --start N --forms a,b --seeds 5 --steps 25 --adversarial 0.3 --rust --shrink-budget
-  200 --domain-shrink-budget 40 --promote dir --name N --from-dials --blueprint F
-  --source F"]
-qa_log_bug: hecks quality_control bug.log sweep=<sweep id> reference= sequence=N title=
-  demonstration= symptom= expectation= submitter= [tags=a,b] [name=] [reproduced=yes|no]
-qa_mine_combinations: hecks quality_control target.mine_combinations [arguments="--candidates
-  3 --rust --seeds 5 --steps 25 --adversarial 0.3 --repair-rounds 1 --agent CMD --from
-  DIR --against PATH --brief"]
-qa_open_pr: hecks quality_control patch.open bug=BUG#n number=N url=… branch=… commit=SHA
-  title=… [now=]; hecks quality_control improvement.open [angle=ANGLE-n] number=N
-  url=… branch=… title=… [now=]
-qa_postgres_migrate: hecks quality_control sweep.migrate_ledger_from_heki domain=<domain_dir>
-  data=<heki_dir> [arguments="[aggregate …] --force"] (a dry run without --force)
-qa_postgres_role: hecks quality_control sweep.create_ledger_role <database> [role=hecks_qa]
-qa_pr_check: hecks quality_control clearance.check_pull_requests
-qa_seed_angles: hecks quality_control angle.seed
-qa_seed_targets: hecks quality_control target.seed
-qa_sweep: hecks quality_control query sweep.run [target=] [arguments="--all --seeds N --steps
-  N --adversarial F --role-draw F --dry-run F --self-consistency BOOL --modes a,b
-  --persistence-parity --no-parity"]; hecks quality_control target.release <target> [now=]
-  [next_streak=] [capabilities=] [yield_score=]
-qa_tick: hecks quality_control sweep.tick
-query_ir: hecks corpus_run.ir_constructs [names=a,b]; hecks corpus_run.ir_duplicates [domains=a,b] [--meta];
-  hecks corpus_run.ir_impact name=N field=F
-reattest_era: hecks era.reattest <domain> era=N --confirm
-reference: hecks language_run.project_reference
-refresh_rspec_runtime_baseline: hecks test_suite_run.refresh_runtime_baseline [workers=] [from_run=ID]
-regen_codegen_domains: hecks regeneration_run.regenerate_corpus [--check]
-regenerate_persistence_legacy_fixtures: hecks test_suite_run.regenerate_legacy_fixtures --confirm
-release: hecks publishing_run.publish [--gem-only] [--npm-only] [--npm-local] [--no-wait] --confirm
-  (without --confirm, the old --dry-run)
-release_gem: hecks publishing_run.publish_gem --confirm
-rspec_io_parallel_files: hecks test_suite_run.list_io_parallel_specs exclude=REGEX [tags=] [check=file];
-  hecks test_suite_run.write_io_parallel_spec_list exclude=REGEX [tags=] write=file --confirm
-rspec_shard_files: hecks test_suite_run.shard_specs group=1 groups=N [runtime_log=]
-run: hecks run [domain] <verb [name=value …] | script.json | - | '{"steps":[…]}'>
-rust_conformance: hecks build.check_conformance <domain> script=steps.json [artifact=native]
-rust_conformance_fuzz: hecks build.fuzz_conformance <domain> artifact=native [seeds=10]
-  [steps=25]
-rust_coverage: hecks build.rust_coverage <module> [codegen=ruby]; hecks build.check_coverage_allowlist
-rust_kernel_coverage: hecks kernel_run.measure_kernel_coverage
-scaffold_translation: hecks era.scaffold_translation <domain>
-seed_semantics_corpus: hecks test_suite_run.seed_semantics_corpus [fixture=name]
-shape: hecks introspection.shape <domain>
-smoke_http: hecks operation.smoke_http path=/p [url=] [header=] [scheme=timestamped]
-  [payload=] [payload_file=] [health_path=] [state_path=]
-smoke_test: hecks smoke_test [domain]
-spec_example: hecks test_suite_run.run_spec_example file=path example=text
-standardize_comments: hecks style_run.report_comments paths=a,b [only=] [--json] [top=20]; hecks
-  style_run.check_comments paths=…; hecks style_run.fix_comments paths=… --confirm; hecks style_run.write_comment_baseline
-  --confirm; hecks style_run.check_comments_unchanged ref=REF
-standardize_comments_rust: hecks style_run.report_rust_comments paths=a,b [only=] [--json] [top=N];
-  hecks style_run.check_rust_comments paths=… [only=]; hecks style_run.fix_rust_comments paths=… [only=]
-  --confirm
-statements: hecks introspection.statements <domain> chapter=Name
-stores: hecks stores <domain>
-stress_concurrency_specs: hecks test_suite_run.stress_concurrency [runs=] [parallel=] [seed_start=]
-translation_audit: hecks era.audit_translation <domain>; hecks era.approve_translation <domain>
-  [snapshot=] [host_version=] [rehearsal=pass|fail] [rehearsed_at=] --confirm
-vendor_bluebook: hecks package.vendor <package[@version]> [from=path] [root=path]

data/lib/hecks/three_zero.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-
-module Hecks
-  # The table of what each retired `bin/` script became in hecks 3.0.0 (ADR 0080): a command on
-  # the Hecks domain, run through `exe/hecks`. `docs/tools.md` is pinned to it.
-  module ThreeZero
-    # Each retired script's name mapped to the 3.0 form that replaced it.
-    FORMS = YAML.safe_load_file(File.join(__dir__, "three_zero/forms.yml")).freeze
-  end
-end

data/rust/build/src/json.rs

@@ -1,421 +0,0 @@
-//! A minimal, dependency-free, mutable JSON value with a reader and a pretty writer.
-//! The writer matches `JSON.pretty_generate` byte-for-byte, including its empty-array quirk.
-
-use std::fmt::Write as _;
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum Json {
-    Null,
-    Bool(bool),
-    /// Raw literal text as scanned, so numbers round-trip unchanged.
-    Number(String),
-    String(String),
-    Array(Vec<Json>),
-    /// Insertion-ordered pairs; byte-exact re-emission depends on key order.
-    Object(Vec<(String, Json)>),
-}
-
-impl Json {
-    pub fn parse(text: &str) -> Result<Json, String> {
-        let mut p = Parser { bytes: text.as_bytes(), pos: 0 };
-        p.skip_ws();
-        let value = p.parse_value()?;
-        p.skip_ws();
-        if p.pos != p.bytes.len() {
-            return Err(format!("trailing content at byte {}", p.pos));
-        }
-        Ok(value)
-    }
-
-    /// Looks up `key`, treating a `null` value as missing.
-    pub fn get(&self, key: &str) -> Option<&Json> {
-        match self {
-            Json::Object(pairs) => pairs.iter().find(|(k, v)| k == key && !matches!(v, Json::Null)).map(|(_, v)| v),
-            _ => None,
-        }
-    }
-
-    pub fn get_mut(&mut self, key: &str) -> Option<&mut Json> {
-        match self {
-            Json::Object(pairs) => pairs.iter_mut().find(|(k, _)| k == key).map(|(_, v)| v),
-            _ => None,
-        }
-    }
-
-    pub fn as_str(&self) -> Option<&str> {
-        match self {
-            Json::String(s) => Some(s.as_str()),
-            _ => None,
-        }
-    }
-
-    pub fn as_array(&self) -> Option<&[Json]> {
-        match self {
-            Json::Array(items) => Some(items.as_slice()),
-            _ => None,
-        }
-    }
-
-    pub fn as_array_mut(&mut self) -> Option<&mut Vec<Json>> {
-        match self {
-            Json::Array(items) => Some(items),
-            _ => None,
-        }
-    }
-
-    pub fn as_object(&self) -> Option<&[(String, Json)]> {
-        match self {
-            Json::Object(pairs) => Some(pairs.as_slice()),
-            _ => None,
-        }
-    }
-
-    /// Ruby truthiness: everything except `false` and `null` is true.
-    pub fn as_bool(&self) -> bool {
-        !matches!(self, Json::Bool(false) | Json::Null)
-    }
-
-    /// Iterates an array field; empty for any other value.
-    pub fn each(&self) -> &[Json] {
-        self.as_array().unwrap_or(&[])
-    }
-
-    /// Sets `key` to `value`, the only mutation the optional-marking pass performs.
-    /// Overwrites the existing pair, or appends one if absent.
-    pub fn set_bool(&mut self, key: &str, value: bool) {
-        if let Json::Object(pairs) = self {
-            if let Some((_, existing)) = pairs.iter_mut().find(|(k, _)| k == key) {
-                *existing = Json::Bool(value);
-                return;
-            }
-            pairs.push((key.to_string(), Json::Bool(value)));
-        }
-    }
-
-    /// Sets `key` to `value`, overwriting in place or else appending last.
-    pub fn set(&mut self, key: &str, value: Json) {
-        if let Json::Object(pairs) = self {
-            if let Some((_, existing)) = pairs.iter_mut().find(|(k, _)| k == key) {
-                *existing = value;
-                return;
-            }
-            pairs.push((key.to_string(), value));
-        }
-    }
-}
-
-struct Parser<'a> {
-    bytes: &'a [u8],
-    pos: usize,
-}
-
-impl<'a> Parser<'a> {
-    fn peek(&self) -> Option<u8> {
-        self.bytes.get(self.pos).copied()
-    }
-
-    fn skip_ws(&mut self) {
-        while let Some(b) = self.peek() {
-            if b == b' ' || b == b'\t' || b == b'\n' || b == b'\r' {
-                self.pos += 1;
-            } else {
-                break;
-            }
-        }
-    }
-
-    fn expect(&mut self, b: u8) -> Result<(), String> {
-        if self.peek() == Some(b) {
-            self.pos += 1;
-            Ok(())
-        } else {
-            Err(format!("expected {:?} at byte {}, found {:?}", b as char, self.pos, self.peek().map(|c| c as char)))
-        }
-    }
-
-    fn parse_value(&mut self) -> Result<Json, String> {
-        self.skip_ws();
-        match self.peek() {
-            Some(b'{') => self.parse_object(),
-            Some(b'[') => self.parse_array(),
-            Some(b'"') => Ok(Json::String(self.parse_string()?)),
-            Some(b't') => {
-                self.expect_literal("true")?;
-                Ok(Json::Bool(true))
-            }
-            Some(b'f') => {
-                self.expect_literal("false")?;
-                Ok(Json::Bool(false))
-            }
-            Some(b'n') => {
-                self.expect_literal("null")?;
-                Ok(Json::Null)
-            }
-            Some(c) if c == b'-' || c.is_ascii_digit() => self.parse_number(),
-            other => Err(format!("unexpected byte {:?} at {}", other.map(|c| c as char), self.pos)),
-        }
-    }
-
-    fn expect_literal(&mut self, lit: &str) -> Result<(), String> {
-        let end = self.pos + lit.len();
-        if end <= self.bytes.len() && &self.bytes[self.pos..end] == lit.as_bytes() {
-            self.pos = end;
-            Ok(())
-        } else {
-            Err(format!("expected literal {lit:?} at byte {}", self.pos))
-        }
-    }
-
-    fn parse_object(&mut self) -> Result<Json, String> {
-        self.expect(b'{')?;
-        let mut pairs = Vec::new();
-        self.skip_ws();
-        if self.peek() == Some(b'}') {
-            self.pos += 1;
-            return Ok(Json::Object(pairs));
-        }
-        loop {
-            self.skip_ws();
-            let key = self.parse_string()?;
-            self.skip_ws();
-            self.expect(b':')?;
-            let value = self.parse_value()?;
-            pairs.push((key, value));
-            self.skip_ws();
-            match self.peek() {
-                Some(b',') => {
-                    self.pos += 1;
-                }
-                Some(b'}') => {
-                    self.pos += 1;
-                    break;
-                }
-                other => return Err(format!("expected ',' or '}}' at byte {}, found {:?}", self.pos, other.map(|c| c as char))),
-            }
-        }
-        Ok(Json::Object(pairs))
-    }
-
-    fn parse_array(&mut self) -> Result<Json, String> {
-        self.expect(b'[')?;
-        let mut items = Vec::new();
-        self.skip_ws();
-        if self.peek() == Some(b']') {
-            self.pos += 1;
-            return Ok(Json::Array(items));
-        }
-        loop {
-            let value = self.parse_value()?;
-            items.push(value);
-            self.skip_ws();
-            match self.peek() {
-                Some(b',') => {
-                    self.pos += 1;
-                }
-                Some(b']') => {
-                    self.pos += 1;
-                    break;
-                }
-                other => return Err(format!("expected ',' or ']' at byte {}, found {:?}", self.pos, other.map(|c| c as char))),
-            }
-        }
-        Ok(Json::Array(items))
-    }
-
-    fn parse_string(&mut self) -> Result<String, String> {
-        self.expect(b'"')?;
-        let mut out = String::new();
-        loop {
-            match self.peek() {
-                None => return Err("unterminated string".to_string()),
-                Some(b'"') => {
-                    self.pos += 1;
-                    break;
-                }
-                Some(b'\\') => {
-                    self.pos += 1;
-                    match self.peek() {
-                        Some(b'"') => {
-                            out.push('"');
-                            self.pos += 1;
-                        }
-                        Some(b'\\') => {
-                            out.push('\\');
-                            self.pos += 1;
-                        }
-                        Some(b'/') => {
-                            out.push('/');
-                            self.pos += 1;
-                        }
-                        Some(b'n') => {
-                            out.push('\n');
-                            self.pos += 1;
-                        }
-                        Some(b't') => {
-                            out.push('\t');
-                            self.pos += 1;
-                        }
-                        Some(b'r') => {
-                            out.push('\r');
-                            self.pos += 1;
-                        }
-                        Some(b'b') => {
-                            out.push('\u{8}');
-                            self.pos += 1;
-                        }
-                        Some(b'f') => {
-                            out.push('\u{c}');
-                            self.pos += 1;
-                        }
-                        Some(b'u') => {
-                            self.pos += 1;
-                            let hex = std::str::from_utf8(&self.bytes[self.pos..self.pos + 4]).map_err(|e| e.to_string())?;
-                            let code = u32::from_str_radix(hex, 16).map_err(|e| e.to_string())?;
-                            self.pos += 4;
-                            if let Some(c) = char::from_u32(code) {
-                                out.push(c);
-                            }
-                        }
-                        other => return Err(format!("bad escape {:?}", other.map(|c| c as char))),
-                    }
-                }
-                Some(_) => {
-                    // One UTF-8 char at a time so multi-byte text survives.
-                    let start = self.pos;
-                    let rest = std::str::from_utf8(&self.bytes[start..]).map_err(|e| e.to_string())?;
-                    let ch = rest.chars().next().ok_or("empty remainder")?;
-                    out.push(ch);
-                    self.pos += ch.len_utf8();
-                }
-            }
-        }
-        Ok(out)
-    }
-
-    // Keeps the raw literal text, so numbers round-trip unchanged.
-    fn parse_number(&mut self) -> Result<Json, String> {
-        let start = self.pos;
-        if self.peek() == Some(b'-') {
-            self.pos += 1;
-        }
-        while matches!(self.peek(), Some(c) if c.is_ascii_digit()) {
-            self.pos += 1;
-        }
-        if self.peek() == Some(b'.') {
-            self.pos += 1;
-            while matches!(self.peek(), Some(c) if c.is_ascii_digit()) {
-                self.pos += 1;
-            }
-        }
-        if matches!(self.peek(), Some(b'e') | Some(b'E')) {
-            self.pos += 1;
-            if matches!(self.peek(), Some(b'+') | Some(b'-')) {
-                self.pos += 1;
-            }
-            while matches!(self.peek(), Some(c) if c.is_ascii_digit()) {
-                self.pos += 1;
-            }
-        }
-        let text = std::str::from_utf8(&self.bytes[start..self.pos]).map_err(|e| e.to_string())?;
-        Ok(Json::Number(text.to_string()))
-    }
-}
-
-/// Renders `value` exactly as `JSON.pretty_generate` does for the pinned json gem.
-pub fn write(value: &Json) -> String {
-    let mut out = String::new();
-    write_value(&mut out, value, 0);
-    out
-}
-
-fn indent(out: &mut String, depth: usize) {
-    for _ in 0..depth {
-        out.push_str("  ");
-    }
-}
-
-fn write_value(out: &mut String, value: &Json, depth: usize) {
-    match value {
-        Json::Null => out.push_str("null"),
-        Json::Bool(b) => out.push_str(if *b { "true" } else { "false" }),
-        Json::Number(n) => out.push_str(n),
-        Json::String(s) => write_string(out, s),
-        Json::Array(items) => write_array(out, items, depth),
-        Json::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: &[Json], depth: usize) {
-    if items.is_empty() {
-        // Empty arrays render with a blank line, matching the pinned json gem.
-        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, Json)], depth: usize) {
-    // An empty object needs no special case: the loop runs zero times.
-    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 round_trips_an_empty_object() {
-        let text = "{\n}";
-        let value = Json::parse(text).expect("parses");
-        assert_eq!(write(&value), text);
-    }
-
-    #[test]
-    fn set_bool_overwrites_an_existing_key() {
-        let mut value = Json::parse("{\n  \"optional\": false\n}").expect("parses");
-        value.set_bool("optional", true);
-        assert_eq!(write(&value), "{\n  \"optional\": true\n}");
-    }
-}