acute 1.0.0

data/lib/acute/tool/compact.rb

@@ -0,0 +1,82 @@
+module Acute
+  class Tool
+    # The model pays for every char of a result on every call, so a tool gives the library's JSON without what
+    # repeats: the input's echo, a begin equal to time, a mention's kind and text again in its value, the expected
+    # reading of a verdict that holds, now's offset, which the now string ends with, a rule's ical when it holds
+    # only its dtstart and rrule, whichever of cron and cron_reason is null, and empty lists. An assumption's
+    # message is its short form, the gist in about half the chars. The schema rules make the same cuts in the output
+    # schemas, so the two can't drift.
+    # @api private
+    module Compact
+      def self.call(out)
+        case out["kind"]
+        when "time" then result(out)
+        when "extraction"
+          out.delete("text")
+          out["mentions"].each do |m|
+            m.delete("kind")
+            case m["value"]["kind"]
+            when "time" then result(m["value"])
+            when "rule" then rule(m["value"])
+            end
+          end
+        when "verdict"
+          out.delete("text")
+          if out["ok"] then out.delete("expected")
+          elsif out["expected"] then result(out["expected"])
+          end
+        when "rule" then rule(out)
+        when "now" then out.delete("offset")
+        end
+        out.delete("unread") if out["unread"] == []
+        out
+      end
+
+      def self.result(r)
+        r.delete("text")
+        if r["assumptions"].empty? then r.delete("assumptions")
+        else r["assumptions"].each { _1["message"] = Assumption.for(_1["code"].to_sym).short }
+        end
+        r.delete("alternatives") if r["alternatives"].empty?
+        [r, *r["alternatives"]].each { _1.delete("begin") if _1["begin"] == _1["time"] }
+      end
+      private_class_method :result
+
+      def self.rule(r)
+        r.delete("text")
+        r.delete("ical") unless r["ical"].include?("\nEXDATE")
+        r.delete(r["cron"] ? "cron_reason" : "cron")
+      end
+      private_class_method :rule
+
+      # defs: the schemas tool's output schema holds, by file name, before they are inlined. The recurrence tool
+      # adds a rule's first occurrences, and extract a count of the mentions past its cap.
+      def self.schema(defs, tool)
+        trim(defs["result"], drop: %w[text], optional: %w[begin assumptions alternatives])
+        trim(defs.dig("result", "properties", "alternatives", "items"), optional: %w[begin])
+        trim(defs["extraction"], drop: %w[text])
+        trim(defs.dig("extraction", "properties", "mentions", "items"), drop: %w[kind])
+        defs["extraction"]["properties"]["more"] = { "type" => "integer" } if defs["extraction"]
+        trim(defs["verdict"], drop: %w[text], optional: %w[expected unread])
+        if (rule = defs["rule"])
+          trim(rule, drop: %w[text], optional: %w[ical cron cron_reason])
+          rule["properties"] = rule["properties"].merge("cron" => { "type" => "string" }, "cron_reason" => { "type" => "string" })
+        end
+        if tool == "recurrence"
+          rule["properties"]["next"] = { "type" => "array", "items" => { "type" => "string" }, "maxItems" => OCCURRENCES }
+          rule["required"] += ["next"]
+        end
+        trim(defs["now"], drop: %w[offset])
+        trim(defs["failure"], drop: %w[text]) # T5: a tool never echoes its input
+        defs
+      end
+
+      def self.trim(node, drop: [], optional: [])
+        return unless node
+        node["properties"] = node["properties"].except(*drop)
+        node["required"] -= drop + optional
+      end
+      private_class_method :trim
+    end
+  end
+end

data/lib/acute/tool/ruby_llm.rb

@@ -0,0 +1,29 @@
+begin
+  require "ruby_llm"
+rescue LoadError => e
+  raise LoadError, "acute/tool/ruby_llm needs the ruby_llm gem; add it to your Gemfile (#{e.message})"
+end
+require_relative "../tool"
+
+module Acute
+  class Tool
+    # One RubyLLM::Tool per tool, bound to this one's options: chat.with_tools(*Acute::Tool.new(zone: user.zone).ruby_llm)
+    def ruby_llm = definitions.map { RubyLLMTool.new(self, _1) }
+
+    # RubyLLM reads a tool's name, description and parameters_schema from the instance, and validates the
+    # arguments against execute's keywords before calling it, so execute takes any and Acute::Tool checks them
+    class RubyLLMTool < ::RubyLLM::Tool
+      attr_reader :name, :description, :parameters_schema
+
+      def initialize(tool, definition)
+        super()
+        @tool = tool
+        @name = definition[:name]
+        @description = definition[:description]
+        @parameters_schema = definition[:input_schema]
+      end
+
+      def execute(**arguments) = @tool.call(@name, arguments)
+    end
+  end
+end

