Synced with 1.14

1 files changed, 924 insertions, 203 deletions

diff --git a/docs/parse_log.txt b/docs/parse_log.txt
index 68a48a2..4b8486f 100644
--- a/docs/parse_log.txt
+++ b/docs/parse_log.txt
@@ -2880,13 +2880,13 @@ The response to this question requires a few subparts. First we need to clarify
 - End of paragraph detected.
 *** True Line Result
 
-** Processing line: ~A runtime is an _implementation_ of a langauge specification. When~
+** Processing line: ~A runtime is an _implementation_ of a language specification. When~
 ** Processing line: ~people say "Ruby," they are usually referring to "the Ruby 3.0+ language~
 ** Processing line: ~specification implemented via the CRuby/MRI Runtime."~
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
-A runtime is an _implementation_ of a langauge specification. When people say "Ruby," they are usually referring to "the Ruby 3.0+ language specification implemented via the CRuby/MRI Runtime."
+A runtime is an _implementation_ of a language specification. When people say "Ruby," they are usually referring to "the Ruby 3.0+ language specification implemented via the CRuby/MRI Runtime."
 ** Processing line: ~But, there are many Ruby Runtimes: CRuby/MRI, JRuby, Truffle, Rubinius, Artichoke,~
 ** Processing line: ~and (last but certainly not least) DragonRuby.~
 ** Processing line: ~~
@@ -2972,37 +2972,37 @@ There are complexities associated with targeting all the platforms we support. B
 - Level 3 consists of portable C libraries and their Ruby
   C-Extensions.
 ** Processing line: ~Levels 1 through 3 are fairly commonplace in many runtime~
