acute 1.0.0

data/lib/acute/mcp.rb

@@ -0,0 +1,224 @@
+require "json"
+require_relative "tool"
+
+module Acute
+  # acute mcp: Acute::Tool as an MCP server, one JSON-RPC message per line of stdin and stdout. Dual-era: a request
+  # whose _meta names a modern version is served statelessly as that version; an initialize opens a legacy session.
+  # T5: no error message quotes the input. The tool's own failures put it in unread.
+  # @api private
+  class MCP
+    MODERN = %w[2026-07-28].freeze
+    LEGACY = %w[2025-11-25 2025-06-18].freeze
+    VERSION_KEY = "io.modelcontextprotocol/protocolVersion".freeze
+    LINE_LIMIT = 64 * 1024
+    PARSE_ERROR = -32_700
+    INVALID_REQUEST = -32_600
+    METHOD_NOT_FOUND = -32_601
+    INVALID_PARAMS = -32_602
+    INTERNAL_ERROR = -32_603
+    UNSUPPORTED_VERSION = -32_022
+    ZONED = %w[parse recurrence extract verify describe now].freeze
+    ZONE_LENGTH = 64
+    ZONE = {
+      "type" => "string", "maxLength" => ZONE_LENGTH,
+      "description" => "Only if the user names a zone not their own (\"3pm London time\"): IANA or UTC offset"
+    }.freeze
+    ZONE_ERROR = "zone must be an IANA time zone or a UTC offset such as +05:30".freeze
+    OUTPUTS = { "parse" => "result", "duration" => "duration", "recurrence" => "rule", "extract" => "extraction",
+                "verify" => "verdict", "describe" => "description", "now" => "now" }.freeze
+    ANNOTATIONS = %w[title description examples $comment].freeze
+    NAMED = %w[properties $defs].freeze
+    SCHEMAS = File.expand_path("../../schema", __dir__)
+
+    Refusal = Class.new(StandardError) do
+      attr_reader :code, :data
+
+      def initialize(code, message, data = nil)
+        super(message)
+        @code = code
+        @data = data
+      end
+    end
+
+    # A tool's own schema or a failure, in one self-contained document: the schemas it refers to are inlined, so a
+    # client resolves everything without fetching
+    def self.output_schema(name)
+      defs = {}
+      hoist = lambda do |file|
+        return if defs.key?(file)
+        defs[file] = nil
+        schema = JSON.parse(File.read(File.join(SCHEMAS, "#{file}.json")))
+        defs.merge!(schema.delete("$defs") || {})
+        defs[file] = localise(schema.except("$schema", "$id"), hoist)
+      end
+      own = OUTPUTS.fetch(name)
+      [own, "failure"].each(&hoist)
+      defs = bare(Tool::Compact.schema(defs, name), names: true)
+      root = [own, "failure"].map { { "$ref" => "#/$defs/#{_1}" } }
+      uses = JSON.generate([root, defs]).scan(%r{"#/\$defs/(\w+)"}).flatten.tally
+      schema = { "type" => "object", "oneOf" => inline(root, defs, uses) }
+      shared = defs.select { uses.fetch(_1, 0) > 1 }.transform_values { inline(_1, defs, uses) }
+      shared.empty? ? schema : schema.merge("$defs" => shared)
+    end
+
+    # The model's host pays for every char of a listing, and the annotations are for people: validation needs only
+    # the structure. Under properties and $defs the keys are names, never annotations.
+    def self.bare(node, names: false)
+      case node
+      when Hash
+        node.each_with_object({}) do |(key, value), out|
+          out[key] = bare(value, names: !names && NAMED.include?(key)) if names || !ANNOTATIONS.include?(key)
+        end
+      when Array then node.map { bare(_1) }
+      else node
+      end
+    end
+
+    # A schema referred to once is written in place; only those referred to more than once stay in $defs
+    def self.inline(node, defs, uses)
+      case node
+      when Hash
+        ref = node["$ref"]&.delete_prefix("#/$defs/")
+        return inline(defs.fetch(ref), defs, uses).merge(node.except("$ref")) if ref && uses[ref] == 1
+        node.transform_values { inline(_1, defs, uses) }
+      when Array then node.map { inline(_1, defs, uses) }
+      else node
+      end
+    end
+
+    def self.localise(node, hoist)
+      case node
+      when Hash
+        node.to_h do |key, value|
+          next [key, localise(value, hoist)] unless key == "$ref" && value.end_with?(".json")
+          file = value.delete_suffix(".json")
+          hoist.(file)
+          [key, "#/$defs/#{file}"]
+        end
+      when Array then node.map { localise(_1, hoist) }
+      else node
+      end
+    end
+
+    def initialize(tool = Tool.new, log: nil)
+      @tool = tool
+      @log = log
+      @tools = tool.definitions.map { listing(_1) }
+      @names = @tools.to_h { [_1["name"], _1["name"].delete_prefix(tool.prefix)] }
+    end
+
+    def serve(input, output)
+      while (line = read(input))
+        next if String === line && line.strip.empty?
+        reply = line == :oversize ? error(nil, INVALID_REQUEST, "Invalid request: the line is too long") : handle(line)
+        next unless reply
+        output.write("#{JSON.generate(reply)}\n")
+        output.flush
+      end
+    end
+
+    private
+
+    def handle(line)
+      line = line.dup.force_encoding(Encoding::UTF_8)
+      return error(nil, PARSE_ERROR, "Parse error") unless line.valid_encoding?
+      respond(JSON.parse(line))
+    rescue JSON::ParserError
+      error(nil, PARSE_ERROR, "Parse error")
+    end
+
+    def read(input)
+      line = input.gets("\n", LINE_LIMIT + 1) or return
+      return line if line.end_with?("\n") || line.bytesize <= LINE_LIMIT
+      while (rest = input.gets("\n", LINE_LIMIT))
+        break if rest.end_with?("\n")
+      end
+      :oversize
+    end
+
+    def respond(message)
+      return error(nil, INVALID_REQUEST, "Invalid request") unless Hash === message
+      # Notifications get no reply, whatever they are
+      return if !message.key?("id") && String === message["method"]
+      id = message["id"]
+      return error(nil, INVALID_REQUEST, "Invalid request") unless String === id || Integer === id
+      params = message.fetch("params", {})
+      unless message["jsonrpc"] == "2.0" && String === message["method"] && Hash === params
+        return error(id, INVALID_REQUEST, "Invalid request")
+      end
+      { "jsonrpc" => "2.0", "id" => id, "result" => dispatch(message["method"], params) }
+    rescue Refusal => e
+      error(id, e.code, e.message, e.data)
+    rescue StandardError => e
+      @log&.puts "acute mcp: #{e.class} at #{e.backtrace&.first}"
+      error(id, INTERNAL_ERROR, "Internal error")
+    end
+
+    def dispatch(method, params)
+      meta = params["_meta"]
+      version = meta[VERSION_KEY] if Hash === meta && meta.key?(VERSION_KEY)
+      if version && !MODERN.include?(version)
+        raise Refusal.new(UNSUPPORTED_VERSION, "Unsupported protocol version", { "supported" => MODERN })
+      end
+      result =
+        case method
+        when "initialize" then opening(params["protocolVersion"])
+        when "server/discover" then discovery
+        when "ping" then {}
+        when "tools/list" then { "tools" => @tools }
+        when "tools/call" then call(params["name"], params.fetch("arguments", {}))
+        else raise Refusal.new(METHOD_NOT_FOUND, "Method not found")
+        end
+      version ? result.merge("resultType" => "complete") : result
+    end
+
+    def server_info = { "name" => "acute", "version" => VERSION }
+
+    # A legacy client asking for a version this server doesn't speak gets the latest legacy one: the modern
+    # versions have no initialize
+    def opening(asked)
+      { "protocolVersion" => LEGACY.include?(asked) ? asked : LEGACY.first, "capabilities" => { "tools" => {} },
+        "serverInfo" => server_info }
+    end
+
+    def discovery
+      { "supportedVersions" => MODERN, "capabilities" => { "tools" => {} },
+        "_meta" => { "io.modelcontextprotocol/serverInfo" => server_info } }
+    end
+
+    def call(name, args)
+      # A Tool with a prefix: lists and answers to the prefixed names only, as Tool#call does
+      base = @names[name] or raise Refusal.new(INVALID_PARAMS, "Unknown tool")
+      raise Refusal.new(INVALID_PARAMS, "Invalid params: arguments must be an object") unless Hash === args
+      zone = args["zone"] if ZONED.include?(base)
+      value = zone.nil? ? @tool.call(name, args) : zoned(zone)&.call(name, args.except("zone")) || zone_failure(zone)
+      { "content" => [{ "type" => "text", "text" => JSON.generate(value) }], "structuredContent" => value,
+        "isError" => value["kind"] == "failure" }
+    end
+
+    def zoned(zone)
+      return unless String === zone && zone.length <= ZONE_LENGTH
+      Tool.new(@tool.parser, prefix: @tool.prefix, zone: zone)
+    rescue OptionError
+      nil
+    end
+
+    def zone_failure(zone)
+      unread = String === zone ? [zone[0, Tool::UNREAD_LENGTH]] : []
+      Tool::Compact.({ "kind" => "failure", "code" => "invalid_argument", "error" => ZONE_ERROR, "unread" => unread })
+    end
+
+    def listing(definition)
+      name = definition[:name]
+      base = name.delete_prefix(@tool.prefix)
+      input = definition[:input_schema]
+      input = input.merge("properties" => input["properties"].merge("zone" => ZONE)) if ZONED.include?(base)
+      { "name" => name, "description" => definition[:description], "inputSchema" => input,
+        "outputSchema" => self.class.output_schema(base) }
+    end
+
+    def error(id, code, message, data = nil)
+      { "jsonrpc" => "2.0", "id" => id, "error" => { "code" => code, "message" => message, "data" => data }.compact }
+    end
+  end
+end

