carve-lang 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 701231311b5228a33a5ca37b7855209d3521f8ece697824f0b3e3322cb69a30a
-  data.tar.gz: 869fc6cbce2b49755f7c9e734afd1ec1afc860f508cec75f4e8f3b13b7ed91db
+  metadata.gz: 2d4e85e4ab93621b11f1502ca546d64cc0d46e513e4074e6e4014cec8f5aee04
+  data.tar.gz: 3100558ccb654d5c2441358ce8a13ba363db7937e0e979be3944780322b62561
 SHA512:
-  metadata.gz: c46d50c7fe1dde855c0d4959067b8d99c45a905610c156a68d40ebf1f5b241d8fc036754755309c8a58d54d41e85c0bd3418031eed1fd393f3dfb6e9b5226ee1
-  data.tar.gz: 23f7732176af5392bd32839ddffc77e565ed0a9d3a68677f9206d19c71db796922301fcc6231f028dc7bf3ca250ccab54912d879ed8b3c2305eff18123cd7e17
+  metadata.gz: db44ca3900ce90483edd037944efa79adf6c55a921afe8b00b00a31ba687d6f0f5fce97efba6ec3fb67e69f3c931544bd6b0e09169d62e9a8549b99e0836c693
+  data.tar.gz: 28dbc892917d7fb9074005e71cff53fe603bc25ca4d3a54add3042be7813aa4bed7e2db0eea5b950b1a5e2c416de9d9588c38ac7f8985cb90aa126f482d17c86

data/CHANGELOG.md

