Added beginning of insert mode.

This immmediately revealed a cursor problem, namely that I can't
style it with a vertical bar without using the actual terminal
cursor (I've been styling the normal-mode cursor with a highlighted
cell, not the real terminal cursor). I'll need to refactor a bit to
support that, but for now I'm just using a different color.

On the other hand, I was able to implement some basic commands:
- Switch to insert mode from normal via 'i',
- Switch to normal mode from insert via 'esc',
- Insert chars when in normal mode,
- "Forward deletion" (delete-key deletion, as opposed to backspace).

Fixed bug where widgets were using stale frame sizes.

Added cursor x position memory.

Explicit horizontal movements store their final x position. When
making vertical movements, the cursor attempts to honor this stored
x position while clamping to the line length. The stored x position
is updated when another horizontal movement is made.

If this is confusing, open a text editor (I used Vim as a reference for
the observed behavior), move the cursor to the end of the line, then
navigate up/down. If the moved-to line is longer than the moved-from
one, the cursor will be at the same x position. If it's shorter, it
will be clamped to the moved-to line's length. This will apply no matter
how many times you move up/down. Moving horizontally will reset the
"stored" position.

Added basic horizontal cursor display and movement.

- h/l for left/right
- 0/$ for beginning/end of line

Added a cursor_y position and assocated behavior.

- The editor now tracks cursor (y only) movement
- The viewport scrolls 1:1 if the cursor goes outside
the current view
- Added keybinds for cursor up/down (j/k/uparrow/downarrow),
viewport up/down (shift+), and fastscrollup/down (ctrl+).

Next steps will be cursor_x movement across the columns,
and 'insert' mode.

Added a scrollbar

Added Y/N shortcuts to YesNoModals

Filling in editor components.

1. Added modal for app quitting,
2. Added editor with file load and simple scroll,

I'm still messing with event handling and call/returns. It's
not clear yet how I'll let child views control which views
are visible. Bunch of stuff to read/figure out.

Added basic app elements.

UI development paradigms are generally foreign to me, so
I'll be doing some exploration while implementing basic features.

Right now there's a status bar and module picker. Next is the basic
editor and module creation.

Added project scaffolding.

I need root directory for the editor to hook into. It's
primitive at the moment, the only requirements being:

1. There must exist a file, chasm.toml, at the specified dir,
2. There must be a src/ directory within the specified dir.

It's just enough to signal "project dir" without defining much
about it (yet).

Added ratatui and crossterm scaffolding for editor.

The goal here is to experiment with a TUI-based editor
for chasm assembly projects.

Started assembly editor project

Applied uniform border to code

Updated single line styling.

Small changes to formatting.

Updated some verbiage in Project 5.

Added Project 5 - Linker and module system.

Added doc comments explaining rationale

First cut at an object file.

The file format is more-or-less ad-hoc. I wanted something that was
going to be human-readable while not being fully textual. I ended up
with the following:

1. A binary prelude containing some magic bytes, the version number,
   and the length of the header,
2. A human readable header containing the struct fields of
   AssemblyModule,
3. The module's code as binary.

I'm fine-ish with it as first pass, but may just end up with a fully
binary format and some kind of chasm 'objdump' program to read it. We'll
see.

Added public labels.

The syntax is '@pub label'.

Cleaned up a couple error messages, removed import

Removed redundant tokenization for single-symbol tokens.

Added application support for multiple files.

- Previously 'chasm assemble' took a single file, it now takes a list
- 'chasm assemble' now automatically invokes the linker on the given
  files.
- Added '--no-link` flag to opt out of linking. When provided,
  'assemble' will write the modules to their respective binary files as
  before.

Fixed bug where definition references were always 32-bit.

Renamed patch_size to ref_size.

Added support for branch patches across modules.

- All labels are considered public.
I'll take the next few rounds of commits to do some cleanup, but
immediately afterwards I'll delineate between public and private labels.

First cut at imports and cross-module references.

- Updated definition references ($thing) to require a width.
Deciding on syntax for this was difficult and the current solution is
unsatisfying, I have a mental note to revisit it: $32:thing.

- Added support for definition references across modules:
  $32:modname::thing

- Added support for label references across modules: &module::label.
Label references are more palatable because the width is always the
size of a pointer (currently 32-bit since we're targeting Cortex M
first).

