tg_geometry 0.1.0

data/spec/block_6_index_build_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Release Core Block 6 Index build skeleton" do
+  let(:geom) { TG::Geometry.parse_wkt("POINT (1 2)") }
+
+  it "builds an empty immutable index" do
+    index = TG::Geometry::Index.build([], via: :geojson, strategy: :flat)
+
+    expect(index).to be_a(TG::Geometry::Index)
+    expect(index).to be_frozen
+    expect(index.size).to eq(0)
+    expect(index.strategy).to eq(:flat)
+    expect(index.predicate).to eq(:covers)
+    expect(index.bbox).to be_nil
+  end
+
+  it "requires entries to be an Array" do
+    expect { TG::Geometry::Index.build("bad", via: :geojson, strategy: :flat) }
+      .to raise_error(TypeError)
+  end
+
+  it "requires each entry to be a two-element Array" do
+    expect { TG::Geometry::Index.build([:bad], via: :geojson, strategy: :flat) }
+      .to raise_error(TypeError)
+
+    expect { TG::Geometry::Index.build([[1, "{}", :extra]], via: :geojson, strategy: :flat) }
+      .to raise_error(TG::Geometry::ArgumentError)
+  end
+
+  it "rejects nil ids" do
+    expect { TG::Geometry::Index.build([[nil, "{}"]], via: :geojson, strategy: :flat) }
+      .to raise_error(TG::Geometry::ArgumentError, /id cannot be nil/)
+  end
+
+  it "allows false ids and duplicate ids" do
+    index = TG::Geometry::Index.build([[false, geom], [:same, geom], [:same, geom]],
+                                      via: :geom,
+                                      strategy: :flat)
+
+    expect(index.size).to eq(3)
+    expect(index.bbox).to be_a(TG::Geometry::Rect)
+  end
+
+  it "validates via, strategy, predicate, and geometry_index symbols" do
+    expect { TG::Geometry::Index.build([], via: :shape, strategy: :flat) }
+      .to raise_error(TG::Geometry::ArgumentError)
+    expect { TG::Geometry::Index.build([], via: :geojson, strategy: :bogus) }
+      .to raise_error(TG::Geometry::ArgumentError)
+    expect { TG::Geometry::Index.build([], via: :geojson, strategy: :flat, predicate: :touches) }
+      .to raise_error(TG::Geometry::ArgumentError)
+    expect { TG::Geometry::Index.build([], via: :geojson, strategy: :flat, geometry_index: :packed) }
+      .to raise_error(TG::Geometry::ArgumentError)
+  end
+
+  it "requires String values for owned geometry modes in the block 6 skeleton" do
+    expect { TG::Geometry::Index.build([[1, Object.new]], via: :geojson, strategy: :flat) }
+      .to raise_error(TypeError)
+    expect { TG::Geometry::Index.build([[1, Object.new]], via: :wkb, strategy: :flat) }
+      .to raise_error(TypeError)
+  end
+
+  it "requires Geom values for via: :geom" do
+    expect { TG::Geometry::Index.build([[1, "not geom"]], via: :geom, strategy: :flat) }
+      .to raise_error(TypeError)
+  end
+
+  it "cleans up immediately after failed build validation" do
+    entries = [[1, geom], [nil, geom], [2, geom]]
+
+    expect { TG::Geometry::Index.build(entries, via: :geom, strategy: :flat) }
+      .to raise_error(TG::Geometry::ArgumentError)
+
+    GC.start
+    GC.compact if GC.respond_to?(:compact)
+  end
+
+  it "survives GC.stress build/free lifecycle" do
+    old_stress = GC.stress
+    GC.stress = true
+
+    10.times do
+      index = TG::Geometry::Index.build([[false, geom], [:dup, geom], [:dup, geom]],
+                                        via: :geom,
+                                        strategy: :rtree,
+                                        predicate: :contains,
+                                        geometry_index: :ystripes)
+      expect(index).to be_frozen
+      expect(index.size).to eq(3)
+      expect(index.strategy).to eq(:rtree)
+      expect(index.predicate).to eq(:contains)
+    end
+  ensure
+    GC.stress = old_stress
+  end
+
+  it "survives GC.compact build/free lifecycle" do
+    index = TG::Geometry::Index.build([["id", geom]], via: :geom, strategy: :flat)
+
+    GC.start
+    GC.compact if GC.respond_to?(:compact)
+
+    expect(index.size).to eq(1)
+    expect(index.bbox).to be_a(TG::Geometry::Rect)
+  end
+
+  it "keeps public allocate disabled" do
+    expect { TG::Geometry::Index.allocate }.to raise_error(TypeError)
+  end
+end