data/lib/acute/parser.rb

@@ -0,0 +1,66 @@
+module Acute
+  def self.with(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)
+    Parser.new(now: 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)
+  end
+
+  # Every entry point with the same options. Frozen and Ractor-shareable; options given to a call override
+  # the parser's (D45). D47: a holidays: or business_days: object is kept as given, not frozen, so a parser
+  # holding one is shareable only if the object already is.
+  class Parser
+    attr_reader :options
+
+    def initialize(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)
+      # A now that carries a zone (a TimeWithZone) gives the parser that zone, as each call would infer it
+      zone ||= ctx.zone.name if Context.carried_zone(now)
+      # Copies, so making the parser shareable freezes nothing of the caller's
+      opts = { now: now && Time.at(ctx.now).utc, zone: zone && -ctx.zone.name, context: context,
+               locale: locale && -locale.to_s, week_start: week_start&.to_sym, hemisphere: hemisphere&.to_sym,
+               fiscal_year_start: fiscal_year_start && Integer(fiscal_year_start), strict: strict == false ? false : nil,
+               dst: dst&.to_sym, year_bias: year_bias && Integer(year_bias) }
+      # A region is copied; an object answering holiday? or business_day? is the caller's, so it is kept as is
+      holidays = Array(holidays).map(&:to_sym) if Symbol === holidays || String === holidays || Array === holidays
+      @options = opts.merge(holidays: holidays, business_days: business_days).compact
+      # extract takes no strict:, as it always skips unknown words
+      @extract_options = @options.except(:strict)
+      objects = [holidays, business_days].compact.reject { Array === _1 }
+      if objects.all? { Ractor.shareable?(_1) }
+        Ractor.make_shareable(self)
+      else
+        @options.each_value { Ractor.make_shareable(_1) unless objects.include?(_1) }
+        @options.freeze
+        @extract_options.freeze
+        freeze
+      end
+    end
+
+    def parse(text, **ctx) = Acute.parse(text, **@options, **ctx)
+
+    def parse!(text, **ctx) = Acute.parse!(text, **@options, **ctx)
+
+    def read(text, **ctx) = Acute.read(text, **@options, **ctx)
+
+    def extract(text, **ctx) = Acute.extract(text, **@extract_options, **ctx)
+
+    def describe(value, **ctx) = Acute.describe(value, **@options, **ctx)
+
+    def verify(text, value, **ctx) = Acute.verify(text, value, **@options, **ctx)
+
+    def duration(text, **ctx) = Acute.duration(text, **@options, **ctx)
+
+    def duration!(text, **ctx) = Acute.duration!(text, **@options, **ctx)
+
+    def recurrence(text, **ctx) = Acute.recurrence(text, **@options, **ctx)
+
+    def recurrence!(text, **ctx) = Acute.recurrence!(text, **@options, **ctx)
+
+    def with(**more) = Parser.new(**@options, **more)
+
+    def inspect = "#<Acute::Parser #{@options.map { "#{_1}: #{_2.inspect}" }.join(", ")}>"
+  end
+end