There's pieces laying around the shop, but all the plumbing and
implementation is present. Some of the proverbial mess needs attention,
and I also need to add the final support for applying branch patches.

Discovered variable-width sizing in emitted assembly, fixing.

- This commit addresses the declaration side, although perhaps not
  strictly needed.
- Next commit will fix the use/caller side, where the assembler
  must know the length of the imported reference.

Added linker patch for thumb addr pseudo op

Added linker patch support for branch instructions.

While implementing this, I realized that current branching
only supports local references, and thus no linker patching
is needed.

As soon as I add reference support across modules, this will change.

Implemented linker patching for plain label offsets.

Updates to support linker work.

- Differentiate between linker patches and assembler patches,
- All address references used during assembly will generate a linker
  patch,
  - This needs some work around automation, adding is manual, tedious
    and error-prone,
- Added linker tests for basic main/lib module behavior.

Next commit with actually apply linker patches when linking.

Updated import references to fail codegen if the module wasn't imported.

Started defining linker semantics and constraints.

1. Initial support is for executables only.
2. All modules must be included at link-time.
3. One and only one module must be designated "main".
4. The main module is the root. Modules provided to the linker
that aren't directly or indirectly imported into main are ignored.

None of this is meant to mirror conventional C-toolchain linkers
(although some parts may, and some parts may be wildly different).

Added linker project boilerplate.

Added assembler support for module references.

Next step is linking and resolving references across modules.

Intermediate commit

Linker prep: added  pseudo instruction for exported definitions

Added basic import statement

Added Project 4 - function calls

Updated emulator scripts to use cgdb

Added mov! pseudo instruction.

The syntax is `mov!(reg, hex_literal)`, where hex_literal is a
32, 16, or 8-bit hex literal. The different bit widths result
in different instructions being generated:

u32 => movw(lower16), movt(upper16),
u16 => movw,
u8  => movs

Added define pseudo instruction.

- Syntax is `define!(identifier, hex literal)`
- After definition, `$identifier` evaluates to the hex literal
- The definition itself doesn't appear during code generation

Added some unit tests for pop error paths

Added POP {regs...} - T1 encoding

Added PUSH {regs*} - T1 encoding.

Fixed clarification on project 2 references.

Removed debug prints from BL codegen.

Added basic qemu setup for toolchain-centric changes.

Added BL instruction after some...difficulties.

Added LLM dislaimer (no programmatic usage).

Added Project 4 - button press LED toggle.

Added BX instruction.

Added EORS reg reg.

Consolidated some token fetching logic.

Added pad-with-to! pseudo instruction.

The only supported form is `pad-with-to!(<byte: u8>, <target: u32>)`, which fills
the output with <byte> from the current address up to, but not including
<target>.

An soon-to-be-implemented extension will support <target> as a label
reference.

Added support for pseudo-instructions.

These take the format instruction!(operand). The intent is
to provide support for common operations that don't neccessarily
correspond to a specific assembler mnemonic, or wouldn't be
found in the ARM technical reference.

The first supported pseudo is `thumb-addr!(&ref)`, which expects a
label reference and relaces it with <label-address> | 1.

An obvious objection to this pseudo is that it's too specific. A more
general pseudo like `math!(&ref | 1)` would be applicable to a variety
of usecases. I agree, but a) I wanted something I could use immediately,
and b) I didn't want to get tangled up in a more general-purpose
implementation when it wasn't strictly neccessary.

It's possible that thumb-addr! gets removed in lieu of something more
general, but this is fine for now.

Added support for branching forward.

Adding support involved generating code for forward references with 'dummy'
values, and then making a second pass over all unresolved references
to patch the generated binary.

The implication of doing so is that we can now support if/else logic.

Added '.' to README.

Added support for standalone label refs '&label'.

Added support for label references.

- Branch-related syntax went from 'B @label' to 'B &label'.
- The actual benefit is that we can use &label elsewhere to
refer to arbitrary addresses.

Made LDR and STR use [R*] syntax.

Bunch of small styling changes.

Added project 2 - red LED.

Added BEQ (t1 encoding)

Added AND(register)

Added encoding and instruction:

LDR(immediate) - t3 encoding,
ORRS(register) - t1 encoding,
STR(immediate) - t1 encoding.