data/spec/block_7_index_owned_geometry_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "objspace"
+
+RSpec.describe "Release Core Block 7 Index owned geometry ingestion" do
+  let(:geojson_a) do
+    '{"type":"Polygon","coordinates":[[[0,0],[2,0],[2,2],[0,2],[0,0]]]}'
+  end
+
+  let(:geojson_b) do
+    '{"type":"Polygon","coordinates":[[[10,10],[12,10],[12,12],[10,12],[10,10]]]}'
+  end
+
+  let(:geojson_c) do
+    '{"type":"Polygon","coordinates":[[[-5,-4],[-2,-4],[-2,-1],[-5,-1],[-5,-4]]]}'
+  end
+
+  let(:wkb_a) { TG::Geometry.parse_geojson(geojson_a).to_wkb }
+  let(:wkb_b) { TG::Geometry.parse_geojson(geojson_b).to_wkb }
+  let(:wkb_c) { TG::Geometry.parse_geojson(geojson_c).to_wkb }
+
+  it "builds an immutable index via: :geojson and computes the union bbox" do
+    index = TG::Geometry::Index.build([[:a, geojson_a], [:b, geojson_b], [:c, geojson_c]],
+                                      via: :geojson,
+                                      strategy: :flat)
+
+    expect(index).to be_frozen
+    expect(index.size).to eq(3)
+    expect(index.strategy).to eq(:flat)
+    expect(index.predicate).to eq(:covers)
+
+    bbox = index.bbox
+    expect(bbox.min_x).to eq(-5.0)
+    expect(bbox.min_y).to eq(-4.0)
+    expect(bbox.max_x).to eq(12.0)
+    expect(bbox.max_y).to eq(12.0)
+  end
+
+  it "builds an immutable index via: :wkb and treats input strings as bytes" do
+    index = TG::Geometry::Index.build([[:a, wkb_a], [:b, wkb_b], [:c, wkb_c]],
+                                      via: :wkb,
+                                      strategy: :flat,
+                                      geometry_index: :natural)
+
+    expect(index).to be_frozen
+    expect(index.size).to eq(3)
+
+    bbox = index.bbox
+    expect(bbox.min_x).to eq(-5.0)
+    expect(bbox.min_y).to eq(-4.0)
+    expect(bbox.max_x).to eq(12.0)
+    expect(bbox.max_y).to eq(12.0)
+  end
+
+  it "raises ParseError for malformed geojson at first, middle, and last positions" do
+    malformed = "not geojson"
+
+    expect do
+      TG::Geometry::Index.build([[1, malformed], [2, geojson_a], [3, geojson_b]],
+                                via: :geojson,
+                                strategy: :flat)
+    end.to raise_error(TG::Geometry::ParseError)
+
+    expect do
+      TG::Geometry::Index.build([[1, geojson_a], [2, malformed], [3, geojson_b]],
+                                via: :geojson,
+                                strategy: :flat)
+    end.to raise_error(TG::Geometry::ParseError)
+
+    expect do
+      TG::Geometry::Index.build([[1, geojson_a], [2, geojson_b], [3, malformed]],
+                                via: :geojson,
+                                strategy: :flat)
+    end.to raise_error(TG::Geometry::ParseError)
+
+    GC.start
+    GC.compact if GC.respond_to?(:compact)
+  end
+
+  it "raises ParseError for malformed wkb at first, middle, and last positions" do
+    malformed = "not wkb".b
+
+    expect do
+      TG::Geometry::Index.build([[1, malformed], [2, wkb_a], [3, wkb_b]],
+                                via: :wkb,
+                                strategy: :flat)
+    end.to raise_error(TG::Geometry::ParseError)
+
+    expect do
+      TG::Geometry::Index.build([[1, wkb_a], [2, malformed], [3, wkb_b]],
+                                via: :wkb,
+                                strategy: :flat)
+    end.to raise_error(TG::Geometry::ParseError)
+
+    expect do
+      TG::Geometry::Index.build([[1, wkb_a], [2, wkb_b], [3, malformed]],
+                                via: :wkb,
+                                strategy: :flat)
+    end.to raise_error(TG::Geometry::ParseError)
+
+    GC.start
+    GC.compact if GC.respond_to?(:compact)
+  end
+
+  it "disposes already parsed owned geometries after partial build failure" do
+    20.times do
+      expect do
+        TG::Geometry::Index.build([[1, geojson_a], [2, geojson_b], [3, "bad geojson"]],
+                                  via: :geojson,
+                                  strategy: :flat)
+      end.to raise_error(TG::Geometry::ParseError)
+    end
+
+    GC.start
+    GC.compact if GC.respond_to?(:compact)
+  end
+
+  it "reports owned geometry native memory through ObjectSpace.memsize_of" do
+    borrowed_geom = TG::Geometry.parse_geojson(geojson_a)
+    borrowed = TG::Geometry::Index.build([[:a, borrowed_geom]], via: :geom, strategy: :flat)
+    owned = TG::Geometry::Index.build([[:a, geojson_a]], via: :geojson, strategy: :flat)
+
+    expect(ObjectSpace.memsize_of(owned)).to be > ObjectSpace.memsize_of(borrowed)
+  end
+
+  it "survives GC.stress and GC.compact for owned geometry build/free" do
+    old_stress = GC.stress
+    GC.stress = true
+
+    5.times do
+      index = TG::Geometry::Index.build([[:a, geojson_a], [:b, geojson_b]],
+                                        via: :geojson,
+                                        strategy: :flat)
+      expect(index.size).to eq(2)
+      expect(index.bbox).to be_a(TG::Geometry::Rect)
+    end
+  ensure
+    GC.stress = old_stress
+    GC.start
+    GC.compact if GC.respond_to?(:compact)
+  end
+end