-** Processing line: ~implemenations (with level 1 being the most portable, and level 3~
+** Processing line: ~implementations (with level 1 being the most portable, and level 3~
 ** Processing line: ~being the fastest). But the DragonRuby Runtime has taken things a~
 ** Processing line: ~bit further:~
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
-Levels 1 through 3 are fairly commonplace in many runtime implemenations (with level 1 being the most portable, and level 3 being the fastest). But the DragonRuby Runtime has taken things a bit further:
+Levels 1 through 3 are fairly commonplace in many runtime implementations (with level 1 being the most portable, and level 3 being the fastest). But the DragonRuby Runtime has taken things a bit further:
 ** Processing line: ~- Level 4 consists of shared abstractions around hardware I/O and operating~
 - Line was identified as a list.
 *** True Line Result
 
 ** Processing line: ~  system resources. This level leverages open source and proprietary~
-** Processing line: ~  components within Simple DirectMedia Layer (a lowlevel multimedia~
+** Processing line: ~  components within Simple DirectMedia Layer (a low level multimedia~
 ** Processing line: ~  component library that has been in active development for 22 years~
 ** Processing line: ~  and counting).~
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
 - Level 4 consists of shared abstractions around hardware I/O and operating
-  system resources. This level leverages open source and proprietary   components within Simple DirectMedia Layer (a lowlevel multimedia   component library that has been in active development for 22 years   and counting).
-** Processing line: ~- Level 5 is a codegeneration layer which creates metadata that allows~
+  system resources. This level leverages open source and proprietary   components within Simple DirectMedia Layer (a low level multimedia   component library that has been in active development for 22 years   and counting).
+** Processing line: ~- Level 5 is a code generation layer which creates metadata that allows~
 - Line was identified as a list.
 *** True Line Result
 
-** Processing line: ~  for native interopability with host runtime libraries. It also~
+** Processing line: ~  for native interoperability with host runtime libraries. It also~
 ** Processing line: ~  includes OS specific message pump orchestrations.~
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
-- Level 5 is a codegeneration layer which creates metadata that allows
-  for native interopability with host runtime libraries. It also   includes OS specific message pump orchestrations.
+- Level 5 is a code generation layer which creates metadata that allows
+  for native interoperability with host runtime libraries. It also   includes OS specific message pump orchestrations.
 ** Processing line: ~- Level 6 is a Ahead of Time/Just in Time Ruby compiler built with LLVM. This~
 - Line was identified as a list.
 *** True Line Result
@@ -3016,12 +3016,12 @@ Levels 1 through 3 are fairly commonplace in many runtime implemenations (with l
   compiler outputs _very_ fast platform specific bitcode, but only   supports a subset of the Ruby language specification.
 ** Processing line: ~These levels allow us to stay up to date with open source~
 ** Processing line: ~implementations of Ruby; provide fast, native code execution~
-** Processing line: ~on proprietary platforms; ensure good seperation between these two~
+** Processing line: ~on proprietary platforms; ensure good separation between these two~
 ** Processing line: ~worlds; and provides a means to add new platforms without going insane.~
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
-These levels allow us to stay up to date with open source implementations of Ruby; provide fast, native code execution on proprietary platforms; ensure good seperation between these two worlds; and provides a means to add new platforms without going insane.
+These levels allow us to stay up to date with open source implementations of Ruby; provide fast, native code execution on proprietary platforms; ensure good separation between these two worlds; and provides a means to add new platforms without going insane.
 ** Processing line: ~*** Cool cool. So given that I understand everything to this point, can we answer the original question? What is DragonRuby?~
 - Header detected.
 *** True Line Result
@@ -3032,13 +3032,13 @@ These levels allow us to stay up to date with open source implementations of Rub
 - End of paragraph detected.
 *** True Line Result
 
-** Processing line: ~DragonRuby is a Ruby runtime implentation that takes all the lessons~
+** Processing line: ~DragonRuby is a Ruby runtime implementation that takes all the lessons~
 ** Processing line: ~we've learned from MRI/CRuby, and merges it with the latest and greatest~
 ** Processing line: ~compiler and OSS technologies.~
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
-DragonRuby is a Ruby runtime implentation that takes all the lessons we've learned from MRI/CRuby, and merges it with the latest and greatest compiler and OSS technologies.
+DragonRuby is a Ruby runtime implementation that takes all the lessons we've learned from MRI/CRuby, and merges it with the latest and greatest compiler and OSS technologies.
 ** Processing line: ~** Frequent Comments~
 - Header detected.
 *** True Line Result
@@ -3099,12 +3099,12 @@ Let's stop making this comment shall we?
 - End of paragraph detected.
 *** True Line Result
 That doesn't make any sense. A language specification can't be slow... it's a language spec. Sure, an _implementation/runtime_ can be slow though, but then we'd have to talk about which runtime.
-** Processing line: ~*** Dynamic langauges are slow.~
+** Processing line: ~*** Dynamic languages are slow.~
 - Header detected.
 *** True Line Result
 
 *** True Line Result
-*** Dynamic langauges are slow.
+*** Dynamic languages are slow.
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
@@ -3117,19 +3117,19 @@ That doesn't make any sense. A language specification can't be slow... it's a la
 *** True Line Result
 They are certainly slower than statically compiled languages. With the processing power and compiler optimizations we have today, dynamic languages like Ruby are _fast enough_.
 ** Processing line: ~Unless you are writing in some form of intermediate representation by hand,~
-** Processing line: ~your langauge of choice also suffers this same fallacy of slow. Like, nothing is~
+** Processing line: ~your language of choice also suffers this same fallacy of slow. Like, nothing is~
 ** Processing line: ~faster than a low level assembly-like language. So unless you're~
 ** Processing line: ~writing in that, let's stop making this comment.~
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
-Unless you are writing in some form of intermediate representation by hand, your langauge of choice also suffers this same fallacy of slow. Like, nothing is faster than a low level assembly-like language. So unless you're writing in that, let's stop making this comment.
+Unless you are writing in some form of intermediate representation by hand, your language of choice also suffers this same fallacy of slow. Like, nothing is faster than a low level assembly-like language. So unless you're writing in that, let's stop making this comment.
 ** Processing line: ~NOTE: If you _are_ hand writing LLVM IR, we are always open to~
-** Processing line: ~bringing on new partners with such a skillset. Email us ^_^.~
+** Processing line: ~bringing on new partners with such a skill set. Email us ^_^.~
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
-NOTE: If you _are_ hand writing LLVM IR, we are always open to bringing on new partners with such a skillset. Email us ^_^.
+NOTE: If you _are_ hand writing LLVM IR, we are always open to bringing on new partners with such a skill set. Email us ^_^.
 ** Processing line: ~** Frequent Concerns~
 - Header detected.
 *** True Line Result
@@ -3151,20 +3151,20 @@ NOTE: If you _are_ hand writing LLVM IR, we are always open to bringing on new p
 *** True Line Result
 
 ** Processing line: ~The current state of open source is unsustainable. Contributors work~
-** Processing line: ~for free, most all open source repositories are serverly understaffed,~
+** Processing line: ~for free, most all open source repositories are severely under-staffed,~
 ** Processing line: ~and burnout from core members is rampant.~
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
-The current state of open source is unsustainable. Contributors work for free, most all open source repositories are serverly understaffed, and burnout from core members is rampant.
+The current state of open source is unsustainable. Contributors work for free, most all open source repositories are severely under-staffed, and burnout from core members is rampant.
 ** Processing line: ~We believe in open source very strongly. Parts of DragonRuby are~
-** Processing line: ~infact, open source. Just not all of it (for legal reasons, and~
+** Processing line: ~in fact, open source. Just not all of it (for legal reasons, and~
 ** Processing line: ~because the IP we've created has value). And we promise that we are~
 ** Processing line: ~looking for (or creating) ways to _sustainably_ open source everything we do.~
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
-We believe in open source very strongly. Parts of DragonRuby are infact, open source. Just not all of it (for legal reasons, and because the IP we've created has value). And we promise that we are looking for (or creating) ways to _sustainably_ open source everything we do.
+We believe in open source very strongly. Parts of DragonRuby are in fact, open source. Just not all of it (for legal reasons, and because the IP we've created has value). And we promise that we are looking for (or creating) ways to _sustainably_ open source everything we do.
 ** Processing line: ~If you have ideas on how we can do this, email us!~
 ** Processing line: ~~
 - End of paragraph detected.
@@ -3283,14 +3283,14 @@ Seriously just buy it. Get a refund if you don't like it. We make it stupid easy
 - End of paragraph detected.
 *** True Line Result
 Free isn't a sustainable financial model. We don't want to spam your email. We don't want to collect usage data off of you either. We just want to provide quality toolchains to quality developers (as opposed to a large quantity of developers).
-** Processing line: ~The peiple that pay for DragonRuby and make an effort to understand it are the~
+** Processing line: ~The people that pay for DragonRuby and make an effort to understand it are the~
 ** Processing line: ~ones we want to build a community around, partner with, and collaborate~
 ** Processing line: ~with. So having that small monetary wall deters entitled individuals~
 ** Processing line: ~that don't value the same things we do.~
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
-The peiple that pay for DragonRuby and make an effort to understand it are the ones we want to build a community around, partner with, and collaborate with. So having that small monetary wall deters entitled individuals that don't value the same things we do.
+The people that pay for DragonRuby and make an effort to understand it are the ones we want to build a community around, partner with, and collaborate with. So having that small monetary wall deters entitled individuals that don't value the same things we do.
 ** Processing line: ~*** What if I build something with DragonRuby, but DragonRuby LLP becomes insolvent.~
 - Header detected.
 *** True Line Result
@@ -3309,13 +3309,13 @@ The peiple that pay for DragonRuby and make an effort to understand it are the o
 - End of paragraph detected.
 *** True Line Result
 That won't happen if the development world stop asking for free stuff and non-trivially compensate open source developers. Look, we want to be able to work on the stuff we love, every day of our lives. And we'll go to great lengths to make that happen.
-** Processing line: ~But, in the event that sad day comes, our partnershiop bylaws state that~
+** Processing line: ~But, in the event that sad day comes, our partnership bylaws state that~
 ** Processing line: ~_all_ DragonRuby IP that can be legally open sourced, will be released~
 ** Processing line: ~under a permissive license.~
 ** Processing line: ~~
 - End of paragraph detected.
 *** True Line Result
-But, in the event that sad day comes, our partnershiop bylaws state that _all_ DragonRuby IP that can be legally open sourced, will be released under a permissive license.
+But, in the event that sad day comes, our partnership bylaws state that _all_ DragonRuby IP that can be legally open sourced, will be released under a permissive license.
 ** Processing line: ~* DOCS: ~GTK::Runtime~~
 - Header detected.
 *** True Line Result
@@ -4372,101 +4372,6 @@ Outputs is how you render primitives to the screen. The minimal setup for render
 - End of paragraph detected.
 *** True Line Result
 
-** Processing line: ~* DOCS: ~GTK::Outputs#borders~~
-- Header detected.
-*** True Line Result
-
-*** True Line Result
-* DOCS: ~GTK::Outputs#borders~
-** Processing line: ~~
-- End of paragraph detected.
-*** True Line Result
-
-** Processing line: ~Add primitives to this collection to render an unfilled solid to the screen. Take a look at the~
-** Processing line: ~documentation for Outputs#solids.~
-** Processing line: ~~
-- End of paragraph detected.
-*** True Line Result
-Add primitives to this collection to render an unfilled solid to the screen. Take a look at the documentation for Outputs#solids.
-** Processing line: ~The only difference between the two primitives is where they are added.~
-** Processing line: ~~
-- End of paragraph detected.
-*** True Line Result
-The only difference between the two primitives is where they are added.
-** Processing line: ~Instead of using ~args.outputs.solids~:~
-** Processing line: ~~
-- End of paragraph detected.
-*** True Line Result
-Instead of using ~args.outputs.solids~:
-** Processing line: ~#+begin_src~
-- Line was identified as the beginning of a code block.
-*** True Line Result
-
-*** True Line Result
-#+begin_src
-** Processing line: ~  def tick args~
-- Inside source: true
-*** True Line Result
-  def tick args
-** Processing line: ~    #                         X    Y  WIDTH  HEIGHT~
-- Inside source: true
-*** True Line Result
-    #                         X    Y  WIDTH  HEIGHT
-** Processing line: ~    args.outputs.solids << [100, 100,   160,     90]~
-- Inside source: true
-*** True Line Result
-    args.outputs.solids << [100, 100,   160,     90]
-** Processing line: ~  end~
-- Inside source: true
-*** True Line Result
-  end
-** Processing line: ~#+end_src~
-- Line was identified as the end of a code block.
-*** True Line Result
-#+end_src
-** Processing line: ~~
-- End of paragraph detected.
-*** True Line Result
-
-** Processing line: ~You have to use ~args.outputs.borders~:~
-** Processing line: ~~
-- End of paragraph detected.
-*** True Line Result
-You have to use ~args.outputs.borders~:
-** Processing line: ~#+begin_src~
-- Line was identified as the beginning of a code block.
-*** True Line Result
-
-*** True Line Result
-#+begin_src
-** Processing line: ~  def tick args~
-- Inside source: true
-*** True Line Result
-  def tick args
-** Processing line: ~    #                           X    Y  WIDTH  HEIGHT~
-- Inside source: true
-*** True Line Result
-    #                           X    Y  WIDTH  HEIGHT
-** Processing line: ~    args.outputs.borders << [100, 100,   160,     90]~
-- Inside source: true
-*** True Line Result
-    args.outputs.borders << [100, 100,   160,     90]
-** Processing line: ~  end~
-- Inside source: true
-*** True Line Result
-  end
-** Processing line: ~#+end_src~
-- Line was identified as the end of a code block.
-*** True Line Result
-#+end_src
-** Processing line: ~~
-- End of paragraph detected.
-*** True Line Result
-
-** Processing line: ~~
-- End of paragraph detected.
-*** True Line Result
-
 ** Processing line: ~* DOCS: ~GTK::Outputs#solids~~
 - Header detected.
 *** True Line Result
@@ -4794,6 +4699,101 @@ Here is an example:
 - End of paragraph detected.
 *** True Line Result
 
+** Processing line: ~* DOCS: ~GTK::Outputs#borders~~
+- Header detected.
+*** True Line Result
+
+*** True Line Result
+* DOCS: ~GTK::Outputs#borders~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+
+** Processing line: ~Add primitives to this collection to render an unfilled solid to the screen. Take a look at the~
+** Processing line: ~documentation for Outputs#solids.~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+Add primitives to this collection to render an unfilled solid to the screen. Take a look at the documentation for Outputs#solids.
+** Processing line: ~The only difference between the two primitives is where they are added.~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+The only difference between the two primitives is where they are added.
+** Processing line: ~Instead of using ~args.outputs.solids~:~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+Instead of using ~args.outputs.solids~:
+** Processing line: ~#+begin_src~
+- Line was identified as the beginning of a code block.
+*** True Line Result
+
+*** True Line Result
+#+begin_src
+** Processing line: ~  def tick args~
+- Inside source: true
+*** True Line Result
+  def tick args
+** Processing line: ~    #                         X    Y  WIDTH  HEIGHT~
+- Inside source: true
+*** True Line Result
+    #                         X    Y  WIDTH  HEIGHT
+** Processing line: ~    args.outputs.solids << [100, 100,   160,     90]~
+- Inside source: true
+*** True Line Result
+    args.outputs.solids << [100, 100,   160,     90]
+** Processing line: ~  end~
+- Inside source: true
+*** True Line Result
+  end
+** Processing line: ~#+end_src~
+- Line was identified as the end of a code block.
+*** True Line Result
+#+end_src
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+
+** Processing line: ~You have to use ~args.outputs.borders~:~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+You have to use ~args.outputs.borders~:
+** Processing line: ~#+begin_src~
+- Line was identified as the beginning of a code block.
+*** True Line Result
+
+*** True Line Result
+#+begin_src
+** Processing line: ~  def tick args~
+- Inside source: true
+*** True Line Result
+  def tick args
+** Processing line: ~    #                           X    Y  WIDTH  HEIGHT~
+- Inside source: true
+*** True Line Result
+    #                           X    Y  WIDTH  HEIGHT
+** Processing line: ~    args.outputs.borders << [100, 100,   160,     90]~
+- Inside source: true
+*** True Line Result
+    args.outputs.borders << [100, 100,   160,     90]
+** Processing line: ~  end~
+- Inside source: true
+*** True Line Result
+  end
+** Processing line: ~#+end_src~
+- Line was identified as the end of a code block.
+*** True Line Result
+#+end_src
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+
 ** Processing line: ~* DOCS: ~GTK::Mouse~~
 - Header detected.
 *** True Line Result
@@ -5453,6 +5453,535 @@ Example using named parameters:
 - End of paragraph detected.
 *** True Line Result
 
+** Processing line: ~* DOCS: ~Numeric#elapsed_time~~
+- Header detected.
+*** True Line Result
+
+*** True Line Result
+* DOCS: ~Numeric#elapsed_time~
+** Processing line: ~For a given number, the elapsed frames since that number is returned.~
+** Processing line: ~`Kernel.tick_count` is used to determine how many frames have elapsed.~
+** Processing line: ~An optional numeric argument can be passed in which will be used instead~
+** Processing line: ~of `Kernel.tick_count`.~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+For a given number, the elapsed frames since that number is returned. `Kernel.tick_count` is used to determine how many frames have elapsed. An optional numeric argument can be passed in which will be used instead of `Kernel.tick_count`.
+** Processing line: ~Here is an example of how elapsed_time can be used.~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+Here is an example of how elapsed_time can be used.
+** Processing line: ~#+begin_src ruby~
+- Line was identified as the beginning of a code block.
+*** True Line Result
+
+*** True Line Result
+#+begin_src ruby
+** Processing line: ~  def tick args~
+- Inside source: true
+*** True Line Result
+  def tick args
+** Processing line: ~    args.state.last_click_at ||= 0~
+- Inside source: true
+*** True Line Result
+    args.state.last_click_at ||= 0
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    # record when a mouse click occurs~
+- Inside source: true
+*** True Line Result
+    # record when a mouse click occurs
+** Processing line: ~    if args.inputs.mouse.click~
+- Inside source: true
+*** True Line Result
+    if args.inputs.mouse.click
+** Processing line: ~      args.state.last_click_at = args.state.tick_count~
+- Inside source: true
+*** True Line Result
+      args.state.last_click_at = args.state.tick_count
+** Processing line: ~    end~
+- Inside source: true
+*** True Line Result
+    end
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    # Use Numeric#elapsed_time to determine how long it's been~
+- Inside source: true
+*** True Line Result
+    # Use Numeric#elapsed_time to determine how long it's been
+** Processing line: ~    if args.state.last_click_at.elapsed_time > 120~
+- Inside source: true
+*** True Line Result
+    if args.state.last_click_at.elapsed_time > 120
+** Processing line: ~      args.outputs.labels << [10, 710, "It has been over 2 seconds since the mouse was clicked."]~
+- Inside source: true
+*** True Line Result
+      args.outputs.labels << [10, 710, "It has been over 2 seconds since the mouse was clicked."]
+** Processing line: ~    end~
+- Inside source: true
+*** True Line Result
+    end
+** Processing line: ~  end~
+- Inside source: true
+*** True Line Result
+  end
+** Processing line: ~#+end_src~
+- Line was identified as the end of a code block.
+*** True Line Result
+#+end_src
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+
+** Processing line: ~And here is an example where the override parameter is passed in:~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+And here is an example where the override parameter is passed in:
+** Processing line: ~#+begin_src ruby~
+- Line was identified as the beginning of a code block.
+*** True Line Result
+
+*** True Line Result
+#+begin_src ruby
+** Processing line: ~  def tick args~
+- Inside source: true
+*** True Line Result
+  def tick args
+** Processing line: ~    args.state.last_click_at ||= 0~
+- Inside source: true
+*** True Line Result
+    args.state.last_click_at ||= 0
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    # create a state variable that tracks time at half the speed of args.state.tick_count~
+- Inside source: true
+*** True Line Result
+    # create a state variable that tracks time at half the speed of args.state.tick_count
+** Processing line: ~    args.state.simulation_tick = args.state.tick_count.idiv 2~
+- Inside source: true
+*** True Line Result
+    args.state.simulation_tick = args.state.tick_count.idiv 2
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    # record when a mouse click occurs~
+- Inside source: true
+*** True Line Result
+    # record when a mouse click occurs
+** Processing line: ~    if args.inputs.mouse.click~
+- Inside source: true
+*** True Line Result
+    if args.inputs.mouse.click
+** Processing line: ~      args.state.last_click_at = args.state.simulation_tick~
+- Inside source: true
+*** True Line Result
+      args.state.last_click_at = args.state.simulation_tick
+** Processing line: ~    end~
+- Inside source: true
+*** True Line Result
+    end
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    # Use Numeric#elapsed_time to determine how long it's been~
+- Inside source: true
+*** True Line Result
+    # Use Numeric#elapsed_time to determine how long it's been
+** Processing line: ~    if (args.state.last_click_at.elapsed_time args.state.simulation_tick) > 120~
+- Inside source: true
+*** True Line Result
+    if (args.state.last_click_at.elapsed_time args.state.simulation_tick) > 120
+** Processing line: ~      args.outputs.labels << [10, 710, "It has been over 4 seconds since the mouse was clicked."]~
+- Inside source: true
+*** True Line Result
+      args.outputs.labels << [10, 710, "It has been over 4 seconds since the mouse was clicked."]
+** Processing line: ~    end~
+- Inside source: true
+*** True Line Result
+    end
+** Processing line: ~  end~
+- Inside source: true
+*** True Line Result
+  end
+** Processing line: ~#+end_src~
+- Line was identified as the end of a code block.
+*** True Line Result
+#+end_src
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+
+** Processing line: ~* DOCS: ~Numeric#elapsed?~~
+- Header detected.
+*** True Line Result
+
+*** True Line Result
+* DOCS: ~Numeric#elapsed?~
+** Processing line: ~Returns true if ~Numeric#elapsed_time~ is greater than the number. An optional parameter can be~
+** Processing line: ~passed into ~elapsed?~ which is added to the number before evaluating whether ~elapsed?~ is true.~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+Returns true if ~Numeric#elapsed_time~ is greater than the number. An optional parameter can be passed into ~elapsed?~ which is added to the number before evaluating whether ~elapsed?~ is true.
+** Processing line: ~Example usage (no optional parameter):~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+Example usage (no optional parameter):
+** Processing line: ~#+begin_src ruby~
+- Line was identified as the beginning of a code block.
+*** True Line Result
+
+*** True Line Result
+#+begin_src ruby
+** Processing line: ~  def tick args~
+- Inside source: true
+*** True Line Result
+  def tick args
+** Processing line: ~    args.state.box_queue ||= []~
+- Inside source: true
+*** True Line Result
+    args.state.box_queue ||= []
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    if args.state.box_queue.empty?~
+- Inside source: true
+*** True Line Result
+    if args.state.box_queue.empty?
+** Processing line: ~      args.state.box_queue << { name: :red,~
+- Inside source: true
+*** True Line Result
+      args.state.box_queue << { name: :red,
+** Processing line: ~                                destroy_at: args.state.tick_count + 60 }~
+- Inside source: true
+*** True Line Result
+                                destroy_at: args.state.tick_count + 60 }
+** Processing line: ~      args.state.box_queue << { name: :green,~
+- Inside source: true
+*** True Line Result
+      args.state.box_queue << { name: :green,
+** Processing line: ~                                destroy_at: args.state.tick_count + 60 }~
+- Inside source: true
+*** True Line Result
+                                destroy_at: args.state.tick_count + 60 }
+** Processing line: ~      args.state.box_queue << { name: :blue,~
+- Inside source: true
+*** True Line Result
+      args.state.box_queue << { name: :blue,
+** Processing line: ~                                destroy_at: args.state.tick_count + 120 }~
+- Inside source: true
+*** True Line Result
+                                destroy_at: args.state.tick_count + 120 }
+** Processing line: ~    end~
+- Inside source: true
+*** True Line Result
+    end
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    boxes_to_destroy = args.state~
+- Inside source: true
+*** True Line Result
+    boxes_to_destroy = args.state
+** Processing line: ~                           .box_queue~
+- Inside source: true
+*** True Line Result
+                           .box_queue
+** Processing line: ~                           .find_all { |b| b[:destroy_at].elapsed? }~
+- Inside source: true
+*** True Line Result
+                           .find_all { |b| b[:destroy_at].elapsed? }
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    if !boxes_to_destroy.empty?~
+- Inside source: true
+*** True Line Result
+    if !boxes_to_destroy.empty?
+** Processing line: ~      puts "boxes to destroy count: #{boxes_to_destroy.length}"~
+- Inside source: true
+*** True Line Result
+      puts "boxes to destroy count: #{boxes_to_destroy.length}"
+** Processing line: ~    end~
+- Inside source: true
+*** True Line Result
+    end
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    boxes_to_destroy.each { |b| puts "box #{b} was elapsed? on #{args.state.tick_count}." }~
+- Inside source: true
+*** True Line Result
+    boxes_to_destroy.each { |b| puts "box #{b} was elapsed? on #{args.state.tick_count}." }
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    args.state.box_queue -= boxes_to_destroy~
+- Inside source: true
+*** True Line Result
+    args.state.box_queue -= boxes_to_destroy
+** Processing line: ~  end~
+- Inside source: true
+*** True Line Result
+  end
+** Processing line: ~#+end_src~
+- Line was identified as the end of a code block.
+*** True Line Result
+#+end_src
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+
+** Processing line: ~Example usage (with optional parameter):~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+Example usage (with optional parameter):
+** Processing line: ~#+begin_src ruby~
+- Line was identified as the beginning of a code block.
+*** True Line Result
+
+*** True Line Result
+#+begin_src ruby
+** Processing line: ~  def tick args~
+- Inside source: true
+*** True Line Result
+  def tick args
+** Processing line: ~    args.state.box_queue ||= []~
+- Inside source: true
+*** True Line Result
+    args.state.box_queue ||= []
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    if args.state.box_queue.empty?~
+- Inside source: true
+*** True Line Result
+    if args.state.box_queue.empty?
+** Processing line: ~      args.state.box_queue << { name: :red,~
+- Inside source: true
+*** True Line Result
+      args.state.box_queue << { name: :red,
+** Processing line: ~                                create_at: args.state.tick_count + 120,~
+- Inside source: true
+*** True Line Result
+                                create_at: args.state.tick_count + 120,
+** Processing line: ~                                lifespan: 60 }~
+- Inside source: true
+*** True Line Result
+                                lifespan: 60 }
+** Processing line: ~      args.state.box_queue << { name: :green,~
+- Inside source: true
+*** True Line Result
+      args.state.box_queue << { name: :green,
+** Processing line: ~                                create_at: args.state.tick_count + 120,~
+- Inside source: true
+*** True Line Result
+                                create_at: args.state.tick_count + 120,
+** Processing line: ~                                lifespan: 60 }~
+- Inside source: true
+*** True Line Result
+                                lifespan: 60 }
+** Processing line: ~      args.state.box_queue << { name: :blue,~
+- Inside source: true
+*** True Line Result
+      args.state.box_queue << { name: :blue,
+** Processing line: ~                                create_at: args.state.tick_count + 120,~
+- Inside source: true
+*** True Line Result
+                                create_at: args.state.tick_count + 120,
+** Processing line: ~                                lifespan: 120 }~
+- Inside source: true
+*** True Line Result
+                                lifespan: 120 }
+** Processing line: ~    end~
+- Inside source: true
+*** True Line Result
+    end
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    # lifespan is passed in as a parameter to ~elapsed?~~
+- Inside source: true
+*** True Line Result
+    # lifespan is passed in as a parameter to ~elapsed?~
+** Processing line: ~    boxes_to_destroy = args.state~
+- Inside source: true
+*** True Line Result
+    boxes_to_destroy = args.state
+** Processing line: ~                           .box_queue~
+- Inside source: true
+*** True Line Result
+                           .box_queue
+** Processing line: ~                           .find_all { |b| b[:create_at].elapsed? b[:lifespan] }~
+- Inside source: true
+*** True Line Result
+                           .find_all { |b| b[:create_at].elapsed? b[:lifespan] }
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    if !boxes_to_destroy.empty?~
+- Inside source: true
+*** True Line Result
+    if !boxes_to_destroy.empty?
+** Processing line: ~      puts "boxes to destroy count: #{boxes_to_destroy.length}"~
+- Inside source: true
+*** True Line Result
+      puts "boxes to destroy count: #{boxes_to_destroy.length}"
+** Processing line: ~    end~
+- Inside source: true
+*** True Line Result
+    end
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    boxes_to_destroy.each { |b| puts "box #{b} was elapsed? on #{args.state.tick_count}." }~
+- Inside source: true
+*** True Line Result
+    boxes_to_destroy.each { |b| puts "box #{b} was elapsed? on #{args.state.tick_count}." }
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    args.state.box_queue -= boxes_to_destroy~
+- Inside source: true
+*** True Line Result
+    args.state.box_queue -= boxes_to_destroy
+** Processing line: ~  end~
+- Inside source: true
+*** True Line Result
+  end
+** Processing line: ~#+end_src~
+- Line was identified as the end of a code block.
+*** True Line Result
+#+end_src
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+
+** Processing line: ~* DOCS: ~Numeric#created?~~
+- Header detected.
+*** True Line Result
+
+*** True Line Result
+* DOCS: ~Numeric#created?~
+** Processing line: ~Returns true if ~Numeric#elapsed_time == 0~. Essentially communicating that~
+** Processing line: ~number is equal to the current frame.~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+Returns true if ~Numeric#elapsed_time == 0~. Essentially communicating that number is equal to the current frame.
+** Processing line: ~Example usage:~
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+Example usage:
+** Processing line: ~#+begin_src ruby~
+- Line was identified as the beginning of a code block.
+*** True Line Result
+
+*** True Line Result
+#+begin_src ruby
+** Processing line: ~  def tick args~
+- Inside source: true
+*** True Line Result
+  def tick args
+** Processing line: ~    args.state.box_queue ||= []~
+- Inside source: true
+*** True Line Result
+    args.state.box_queue ||= []
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    if args.state.box_queue.empty?~
+- Inside source: true
+*** True Line Result
+    if args.state.box_queue.empty?
+** Processing line: ~      args.state.box_queue << { name: :red,~
+- Inside source: true
+*** True Line Result
+      args.state.box_queue << { name: :red,
+** Processing line: ~                                create_at: args.state.tick_count + 60 }~
+- Inside source: true
+*** True Line Result
+                                create_at: args.state.tick_count + 60 }
+** Processing line: ~    end~
+- Inside source: true
+*** True Line Result
+    end
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    boxes_to_spawn_this_frame = args.state~
+- Inside source: true
+*** True Line Result
+    boxes_to_spawn_this_frame = args.state
+** Processing line: ~                                    .box_queue~
+- Inside source: true
+*** True Line Result
+                                    .box_queue
+** Processing line: ~                                    .find_all { |b| b[:create_at].new? }~
+- Inside source: true
+*** True Line Result
+                                    .find_all { |b| b[:create_at].new? }
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    boxes_to_spawn_this_frame.each { |b| puts "box #{b} was new? on #{args.state.tick_count}." }~
+- Inside source: true
+*** True Line Result
+    boxes_to_spawn_this_frame.each { |b| puts "box #{b} was new? on #{args.state.tick_count}." }
+** Processing line: ~~
+- Inside source: true
+*** True Line Result
+
+** Processing line: ~    args.state.box_queue -= boxes_to_spawn_this_frame~
+- Inside source: true
+*** True Line Result
+    args.state.box_queue -= boxes_to_spawn_this_frame
+** Processing line: ~  end~
+- Inside source: true
+*** True Line Result
+  end
+** Processing line: ~#+end_src~
+- Line was identified as the end of a code block.
+*** True Line Result
+#+end_src
+** Processing line: ~~
+- End of paragraph detected.
+*** True Line Result
+
 ** Processing line: ~* DOCS: ~Kernel~~
 - Header detected.
 *** True Line Result
@@ -7339,9 +7868,9 @@ Returns the current tick of the game. This value is reset if you call $gtk.reset
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
-** Processing line: ~A runtime is an _implementation_ of a langauge specification. When people say "Ruby," they are usually referring to "the Ruby 3.0+ language specification implemented via the CRuby/MRI Runtime."~
+** Processing line: ~A runtime is an _implementation_ of a language specification. When people say "Ruby," they are usually referring to "the Ruby 3.0+ language specification implemented via the CRuby/MRI Runtime."~
 - P detected.
-- Formatting line: ~A runtime is an _implementation_ of a langauge specification. When people say "Ruby," they are usually referring to "the Ruby 3.0+ language specification implemented via the CRuby/MRI Runtime."~
+- Formatting line: ~A runtime is an _implementation_ of a language specification. When people say "Ruby," they are usually referring to "the Ruby 3.0+ language specification implemented via the CRuby/MRI Runtime."~
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~But, there are many Ruby Runtimes: CRuby/MRI, JRuby, Truffle, Rubinius, Artichoke, and (last but certainly not least) DragonRuby.~
@@ -7420,27 +7949,27 @@ Returns the current tick of the game. This value is reset if you call $gtk.reset
   C-Extensions.~
 - Line's tilde count is: 0
 - Line contains link marker: false
-** Processing line: ~Levels 1 through 3 are fairly commonplace in many runtime implemenations (with level 1 being the most portable, and level 3 being the fastest). But the DragonRuby Runtime has taken things a bit further:~
+** Processing line: ~Levels 1 through 3 are fairly commonplace in many runtime implementations (with level 1 being the most portable, and level 3 being the fastest). But the DragonRuby Runtime has taken things a bit further:~
 - UL end detected.
 - P detected.
-- Formatting line: ~Levels 1 through 3 are fairly commonplace in many runtime implemenations (with level 1 being the most portable, and level 3 being the fastest). But the DragonRuby Runtime has taken things a bit further:~
+- Formatting line: ~Levels 1 through 3 are fairly commonplace in many runtime implementations (with level 1 being the most portable, and level 3 being the fastest). But the DragonRuby Runtime has taken things a bit further:~
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
 ** Processing line: ~- Level 4 consists of shared abstractions around hardware I/O and operating
-  system resources. This level leverages open source and proprietary   components within Simple DirectMedia Layer (a lowlevel multimedia   component library that has been in active development for 22 years   and counting).~
+  system resources. This level leverages open source and proprietary   components within Simple DirectMedia Layer (a low level multimedia   component library that has been in active development for 22 years   and counting).~
 - UL start detected.
 - LI detected.
 - Formatting line: ~Level 4 consists of shared abstractions around hardware I/O and operating
-  system resources. This level leverages open source and proprietary   components within Simple DirectMedia Layer (a lowlevel multimedia   component library that has been in active development for 22 years   and counting).~
+  system resources. This level leverages open source and proprietary   components within Simple DirectMedia Layer (a low level multimedia   component library that has been in active development for 22 years   and counting).~
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
-** Processing line: ~- Level 5 is a codegeneration layer which creates metadata that allows
-  for native interopability with host runtime libraries. It also   includes OS specific message pump orchestrations.~
+** Processing line: ~- Level 5 is a code generation layer which creates metadata that allows
+  for native interoperability with host runtime libraries. It also   includes OS specific message pump orchestrations.~
 - LI detected.
-- Formatting line: ~Level 5 is a codegeneration layer which creates metadata that allows
-  for native interopability with host runtime libraries. It also   includes OS specific message pump orchestrations.~
+- Formatting line: ~Level 5 is a code generation layer which creates metadata that allows
+  for native interoperability with host runtime libraries. It also   includes OS specific message pump orchestrations.~
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
@@ -7451,10 +7980,10 @@ Returns the current tick of the game. This value is reset if you call $gtk.reset
   compiler outputs _very_ fast platform specific bitcode, but only   supports a subset of the Ruby language specification.~
 - Line's tilde count is: 0
 - Line contains link marker: false
-** Processing line: ~These levels allow us to stay up to date with open source implementations of Ruby; provide fast, native code execution on proprietary platforms; ensure good seperation between these two worlds; and provides a means to add new platforms without going insane.~
+** Processing line: ~These levels allow us to stay up to date with open source implementations of Ruby; provide fast, native code execution on proprietary platforms; ensure good separation between these two worlds; and provides a means to add new platforms without going insane.~
 - UL end detected.
 - P detected.
-- Formatting line: ~These levels allow us to stay up to date with open source implementations of Ruby; provide fast, native code execution on proprietary platforms; ensure good seperation between these two worlds; and provides a means to add new platforms without going insane.~
+- Formatting line: ~These levels allow us to stay up to date with open source implementations of Ruby; provide fast, native code execution on proprietary platforms; ensure good separation between these two worlds; and provides a means to add new platforms without going insane.~
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
@@ -7467,9 +7996,9 @@ Returns the current tick of the game. This value is reset if you call $gtk.reset
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
-** Processing line: ~DragonRuby is a Ruby runtime implentation that takes all the lessons we've learned from MRI/CRuby, and merges it with the latest and greatest compiler and OSS technologies.~
+** Processing line: ~DragonRuby is a Ruby runtime implementation that takes all the lessons we've learned from MRI/CRuby, and merges it with the latest and greatest compiler and OSS technologies.~
 - P detected.
-- Formatting line: ~DragonRuby is a Ruby runtime implentation that takes all the lessons we've learned from MRI/CRuby, and merges it with the latest and greatest compiler and OSS technologies.~
+- Formatting line: ~DragonRuby is a Ruby runtime implementation that takes all the lessons we've learned from MRI/CRuby, and merges it with the latest and greatest compiler and OSS technologies.~
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
@@ -7529,12 +8058,12 @@ Returns the current tick of the game. This value is reset if you call $gtk.reset
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
-** Processing line: ~*** Dynamic langauges are slow.~
+** Processing line: ~*** Dynamic languages are slow.~
 - H3 detected.
-- Formatting line: ~Dynamic langauges are slow.~
+- Formatting line: ~Dynamic languages are slow.~
 - Line's tilde count is: 0
 - Line contains link marker: false
-- Formatting line: ~Dynamic langauges are slow.~
+- Formatting line: ~Dynamic languages are slow.~
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
@@ -7543,14 +8072,14 @@ Returns the current tick of the game. This value is reset if you call $gtk.reset
 - Formatting line: ~They are certainly slower than statically compiled languages. With the processing power and compiler optimizations we have today, dynamic languages like Ruby are _fast enough_.~
 - Line's tilde count is: 0
 - Line contains link marker: false
-** Processing line: ~Unless you are writing in some form of intermediate representation by hand, your langauge of choice also suffers this same fallacy of slow. Like, nothing is faster than a low level assembly-like language. So unless you're writing in that, let's stop making this comment.~
+** Processing line: ~Unless you are writing in some form of intermediate representation by hand, your language of choice also suffers this same fallacy of slow. Like, nothing is faster than a low level assembly-like language. So unless you're writing in that, let's stop making this comment.~
 - P detected.
-- Formatting line: ~Unless you are writing in some form of intermediate representation by hand, your langauge of choice also suffers this same fallacy of slow. Like, nothing is faster than a low level assembly-like language. So unless you're writing in that, let's stop making this comment.~
+- Formatting line: ~Unless you are writing in some form of intermediate representation by hand, your language of choice also suffers this same fallacy of slow. Like, nothing is faster than a low level assembly-like language. So unless you're writing in that, let's stop making this comment.~
 - Line's tilde count is: 0
 - Line contains link marker: false
-** Processing line: ~NOTE: If you _are_ hand writing LLVM IR, we are always open to bringing on new partners with such a skillset. Email us ^_^.~
+** Processing line: ~NOTE: If you _are_ hand writing LLVM IR, we are always open to bringing on new partners with such a skill set. Email us ^_^.~
 - P detected.
-- Formatting line: ~NOTE: If you _are_ hand writing LLVM IR, we are always open to bringing on new partners with such a skillset. Email us ^_^.~
+- Formatting line: ~NOTE: If you _are_ hand writing LLVM IR, we are always open to bringing on new partners with such a skill set. Email us ^_^.~
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
@@ -7573,14 +8102,14 @@ Returns the current tick of the game. This value is reset if you call $gtk.reset
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
-** Processing line: ~The current state of open source is unsustainable. Contributors work for free, most all open source repositories are serverly understaffed, and burnout from core members is rampant.~
+** Processing line: ~The current state of open source is unsustainable. Contributors work for free, most all open source repositories are severely under-staffed, and burnout from core members is rampant.~
 - P detected.
-- Formatting line: ~The current state of open source is unsustainable. Contributors work for free, most all open source repositories are serverly understaffed, and burnout from core members is rampant.~
+- Formatting line: ~The current state of open source is unsustainable. Contributors work for free, most all open source repositories are severely under-staffed, and burnout from core members is rampant.~
 - Line's tilde count is: 0
 - Line contains link marker: false
-** Processing line: ~We believe in open source very strongly. Parts of DragonRuby are infact, open source. Just not all of it (for legal reasons, and because the IP we've created has value). And we promise that we are looking for (or creating) ways to _sustainably_ open source everything we do.~
+** Processing line: ~We believe in open source very strongly. Parts of DragonRuby are in fact, open source. Just not all of it (for legal reasons, and because the IP we've created has value). And we promise that we are looking for (or creating) ways to _sustainably_ open source everything we do.~
 - P detected.
-- Formatting line: ~We believe in open source very strongly. Parts of DragonRuby are infact, open source. Just not all of it (for legal reasons, and because the IP we've created has value). And we promise that we are looking for (or creating) ways to _sustainably_ open source everything we do.~
+- Formatting line: ~We believe in open source very strongly. Parts of DragonRuby are in fact, open source. Just not all of it (for legal reasons, and because the IP we've created has value). And we promise that we are looking for (or creating) ways to _sustainably_ open source everything we do.~
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~If you have ideas on how we can do this, email us!~
@@ -7690,9 +8219,9 @@ Returns the current tick of the game. This value is reset if you call $gtk.reset
 - Formatting line: ~Free isn't a sustainable financial model. We don't want to spam your email. We don't want to collect usage data off of you either. We just want to provide quality toolchains to quality developers (as opposed to a large quantity of developers).~
 - Line's tilde count is: 0
 - Line contains link marker: false
-** Processing line: ~The peiple that pay for DragonRuby and make an effort to understand it are the ones we want to build a community around, partner with, and collaborate with. So having that small monetary wall deters entitled individuals that don't value the same things we do.~
+** Processing line: ~The people that pay for DragonRuby and make an effort to understand it are the ones we want to build a community around, partner with, and collaborate with. So having that small monetary wall deters entitled individuals that don't value the same things we do.~
 - P detected.
-- Formatting line: ~The peiple that pay for DragonRuby and make an effort to understand it are the ones we want to build a community around, partner with, and collaborate with. So having that small monetary wall deters entitled individuals that don't value the same things we do.~
+- Formatting line: ~The people that pay for DragonRuby and make an effort to understand it are the ones we want to build a community around, partner with, and collaborate with. So having that small monetary wall deters entitled individuals that don't value the same things we do.~
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
@@ -7710,9 +8239,9 @@ Returns the current tick of the game. This value is reset if you call $gtk.reset
 - Formatting line: ~That won't happen if the development world stop asking for free stuff and non-trivially compensate open source developers. Look, we want to be able to work on the stuff we love, every day of our lives. And we'll go to great lengths to make that happen.~
 - Line's tilde count is: 0
 - Line contains link marker: false
-** Processing line: ~But, in the event that sad day comes, our partnershiop bylaws state that _all_ DragonRuby IP that can be legally open sourced, will be released under a permissive license.~
+** Processing line: ~But, in the event that sad day comes, our partnership bylaws state that _all_ DragonRuby IP that can be legally open sourced, will be released under a permissive license.~
 - P detected.
-- Formatting line: ~But, in the event that sad day comes, our partnershiop bylaws state that _all_ DragonRuby IP that can be legally open sourced, will be released under a permissive license.~
+- Formatting line: ~But, in the event that sad day comes, our partnership bylaws state that _all_ DragonRuby IP that can be legally open sourced, will be released under a permissive license.~
 - Line's tilde count is: 0
 - Line contains link marker: false
 ** Processing line: ~~
@@ -8147,57 +8676,6 @@ Returns the current tick of the game. This value is reset if you call $gtk.reset
 ** Processing line: ~~
 ** Processing line: ~~
 ** Processing line: ~~
-** Processing line: ~* DOCS: ~GTK::Outputs#borders~~
-- H1 detected.
-- Formatting line: ~~GTK::Outputs#borders~~
-- Line's tilde count is: 2
-- Line contains link marker: false
-- CODE detected.
-** Processing line: ~~
-** Processing line: ~Add primitives to this collection to render an unfilled solid to the screen. Take a look at the documentation for Outputs#solids.~
-- P detected.
-- Formatting line: ~Add primitives to this collection to render an unfilled solid to the screen. Take a look at the documentation for Outputs#solids.~
-- Line's tilde count is: 0
-- Line contains link marker: false
-** Processing line: ~The only difference between the two primitives is where they are added.~
-- P detected.
-- Formatting line: ~The only difference between the two primitives is where they are added.~
-- Line's tilde count is: 0
-- Line contains link marker: false
-** Processing line: ~Instead of using ~args.outputs.solids~:~
-- P detected.
-- Formatting line: ~Instead of using ~args.outputs.solids~:~
-- Line's tilde count is: 2
-- Line contains link marker: false
-- CODE detected.
-** Processing line: ~~
-** Processing line: ~#+begin_src~
-- PRE start detected.
-** Processing line: ~  def tick args~
-** Processing line: ~    #                         X    Y  WIDTH  HEIGHT~
-** Processing line: ~    args.outputs.solids << [100, 100,   160,     90]~
-** Processing line: ~  end~
-** Processing line: ~#+end_src~
-- PRE end detected.
-** Processing line: ~~
-** Processing line: ~You have to use ~args.outputs.borders~:~
-- P detected.
-- Formatting line: ~You have to use ~args.outputs.borders~:~
-- Line's tilde count is: 2
-- Line contains link marker: false
-- CODE detected.
-** Processing line: ~~
-** Processing line: ~#+begin_src~
-- PRE start detected.
-** Processing line: ~  def tick args~
-** Processing line: ~    #                           X    Y  WIDTH  HEIGHT~
-** Processing line: ~    args.outputs.borders << [100, 100,   160,     90]~
-** Processing line: ~  end~
-** Processing line: ~#+end_src~
-- PRE end detected.
-** Processing line: ~~
-** Processing line: ~~
-** Processing line: ~~
 ** Processing line: ~* DOCS: ~GTK::Outputs#solids~~
 - H1 detected.
 - Formatting line: ~~GTK::Outputs#solids~~
@@ -8352,6 +8830,57 @@ Returns the current tick of the game. This value is reset if you call $gtk.reset
 ** Processing line: ~~
 ** Processing line: ~~
 ** Processing line: ~~
+** Processing line: ~* DOCS: ~GTK::Outputs#borders~~
+- H1 detected.
+- Formatting line: ~~GTK::Outputs#borders~~
+- Line's tilde count is: 2
+- Line contains link marker: false
+- CODE detected.
+** Processing line: ~~
+** Processing line: ~Add primitives to this collection to render an unfilled solid to the screen. Take a look at the documentation for Outputs#solids.~
+- P detected.
+- Formatting line: ~Add primitives to this collection to render an unfilled solid to the screen. Take a look at the documentation for Outputs#solids.~
+- Line's tilde count is: 0
+- Line contains link marker: false
+** Processing line: ~The only difference between the two primitives is where they are added.~
+- P detected.
+- Formatting line: ~The only difference between the two primitives is where they are added.~
+- Line's tilde count is: 0
+- Line contains link marker: false
+** Processing line: ~Instead of using ~args.outputs.solids~:~
+- P detected.
+- Formatting line: ~Instead of using ~args.outputs.solids~:~
+- Line's tilde count is: 2
+- Line contains link marker: false
+- CODE detected.
+** Processing line: ~~
+** Processing line: ~#+begin_src~
+- PRE start detected.
+** Processing line: ~  def tick args~
+** Processing line: ~    #                         X    Y  WIDTH  HEIGHT~
+** Processing line: ~    args.outputs.solids << [100, 100,   160,     90]~
+** Processing line: ~  end~
+** Processing line: ~#+end_src~
+- PRE end detected.
+** Processing line: ~~
+** Processing line: ~You have to use ~args.outputs.borders~:~
+- P detected.
+- Formatting line: ~You have to use ~args.outputs.borders~:~
+- Line's tilde count is: 2
+- Line contains link marker: false
+- CODE detected.
+** Processing line: ~~
+** Processing line: ~#+begin_src~
+- PRE start detected.
+** Processing line: ~  def tick args~
+** Processing line: ~    #                           X    Y  WIDTH  HEIGHT~
+** Processing line: ~    args.outputs.borders << [100, 100,   160,     90]~
+** Processing line: ~  end~
+** Processing line: ~#+end_src~
+- PRE end detected.
+** Processing line: ~~
+** Processing line: ~~
+** Processing line: ~~
 ** Processing line: ~* DOCS: ~GTK::Mouse~~
 - H1 detected.
 - Formatting line: ~~GTK::Mouse~~
@@ -8760,6 +9289,198 @@ Returns the current tick of the game. This value is reset if you call $gtk.reset
 ** Processing line: ~~
 ** Processing line: ~~
 ** Processing line: ~~
+** Processing line: ~* DOCS: ~Numeric#elapsed_time~~
+- H1 detected.
+- Formatting line: ~~Numeric#elapsed_time~~
+- Line's tilde count is: 2
+- Line contains link marker: false
+- CODE detected.
+** Processing line: ~For a given number, the elapsed frames since that number is returned. `Kernel.tick_count` is used to determine how many frames have elapsed. An optional numeric argument can be passed in which will be used instead of `Kernel.tick_count`.~
+- P detected.
+- Formatting line: ~For a given number, the elapsed frames since that number is returned. `Kernel.tick_count` is used to determine how many frames have elapsed. An optional numeric argument can be passed in which will be used instead of `Kernel.tick_count`.~
+- Line's tilde count is: 0
+- Line contains link marker: false
+** Processing line: ~Here is an example of how elapsed_time can be used.~
+- P detected.
+- Formatting line: ~Here is an example of how elapsed_time can be used.~
+- Line's tilde count is: 0
+- Line contains link marker: false
+** Processing line: ~~
+** Processing line: ~#+begin_src ruby~
+- PRE start detected.
+** Processing line: ~  def tick args~
+** Processing line: ~    args.state.last_click_at ||= 0~
+** Processing line: ~~
+** Processing line: ~    # record when a mouse click occurs~
+** Processing line: ~    if args.inputs.mouse.click~
+** Processing line: ~      args.state.last_click_at = args.state.tick_count~
+** Processing line: ~    end~
+** Processing line: ~~
+** Processing line: ~    # Use Numeric#elapsed_time to determine how long it's been~
+** Processing line: ~    if args.state.last_click_at.elapsed_time > 120~
+** Processing line: ~      args.outputs.labels << [10, 710, "It has been over 2 seconds since the mouse was clicked."]~
+** Processing line: ~    end~
+** Processing line: ~  end~
+** Processing line: ~#+end_src~
+- PRE end detected.
+** Processing line: ~~
+** Processing line: ~And here is an example where the override parameter is passed in:~
+- P detected.
+- Formatting line: ~And here is an example where the override parameter is passed in:~
+- Line's tilde count is: 0
+- Line contains link marker: false
+** Processing line: ~~
+** Processing line: ~#+begin_src ruby~
+- PRE start detected.
+** Processing line: ~  def tick args~
+** Processing line: ~    args.state.last_click_at ||= 0~
+** Processing line: ~~
+** Processing line: ~    # create a state variable that tracks time at half the speed of args.state.tick_count~
+** Processing line: ~    args.state.simulation_tick = args.state.tick_count.idiv 2~
+** Processing line: ~~
+** Processing line: ~    # record when a mouse click occurs~
+** Processing line: ~    if args.inputs.mouse.click~
+** Processing line: ~      args.state.last_click_at = args.state.simulation_tick~
+** Processing line: ~    end~
+** Processing line: ~~
+** Processing line: ~    # Use Numeric#elapsed_time to determine how long it's been~
+** Processing line: ~    if (args.state.last_click_at.elapsed_time args.state.simulation_tick) > 120~
+** Processing line: ~      args.outputs.labels << [10, 710, "It has been over 4 seconds since the mouse was clicked."]~
+** Processing line: ~    end~
+** Processing line: ~  end~
+** Processing line: ~#+end_src~
+- PRE end detected.
+** Processing line: ~~
+** Processing line: ~~
+** Processing line: ~~
+** Processing line: ~* DOCS: ~Numeric#elapsed?~~
+- H1 detected.
+- Formatting line: ~~Numeric#elapsed?~~
+- Line's tilde count is: 2
+- Line contains link marker: false
+- CODE detected.
+** Processing line: ~Returns true if ~Numeric#elapsed_time~ is greater than the number. An optional parameter can be passed into ~elapsed?~ which is added to the number before evaluating whether ~elapsed?~ is true.~
+- P detected.
+- Formatting line: ~Returns true if ~Numeric#elapsed_time~ is greater than the number. An optional parameter can be passed into ~elapsed?~ which is added to the number before evaluating whether ~elapsed?~ is true.~
+- Line's tilde count is: 6
+- Line contains link marker: false
+- CODE detected.
+** Processing line: ~Example usage (no optional parameter):~
+- P detected.
+- Formatting line: ~Example usage (no optional parameter):~
+- Line's tilde count is: 0
+- Line contains link marker: false
+** Processing line: ~~
+** Processing line: ~#+begin_src ruby~
+- PRE start detected.
+** Processing line: ~  def tick args~
+** Processing line: ~    args.state.box_queue ||= []~
+** Processing line: ~~
+** Processing line: ~    if args.state.box_queue.empty?~
+** Processing line: ~      args.state.box_queue << { name: :red,~
+** Processing line: ~                                destroy_at: args.state.tick_count + 60 }~
+** Processing line: ~      args.state.box_queue << { name: :green,~
+** Processing line: ~                                destroy_at: args.state.tick_count + 60 }~
+** Processing line: ~      args.state.box_queue << { name: :blue,~
+** Processing line: ~                                destroy_at: args.state.tick_count + 120 }~
+** Processing line: ~    end~
+** Processing line: ~~
+** Processing line: ~    boxes_to_destroy = args.state~
+** Processing line: ~                           .box_queue~
+** Processing line: ~                           .find_all { |b| b[:destroy_at].elapsed? }~
+** Processing line: ~~
+** Processing line: ~    if !boxes_to_destroy.empty?~
+** Processing line: ~      puts "boxes to destroy count: #{boxes_to_destroy.length}"~
+** Processing line: ~    end~
+** Processing line: ~~
+** Processing line: ~    boxes_to_destroy.each { |b| puts "box #{b} was elapsed? on #{args.state.tick_count}." }~
+** Processing line: ~~
+** Processing line: ~    args.state.box_queue -= boxes_to_destroy~
+** Processing line: ~  end~
+** Processing line: ~#+end_src~
+- PRE end detected.
+** Processing line: ~~
+** Processing line: ~Example usage (with optional parameter):~
+- P detected.
+- Formatting line: ~Example usage (with optional parameter):~
+- Line's tilde count is: 0
+- Line contains link marker: false
+** Processing line: ~~
+** Processing line: ~#+begin_src ruby~
+- PRE start detected.
+** Processing line: ~  def tick args~
+** Processing line: ~    args.state.box_queue ||= []~
+** Processing line: ~~
+** Processing line: ~    if args.state.box_queue.empty?~
+** Processing line: ~      args.state.box_queue << { name: :red,~
+** Processing line: ~                                create_at: args.state.tick_count + 120,~
+** Processing line: ~                                lifespan: 60 }~
+** Processing line: ~      args.state.box_queue << { name: :green,~
+** Processing line: ~                                create_at: args.state.tick_count + 120,~
+** Processing line: ~                                lifespan: 60 }~
+** Processing line: ~      args.state.box_queue << { name: :blue,~
+** Processing line: ~                                create_at: args.state.tick_count + 120,~
+** Processing line: ~                                lifespan: 120 }~
+** Processing line: ~    end~
+** Processing line: ~~
+** Processing line: ~    # lifespan is passed in as a parameter to ~elapsed?~~
+** Processing line: ~    boxes_to_destroy = args.state~
+** Processing line: ~                           .box_queue~
+** Processing line: ~                           .find_all { |b| b[:create_at].elapsed? b[:lifespan] }~
+** Processing line: ~~
+** Processing line: ~    if !boxes_to_destroy.empty?~
+** Processing line: ~      puts "boxes to destroy count: #{boxes_to_destroy.length}"~
+** Processing line: ~    end~
+** Processing line: ~~
+** Processing line: ~    boxes_to_destroy.each { |b| puts "box #{b} was elapsed? on #{args.state.tick_count}." }~
+** Processing line: ~~
+** Processing line: ~    args.state.box_queue -= boxes_to_destroy~
+** Processing line: ~  end~
+** Processing line: ~#+end_src~
+- PRE end detected.
+** Processing line: ~~
+** Processing line: ~~
+** Processing line: ~~
+** Processing line: ~* DOCS: ~Numeric#created?~~
+- H1 detected.
+- Formatting line: ~~Numeric#created?~~
+- Line's tilde count is: 2
+- Line contains link marker: false
+- CODE detected.
+** Processing line: ~Returns true if ~Numeric#elapsed_time == 0~. Essentially communicating that number is equal to the current frame.~
+- P detected.
+- Formatting line: ~Returns true if ~Numeric#elapsed_time == 0~. Essentially communicating that number is equal to the current frame.~
+- Line's tilde count is: 2
+- Line contains link marker: false
+- CODE detected.
+** Processing line: ~Example usage:~
+- P detected.
+- Formatting line: ~Example usage:~
+- Line's tilde count is: 0
+- Line contains link marker: false
+** Processing line: ~~
+** Processing line: ~#+begin_src ruby~
+- PRE start detected.
+** Processing line: ~  def tick args~
+** Processing line: ~    args.state.box_queue ||= []~
+** Processing line: ~~
+** Processing line: ~    if args.state.box_queue.empty?~
+** Processing line: ~      args.state.box_queue << { name: :red,~
+** Processing line: ~                                create_at: args.state.tick_count + 60 }~
+** Processing line: ~    end~
+** Processing line: ~~
+** Processing line: ~    boxes_to_spawn_this_frame = args.state~
+** Processing line: ~                                    .box_queue~
+** Processing line: ~                                    .find_all { |b| b[:create_at].new? }~
+** Processing line: ~~
+** Processing line: ~    boxes_to_spawn_this_frame.each { |b| puts "box #{b} was new? on #{args.state.tick_count}." }~
+** Processing line: ~~
+** Processing line: ~    args.state.box_queue -= boxes_to_spawn_this_frame~
+** Processing line: ~  end~
+** Processing line: ~#+end_src~
+- PRE end detected.
+** Processing line: ~~
+** Processing line: ~~
 ** Processing line: ~* DOCS: ~Kernel~~
 - H1 detected.
 - Formatting line: ~~Kernel~~