Added LDR(immediate) - t1 encoding

Added MOVT

Added movw - first 32bit instruction

Added Project 1 - chasm conversion.

Added chasm project README.

Added metal-arm/0 as a test.

Added support for comments, via ';'

Added support for 'B @label' (backwards only)

Added labels, like @label

Added ADDS Rdn, #imm8

Support for MOVS Rd, #imm8 (hex)

Added tokenize, parse, and codegen for 8-32bit hex literals.

Added assembler scaffolding

Changed comment char in Project 0 program.

Changed comment char to ';'.

Added project 0 - machine code and flash.

Added project README.

Added CLI help

Added a few CLI args.

- --reverse (-r): bin -> text instead of text -> bin
- --row-len (-l): specify number of bytes per row (line break after n hex bytes)
- --spaced (-s): spaces between hex bytesspaced: bool,
- --offsets (-o): Print hex byte offsets in left column.

Added tests for existing functionality.

Added basic text -> binary support, including,

- All whitespace is stripped from the text input,
- Comments (preceding #) are stripped,
- Output to file or stdout.

Added hx project.

Initial commit

Initial commit

Updated markdown parsing to include inline HTML.

Paid the long-coming clippy tax.

Made --to-html a global arg.

Fixed git issues.

- We were including submodules in attempted diffs.
- We weren't pulling files from the working directory and repo
  correctly. Sometimes we would do a repo read when we really needed the
  working directory, and vice-versa.

Fixed spacing issue where multiple diffs weren't separated by newline.

Added Rust dependency post.

Fixed issue where extra padding was applied to add/remove items.

Version bump.

Bugfix: filenames were printed even if there wasn't a diff.

Updated tag.

Added tuple/field diffs.

Added unit/field diffs.

Added unit/tuple diffs.

Added HTLM output escapes.

Variants now elide information.

Updated TODO with completed and upcoming items

Started updating struct diff logic.

- This fixes the issue where order mattered when diffing structs
with named fields.
- Tuple structs and name structs are handled.
- Still need support for diffs like tuple -> named and vice versa.
- Also discovered an issue where enum variants with tuple/field
types aren't elided like other container types.

Updated TODO and some comments.

Added visual cue when eliding members.

Refactored to use shared signature parsing.

Elide whitespace in trait item diffs.

Elide whitespace from enum diffs in the same vein.

Updated impl_ and struct_ change construction.

* Impls now elide whitespace like structs.
* Fixed a bug with structs where completely new members
caused an infinite loop.

Fixed an issue with struct parsing.

* The shared parsing functions were referencing "new" structs only.

Refactored struct's View implementation to:
* Elide whitespace not pertaining to any struct diffs (eliminating diffs as long as the struct's definition),
* Share a bunch of code between old/new parsing.

Made changes to HTML formatting.

I'll slowly try to make the 'feel' of the UI familiar, or at least
not completey foreign, to folks familiar with the GitHub diff UI.
It's not there yet, but something actually useful is forming...

Added basic HTML output.

CSS grid is used for formatting, but honestly a table would
be easier to work with. GitHub apparently uses a table for
their diffs, so I'll likely take that as my cue/allowance
to do the same.

Adding plumbing for --to-html output option.

More styling updates.

Some styling updates, edited post.

Updated a bunch of random stuff, prepped for first post.

-

Moved nav bar next to header.

Deploying with (empty) posts support.

Updated and tested publish/deploy scripts.

Updated local deploy script.

Added new deployment layout and directory structure.

Updated templates dir

Testing posts build.

Got post index page working.

Added basic support for posts/ index.

Fixed home location when near Bristol.

My ISP comes out of Bristol, TN or Bristol, VA. I had a check
in place to correct Bristol, TN to my current home, but not
for VA (Bristol straddles the TN/VA border). I added the check.

Updated README.

Updated install instructions.

Updated wrongly-formatted license.

Updated .toml.

Updated README, adding publishing stuff.

Fixed issue where appendln was inserting newlines incorrectly.

Switched to relative path when displaying overview.

Added basic --fancy output (but removed the flag).

Starting --fancy diff output (somewhat akin to 'git diff'-style).

Fixed bug where add/remove impl diffs were displaying function bodies.

Fixed bug where impls weren't working on traits.

Updated struct diffs to omit fields that weren't changed.

Updated enum diffs to omit variants that weren't changed.

Removed useless design block.

Trying to get impl items to omit items that didn't have a diff.

For example, skip printing methods that don't have a signature change.
I'll apply this to struct members, enum variants, and traits, but
the algorithm needs more thought.

More finely-grained diff for enum variants, specifically around 'fields'.

Used function diffs in trait items.

Removed old column formatting.

Display-based output is managed by View now.

Added View to Use

Deleted impl Display on TraitDiff.

Converted trait diffs to View.

Converted enum diffs to View.

Converted structs to use View instead of Display.

Removed display from impls structs.

Implemented impl blocks.

- Need to remove { .. } on impl functions.

Removed display from Function[s]Diff

Finished function inputs and block omissions.

Giant commit for a a bunch of formatting changes.

- Added colored output on terminals.
- Starting with functions, output formatting is delegated to a separate
struct. The goal is to output a single type that can then be formatted
based on the chosen "backend." Text output is currently supported,
but HTML is planned for use in GitHub-like PRs.
- Need to finish function inputs.

Deleted Vis and just using syn::Visibility.

Updated TODO, starting ViewableDiff.

Use original source for impls.

Added original source for function and traits.

Use original source for enum diff.

Use original source for struct diff.

Added original source to each overview and diff.

This enables us to:
- use the author's original formatting when presenting the diff,
- selectively highlight the original source based on the diff.

Impl display implemented, need to fix:

- Impl displays full block, need to remove fn bodies,
- Formatting

Filled out impl diff (functions only).

Added boilerplate for impl diffs.

Added ~ on modified trait/struct/enum/fn

Filled in 'diff <c1> <c2>' capability.

- Commits can be diffed like 'dover diff <tree-ish> <tree-ish>'
- Intent is to emulate the general cases of 'git diff <...>'

Fixed side-by-side formatting

Existence changes (+/-) for top-level types like functions
and structs were being printed in the left column only,
instead of following the "left old, right new" columnar
format.

Added diff subcommand in place of just 'dover'.

eg: dover diff
I want to capitalize on the muscle memory for 'git diff'.

Formatting and git search changes.

- Formatting was appending a bunch of newlines to the final output, fixed.
- Enabled search through parent directories if a git repo wasn't found in
currentdir.

Removed redundant overview formatting when set was empty.

Added recent additions to overview print.

- Enums
- Traits
- Freestanding functionswq

Updated TODO.

Next is impl blocks.

Changed function formatting.

Removed function blocks from display since they're irrelevant.

Added freestanding function diffs.

Added function diff boilerplate.

Refactored OverviewDiff display.

- Display now doesn't show headers for diffs that aren't present.

Added support for diffing trait modifications.

- (prior support was just for existence)
- Updated todo.

Added coarse trait diff.

Added Trait scaffolding.

Updated TODO. Next tasks include:

* impl blocks for structs and enums,
* freestanding functions,
* trait signatures

Added category importance (UI) and default port (backend).

Added enum and variant diffing.

Sample output:
--------------------------------------------------------------------
enum L7Protocol<T: Clone> {                        enum L7Protocol {
    Http { t: T },                                     Https,
    Https,                                             Dns,
    STUN,                                              Smtp,
}                                                  }

variants:
- Http { t : T }                                   + Dns
- STUN                                             + Smtp

generic parameters:
- T : Clone
--------------------------------------------------------------------

Added scripts/ and test_files.

Added enum and variant scaffolding.

Some shared structs/functions were moved from structs.rs
into lib.rs (like struct Vis, get_source, etc.).

Added coarse fields diff.

Formatted commit messages with pre tag.

Added formatting goals from previous commit.

Given two files containing (side-by-side):
```
use cake::cheese;                                     use cake::cheese::eggs;
                                                      use rice;

pub struct Thing<T, U, V: Clone, W, X>(T, U, V)       struct Thing<T, U>(T, U)
where                                                 where
    X: Cake,                                            U: Cake,
    U: Powder,                                          T: Eggs;
    W: Rice,
    Y: Milk;
```

We can get a diff like:
```
Use
¯¯¯
- cake::cheese
+ cake::cheese::eggs
+ rice

Structs
¯¯¯¯¯¯¯
pub struct Thing<T, U, V: Clone, W, X>(            struct Thing<T, U>(
    T,                                                 T,
    U,                                                 U,
    V,                                             )
)                                                  where
where                                                  U: Cake,
    X: Cake,                                           T: Eggs;
    U: Powder,
    W: Rice,
    Y: Milk;

visibility:
- pub                                              + (none)

generic parameters:
- V : Clone
- W
- X

where clause:
- X : Cake                                         + U : Cake
- U : Powder                                       + T : Eggs
- W : Rice
- Y : Milk
```

TODO:
  - struct fields
  - Formatting will likely change to something capable of layouts
    (ratatui).

Working on struct visualization.

* Using `prettyplease` for formatting
* Need to decide what to use for side-by-side layout. Options:
  * ratatui, if I can use it without replacing the screen,
  * self written, if it doesn't get too painful.

Working on visualizing more complex diffs.

Sample struct output (WIP):

Structs
¯¯¯¯¯¯¯
    pub struct Thing<T, U, V: Clone>(T, U, V)            pub struct Thing<T, U, K: Milk + Eggs>(T, U, K)
    where
        X: Cake,
        U: Powder;

    Generics
    ¯¯¯¯¯¯¯¯
    - V: Clone                                           + K: Milk + Eggs
    - where
        - X: Cake,
        - U: Powder

    Fields
    ¯¯¯¯¯¯
    - V                                                  + K

Added coarse-grained where clause diffing.

'where' clauses are diffed by existence (for now), similar to generic
types.

Also like generics, the plan is to introduce per-type/lifetime diffs on
the constraints, but that's a future problem. The immediate goal is to
get an end-to-end diff of all main components (struct args, return
types, etc), before tackling more specific diff problems.

Added coarse-grained generic diffing.

Generic diffs currently only check existence. That is, if the
exact generic type isn't found in another struct's declaration,
it's counted as added or removed.

The next step is to include modifications to a type (like T: Debug +
Clone), and to be able to say "T was modified, added Clone constraint").

Filled out struct templates for Generics[Diff].

Added struct/field diffing.

Technically this only supports unit/tuple structs, but with the
struct variant refactor from a recent previous commit, 'standard'
structs are likely supported as well.

Next up are enums, traits, and impl blocks.

Added fields to Struct struct.

- Removed struct variants.
- diff/overview will be done on struct, vis, and a struct's fields.

Changed Vis formatting.

Added structs diff.

Formatting isn't perfect, but the model is correct enough.

Updated enum signature in git.rs.

Updated diff method and applied to Use statements.

* The diff return type for containers will be `Option<T>`.
* Diffs will be 'member' based, e.g
  * Use members are a single use statement (non-nested),
  * Struct members are (currently) vis and fields,
  * Field members are (name, type) pairs,
  * etc.

Refactored modules.

* Overview goes into its own module.
* Overview "members" (structs, use statements, etc.) go into submodules
  of overview.

Added TODO to repo.

This has been going since the start of the project, but it's worth
adding to the repo in case I need a timeline of added/completed.

Added non-diff overview for a list of .rs files.

Included early use of git.

- Running 'dover' in a repo root will diff unstaged changes against
  HEAD.
- Running 'dover files <file1> <file2> will diff two files on the
  filesystem.

Added diff behavior between two files.

Sample output:
src/lib.rs
¯¯¯¯¯¯¯¯¯¯
Imports:
  anyhow::Context
  anyhow::Result
  std::fmt::Display
  std::fs
  std::ops::Deref
  std::path::Path
  std::path::PathBuf
  syn::File
  syn::Item
  syn::ItemFn
  syn::ItemUse
  syn::UseTree

test_files/lib_copy.rs
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
Imports:
  anyhow::Context
  anyhow::Result
  std::collections::HashSet
  std::fmt::Display
  std::fs
  syn::File
  syn::Item
  syn::ItemFn
  syn::ItemUse
  syn::UseTree

src/lib.rs -> test_files/lib_copy.rs
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
Imports:
  + std::collections::HashSet
  - std::ops::Deref
  - std::path::Path
  - std::path::PathBuf

Added support for use statements.

Uses are flattened, de-aliased, de-duplicated, and collected into
a HashSet.

First commit of "diff overview" AKA dover.

Initial commit

Updated job description

This seems like something that will be tweaked forever...

Fixed full-width link issue.

Updated spacing and removed border.

Fixed spacing on mobile.

Updated some verbiage in the job description.

Updated dev watch script.

Expanded the site, included a little work history.

Updated to include last location.

Updated TODO and categorized certain 'milestone' goals for the project.

The purpose has always been to make programming 'better' by shortening the feedback loop when
reading and writing code. The intended features operate at at least two 'meta-layers' of programming work:
* The function level, like when you're reading/writing a function.
* The module/architectural level, like how different modules compose to form the entire application.
The core features are:

* Interactive Trace View
(function-level)
- Is implemented in VSCode Cottage extension (with some TODOs for polish)
- Like printf debugging, but the timeline is 2d and interactive.
- Interaction involves the user hovering over values. The view responds by
showing the values for associated cells.
- This can be thought of as a replay editor in which all the steps are available immediately.

* Execution Graph
(module-level, but some function-level as well)
- Is not implemented
- Will show a graph-like view (a la Sprotty and ElkJS) of data paths
- Zoomable to different layers of the application (mitigates the massive picture of
'boxes and arrows' of certain prior attempts from other projects)
- Collapsable to show only a single piece of data/function.

* Inline Forever
(function-level)
- Is not implemented
- Inline function calls to a certain depth to show a more complete view of code

* Call Trace
(module and function-level)
- Is not implemented
- Simple execution trace showing what actually happened (like bash's 'set -x' or lisp's (trace) macro).

Removed yet more debug logs in extension.

Made select styling in code comparable to trace view.
* Code used border outline, trace used bg color.
* Code now uses the same bg color.
This more or less unifies styling between trace and code views.

Fixed issue where decorations wouldn't display on extension load.

Fixed issue where a document's activeTextEditor wasn't being null-checked.

Updated hover support.
* Hover in code sends events to webview, and webview sets styles accordingly.
* Longstanding exception when opening webview depending on if a cottage file is open or not, needs fixed.
* Updated TODO.

Removed many debug logs from extension.

Hover now responds to cursor movement.
* TODO: Pass hover to webview
* TODO: Remove onhover in webview and receive message from client
* TODO: Remove debug logs.

Added boilerplate for tracking cursor movements.
* Goal is the repurpose 'hover' in trace view to reflect cursor movements in editor, instead of responding to hover in trace view.

Removed UTC time from commit date.

Updated TODO and cottage test script.

Fixed styling.
* Graph wasn't scaling correctly with the updated commit size (too much
  history).