data/spec/block_8_index_borrowed_geometry_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "json"
+require "objspace"
+require "weakref"
+
+RSpec.describe "Release Core Block 8 Index borrowed geometry ingestion" do
+  let(:polygon_a_wkt) { "POLYGON ((0 0, 2 0, 2 2, 0 2, 0 0))" }
+  let(:polygon_b_wkt) { "POLYGON ((10 10, 12 10, 12 12, 10 12, 10 10))" }
+
+  it "builds an immutable index via: :geom using borrowed TG::Geometry::Geom objects" do
+    geom_a = TG::Geometry.parse_wkt(polygon_a_wkt)
+    geom_b = TG::Geometry.parse_wkt(polygon_b_wkt)
+
+    index = TG::Geometry::Index.build([[:a, geom_a], [:b, geom_b]],
+                                      via: :geom,
+                                      strategy: :flat)
+
+    expect(index).to be_a(TG::Geometry::Index)
+    expect(index).to be_frozen
+    expect(index.size).to eq(2)
+    expect(index.strategy).to eq(:flat)
+    expect(index.predicate).to eq(:covers)
+
+    bbox = index.bbox
+    expect(bbox.min_x).to eq(0.0)
+    expect(bbox.min_y).to eq(0.0)
+    expect(bbox.max_x).to eq(12.0)
+    expect(bbox.max_y).to eq(12.0)
+  end
+
+  it "keeps borrowed geometry owners alive after caller drops local references" do
+    geom = TG::Geometry.parse_wkt(polygon_a_wkt)
+    weak_geom = WeakRef.new(geom)
+
+    index = TG::Geometry::Index.build([[:zone, geom]], via: :geom, strategy: :flat)
+    geom = nil
+
+    GC.start(full_mark: true, immediate_sweep: true)
+    GC.compact if GC.respond_to?(:compact)
+    GC.start(full_mark: true, immediate_sweep: true)
+
+    expect(weak_geom.weakref_alive?).to be(true)
+    expect(index.bbox.max_x).to eq(2.0)
+  end
+
+  it "allows the borrowed geometry wrapper to be collected only after the index is released" do
+    geom = TG::Geometry.parse_wkt(polygon_a_wkt)
+    weak_geom = WeakRef.new(geom)
+
+    index = TG::Geometry::Index.build([[:zone, geom]], via: :geom, strategy: :flat)
+    geom = nil
+
+    GC.start(full_mark: true, immediate_sweep: true)
+    GC.compact if GC.respond_to?(:compact)
+    expect(weak_geom.weakref_alive?).to be(true)
+
+    index = nil
+    5.times do
+      GC.start(full_mark: true, immediate_sweep: true)
+      GC.compact if GC.respond_to?(:compact)
+    end
+
+    expect(weak_geom.weakref_alive?).to be_falsey
+  end
+
+  it "does not free borrowed native geometry when the index is disposed" do
+    geom = TG::Geometry.parse_wkt(polygon_a_wkt)
+
+    index = TG::Geometry::Index.build([[:zone, geom]], via: :geom, strategy: :flat)
+    expect(index.size).to eq(1)
+
+    index = nil
+    GC.start(full_mark: true, immediate_sweep: true)
+    GC.compact if GC.respond_to?(:compact)
+
+    expect(geom.bbox.max_x).to eq(2.0)
+    expect(geom.covers_xy?(1.0, 1.0)).to be(true)
+  end
+
+  it "does not count borrowed native geometry bytes in Index ObjectSpace.memsize_of" do
+    point_count = 1_000
+    coordinates = Array.new(point_count) do |i|
+      angle = (2.0 * Math::PI * i) / point_count
+      [Math.cos(angle), Math.sin(angle)]
+    end
+    coordinates << coordinates.first
+
+    geojson = JSON.generate(type: "Polygon", coordinates: [coordinates])
+    geom = TG::Geometry.parse_geojson(geojson)
+
+    borrowed_index = TG::Geometry::Index.build([[:large, geom]], via: :geom, strategy: :flat)
+    owned_index = TG::Geometry::Index.build([[:large, geojson]], via: :geojson, strategy: :flat)
+
+    expect(ObjectSpace.memsize_of(geom)).to be > 10_000
+    expect(ObjectSpace.memsize_of(borrowed_index)).to be < ObjectSpace.memsize_of(geom)
+    expect(ObjectSpace.memsize_of(owned_index)).to be > ObjectSpace.memsize_of(borrowed_index)
+  end
+
+  it "requires TG::Geometry::Geom values for via: :geom" do
+    expect do
+      TG::Geometry::Index.build([[:bad, polygon_a_wkt]], via: :geom, strategy: :flat)
+    end.to raise_error(TypeError)
+  end
+end