data/lib/acute/tool.rb

@@ -0,0 +1,192 @@
+require_relative "../acute"
+require_relative "tool/compact"
+
+module Acute
+  # The tools an app's LLM calls, for any SDK. The app fixes the options at construction; the input schemas in
+  # schema/tools/ leave them out, so the model can't set them. What the model sends is a boundary: anything wrong
+  # with it comes back as a failure value. T5: no string the model reads as prose quotes its input; text
+  # that needs pointing at goes in unread, which the schema marks as data.
+  class Tool
+    # @api private: NAMES, SCHEMAS and UNREAD_LENGTH are read by MCP
+    NAMES = %w[parse duration recurrence extract verify describe now].freeze
+    SCHEMAS = Ractor.make_shareable(NAMES.to_h do |name|
+      [name, JSON.parse(File.read(File.expand_path("../../schema/tools/#{name}.json", __dir__)))]
+    end)
+    UNREAD = 5
+    OCCURRENCES = 3
+    MENTIONS = 50 # T34: a reply many times its text would crowd the model's context
+    UNREAD_LENGTH = 60
+    PARSE_ERRORS = {
+      unknown_word: "acute couldn't read the words in unread",
+      invalid_date: "the date or time in unread doesn't exist",
+      incomplete: "the phrase is incomplete",
+      conflict: "the words in unread don't fit with the rest of the phrase",
+      not_rule: "not a repeating time",
+      vague_rule: "the phrase says how often, not when: ask the user which days or times",
+      no_occurrence: "the rule ends before it starts",
+      dst_skipped_time: "the time in unread is skipped as the clocks go forward: ask the user for a time either side of it",
+      dst_repeated_time: "the time in unread happens twice as the clocks go back: ask the user which they meant",
+      business_day_limit: "more than #{Resolve::Period::LIMIT} business days in one call is too many to count",
+      too_long: "the text is longer than #{MAX_LENGTH} bytes",
+      invalid_encoding: "the text is not valid UTF-8"
+    }.freeze
+    OPTION_ERRORS = { value: "value must be an ISO 8601 time or date" }.freeze
+    POINTED = %i[invalid_date conflict dst_skipped_time dst_repeated_time].freeze
+    ISO_DURATION = /\AP(?!\z)(?:(\d+(?:\.\d+)?)Y)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?
+                   (?:T(?=\d)(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?\z/x
+    ISO_PARTS = %i[years months weeks days hours minutes seconds].freeze
+    ISO_TIME = /\A\d{4}-\d\d-\d\d(?:[T ]|\z)/
+    private_constant :UNREAD, :OCCURRENCES, :MENTIONS, :PARSE_ERRORS, :OPTION_ERRORS, :POINTED, :ISO_DURATION, :ISO_PARTS, :ISO_TIME
+
+    attr_reader :parser, :prefix
+
+    def initialize(parser = nil, prefix: "", **options)
+      raise ArgumentError, "expected a parser Acute.with made, got #{parser.class}" unless parser.nil? || Parser === parser
+      # Tool names may hold letters, digits, _ and -, and no more than 64 of them
+      unless String === prefix && prefix.valid_encoding? && prefix.match?(/\A[A-Za-z0-9_-]{0,56}\z/)
+        raise OptionError.new("prefix: must be up to 56 letters, digits, _ or -", option: :prefix, value: prefix)
+      end
+      @parser = (parser || Acute).with(**options)
+      @prefix = -prefix
+      freeze
+    end
+
+    def definitions(format = :anthropic)
+      NAMES.map do |name|
+        schema = SCHEMAS[name]
+        full = "#{@prefix}#{name}"
+        description = schema["description"].gsub(/\{(\w+)\}/) { "#{@prefix}#{$1}" }
+        input = schema.except("$schema", "$id", "title", "description")
+        case format
+        when :anthropic then { name: full, description: description, input_schema: input }
+        when :openai then { type: "function", function: { name: full, description: description, parameters: input } }
+        else raise ArgumentError, "format must be :anthropic or :openai, got #{format.inspect}"
+        end
+      end
+    end
+
+    # arguments as an SDK gives them: a Hash with string or symbol keys, or OpenAI's JSON string
+    def call(name, arguments) = Compact.(answer(name, arguments))
+
+    def inspect = "#<Acute::Tool #{"prefix: #{@prefix.inspect} " unless @prefix.empty?}#{@parser.inspect}>"
+
+    private
+
+    def answer(name, arguments)
+      tool = name.delete_prefix(@prefix) if String === name && name.valid_encoding? && name.start_with?(@prefix)
+      return failure(:unknown_tool, "there is no tool by the name in unread", [name]) unless NAMES.include?(tool)
+      args = arguments(arguments) or return failure(:invalid_argument, "the arguments must be a JSON object")
+      wrong = check(SCHEMAS[tool], args) and return wrong
+      run(tool, args)
+    rescue ParseError => e
+      parse_failure(e, args["text"])
+    rescue OptionError => e
+      failure(:invalid_argument, OPTION_ERRORS.fetch(e.option, "#{e.option} isn't one acute can use"), [e.value])
+    end
+
+    def arguments(given)
+      given = JSON.parse(given) if String === given
+      # A null is an argument left out, as some SDKs send every optional one
+      given.to_h { |k, v| [k.to_s, v] }.compact if Hash === given
+    rescue JSON::ParserError, EncodingError
+      nil
+    end
+
+    def check(schema, args)
+      props = schema["properties"]
+      unknown = args.keys - props.keys
+      return failure(:unknown_argument, "there are no arguments by the names in unread", unknown) if unknown.any?
+      missing = schema["required"].to_a - args.keys
+      return failure(:missing_argument, "#{missing.join(" and ")} #{missing.size == 1 ? "is" : "are"} required") if missing.any?
+      args.each do |key, value|
+        prop = props[key]
+        error =
+          if prop["enum"] then "#{key} must be one of #{prop["enum"].join(", ")}" unless prop["enum"].include?(value)
+          elsif !(String === value) then "#{key} must be a string"
+          elsif !value.valid_encoding? then "#{key} is not valid UTF-8"
+          elsif value.length > prop["maxLength"] then "#{key} is longer than #{prop["maxLength"]} characters"
+          end
+        return failure(:invalid_argument, error) if error
+      end
+      nil
+    end
+
+    def run(tool, args)
+      text = args["text"]
+      context = args.key?("context") ? { context: args["context"].to_sym } : {}
+      case tool
+      when "parse" then @parser.parse!(text, **context).as_json
+      when "duration" then @parser.duration!(text).as_json
+      when "recurrence" then recurrence(text)
+      when "extract" then extract(text, context)
+      when "verify" then verify(text, args["value"], context)
+      when "describe" then describe(args["value"], args.fetch("style", "relative").to_sym)
+      else now
+      end
+    end
+
+    def verify(text, value, context)
+      Acute.send(:verifier, text, value, **@parser.options, **context).tool_verdict.as_json.merge("unread" => [])
+    rescue ParseError => e
+      failed = parse_failure(e, text)
+      message = "The text can't be read: #{failed["error"]}. Ask the user to rephrase."
+      Verdict.new(text, :unparsed, message, nil).as_json.merge("unread" => failed["unread"])
+    end
+
+    # The rule's first occurrences, DTSTART's included, so the model can check what it set up. each rather than
+    # next: next counts from now and leaves out a DTSTART equal to it. each ends when its steps run out, so a
+    # rule whose occurrences are that far apart lists fewer.
+    def recurrence(text)
+      rule = @parser.recurrence!(text)
+      rule.as_json.merge("next" => rule.each.first(OCCURRENCES).map(&:iso8601))
+    end
+
+    # more: how many mentions past the first MENTIONS were left out
+    def extract(text, context)
+      json = @parser.extract(text, **context).as_json
+      more = json["mentions"].size - MENTIONS
+      return json unless more.positive?
+      json["mentions"] = json["mentions"].first(MENTIONS)
+      json.merge("more" => more)
+    end
+
+    def describe(value, style)
+      target = duration(value) || (@parser.parse(value, strict: true) if value.match?(ISO_TIME))
+      return failure(:invalid_argument, "value must be an ISO 8601 time, date or duration", [value]) unless target
+      { "kind" => "description", "description" => @parser.describe(target, style: style) }
+    end
+
+    def duration(value)
+      m = ISO_DURATION.match(value) or return
+      Duration.new(**ISO_PARTS.zip(m.captures).to_h { |part, n| [part, n && (n.include?(".") ? n.to_r : n.to_i)] })
+    end
+
+    def now
+      ctx = Context.new(@parser.options[:now], @parser.options[:zone], :future)
+      zone = ctx.zone
+      at = ctx.now
+      change = zone.next_change(at)
+      local = Time.at(at, in: zone.offset_at(at))
+      { "kind" => "now", "now" => local.strftime("%FT%T%:z"), "weekday" => local.strftime("%A"), "zone" => zone.name,
+        "offset" => local.strftime("%:z"), "dst" => !change.nil? && zone.offset_at(at) > zone.offset_at(change),
+        "next_change" => change && Time.at(change, in: zone.offset_at(change)).strftime("%FT%T%:z") }
+    end
+
+    def parse_failure(e, text)
+      unread = e.code == :unknown_word ? e.unknown : POINTED.include?(e.code) ? [text[e.position]] : []
+      found = failure(e.code, Explain.reason(e, text) || PARSE_ERRORS.fetch(e.code), unread)
+      # a position over the whole phrase tells the model nothing the error doesn't
+      found["position"] = [e.position.begin, e.position.end] unless whole?(e.position, text)
+      # only unknown_word's hint is for the model; the others name library options the app fixes
+      found["hint"] = e.hint if e.hint && e.code == :unknown_word
+      found
+    end
+
+    def whole?(span, text) = text[0...span.begin].strip.empty? && text[span.end..].to_s.strip.empty?
+
+    def failure(code, error, unread = [])
+      words = unread.first(UNREAD).map { _1.to_s.dup.force_encoding(Encoding::UTF_8).scrub[0, UNREAD_LENGTH] }
+      { "kind" => "failure", "code" => code.to_s, "error" => error, "unread" => words }
+    end
+  end
+end

data/lib/acute/verify.rb

@@ -0,0 +1,216 @@
+module Acute
+  def self.verify(text, value, now: nil, zone: nil, context: :future, locale: nil, week_start: nil, hemisphere: nil,
+                  fiscal_year_start: nil, strict: true, dst: nil, holidays: nil, business_days: nil, year_bias: nil)
+    verifier(text, value, now:, zone:, context:, locale:, week_start:, hemisphere:, fiscal_year_start:, strict:, dst:,
+                          holidays:, business_days:, year_bias:).verdict
+  end
+
+  # Acute::Tool takes the Verify, by send, to word the verdict without the input (T5)
+  def self.verifier(text, value, now: nil, zone: nil, context: :future, locale: nil, week_start: nil, hemisphere: nil,
+                    fiscal_year_start: nil, strict: true, dst: nil, holidays: nil, business_days: nil, year_bias: nil)
+    ctx = Context.new(now, zone, context, locale, week_start, hemisphere, fiscal_year_start, strict, dst, holidays,
+                      business_days, year_bias)
+    opts = { now: Time.at(ctx.now), zone: zone, context: context, locale: locale, week_start: week_start,
+             hemisphere: hemisphere, fiscal_year_start: fiscal_year_start, strict: strict, dst: dst,
+             holidays: holidays, business_days: business_days, year_bias: year_bias }
+    Verify.new(text, value, ctx, opts)
+  end
+  private_class_method :verifier
+
+  # Whether a time someone else worked out is what the text says. The message is written to go straight back
+  # to a model (D45).
+  class Verdict
+    STATUSES = %i[match inside alternative mismatch unparsed].freeze
+    OK = %i[match inside alternative].freeze
+    private_constant :STATUSES, :OK
+
+    attr_reader :text, :status, :message, :expected
+
+    # @api private
+    def initialize(text, status, message, expected)
+      @text = text
+      @status = status
+      @message = Acute.visible(message)
+      @expected = expected
+      freeze
+    end
+
+    def ok? = OK.include?(@status)
+
+    # JSON can't hold invalid UTF-8, so such a text is given scrubbed
+    def to_h = { kind: "verdict", text: @text.dup.force_encoding(Encoding::UTF_8).scrub, status: @status.to_s, ok: ok?, message: @message, expected: @expected&.to_h }
+
+    def to_json(*args) = to_h.to_json(*args)
+
+    def as_json(*) = JSON.parse(to_json)
+
+    def inspect = "#<Acute::Verdict #{@status} #{@message.inspect}>"
+  end
+
+  # @api private
+  class Verify
+    DAY = 86_400
+    ORDINALS = %w[first second third fourth fifth sixth seventh eighth ninth tenth].freeze
+    DATE = /\A\d{4}-\d\d-\d\d\z/
+
+    def initialize(text, value, ctx, opts)
+      @text = text
+      @ctx = ctx
+      @zone = ctx.zone
+      @opts = opts
+      @value = target(value)
+      @given = given(value)
+    end
+
+    def verdict
+      judge(@given, @text.inspect)
+    rescue ParseError => e
+      Verdict.new(@text, :unparsed, "#{shorten(@text)} can't be read as a time: #{unknown(e)}. Ask the user to say it " \
+                                    "another way.", nil)
+    end
+
+    # T5: the message names the text by its readings' labels and a mismatched value as acute normalised it, never
+    # as they came in; the model knows which value it sent. A text it can't read raises the ParseError, for the caller to word.
+    def tool_verdict = judge("the value", "the text")
+
+    private
+
+    def judge(value, text)
+      r = Acute.parse!(@text, **@opts)
+      also = others(r, " It can also mean %s; ask the user if that matters.")
+      status = relation(r)
+      i = r.alternatives.index { relation(_1) } unless status
+      status ||= i ? :alternative : :mismatch
+      message =
+        case status
+        when :match then "#{value} matches #{text}: #{label(r)}.#{also}"
+        when :inside then "#{value} is inside #{text}, which is #{label(r)}.#{also}"
+        when :alternative
+          "#{value} is the #{ORDINALS[i + 1] || "#{i + 2}th"} reading of #{text}; the first is #{label(r)}. Ask the user " \
+          "which they meant."
+        else "#{text} is #{label(r)}#{others(r, " (or %s)")}, not #{label(@value)}."
+        end
+      # the tool's subjects begin a sentence in lower case; the library's are a quote or a digit
+      Verdict.new(@text, status, message.sub(/\A\w/, &:upcase), r)
+    end
+
+    def unknown(error)
+      words = error.unknown
+      return error.message.length > 80 ? "#{error.message[0, 80]}…" : error.message if words.empty?
+      shown = words.first(5).map { shorten(_1, 20) }
+      "unknown #{words.size == 1 ? "word" : "words"} #{shown.join(", ")}#{" and #{words.size - 5} more" if words.size > 5}"
+    end
+
+    def others(r, form) = r.ambiguous? ? format(form, r.alternatives.map { label(_1) }.join(" or ")) : ""
+
+    # A date ("2026-10-23", a Date or a range of them) is checked by its days; anything else by its instants
+    def target(value)
+      @days = Date === value || (Range === value && (Date === value.begin || Date === value.end))
+      if String === value
+        # never the lenient reading: trailing words are not an ISO 8601 string
+        r = (Acute.parse(value, **@opts, strict: true) if readable?(value) && value.match?(/\A\d{4}-\d\d-\d\d/))
+        unless r && !r.ambiguous?
+          raise OptionError.new("value must be a Time, Date, Range or ISO 8601 string, got #{shorten(value)}",
+                                option: :value, value: value)
+        end
+        @days = DATE.match?(value)
+        @parsed = value = r
+      end
+      Describe::Target.for(value, @ctx)
+    end
+
+    def given(value)
+      case value
+      when String then @days ? @parsed.date.iso8601 : moment_iso(@parsed)
+      when Date then value.iso8601
+      when Range then "#{given(value.begin) if value.begin}#{value.exclude_end? ? "..." : ".."}#{given(value.end) if value.end}"
+      else value.respond_to?(:to_time) ? value.to_time.getlocal(@zone.offset_at(value.to_time.to_i)).strftime("%FT%T%:z") : value.inspect
+      end
+    end
+
+    def readable?(string) = (string.encoding == Encoding::UTF_8 || string.encoding == Encoding::US_ASCII) && string.valid_encoding?
+
+    def shorten(string, limit = 60) = string.length > limit ? "#{string[0, limit].inspect[0..-2]}…\"" : string.inspect
+
+    def moment_iso(r)
+      return r.time.getlocal(@zone.offset_at(r.time.to_i)).strftime("%FT%T%:z") if r.instant?
+      "#{r.begin && moment_iso_at(r.begin)}..#{r.end && moment_iso_at(r.end)}"
+    end
+
+    def moment_iso_at(t) = t.getlocal(@zone.offset_at(t.to_i)).strftime("%FT%T%:z")
+
+    # :match when the reading is the value, :inside when the value lies within it
+    def relation(r)
+      v = @value
+      span = [r.begin&.to_i, r.end&.to_i]
+      if @days
+        return :match if cover(r) == [v.b, v.e]
+      elsif v.instant
+        return :match if r.instant? && r.time.to_i == v.point
+        return r.instant? || !within?(span, v.point, v.point + 1) ? nil : :inside
+      elsif !r.instant? && span == [v.b, v.e]
+        return :match
+      end
+      :inside if !r.instant? && within?(span, v.b, v.e)
+    end
+
+    def within?((b, e), vb, ve) = (b.nil? || (vb && vb >= b)) && (e.nil? || (ve && ve <= e))
+
+    # The whole days a reading falls on; one of a day or less ("tonight", "3pm") is its point's day
+    def cover(r)
+      b = r.begin&.to_i
+      e = r.end&.to_i
+      if b && e && e - b <= DAY
+        d = day_of(r.time.to_i)
+        return [day_start(d), day_start(d + 1)]
+      end
+      [b && day_start(day_of(b)), e && day_start(day_of(e - 1) + 1)]
+    end
+
+    # "Fri 23 Oct", "Fri 23 Oct, 3pm", "Sat 17 Oct – Sun 18 Oct", "from Sat 24 Oct": one form whatever the
+    # locale, as the reader is a model
+    def label(x)
+      if Result === x
+        return @days ? day(day_of(x.time.to_i)) : moment(x.time.to_i) if x.instant?
+        b, e = @days ? cover(x) : [x.begin&.to_i, x.end&.to_i]
+      else
+        return moment(x.point) if x.instant
+        b = x.b
+        e = x.e
+      end
+      return "from #{edge(b)}" unless e
+      return "before #{edge(e)}" unless b
+      return days(b, e) if aligned?(b) && aligned?(e)
+      return "#{moment(b)} – #{Describe.clock(secs_of(e))}" if day_of(b) == day_of(e)
+      "#{moment(b)} – #{moment(e)}"
+    end
+
+    def days(b, e)
+      first = day_of(b)
+      last = day_of(e - 1)
+      first == last ? day(first) : "#{day(first)} – #{day(last)}"
+    end
+
+    def edge(t) = aligned?(t) ? day(day_of(t)) : moment(t)
+
+    def moment(t) = "#{day(day_of(t))}, #{Describe.clock(secs_of(t))}"
+
+    def day(d)
+      x = Calendar.civil_from_days(d)
+      year = x / 10_000 == Calendar.civil_from_days(@ctx.today) / 10_000 ? "" : " #{x / 10_000}"
+      "#{Result::WEEKDAYS[Calendar.weekday(d)]} #{x % 100} #{Result::MONTHS[x / 100 % 100 - 1]}#{year}"
+    end
+
+    def local(t) = t + @zone.offset_at(t)
+
+    def day_of(t) = local(t).div(DAY)
+
+    def secs_of(t) = local(t) % DAY
+
+    def day_start(d) = @zone.local_to_utc(d * DAY, @ctx)
+
+    def aligned?(t) = day_start(day_of(t)) == t
+  end
+
+  private_constant :Verify
+end

data/lib/acute/version.rb

@@ -0,0 +1,3 @@
+module Acute
+  VERSION = "1.0.0".freeze
+end