data/lib/acute/read.rb

@@ -0,0 +1,21 @@
+module Acute
+  ALSO_DURATION = Assumption.for(:also_duration)
+  private_constant :ALSO_DURATION
+
+  # Whatever the text is: a Rule, a Result, a Duration, or nil. A rule comes first, then a time, which wins over
+  # a duration (D45). The rule is tried only when a word that makes one is there.
+  def self.read(text, 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)
+    if String === text && (t = utf8(text)) && t.bytesize <= MAX_LENGTH && Array === (tokens = Lexer.lex(t)) && Grammar.rule?(tokens)
+      out = rule(t, Context.new(now, zone, context, locale, week_start, hemisphere, fiscal_year_start, strict, dst,
+                                holidays, business_days, year_bias), tokens)
+      return out if Rule === out
+    end
+    length = duration(text)
+    ctx.note(ALSO_DURATION) if length
+    out = run(text, ctx)
+    Result === out ? out : length
+  end
+end

data/lib/acute/resolve/clock.rb

@@ -0,0 +1,75 @@
+module Acute
+  module Resolve
+    # Times of day: which seconds-of-day a clock can mean, and which day a bare one falls on
+    module Clock
+      BARE_HOUR = Assumption.for(:bare_hour_window)
+      TWELVE = Assumption.for(:twelve_oclock)
+      MACHINE = Assumption.for(:machine_time)
+      MIDNIGHT_END = Assumption.for(:midnight_end_of_day)
+      NEXT = Assumption.for(:next_occurrence)
+      PREVIOUS = Assumption.for(:previous_occurrence)
+      EQUAL_NOW = Assumption.for(:equal_to_now)
+
+      NOON = [43_200].freeze
+      MIDNIGHT = [0].freeze
+      # Midnight attached to a day: its end (86400 = the next 00:00) first, then its start
+      DAY_MIDNIGHT = [86_400, 0].freeze
+
+      # Seconds of the day, most likely first
+      def self.candidates(c, ctx, attached)
+        ctx.frac = c.frac if c.frac
+        secs = c.min * 60 + c.sec
+        if c.named == :noon then NOON
+        elsif c.named == :midnight
+          return MIDNIGHT unless attached
+          ctx.note(MIDNIGHT_END) # D6
+          DAY_MIDNIGHT
+        elsif c.meridiem
+          [((c.hour % 12) + (c.meridiem == :pm ? 12 : 0)) * 3600 + secs]
+        elsif c.hour == 0 || c.hour >= 13 || c.h24
+          [c.hour * 3600 + secs]
+        elsif c.seconds || ctx.machine
+          ctx.note(MACHINE) # D29
+          [c.hour * 3600 + secs]
+        elsif c.hour == 12
+          ctx.note(TWELVE) # D30
+          [43_200 + secs]
+        else
+          ctx.note(BARE_HOUR) # D4: 6-11 am, 12 and 1-5 pm, then the other half
+          am = c.hour * 3600 + secs
+          c.hour >= 6 ? [am, am + 43_200] : [am + 43_200, am]
+        end
+      end
+
+      # A clock's grain and length in seconds
+      SECOND = [:second, 1].freeze
+      MINUTE = [:minute, 60].freeze
+      HOUR = [:hour, 3600].freeze
+
+      def self.grain(c) = c.seconds ? (c.seconds == :hour ? HOUR : SECOND) : MINUTE
+
+      # D23: the next occurrence of each candidate (the previous one in past context); D36: now counts
+      def self.bare(c, ctx)
+        cands = candidates(c, ctx, false)
+        grain, len = grain(c)
+        now_secs = ctx.now_secs
+        out = []
+        i = 0
+        while i < cands.size
+          secs = cands[i]
+          day = ctx.today
+          if secs == now_secs
+            ctx.note(EQUAL_NOW) if i == 0
+          elsif ctx.past? ? secs > now_secs : secs < now_secs
+            day += ctx.past? ? -1 : 1
+            ctx.note(ctx.past? ? PREVIOUS : NEXT) if i == 0
+          end
+          b = day * 86_400 + secs
+          out << Span.new(b, b + len, grain, nil)
+          i += 1
+        end
+        out
+      end
+    end
+  end
+end

