vicary 0.2.14 → 0.2.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 861bcafb7f5671834b082aea4da0edc1bdd050d71aab888d6b1944f58c70b36f
-  data.tar.gz: 31fbd6f351e16c1ff1cb0acea2f5422b94decfbeb8b0f8021e20386561cd309c
+  metadata.gz: 4e78fbd85fa4dde2e481bbf8b5349ceda35e4ab98fbf9ad0b336761be3f6379d
+  data.tar.gz: b9ad9cd2ebeaffa8b438c4b051d378edb47cfc86f1117cce68732f6cd3f2cdd3
 SHA512:
-  metadata.gz: e5da98338e5c69f9687c1d6daf0b937837dd8d8f074768781f73f47fe789f6e99cebed77b8449b79d32118e16e738e6e45903e79b0b9ab7333acd64575de8827
-  data.tar.gz: '0148acecb49a386d9cec1b5e3832a01385820572b32f8b30f4bfbbf49c3293af70a2ceba44b93990ffc85056ddb555e80630b0e4e3da786c95aec9c8500ae4a3'
+  metadata.gz: 9ef2a213c75f9cf539620a393b20e7f2521173fb14a2bfbc2d6753654a8a19f19875b143a6b4240cc4ce09b01667cccc4d1da8d2e4c52d774bc9678c52eb13cb
+  data.tar.gz: 7102716c3687292aff85bc8191e0fbbe65ef457930f9fcce2c5b78e58ed3134a8e69d5b07f728a09438f0aeda84f97753a82419e91478ebd401ba99df5c2dd47

data/README.md

@@ -45,6 +45,19 @@ replaced. A map that is absent, or that covers only some of the placeholders in
 the text, yields **no** spans and translates as the identity — a caller can
 handle "no spans" and cannot detect a wrong offset.
 
+Before a reader sees it, check that no placeholder the host did not restore
+survived — echoed by a model, or paraphrased as `[NAME_1]`, `{Name_1}` or a bare
+`NAME_1`:
+
+```ruby
+show(Vicary.assert_no_placeholders(feedback))    # raises PlaceholderLeakError
+show(Vicary.scrub_placeholders(feedback).text)   # or drop each sentence carrying one
+```
+
+The error names the kinds and the count, never the text.
+`Vicary.find_placeholders` and `Vicary.has_placeholders?` answer without raising;
+`scrub_placeholders(text, quote: true)` elides instead, for a verbatim quote.
+
 ## Checking it
 
 Three layers, because each catches what the one above it cannot.

data/lib/vicary/candidates.rb