Fixed styling, it'll probably need more work but it's not ultra-small anymore.

Added --save-commits option to save fetched commits (useful for debug/UI experiments)

Functionality and template updates.
* Commits are now bucketed by week to give a more stable feel.
* Changed the number of max tracked commits from 100 to 500.
* Adjusted the activity graph to account for the increased number of commits.
* Added a brief info specifying the number of displayed commits (I may yet make this <details>).

Trace view updates:
* Fixed missing early return when we can't find the expression id,
* Made tdElements global for reference in document.keydown handler,
* Reset [last]selectedRow/Col on incoming updates,
* Fixed issue where document.keydown was being processed multiple times due to multiple event listeners being registered.

Cleared cache on updated decorations.

Trace view selections now cause the code in question to be highlighted in the editor pane.

Cottage trace view sends hover requests back to the extension.

Added lint to ignore possibly-missing global function (acquireVsCodeApi).

With the new recurrence plumbing, 'duplicate' functionality was easy to add, so I did.

Added recurrence functionality.
* Utilizes the pre-existing 'select ledger row',
* Present a modal to configure the recurrence for each row,
* Save or cancels recurrence,
* Adds new entries per configuration (only monthly recurrence is supported currently).

Added callbacks for frequency selection. Upcoming:
* Remove all custom classes and swap in tailwind,
* Store map of selection changes,
* Handle selection changes on 'confirm'

Setup open/close callbacks on recurrence modal.

Fixed an issue where the last selected cell wasn't being rehighlighted if it was previously hovered or hover-related.

Added interface for RecurringEntry, updated callback signature.

Started plumbing for 'recurring selections'.
* Added RecurrenceDisplay widget,
* Added new method to Grid - selected(), returns selected entries,

Updated TODO to account for trace updates.

Added hjkl movement to selection in trace view.

Styling changes to trace UI:
* Made highlight and select colors less intrusive,
* Made borders and test 'not black',
* Bumped font weight one level on keys and evaluated cells,
* Shrunk padding on header

Removed hover highlight when the current element is already selected.

Fixed styling behavior on selection.
* Selected cell is outlined and highlighted.
* Cells related to the selection are outlined.
* Hovered cell is orange.
* Cells related to the hover and highlighted.

This allows you to view the trace related to a selection and the trace related
to a hover separately.

Made expressions selectable in trace view.

Styling still needs some work (for example, some borders are overwritten)

Updated trace view with debug data for 'long range' feature and fixed metadata reference bug.

Added trace view in static/ for non-vscode development.

Updated 'metadata' Td field from boolean -> interface

Updated TODO with trace view 'polishing' tasks.

Added test code for UI 'long ranges' design issue.

In any program with loops, an expression may be evaluated multiple times. This is reflected
in the trace view by multiple columns, e.g. if an expression is evaluated twice, the trace
has 2 columns, 10 for 10 evaluations, etc. etc.