data/lib/acute/resolve/dates.rb

@@ -0,0 +1,75 @@
+module Acute
+  module Resolve
+    # Calendar dates: "2026-10-23", "oct 23", "10/23", "23.10.2026", "2015"
+    module Dates
+      ORDER = Assumption.for(:numeric_date_order)
+      CENTURY = Assumption.for(:century_from_00)
+      DECADE_CENTURY = Assumption.for(:decade_or_century)
+      DAY = Period::DAY
+      LONGEST = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31].freeze
+
+      def self.spans(d, ctx)
+        if d.sep
+          out = []
+          orders(d, ctx).each { |x| out.concat(spans(x, ctx)) }
+          return out
+        end
+        return Periodic.bare(d, ctx) unless d.year
+        y = d.short ? two_digit_year(d.year, ctx) : d.year
+        return [] if y < 1 # D18
+        m = d.month
+        if (day = d.day)
+          return [] unless m >= 1 && m <= 12 && day >= 1 && (day <= 28 || day <= Calendar.days_in_month(y, m))
+          b = Calendar.days_from_civil(y, m, day) * DAY
+          [Span.new(b, b + DAY, :day, nil)]
+        elsif m
+          return [] unless m >= 1 && m <= 12
+          b = Calendar.days_from_civil(y, m, 1) * DAY
+          [Span.new(b, b + (m == 2 ? Calendar.days_in_month(y, m) : Calendar::MONTH_DAYS[m]) * DAY, :month, nil)]
+        else
+          [Span.new(Calendar.year_start(y) * DAY, Calendar.year_start(y + 1) * DAY, :year, nil)]
+        end
+      end
+
+      # D12: "the 15th century" from 1400, then from 1401; "the 90s" in the two-digit window; "the 2000s" the
+      # decade, then the century
+      def self.years(node, ctx)
+        y = node.short ? two_digit_year(node.year, ctx) : node.year
+        b = Calendar.year_start(y) * DAY
+        if node.unit == :century
+          ctx.note(CENTURY)
+          return [Span.new(b, Calendar.year_start(y + 100) * DAY, :century, nil),
+                  Span.new(Calendar.year_start(y + 1) * DAY, Calendar.year_start(y + 101) * DAY, :century, nil)]
+        end
+        decade = Span.new(b, Calendar.year_start(y + 10) * DAY, :decade, nil)
+        return [decade] unless y % 100 == 0 && !node.short
+        ctx.note(DECADE_CENTURY)
+        [decade, Span.new(b, Calendar.year_start(y + 100) * DAY, :century, nil)]
+      end
+
+      # D10, D37: the locale's order first (dots are always day first), then the other order when it is also
+      # a date. The result is plain dates, month and day in place.
+      def self.orders(d, ctx)
+        out = []
+        [false, true].each { |swap| (x = order(d, ctx, swap)) && !out.include?(x) && out << x }
+        ctx.note(ORDER) if out.size > 1
+        out
+      end
+
+      # The date in the locale's order, or with swap in the other, or nil when that is no date
+      def self.order(d, ctx, swap)
+        y = d.year && d.short ? two_digit_year(d.year, ctx) : d.year
+        m, day = (d.sep == :dot || ctx.locale.day_first) == swap ? [d.month, d.day] : [d.day, d.month]
+        return unless m.between?(1, 12) && day.between?(1, y ? Calendar.days_in_month(y, m) : LONGEST[m])
+        G::Date.new(y, m, day, nil, false)
+      end
+
+      # D23: chronic's window, the 100 years from year_bias: years before now (50 by default)
+      def self.two_digit_year(yy, ctx)
+        first = Period.year(ctx.now_local) - ctx.year_bias
+        y = first - first % 100 + yy
+        y < first ? y + 100 : y
+      end
+    end
+  end
+end

