tg_geometry 0.1.0 → 0.2.0

data/ext/tg_geometry/vendor/json/json.h

@@ -0,0 +1,207 @@
+// https://github.com/tidwall/json.c
+//
+// Copyright 2023 Joshua J Baker. All rights reserved.
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+#ifndef JSON_H
+#define JSON_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+enum json_type { 
+    JSON_NULL,
+    JSON_FALSE,
+    JSON_NUMBER,
+    JSON_STRING,
+    JSON_TRUE,
+    JSON_ARRAY,
+    JSON_OBJECT,
+};
+
+struct json { void *priv[4]; };
+
+struct json_valid {
+    bool valid;
+    size_t pos;
+};
+
+// json_valid returns true if the input is valid json data.
+bool json_valid(const char *json_str);
+bool json_validn(const char *json_str, size_t len);
+struct json_valid json_valid_ex(const char *json_str, int opts);
+struct json_valid json_validn_ex(const char *json_str, size_t len, int opts);
+
+// json_parse parses the input data and returns a json value.
+//
+// This function expects that the json is well-formed, and does not validate.
+// Invalid json is safe and will not cause program errors, but it may return
+// unexpected results. If you are consuming JSON from an unpredictable source
+// then you may want to use the 'json_valid' function first.
+// 
+// It's important to note that the resulting 'struct json' is backed by the
+// same memory as json_str, thus a 'struct json' cannot outlive the original
+// json_str. Attempting to use  any of the json_*(struct json...) functions on
+// the result, beyond the lifetime of the originating 'json_str', then it will
+// likely result in a memory fault or some other type of undefined corruption.
+struct json json_parse(const char *json_str);
+struct json json_parsen(const char *json_str, size_t len);
+
+// json_first returns the json's first child.
+//
+// For objects, the key of the first value is returned. For arrays, the first
+// child value is returned. If the input json has no children, or is not an
+// object or array, then a non-existent json value is returned.
+struct json json_first(struct json json);
+
+// json_next returns the json's next child. 
+//
+// This typically follows a 'json_first' call, and is used to iterate over the 
+// children in an object or array. For arrays, each 'json_next' call will
+// return a the next value. For objects, each 'json_next' call alternates over
+// value, key, value  key, value, etc. If there are no more children, then a
+// non-existent json value is returned.
+struct json json_next(struct json json);
+
+// json_exists checks for the existence of json. 
+bool json_exists(struct json json);
+
+// json_type returns the json's type. 
+//
+// Returns one of the following: JSON_NULL, JSON_STRING, JSON_NUMBER,
+// JSON_TRUE, JSON_FALSE, JSON_OBJECT, JSON_ARRAY.
+// For non-existent json, JSON_NULL is returned.
+enum json_type json_type(struct json json);
+
+// json_raw returns the start of the raw json data.
+// 
+// This function may return NULL if the input is non-existent. Also there is
+// no guarentee that this data will be null-terminated C string. If you want to
+// retain this data for longer that the data from the original 'json_parse'
+// call then you should copy it first, such as:
+// 
+//    size_t len = json_raw_length(json);
+//    char *raw = malloc(len+1);
+//    memcpy(raw, json_raw(json), len);
+//    raw[len] = '\0';
+//
+const char *json_raw(struct json json);
+
+// json_raw_length returns the length of the raw json data.
+size_t json_raw_length(struct json json);
+
+// Compare a json's raw data with a C string.
+//
+// This function performs a binary comparison of the characters. It compares
+// each character, one-by-one, of both strings. If they are equal to each
+// other, it continues until the characters differ or until the end of the JSON
+// or a terminating null-character in the C string is reached.
+// Returns -1, 0, +1 for less-than, equal-to, greater-than.
+int json_raw_compare(struct json json, const char *str);
+int json_raw_comparen(struct json json, const char *str, size_t len);
+
+// Compares a json string to the provided C string.
+//
+// This function performs a binary comparison of the characters. It compares
+// each character, one-by-one, of both strings. If they are equal to each
+// other, it continues until the characters differ or until the end of the JSON
+// or a terminating null-character in the C string is reached.
+//
+// If the JSON type is JSON_STRING, then each character that needs to be 
+// unescaped is done so in a streaming manner. ie. without the additional
+// buffering or memory allocations. Of those characters, the ones that are
+// non-ascii codepoints are encoded into their UTF-8 representation, of which
+// those bytes are then compared to the C string.
+// 
+// If the JSON type is not a JSON_STRING, then it performs a binary comparison
+// of the raw JSON to the C string.
+int json_string_compare(struct json json, const char *str);
+int json_string_comparen(struct json json, const char *str, size_t len);
+
+// json_string_length returns the number of characters needed to represent the
+// JSON as a UTF-8 string.
+size_t json_string_length(struct json json);
+
+// json_string_is_escaped returns true if the json is a string that contains
+// an escape sequence.
+bool json_string_is_escaped(struct json json);
+
+// json_string_copy copies a json string into the provided C string buffer.
+//
+// Returns the number of characters, not including the null-terminator, needed
+// to store the JSON into the C string buffer.
+// If the returned length is greater than nbytes-1, then only a parital copy
+// occurred, for example:
+//    
+//    char buf[64];
+//    size_t len = json_string_copy(json, str, sizeof(str));
+//    if (len > sizeof(str)-1) {
+//        // ... copy did not complete ...
+//    }
+//
+size_t json_string_copy(struct json json, char *str, size_t nbytes);
+
+// json_array_get returns the child json element at index. This is to be used
+// on json with the type JSON_ARRAY.
+struct json json_array_get(struct json json, size_t index);
+
+// json_array_count returns the number of elements in a json array.
+size_t json_array_count(struct json json);
+
+// json_object_get returns the json value for its key. This is to be used on
+// json with the type JSON_OBJECT.
+struct json json_object_get(struct json json, const char *key);
+struct json json_object_getn(struct json json, const char *key, size_t len);
+
+// json_get finds json at the provide path.
+//
+// A path is a series of keys separated by a dot.
+//
+//    json_get(json_str, "name");
+//    json_get(json_str, "user.id");
+//
+// The syntax is limited to very basic key names containing only alphanumeric
+// characters, underscores, and dashes. If you need to access keys that have a
+// broader range of characters, you can use the json_object_get and
+// json_array_get functions.
+//
+//    json_str = "{\"notes\": {\"special.info\": \"it's nice outside\"}";
+//    json = json_parse(json_str); 
+//    json = json_object_get(json, "notes"); 
+//    json = json_object_get(json, "special.info");
+//
+struct json json_get(const char *json_str, const char *path);
+struct json json_getn(const char *json_str, size_t len, const char *path);
+
+// json_double returns a json's double value.
+double json_double(struct json json);
+
+// json_int returns a json's int value.
+int json_int(struct json json);
+
+// json_int64 returns a json's int64 value.
+int64_t json_int64(struct json json);
+
+// json_uint64 returns a json's uint64 value.
+uint64_t json_uint64(struct json json);
+
+// json_bool returns a json's boolean value.
+bool json_bool(struct json json);
+
+// json_escape is a utility function for converting a C string into a valid
+// json string. 
+//
+// Returns the number of characters, not including the null-terminator, needed
+// to store the escaped JSON string in the C string buffer.
+// If the returned length is greater than n-1, then only a parital copy
+// occurred. In other words the 
+size_t json_escape(const char *str, char *escaped, size_t n); 
+size_t json_escapen(const char *str, size_t len, char *escaped, size_t n); 
+
+// json_ensure ensures that the json value has been entirely scanned.
+// Only useful for when you need to call json_raw_length on large objects and
+// arrays more than once.
+struct json json_ensure(struct json json);
+
+#endif // JSON_H