@@ -7,6 +7,70 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.10] - 2026-10-23
+
+### Breaking
+
+- The engine is the published `carve-lang` 0.1.11 crate. A quote-prefixed `+`
+  needs one space after each `>`, so `>+` and `>>+` now render as text, and a
+  continuation marker reads only at column 0 or right after a block opener.
+  Re-check documents that place `+` elsewhere (#215, markup-carve/carve#3421).
+- Includes of a file that is not valid UTF-8 are refused with an
+  `include-non-text` warning instead of being spliced (#215,
+  markup-carve/carve-rs#2885).
+
+### Fixes
+
+- The carve-lang 0.1.11 pin corrects container ownership for quotes, lazy lines,
+  colon divs and footnotes, fences inside nested lists and quotes, and list
+  tightness around captions (#215).
+- Includes see through a byte order mark and keep link definitions and region
+  markers in place. Markdown import keeps link destinations, autolink brackets
+  and pipe escapes as written (#215).
+- `Carve.render_with_includes` with the `markdown`, `plain` and `ansi` targets
+  keeps a link definition where it was written, as `Carve.to_markdown` does,
+  instead of moving it to the end (#221).
+
+### Improvements
+
+- Precompiled gems for `x86_64-linux`, `x86_64-linux-musl`, `aarch64-linux`,
+  `x86_64-darwin`, `arm64-darwin` and `x64-mingw-ucrt` install without a Rust
+  toolchain on Ruby 3.0 to 4.0 (#214).
+- `Carve.to_carve(source, align_tables: true)` pads table columns to display
+  width (#215).
+- `Carve.select_include_region(source, name, mode:)` resolves a named
+  `@region` to a Range of content lines and raises `Carve::IncludeRegionError`
+  for a missing or malformed region (#215).
+- An include with `@code` or `@code:lang` splices a file or region as one code
+  block (#215).
+- Include warnings carry `includedBy`, the chain of directives that reached the
+  file the warning arose in, with root-relative paths, lines and columns (#221).
+
+## [0.1.9] - 2026-10-18
+
+### Breaking
+
+- `Carve.parse` and AST include results carry `astVersion: "1.2"` on the root.
+  Exact-key readers must accept the new field (#210).
+- The carve-lang 0.1.10 pin adds `resolved` to resolved link and image references
+  and `form` to comments. `[text]()` and `![alt]()` render as links and images,
+  and a bare `[r]:` defines an empty destination. Escape `\[` to keep that
+  spelling literal. Checked render reports can also include
+  `table-span-flattened`, `table-header-row-demoted`,
+  `table-header-row-hoisted`, and `table-header-cell-demoted` (#207).
+
+### Fixes
+
+- Source strings in other encodings such as Shift_JIS are transcoded to UTF-8.
+  Malformed UTF-8 and binary bytes become replacement characters instead of
+  failing at the native boundary (#207).
+
+### Improvements
+
+- The carve-lang 0.1.10 pin adds CSV and TSV table fences and keeps plain-text
+  list continuation blocks at their item's indentation. It also corrects
+  parsing of nested lists with quotes and containers (#207).
+
 ## [0.1.8] - 2026-10-14
 
 ### Breaking
@@ -463,7 +527,9 @@ are not listed, because no release ever shipped them.
   Arrays (every AST node type is covered), enabling custom renderers such as
   [carve-hexapdf](https://github.com/markup-carve/carve-hexapdf).
 
-[Unreleased]: https://github.com/markup-carve/carve-rb/compare/v0.1.8...HEAD
+[Unreleased]: https://github.com/markup-carve/carve-rb/compare/v0.1.10...HEAD
+[0.1.10]: https://github.com/markup-carve/carve-rb/compare/v0.1.9...v0.1.10
+[0.1.9]: https://github.com/markup-carve/carve-rb/compare/v0.1.8...v0.1.9
 [0.1.8]: https://github.com/markup-carve/carve-rb/compare/v0.1.7...v0.1.8
 [0.1.7]: https://github.com/markup-carve/carve-rb/compare/v0.1.6...v0.1.7
 [0.1.6]: https://github.com/markup-carve/carve-rb/compare/v0.1.5...v0.1.6

data/README.md

@@ -16,7 +16,48 @@ bundle install
 ```
 
 The distribution name is `carve-lang`, while the require path is `carve`.
-Building from source requires Rust 1.75 or newer and Ruby development headers.
+
+Releases after 0.1.9 ship precompiled gems for `x86_64-linux`,
+`x86_64-linux-musl`, `aarch64-linux`, `x86_64-darwin`, `arm64-darwin` and
+`x64-mingw-ucrt`, with a binary for each Ruby from 3.0 to 4.0 (from 3.1 on
+Windows, where Ruby 3.0 has no UCRT build). On those platforms `gem install`
+needs no Rust toolchain or libclang. Everywhere else, including newer Rubies,
+RubyGems installs the source gem and builds it as described below.
+
+## Installing from source
+
+Version 0.1.9 and earlier ship source only, and so does every release on a
+platform or Ruby without a precompiled gem. There `gem install carve-lang`
+compiles a Rust extension on your machine, so the install needs:
+
+- A Rust toolchain with `cargo`, Rust 1.77 or newer. [rustup](https://rustup.rs)
+  is the usual way to get one.
+- Ruby development headers (`ruby-dev` on Debian and Ubuntu).
+- libclang and clang. The build runs `bindgen` through `rb-sys` to read Ruby's
+  C headers. On Debian and Ubuntu:
+
+```bash
+sudo apt install libclang-dev clang
+```
+
+If only libclang is installed, without the `clang` package, the build stops
+with this error:
+
+```text
+/usr/include/ruby-3.2.0/ruby/ruby.h:23:10: fatal error: 'stdarg.h' file not found
+thread 'main' panicked at .../rb-sys-0.9.128/build/main.rs:52:6:
+generate bindings: ClangDiagnostic("/usr/include/ruby-3.2.0/ruby/ruby.h:23:10: fatal error: 'stdarg.h' file not found\n")
+error: failed to run custom build command for `rb-sys v0.9.128`
+```
+
+libclang cannot find its own builtin headers. Install `clang`, or point
+bindgen at GCC's copy of those headers:
+
+```bash
+BINDGEN_EXTRA_CLANG_ARGS="-I$(gcc -print-file-name=include)" gem install carve-lang
+```
+
+With Bundler, export the variable before running `bundle install`.
 
 ## Render Carve
 
@@ -28,6 +69,7 @@ Carve.to_markdown(source)
 Carve.to_plain_text(source)
 Carve.to_ansi(source)
 Carve.to_carve(source)
+Carve.to_carve(source, align_tables: true) # pad table columns
 ```
 
 Options configure extensions, safe rendering, profiles, symbols, section
@@ -91,7 +133,9 @@ result = Carve.to_html_with_includes(
 )
 ```
 
-The result contains the value, warnings, and root-relative dependencies.
+The result contains the value, warnings, and root-relative dependencies. A
+warning from an included file names the chain of directives that reached it in
+`:includedBy`.
 Other render methods leave directives literal. See the
 [include reference](docs/reference.md#file-includes) for budgets, AST expansion,
 targets, and containment behavior.

data/ext/carve/Cargo.lock

@@ -37,9 +37,9 @@ checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
 
 [[package]]
 name = "carve-lang"
-version = "0.1.9"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8747e096cacdd7097d884ffb9dd15dc70dd7e636081a31335bb786313924f341"
+checksum = "753b90fbe80fab43887d5d559996c153347d9631452bbcb8d0283aad6dfa7ef8"
 dependencies = [
  "html5ever",
  "markup5ever_rcdom",
@@ -54,7 +54,7 @@ dependencies = [
 
 [[package]]
 name = "carve-rb"
-version = "0.1.8"
+version = "0.1.10"
 dependencies = [
  "carve-lang",
  "magnus",

data/ext/carve/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "carve-rb"
-version = "0.1.8"
+version = "0.1.10"
 edition = "2021"
 rust-version = "1.75"
 publish = false
@@ -22,4 +22,4 @@ serde_json = "1"
 # The Carve engine. Imported under the Rust crate alias `carve_rs` so the
 # binding's own crate name (`carve-rb`) does not collide with the engine's
 # package name (`carve`) in the Cargo lockfile.
-carve_rs = { package = "carve-lang", version = "=0.1.9" }
+carve_rs = { package = "carve-lang", version = "=0.1.11" }

data/ext/carve/src/lib.rs

@@ -27,7 +27,9 @@
 use carve_rs::extensions::registry;
 use carve_rs::{CarveExtension, Mode, Options, Profile, StaticRenderers};
 use magnus::value::{InnerValue, Opaque};
-use magnus::{function, prelude::*, Error, ExceptionClass, RArray, RHash, Ruby, Value};
+use magnus::{
+    function, prelude::*, Error, ExceptionClass, RArray, RHash, RString, Ruby, TryConvert, Value,
+};
 use std::any::Any;
 use std::cell::RefCell;
 use std::panic::{self, AssertUnwindSafe};
@@ -97,6 +99,14 @@ fn extension_names() -> Vec<String> {
     registry::keys().map(str::to_string).collect()
 }
 
+fn ast_json_with_version(json: String) -> String {
+    let (body, closing) = json.split_at(json.len() - 1);
+    format!(
+        "{body},\"astVersion\":\"{}\"{closing}",
+        carve_rs::AST_CONTRACT_VERSION
+    )
+}
+
 /// Map a Ruby-facing mode string to a carve-rs [`Mode`].
 ///
 /// Rejects any unknown string with `ArgumentError`, mirroring the spec's
@@ -216,8 +226,44 @@ fn to_ansi(source: String) -> String {
     carve_rs::to_ansi(&source)
 }
 
-fn to_carve(source: String) -> String {
-    carve_rs::to_carve(&source)
+/// Canonical Carve source; a writer refusal returns the source as authored.
+fn to_carve(source: String, align_tables: bool) -> String {
+    let options = Options::default().with_align_tables(align_tables);
+    carve_rs::try_to_carve_with_options(&source, &options).unwrap_or(source)
+}
+
+/// Resolve `@region:name` with the engine's marker rules (spec I1b).
+///
+/// Returns `[start, end]` (1-based, inclusive content lines) or, when the
+/// region is invalid, the warning rule id as a String; `lib/carve.rb` turns
+/// that into `Carve::IncludeRegionError`.
+fn select_include_region(
+    ruby: &Ruby,
+    source: String,
+    name: String,
+    mode: String,
+) -> Result<Value, Error> {
+    let mode = match mode.as_str() {
+        "carve" => carve_rs::IncludeRegionMode::Carve,
+        "code" => carve_rs::IncludeRegionMode::Code,
+        other => {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                format!("mode must be :carve or :code, got {other:?}"),
+            ))
+        }
+    };
+    Ok(
+        match carve_rs::select_include_region(&source, &name, mode) {
+            Ok(region) => ruby
+                .ary_new_from_values(&[
+                    ruby.integer_from_u64(region.start as u64).as_value(),
+                    ruby.integer_from_u64(region.end as u64).as_value(),
+                ])
+                .as_value(),
+            Err(e) => ruby.str_new(e.rule()).as_value(),
+        },
+    )
 }
 
 /// Which renderer runs over the expanded document.
@@ -334,6 +380,12 @@ fn render_with_includes_json(
     if !sections {
         render_options = render_options.with_sections(false);
     }
+    // Positions let the engine record the directive chain behind a warning
+    // (`includedBy`). The AST target keeps them off: spec I4 leaves position
+    // remapping out of scope, so a child's spans would point into the wrong file.
+    if which != IncludeTarget::Ast {
+        render_options = render_options.with_positions(true);
+    }
     let mut include_options = carve_rs::IncludeOptions::new()
         .with_resolver(&resolver)
         .with_source_path(source_real.to_string_lossy());
@@ -378,7 +430,7 @@ fn render_with_includes_json(
         // parse JSON twice. Positions stay OFF, unlike `to_ast_json`: spec I4
         // leaves position remapping out of scope in every engine, so a child's
         // spans would point into a document the caller never passed.
-        IncludeTarget::Ast => Ok(carve_rs::to_json(&prepared.doc)),
+        IncludeTarget::Ast => Ok(ast_json_with_version(carve_rs::to_json(&prepared.doc))),
     }
     .map_err(|error| Error::new(ruby.exception_runtime_error(), error.to_string()))?;
     let value: serde_json::Value = if which == IncludeTarget::Ast {
@@ -409,6 +461,17 @@ fn render_with_includes_json(
                 "rule": warning.rule,
                 "message": warning.message,
                 "file": warning.file.as_deref().map(&safe_path),
+                "includedBy": warning
+                    .included_by
+                    .iter()
+                    .map(|site| {
+                        serde_json::json!({
+                            "file": safe_path(&site.file),
+                            "line": site.line,
+                            "column": site.column,
+                        })
+                    })
+                    .collect::<Vec<_>>(),
             })
         })
         .collect::<Vec<_>>();
@@ -522,7 +585,9 @@ fn migration_diagnostic_json(diagnostic: &carve_rs::MigrationDiagnostic) -> serd
 fn to_ast_json(source: String) -> String {
     let mut options = Options::new();
     options.positions = true;
-    carve_rs::to_json(&carve_rs::parse_with_options(&source, &options))
+    ast_json_with_version(carve_rs::to_json(&carve_rs::parse_with_options(
+        &source, &options,
+    )))
 }
 
 /// Render Carve source to HTML with the named extensions enabled.
@@ -842,42 +907,74 @@ macro_rules! guarded {
     ($wrapper:ident ( $($arg:ident : $ty:ty),* ) -> $ret:ty => $inner:ident) => {
         #[allow(clippy::too_many_arguments)]
         fn $wrapper($($arg: $ty),*) -> Result<$ret, Error> {
-            guard(|| Ok($inner($($arg),*)))
+            guard(|| Ok($inner($($arg.into()),*)))
         }
     };
     ($wrapper:ident ( $($arg:ident : $ty:ty),* ) -> $ret:ty =>? $inner:ident) => {
         #[allow(clippy::too_many_arguments)]
         fn $wrapper($($arg: $ty),*) -> Result<$ret, Error> {
-            guard(|| $inner($($arg),*))
+            guard(|| $inner($($arg.into()),*))
         }
     };
 }
 
-guarded!(g_to_html(source: String) -> String => to_html);
-guarded!(g_to_markdown(source: String) -> String => to_markdown);
-guarded!(g_to_plain_text(source: String) -> String => to_plain_text);
-guarded!(g_to_ansi(source: String) -> String => to_ansi);
-guarded!(g_to_carve(source: String) -> String => to_carve);
-guarded!(g_from_markdown_json(ruby: &Ruby, source: String) -> String =>? from_markdown_json);
-guarded!(g_to_ast_json(source: String) -> String => to_ast_json);
+struct Source(String);
+
+impl TryConvert for Source {
+    fn try_convert(value: Value) -> Result<Self, Error> {
+        let source = RString::try_convert(value)?;
+        let encoding: Value = source.funcall("encoding", ())?;
+        let name: String = encoding.funcall("name", ())?;
+        let text = if name == "ASCII-8BIT" {
+            String::from_utf8_lossy(unsafe { source.as_slice() }).into_owned()
+        } else {
+            let ruby = Ruby::get_with(source);
+            let options = ruby.hash_new();
+            options.aset(ruby.to_symbol("invalid"), ruby.to_symbol("replace"))?;
+            options.aset(ruby.to_symbol("undef"), ruby.to_symbol("replace"))?;
+            options.aset(ruby.to_symbol("replace"), "\u{FFFD}")?;
+            let encoded: RString = source.funcall("encode", ("UTF-8", magnus::KwArgs(options)))?;
+            encoded.to_string()?
+        };
+        Ok(Self(text))
+    }
+}
+
+impl From<Source> for String {
+    fn from(source: Source) -> Self {
+        source.0
+    }
+}
+
+guarded!(g_to_html(source: Source) -> String => to_html);
+guarded!(g_to_markdown(source: Source) -> String => to_markdown);
+guarded!(g_to_plain_text(source: Source) -> String => to_plain_text);
+guarded!(g_to_ansi(source: Source) -> String => to_ansi);
+guarded!(g_to_carve(source: Source, align_tables: bool) -> String => to_carve);
+guarded!(
+    g_select_include_region(ruby: &Ruby, source: Source, name: String, mode: String) -> Value
+        =>? select_include_region
+);
+guarded!(g_from_markdown_json(ruby: &Ruby, source: Source) -> String =>? from_markdown_json);
+guarded!(g_to_ast_json(source: Source) -> String => to_ast_json);
 guarded!(g_extension_names() -> Vec<String> => extension_names);
 guarded!(g_panic_probe() -> String => panic_probe);
 guarded!(
-    g_stamp_needs_review(source: String, current_version: Option<String>) -> bool
+    g_stamp_needs_review(source: Source, current_version: Option<String>) -> bool
         => stamp_needs_review
 );
 guarded!(
-    g_from_html_json(ruby: &Ruby, source: String, mode: String) -> String =>? from_html_json
+    g_from_html_json(ruby: &Ruby, source: Source, mode: String) -> String =>? from_html_json
 );
-guarded!(g_read_stamp(ruby: &Ruby, source: String) -> Value =>? read_stamp);
+guarded!(g_read_stamp(ruby: &Ruby, source: Source) -> Value =>? read_stamp);
 guarded!(
-    g_to_html_with_extensions(ruby: &Ruby, source: String, names: RArray) -> String
+    g_to_html_with_extensions(ruby: &Ruby, source: Source, names: RArray) -> String
         =>? to_html_with_extensions
 );
 guarded!(
     g_to_html_full(
         ruby: &Ruby,
-        source: String,
+        source: Source,
         names: RArray,
         mode: String,
         renderers: RHash
@@ -886,7 +983,7 @@ guarded!(
 guarded!(
     g_to_html_full_with_symbols(
         ruby: &Ruby,
-        source: String,
+        source: Source,
         names: RArray,
         mode: String,
         renderers: RHash,
@@ -896,7 +993,7 @@ guarded!(
 guarded!(
     g_to_html_safe(
         ruby: &Ruby,
-        source: String,
+        source: Source,
         names: RArray,
         mode: String,
         renderers: RHash,
@@ -909,7 +1006,7 @@ guarded!(
 guarded!(
     g_render_with_includes_json(
         ruby: &Ruby,
-        source: String,
+        source: Source,
         root: String,
         source_path: String,
         target: String,
@@ -950,7 +1047,11 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     module.define_singleton_method("to_markdown", function!(g_to_markdown, 1))?;
     module.define_singleton_method("to_plain_text", function!(g_to_plain_text, 1))?;
     module.define_singleton_method("to_ansi", function!(g_to_ansi, 1))?;
-    module.define_singleton_method("to_carve", function!(g_to_carve, 1))?;
+    module.define_singleton_method("_to_carve", function!(g_to_carve, 2))?;
+    module.define_singleton_method(
+        "_select_include_region",
+        function!(g_select_include_region, 3),
+    )?;
     module.define_singleton_method(
         "_render_with_includes_json",
         function!(g_render_with_includes_json, 15),

data/lib/carve/version.rb

@@ -8,5 +8,5 @@ module Carve
   # compares it against ext/carve/Cargo.toml and against the newest cut
   # CHANGELOG section on every run, and .github/workflows/release.yml refuses to
   # publish a gem whose version is not the tag being released.
-  VERSION = "0.1.8"
+  VERSION = "0.1.10"
 end

data/lib/carve.rb

@@ -8,11 +8,30 @@
 require "json"
 require_relative "carve/version"
 
-# Load the compiled native extension. Built by `rake compile` to
-# lib/carve/carve.so (or .bundle on macOS).
-require_relative "carve/carve"
+# Load the compiled native extension. A precompiled platform gem ships one per
+# Ruby ABI under lib/carve/<major.minor>/; a source install and `rake compile`
+# build lib/carve/carve.so (or .bundle on macOS).
+# Chosen by directory rather than by rescuing LoadError, so a binary that is
+# present but cannot load (an older glibc, say) reports its own error.
+abi = RUBY_VERSION[/\A\d+\.\d+/]
+if File.directory?(File.join(__dir__, "carve", abi))
+  require_relative "carve/#{abi}/carve"
+else
+  require_relative "carve/carve"
+end
 
 module Carve
+  # Raised by .select_include_region when the region is missing or a marker is
+  # malformed, unpaired or duplicated. +rule+ is the engine's warning rule id.
+  class IncludeRegionError < ArgumentError
+    attr_reader :rule
+
+    def initialize(rule, name)
+      @rule = rule
+      super("#{rule}: region #{name.inspect} is missing or its markers are malformed")
+    end
+  end
+
   # Extension names the native binding understands.
   #
   # Taken from the engine itself rather than typed out here. This was a literal
@@ -55,7 +74,8 @@ module Carve
     #
     # Returns +{value:, warnings:, dependencies:, suppressedWarnings:}+. Paths
     # in +warnings+ and +dependencies+ are relative to the root, so a report can
-    # be shown to a reader as it stands.
+    # be shown to a reader as it stands. Each warning's +includedBy+ lists the
+    # directives that reached its file, top-level first, as +{file:, line:, column:}+.
     #
     # Every render option +to_html+ takes is accepted and reaches the included
     # children too: an extension, a symbol map or a profile means the same thing
@@ -130,6 +150,28 @@ module Carve
       )
     end
 
+    # Format +source+ into canonical Carve. A writer refusal returns the source
+    # as authored. +align_tables:+ pads table cells into aligned columns.
+    def to_carve(source, align_tables: false)
+      _to_carve(source, align_tables ? true : false)
+    end
+
+    # Resolve <tt>@region:name</tt> in a file's text with the engine's marker
+    # rules, so an editor jumping to a region agrees with the render.
+    #
+    #   Carve.select_include_region(text, "setup", mode: :carve) # => 3..4
+    #
+    # Returns the 1-based, inclusive Range of content lines; an empty region is
+    # an empty Range such as +2..1+. +mode: :carve+ accepts only
+    # <tt>%% #region</tt> markers, +mode: :code+ also the source-comment forms
+    # of an +@code+ include. Raises IncludeRegionError otherwise.
+    def select_include_region(source, name, mode:)
+      result = _select_include_region(source, name.to_s, mode.to_s)
+      raise IncludeRegionError.new(result, name.to_s) if result.is_a?(String)
+
+      result[0]..result[1]
+    end
+
     # Import HTML or Markdown into canonical Carve. Both methods return the
     # shared migration shape `{ value:, report: }`.
     def from_html(source, mode: :safe)
@@ -319,9 +361,10 @@ module Carve
     #   # => {type: "document",
     #   #     children: [{type: "heading", level: 1,
     #   #                 children: [{type: "text", value: "Hi"}], attrs: nil}],
-    #   #     srcByteLength: 4}
+    #   #     srcByteLength: 4, astVersion: "1.2"}
     #
-    # The root carries exactly +:type+, +:children+ and +:srcByteLength+ (spec
+    # The root carries exactly +:type+, +:children+, +:srcByteLength+ and
+    # +:astVersion+ (spec
     # PART 12 §7). Frontmatter and footnote definitions are block nodes in
     # +:children+, not root fields: a root field cannot carry the position §4
     # requires of every node, and both are source an editor navigates to.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: carve-lang
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - markup-carve
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-14 00:00:00.000000000 Z
+date: 2026-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys