globeglitter 1.0.0

data/README.md

@@ -0,0 +1,21 @@
+- https://en.wikipedia.org/wiki/Surrogate_key
+
+- https://devblogs.microsoft.com/oldnewthing/20190426-00/?p=102450
+- https://devblogs.microsoft.com/oldnewthing/20190913-00/?p=102859
+
+
+## Non-UUID specs
+
+- https://github.com/ulid/spec
+- https://github.com/rs/xid
+- https://github.com/boundary/flake
+- https://github.com/segmentio/ksuid
+
+
+## Alternative Ruby Libraries
+
+- `::SecureRandom::uuid` obviously
+- https://github.com/sporkmonger/uuidtools
+- https://github.com/assaf/uuid  /  https://www.rubydoc.info/gems/uuid/
+- https://gist.github.com/brandur/1bddb5215540889983dc7e3a66ef4e41
+- https://github.com/cassandra-rb/simple_uuid

data/bin/are-we-unallocated-yet

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'memory_profiler'
+
+$: << File.expand_path('../lib', __dir__)
+result = MemoryProfiler.report do
+  require 'globeglitter'
+  333.times { GlobeGlitter::random }
+end.pretty_print

data/bin/benchmark

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'globeglitter'
+require 'securerandom'
+require 'benchmark/ips'
+
+Benchmark.ips do |bm|
+  integer_buffer = ::Data::define(:lol, :rofl, :lmao) do
+    def self.new(msb, lsb, rofl: nil, lmao: nil) = self.allocate.tap { |gg|
+      gg.send(
+        :initialize,
+        **{
+          lol: ((msb << 64) | lsb),
+          rofl:,
+          lmao:,
+        }
+      )
+    }
+  end
+
+  io_buffer = ::Data::define(:lol, :rofl, :lmao) do
+    def self.new(msb, lsb, rofl: nil, lmao: nil) = self.allocate.tap { |gg|
+      gg.send(
+        :initialize,
+        **{
+          lol: ::IO::Buffer::new(size=16).tap {
+            _1.set_value(:U64, 0, msb)
+            _1.set_value(:U64, 8, lsb)
+          },
+          rofl:,
+          lmao:,
+        }
+      )
+    }
+  end
+
+  bm.report('Embedded buffer as `::Integer`') do
+    integer_buffer.new(
+      ::SecureRandom::random_number(0xFFFFFFFF_FFFFFFFF),
+      ::SecureRandom::random_number(0xFFFFFFFF_FFFFFFFF),
+    )
+  end
+  bm.report('Embedded buffer as `::IO::Buffer`') do
+    io_buffer.new(
+      ::SecureRandom::random_number(0xFFFFFFFF_FFFFFFFF),
+      ::SecureRandom::random_number(0xFFFFFFFF_FFFFFFFF),
+    )
+  end
+end
+
+Benchmark.ips do |bm|
+  bm.report 'SecureRandom::uuid random String' do
+    ::SecureRandom::uuid
+  end
+  bm.report 'SecureRandom::uuid random String to Integer' do
+    ::SecureRandom::uuid.gsub(?-, '').to_i(16)
+  end
+  bm.report 'GlobeGlitter random from SecureRandom::uuid' do
+    ::GlobeGlitter::new(::SecureRandom::uuid.gsub(?-, '').to_i(16))
+  end
+  bm.report 'GlobeGlitter random native' do
+    ::GlobeGlitter::random
+  end
+  bm.report 'GlobeGlitter random native to String' do
+    ::GlobeGlitter::random.to_s
+  end
+end
+
+# TODO: Benchmark `::IO::Buffer` vs `::Integer` immediates https://docs.ruby-lang.org/en/master/IO/Buffer.html

data/bin/profile

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'globeglitter'
+
+require 'ruby-prof'
+
+
+result = RubyProf.profile(:track_allocations => true) do
+  1_234_56.times do
+    ::GlobeGlitter::random
+  end
+end
+printer = RubyProf::GraphPrinter.new(result)
+printer.print(STDOUT, :min_percent => 2)

data/bin/repl

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "irb"
+require "objspace"
+require "globeglitter"
+
+IRB.start(__FILE__)

data/bin/test-my-best

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require('bundler/setup')
+require_relative('../lib/globeglitter')
+require_relative('../TEST MY BEST/test-my-best')

data/lib/globeglitter/chrono_diver.rb

@@ -0,0 +1,200 @@
+require('securerandom') unless defined?(::SecureRandom)
+require('socket') unless defined?(::Socket)
+
+# Components for time-based UUIDs.
+#
+# See also:
+# - https://pythonhosted.org/time-uuid/
+module ::GlobeGlitter::CHRONO_DIVER; end
+module ::GlobeGlitter::CHRONO_DIVER::PENDULUMS
+
+  # ITU-T Rec. X.667 sez —
+  #
+  #  “The timestamp is a 60-bit value.  For UUID version 1, this is
+  #   represented by Coordinated Universal Time (UTC) as a count of 100-
+  #   nanosecond intervals since 00:00:00.00, 15 October 1582 (the date of
+  #   Gregorian reform to the Christian calendar).“
+  #  “For systems that do not have UTC available, but do have the local
+  #   time, they may use that instead of UTC, as long as they do so
+  #   consistently throughout the system.  However, this is not recommended
+  #   since generating the UTC from local time only needs a time zone offset.”
+  #  “Since a UUID is a fixed size and contains a time field,
+  #   it is possible for values to rollover (around A.D. 3400,
+  #   depending on the specific algorithm used).”
+  #  “NT keeps time in FILETIME format which is 100ns ticks since Jan 1, 1601.
+  #   UUIDs use time in 100ns ticks since Oct 15, 1582.
+  #   The difference is 17 Days in Oct + 30 (Nov) + 31 (Dec) + 18 years and 5 leap days.”
+  #
+  # See also —
+  # - https://medium.com/swlh/should-i-use-date-time-or-datetime-in-ruby-and-rails-9372ad20ca4f
+  # - https://stackoverflow.com/questions/11835193/how-do-i-use-ruby-date-constants-gregorian-julian-england-and-even-italy
+  #
+  # TODO: Figure out how to handle date rollover.
+  private def current_time = (((::Time::now.utc - ::Time::new(1582, 10, 15)) * 1_000_000_000) / 100).to_i
+
+  # ITU-T Rec. X.667 sez —
+  #
+  # “[O]btain a 47-bit cryptographic quality random number and use it as the low 47 bits of the node ID,
+  #  with the least significant bit of the first octet of the node ID set to one.
+  #  This bit is the unicast/multicast bit, which will never be set in IEEE 802 addresses
+  #  obtained from network cards.  Hence, there can never be a conflict between UUIDs
+  #  generated by machines with and without network cards.”
+  private def random_node = (::SecureRandom::random_number(0xFFFFFFFFFFFF) | (0b1 << 40))
+
+  # General background info: https://beej.us/guide/bgnet/html/
+  #
+  # Ruby exposes `hwaddr` in `::Socket::getifaddrs`, e.g. —
+  #
+  # irb> Socket::getifaddrs.map(&:addr)
+  # => 
+  # [#<Addrinfo: PACKET[protocol=0 lo hatype=772 HOST hwaddr=00:00:00:00:00:00]>,
+  #  #<Addrinfo: PACKET[protocol=0 enp1s0 hatype=1 HOST hwaddr=00:e0:4c:18:42:69]>,
+  #  #<Addrinfo: PACKET[protocol=0 wlp2s0 hatype=1 HOST hwaddr=80:19:34:6f:13:37]>,
+  #  #<Addrinfo: 127.0.0.1>,
+  #  #<Addrinfo: 172.16.0.226>,
+  #  #<Addrinfo: 172.16.0.88>,
+  #  #<Addrinfo: ::1>,
+  #  #<Addrinfo: fe80::d9d7:4890:9ebc:486%wlp2s0>]
+  #
+  # …but there seems to be no way to get it in Ruby code without parsing the `::String` output
+  # of `::Addrinfo#inspect`, confirmed when we look at `raddrinfo.c` and see it constructing a `str`:
+  # https://github.com/ruby/ruby/blob/ea8a7287e2b96b9c24e5e89fe863e5bfa60bfdda/ext/socket/raddrinfo.c#L1375
+  #
+  # MAYBE: Figure out how to use ioctl to get this without `::String` parsing.
+  # - https://stackoverflow.com/a/1779758
+  # - https://medium.com/geckoboard-under-the-hood/how-to-build-a-network-stack-in-ruby-f73aeb1b661b
+  private def hardware_node = ::Socket::getifaddrs.map(&:addr).map(&:inspect_sockaddr).map! {
+    _1.match(/hwaddr=(?<hwaddr>\h\h:\h\h:\h\h:\h\h:\h\h:\h\h)/)&.captures&.pop&.gsub(?:, '')&.to_i(16)
+  }.compact.tap {
+    # Remove `00:00:00:00:00:00` loopback address.
+    # TODO: Better logic. There can be multiple loopback interfaces or no loopback interface.
+    #       Maybe alter the `::Regexp` above and remove this `tap`/`delete` section entirely.
+    _1.delete(0)
+  }&.max {
+    # Choose the hwaddr that gives up the most entropy for a UUID,
+    # rather than always the first-enumerated hwaddr.
+    _1.bit_length
+  }
+
+  # Fall back to random node ID if a hardware ID is unavailable.
+  private def current_node = self.hardware_node || self.random_node
+
+  # ITU-T Rec. X.667 sez —
+  #
+  #  “For UUID version 1, the clock sequence is used to help avoid
+  #   duplicates that could arise when the clock is set backwards in time
+  #   or if the node ID changes.
+  #
+  #   If the clock is set backwards, or might have been set backwards
+  #   (e.g., while the system was powered off), and the UUID generator can
+  #   not be sure that no UUIDs were generated with timestamps larger than
+  #   the value to which the clock was set, then the clock sequence has to
+  #   be changed.  If the previous value of the clock sequence is known, it
+  #   can just be incremented; otherwise it should be set to a random or
+  #   high-quality pseudo-random value.
+  #
+  #   Similarly, if the node ID changes (e.g., because a network card has
+  #   been moved between machines), setting the clock sequence to a random
+  #   number minimizes the probability of a duplicate due to slight
+  #   differences in the clock settings of the machines.  If the value of
+  #   clock sequence associated with the changed node ID were known, then
+  #   the clock sequence could just be incremented, but that is unlikely.
+  #
+  #   The clock sequence MUST be originally (i.e., once in the lifetime of
+  #   a system) initialized to a random number to minimize the correlation
+  #   across systems.  This provides maximum protection against node
+  #   identifiers that may move or switch from system to system rapidly.
+  #   The initial value MUST NOT be correlated to the node identifier.”
+  #
+  # TODO: Pick a single random sequence at startup and increment from there,
+  #       maybe in a dedicated `::Ractor`.
+  def clock_sequence = ::SecureRandom::random_number(0xFFFF)
+
+  # TODO: Take arguments to generate identifiers for specific time/seq/node.
+  def from_time = self::new(
+    current_time,
+    clock_sequence,
+    current_node,
+    structure: ::GlobeGlitter::STRUCTURE_ITU_T_REC_X_667,
+    rules: ::GlobeGlitter::RULES_TIME_GREGORIAN,
+  )
+end
+
+module ::GlobeGlitter::CHRONO_DIVER::FRAGMENT
+
+  # Getters for fields defined in the specification.
+  def time_low                    = self.bits127–96
+  def time_mid                    = self.bits95–80
+  def time_high_and_version       = self.bits79–64
+  def clock_seq_high_and_reserved = self.bits63–56 & case self.structure
+    # This field is overlayed by the backward-masked `structure` a.k.a. """variant""",
+    # so we return a different number of bits from the chunk depending on that value.
+    when 0    then 0b01111111
+    when 1    then 0b00111111
+    when 2, 3 then 0b00011111
+    else           0b11111111  # Non-compliant structure. This should never happen.
+  end
+  def clock_seq_low               =  self.bits55–48
+  def node                        =  self.bits47–0
+
+  # Setters for fields defined in the specification.
+  def time_low=(otra);  self.bits127–96=(otra); end
+  def time_mid=(otra);  self.bits95–80=(otra);  end
+  def time_high=(otra); self.bits79–64=(((self.inner_spirit >> 64) & 0xF000) | (otra & 0x0FFF)); end
+  def time=(otra)
+    self.bits79–64=(((self.inner_spirit >> 64) & 0x00000000_0000F000) | (otra & 0xFFFFFFFF_FFFF0FFF))
+  end
+  def clock_seq_high_and_reserved=(otra)
+    # This field is overlayed by the backward-masked `structure` a.k.a. """variant""",
+    # so we set a different number of bits from the chunk depending on that value
+    # along with saving the existing value.
+    self.bits63–56=(
+      (otra & case self.structure
+        when 0    then 0b01111111
+        when 1    then 0b00111111
+        when 2, 3 then 0b00011111
+        else           0b11111111  # Non-compliant structure. This should never happen.
+      end) | (case self.structure
+        when 0    then 0b00000000
+        when 1    then 0b10000000
+        when 2    then 0b11000000
+        when 3    then 0b11100000
+        else           0b00000000  # Non-compliant structure. This should never happen.
+      end)
+    )
+  end
+  def clock_seq_low=(otra)
+    self.bits55–48=(otra)
+  end
+  def node=(otra)
+    self.bits47–0=(otra)
+  end
+
+  # Getter for Base-16 `::String` output where these two fields are combined.
+  def clock_seq = (self.clock_seq_high_and_reserved << 8) | self.clock_seq_low
+  def clock_seq=(otra)
+    self.with(inner_spirit: (
+      (self.inner_spirit & 0xFFFFFFFF_FFFFFFFF_0000FFFF_FFFFFFFF) |
+      (
+        case self.structure
+          when 0    then 0b00000000
+          when 1    then 0b10000000
+          when 2    then 0b11000000
+          when 3    then 0b11100000
+        end << 56
+      ) | (otra << 48)
+    ))
+  end
+
+  # Construct the full timestamp from the split chunk contents.
+  def time = (self.bits127–96 << 32) | (self.bits95–80 << 16) | (self.bits79–64 & 0x0FFF)
+
+  # ITU-T Rec. X.667 sez —
+  #
+  #  “The timestamp is a 60-bit value.  For UUID version 1, this is
+  #   represented by Coordinated Universal Time (UTC) as a count of 100-
+  #   nanosecond intervals since 00:00:00.00, 15 October 1582 (the date of
+  #   Gregorian reform to the Christian calendar).“
+  def to_time = ::Time::new(1582, 10, 15).utc + (self.time / 10000000)
+
+end

data/lib/globeglitter/first_resolution.rb

@@ -0,0 +1,24 @@
+require('forwardable') unless defined?(::Forwardable)
+require('comparable') unless defined?(::Comparable)
+
+::GlobeGlitter::FIRST_RESOLUTION = ::Module::new do
+
+  #extend(::Forwardable)
+  #def_instance_delegators(:inner_spirit, :to_i, :eql?)
+
+  # https://devblogs.microsoft.com/oldnewthing/20190426-00/?p=102450
+  # https://devblogs.microsoft.com/oldnewthing/20190913-00/?p=102859
+  # https://bornsql.ca/blog/how-sql-server-stores-data-types-guid/
+  COMPARATOR_UUID = 1
+  include(::Comparable)
+  def <=>(otra, comparator: COMPARATOR_UUID)
+    case otra
+    when ::GlobeGlitter then
+      case comparator
+      when COMPARATOR_UUID then self.inner_spirit.<=>(otra.inner_spirit)
+      #else
+      end
+    else self.inner_spirit.<=>(::GlobeGlitter::try_convert(otra))
+    end
+  end
+end

data/lib/globeglitter/inner_spirit.rb

@@ -0,0 +1,162 @@
+# Bitslicing components.
+module ::GlobeGlitter::INNER_SPIRIT
+
+  # NOTE: These method names are based on big-endian representation of our buffer, i.e. MSB <-> LSB.
+  #
+  # ITU-T Rec. X.667 sez —
+  #  “This Recommendation | International Standard specifies a sequence of octets for a UUID
+  #   using the terms first and last. The first octet is also called "octet 15" and the last octet "octet 0".
+  #   The bits within a UUID are also numbered as "bit 127" to "bit 0", with bit 127 as the most-
+  #   significant bit of octet 15 and bit 0 as the least significant bit of octet 0.”
+  #
+  # I am going to 1-index the boundaries in these helper methods because I think the resulting numbers
+  # are easier to remember, but our structure is otherwise identical to what's described in the quote.
+  def bits127–96 = self.inner_spirit.get_value(self.structure.eql?(self.class::STRUCTURE_MICROSOFT) ? :u32 : :U32, 0)
+  def bits95–80  = self.inner_spirit.get_value(self.structure.eql?(self.class::STRUCTURE_MICROSOFT) ? :u16 : :U16, 4)
+  def bits79–64  = self.inner_spirit.get_value(self.structure.eql?(self.class::STRUCTURE_MICROSOFT) ? :u16 : :U16, 6)
+  def bits63–56  = self.inner_spirit.get_value(:U8, 8)
+  def bits55–48  = self.inner_spirit.get_value(:U8, 9)
+  def bits47–0   = (self.inner_spirit.get_value(:U16, 10) << 32) | self.inner_spirit.get_value(:U32, 12)
+
+  def bits127–96=(otra); self.inner_spirit.set_value(self.structure.eql?(self.class::STRUCTURE_MICROSOFT) ? :u32 : :U32, 0, otra); end
+  def bits95–80=(otra);  self.inner_spirit.set_value(self.structure.eql?(self.class::STRUCTURE_MICROSOFT) ? :u16 : :U16, 4, otra); end
+  def bits79–64=(otra);  self.inner_spirit.set_value(self.structure.eql?(self.class::STRUCTURE_MICROSOFT) ? :u16 : :U16, 6, otra); end
+  def bits63–56=(otra);  self.inner_spirit.set_value(:U8, 8, otra); end
+  def bits55–48=(otra);  self.inner_spirit.set_value(:U8, 9, otra); end
+  def bits47–0=(otra)
+    self.inner_spirit.set_value(:U16, 10, otra >> 32)
+    self.inner_spirit.set_value(:U32, 12, otra & 0xFFFFFFFF)
+  end
+
+  # ITU-T Rec. X.667 sez —
+  #
+  # “The version number is in the most significant 4 bits of the time
+  #  stamp (bits 4 through 7 of the time_hi_and_version field).”
+  #
+  # “The following table lists the currently-defined versions for this UUID structure.”
+  #
+  # Msb0  Msb1  Msb2  Msb3   Version  Description
+  #
+  #  0     0     0     1        1     The time-based version
+  #                                   specified in this document.
+  #
+  #  0     0     1     0        2     DCE Security version, with
+  #                                   embedded POSIX UIDs.
+  #
+  #  0     0     1     1        3     The name-based version
+  #                                   specified in this document
+  #                                   that uses MD5 hashing.
+  #
+  #  0     1     0     0        4     The randomly or pseudo-
+  #                                   randomly generated version
+  #                                   specified in this document.
+  #
+  #  0     1     0     1        5     The name-based version
+  #                                   specified in this document
+  #                                   that uses SHA-1 hashing.
+  #
+  # “The version is more accurately a sub-type; again, we retain the term for compatibility.”
+  def rules = (self.to_i >> 76) & 0xF
+    # NOTE: Assignment methods in Ruby can only return their argument, so we name this `replace` instead.
+  def replace_rules(otra)
+    raise ::ArgumentError::new("invalid version #{otra.to_s}") unless otra.is_a?(::Integer) and otra.between?(1, 8)
+    return self.with(rules: otra).tap {
+      _1.inner_spirit.set_value(:U8, 7, ((otra << 0xF) | (self.inner_spirit.get_value(:U8, 7) & 0xF)))
+    }
+  end
+  # This is just straight-up the same thing as "version" in the UUID specification,
+  # but I don't want to call it that because it's a terrible ambiguous word
+  # for anybody unfamiliar with the minutae of the specs.
+  # We should still provide it as `#version` because why not??
+  alias_method(:version, :rules)
+
+  # ITU-T Rec. X.667 sez —
+  #
+  # “The variant field determines the layout of the UUID.
+  #  That is, the interpretation of all other bits in the UUID depends on the setting
+  #  of the bits in the variant field.  As such, it could more accurately be called a type field;
+  #  we retain the original term for compatibility.
+  #  The variant field consists of a variable number of the most significant bits of octet 8 of the UUID.
+  #
+  # “The following table lists the contents of the variant field, where
+  #  the letter "x" indicates a "don't-care" value.
+  #
+  #   Msb0  Msb1  Msb2  Description
+  #
+  #    0     x     x    Reserved, NCS backward compatibility.
+  #
+  #    1     0     x    The structure specified in this document.
+  #
+  #    1     1     0    Reserved, Microsoft Corporation backward compatibility
+  #
+  #    1     1     1    Reserved for future definition.
+  #
+  #
+  # NOTE: Some libraries (like `java.util.UUID`) specify the variant value as if it were not backwards-masked:
+  #       https://docs.oracle.com/en/java/javase/19/docs/api/java.base/java/util/UUID.html#variant()
+  #
+  #       I think it makes more sense for it to count upward like `version` rather than use the raw bit value.
+  def structure
+    # Can't use getter for this since the getter return value will rely on this structure.
+    clock_seq_high_and_reserved = self.inner_spirit.get_value(:U8, 8)
+    # The structure is masked backwards, but with a variable number of bits,
+    # so we can't just swap it and mask.
+    case
+    when (clock_seq_high_and_reserved >> 7).zero?       then 0
+    when (clock_seq_high_and_reserved >> 6).eql?(0b10)  then 1
+    when (clock_seq_high_and_reserved >> 5).eql?(0b110) then 2
+    when (clock_seq_high_and_reserved >> 5).eql?(0b111) then 3
+    end
+  end
+
+    # NOTE: Assignment methods in Ruby can only return their argument, so we name this `replace` instead.
+  def replace_structure(otra)
+    raise ::ArgumentError::new("invalid structure #{otra.to_s}") unless otra.respond_to?(:<) and otra.<(4)
+    return self.with(structure: otra).tap {
+      _1.inner_spirit.set_value(:U8, 9,
+        (
+          (case otra
+            when 0    then 0b00000000
+            when 1    then 0b10000000
+            when 2    then 0b11000000
+            when 3    then 0b11100000
+            else      raise ::ArgumentError::new("invalid structure #{otra.to_s}")
+          end) |
+          (_1.inner_spirit.get_value(:U8, 9) & case otra
+            when 0    then 0b01111111
+            when 1    then 0b00111111
+            when 2, 3 then 0b00011111
+            else      raise ::ArgumentError::new("invalid structure #{otra.to_s}")
+            end)
+        )
+      )
+    }
+  end
+
+  # Return `::Integer` representation of the contents of our embedded buffer.
+  # ITU-T Rec. X.667 sez —
+  # “A UUID can be represented as a single integer value. To obtain the single integer value of the UUID,
+  #  the 16 octets of the binary representation shall be treated as an unsigned integer encoding with
+  #  the most significant bit of the integer encoding as the most significant bit (bit 7) of the first
+  #  of the sixteen octets (octet 15) and the least significant bit as the least significant bit (bit 0)
+  #  of the last of the sixteen octets (octet 0).”
+  # “UUIDs forming a component of an OID are represented in ASN.1 value notation
+  # as the decimal representation of their integer value.”
+  def to_i = (self.inner_spirit.get_value(:U64, 0) << 64) | self.inner_spirit.get_value(:U64, 8)
+
+  # ITU-T Rec. X.667 sez —
+  # “An alternative URN format [alternative to `"urn:uuid:<hex-string>"`] is available,
+  #  but is not recommended for URNs generated using UUIDs.
+  #  This alternative format uses the single integer value of the UUID, and represents the UUID
+  #  `f81d4fae-7dec-11d0-a765-00a0c91e6bf6` as `urn:oid:2.25.329800735698586629295641978511506172918`.”
+  #
+  # Explicitly call `#to_i#to_s` to avoid `RangeError: bignum out of char range`.
+  def to_oid = ::String::new("urn:oid:2.25.".concat(self.to_i.to_s), encoding: ::Encoding::US_ASCII).-@
+
+  # Compare to dotNET `Guid.ToByteArray` https://learn.microsoft.com/en-us/dotnet/api/system.guid.tobytearray
+  # Match the naming of `::String#bytes` since we behave identically.
+  def bytes = self.inner_spirit.values
+  # Also keep the name `values` because why not lol
+  def values = self.inner_spirit.values
+
+end