data/lib/tg/geometry/registry.rb

@@ -11,9 +11,9 @@ module TG
       }.freeze
 
       class << self
-        def source(&block)
-          if block
-            @source = block
+        def source(&definition)
+          if definition
+            @source = definition
           elsif instance_variable_defined?(:@source)
             @source
           elsif superclass.respond_to?(:source)

data/lib/tg/geometry/version.rb

@@ -2,6 +2,6 @@
 
 module TG
   module Geometry
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/script/vendor_libs.rb

@@ -26,6 +26,14 @@ PINS = {
     sha256: "4afc86cbd3abe03730206031a5aff5b8b29d37b055fc356052f6f06e1d1f9a61",
     target: "rtree",
     files: %w[rtree.c rtree.h LICENSE README.md]
+  },
+  json: {
+    repo: "https://github.com/tidwall/json.c.git",
+    ref: "main",
+    commit: "4aaf99b5c08e4e1364f97500fe5c5d5a2617b4a6",
+    sha256: "059393302de9325ab6ccf79c298234f2b688a59d138103305da317d2d0176fe2",
+    target: "json",
+    files: %w[json.c json.h LICENSE]
   }
 }.freeze
 
@@ -160,9 +168,13 @@ def write_manifest(results)
   File.utime(NORMALIZED_MTIME, NORMALIZED_MTIME, MANIFEST_PATH)
 end
 