data/lib/acute/resolve/day.rb

@@ -0,0 +1,24 @@
+module Acute
+  module Resolve
+    # Day words: today, tomorrow, yesterday
+    module Day
+      TOMORROW_EARLY = Assumption.for(:tomorrow_after_midnight)
+      NIGHT_ENDS = 4 * 3600
+
+      # The day's spans, most likely first
+      def self.whole(d, ctx)
+        today = ctx.today
+        # D40: before 04:00 the speaker's "tomorrow" is usually the coming day. Exactly 00:00 is excluded:
+        # it is what a Date or a time-less fixture gives as now, which means the day itself (D41)
+        if d.offset == 1 && ctx.now_secs > 0 && ctx.now_secs < NIGHT_ENDS
+          ctx.note(TOMORROW_EARLY)
+          [day(today), day(today + 1)]
+        else
+          [day(today + d.offset)]
+        end
+      end
+
+      def self.day(d) = Span.new(d * 86_400, d * 86_400 + 86_400, :day, nil)
+    end
+  end
+end

data/lib/acute/resolve/fuzzy.rb

@@ -0,0 +1,91 @@
+module Acute
+  module Resolve
+    # early / mid / late / start / end of a period (D2, D35)
+    module Fuzzy
+      DAY = Period::DAY
+      HOUR = 3600
+
+      # D42: a repeating one is picked by the fuzzy part, so "early morning" said at 10:30 is tomorrow's
+      def self.spans(node, ctx)
+        return Periodic.bare(node, ctx) if Periodic.cycle(node.node)
+        Resolve.spans(node.node, ctx).flat_map { |s| apply(node.pos, s, node.node, ctx) }
+      end
+
+      def self.apply(pos, s, x, ctx)
+        part = Periodic.part_name(x)
+        return [part(pos, s, part)] if part
+        case s.grain
+        when :month then [days(pos, s, 10)]
+        when :year, :quarter, :season then [months(pos, s, ctx)]
+        when :week then [week(pos, s, ctx)]
+        when :day then [day(pos, s)]
+        when :decade
+          y = Period.year(s.b)
+          from, to = { early: [0, 4], mid: [4, 7], late: [7, 10], start: [0, 1], end: [9, 10] }.fetch(pos)
+          [Span.new(Period.civil(y + from, 1, 1), Period.civil(y + to, 1, 1), :year, nil)]
+        else [s]
+        end
+      end
+
+      # D2: thirds of a month (1-10, 11-20, 21-end); start and end are the first and last day
+      def self.days(pos, s, third)
+        case pos
+        when :start then Span.new(s.b, s.b + DAY, :day, nil)
+        when :end then Span.new(s.e - DAY, s.e, :day, nil)
+        when :early then Span.new(s.b, s.b + third * DAY, :day, nil)
+        when :mid then Span.new(s.b + third * DAY, s.b + 2 * third * DAY, :day, s.b + 14 * DAY)
+        else Span.new(s.b + 2 * third * DAY, s.e, :day, nil)
+        end
+      end
+
+      # D2: a year in thirds of four months; a quarter or season in months
+      def self.months(pos, s, _ctx)
+        return days(pos, s, 0) if pos == :start || pos == :end
+        n = s.grain == :year ? 4 : 1
+        k = { early: 0, mid: 1, late: 2 }.fetch(pos)
+        b = Period.add(s.b, k * n, :month)
+        Span.new(b, k == 2 ? s.e : Period.add(b, n, :month), :month, nil)
+      end
+
+      # D2: early Mon-Tue, mid Wed-Thu, late Fri-Sat; end of week is Friday; D38: start is the locale's
+      # first day
+      def self.week(pos, s, ctx)
+        mon = s.b + ((1 - ctx.week_start) % 7) * DAY
+        case pos
+        when :start then Span.new(s.b, s.b + DAY, :day, nil)
+        when :end then Span.new(mon + 4 * DAY, mon + 5 * DAY, :day, nil)
+        else
+          b = mon + { early: 0, mid: 2, late: 4 }.fetch(pos) * DAY
+          Span.new(b, b + 2 * DAY, :day, nil)
+        end
+      end
+
+      # D2: end of day is 23:59:59
+      def self.day(pos, s)
+        case pos
+        when :start then Span.new(s.b, s.b + 1, :second, nil)
+        when :end then Span.new(s.e - 1, s.e, :second, nil)
+        else
+          b = s.b + { early: 0, mid: 8, late: 16 }.fetch(pos) * HOUR
+          Span.new(b, b + 8 * HOUR, :hour, nil)
+        end
+      end
+
+      # D1: early morning 04-08 and late night 22-04; D35: otherwise halves; D40: mid is the middle third
+      def self.part(pos, s, name)
+        day = Period.day(s.b) * DAY
+        if pos == :early && name == :morning then Span.new(day + 4 * HOUR, day + 8 * HOUR, :hour, day + 6 * HOUR)
+        elsif pos == :late && (name == :night || name == :tonight)
+          Span.new(day + 22 * HOUR, day + 28 * HOUR, :hour, day + 23 * HOUR)
+        else
+          len = s.e - s.b
+          case pos
+          when :early, :start then Span.new(s.b, s.b + len / 2, :hour, nil)
+          when :mid then Span.new(s.b + len / 3, s.b + 2 * len / 3, :hour, nil)
+          else Span.new(s.b + len / 2, s.e, :hour, nil)
+          end
+        end
+      end
+    end
+  end
+end