This becomes unweildy once the number of columns scrolls horizontally off the screen, because you can
no longer see the full state of execution for a given trace in a single view. It's a UI problem and needs
some design work to solve.

Updated TODO to account for:
* Trace MVP finished,
* Graph view on the horizon

Added webview -> extension messages.

When the active editor in a given column switched from the webview to a different panel and back,
the webview lost the previous trace it was displaying, if any.

This commit allows the webview to request the last displayed trace from the extension, if any.

Added default message if trace wasn't loaded.

Trace view now updates on script changes.

Bugfix: only set editor decorations if the current editor language is cottage.

Added webiew support in vscode and ported trace view over (non-interactive still)

Fixed comment and updated formatting.

Hover works as expected for all related expressions in trace UI.

TODO: plug in to LSP update cycle

Begin styling trace view.
TODO: Add hover on data elements.
TODO: Store data elements for hover reference.

Testing table vs. grid, and added tailwind in js.

Added tailwind setup for UI trace view prototype.

Scrolling works with various edge cases, still need a scrollbar.

Started plumbing for scroll/overflow.

Hooked database up to UI.

Added contractors page and click-to-nav in nav bar.

Set border type on selection.

Added top-level nav bar w/ 'active screen' styling.

Implemented nav scheme from parent <-> child.