@@ -186,42 +186,32 @@ module Vicary
     # of the commonest surname shapes there are.
     PIECE = /[^'’\-‐-―]+/
 
-    # The word tokens {Candidates.interior_capital?} can possibly say yes to,
-    # and the only ones {Candidates.capitalises_inside_a_word?} needs to look
-    # at.
+    # The only shape a word with an interior capital can carry: a capital with a
+    # word character in front of it. Every capital {Candidates.interior_capital?}
+    # is allowed to fire on sits at word-index 1 or later, so it is preceded
+    # either by the word's own first character or by one of `[A-Za-z'’-]`, and
+    # both are inside this class. A document that fails this has no interior
+    # capital and needs no word scan at all; a document that passes has told the
+    # scan exactly where to look. That makes this a filter and never a second
+    # opinion — the answer stays that method's.
     #
-    # It is {WORD_TOKEN} with one letter of the continuation class removed: a
-    # capital somewhere after the first character. That is a *necessary*
-    # condition for an interior capital — every position the exemptions in
-    # {Candidates.interior_capital?} still allow to fire is at piece-index 1 or
-    # later, so it is at word-index 1 or later too — which makes this a filter
-    # and never a second opinion. The answer stays that method's.
-    #
-    # The match is the same substring {WORD_TOKEN} would have produced, not a
-    # fragment of one. A token whose first capital after position 0 sits at k
-    # has every earlier character in `[a-z'’-]` by construction, so the engine
-    # matches from the token's own start, and the trailing class then runs
-    # greedily to the token's own end.
-    #
-    # Why this is worth a second pattern: the scan is per-document and the words
-    # it is looking for are rare. On the twenty-essay gate corpus exactly ONE
-    # document contains an interior capital, so the other nineteen used to be
-    # tokenised to the last word — and a regex spent on each — to return false.
-    INTERIOR_CAP_WORD = /[A-Za-z][a-z'’-]*[A-Z][A-Za-z'’-]*/
-
-    # The two-character shape {INTERIOR_CAP_WORD} cannot match without: a
-    # capital with a word character in front of it. Every capital that pattern
-    # fires on is preceded either by its own first character or by one of
-    # `[a-z'’-]`, and both are inside this class, so a document that fails
-    # this has no interior capital and needs no word scan at all.
-    #
-    # It exists because the precise pattern backtracks. `[a-z'’-]*[A-Z]` is
-    # retried at every letter of every word that has no capital after it, which
-    # is most words in most documents; this is a two-character scan that cannot
-    # backtrack. On the twenty-essay gate corpus it clears thirteen documents
-    # outright at a twentieth of the cost.
+    # Two characters, and it cannot backtrack. It replaced a precise word
+    # pattern (`[A-Za-z][a-z'’-]*[A-Z][A-Za-z'’-]*`) that did: `[a-z'’-]*[A-Z]`
+    # is retried at every letter of every word that has no capital after it,
+    # which is most words in most documents, and running it over the whole text
+    # cost threefold what running this one and walking out from its hits costs —
+    # 57 µs per document against 17.5 on the twenty-essay gate corpus. The walk
+    # is in {Candidates.capitalises_inside_a_word?}; the word it reaches is the
+    # same substring {WORD_TOKEN} would have produced, because the walk uses
+    # that token's own continuation class.
     INTERIOR_CAP_HINT = /[A-Za-z'’-][A-Z]/
 
+    # The complement of {WORD_TOKEN}'s continuation class, and its first-character
+    # class. The interior-capital walk reads outwards from a hint rather than
+    # forwards from a word, so it needs the boundary rather than the token.
+    NOT_WORD_CHARACTER = /[^A-Za-z'’-]/
+    WORD_FIRST_CHARACTER = /[A-Za-z]/
+
     # Where a sentence begins: start of text, after terminal punctuation and any
     # closing quote, after a line break, or immediately inside an *opening*
     # quote. A capital in one of these positions is required by orthography, so
@@ -383,6 +373,11 @@ module Vicary
     # One row of the precedence table: a tag, and what it decides.
     PrecedenceRow = Struct.new(:tag, :mask, :kind)
 
+    # What one pass over a document's words says about how the writer cases
+    # them. See {Candidates.document_casing}; either half is empty when the
+    # caller did not ask for it.
+    DocumentCasing = Struct.new(:written_as_a_capital, :written_in_lower_case)
+
     # The precedence table. The first row whose tag the span carries decides both
     # the mask/keep verdict and the placeholder, and that is the whole
     # classification policy.
@@ -1085,16 +1080,63 @@ module Vicary
       # Horses" vouch for "Horses" as a name — the heading corroborating itself,
       # one line removed.
       def mid_sentence_capitals(text, starts, headings = [])
-        out = Set.new
+        document_casing(text, starts, headings, lower_case: false).written_as_a_capital
+      end
+
+      # Both halves of the document's casing testimony, from ONE pass over its
+      # words.
+      #
+      # {.mid_sentence_capitals} and {.written_in_lower_case} ask opposite
+      # questions of the same tokens — one reads the words a writer capitalised
+      # where orthography would not have, the other the words they left
+      # lower-case — and a token answers exactly one of them, because a word's
+      # first character is either a capital or it is not. Run separately they
+      # tokenised every document twice.
+      #
+      # That second tokenisation is what this exists to remove, and it is worth
+      # a method rather than a comment: the pair was most of what the two
+      # orthography channels added to the release latency gate.
+      #
+      # Each half is opt-in because each has a caller that does not want it. The
+      # lower-case set is evidence only where the writer marks proper nouns at
+      # all (see `lower_cased` in {.find_candidates}), and asking for a set that
+      # will be discarded is the cost this method was written to avoid.
+      def document_casing(text, starts = Set.new, headings = [], capitals: true, lower_case: true)
+        capitalised = Set.new
+        lowered = Set.new
         each_match(text, WORD_TOKEN) do |m|
           token = m[0]
-          next if starts.include?(m.begin(0)) || !token[0].match?(/[A-Z]/)
+          # A byte comparison rather than `token[0].match?(/[A-Z]/)`, which
+          # allocated a one-character string and ran a regex for every word of
+          # every document. Exact, not an approximation: {WORD_TOKEN}'s first
+          # character is `[A-Za-z]`, so it is ASCII, a single byte, and
+          # lower-case exactly when it is not upper-case — which is what splits
+          # the two halves, at one test rather than two.
+          first = token.getbyte(0)
+          if first >= 97 && first <= 122
+            next unless lower_case
+
+            # {.strip} copies the string whether or not it takes anything off,
+            # and almost no word ends in an apostrophe. Same value either way —
+            # a strip that removes nothing returns an equal string, and the set
+            # holds values.
+            #
+            # Only the tail is worth testing. {.strip} works in from both ends,
+            # and the head was just established to be a lower-case ASCII letter,
+            # so the leading pass stops on the first character every time.
+            lowered_token = token.downcase
+            lowered_token = strip(lowered_token, "'’") if lowered_token.end_with?("'", "’")
+            lowered << lowered_token
+            next
+          end
+          next unless capitals
+          next if starts.include?(m.begin(0))
           next if token.length > 1 && upper?(token)
           next if overlaps?(headings, m.begin(0), m.begin(0) + token.length)
 
-          out << strip(token.downcase, "'’")
+          capitalised << strip(token.downcase, "'’")
         end
-        out
+        DocumentCasing.new(capitalised, lowered)
       end
 
       # ---------------------------------------------------------------------
@@ -1334,13 +1376,27 @@ module Vicary
       # NWP corpus 14 papers carry an interior capital and 2 of them (`SPecial`,
       # `AFter`) carry it only inside a heading.
       #
-      # The scan is over {INTERIOR_CAP_WORD} rather than every word token, which
-      # is a filter and not a change of answer — see that pattern.
+      # The scan is driven off {INTERIOR_CAP_HINT} rather than run over every
+      # word token, which is a filter and not a change of answer — see that
+      # pattern. Each hit names a capital and the walk reaches the word carrying
+      # it; the hit need not be interior itself (`'ChoaCh'` hints at its own
+      # first letter), so the WHOLE token is handed over rather than the
+      # position being judged here.
       def capitalises_inside_a_word?(text)
-        return false unless INTERIOR_CAP_HINT.match?(text)
-
-        text.scan(INTERIOR_CAP_WORD) do |word|
-          return true if interior_capital?(word)
+        pos = 0
+        while (hint = INTERIOR_CAP_HINT.match(text, pos))
+          capital = hint.begin(0) + 1
+          boundary = text.rindex(NOT_WORD_CHARACTER, capital - 1)
+          # A word begins on a letter, so a run of leading apostrophes or
+          # hyphens the walk crossed belongs to no word — `'Abc` tokenises to
+          # `Abc`. The capital is itself a letter, so this never runs past it.
+          start = text.index(WORD_FIRST_CHARACTER, boundary.nil? ? 0 : boundary + 1)
+          stop = text.index(NOT_WORD_CHARACTER, capital + 1) || text.length
+          return true if interior_capital?(text[start...stop])
+
+          # Past the whole word: it has just been read in full, so a second
+          # capital inside it would ask the same question again.
+          pos = stop
         end
         false
       end
@@ -1359,29 +1415,7 @@ module Vicary
       # letters, which is what keeps the rule free of any imported collision: it
       # consults no list, so it cannot inherit one's mistakes.
       def written_in_lower_case(text)
-        out = Set.new
-        # `scan` rather than `each_match`, and a byte comparison rather than
-        # `token[0].match?(/[a-z]/)` — which allocated a one-character string
-        # and ran a regex for every word of every document. Exact, not an
-        # approximation: {WORD_TOKEN}'s first character is `[A-Za-z]`, so it is
-        # ASCII and a single byte by construction.
-        text.scan(WORD_TOKEN) do |token|
-          first = token.getbyte(0)
-          next unless first >= 97 && first <= 122
-
-          # {.strip} copies the string whether or not it takes anything off,
-          # and almost no word ends in an apostrophe. Same value either way — a
-          # strip that removes nothing returns an equal string, and the set
-          # holds values.
-          #
-          # Only the tail is worth testing. {.strip} works in from both ends,
-          # and the head was just established to be a lower-case ASCII letter,
-          # so the leading pass stops on the first character every time.
-          lowered = token.downcase
-          lowered = strip(lowered, "'’") if lowered.end_with?("'", "’")
-          out << lowered
-        end
-        out
+        document_casing(text, capitals: false).written_in_lower_case
       end
 
       # The mid-sentence guard: drop a lone capital a sloppy capitaliser chose.
@@ -1947,21 +1981,23 @@ module Vicary
           blocked.any? { |block_start, block_end| start < block_end && finish > block_start }
         end
 
-        written_as_a_capital = mid_sentence_capitals(text, starts, headings)
-        # A property of the whole document, read once, for the same reason
-        # `habit` is: two call sites computing it separately could disagree.
+        # Both casing questions, read once from one pass over the words, for the
+        # same reason `habit` is read once: two call sites computing it
+        # separately could disagree.
+        #
+        # The lower-case half is asked for only where the writer marks proper
+        # nouns at all: that rule reads the ABSENCE of a capital as testimony,
+        # and the habit states in as many words that an absence means nothing in
+        # a LOWERCASE or SILENT document. Running it there would suppress every
+        # capital the writer did manage.
+        casing = document_casing(
+          text, starts, headings,
+          lower_case: case_variance && !given_name.nil? && marks_proper_nouns?(habit),
+        )
+        written_as_a_capital = casing.written_as_a_capital
+        lower_cased = casing.written_in_lower_case
         stray_capitals = mid_sentence_corroboration && !given_name.nil? &&
                          capitalises_ordinary_words?(text, headings)
-        # The mirror of `written_as_a_capital`, read once for the same reason.
-        # Empty unless the writer marks proper nouns at all: this rule reads the
-        # ABSENCE of a capital as testimony, and the habit states in as many
-        # words that an absence means nothing in a LOWERCASE or SILENT document.
-        # Running it there would suppress every capital the writer did manage.
-        lower_cased = if case_variance && !given_name.nil? && marks_proper_nouns?(habit)
-                        written_in_lower_case(text)
-                      else
-                        Set.new
-                      end
 
         out = []
         each_match(text, CANDIDATE_RE) do |m|

data/lib/vicary/conformance.rb

@@ -181,6 +181,23 @@ module Vicary
         raw
       end
 
+      # The placeholder guard's contract: the pattern source, the cases and the
+      # reference's answers. Absent is an error, as for `spans.json`: a guard
+      # checked against nothing reports the same green as one that agrees.
+      def load_placeholders(dir = nil)
+        dir = Pathname.new(dir || directory)
+        path = dir.join("placeholders.json")
+        unless path.file?
+          raise SpecError,
+                "no placeholders.json at #{path}. The ports would check their " \
+                "placeholder guard against nothing."
+        end
+
+        raw = JSON.parse(path.read)
+        require_version(raw["document_version"], "placeholders.json")
+        raw
+      end
+
       # Score an implementation against every frame.
       #
       # The block receives (sentence, identity) — the same input every Python arm

data/lib/vicary/placeholders.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Vicary
+  # Text bound for a reader still carries a redaction placeholder.
+  #
+  # Names the kinds and the count, never the text around them: the message is
+  # going to a log, and the text is exactly what was not supposed to leave.
+  class PlaceholderLeakError < ArgumentError
+    attr_reader :kinds, :count
+
+    def initialize(kinds, count)
+      @kinds = kinds.freeze
+      @count = count
+      noun = count == 1 ? "placeholder" : "placeholders"
+      super("#{count} redaction #{noun} would reach a reader " \
+            "(kinds: #{kinds.join(', ')})")
+    end
+  end
+
+  # The host boundary: assert that no placeholder reaches a reader — the Ruby
+  # port of `python/src/vicary/placeholders.py`.
+  #
+  # vicary masks what it redacts as typed placeholders (`{NAME_1}`,
+  # `{LOCATION_2}`, `{EMAIL}`) and a host restores the ones a reader may see.
+  # Everything else must never be displayed, and two ways one gets out anyway
+  # are invisible to the masker: a model echoes a placeholder the host's restore
+  # map does not cover, or paraphrases one — `[NAME_1]`, `{Name_1}`,
+  # `{ NAME_1 }`, a bare `NAME_1`.
+  #
+  # {assert_no_placeholders} raises before the text is shown;
+  # {scrub_placeholders} removes them (a prose sentence carrying one is dropped,
+  # a quote elides it with `…`). Nothing is rewritten back into a word here.
+  #
+  # The pattern source is byte-identical in all three front doors, written in
+  # the dialect the engines share — ASCII classes rather than `\b`/`\w`/`\s`,
+  # and `\A`/`\z` rather than `^`/`$`, which anchor per line in Ruby.
+  # `test/placeholders_test.rb` compares it with `conformance/placeholders.json`.
+  module Placeholders
+    KINDS = %w[
+      ADDRESS AGE AWS_ACCESS_KEY AWS_SECRET_KEY
+      CREDIT_DEBIT_CARD_CVV CREDIT_DEBIT_CARD_EXPIRY
+      CREDIT_DEBIT_CARD_NUMBER DATE_OF_BIRTH DRIVER_ID EMAIL
+      IP_ADDRESS LICENSE_PLATE LOCATION MAC_ADDRESS NAME
+      ORGANIZATION PASSWORD PERSON PHONE PIN SCHOOL URL
+      US_BANK_ACCOUNT_NUMBER US_BANK_ROUTING_NUMBER US_PASSPORT_NUMBER
+      US_SOCIAL_SECURITY_NUMBER USERNAME ZIP_CODE
+    ].freeze
+    private_constant :KINDS
+
+    # Every placeholder kind vicary or its Guardrail arm can mint, plus
+    # `PERSON`, which is what a model writes when it paraphrases `NAME`.
+    # Longest first, so a match reports the whole kind.
+    PLACEHOLDER_KINDS = KINDS.sort_by { |kind| [-kind.length, kind] }.freeze
+
+    # The kind reported for a `{UPPER_CASE}` token that names no known kind.
+    OTHER_KIND = "OTHER"
+
+    WORD = "[A-Za-z0-9_]"
+    private_constant :WORD
+
+    # `NAME` -> `[Nn][Aa][Mm][Ee]`: case-insensitive in every dialect.
+    def self.fold(kind)
+      kind.chars.map { |c| c.match?(/[A-Z]/) ? "[#{c}#{c.downcase}]" : c }.join
+    end
+    private_class_method :fold
+
+    # Anything placeholder-shaped: vicary's own `{KIND}` / `{KIND_n}` for any
+    # upper-case kind; a known kind in any case inside `{}`, `[]` or `<>` with
+    # stray spaces or tabs; or a bare upper-case `KIND_n` as a whole word.
+    PLACEHOLDER_LIKE = Regexp.new(
+      "\\{[A-Z][A-Z_]*(?:_[0-9]+)?\\}" \
+      "|[{\\[<][ \\t]*(?:#{PLACEHOLDER_KINDS.map { |k| fold(k) }.join('|')})" \
+      "(?:_[0-9]+)?[ \\t]*[}\\]>]" \
+      "|(?<!#{WORD})(?:#{PLACEHOLDER_KINDS.join('|')})_[0-9]+(?!#{WORD})"
+    )
+
+    # A sentence ends at `.`, `!` or `?` followed by whitespace — but not after
+    # an honorific, an initial, `e.g.`, `i.e.` or `vs.`.
+    SENTENCE_END = Regexp.new(
+      "(?<![A-Z][a-z]\\.)" \
+      "(?<!(?<!#{WORD})[A-Z][a-z][a-z]\\.)" \
+      "(?<!(?<!#{WORD})[A-Z]\\.)" \
+      "(?<!(?<!#{WORD})e\\.g\\.)" \
+      "(?<!(?<!#{WORD})i\\.e\\.)" \
+      "(?<!(?<!#{WORD})vs\\.)" \
+      "(?<=[.!?])[ \\t\\n\\r\\f\\v]+"
+    )
+
+    # What stands in for a placeholder when every sentence of a prose field
+    # carries one. Any other kind reads "this".
+    GENERIC_STAND_INS = {
+      "NAME" => "someone",
+      "PERSON" => "someone",
+      "LOCATION" => "a place",
+      "SCHOOL" => "the school",
+      "ORGANIZATION" => "an organization"
+    }.freeze
+
+    TRIM = /\A[ \t\n\r\f\v]+|[ \t\n\r\f\v]+\z/
+    TRIM_TOKEN = /\A[{}\[\]<> \t\n\r\f\v]+|[{}\[\]<> \t\n\r\f\v]+\z/
+    ELISION = /[ \t\n\r\f\v]*…[ \t\n\r\f\v]*/
+    ELISION_BEFORE_PUNCT = / … ([.,;:!?])/
+    NUMBER_SUFFIX = /_[0-9]+\z/
+    private_constant :TRIM, :TRIM_TOKEN, :ELISION, :ELISION_BEFORE_PUNCT,
+                     :NUMBER_SUFFIX
+
+    # One placeholder found in text. `start`/`end` count characters.
+    Match = Struct.new(:text, :kind, :start, :end) do
+      def to_h
+        { "text" => text, "kind" => kind, "start" => start, "end" => self.end }
+      end
+    end
+
+    # Text with every placeholder removed, and how many were.
+    ScrubResult = Struct.new(:text, :removed)
+
+    class << self
+      # The kind a placeholder token names: `[ Name_2 ]` -> `NAME`; else
+      # {OTHER_KIND}.
+      def kind_of(token)
+        kind = token.gsub(TRIM_TOKEN, "").upcase.sub(NUMBER_SUFFIX, "")
+        PLACEHOLDER_KINDS.include?(kind) ? kind : OTHER_KIND
+      end
+
+      # Every placeholder in `text`, in order.
+      def find(text)
+        return [] if text.nil? || text.empty?
+
+        text.to_enum(:scan, PLACEHOLDER_LIKE).map do
+          m = Regexp.last_match
+          Match.new(m[0], kind_of(m[0]), m.begin(0), m.end(0))
+        end
+      end
+
+      # Whether `text` carries any placeholder.
+      def any?(text)
+        !text.nil? && !text.empty? && PLACEHOLDER_LIKE.match?(text)
+      end
+
+      # Return `text` unchanged, or raise {Vicary::PlaceholderLeakError}. Call
+      # it on the last string a host builds before a reader sees it.
+      def assert_none(text)
+        found = find(text)
+        unless found.empty?
+          raise PlaceholderLeakError.new(found.map(&:kind).uniq.sort, found.length)
+        end
+
+        text
+      end
+
+      # Remove every placeholder from `text`. Prose (the default) drops each
+      # sentence carrying one, or — when every sentence does — replaces each
+      # with its {GENERIC_STAND_INS} entry; `quote: true` elides each as `…`.
+      def scrub(text, quote: false)
+        return ScrubResult.new(text, 0) unless any?(text)
+
+        removed = text.scan(PLACEHOLDER_LIKE).length
+        if quote
+          out = text.gsub(PLACEHOLDER_LIKE, "…").gsub(ELISION, " … ")
+                    .gsub(ELISION_BEFORE_PUNCT, ' …\1').gsub(TRIM, "")
+          return ScrubResult.new(out, removed)
+        end
+
+        kept = text.gsub(TRIM, "").split(SENTENCE_END).reject { |s| any?(s) }
+        return ScrubResult.new(kept.join(" "), removed) unless kept.empty?
+
+        out = text.gsub(PLACEHOLDER_LIKE) do |token|
+          GENERIC_STAND_INS.fetch(kind_of(token), "this")
+        end
+        ScrubResult.new(out, removed)
+      end
+    end
+  end
+
+  class << self
+    # Every placeholder in `text` — see {Vicary::Placeholders}.
+    def find_placeholders(text)
+      Placeholders.find(text)
+    end
+
+    # Whether `text` carries any placeholder.
+    def has_placeholders?(text)
+      Placeholders.any?(text)
+    end
+
+    # Return `text`, or raise {Vicary::PlaceholderLeakError}.
+    def assert_no_placeholders(text)
+      Placeholders.assert_none(text)
+    end
+
+    # Remove every placeholder from `text`.
+    def scrub_placeholders(text, quote: false)
+      Placeholders.scrub(text, quote: quote)
+    end
+  end
+end

data/lib/vicary/version.rb

@@ -6,5 +6,5 @@ module Vicary
   # Shared across all three front doors on purpose: one detector, one number. A
   # gem 0.3.0 that corresponds to nothing on PyPI cannot be reasoned about, and
   # the parity claim is between *versions*, not between package names.
-  VERSION = "0.2.14"
+  VERSION = "0.2.16"
 end

data/lib/vicary.rb

@@ -44,3 +44,4 @@ require_relative "vicary/corpus"
 require_relative "vicary/latency_baseline"
 require_relative "vicary/redact"
 require_relative "vicary/spans"
+require_relative "vicary/placeholders"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vicary
 version: !ruby/object:Gem::Version
-  version: 0.2.14
+  version: 0.2.16
 platform: ruby
 authors:
 - Blake Thomas
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-13 00:00:00.000000000 Z
+date: 2026-10-19 00:00:00.000000000 Z
 dependencies: []
 description: |
   Finds the names a student writes about — classmates, teachers, relatives — and
@@ -38,6 +38,7 @@ files:
 - lib/vicary/latency_baseline.rb
 - lib/vicary/lexicon.rb
 - lib/vicary/minter.rb
+- lib/vicary/placeholders.rb
 - lib/vicary/redact.rb
 - lib/vicary/spans.rb
 - lib/vicary/structured.rb