textus 0.10.1 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da7bc5c1fbc90ea76df8adb279491b3a94b4b093f014281ca28c317366539cad
-  data.tar.gz: 92b35dab2a95f81d93e45a467652ee840ed06617a3df587d66a170884b99b81f
+  metadata.gz: 37ec398fd3e4bc171cdd4de0452b16de423d899103b1b66c31411bc296260115
+  data.tar.gz: 47f2a2f213698adfa9f7ba8019d05b80d704aaf1de7ac6cf2a96ceb33642b966
 SHA512:
-  metadata.gz: f84bf665d8aa002bfac744ada1e43b6993d9209f8997cafdfc441f74c758edb8ef28b5b3d45e70f8ccb58cc3c82c05a3238a40940142a35d25fd1807ed237324
-  data.tar.gz: cd2326ee626d90217aaf9f9e91b10441d6b397af3bf3bb8c54dde00e5bfa37eca56ca7011175f58168a1b0365a484de76e9ebac3022f035833974442a73e9f1e
+  metadata.gz: 4cccb93db3f1e94f75a12ff4513c51d6c95177e2f530b94a8ba9220cefc9e0bce949acc187f5546a6c8c68a6ebf70e3d79a890ebe32e8c2e66831e10309ee4b0
+  data.tar.gz: af03c10214acc105d2d7a0921c486d926446b3f7d2763172ab6199c54322682d1a40aced0966054899067840686fedbe52cbf3e9d3714dbabae8693893149467

data/CHANGELOG.md

@@ -8,6 +8,30 @@ The **gem version** (`0.x.y`) is distinct from the **protocol version**
 (currently `textus/2`, embedded in every envelope as `protocol`). The protocol
 is additive within a major; a new major would change the wire string.
 
+## 0.10.2 — Doctor and store cleanup (2026-05-23)
+
+Patch release. Internal cleanup: extracts `Store::Sentinel`, moves audit-log integrity into `Store::AuditLog`, surfaces previously-swallowed schema parse errors, and tidies two doctor checks. No CLI, wire-protocol, or behavioral changes for plugin authors. Sentinel JSON shape changes (repo-relative paths) are forward-compatible; legacy absolute paths are still read correctly.
+
+### Added
+
+- `Textus::Store::Sentinel` value object owning the sentinel JSON shape (`source`/`target`/`sha256`/`mode`) and the on-disk path layout. Repo-relative paths on write; legacy absolute paths still accepted on read.
+- `Textus::Store::AuditLog#verify_integrity` returns line-by-line integrity violations as `{lineno, reason, detail}` hashes.
+- `Textus::Schema#unowned_fields` returns field names whose spec lacks `maintained_by`.
+- New doctor check `schema_parse_error` (error level) surfaces YAML parse failures on `schemas/*.yaml`. Previously these were silently rescued in `UnownedSchemaFields`, leaving operators with no signal.
+
+### Changed
+
+- `Infra::Publisher` delegates sentinel I/O to `Store::Sentinel`. The sentinel JSON now stores repo-relative `source`/`target` so example trees can be committed without leaking author paths.
+- `Doctor::Check::Sentinels` delegates parse/orphan/drift detection to `Store::Sentinel`. Drops `rubocop:disable Metrics/BlockLength`.
+- `Doctor::Check::AuditLog` delegates parsing to `Store::AuditLog#verify_integrity`. Drops `rubocop:disable Metrics/BlockLength`.
+- `Doctor::Check::ManifestFiles` uses `Textus::Key::Path.resolve` instead of reimplementing leaf-path math.
+- `Doctor::Check::UnownedSchemaFields` uses `Schema#unowned_fields` instead of reaching into `schema.fields` and the raw `maintained_by` Hash key.
+- `examples/claude-plugin/.gitignore` no longer excludes `.textus/sentinels/`. The example's sentinels are now committed with repo-relative paths.
+
+### Documentation
+
+- `SPEC.md` builtin doctor-check list updated to include `schema_parse_error`, and brings the prose up to date with three checks shipped in 0.9.x/0.10.0 that were missing from the list (`policy_ambiguity`, `handler_allowlist`, `legacy_intake_fields`).
+
 ## 0.10.1 — Documentation refresh and spec hygiene (2026-05-22)
 
 Lightweight maintenance release: documentation refresh plus spec-suite hygiene. No `lib/` changes; no CLI, wire-protocol, or behavioral changes.