data/lib/globeglitter/say_yeeeahh.rb

@@ -0,0 +1,64 @@
+# `::String`-printing components.
+module ::GlobeGlitter::SAY_YEEEAHH
+
+  # SAY YEEEAHH
+  # NOTE: Built-in Ruby classes emit `US-ASCII` as their `#to_s`, thus so shall we.
+  #       Some relevant discussions:
+  #       - In https://bugs.ruby-lang.org/issues/7752 `naruse` sez —
+  #         “On current policy, strings which always include only US-ASCII characters are US-ASCII.
+  #          If there is a practical issue, I may change the policy in the future.
+  #          Note that US-ASCII string is faster than UTF-8 on getting length or index access.”
+  #       - `::Time`:       https://bugs.ruby-lang.org/issues/6820
+  #       - `::Integer`:    https://bugs.ruby-lang.org/issues/15876
+  #       - `::BigDecimal`: https://bugs.ruby-lang.org/issues/17011
+  def to_s(base=16)
+    case base
+    when 2  then self.to_i.to_s(2).rjust(128, ?0)
+    when 16 then
+      # ITU-T Rec. X.667 sez —
+      #
+      # “Each field is treated as an integer and has its value printed as a
+      #  zero-filled hexadecimal digit string with the most significant digit first.
+      #  The hexadecimal values "a" through "f" are output as lower case characters.”
+      ::Array[
+        # TODO: Handle swapping for String representation of MS-style GUIDs
+        self.bits127–96.to_s(16).rjust(8, ?0),
+        self.bits95–80.to_s(16).rjust(4, ?0),
+        self.bits79–64.to_s(16).rjust(4, ?0),
+        ((self.bits63–56 << 8) | self.bits55–48).to_s(16).rjust(4, ?0),
+        self.bits47–0.to_s(16).rjust(12, ?0),
+      ].join(?-).encode!(::Encoding::US_ASCII).-@
+    else
+      # Compare to `::Integer#to_s` behavior:
+      #   irb> 333.to_s(666)
+      #   (irb):in `to_s': invalid radix 666 (ArgumentError)
+      raise ::ArgumentError::new("invalid radix #{base.to_s}")
+    end
+  end
+
+  # In Microsoft-land, GUIDs were ALL-CAPS hex packaged between curly braces
+  def to_guid = ::String::new("{#{self.to_s(16).upcase}}", encoding: ::Encoding::US_ASCII)
+
+  def inspect = ::String::new("#<#{self.class.name} #{self.to_s}>", encoding: ::Encoding::US_ASCII)
+
+  # ITU-T Rec. X.667 sez —
+  #
+  # “A UUID can be used as the primary integer value of a Joint UUID arc using the single integer value of the UUID.
+  #  The hexadecimal representation of the UUID can also be used as a non-integer Unicode label for the arc.
+  #  EXAMPLE — The following is an example of the use of a UUID to form an IRI/URI value: 
+  #            "oid:/UUID/f81d4fae-7dec-11d0-a765-00a0c91e6bf6"”
+  def to_oid_s = ::String::new("oid:/UUID/".concat(self.to_s(base=16)), encoding: ::Encoding::US_ASCII).-@
+
+  # ITU-T Rec. X.667 sez —
+  #
+  # “The string representation of a UUID is fully compatible with the URN syntax.
+  #  When converting from a bit-oriented, in-memory representation of a UUID into a URN,
+  #  care must be taken to strictly adhere to the byte order issues
+  #  mentioned in the string representation section.”
+  # “The following is an example of the string representation of a UUID as a URN:
+  #   urn:inner_spirit:f81d4fae-7dec-11d0-a765-00a0c91e6bf6”
+  def to_urn = ::String::new("urn:uuid:".concat(self.to_s(base=16)), encoding: ::Encoding::US_ASCII).-@
+
+  # TODO: `#to_clsid` https://www.w3.org/Addressing/clsid-scheme
+
+end