-def expected_vendor_results
+def expected_vendor_results(manifest = nil)
+  manifest ||= parse_kv_file(MANIFEST_PATH)
+
   PINS.each_with_object({}) do |(name, pin), results|
-    results[name] = pin.merge(tree_sha256: pin.fetch(:sha256))
+    manifest_sha = manifest["#{name}_tree_sha256"]
+    tree_sha = pin.fetch(:sha256) || manifest_sha
+    results[name] = pin.merge(tree_sha256: tree_sha)
   end
 end
 
@@ -186,6 +198,7 @@ end
 
 def verify_vendor_tree
   failures = []
+  manifest = parse_kv_file(MANIFEST_PATH)
 
   PINS.each do |name, pin|
     target = File.join(VENDOR_DIR, pin.fetch(:target))
@@ -207,12 +220,15 @@ def verify_vendor_tree
     next unless failures.none? { |failure| failure.start_with?("#{name}:") }
 
     actual_sha256 = tree_sha256_for(target)
-    expected_sha256 = pin.fetch(:sha256)
-    failures << "#{name}: tree_sha256 mismatch: expected #{expected_sha256}, got #{actual_sha256}" unless actual_sha256 == expected_sha256
+    expected_sha256 = pin.fetch(:sha256) || manifest["#{name}_tree_sha256"]
+    if expected_sha256.nil? || expected_sha256.empty?
+      failures << "#{name}: tree_sha256 missing from manifest"
+    elsif actual_sha256 != expected_sha256
+      failures << "#{name}: tree_sha256 mismatch: expected #{expected_sha256}, got #{actual_sha256}"
+    end
   end
 
-  expected_results = expected_vendor_results
-  manifest = parse_kv_file(MANIFEST_PATH)
+  expected_results = expected_vendor_results(manifest)
   if manifest.empty?
     failures << "manifest: missing #{MANIFEST_PATH}"
   else