data/SPEC.md

@@ -693,7 +693,7 @@ Every `Textus::Error` exposes `code`, `message`, and an optional `hint:`. The hi
 
 ## 10.2 `textus doctor`
 
-`textus doctor` returns a health-check envelope: `{ "protocol": "textus/2", "ok": bool, "issues": [...], "summary": {error, warning, info} }`. Each issue carries `code`, `level` (`error|warning|info`), `subject`, `message`, and optionally `fix`. `ok` is true iff no error-level issues are present; warnings and info do not flip the bit. Builtin checks: `manifest_files`, `schemas`, `templates`, `hooks`, `illegal_keys`, `sentinels`, `audit_log`, `unowned_schema_fields`, `schema_violations`. Additional registered `:check` hooks (§5.10) run after the builtin set. Exit code is 0 on `ok`, 1 otherwise.
+`textus doctor` returns a health-check envelope: `{ "protocol": "textus/2", "ok": bool, "issues": [...], "summary": {error, warning, info} }`. Each issue carries `code`, `level` (`error|warning|info`), `subject`, `message`, and optionally `fix`. `ok` is true iff no error-level issues are present; warnings and info do not flip the bit. Builtin checks: `manifest_files`, `schemas`, `schema_parse_error`, `templates`, `hooks`, `illegal_keys`, `sentinels`, `audit_log`, `unowned_schema_fields`, `schema_violations`, `policy_ambiguity`, `handler_allowlist`, `legacy_intake_fields`. Additional registered `:check` hooks (§5.10) run after the builtin set. Exit code is 0 on `ok`, 1 otherwise.
 
 ## 11. Versioning
 

data/lib/textus/doctor/check/audit_log.rb

@@ -1,48 +1,32 @@
-require "json"
-
 module Textus
   module Doctor
     class Check
       class AuditLog < Check
         def call
-          out = []
           path = File.join(store.root, "audit.log")
-          return out unless File.exist?(path)
-
-          File.foreach(path).with_index(1) do |line, lineno| # rubocop:disable Metrics/BlockLength
-            stripped = line.chomp
-            next if stripped.empty?
+          Textus::Store::AuditLog.new(store.root).verify_integrity.map do |v|
+            {
+              "code" => "audit.parse_error",
+              "level" => "warning",
+              "subject" => "#{path}:#{v["lineno"]}",
+              "message" => violation_message(v),
+              "fix" => "inspect #{path} at line #{v["lineno"]} and remove the corrupted row",
+            }
+          end
+        end
 
-            if stripped.start_with?("{")
-              begin
-                JSON.parse(stripped)
-              rescue JSON::ParserError => e
-                out << {
-                  "code" => "audit.parse_error",
-                  "level" => "warning",
-                  "subject" => "#{path}:#{lineno}",
-                  "message" => "audit log line #{lineno} is invalid JSON: #{e.message}",
-                  "fix" => "inspect #{path} at line #{lineno} and remove the corrupted row",
-                }
-              end
-            else
-              # Legacy TSV (pre-0.5): read-only support retained for on-disk logs
-              # written by older textus versions. Never written by current code.
-              # Minimum 6 fields.
-              fields = stripped.split("\t")
-              next if fields.length >= 6
+        private
 
-              out << {
-                "code" => "audit.parse_error",
-                "level" => "warning",
-                "subject" => "#{path}:#{lineno}",
-                "message" => "audit log line #{lineno} has #{fields.length} fields " \
-                             "(expected >=6 for legacy TSV; consider migrating to NDJSON)",
-                "fix" => "inspect #{path} at line #{lineno} and remove the corrupted row",
-              }
-            end
+        def violation_message(v)
+          case v["reason"]
+          when "invalid_json"
+            "audit log line #{v["lineno"]} is invalid JSON: #{v["detail"]}"
+          when "short_tsv"
+            "audit log line #{v["lineno"]} #{v["detail"]} " \
+            "(consider migrating to NDJSON)"
+          else
+            v["detail"]
           end
-          out
         end
       end
     end

data/lib/textus/doctor/check/manifest_files.rb