Restructing in the same direction as the previous commit.

* Debug event display was moved to AppUi
* Screen::draw() takes an area and buffer instead of a rect. This lets parents deterine the box children live in.
* Next step is adding navigation between screens, and whether it should be heirarchical or if children can send events back to the parent.

Restructured a bit.

* Introduced a screen heirarchy, where each 'screen' is a top level view responsible for layout and sending events to the right widgets.
* The AppUi is the top level struct holding all the screens, and is responsible for detecting screen switches and delegating events to the active screen.

Started filling in UI events.

* Exploring ways to link widget location with event location.
* First attempt uses (rect, id) scheme, but the plan is to either implement Widget
or create a type that returns a widget on demand. Not sure about tradeoffs yet.

Updated width for mobile overflow. CSS is great.

Updates to main and template:

* Only check for token if fetching
* Changed heading size to be less intrusive
* Removed width from activity graph, should fix scaling on mobile.
* Fixed wrap issue on mobile.

Fixed viewBox for mobile.

Made activity graph continuous from <most recent hundreth commit date> -> <today>

Updates to template, dev script and commit stats:
* Template shows a small graph of recent activity,
* dev script now includes changes in the src/ dir,
* Site builder populates recent activity as a series of points.

Going with ratatui for UI =).

Fixed repo fetch even when --no-fetch was specified.

Housekeeping and minor format change:

* Removed parent out/ directory since publish model changed.
* Add newline consideration in comment messages.
* Commented out nav until there's more to populate.

Updating template still.

Updated main template.

Template update.

Updated template, added dev support scripts.

Added debug commits and started working on the template.

Added read-from-file for testing/dry-runs/template work.

Added sketch.

Added basic templating w/ Tera.

Simplified the whole git subtree thing (by not using it =), and turned down some verbose logs in main.rs

Fixed publisher, installed crontab.

Updated gitignore.

Added deployment script, tailwind config, template, etc.