data/spec/{expansion_a_auto_strategy_spec.rb → auto_strategy_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe "Expansion Block A auto strategy status" do
+RSpec.describe "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]]]}']]
 

data/spec/{block_12_batch_packed_spec.rb → batch_packed_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe "Release Core Block 12 packed batch API" do
+RSpec.describe "Packed batch API" 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 ((20 20, 30 20, 30 30, 20 30, 20 20))") }
 

data/spec/{block_20_concurrency_spec.rb → concurrency_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe "Release Core Block 20 concurrency hardening" do
+RSpec.describe "Concurrency hardening" do
   let(:zone_a) { '{"type":"Polygon","coordinates":[[[0,0],[10,0],[10,10],[0,10],[0,0]]]}' }
   let(:zone_b) { '{"type":"Polygon","coordinates":[[[5,5],[15,5],[15,15],[5,15],[5,5]]]}' }
   let(:zone_c) { '{"type":"Polygon","coordinates":[[[100,100],[110,100],[110,110],[100,110],[100,100]]]}' }

data/spec/{block_13_error_hardening_spec.rb → error_hardening_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe "Release Core Block 13 error hardening" do
+RSpec.describe "Error hardening" do
   let(:geojson) { '{"type":"Polygon","coordinates":[[[0,0],[1,0],[1,1],[0,1],[0,0]]]}' }
   let(:wkb) { TG::Geometry.parse_geojson(geojson).to_wkb }
 

data/spec/feature_source_nogvl_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tempfile"
+
+RSpec.describe "FeatureSource no-GVL behavior" do
+  def polygon_feature_json(id, x, y)
+    <<~JSON.chomp
+      {"type":"Feature","properties":{"@id":"zone/#{id}"},"geometry":{"type":"Polygon","coordinates":[[[#{x},#{y}],[#{x + 0.8},#{y}],[#{x + 0.8},#{y + 0.8}],[#{x},#{y + 0.8}],[#{x},#{y}]]]}}
+    JSON
+  end
+
+  def write_large_feature_collection(count)
+    file = Tempfile.new(["tg_geometry_feature_source_nogvl", ".geojson"])
+    file.binmode
+    file.write('{"type":"FeatureCollection","features":[')
+    count.times do |i|
+      file.write(",") unless i.zero?
+      file.write(polygon_feature_json(i, i % 1000, i / 1000))
+    end
+    file.write("]}")
+    file.flush
+    file.close
+    file
+  end
+
+  it "lets other Ruby threads run during large FeatureSource file processing" do
+    count = 40_000
+    file = write_large_feature_collection(count)
+    ticks = 0
+    done = false
+
+    ticker = Thread.new do
+      until done
+        ticks += 1
+        sleep 0.005
+      end
+    end
+
+    index = TG::Geometry::FeatureSource.build_index_file(file.path, strategy: :flat)
+    done = true
+    ticker.join
+
+    expect(index.size).to eq(count)
+    expect(ticks).to be >= 1
+  ensure
+    done = true
+    ticker&.join
+    file&.unlink
+  end
+end

data/spec/feature_source_spec.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "stringio"
+
+RSpec.describe "FeatureSource" do
+  let(:fixture_dir) { File.join(__dir__, "fixtures", "feature_source") }
+  let(:simple_path) { File.join(fixture_dir, "simple_feature_collection.geojson") }
+  let(:simple_json) { File.binread(simple_path) }
+
+  it "defines TG::Geometry::FeatureSource" do
+    expect(TG::Geometry.const_defined?(:FeatureSource)).to be(true)
+  end
+
+  it "reads entries from JSON, file, and IO without parsing properties to Hash" do
+    expected = [["zone/a", /"Polygon"/], [2, /"MultiPolygon"/]]
+
+    [
+      TG::Geometry::FeatureSource.read_entries_json(simple_json),
+      TG::Geometry::FeatureSource.read_entries_file(simple_path),
+      TG::Geometry::FeatureSource.read_entries_io(StringIO.new(simple_json))
+    ].each do |entries|
+      expect(entries.size).to eq(2)
+      expected.each_with_index do |(id, geometry_matcher), i|
+        expect(entries[i][0]).to eq(id)
+        expect(entries[i][1]).to match(geometry_matcher)
+        expect(entries[i][1]).to be_a(String)
+      end
+    end
+  end
+
+  it "reads features with raw properties JSON" do
+    features = TG::Geometry::FeatureSource.read_features_json(simple_json)
+
+    expect(features.size).to eq(2)
+    expect(features[0][0]).to eq("zone/a")
+    expect(features[0][1]).to include('"Polygon"')
+    expect(features[0][2]).to include('"@id": "zone/a"')
+    expect(features[1][2]).to include('"@id": 2')
+  end
+
+  it "uses the OSM-style default id path [properties, @id]" do
+    json = File.binread(File.join(fixture_dir, "osm_like_feature_collection.geojson"))
+
+    entries = TG::Geometry::FeatureSource.read_entries_json(json)
+
+    expect(entries.first.first).to eq("relation/100")
+  end
+
+  it "filters non polygon types by default and reports filtered separately" do
+    json = File.binread(File.join(fixture_dir, "mixed_geometry_types.geojson"))
+
+    report = TG::Geometry::FeatureSource.read_entries_json(json, report: true)
+
+    expect(report[:entries].map(&:first)).to eq(["poly"])
+    expect(report[:filtered]).to eq(2)
+    expect(report[:skipped]).to eq(0)
+    expect(report[:errors]).to eq([])
+  end
+
+  it "supports only: nil for no geometry type filtering" do
+    json = File.binread(File.join(fixture_dir, "mixed_geometry_types.geojson"))
+
+    entries = TG::Geometry::FeatureSource.read_entries_json(json, only: nil)
+
+    expect(entries.map(&:first)).to eq(%w[poly point line])
+  end
+
+  it "requires report mode for skip options" do
+    expect do
+      TG::Geometry::FeatureSource.read_entries_json(simple_json, on_invalid: :skip)
+    end.to raise_error(TG::Geometry::ArgumentError)
+
+    expect do
+      TG::Geometry::FeatureSource.read_entries_json(simple_json, on_missing_id: :skip)
+    end.to raise_error(TG::Geometry::ArgumentError)
+  end
+
+  it "supports on_missing_id: :ordinal" do
+    json = File.binread(File.join(fixture_dir, "properties_null_missing.geojson"))
+
+    entries = TG::Geometry::FeatureSource.read_entries_json(json, on_missing_id: :ordinal)
+
+    expect(entries.map(&:first)).to eq(["feature/0", "feature/1"])
+  end
+
+  it "supports on_missing_id: :skip in report mode without requiring on_invalid: :skip" do
+    json = File.binread(File.join(fixture_dir, "properties_null_missing.geojson"))
+
+    report = TG::Geometry::FeatureSource.read_entries_json(json,
+                                                           report: true,
+                                                           on_missing_id: :skip)
+
+    expect(report[:entries]).to eq([])
+    expect(report[:skipped]).to eq(2)
+    expect(report[:filtered]).to eq(0)
+    expect(report[:errors].map { |e| e[:feature_index] }).to eq([0, 1])
+  end
+
+  it "reports invalid geometry with capped errors and exact skipped count" do
+    json = File.binread(File.join(fixture_dir, "invalid_geometry_middle.geojson"))
+
+    report = TG::Geometry::FeatureSource.read_entries_json(json,
+                                                           report: true,
+                                                           on_invalid: :skip,
+                                                           max_errors: 1)
+
+    expect(report[:entries].map(&:first)).to eq(["ok-a", "ok-b"])
+    expect(report[:skipped]).to eq(1)
+    expect(report[:errors].size).to eq(1)
+    expect(report[:errors].first[:feature_index]).to eq(1)
+    expect(report[:errors].first[:reason]).to include("invalid geometry")
+  end
+
+  it "raises ParseError for malformed JSON and non FeatureCollection roots" do
+    malformed = File.binread(File.join(fixture_dir, "malformed_json.geojson"))
+
+    expect { TG::Geometry::FeatureSource.read_entries_json(malformed) }
+      .to raise_error(TG::Geometry::ParseError)
+    expect { TG::Geometry::FeatureSource.read_entries_json('{"type":"Feature"}') }
+      .to raise_error(TG::Geometry::ParseError)
+  end
+
+  it "builds an Index directly from JSON, file, and IO" do
+    indexes = [
+      TG::Geometry::FeatureSource.build_index_json(simple_json, strategy: :flat),
+      TG::Geometry::FeatureSource.build_index_file(simple_path, strategy: :flat),
+      TG::Geometry::FeatureSource.build_index_io(StringIO.new(simple_json), strategy: :flat)
+    ]
+
+    indexes.each do |index|
+      expect(index).to be_a(TG::Geometry::Index)
+      expect(index).to be_frozen
+      expect(index.size).to eq(2)
+      expect(index.find_covering(5, 5)).to eq("zone/a")
+      expect(index.find_covering(25, 25)).to eq(2)
+    end
+  end
+
+  it "matches Index.build(read_entries, via: :geojson) behavior" do
+    entries = TG::Geometry::FeatureSource.read_entries_json(simple_json)
+    from_entries = TG::Geometry::Index.build(entries, via: :geojson, strategy: :flat)
+    direct = TG::Geometry::FeatureSource.build_index_json(simple_json, strategy: :flat)
+
+    [[5, 5], [25, 25], [100, 100]].each do |lon, lat|
+      expect(direct.find_covering(lon, lat)).to eq(from_entries.find_covering(lon, lat))
+    end
+  end
+
+
+  it "raises ParseError with a string reason for missing geometry" do
+    json = '{"type":"FeatureCollection","features":[{"type":"Feature","properties":{"@id":"x"}}]}'
+
+    expect { TG::Geometry::FeatureSource.read_entries_json(json) }
+      .to raise_error(TG::Geometry::ParseError, /feature 0.*missing geometry/)
+  end
+
+  it "reports missing geometry with a string reason in skip mode" do
+    json = '{"type":"FeatureCollection","features":[{"type":"Feature","properties":{"@id":"x"}}]}'
+
+    report = TG::Geometry::FeatureSource.read_entries_json(
+      json,
+      report: true,
+      on_invalid: :skip
+    )
+
+    expect(report[:entries]).to eq([])
+    expect(report[:skipped]).to eq(1)
+    expect(report[:filtered]).to eq(0)
+    expect(report[:errors].first[:reason]).to be_a(String)
+    expect(report[:errors].first[:reason]).to include("missing geometry")
+  end
+
+  it "skips invalid id type when on_invalid is skip and report is true" do
+    json = <<~JSON
+      {"type":"FeatureCollection","features":[
+        {"type":"Feature","properties":{"@id":false},"geometry":{"type":"Polygon","coordinates":[[[0,0],[0,1],[1,1],[1,0],[0,0]]]}}
+      ]}
+    JSON
+
+    report = TG::Geometry::FeatureSource.read_entries_json(
+      json,
+      report: true,
+      on_invalid: :skip
+    )
+
+    expect(report[:entries]).to eq([])
+    expect(report[:skipped]).to eq(1)
+    expect(report[:filtered]).to eq(0)
+    expect(report[:errors].first[:reason]).to include("invalid id")
+  end
+
+  it "skips fractional numeric id when on_invalid is skip and report is true" do
+    json = <<~JSON
+      {"type":"FeatureCollection","features":[
+        {"type":"Feature","properties":{"@id":1.2},"geometry":{"type":"Polygon","coordinates":[[[0,0],[0,1],[1,1],[1,0],[0,0]]]}}
+      ]}
+    JSON
+
+    report = TG::Geometry::FeatureSource.read_entries_json(
+      json,
+      report: true,
+      on_invalid: :skip
+    )
+
+    expect(report[:entries]).to eq([])
+    expect(report[:skipped]).to eq(1)
+    expect(report[:errors].first[:reason]).to include("numeric id must be an integer")
+  end
+
+  it "raises ParseError for malformed feature shapes" do
+    cases = [
+      '[1]',
+      '{"type":"Feature","properties":{"@id":"x"},"geometry":null}',
+      '{"type":"Feature","properties":{"@id":"x"},"geometry":"bad"}',
+      '{"type":"Feature","properties":{"@id":"x"},"geometry":{"coordinates":[]}}',
+      '{"type":"Feature","properties":{"@id":"x"},"geometry":{"type":1,"coordinates":[]}}'
+    ]
+
+    cases.each do |feature_json|
+      json = "{\"type\":\"FeatureCollection\",\"features\":[#{feature_json}]}"
+      expect { TG::Geometry::FeatureSource.read_entries_json(json) }
+        .to raise_error(TG::Geometry::ParseError)
+    end
+  end
+
+  it "raises ParseError for missing or non-array features" do
+    expect { TG::Geometry::FeatureSource.read_entries_json('{"type":"FeatureCollection"}') }
+      .to raise_error(TG::Geometry::ParseError, /features/)
+
+    expect { TG::Geometry::FeatureSource.read_entries_json('{"type":"FeatureCollection","features":{}}') }
+      .to raise_error(TG::Geometry::ParseError, /features/)
+  end
+
+  it "treats invalid properties type as invalid feature for read_features" do
+    json = <<~JSON
+      {"type":"FeatureCollection","features":[
+        {"type":"Feature","properties":[],"geometry":{"type":"Polygon","coordinates":[[[0,0],[0,1],[1,1],[1,0],[0,0]]]}}
+      ]}
+    JSON
+
+    expect { TG::Geometry::FeatureSource.read_features_json(json, on_missing_id: :ordinal) }
+      .to raise_error(TG::Geometry::ParseError, /properties must be an object or null/)
+  end
+
+  it "rejects unknown keywords" do
+    expect { TG::Geometry::FeatureSource.read_entries_json(simple_json, typo: 1) }
+      .to raise_error(TG::Geometry::ArgumentError, /unknown keyword/)
+  end
+
+  it "surfaces missing file errors as file errors" do
+    missing = File.join(fixture_dir, "does_not_exist.geojson")
+
+    expect { TG::Geometry::FeatureSource.read_entries_file(missing) }
+      .to raise_error(Errno::ENOENT)
+  end
+
+  it "rejects invalid id types" do
+    json = <<~JSON
+      {"type":"FeatureCollection","features":[
+        {"type":"Feature","properties":{"@id":false},"geometry":{"type":"Polygon","coordinates":[[[0,0],[0,1],[1,1],[1,0],[0,0]]]}}
+      ]}
+    JSON
+
+    expect { TG::Geometry::FeatureSource.read_entries_json(json) }
+      .to raise_error(TG::Geometry::ArgumentError)
+  end
+end

data/spec/{expansion_d_format_coverage_spec.rb → format_coverage_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe "Expansion Block D format coverage" do
+RSpec.describe "Format coverage" do
   it "roundtrips Hex" do
     geom = TG::Geometry.parse_wkt("POINT (1 2)")
     hex = geom.to_hex

data/spec/{block_20_fuzz_spec.rb → fuzz_spec.rb}

@@ -3,7 +3,7 @@
 require "spec_helper"
 require "fileutils"
 
-RSpec.describe "Release Core Block 20 fuzz hardening" do
+RSpec.describe "Fuzz hardening" do
   ITERATIONS = Integer(ENV.fetch("TG_GEOMETRY_FUZZ_ITERATIONS", "2000")).freeze
   SEED = Integer(ENV.fetch("TG_GEOMETRY_FUZZ_SEED", "20260524")).freeze
   CORPUS_DIR = File.expand_path("fixtures/fuzz_corpus", __dir__).freeze

data/spec/{block_4_geom_api_spec.rb → geom_api_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe "Release Core Block 4 Geom API" do
+RSpec.describe "Geom API" do
   let(:polygon_wkt) { "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))" }
   let(:inner_point_wkt) { "POINT (5 5)" }
   let(:boundary_point_wkt) { "POINT (0 5)" }