@@ -3,11 +3,10 @@ module Textus
     class Check
       class ManifestFiles < Check
         def call
-          out = []
-          store.manifest.entries.each do |entry|
+          store.manifest.entries.each_with_object([]) do |entry, out|
             next if entry.nested
 
-            path = leaf_path_for(entry)
+            path = Textus::Key::Path.resolve(store.manifest, entry)
             next if File.exist?(path)
 
             out << {
@@ -19,18 +18,6 @@ module Textus
                        "(or leave empty if not yet authored)",
             }
           end
-          out
-        end
-
-        private
-
-        def leaf_path_for(entry)
-          primary_ext = Entry.for_format(entry.format).extensions.first
-          if File.extname(entry.path) == ""
-            File.join(store.root, "zones", entry.path + primary_ext)
-          else
-            File.join(store.root, "zones", entry.path)
-          end
         end
       end
     end

data/lib/textus/doctor/check/schema_parse_error.rb

@@ -0,0 +1,28 @@
+module Textus
+  module Doctor
+    class Check
+      # Surfaces YAML parse failures for files in <store>/schemas/. Without
+      # this check, malformed schemas are silently skipped by other doctor
+      # checks (UnownedSchemaFields rescues, Schemas only checks filenames),
+      # leaving the operator with no signal that a schema is broken.
+      class SchemaParseError < Check
+        def call
+          dir = File.join(store.root, "schemas")
+          return [] unless File.directory?(dir)
+
+          Dir.glob(File.join(dir, "*.yaml")).each_with_object([]) do |path, out|
+            Schema.load(path)
+          rescue StandardError => e
+            out << {
+              "code" => "schema.parse_error",
+              "level" => "error",
+              "subject" => path,
+              "message" => "schema failed to parse: #{e.class}: #{e.message}",
+              "fix" => "fix the YAML at #{path} (check indentation, quoted scalars, and aliases)",
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/textus/doctor/check/sentinels.rb

@@ -1,55 +1,56 @@
-require "digest"
-require "json"
-
 module Textus
   module Doctor
     class Check
       class Sentinels < Check
         def call
-          out = []
           dir = File.join(store.root, "sentinels")
-          return out unless File.directory?(dir)
+          return [] unless File.directory?(dir)
 
-          Dir.glob(File.join(dir, "**", "*.textus-managed.json")).each do |sp| # rubocop:disable Metrics/BlockLength
-            begin
-              data = JSON.parse(File.read(sp))
-            rescue JSON::ParserError => e
-              out << {
-                "code" => "sentinel.parse_error",
-                "level" => "warning",
-                "subject" => sp,
-                "message" => "sentinel is not valid JSON: #{e.message}",
-                "fix" => "delete #{sp} and re-run 'textus build' to regenerate",
-              }
-              next
-            end
+          repo_root = File.dirname(store.root)
+          Dir.glob(File.join(dir, "**", "*#{Textus::Store::Sentinel::SUFFIX}")).flat_map do |sentinel_path|
+            inspect_sentinel(sentinel_path, repo_root)
+          end
+        end
 
-            target = data["target"]
-            recorded_sha = data["sha256"]
+        private
 
-            if target.nil? || !File.exist?(target)
-              out << {
-                "code" => "sentinel.orphan",
-                "level" => "warning",
-                "subject" => sp,
-                "message" => "sentinel target #{target.inspect} no longer exists",
-                "fix" => "delete #{sp} (the published file is gone) or restore the target",
-              }
-              next
-            end
+        def inspect_sentinel(sentinel_path, repo_root)
+          sentinel = Textus::Store::Sentinel.load(sentinel_path, repo_root)
+          return [parse_error_issue(sentinel_path)] if sentinel.nil?
+          return [orphan_issue(sentinel_path, sentinel)] if sentinel.orphan?
+          return [drift_issue(sentinel)] if sentinel.drift?
 
-            current_sha = Digest::SHA256.hexdigest(File.binread(target))
-            next if recorded_sha.nil? || current_sha == recorded_sha
+          []
+        end
 
-            out << {
-              "code" => "sentinel.drift",
-              "level" => "warning",
-              "subject" => target,
-              "message" => "published file at #{target} was modified out-of-band",
-              "fix" => "re-run 'textus build' to overwrite, or copy the manual edit back into the store source",
-            }
-          end
-          out
+        def parse_error_issue(sentinel_path)
+          {
+            "code" => "sentinel.parse_error",
+            "level" => "warning",
+            "subject" => sentinel_path,
+            "message" => "sentinel is not valid JSON",
+            "fix" => "delete #{sentinel_path} and re-run 'textus build' to regenerate",
+          }
+        end
+
+        def orphan_issue(sentinel_path, sentinel)
+          {
+            "code" => "sentinel.orphan",
+            "level" => "warning",
+            "subject" => sentinel_path,
+            "message" => "sentinel target #{sentinel.target.inspect} no longer exists",
+            "fix" => "delete #{sentinel_path} (the published file is gone) or restore the target",
+          }
+        end
+
+        def drift_issue(sentinel)
+          {
+            "code" => "sentinel.drift",
+            "level" => "warning",
+            "subject" => sentinel.target,
+            "message" => "published file at #{sentinel.target} was modified out-of-band",
+            "fix" => "re-run 'textus build' to overwrite, or copy the manual edit back into the store source",
+          }
         end
       end
     end

data/lib/textus/doctor/check/unowned_schema_fields.rb

@@ -3,30 +3,36 @@ module Textus
     class Check
       class UnownedSchemaFields < Check
         def call
-          out = []
           dir = File.join(store.root, "schemas")
-          return out unless File.directory?(dir)
+          return [] unless File.directory?(dir)
 
-          Dir.glob(File.join(dir, "*.yaml")).sort.each do |sp| # rubocop:disable Lint/RedundantDirGlobSort
-            schema = begin
-              Schema.load(sp)
-            rescue StandardError
-              next
-            end
-            unowned = schema.fields.each_with_object([]) do |(name, spec), acc|
-              acc << name if spec.is_a?(Hash) && spec["maintained_by"].nil?
-            end
-            next if unowned.empty?
-
-            out << {
-              "code" => "schema.unowned_fields",
-              "level" => "info",
-              "subject" => schema.name || File.basename(sp, ".yaml"),
-              "message" => "schema has fields without maintained_by: #{unowned.join(", ")}",
-              "fix" => "add 'maintained_by: <role>' to each field in #{sp} (optional but recommended)",
-            }
+          Dir.glob(File.join(dir, "*.yaml")).flat_map do |path|
+            issues_for(path)
           end
-          out
+        end
+
+        private
+
+        def issues_for(path)
+          schema = safe_load(path)
+          return [] if schema.nil?
+
+          unowned = schema.unowned_fields
+          return [] if unowned.empty?
+
+          [{
+            "code" => "schema.unowned_fields",
+            "level" => "info",
+            "subject" => schema.name || File.basename(path, ".yaml"),
+            "message" => "schema has fields without maintained_by: #{unowned.join(", ")}",
+            "fix" => "add 'maintained_by: <role>' to each field in #{path} (optional but recommended)",
+          }]
+        end
+
+        def safe_load(path)
+          Schema.load(path)
+        rescue StandardError
+          nil
         end
       end
     end

data/lib/textus/doctor.rb

@@ -11,6 +11,7 @@ module Textus
     CHECKS = [
       Check::ManifestFiles,
       Check::Schemas,
+      Check::SchemaParseError,
       Check::Templates,
       Check::Hooks,
       Check::IntakeRegistration,

data/lib/textus/infra/publisher.rb

@@ -1,24 +1,21 @@
-require "json"
-require "digest"
 require "fileutils"
 
 module Textus
   module Infra
     # Publishes built artifacts from the store to repo-relative consumer paths.
     # Publish = copy + sentinel. The in-store file is already the consumer-shaped
-    # artifact; no parsing or stripping. Sentinels live under
+    # artifact; no parsing or stripping.
+    #
+    # Sentinel I/O is delegated to Store::Sentinel. Sentinels live under
     # `<store_root>/sentinels/` and mirror the target's repo-relative layout so
     # consumer directories aren't polluted with `.textus-managed.json` siblings.
     module Publisher
-      SENTINEL_SUFFIX = ".textus-managed.json".freeze
-      SENTINEL_DIR    = "sentinels".freeze
-
       def self.publish(source:, target:, store_root:)
         FileUtils.mkdir_p(File.dirname(target))
         refuse_if_unmanaged(target, store_root)
         File.delete(target) if File.symlink?(target)
         FileUtils.cp(source, target)
-        write_sentinel(target, store_root: store_root, source: source)
+        Store::Sentinel.write!(target: target, source: source, store_root: store_root)
         cleanup_legacy_sentinel(target)
       end
 
@@ -30,43 +27,12 @@ module Textus
       end
 
       def self.managed?(target, store_root)
-        File.exist?(sentinel_path(target, store_root)) || File.exist?(legacy_sentinel_path(target))
-      end
-
-      def self.write_sentinel(target, store_root:, source:)
-        path = sentinel_path(target, store_root)
-        FileUtils.mkdir_p(File.dirname(path))
-        File.write(path, JSON.generate(
-                           "source" => source,
-                           "target" => target,
-                           "sha256" => Digest::SHA256.hexdigest(File.binread(target)),
-                           "mode" => "copy",
-                         ))
-      end
-
-      # Sentinel layout: <store_root>/sentinels/<target_rel_to_repo>.textus-managed.json
-      # The full target extension is preserved so a marketplace.json and
-      # marketplace.yaml don't collide.
-      def self.sentinel_path(target, store_root)
-        repo_root = File.dirname(store_root)
-        rel = relative_to(target, repo_root) || File.basename(target)
-        File.join(store_root, SENTINEL_DIR, rel + SENTINEL_SUFFIX)
-      end
-
-      def self.legacy_sentinel_path(target)
-        target + SENTINEL_SUFFIX
+        File.exist?(Store::Sentinel.sentinel_path(target, store_root)) ||
+          File.exist?(Store::Sentinel.legacy_path(target))
       end
 
       def self.cleanup_legacy_sentinel(target)
-        FileUtils.rm_f(legacy_sentinel_path(target))
-      end
-
-      def self.relative_to(path, base)
-        path = File.expand_path(path)
-        base = File.expand_path(base)
-        return nil unless path.start_with?(base + File::SEPARATOR)
-
-        path[(base.length + 1)..]
+        FileUtils.rm_f(Store::Sentinel.legacy_path(target))
       end
     end
   end

data/lib/textus/schema.rb

@@ -26,6 +26,16 @@ module Textus
       meta["maintained_by"]
     end
 
+    # Returns the list of field names whose spec is a Hash but lacks the
+    # 'maintained_by' key. Used by Doctor::Check::UnownedSchemaFields.
+    def unowned_fields
+      @fields.each_with_object([]) do |(name, spec), acc|
+        next unless spec.is_a?(Hash)
+
+        acc << name if spec["maintained_by"].nil?
+      end
+    end
+
     def evolution
       raw = @raw["evolution"] || {}
       raw.each_with_object({}) do |(k, v), h|

data/lib/textus/store/audit_log.rb

@@ -47,6 +47,20 @@ module Textus
         end
       end
 
+      # Returns an array of integrity-violation descriptors for the on-disk log.
+      # Each entry is { "lineno" => Integer, "reason" => String, "detail" => String }.
+      # Empty array means the log is well-formed (or doesn't exist yet).
+      def verify_integrity
+        return [] unless File.exist?(@path)
+
+        out = []
+        File.foreach(@path).with_index(1) do |line, lineno|
+          violation = check_line(line.chomp, lineno)
+          out << violation if violation
+        end
+        out
+      end
+
       private
 
       def parse_row(line)
@@ -66,6 +80,30 @@ module Textus
       rescue JSON::ParserError
         nil
       end
+
+      def check_line(stripped, lineno)
+        return nil if stripped.empty?
+
+        if stripped.start_with?("{")
+          begin
+            JSON.parse(stripped)
+            nil
+          rescue JSON::ParserError => e
+            { "lineno" => lineno, "reason" => "invalid_json", "detail" => e.message }
+          end
+        else
+          # parse_row accepts >= 4 fields for read-compat; integrity requires
+          # all 6 data columns of the legacy TSV format.
+          fields = stripped.split("\t")
+          return nil if fields.length >= 6
+
+          {
+            "lineno" => lineno,
+            "reason" => "short_tsv",
+            "detail" => "legacy TSV row has #{fields.length} fields (expected >= 6)",
+          }
+        end
+      end
     end
   end
 end

data/lib/textus/store/sentinel.rb

@@ -0,0 +1,93 @@
+require "json"
+require "digest"
+require "fileutils"
+
+module Textus
+  class Store
+    # Value object for sentinel files written by Infra::Publisher and inspected
+    # by Doctor::Check::Sentinels. Owns the JSON shape ({source, target,
+    # sha256, mode}) and the on-disk path layout (<store_root>/sentinels/
+    # <target-rel-to-repo>.textus-managed.json).
+    #
+    # Repo-relative target/source on write so example trees can be committed
+    # without leaking the author's absolute filesystem paths. Legacy absolute
+    # paths are still accepted on read.
+    class Sentinel
+      SUFFIX = ".textus-managed.json".freeze
+      DIR    = "sentinels".freeze
+
+      attr_reader :target, :source, :sha256, :mode
+
+      def self.write!(target:, source:, store_root:)
+        path = sentinel_path(target, store_root)
+        FileUtils.mkdir_p(File.dirname(path))
+        repo_root = File.dirname(store_root)
+        File.write(path, JSON.generate(
+                           "source" => rel_or_abs(source, repo_root),
+                           "target" => rel_or_abs(target, repo_root),
+                           "sha256" => Digest::SHA256.hexdigest(File.binread(target)),
+                           "mode" => "copy",
+                         ))
+      end
+
+      def self.load(path, repo_root)
+        raw = JSON.parse(File.read(path))
+        new(
+          target: absolutize(raw["target"], repo_root),
+          source: absolutize(raw["source"], repo_root),
+          sha256: raw["sha256"],
+          mode: raw["mode"],
+        )
+      rescue JSON::ParserError, Errno::ENOENT
+        nil
+      end
+
+      def self.sentinel_path(target, store_root)
+        repo_root = File.dirname(store_root)
+        rel = relative_to(target, repo_root) || File.basename(target)
+        File.join(store_root, DIR, rel + SUFFIX)
+      end
+
+      def self.legacy_path(target)
+        target + SUFFIX
+      end
+
+      def self.rel_or_abs(path, repo_root)
+        relative_to(path, repo_root) || File.expand_path(path)
+      end
+
+      def self.relative_to(path, repo_root)
+        path = File.expand_path(path)
+        base = File.expand_path(repo_root)
+        return nil unless path.start_with?(base + File::SEPARATOR)
+
+        path[(base.length + 1)..]
+      end
+
+      def self.absolutize(path, repo_root)
+        return path if path.nil?
+        return path if File.absolute_path?(path)
+
+        File.expand_path(path, repo_root)
+      end
+
+      def initialize(target:, source:, sha256:, mode:)
+        @target = target
+        @source = source
+        @sha256 = sha256
+        @mode = mode
+      end
+
+      def orphan?
+        @target.nil? || !File.exist?(@target)
+      end
+
+      def drift?
+        return false if orphan?
+        return false if @sha256.nil?
+
+        Digest::SHA256.hexdigest(File.binread(@target)) != @sha256
+      end
+    end
+  end
+end

data/lib/textus/version.rb

@@ -1,4 +1,4 @@
 module Textus
-  VERSION = "0.10.1"
+  VERSION = "0.10.2"
   PROTOCOL = "textus/2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: textus
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.10.2
 platform: ruby
 authors:
 - Patrick
@@ -178,6 +178,7 @@ files:
 - lib/textus/doctor/check/legacy_intake_fields.rb
 - lib/textus/doctor/check/manifest_files.rb
 - lib/textus/doctor/check/policy_ambiguity.rb
+- lib/textus/doctor/check/schema_parse_error.rb
 - lib/textus/doctor/check/schema_violations.rb
 - lib/textus/doctor/check/schemas.rb
 - lib/textus/doctor/check/sentinels.rb
@@ -233,6 +234,7 @@ files:
 - lib/textus/store/audit_log.rb
 - lib/textus/store/mover.rb
 - lib/textus/store/reader.rb
+- lib/textus/store/sentinel.rb
 - lib/textus/store/staleness.rb
 - lib/textus/store/validator.rb
 - lib/textus/store/writer.rb