data/spec/block_9_flat_query_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Release Core Block 9 flat query engine" do
+  let(:zone_a) { TG::Geometry.parse_wkt("POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))") }
+  let(:zone_b) { TG::Geometry.parse_wkt("POLYGON ((5 5, 12 5, 12 12, 5 12, 5 5))") }
+  let(:zone_c) { TG::Geometry.parse_wkt("POLYGON ((20 20, 22 20, 22 22, 20 22, 20 20))") }
+
+  it "finds the first covering id by insertion order" do
+    index = TG::Geometry::Index.build([[:a, zone_a], [:b, zone_b]], via: :geom, strategy: :flat)
+
+    expect(index.find_covering(6, 6)).to eq(:a)
+    expect(index.find_covering(11, 11)).to eq(:b)
+    expect(index.find_covering(100, 100)).to be_nil
+  end
+
+  it "returns all covering ids in insertion order, including duplicates and false ids" do
+    index = TG::Geometry::Index.build([[false, zone_a], [:dup, zone_a], [:dup, zone_b]],
+                                      via: :geom,
+                                      strategy: :flat)
+
+    expect(index.covering_ids(6, 6)).to eq([false, :dup, :dup])
+    expect(index.covering_ids(1, 1)).to eq([false, :dup])
+  end
+
+  it "distinguishes :covers from strict :contains on boundaries" do
+    covers_index = TG::Geometry::Index.build([[:zone, zone_a]], via: :geom, strategy: :flat)
+    contains_index = TG::Geometry::Index.build([[:zone, zone_a]],
+                                               via: :geom,
+                                               strategy: :flat,
+                                               predicate: :contains)
+
+    expect(covers_index.find_covering(0, 5)).to eq(:zone)
+    expect(contains_index.find_covering(0, 5)).to be_nil
+    expect(contains_index.find_covering(5, 5)).to eq(:zone)
+  end
+
+  it "returns exact-filtered intersecting rect ids in insertion order" do
+    index = TG::Geometry::Index.build([[:a, zone_a], [:b, zone_b], [:c, zone_c]],
+                                      via: :geom,
+                                      strategy: :flat)
+
+    expect(index.intersecting_rect(9, 9, 11, 11)).to eq(%i[a b])
+    expect(index.intersecting_rect(30, 30, 31, 31)).to eq([])
+  end
+
+  it "handles empty indexes" do
+    index = TG::Geometry::Index.build([], via: :geojson, strategy: :flat)
+
+    expect(index.find_covering(1, 1)).to be_nil
+    expect(index.covering_ids(1, 1)).to eq([])
+    expect(index.intersecting_rect(0, 0, 1, 1)).to eq([])
+  end
+
+  it "rejects non-finite point and rect query coordinates" do
+    index = TG::Geometry::Index.build([[:a, zone_a]], via: :geom, strategy: :flat)
+
+    expect { index.find_covering(Float::NAN, 1) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { index.covering_ids(1, Float::INFINITY) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { index.intersecting_rect(0, 0, Float::INFINITY, 1) }
+      .to raise_error(TG::Geometry::ArgumentError)
+    expect { index.intersecting_rect(2, 0, 1, 1) }.to raise_error(TG::Geometry::ArgumentError)
+  end
+end

data/spec/expansion_a_auto_strategy_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Expansion Block A auto strategy status" do
+  it "does not expose :auto in the first public release" do
+    entries = [[1, '{"type":"Polygon","coordinates":[[[0,0],[1,0],[1,1],[0,1],[0,0]]]}']]
+
+    expect(TG::Geometry::Index).not_to respond_to(:auto_strategy_threshold)
+    expect do
+      TG::Geometry::Index.build(entries, via: :geojson, strategy: :auto)
+    end.to raise_error(TG::Geometry::ArgumentError)
+  end
+end

data/spec/expansion_b_registry_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe TG::Geometry::Registry do
+  let(:zone_a) do
+    '{"type":"Polygon","coordinates":[[[0,0],[10,0],[10,10],[0,10],[0,0]]]}'
+  end
+
+  let(:zone_b) do
+    '{"type":"Polygon","coordinates":[[[20,20],[30,20],[30,30],[20,30],[20,20]]]}'
+  end
+
+  it "builds and swaps immutable indexes on reload" do
+    current_entries = [[:a, zone_a]]
+    registry = described_class.new(source: -> { current_entries }, via: :geojson, strategy: :flat)
+    old_index = registry.reload!
+
+    expect(registry.find_covering(5, 5)).to eq(:a)
+
+    current_entries = [[:b, zone_b]]
+    new_index = registry.reload!
+
+    expect(old_index.find_covering(5, 5)).to eq(:a)
+    expect(new_index.find_covering(25, 25)).to eq(:b)
+    expect(registry.find_covering(25, 25)).to eq(:b)
+  end
+
+  it "supports subclass source blocks" do
+    entries = [[:a, zone_a]]
+    klass = Class.new(described_class) do
+      source { entries }
+    end
+
+    registry = klass.new(via: :geojson, strategy: :flat)
+    registry.reload!
+
+    expect(registry.loaded?).to eq(true)
+    expect(registry.covering_ids(5, 5)).to eq([:a])
+  end
+
+  it "raises before reload" do
+    registry = described_class.new(entries: [[:a, zone_a]], via: :geojson, strategy: :flat)
+
+    expect { registry.find_covering(5, 5) }.to raise_error(TG::Geometry::Error)
+  end
+end

data/spec/expansion_c_active_record_source_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe TG::Geometry::ActiveRecordSource do
+  Record = Struct.new(:id, :geojson, keyword_init: true)
+
+  let(:zone) do
+    '{"type":"Polygon","coordinates":[[[0,0],[10,0],[10,10],[0,10],[0,0]]]}'
+  end
+
+  it "builds entries from enumerable records without requiring Rails" do
+    records = [Record.new(id: :a, geojson: zone)]
+
+    expect(described_class.call(records, id: :id, geometry: :geojson)).to eq([[:a, zone]])
+  end
+
+  it "supports proc readers" do
+    records = [Record.new(id: :a, geojson: zone)]
+
+    entries = described_class.call(
+      records,
+      id: ->(record) { record.id.to_s },
+      geometry: ->(record) { record.geojson }
+    )
+
+    expect(entries).to eq([["a", zone]])
+  end
+
+  it "can feed a Registry source" do
+    records = [Record.new(id: :a, geojson: zone)]
+    registry = TG::Geometry::Registry.new(
+      source: described_class.registry_source(records, id: :id, geometry: :geojson),
+      via: :geojson,
+      strategy: :flat
+    )
+
+    registry.reload!
+
+    expect(registry.find_covering(5, 5)).to eq(:a)
+  end
+end

data/spec/expansion_d_format_coverage_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Expansion Block D format coverage" do
+  it "roundtrips Hex" do
+    geom = TG::Geometry.parse_wkt("POINT (1 2)")
+    hex = geom.to_hex
+
+    expect(hex.encoding).to eq(Encoding::UTF_8)
+    expect(TG::Geometry.parse_hex(hex).to_wkt).to eq("POINT(1 2)")
+  end
+
+  it "roundtrips GeoBIN" do
+    geom = TG::Geometry.parse_wkt("POINT (1 2)")
+    geobin = geom.to_geobin
+
+    expect(geobin.encoding).to eq(Encoding::ASCII_8BIT)
+    expect(TG::Geometry.parse_geobin(geobin).to_wkt).to eq("POINT(1 2)")
+  end
+
+  it "returns raw extra_json without JSON parsing" do
+    geom = TG::Geometry.parse_geojson(
+      '{"type":"Feature","properties":{"name":"a"},"geometry":{"type":"Point","coordinates":[1,2]}}'
+    )
+
+    expect(geom.extra_json).to eq('{"properties":{"name":"a"}}')
+    expect(geom.extra_json).to be_a(String)
+  end
+end

data/spec/expansion_e_low_level_geometry_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Expansion Block E low-level geometry wrappers" do
+  it "exposes Point coordinates without constructing a mutable point wrapper" do
+    geom = TG::Geometry.parse_wkt("POINT (1 2)")
+
+    expect(geom.point).to eq([1.0, 2.0])
+    expect(geom.line).to be_nil
+    expect(geom.polygon).to be_nil
+  end
+
+  it "exposes borrowed LineString accessors while keeping the parent Geom alive" do
+    geom = TG::Geometry.parse_wkt("LINESTRING (0 0, 3 4)")
+    line = geom.line
+
+    expect(line).to be_a(TG::Geometry::Line)
+    expect(line).to be_frozen
+    expect(line.num_points).to eq(2)
+    expect(line.num_segments).to eq(1)
+    expect(line.point_at(1)).to eq([3.0, 4.0])
+    expect(line.points).to eq([[0.0, 0.0], [3.0, 4.0]])
+    expect(line.length).to eq(5.0)
+    expect(line.bbox.center).to eq([1.5, 2.0])
+
+    geom = nil
+    GC.start
+    GC.compact if GC.respond_to?(:compact)
+
+    expect(line.length).to eq(5.0)
+    expect(line.points).to eq([[0.0, 0.0], [3.0, 4.0]])
+  end
+
+  it "exposes borrowed Polygon and Ring accessors without freeing child pointers" do
+    geom = TG::Geometry.parse_wkt(
+      "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (2 2, 4 2, 4 4, 2 4, 2 2))"
+    )
+    polygon = geom.polygon
+    exterior = polygon.exterior_ring
+    hole = polygon.hole_at(0)
+
+    expect(polygon).to be_a(TG::Geometry::Polygon)
+    expect(polygon).to be_frozen
+    expect(polygon.num_holes).to eq(1)
+    expect(polygon.holes.map(&:class)).to eq([TG::Geometry::Ring])
+    expect(polygon.bbox.center).to eq([5.0, 5.0])
+
+    expect(exterior).to be_a(TG::Geometry::Ring)
+    expect(exterior).to be_frozen
+    expect(exterior.num_points).to eq(5)
+    expect(exterior.num_segments).to eq(4)
+    expect(exterior.point_at(2)).to eq([10.0, 10.0])
+    expect(exterior.points.first).to eq([0.0, 0.0])
+    expect(exterior.area).to eq(100.0)
+    expect(exterior.perimeter).to eq(40.0)
+    expect(exterior.convex?).to be(true)
+    expect(hole.area).to eq(4.0)
+
+    geom = nil
+    polygon = nil
+    GC.start
+    GC.compact if GC.respond_to?(:compact)
+
+    expect(exterior.area).to eq(100.0)
+    expect(hole.perimeter).to eq(8.0)
+  end
+
+  it "keeps low-level wrapper allocation private" do
+    expect { TG::Geometry::Line.allocate }.to raise_error(TypeError)
+    expect { TG::Geometry::Ring.allocate }.to raise_error(TypeError)
+    expect { TG::Geometry::Polygon.allocate }.to raise_error(TypeError)
+  end
+
+  it "rejects out-of-range child indexes" do
+    line = TG::Geometry.parse_wkt("LINESTRING (0 0, 1 1)").line
+    polygon = TG::Geometry.parse_wkt("POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))").polygon
+
+    expect { line.point_at(2) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { polygon.hole_at(0) }.to raise_error(TG::Geometry::ArgumentError)
+  end
+end

data/spec/expansion_i_ractor_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Expansion Block I Ractor investigation" do
+  it "keeps native wrappers outside Ractor shareability claims" do
+    skip "Ractor is not available on this Ruby" unless defined?(Ractor)
+
+    geom = TG::Geometry.parse_wkt("POINT (1 2)")
+    rect = TG::Geometry::Rect.new(0, 0, 1, 1)
+    index = TG::Geometry::Index.build(
+      [[:zone, '{"type":"Polygon","coordinates":[[[0,0],[1,0],[1,1],[0,1],[0,0]]]}']],
+      via: :geojson,
+      strategy: :flat
+    )
+
+    expect(Ractor.shareable?(geom)).to be(false)
+    expect(Ractor.shareable?(rect)).to be(false)
+    expect(Ractor.shareable?(index)).to be(false)
+
+    expect { Ractor.make_shareable(geom) }.to raise_error(Ractor::Error)
+    expect { Ractor.make_shareable(rect) }.to raise_error(Ractor::Error)
+    expect { Ractor.make_shareable(index) }.to raise_error(Ractor::Error)
+  end
+end