diff --git a/.entangled/filedb.json b/.entangled/filedb.json
deleted file mode 100644
index 78f29f8..0000000
--- a/.entangled/filedb.json
+++ /dev/null
@@ -1 +0,0 @@
-{"version": "2.0.0", "files": [], "source": [], "target": []}
\ No newline at end of file
diff --git a/.entangled/filedb.lock b/.entangled/filedb.lock
deleted file mode 100644
index e69de29..0000000
diff --git a/.github/workflows/python-package.yml b/.github/workflows/python-package.yml
index 1f525ab..9d7f3ca 100644
--- a/.github/workflows/python-package.yml
+++ b/.github/workflows/python-package.yml
@@ -15,7 +15,7 @@ jobs:
       fail-fast: false
       matrix:
         os: ["windows-latest", "ubuntu-latest", "macos-latest"]
-        python-version: ["3.12", "3.13"]
+        python-version: ["3.12", "3.13", "3.14"]
 
     runs-on: ${{matrix.os}}
 
diff --git a/.gitignore b/.gitignore
index 4bc0a05..3eede02 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,4 @@ __pycache__
 coverage.*
 dist
 site
+
diff --git a/Makefile b/Makefile
index 32bec2c..95486d3 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-.PHONY: test
+.PHONY: test man-pages
 
 test:
 	uv run coverage run --source=entangled -m pytest
@@ -8,3 +8,27 @@ test:
 
 docs:
 	uv run mkdocs build
+
+define test_template =
+.PHONY: test-$(1)
+
+test-$(1):
+	uv run pytest test/$(1) --cov=entangled/$(1)
+	uv run coverage xml
+endef
+
+modules = readers io iterators model interface config commands
+
+$(foreach mod,$(modules),$(eval $(call test_template,$(mod))))
+
+.PHONY: test-modules
+
+test-modules:
+	uv run pytest $(modules:%=test/%) --cov=entangled -x
+
+man-pages: man/entangled.1
+
+man/entangled.1: docs/man-pages/english.md
+	mkdir -p $(@D)
+	pandoc -s -t man $< -o $@
+
diff --git a/docs/api.md b/docs/api.md
index 997962e..95e64c3 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -7,35 +7,21 @@ This is internal API documentation. This may be of use if you want to use Entang
         heading_level: 3
 
 ## Document structure
-::: entangled.document
+::: entangled.interface
     options:
         heading_level: 3
 
 ## Readers
-::: entangled.markdown_reader
+::: entangled.readers
     options:
         heading_level: 3
 
-::: entangled.code_reader
+## I/O
+::: entangled.io
     options:
         heading_level: 3
 
-## FileDB
-::: entangled.filedb
+## Model
+::: entangled.model
     options:
         heading_level: 3
-
-## Transactions
-::: entangled.transaction
-    options:
-        heading_level: 3
-
-## Parsing
-::: entangled.parsing
-    options:
-        heading_level: 3
-
-## Properties
-::: entangled.properties
-    options:
-        heading_level: 3
\ No newline at end of file
diff --git a/docs/architecture.md b/docs/architecture.md
index f915d17..4d57ed2 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -1,14 +1,163 @@
-# Architecture
+Entangled Architecture
+======================
 
-## Line processor
-All parsing in Entangled is done on a per-line basis using a primitive line processor `mawk`. This makes Entangled both simple in design and easy to configure.
+Entangled is organised into several sub-modules with clearly defined responsibilities:
 
-## Transactions
-Whenever we write a file, this is done through the `Transaction` class.
+- `commands`, all sub-commands for the command line.
+- `config`, all data types related to configuring Entangled.
+- `hooks`, the hook subsystem.
+- `interface`, interfaces the model and io with commands.
+- `io`, manages file I/O.
+- `iterators`, support functions for iterators.
+- `model`, the data model for Entangled, also contains the tangler.
+- `readers`, reading data into the model.
+
+Imports in Python need to be acyclical, as follows:
+
+``` mermaid
+graph TD;
+    iterators --> model;
+    config --> hooks;
+    config --> interface;
+    config --> model;
+    config --> readers;
+    hooks --> readers;
+    iterators --> readers;
+    model --> readers;
+    readers --> interface;
+    io --> interface;
+    hooks --> interface;
+    interface --> commands;
+```
+
+Commands
+--------
+
+We use `click` to make the command line interface, and `rich` and `rich-click` to make it pretty. Every command is encapsulated in a transaction:
 
 ```python
 with transaction() as t:
+    ...
+```
+
+This transaction is the front-end for all I/O based operations. Communication with the user is all handled through the `logging` system.
+
+Note: in the past we used `argh` to parse arguments, but this package doesn't have the same level of support from the community.
+
+Config
+------
+
+Config is read from `entangled.toml` using the `msgspec` package. The config is separated into an in-memory representation `Config`, and a loadable structure `ConfigUpdate`. We load an update from `entangled.toml` or from a YAML header at the top of a Markdown file. This `ConfigUpdate` is merged with an existing `Config` using the `|` operator. This way we can stack different layers of configuration on top of each other. We can even have different Markdown dialects between files working together.
+
+Hooks
+-----
+
+A hook is a class derived from `HookBase`, where you can override the following. A nested `Config` class that can be loaded by `msgspec`:
+
+```python
+class Config(msgspec.Struct):
+    pass
+```
+
+An `__init__` method:
+
+```python
+def __init__(self, config: Config):
+    super().__init__(config)
+```
+
+The `check_prerequisites` method checks that prerequisites are met. For instance, the build hook can use this to see that GNU Make is available.
+
+```python
+def check_prerequisites(self):
+    pass
+```
+
+The `on_read` method is called right after a code block is being read. Example: `quarto_attributes` uses this method to translate the YAML mini header into code block attributes.
+
+```python
+def on_read(self, code: CodeBlock):
+    pass
+```
+
+The `pre_tangle` method is run after all the Markdown is read, but before any output is written. Here you can define any additional output targets or modify the reference map in place.
+
+```python
+def pre_tangle(self, refs: ReferenceMap):
+    pass
+```
+
+The `on_tangle` method lets you add actions to the I/O transaction.
+
+```python
+def on_tangle(self, t: Transaction, refs: ReferenceMap):
+    pass
+```
+
+Lastly, `post_tangle` lets you do clean-up after tangle is complete. I've never used this.
+
+```python
+def post_tangle(self, refs: ReferenceMap):
+    pass
+```
+
+Hooks can be used to implement many things that feel to the user like features.
+
+I/O
+---
+
+Offers a virtualization layer on top of all file IO. All IO in Entangled is organized into transactions. When conflicts are found that could endanger your data integrity, Entangled will fail to run the entire transaction. For instance, if you have a markdown file called `model.md` which generates a file called `model.py`, and you have edits in both of them, either `entangled tangle` or `entangled stitch` will see that and refuse to overwrite changes, unless you run with `-f/--force`.
+
+A file database is kept containing MD5 hashes of all input files, to check that content hasn't changed without Entangled knowing about it. All input (and their hashes) are cached in `entangled.virtual.FileCache`.
+
+On the top level, all I/O is encapsulated in transactions:
+
+```python
+with transaction() as t:
+    t.read(...)
     t.write(...)
+    ...
 ```
 
-At the end of a transaction all write actions are checked against a database of known file contents. If any conflicts are found, the entire transaction is not executed (unless run with `-f/--force`).
\ No newline at end of file
+Iterators
+---------
+
+Internally, Entangled makes heavy use of generators to read files and process text line-by-line. Because both the `model` and `readers` modules use these operations, they need to be in a separate module. Crucially, this module contains the `Peekable` iterator, which allows us to peek into the future of an iterator by caching a single element.
+
+Model
+-----
+
+The `model`  contains some of the core functionality of Entangled. It defines the in-memory representation of a Markdown document, as well as the graph representing the code blocks and their references.
+
+- `ReferenceName` contains a `namespace: tuple[str, ...]` and `name: str`, representing a named code entity that may consist of multiple linked code blocks by the same name.
+- `ReferenceId` is a unique identifier for every code block. This stores the reference `name`, but also its Markdown source `file` and a `ref_count` for when there are multiple code blocks of the same name.
+- `Content` is either `PlainText` which is ignored by Entangled unless stitching, or a `ReferenceId`.
+- `CodeBlock` contains all information on a code block including enclosing lines (i.e. the lines containing the three back-tics), its attributes, indentation and the origin of the content.
+- `ReferenceMap` fundamentally acts as a `Mapping[ReferenceId, CodeBlock]`, but also contains an index for searching by `ReferenceName` or target file.
+- `Document` collects configuration, a dictionary of content and the reference map for ease of use.
+
+Readers
+-------
+
+Readers are implemented as `Callable[[InputStream], Generator[RawContent, None, T]]`. Here, `RawContent` is a form of `Content` where we're still dealing with `CodeBlock`s directly instead of `ReferenceId`. The third type-argument to `Generator` is kept abstract here. We can use it to pass values from one generator to the other. For instance (a simplified version):
+
+```python
+def read_yaml_header(inp: InputStream) -> Generator[RawContent, None, ConfigUpdate]:
+    ...
+    yield plain_text
+    return config_update
+
+def read_markdown(inp: InputStream, refs: ReferenceMap) -> Generator[RawContent, None, Config]:
+    config_update = yield from read_yaml_header(inp)
+    config = Config() | config_update
+    yield from rest_of_markdown(config, inp, refs)
+    return config
+```
+
+Here we have a `read_yaml_header` reader that emits `PlainText`, but also parses the YAML header into a `ConfigUpdate`. We subsequently use that configuration to determine how to further read the rest of the Markdown file. This way we can completely process a Markdown file in a single pass, buffering only a single line at a time.
+
+Test Coverage
+=============
+
+Unit tests for each module should cover most of that module. The `Makefile` contains test targets for every module that measure only the coverage on that module.
+
diff --git a/docs/man-pages/english.md b/docs/man-pages/english.md
new file mode 100644
index 0000000..da10e46
--- /dev/null
+++ b/docs/man-pages/english.md
@@ -0,0 +1,496 @@
+% entangled(1) version 2.4 | User Commands
+
+NAME
+====
+
+Entangled - Your literate programming toolkit.
+
+SYNOPSIS
+========
+
+`entangled [options] [command] [arguments]...`
+
+DESCRIPTION
+===========
+
+Entangled helps you write Literate Programs in Markdown. You put all your code inside Markdown code blocks. Entangled automatically extracts the code and writes it to more traditional source files. You can then edit these generated files, and the changes are being fed back to the Markdown.
+
+OPTIONS
+=======
+
+`--help`
+
+: Show the help message and exit.
+
+`-v, --version`
+
+: Show version and exit.
+
+`-d, --debug`
+
+: Print debug messages.
+
+COMMANDS
+========
+
+Each command has its own arguments and flags that can be inspected using `entangled <command> --help`.
+
+`brei <target>`
+
+: Build a Brei workflow target. See section [BREI](#BREI)
+
+`new <template> <project-path>`
+
+: Create a new entangled project from a template in the given project path.
+
+`reset`
+
+: Reset the file database. 
+
+`status`
+
+: Print a status overview.
+
+`stitch`
+
+: Stitch code changes back into the documentation.
+
+`sync`
+
+: Automatically detects ifBe smart wether to tangle or stich
+
+`tangle`
+
+: Tangle codes from the documentation.
+
+`watch`
+
+: Keep a loop running, watching for changes in the file system.
+
+WRITING PROGRAMS
+================
+
+Entangled enables a **documentation first** approach to programming. To write programs using Entangled, you start by writing documentation and in Markdown and then add code blocks. The code blocks can be marked with attributes to indicate where code should be written.
+
+HELLO WORLD
+-----------
+
+The combined code-blocks in this example compose a compilable source code for "Hello World". For didactic reasons we don't always give the listing of an entire source file in one go. In stead, we use a system of references known as *noweb* (after Ramsey 1994).
+
+Inside source fragments you may encounter a line with `<<...>>` marks like,
+
+~~~markdown
+``` {.cpp file=hello_world.cc}
+#include <cstdlib>
+#include <iostream>
+
+<<example-main-function>>
+```
+~~~
+
+which is then elsewhere specified. Order doesn't matter,
+
+~~~markdown
+``` {.cpp #hello-world}
+std::cout << "Hello, World!" << std::endl;
+```
+~~~
+
+So we can reference the `<<hello-world>>` code block later on.
+
+~~~markdown
+``` {.cpp #example-main-function}
+int main(int argc, char **argv)
+{
+    <<hello-world>>
+}
+```
+~~~
+
+A definition can be appended with more code as follows (in this case, order does matter!):
+
+~~~markdown
+``` {.cpp #hello-world}
+return EXIT_SUCCESS;
+```
+~~~
+
+These blocks of code can be **tangled** into source files.
+
+DEFAULT SYNTAX
+--------------
+
+The standard syntax is aimed to work well together with Pandoc. Every code block is delimited with three back ticks. Added to the opening line is a sequence of space separated **code properties**. These properties align with the CSS attributes that would end up in the generated HTML. For those unfamiliar with CSS:
+
+- `#identifier`; a name prefixed with a `#` (sharp), identifies the object, only one of these should be present per item
+- `.class`; a name prefixed with `.` (period), assigns the object to a class, a object can belong to any number of classes
+- `key=value`; a name suffixed with `=` (equals), optionally followed by a value, adds any meta-data attribute to the object
+
+The complete syntax of a code block then looks like:
+
+~~~markdown
+``` {[#<reference>|.<language>|<key>=<value>] ...}
+<code> ...
+```
+~~~
+
+The first class in the code properties is always interpreted to give the **programming language** of the code block. In Entangled, any code block is one of the following:
+    
+- A **referable** block: has exactly one **reference id** (`#<reference>`) and a class giving the language of the code block (`.<language>`). Example:
+
+  ~~~markdown
+  ``` {.rust #hello-rust}
+  println!("Hello, Rust!");
+  ```
+  ~~~
+ 
+  In some cases you may want to have additional classes to trigger hooks or a specific filter. Always the first class is interpreted to identify the language.
+- A **file** block: has a key-value pair giving the path to the file (`file=<path>`), absolute or relative to the directory in which `entangled` runs. Again, there should be one class giving the language of the block (`.<language>`). Example:
+
+  ~~~markdown
+  ``` {.rust file=src/main.rs}
+  fn main() {
+     <<hello-rust>>
+  }
+  ```
+  ~~~
+
+  The identifier in a file block is optional. If it is left out, the identifier will silently be taken to be the file name.
+- An **ignored** block: anything not matching the previous two.
+
+TANGLED CODE
+------------
+
+Entangled recognizes three parameters for every code block. These parameters are extracted from an opening line may be [configured using regular expressions](#MARKERS). Formally, every code block has three properties:
+
+- `Language`
+- `Identifier`
+- `Optional Filename`
+
+Entangled should tangle your code following these rules:
+
+1. If an **identifier** is repeated the contents of the code blocks is concatenated in the order that they appear in the Markdown. If an identifier appears in multiple files, the order is dependent on the order by which the files appear in the configuration, or if they result from a glob-pattern expansion, alphabetical order.
+
+3. **Noweb references** are **expanded**. A noweb reference in Entangled should occupy a single line of code by itself, and is enclosed with double angle brackets, and maybe indented with white space. Space at the end of the line is ignored.
+
+   ~~~txt
+   +--- indentation ---+--- reference  ---+--- possible space ---+
+                       <<noweb-reference>>
+   ~~~
+
+   The reference is expanded recursively, after which the indentation is prefixed to every line in the expanded reference content.
+
+4. **Annotation**; Expanded and concatenated code blocks are annotated using comment lines. These lines should not be touched when editing the generated files. The default method of annotation follows an opening comment with `~\~ begin <<filename#identifier>>[n]`, and a closing comment with `~\~ end`. For example
+
+   ~~~rust
+   // ~\~ begin <<lit/index.md|main>>[1]
+   println!("hello");
+   // ~\~ end
+   ~~~
+
+CONFIGURATION
+=============
+
+Global configuration is loaded from `entangled.toml` in the current working directory, or from the YAML header of the Markdown file, if there is only one input file. In the case of multiple input files, the YAML header is local to that input file.
+
+Configuration should match the following scheme:
+
+`version`
+
+: (`string`) the minimum version of Entangled.
+
+`style`
+
+: (`string`: `default` | `basic`) (default: `default`) a configuration preset. See STYLES.
+
+`languages`
+
+: (`list[Language]`) additional language settings.
+
+`markers`
+
+: (`Markers`) override marker expressions for extracting code blocks.
+
+`watch_list`
+
+: (`list[string]`) sets a list of glob patterns for files to read.
+
+`ignore_list`
+
+: (`list[string]`) sets a list of glob patterns to exclude from reading.
+
+`annotation`
+
+: (`string`: `standard` | `naked` | `supplemented`) sets the method for annotating tangled files.
+
+`annotation_format`
+
+: (`string`) set a format string for `supplemented` annotation (not yet implemented).
+
+`use_line_directives`
+
+: (`bool`) wether to include line directives to point compilers to the Markdown input source (not yet implemented).
+
+`namespace`
+
+: (`string`) set the namespace for the current input file. Namespaces are separated with double colons `::`.
+
+`namespace_default`
+
+: (`string`: `global` | `private`) if the namespace is absent, this controls the scope of code block identifiers.
+
+`hooks`
+
+: (`list[string]`) set the hooks used. Prepend a hook name with a tilde `~` to disable a hook locally.
+
+`hook`
+
+: (`object`) additional settings for enabled hooks.
+
+`brei`
+
+: (`Program`) create more Brei targets that are not listed in code blocks. The `Program` API is specified by the `brei` package.
+
+LANGUAGE
+--------
+
+We can configure how a language is treated by setting comment characters. For example:
+
+```toml
+[[languages]]
+name = "Java"
+identifiers = ["java"]
+comment = { open = "//" }
+
+# Some languages have comments that are not terminated by
+# newlines, like XML or CSS.
+[[languages]]
+name = "XML"
+identifiers = ["xml", "html", "svg"]
+comment = { open = "<!--", close = "-->" }
+```
+
+`name`
+
+: (`string`) a unique name for the language.
+
+`identifiers`
+
+: (`list[string]`) a set of identifiers that are admissable as language classes for a code block using this language.
+
+`comment`
+
+: (`object[open: string, close: string = ""]`) how to write comments in this language.
+
+MARKERS
+-------
+
+This configures how code blocks are detected.
+
+`open`
+
+: (`string`) opening regex for a code block. Python's regex engine supports named groups using `(?P<name>...)` syntax. This expression should contain an `indent` group and a `properties` group. The returned indentation should contain only spaces, and `properties` should at the minimum have the language identifier for the code block.
+
+`close`
+
+: (`string`) closing regex for a code block. This should contain a named pattern group `indent`.
+
+STYLES
+======
+
+There are two configuration styles available: `default` and `basic`.
+
+DEFAULT
+-------
+
+The default is to read code blocks with three back-tics and attributes grouped in curly braces. For example:
+
+~~~markdown
+This is a code block:
+
+``` {.c #print-hello}
+printf("Hello, World!");
+```
+~~~
+
+BASIC
+-----
+
+The basic style is less expressive but has better compatability with most standard Markdown syntaxes like Github.In this style only the language identifier is given after three back-tics. Other attributes are passed using the `quarto_attributes` hook. For example:
+
+~~~markdown
+This is a code block:
+
+```c
+//| id: print-hello
+printf("Hello, World!");
+```
+~~~
+
+HOOKS
+=====
+
+BREI
+----
+
+Entangled has an integrated build system called Brei, that can be used to produce figures or other artifacts. Targets and their dependencies can be specified in code blocks using the `brei` hook. These tasks may depend on one another. Brei will run these when dependencies are newer than the target. Execution is lazy and in parallel. Brei supports:
+
+- Running tasks by passing a script to any configured interpreter, e.g. Bash, Python, Lua etc.
+- Redirecting `stdout` or `stdin` to or from files.
+- Defining so called "phony" targets.
+- Define `template` for programmable reuse.
+- `include` other Brei files, even ones that need to be generated by another `task`.
+- Variable substitution, including writing `stdout` to variables.
+
+Brei is available as a separate package, see [the Brei documentation](https://entangled.github.io/brei).
+
+### Examples
+
+To write out "Hello, World!" to a file `msg.txt`, we may do the following,
+
+```toml
+[[task]]
+stdout = "secret.txt"
+language = "Python"
+script = """
+print("Uryyb, Jbeyq!")
+"""
+```
+
+To have this message decoded define a pattern,
+
+```toml
+[pattern.rot13]
+stdout = "{stdout}"
+stdin = "{stdin}"
+language = "Bash"
+script = """
+tr a-zA-Z n-za-mN-ZA-M
+"""
+
+[[call]]
+pattern = "rot13"
+  [call.args]
+  stdin = "secret.txt"
+  stdout = "msg.txt"
+```
+
+To define a phony target "all",
+
+```toml
+[[task]]
+name = "all"
+requires = ["msg.txt"]
+```
+
+### The Brei hook
+
+The following example uses both `brei` and `quatro_attributes` hooks. To add a Brei task, tag a code block with the `.task` class.
+
+~~~markdown
+First we generate some data.
+
+``` {.python #some-functions}
+# define some functions
+```
+
+Now we show what that data would look like:
+
+``` {.python .task}
+#| description: Generate data
+#| creates: data/data.npy
+
+<<some-functions>>
+
+# generate and save data
+```
+
+Then we plot in another task.
+
+``` {.python .task}
+#| description: Plot data
+#| creates: docs/fig/plot.svg
+#| requires: data/data.npy
+#| collect: figures
+
+# load data and plot
+```
+~~~
+
+The `collect` attribute tells the Brei hook to add the `docs/fig/plot.svg` target to the `figures` collection. All figures can then be rendered as follows, having in `entangled.toml`
+
+```toml
+version = "2.0"
+watch_list = ["docs/**/*.md"]
+hooks = ["quatro_attributes", "brei"]
+
+[brei]
+include = [".entangled/tasks.json"]
+```
+
+And run
+
+```bash
+entangled brei figures
+```
+
+You can use `${variable}` syntax inside Brei tasks just as you would in a stand-alone Brei script.
+
+QUARTO ATTRIBUTES
+-----------------
+
+Sometimes using the `build` hook (or the `brei` hook, see below), leads to long header lines. It is then better to specify attributes in a header section of your code. The Quarto project came up with a syntax, having the header be indicated by a comment with a vertical bar, e.g. `#|` or `//|` etc. The `quarto_attributes` hook reads those attributes and adds them to the properties of the code block.
+
+Example with the `brei` hook:
+
+~~~markdown
+``` {.python .task}
+#| description: Draw a triangle
+#| creates: docs/fig/triangle.svg
+#| collect: figures
+from matplotlib import pyplot as plt
+plt.plot([[-1, -0.5], [1, -0.5], [0, 1], [-1, -0.5]])
+plt.savefig("docs/fig/triangle.svg")
+```
+
+![](fig/triangle.svg)
+~~~
+
+Using these attributes it is possible to write in Entangled using completely standard Markdown syntax. 
+
+The `id` attribute is reserved for the code's identifier (normally indicated with `#`) and the `classes` attribute can be used to indicate a list of classes in addition to the language class already given.
+
+REPL (experimental)
+-------------------
+
+The `repl` hook enables running code blocks in REPL sessions. The hook extracts these code blocks into a separate JSON session file that can be evaluated using the `repl-session` tool [https://entangled.github.io/repl-session](https://entangled.github.io/repl-session). The output needs to be processed by the documentation rendering system. The `mkdocs-entangled-plugin` package handles `repl` sessions and integrates the output into the rendered HTML.
+
+SHEBANG
+-------
+
+If a code block starts with `#!...` on the first line. This line is brought to the top of the tangled file. Together with the use of a `mode` attribute, this enables coding executable scripts in Entangled. Example:
+
+~~~markdown
+A first Bash script:
+
+``` {.bash file=cowsay mode=0755}
+#!/bin/bash
+echo "Mooo!"
+```
+~~~
+
+SPDX_LICENSE
+------------
+
+If a code block starts with a line containing the string "SPDX-License-Identifier". That line is put above the first annotation comment, similar to the `shebang` hook.
+
+BUGS
+====
+
+Bugs can be reported at [github.com/entangled/entangled.py/issues](https://github.com/entangled/entangled.py/issues).
+
+AUTHORS
+=======
+
+Entangled was written by Johan Hidding, with contributions by Ole Mussmann, Reggie Cushing, Olga Lyashevska and several others.
+
diff --git a/entangled/code_reader.py b/entangled/code_reader.py
deleted file mode 100644
index 5da2116..0000000
--- a/entangled/code_reader.py
+++ /dev/null
@@ -1,81 +0,0 @@
-from dataclasses import dataclass, field
-from pathlib import PurePath
-
-import mawk
-import re
-
-from .text_location import TextLocation
-from .document import ReferenceId, ReferenceMap
-from .errors.user import IndentationError
-
-
-@dataclass
-class Frame:
-    ref: ReferenceId
-    indent: str
-    content: list[str] = field(default_factory=list)
-
-
-class CodeReader(mawk.RuleSet):
-    """Reads an annotated code file."""
-
-    def __init__(self, path: PurePath, refs: ReferenceMap):
-        self.location: TextLocation = TextLocation(path, 0)
-        self.stack: list[Frame] = [Frame(ReferenceId("#root#", PurePath("-"), -1), "")]
-        self.refs: ReferenceMap = refs
-
-    @property
-    def current(self) -> Frame:
-        return self.stack[-1]
-
-    @mawk.always
-    def increase_line_number(self, _):
-        self.location.line_number += 1
-
-    @mawk.on_match(
-        r"^(?P<indent>\s*).* ~/~ begin <<(?P<source>[^#<>]+)#(?P<ref_name>[^#<>]+)>>\[(?P<ref_count>init|\d+)\]"
-    )
-    def on_block_begin(self, m: re.Match[str]) -> list[str]:
-        ref_name = m["ref_name"]
-
-        # When there are lines above the first ref, say a shebang, swap
-        # them into the first block.
-        if len(self.stack) == 1 and len(self.stack[0].content) > 0:
-            content = self.stack[0].content
-            self.stack[0].content = []
-        else:
-            content = []
-
-        if m["ref_count"] == "init":
-            ref_count = 0
-            if not m["indent"].startswith(self.current.indent):
-                raise IndentationError(self.location)
-            indent = m["indent"].removeprefix(self.current.indent)
-            self.current.content.append(f"{indent}<<{ref_name}>>")
-        else:
-            ref_count = int(m["ref_count"])
-
-        self.stack.append(
-            Frame(
-                ReferenceId(m["ref_name"], PurePath(m["source"]), ref_count), m["indent"], content
-            )
-        )
-        return []
-
-    @mawk.on_match(r"^(?P<indent>\s*).* ~/~ end")
-    def on_block_end(self, m: re.Match[str]) -> list[str]:
-        if m["indent"] != self.current.indent:
-            raise IndentationError(self.location)
-        self.refs.get_codeblock(self.current.ref).source = "\n".join(self.current.content)
-        _ = self.stack.pop()
-        return []
-
-    @mawk.always
-    def otherwise(self, line: str) -> list[str]:
-        if line.strip() == "":
-            self.current.content.append("")
-            return []
-        if not line.startswith(self.current.indent):
-            raise IndentationError(self.location)
-        self.current.content.append(line.removeprefix(self.current.indent))
-        return []
diff --git a/entangled/commands/__init__.py b/entangled/commands/__init__.py
index c6f631c..74b391f 100644
--- a/entangled/commands/__init__.py
+++ b/entangled/commands/__init__.py
@@ -1,19 +1,13 @@
-from .new import new
-from .status import status
+from .main import main
 from .stitch import stitch
-from .sync import sync
 from .tangle import tangle
+from .new import new
 from .reset import reset
+from .sync import sync
 from .watch import watch
+from .status import status
 from .brei import brei
 
 __all__ = [
-    "new",
-    "brei",
-    "reset",
-    "status",
-    "stitch",
-    "sync",
-    "tangle",
-    "watch",
+    "main", "stitch", "tangle", "new", "reset", "sync", "watch", "status", "brei"
 ]
diff --git a/entangled/commands/brei.py b/entangled/commands/brei.py
index fcd8107..cda61bc 100644
--- a/entangled/commands/brei.py
+++ b/entangled/commands/brei.py
@@ -1,22 +1,25 @@
 from pathlib import Path
 from collections.abc import Awaitable
 from typing import Any
-import argh  # type: ignore
 import asyncio
 import textwrap
 
-from ..config import config
+from ..config import Config, read_config
 from brei import resolve_tasks, Phony
 from ..logging import logger
+from .main import main
+
+import click
 
 log = logger()
 
 
-async def main(target_strs: list[str], force_run: bool, throttle: int | None):
+async def brei_main(target_strs: list[str], force_run: bool, throttle: int | None):
     if not Path(".entangled").exists():
         Path(".entangled").mkdir()
 
-    db = await resolve_tasks(config.get.brei, Path(".entangled/brei_history"))
+    cfg = Config() | read_config()
+    db = await resolve_tasks(cfg.brei, Path(".entangled/brei_history"))
     if throttle:
         db.throttle = asyncio.Semaphore(throttle)
     db.force_run = force_run
@@ -33,10 +36,13 @@ async def main(target_strs: list[str], force_run: bool, throttle: int | None):
                 log.error(msg)
 
 
-@argh.arg("targets", nargs="+", help="name of target to run")
-@argh.arg("-B", "--force-run", help="rebuild all dependencies")
-@argh.arg("-j", "--throttle", help="limit number of concurrent jobs")
+@main.command()
+@click.argument("targets", nargs=-1)
+@click.option("-B", "--force-run", is_flag=True, help="rebuild all dependencies")
+@click.option("-j", "--throttle", is_flag=True, help="limit number of concurrent jobs")
 def brei(targets: list[str], *, force_run: bool = False, throttle: int | None = None):
-    """Build one of the configured targets."""
-    config.read()
-    asyncio.run(main(targets, force_run, throttle))
+    """Build one of the configured targets.
+
+    TARGETS     Names of the targets to run.
+    """
+    asyncio.run(brei_main(targets, force_run, throttle))
diff --git a/entangled/commands/main.py b/entangled/commands/main.py
new file mode 100644
index 0000000..2ad2660
--- /dev/null
+++ b/entangled/commands/main.py
@@ -0,0 +1,24 @@
+from ..logging import configure, logger
+from ..version import __version__
+
+import sys
+import rich_click as click
+
+
+@click.group(
+    invoke_without_command=True,
+    epilog="See https://entangled.github.io/ for more help and tutorials."
+)
+@click.rich_config({"commands_before_options": True, "theme": "nord-modern"})
+@click.option("-v", "--version", is_flag=True, help="Show version.")
+@click.option("-d", "--debug", is_flag=True, help="Enable debugging.")
+def main(version: bool = False, debug: bool = False):
+    """Your literate programming toolkit.
+    """
+    if version:
+        print(f"Entangled {__version__}")
+        sys.exit(0)
+
+    configure(debug)
+    logger().debug(f"Welcome to Entangled v{__version__}!")
+
diff --git a/entangled/commands/new.py b/entangled/commands/new.py
index 80e7e97..ab0c61f 100644
--- a/entangled/commands/new.py
+++ b/entangled/commands/new.py
@@ -1,13 +1,11 @@
-import argh  # type: ignore
-from argh.utils import get_subparsers
-import argparse
+import click
 
 from pathlib import Path
-from rich_argparse import RichHelpFormatter
 from rich.console import Console
 from rich.table import Table
 
 from ..errors.user import HelpfulUserError
+from .main import main
 
 description = """Create a new entangled project from a template.
 
@@ -42,61 +40,52 @@ def print_help() -> None:
     For this we first have to create a parser and attach this `new` function
     to it. Then we have a parser object that we can `print_help()` from.
     """
-    parser = argparse.ArgumentParser(formatter_class=RichHelpFormatter)
-    argh.add_commands(parser, [new], func_kwargs={"formatter_class": RichHelpFormatter})
-    get_subparsers(parser).choices["new"].print_help()
+    ctx = click.get_current_context()
+    click.echo(ctx.get_help())
+    ctx.exit()
 
 
-@argh.arg(
-    "-a",
-    "--answers-file",
+@main.command(
+    epilog="This command, and the options provided are a front-end for `copier`. " +
+           "See https://copier.readthedocs.io/en/stable/ for more information."
+)
+@click.option(
+    "-a", "--answers-file",
     help="Update using this path (relative to [project_path]) to find the answers file for `copier`",
 )
-@argh.arg(
-    "-d",
-    "--data",
+@click.option(
+    "-d", "--data",
     help='"VARIABLE1=VALUE1;VARIABLE1=VALUE2" Make VARIABLEs available as VALUEs when rendering the template; make sure to use quotation marks for multiple variables/values',
 )
-@argh.arg(
-    "-D",
-    "--defaults",
+@click.option(
+    "-D", "--defaults", is_flag=True,
     help="Use default answers to questions, which might be null if not specified; overwrites when combined with -d!",
 )
-@argh.arg(
-    "-p",
-    "--pretend",
+@click.option(
+    "-p", "--pretend", is_flag=True,
     help="Run but do not make any changes",
 )
-@argh.arg(
-    "-o",
-    "--overwrite",
+@click.option(
+    "-o", "--overwrite", is_flag=True,
     help="Overwrite files that already exist, without asking.",
 )
-@argh.arg(
-    "-l",
-    "--list-templates",
+@click.option(
+    "-l", "--list-templates", is_flag=True,
     help="List all official templates and exit",
 )
-@argh.arg(
-    "-t",
-    "--trust",
+@click.option(
+    "-t", "--trust", is_flag=True,
     help='Allow templates with unsafe features (Jinja extensions, migrations, tasks); "True" for officially supported templates',
 )
-@argh.arg(
-    "template",
-    # default=None,
-    nargs="?",
-    help="Template handle or URL; initialize a new project from this template",
+@click.argument(
+    "template"
 )
-@argh.arg(
-    "project-path",
-    # default=None,
-    nargs="?",
-    help="Initialize a new project at this path",
+@click.argument(
+    "project-path"
 )
 def new(
-    template: str | None,
-    project_path: Path | None, *,
+    template: str,
+    project_path: Path, *,
     answers_file: str | None = None,
     data: str = "",
     defaults: bool = False,
@@ -105,7 +94,12 @@ def new(
     list_templates: bool = False,
     trust: bool = False,
 ) -> None:
-    """Create a new entangled project from a template."""
+    """Create a new entangled project from a template.
+
+    TEMPLATE      Template handle or URL; initialize a new project from this template.
+
+    PROJECT_PATH  Initialize a new project at this path.
+    """
 
     from ..config.templates import templates as AVAILABLE_TEMPLATES
     from ..config.templates import Template
diff --git a/entangled/commands/reset.py b/entangled/commands/reset.py
index da262e5..fc9351b 100644
--- a/entangled/commands/reset.py
+++ b/entangled/commands/reset.py
@@ -7,56 +7,28 @@
 """
 
 from ..io import TransactionMode, transaction
-from ..config import config, get_input_files
-from ..hooks import  get_hooks
-from ..document import ReferenceMap
 from ..errors.user import UserError
+from ..interface import Document
+from .main import main
 
 import logging
-from pathlib import Path
 
 
+@main.command(short_help="Reset the file database.")
 def reset():
     """
-    Resets the database. This performs a tangle without actually writing
-    output to the files, but updating the database as if we were.
+    Resets the file database. This performs a tangle without actually
+    writing output to the files, but updating the database as if we were.
     """
-    config.read()
-
-    # these imports depend on config being read
-    from ..markdown_reader import read_markdown_file
-    from ..tangle import tangle_ref
-
-    input_file_list = get_input_files()
-
-    refs = ReferenceMap()
-    hooks = get_hooks()
-    logging.debug("tangling with hooks: %s", [h.__module__ for h in hooks])
-    mode = TransactionMode.RESETDB
-    annotation_method = config.get.annotation
-
+    
     try:
-        with transaction(mode) as t:
-            for path in input_file_list:
-                logging.debug("reading `%s`", path)
-                t.update(path)
-                _, _ = read_markdown_file(t, path, refs=refs, hooks=hooks)
-
-            for h in hooks:
-                h.pre_tangle(refs)
-
-            for tgt in refs.targets:
-                result, deps = tangle_ref(refs, tgt, annotation_method)
-                mask = next(iter(refs.by_name(tgt))).mode
-                t.write(Path(tgt), result, list(map(Path, deps)), mask)
-
-            for h in hooks:
-                h.on_tangle(t, refs)
+        doc = Document()
+        mode = TransactionMode.RESETDB
 
+        with transaction(mode) as t:
+            doc.load(t)
+            doc.tangle(t)
             t.clear_orphans()
 
-        for h in hooks:
-            h.post_tangle(refs)
-
     except UserError as e:
         logging.error(str(e))
diff --git a/entangled/commands/status.py b/entangled/commands/status.py
index b9a5f58..fcbe2c6 100644
--- a/entangled/commands/status.py
+++ b/entangled/commands/status.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 from collections.abc import Iterable
-from ..status import list_input_files, list_dependent_files
-from ..config import config
+from ..status import list_dependent_files
+from ..config import Config, read_config, get_input_files
 from pathlib import Path
 
 from rich.console import Console, Group
@@ -10,6 +10,8 @@
 from rich.panel import Panel
 from rich.tree import Tree
 
+from .main import main
+
 
 def tree_from_files(files: Iterable[Path]):
     tree = Tree(label=".")
@@ -28,23 +30,24 @@ def files_panel(file_list: Iterable[Path], title: str) -> Panel:
 
 
 def rich_status():
+    cfg = Config() | read_config()
     config_table = Table()
     config_table.add_column("name")
     config_table.add_column("value")
     config_table.add_row(
-        "Watch list", ", ".join(f"'{pat}'" for pat in config.get.watch_list)
+        "Watch list", ", ".join(f"'{pat}'" for pat in cfg.watch_list)
     )
     config_table.add_row(
-        "Ignore list", ", ".join(f"'{pat}'" for pat in config.get.ignore_list)
+        "Ignore list", ", ".join(f"'{pat}'" for pat in cfg.ignore_list)
     )
-    config_table.add_row("Hooks enabled", ", ".join(config.get.hooks))
+    config_table.add_row("Hooks enabled", ", ".join(cfg.hooks))
 
     console = Console(color_system="auto")
     group = Group(
         Panel(config_table, title="config", border_style="dark_cyan"),
         Columns(
             [
-                files_panel(list_input_files(), "input files"),
+                files_panel(get_input_files(cfg), "input files"),
                 files_panel(list_dependent_files(), "dependent files"),
             ]
         ),
@@ -53,6 +56,7 @@ def rich_status():
     console.print(group)
 
 
+@main.command()
 def status():
-    config.read()
+    """Print a status overview."""
     rich_status()
diff --git a/entangled/commands/stitch.py b/entangled/commands/stitch.py
index 112a85b..c304c38 100644
--- a/entangled/commands/stitch.py
+++ b/entangled/commands/stitch.py
@@ -1,41 +1,17 @@
-from itertools import chain
-from pathlib import Path
+import rich_click as click
 
-import logging
-import argh  # type: ignore
+from .main import main
 
-from ..config import config
-from ..document import ReferenceMap, Content, PlainText, ReferenceId
+from ..interface import Document
 from ..io import transaction, TransactionMode
 from ..errors.user import UserError
-from ..config import get_input_files
 
 
-def stitch_markdown(reference_map: ReferenceMap, content: list[Content]) -> str:
-    def get(item: Content):
-        match item:
-            case PlainText(s):
-                return s
-            case ReferenceId():
-                return reference_map.get_codeblock(item).indented_text
-
-    return "\n".join(get(i) for i in content) + "\n"
-
-
-@argh.arg("--force", help="force overwrite on conflict")
-@argh.arg("-s", "--show", help="only show, don't act")
+@main.command()
+@click.option("-f", "--force", is_flag=True, help="force overwrite on conflict")
+@click.option("-s", "--show", is_flag=True, help="only show, don't act")
 def stitch(*, force: bool = False, show: bool = False):
-    """Stitch code changes back into the Markdown"""
-    config.read()
-
-    # these imports depend on config being read
-    from ..markdown_reader import read_markdown_file
-    from ..code_reader import CodeReader
-    from ..hooks import get_hooks
-
-    input_file_list = get_input_files()
-    hooks = get_hooks()
-
+    """Stitch code changes back into the documentation."""
     if show:
         mode = TransactionMode.SHOW
     elif force:
@@ -43,22 +19,13 @@ def stitch(*, force: bool = False, show: bool = False):
     else:
         mode = TransactionMode.FAIL
 
-    refs = ReferenceMap()
-    content: dict[Path, list[Content]] = {}
     try:
-        with transaction(mode) as t:
-            for path in input_file_list:
-                logging.debug("reading `%s`", path)
-                _, c = read_markdown_file(t, path, refs=refs, hooks=hooks)
-                content[path] = c
+        doc = Document()
 
-            for path in t.db.managed_files:
-                logging.debug("reading `%s`", path)
-                t.update(path)
-                _ = CodeReader(path, refs).run(t.read(path))
-
-            for path in input_file_list:
-                t.write(path, stitch_markdown(refs, content[path]), [])
+        with transaction(mode) as t:
+            doc.load(t)
+            doc.load_all_code(t)
+            doc.stitch(t)
 
     except UserError as e:
-        logging.error(str(e))
+        e.handle()
diff --git a/entangled/commands/sync.py b/entangled/commands/sync.py
index df1a86d..3d72b34 100644
--- a/entangled/commands/sync.py
+++ b/entangled/commands/sync.py
@@ -1,51 +1,87 @@
-from typing import Optional, Callable
-from itertools import chain
-from pathlib import Path
+from enum import Enum
 
-import logging
+from ..io import filedb, FileCache, transaction
+from ..interface import Document
+from ..errors.user import UserError
+
+from .main import main
 
-from ..io import filedb, FileCache
-from ..config import config
-from .stitch import stitch, get_input_files
-from .tangle import tangle
+import logging
 
 
-def _stitch_then_tangle():
-    stitch()
-    tangle()
+class Action(Enum):
+    NOTHING = 0
+    TANGLE = 1
+    STITCH = 2
 
 
-def sync_action() -> Callable[[], None] | None:
-    input_file_list = get_input_files()
+def sync_action(doc: Document) -> Action:
+    input_file_list = doc.input_files()
     fs = FileCache()
 
     with filedb(readonly=True) as db:
         changed = set(db.changed_files(fs))
 
         if not all(f in db for f in input_file_list):
-            return tangle
+            return Action.TANGLE
 
         if not changed:
-            return None
+            return Action.NOTHING
 
         if changed.isdisjoint(db.managed_files):
-            logging.info("Tangling")
-            return tangle
+            return Action.TANGLE
 
         if changed.issubset(db.managed_files):
-            logging.info("Stitching")
-            return _stitch_then_tangle
+            return Action.STITCH
 
         logging.error("changed: %s", [str(p) for p in changed])
         logging.error(
             "Both markdown and code seem to have changed, don't know what to do now."
         )
-        return None
+        return Action.NOTHING
+
+
+def tangle(doc: Document):
+    with transaction() as t:
+        doc.load(t)
+        doc.tangle(t)
+        t.clear_orphans()
+        for h in doc.context.hooks:
+            h.post_tangle(doc.reference_map)
+
 
+def stitch(doc: Document):
+    with transaction() as t:
+        doc.load(t)
+        doc.load_all_code(t)
+        doc.stitch(t)
+    with transaction() as t:
+        doc.tangle(t)
+        for h in doc.context.hooks:
+            h.post_tangle(doc.reference_map)
+        
 
+def run_sync():
+    try:
+        doc = Document()
+        match sync_action(doc):
+            case Action.TANGLE:
+                logging.info("Tangling.")
+                tangle(doc)
+
+            case Action.STITCH:
+                logging.info("Stitching.")
+                stitch(doc)
+
+            case Action.NOTHING:
+                pass
+
+    except UserError as e:
+        e.handle()
+
+
+@main.command()
 def sync():
     """Be smart wether to tangle or stich"""
-    config.read()
-    action = sync_action()
-    if action is not None:
-        action()
+    run_sync()
+
diff --git a/entangled/commands/tangle.py b/entangled/commands/tangle.py
index cb0b5ac..0770230 100644
--- a/entangled/commands/tangle.py
+++ b/entangled/commands/tangle.py
@@ -1,74 +1,37 @@
-from pathlib import Path
+import rich_click as click
 
-import argh  # type: ignore
-import logging
+from .main import main
 
-from ..document import ReferenceMap
-from ..config import config, AnnotationMethod, get_input_files
+from ..config import AnnotationMethod
 from ..io import transaction, TransactionMode
-from ..hooks import get_hooks
 from ..errors.user import UserError
+from ..interface import Document
 
 
-@argh.arg(
-    "-a",
-    "--annotate",
-    choices=[m.name.lower() for m in AnnotationMethod],
-    help="annotation method",
-)
-@argh.arg("--force", help="force overwrite on conflict")
-@argh.arg("-s", "--show", help="only show, don't act")
-@argh.arg("-r", "--reset-db", help="resets database")
-def tangle(*, annotate: str | None = None, force: bool = False, show: bool = False, reset_db: bool = False):
-    """Tangle codes from Markdown"""
-    config.read()
-
-    # these imports depend on config being read
-    from ..markdown_reader import read_markdown_file
-    from ..tangle import tangle_ref
-
-    if annotate is None:
-        annotation_method = config.get.annotation
-    else:
-        annotation_method = AnnotationMethod[annotate.upper()]
-
-    input_file_list = get_input_files()
-
-    refs = ReferenceMap()
-    hooks = get_hooks()
-    logging.debug("tangling with hooks: %s", [h.__module__ for h in hooks])
-
+@main.command()
+@click.option("-a", "--annotate", type=click.Choice(AnnotationMethod, case_sensitive=False),
+              help="annotation method")
+@click.option("-f", "--force", is_flag=True, help="force overwriting existing files")
+@click.option("-s", "--show", is_flag=True, help="only show what would happen")
+def tangle(*, annotate: AnnotationMethod | None = None, force: bool = False, show: bool = False):
+    """Tangle codes from the documentation."""
     if show:
         mode = TransactionMode.SHOW
-    elif reset_db:
-        mode = TransactionMode.RESETDB
     elif force:
         mode = TransactionMode.FORCE
     else:
         mode = TransactionMode.FAIL
 
     try:
-        with transaction(mode) as t:
-            for path in input_file_list:
-                logging.debug("reading `%s`", path)
-                t.update(path)
-                _, _ = read_markdown_file(t, path, refs=refs, hooks=hooks)
-
-            for h in hooks:
-                h.pre_tangle(refs)
-
-            for tgt in refs.targets:
-                result, deps = tangle_ref(refs, tgt, annotation_method)
-                mask = next(iter(refs.by_name(tgt))).mode
-                t.write(Path(tgt), result, list(map(Path, deps)), mask)
-
-            for h in hooks:
-                h.on_tangle(t, refs)
+        doc = Document()
 
+        with transaction(mode) as t:
+            doc.load(t)
+            doc.tangle(t, annotate)
             t.clear_orphans()
 
-        for h in hooks:
-            h.post_tangle(refs)
+        for h in doc.context.hooks:
+            h.post_tangle(doc.reference_map)
 
     except UserError as e:
-        logging.error(str(e))
+        e.handle()
diff --git a/entangled/commands/watch.py b/entangled/commands/watch.py
index 8997d06..b73b5ee 100644
--- a/entangled/commands/watch.py
+++ b/entangled/commands/watch.py
@@ -4,10 +4,11 @@
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler, FileSystemEvent
 
-from .sync import sync
-from ..config import config
 from ..status import find_watch_dirs
 
+from .sync import run_sync
+from .main import main
+
 
 class EventHandler(FileSystemEventHandler):
     def __init__(self):
@@ -19,7 +20,6 @@ def update_watched(self):
     def on_any_event(self, event: FileSystemEvent):
         if event.event_type == "opened":
             return
-        config.read()
 
         if isinstance(event.src_path, bytes):
             path = Path(event.src_path.decode("utf-8"))
@@ -29,7 +29,7 @@ def on_any_event(self, event: FileSystemEvent):
         if path.absolute().is_relative_to(Path("./.entangled").absolute()):
             return
         if any(path.absolute().is_relative_to(p.absolute()) for p in self.watched):
-            sync()
+            run_sync()
             # os.sync()
         self.update_watched()
 
@@ -42,7 +42,7 @@ def _watch(_stop_event: Event | None = None, _start_event: Event | None = None):
     def stop() -> bool:
         return _stop_event is not None and _stop_event.is_set()
 
-    sync()
+    run_sync()
 
     event_handler = EventHandler()
     observer = Observer()
@@ -60,7 +60,7 @@ def stop() -> bool:
         observer.join()
 
 
+@main.command()
 def watch():
     """Keep a loop running, watching for changes."""
-    config.read()
     _watch()
diff --git a/entangled/config/__init__.py b/entangled/config/__init__.py
index 7cae419..fb8ec46 100644
--- a/entangled/config/__init__.py
+++ b/entangled/config/__init__.py
@@ -4,114 +4,30 @@
 
 from __future__ import annotations
 
-from functools import cached_property
-import threading
-from contextlib import contextmanager
-from copy import copy, deepcopy
-from enum import StrEnum
 from pathlib import Path
 from typing import Any
 from itertools import chain
 
 import msgspec
-from msgspec import Struct, field
 import tomllib
 
-from brei import Program
+from .annotation_method import AnnotationMethod
+from .markers import Markers
+from .config_data import Config
+from .config_update import ConfigUpdate
+from .namespace_default import NamespaceDefault
 
-from entangled import from_str
-from .language import Language, languages
-from .version import Version
 from ..logging import logger
+from ..version import __version__
+from ..errors.user import HelpfulUserError
 
 
 log = logger()
 
 
-class AnnotationMethod(StrEnum):
-    """Annotation methods.
-
-    - `STANDARD` is the default. Comments tell where a piece of code
-       came from in enough detail to reconstruct the markdown if some
-       of the code is changed.
-    - `NAKED` adds no comments to the tangled files. Stitching is not
-       possible with this setting.
-    - `SUPPLEMENTED` adds extra information to the comment lines.
-    """
-
-    STANDARD = "standard"
-    NAKED = "naked"
-    SUPPLEMENTED = "supplemented"
-
-
-class Markers(Struct):
-    """Markers can be used to configure the Markdown dialect. Currently not used."""
-
-    open: str
-    close: str
-    begin_ignore: str = r"^\s*\~\~\~markdown\s*$"
-    end_ignore: str = r"^\s*\~\~\~\s*$"
-
-
-markers = Markers(
-    r"^(?P<indent>\s*)```\s*{(?P<properties>[^{}]*)}\s*$", r"^(?P<indent>\s*)```\s*$"
-)
-
-
-class Config(Struct, dict=True):
-    """Main config class.
-
-    Attributes:
-        version: Version of Entangled for which this config was created.
-            Entangled should read all versions lower than its own.
-        languages: List of programming languages and their comment styles.
-        markers: Regexes for detecting open and close of code blocks.
-        watch_list: List of glob-expressions indicating files to include
-            for tangling.
-        annotation: Style of annotation.
-        annotation_format: Extra annotation.
-        use_line_directives: Wether to print pragmas in source code for
-            indicating markdown source locations.
-        hooks: List of enabled hooks.
-        hook: Sub-config of hooks.
-        loom: Sub-config of loom.
-
-    This class is made thread-local to make it possible to test in parallel."""
-
-    _version: str = field(name = "version")
-    languages: list[Language] = field(default_factory=list)
-    markers: Markers = field(default_factory=lambda: copy(markers))
-    watch_list: list[str] = field(default_factory=lambda: ["**/*.md"])
-    ignore_list: list[str] = field(default_factory=list)
-    annotation_format: str | None = None
-    annotation: AnnotationMethod = AnnotationMethod.STANDARD
-    use_line_directives: bool = False
-    hooks: list[str] = field(default_factory=lambda: ["shebang"])
-    hook: dict[str, Any] = field(default_factory=dict)  # pyright: ignore[reportExplicitAny]
-    brei: Program = field(default_factory=Program)
-
-    language_index: dict[str, Language] = field(default_factory=dict)
-
-    @cached_property
-    def version(self) -> Version:
-        return Version.from_str(self._version)
-
-    def __post_init__(self):
-        self.languages = languages + self.languages
-        self.make_language_index()
-
-    def make_language_index(self):
-        for l in self.languages:
-            for i in l.identifiers:
-                self.language_index[i] = l
-
-
-default = Config("2.0")  # Version.from_str("2.0"))
-
-
 def read_config_from_toml(
     path: Path, section: str | None = None
-) -> Config | None:
+) -> ConfigUpdate | None:
     """Read a config from given `path` in given `section`. The path should refer to
     a TOML file that should decode to a `Config` object. If `section` is given, only
     that section is decoded to a `Config` object. The `section` string may contain
@@ -131,68 +47,37 @@ def read_config_from_toml(
             if section is not None:
                 for s in section.split("."):
                     json = json[s]  # pyright: ignore[reportAny]
-            return msgspec.convert(json, type=Config, dec_hook=from_str.dec_hook)
+            update = msgspec.convert(json, type=ConfigUpdate)
+            log.debug("Read config from `%s`", path)
+            return update
 
-    except ValueError as e:
-        log.error("Could not read config: %s", e)
-        return None
+    except (msgspec.ValidationError, tomllib.TOMLDecodeError) as e:
+        raise HelpfulUserError(f"Could not read config: {e}")
     except KeyError as e:
         log.debug("%s", str(e))
         log.debug("The config file %s should contain a section %s", path, section)
         return None
 
 
-def read_config():
+def read_config() -> ConfigUpdate | None:
     if Path("./entangled.toml").exists():
-        return read_config_from_toml(Path("./entangled.toml")) or default
+        return read_config_from_toml(Path("./entangled.toml"))
     if Path("./pyproject.toml").exists():
         return (
-            read_config_from_toml(Path("./pyproject.toml"), "tool.entangled") or default
+            read_config_from_toml(Path("./pyproject.toml"), "tool.entangled")
         )
-    return default
-
-
-class ConfigWrapper(threading.local):
-    def __init__(self, config: Config | None = None):
-        self.config: Config | None = config
-
-    def read(self, force: bool = False):
-        if self.config is None or force:
-            self.config = read_config()
-
-    @property
-    def get(self) -> Config:
-        if self.config is None:
-            raise ValueError("No config loaded.")
-        return self.config
+    return None
 
-    @contextmanager
-    def __call__(self, **kwargs):
-        backup = self.config
-        new_config = deepcopy(self.config)
-        for k, v in kwargs.items():
-            setattr(new_config, k, v)
-        self.config = new_config
 
-        yield
-
-        self.config = backup
-
-    def get_language(self, lang_name: str) -> Language | None:
-        if self.config is None:
-            raise ValueError("No config loaded.")
-        return self.config.language_index.get(lang_name, None)
-
-
-config = ConfigWrapper()
-"""The `config.config` variable is changed when the `config` module is loaded.
-Config is read from `entangled.toml` file."""
-
-
-def get_input_files() -> list[Path]:
-    include_file_list = chain.from_iterable(map(Path(".").glob, config.get.watch_list))
+def get_input_files(cfg: Config) -> list[Path]:
+    log.debug("watch list: %s; ignoring: %s", cfg.watch_list, cfg.ignore_list)
+    include_file_list = chain.from_iterable(map(Path(".").glob, cfg.watch_list))
     input_file_list = [
         path for path in include_file_list
-        if not any(path.match(pat) for pat in config.get.ignore_list)
+        if not any(path.match(pat) for pat in cfg.ignore_list) and path.is_file()
     ]
+    log.debug("input file list %s", input_file_list)
     return sorted(input_file_list)
+
+
+__all__ = ["Config", "ConfigUpdate", "AnnotationMethod", "Markers", "NamespaceDefault"]
diff --git a/entangled/config/annotation_method.py b/entangled/config/annotation_method.py
new file mode 100644
index 0000000..ccb96ff
--- /dev/null
+++ b/entangled/config/annotation_method.py
@@ -0,0 +1,17 @@
+from enum import StrEnum
+
+
+class AnnotationMethod(StrEnum):
+    """Annotation methods.
+
+    - `STANDARD` is the default. Comments tell where a piece of code
+       came from in enough detail to reconstruct the markdown if some
+       of the code is changed.
+    - `NAKED` adds no comments to the tangled files. Stitching is not
+       possible with this setting.
+    - `SUPPLEMENTED` adds extra information to the comment lines.
+    """
+
+    STANDARD = "standard"
+    NAKED = "naked"
+    SUPPLEMENTED = "supplemented"
diff --git a/entangled/config/config_data.py b/entangled/config/config_data.py
new file mode 100644
index 0000000..c838fcd
--- /dev/null
+++ b/entangled/config/config_data.py
@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from copy import copy
+from dataclasses import dataclass, field
+from .version import Version
+from .language import Language, languages
+from .markers import Markers, default_markers
+from .annotation_method import AnnotationMethod
+from .namespace_default import NamespaceDefault
+from .config_update import ConfigUpdate, prefab_config
+
+from brei import Program
+
+
+@dataclass(frozen=True)
+class Config:
+    """Main config class.
+
+    Attributes:
+        version: Version of Entangled for which this config was created.
+            Entangled should read all versions lower than its own.
+        languages: Dict of programming languages and their comment styles.
+        markers: Regexes for detecting open and close of code blocks.
+
+        watch_list: List of glob-expressions indicating files to include
+            for tangling.
+        ignore_list: List of glob-expressions black-listing files, overrides
+            anything in the watch_list.
+
+        annotation: Style of annotation.
+        annotation_format: Extra annotation.
+
+        use_line_directives: Wether to print pragmas in source code for
+            indicating markdown source locations.
+        hooks: List of enabled hooks.
+        hook: Sub-config of hooks.
+    """
+    version: Version = Version((2, 0))
+    languages: dict[str, Language] = field(default_factory=lambda: {
+        i: lang for lang in languages for i in lang.identifiers
+    })
+    markers: Markers = field(default_factory=lambda: default_markers)
+
+    watch_list: list[str] = field(default_factory=lambda: ["**/*.md"])
+    ignore_list: list[str] = field(default_factory=list)
+
+    annotation_format: str | None = None
+    annotation: AnnotationMethod = AnnotationMethod.STANDARD
+    use_line_directives: bool = False
+
+    namespace_default: NamespaceDefault = NamespaceDefault.GLOBAL
+    namespace: tuple[str, ...] | None = None
+
+    hooks: set[str] = field(default_factory=lambda: { "shebang" })
+    hook: dict[str, object] = field(default_factory=dict)
+    brei: Program = field(default_factory=Program)
+
+    def get_language(self, lang_id: str) -> Language | None:
+        return self.languages.get(lang_id, None)
+
+    def __or__(self, update: ConfigUpdate | None) -> Config:
+        if update is None:
+            return self
+
+        if update.style is not None:
+            x = self | prefab_config[update.style]
+        else:
+            x = self
+
+        version = max(x.version, Version.from_str(update.version))
+        languages = copy(x.languages)
+        for lang in update.languages:
+            for id in lang.identifiers:
+                languages[id] = lang
+
+        markers = x.markers if update.markers is None else update.markers
+        watch_list = x.watch_list if update.watch_list is None else update.watch_list
+        ignore_list = x.ignore_list if update.ignore_list is None else update.ignore_list
+        annotation_format = x.annotation_format if update.annotation_format is None \
+            else update.annotation_format
+        annotation = x.annotation if update.annotation is None else update.annotation
+        use_line_directives = x.use_line_directives if update.use_line_directives is None \
+            else update.use_line_directives
+
+        namespace_default = x.namespace_default if update.namespace_default is None \
+            else update.namespace_default
+        namespace = x.namespace if update.namespace is None \
+            else tuple(update.namespace.split("::"))
+
+        hook = x.hook if update.hook is None else x.hook | update.hook
+        brei = x.brei if update.brei is None else update.brei
+
+        hooks = copy(x.hooks)
+        for uh in update.hooks:
+            if uh.startswith("~"):
+                h = uh.removeprefix("~")
+                if h in hooks:
+                    hooks.remove(h)
+            else:
+                hooks.add(uh)
+
+        return Config(
+            version, languages, markers, watch_list, ignore_list,
+            annotation_format, annotation, use_line_directives,
+            namespace_default, namespace, hooks, hook, brei)
diff --git a/entangled/config/config_update.py b/entangled/config/config_update.py
new file mode 100644
index 0000000..31d560c
--- /dev/null
+++ b/entangled/config/config_update.py
@@ -0,0 +1,60 @@
+from msgspec import Struct, field
+
+from .document_style import DocumentStyle
+from .language import Language
+from .markers import Markers, default_markers, basic_markers
+from .annotation_method import AnnotationMethod
+from .namespace_default import NamespaceDefault
+
+from brei import Program
+
+
+class ConfigUpdate(Struct):
+    """An update to existing config. This actually sets the API for all
+    config input.
+
+    Attributes:
+        version: updates to the maximum.
+        style: fills in a preset if given.
+        languages: additive list of languages, identical identifiers will
+            overrule existing ones.
+        markers: overrides.
+        watch_list: overrides.
+        ignore_list: overrides.
+        annotation_format: overrides.
+        annotation: overrides.
+        use_line_directives: overrides.
+        hooks: additive, prepend a `~` character to disable a hook).
+        hook: merged with `|` operator (overrides one deep).
+        brei: overrides (TODO: implement merge, requires updating Brei).
+    """
+    version: str
+    style: DocumentStyle | None = None
+    languages: list[Language] = field(default_factory=list)
+    markers: Markers | None = None
+    watch_list: list[str] | None = None
+    ignore_list: list[str] | None = None
+    annotation_format: str | None = None
+    annotation: AnnotationMethod | None = None
+    use_line_directives: bool | None = None
+
+    namespace_default: NamespaceDefault | None = None
+    namespace: str | None = None
+
+    hooks: list[str] = field(default_factory=list)
+    hook: dict[str, object] | None = None
+    brei: Program | None = None
+
+
+prefab_config: dict[DocumentStyle, ConfigUpdate] = {
+    DocumentStyle.DEFAULT: ConfigUpdate(
+        version = "2.0",
+        markers = default_markers,
+        hooks = ["shebang"]
+    ),
+    DocumentStyle.BASIC: ConfigUpdate(
+        version = "2.4",
+        markers = basic_markers,
+        hooks = ["quarto_attributes", "spdx_license", "shebang", "repl", "brei"]
+    )
+}
diff --git a/entangled/config/document_style.py b/entangled/config/document_style.py
new file mode 100644
index 0000000..a3c8e68
--- /dev/null
+++ b/entangled/config/document_style.py
@@ -0,0 +1,18 @@
+from enum import StrEnum
+
+
+class DocumentStyle(StrEnum):
+    """Document style is a short hand for markdown style and hook settings.
+
+    - `DEFAULT` is the default. We have fenced code blocks with a set of
+      attributes attached in curly braces. This setting offers the most
+      consistent syntax but is sometimes lacking in support from third-party
+      tools.
+
+    - `BASIC` sets a simpler syntax where only the language is passed on the
+      same line as the code block fences. All other metadata is to be passed
+      using Quatro style attributes.
+    """
+
+    DEFAULT = "default"
+    BASIC = "basic"
diff --git a/entangled/config/language.py b/entangled/config/language.py
index 7782e0a..fc151fd 100644
--- a/entangled/config/language.py
+++ b/entangled/config/language.py
@@ -24,7 +24,7 @@ class Language(Struct):
 
 languages = [
     Language("Bash", ["sh", "bash"], Comment("#")),
-    Language("C", ["c", "cpp", "c++"], Comment("/*", "*/")),
+    Language("C", ["c", "cpp", "c++"], Comment("//")),
     Language("Python", ["python"], Comment("#")),
     Language("Rust", ["rust"], Comment("//")),
     Language("Haskell", ["haskell"], Comment("--")),
diff --git a/entangled/config/markers.py b/entangled/config/markers.py
new file mode 100644
index 0000000..23658d8
--- /dev/null
+++ b/entangled/config/markers.py
@@ -0,0 +1,21 @@
+from msgspec import Struct
+
+
+class Markers(Struct, frozen=True):
+    """Markers can be used to configure the Markdown dialect. Currently not used."""
+
+    open: str
+    close: str
+    begin_ignore: str = r"^\s*\~\~\~markdown\s*$"
+    end_ignore: str = r"^\s*\~\~\~\s*$"
+
+
+default_markers = Markers(
+    r"^(?P<indent>\s*)```\s*{(?P<properties>[^{}]*)}\s*$",
+    r"^(?P<indent>\s*)```\s*$"
+)
+
+basic_markers = Markers(
+    r"^(?P<indent>\s*)```(?P<properties>.*)$",
+    r"^(?P<indent>\s*)```\s*$"
+)
diff --git a/entangled/config/namespace_default.py b/entangled/config/namespace_default.py
new file mode 100644
index 0000000..288685a
--- /dev/null
+++ b/entangled/config/namespace_default.py
@@ -0,0 +1,14 @@
+from enum import StrEnum
+
+
+class NamespaceDefault(StrEnum):
+    """Default namespace behaviour.
+
+    - `GLOBAL` is the default. Identifiers are all collected into the global
+      namespace.
+
+    - `PRIVATE` means that identifiers are only accessible within the same file.
+    """
+
+    GLOBAL = "global"
+    PRIVATE = "private"
diff --git a/entangled/config/version.py b/entangled/config/version.py
index 31ad6b4..115a463 100644
--- a/entangled/config/version.py
+++ b/entangled/config/version.py
@@ -1,18 +1,17 @@
 from __future__ import annotations
 from dataclasses import dataclass
-from ..from_str import FromStr
-from typing import override
 
 
-@dataclass
-class Version(FromStr):
+@dataclass(frozen=True)
+class Version:
     numbers: tuple[int, ...]
 
-    @override
     def to_str(self) -> str:
         return ".".join(str(i) for i in self.numbers)
 
-    @override
     @classmethod
     def from_str(cls, s: str) -> Version:
         return Version(tuple(int(sv) for sv in s.split(".")))
+
+    def __lt__(self, other: Version) -> bool:
+        return self.numbers < other.numbers
diff --git a/entangled/document.py b/entangled/document.py
deleted file mode 100644
index af60674..0000000
--- a/entangled/document.py
+++ /dev/null
@@ -1,162 +0,0 @@
-from textwrap import indent
-from collections.abc import Iterable
-from typing import override
-from dataclasses import dataclass, field
-from collections import defaultdict
-from functools import singledispatchmethod
-from pathlib import PurePath
-
-from .config.language import Language
-from .properties import Property
-from .errors.internal import InternalError
-from .text_location import TextLocation
-
-
-def length[T](iter: Iterable[T]) -> int:
-    return sum(1 for _ in iter)
-
-
-@dataclass
-class ReferenceId:
-    name: str
-    file: PurePath
-    ref_count: int
-
-    @override
-    def __hash__(self) -> int:
-        return hash((self.name, self.file, self.ref_count))
-
-
-@dataclass
-class PlainText:
-    content: str
-
-
-@dataclass
-class CodeBlock:
-    properties: list[Property]
-    indent: str
-    open_line: str
-    close_line: str
-    source: str
-    origin: TextLocation
-    language: Language | None = None
-    header: str | None = None
-    mode: int | None = None
-
-    @property
-    def text(self) -> str:
-        return self.open_line + "\n" + self.source + "\n" + self.close_line
-
-    @property
-    def indented_text(self) -> str:
-        return indent(self.text, self.indent)
-
-
-Content = PlainText | ReferenceId
-RawContent = PlainText | CodeBlock
-
-
-@dataclass
-class ReferenceMap:
-    """
-    Members:
-        `map`: maps references to actual code block content
-        `index`: maps names to list of references
-        `targets`: lists filenames; a target should be in `index`
-    """
-
-    map: dict[ReferenceId, CodeBlock] = field(default_factory=dict)
-    index: defaultdict[str, list[ReferenceId]] = field(
-        default_factory=lambda: defaultdict(list)
-    )
-    targets: set[str] = field(default_factory=set)
-    alias: dict[str, str] = field(default_factory=dict)
-
-    def names(self) -> Iterable[str]:
-        return self.index.keys()
-
-    def by_name(self, n: str) -> Iterable[CodeBlock]:
-        if n not in self.index and n not in self.alias:
-            raise AttributeError(name=n, obj=self)
-        if n not in self.index:
-            return self.by_name(self.alias[n])
-
-        return (self.map[r] for r in self.index[n])
-
-    def new_id(self, filename: PurePath, name: str) -> ReferenceId:
-        c = length(filter(lambda r: r.file == filename, self.index[name]))
-        return ReferenceId(name, filename, c)
-
-    def __setitem__(self, key: ReferenceId, value: CodeBlock):
-        if key in self.map:
-            raise InternalError("Duplicate key in ReferenceMap", [key])
-        self.map[key] = value
-        self.index[key.name].append(key)
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.index
-
-    def get_codeblock(self, key: ReferenceId) -> CodeBlock:
-        return self.map[key]
-
-    @singledispatchmethod
-    def __getitem__(self, key: ReferenceId | str) -> CodeBlock | Iterable[CodeBlock]:
-        raise NotImplementedError(f"Invalid key: {type(key)}")
-
-    @__getitem__.register
-    def _(self, key: ReferenceId) -> CodeBlock:
-        return self.map[key]
-
-    @__getitem__.register
-    def _(self, key: str) -> Iterable[CodeBlock]:
-        return self.by_name(key)
-
-
-def content_to_text(r: ReferenceMap, c: Content) -> str:
-    """
-    Reconstruct original plain text from a piece of content.
-
-    Args:
-        r: the reference map.
-        c: the content.
-
-    Returns:
-        A string, usually not terminated by a newline.
-    """
-    match c:
-        case PlainText(s):
-            return s
-        case ReferenceId():
-            return r.get_codeblock(c).indented_text
-
-
-def document_to_text(r: ReferenceMap, cs: Iterable[Content]) -> str:
-    """
-    Reconstruct original plain text content from a reference map and
-    list of content.
-
-    Args:
-        r: the reference map.
-        cs: a list of content.
-
-    Returns:
-        A string, including a final newline.
-
-    Usually this is the reconstructed content of a Markdown file. Most
-    editors have a convention to end a file with a newline, but this
-    newline is usually stripped when we read a file.
-
-    Context:
-        In Python `"foo".splitlines()` gives the same as `"foo\n".splitlines()`,
-        with the exception of `"\n".splitlines()` giving `['']`, while
-        `"".splitlines()` returns `[]`.
-
-        As an alternative, we could keep line endings by splitting with `keepends=True`,
-        and joining with `"".join(...)`.
-    """
-    text = "\n".join(content_to_text(r, c) for c in cs)
-    if text[-1] != "\n":
-        return text + "\n"
-    else:
-        return text
diff --git a/entangled/errors/user.py b/entangled/errors/user.py
index 78b5ea6..f41b2e5 100644
--- a/entangled/errors/user.py
+++ b/entangled/errors/user.py
@@ -1,7 +1,10 @@
 from dataclasses import dataclass
-from typing import Any, Callable
+from typing import Any, override, Callable
 from pathlib import Path
 
+import logging
+import sys
+
 from ..text_location import TextLocation
 
 
@@ -9,6 +12,8 @@ class UserError(Exception):
     def __str__(self) -> str:
         return "Unknown user error."
 
+    def handle(self):
+        pass
 
 @dataclass
 class ConfigError(UserError):
@@ -21,16 +26,19 @@ def __str__(self):
 
 @dataclass
 class HelpfulUserError(UserError):
-    """Raise a user error and supply an optional function `func` for context.
-
-    Make sure to also execute e.func() in your error handling."""
-
+    """Raise a user error with a message."""
     msg: str
-    func: Callable[[], Any] = lambda: None
+    action: Callable[[], None] = lambda: None
 
     def __str__(self):
         return f"error: {self.msg}"
 
+    @override
+    def handle(self):
+        self.action()
+        logging.error(str(self))
+        sys.exit(-1)
+        
 
 @dataclass
 class FileError(UserError):
@@ -58,19 +66,10 @@ def __str__(self):
 
 
 @dataclass
-class CyclicReference(UserError):
-    ref_name: str
-    cycle: list[str]
-
-    def __str__(self):
-        cycle_str = " -> ".join(self.cycle)
-        return f"Cyclic reference in <<{self.ref_name}>>: {cycle_str}"
-
-
-@dataclass
-class MissingReference(UserError):
-    ref_name: str
-    location: TextLocation
+class CodeAttributeError(UserError):
+    origin: TextLocation
+    msg: str
 
-    def __str__(self):
-        return f"Missing reference `{self.ref_name}` at `{self.location}`"
+    @override
+    def __str__(self) -> str:
+        return f"{self.origin}: Attribute error: {self.msg}"
diff --git a/entangled/from_str.py b/entangled/from_str.py
deleted file mode 100644
index dae2437..0000000
--- a/entangled/from_str.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Self, Any
-
-
-class FromStr(ABC):
-    @abstractmethod
-    def to_str(self) -> str:
-        ...
-
-    @classmethod
-    @abstractmethod
-    def from_str(cls, s: str) -> Self:
-        ...
-
-
-def enc_hook(obj: Any) -> str:
-    if isinstance(obj, FromStr):
-        return obj.to_str()
-    else:
-        raise NotImplementedError # (f"Object should implement `FromStr`, got: `{type(obj)}`.")
-
-
-def dec_hook(cls: type, obj: Any) -> Any:
-    if issubclass(cls, FromStr) and isinstance(obj, str):
-        return cls.from_str(obj)
-    else:
-        raise NotImplementedError(f"Unsupported type, couldn't decode `{obj}` to `{cls}`.")
diff --git a/entangled/hooks/__init__.py b/entangled/hooks/__init__.py
index ec92d8e..c20b3f8 100644
--- a/entangled/hooks/__init__.py
+++ b/entangled/hooks/__init__.py
@@ -3,7 +3,7 @@
 
 from .base import HookBase, PrerequisitesFailed
 from . import build, task, quarto_attributes, shebang, spdx_license, repl
-from ..config import config
+from ..config import Config
 from typing import TypeVar
 import msgspec
 
@@ -11,9 +11,8 @@
 
 discovered_hooks = entry_points(group="entangled.hooks")
 
-
 external_hooks = {
-    name: discovered_hooks[name].load().Hook for name in discovered_hooks.names
+    name: discovered_hooks[name].load().Hook for name in discovered_hooks.names  # pyright: ignore[reportAny]
 }
 
 hooks: dict[str, type[HookBase]] = {
@@ -23,26 +22,25 @@
     "shebang": shebang.Hook,
     "spdx_license": spdx_license.Hook,
     "quarto_attributes": quarto_attributes.Hook,
-}
+} | external_hooks
+
 
+def create_hook(cfg: Config, h: str) -> HookBase | None:
+    if h not in hooks:
+        logging.error("hook `%s` not found", h)
+        return None
 
-def get_hooks() -> list[HookBase]:
-    active_hooks: list[HookBase] = []
-    for h in config.get.hooks:
-        if h in hooks | external_hooks:
-            try:
-                hook_cfg = msgspec.convert(config.get.hook.get(h, {}), type=hooks[h].Config)
-                hook_instance = hooks[h](hook_cfg)
-                hook_instance.check_prerequisites()
-                active_hooks.append(hook_instance)
-            except PrerequisitesFailed as e:
-                logging.error("hook `%s`: %s", h, str(e))
-            except msgspec.ValidationError as e:
-                logging.error("hook `%s`: %s", h, str(e))
-        else:
-            logging.error("no such hook available: `%s`", h)
+    try:
+        hook_cfg = msgspec.convert(cfg.hook.get(h, {}), type=hooks[h].Config)
+        hook_instance = hooks[h](hook_cfg)
+        hook_instance.check_prerequisites()
+        return hook_instance
+    except PrerequisitesFailed as e:
+        logging.error("hook `%s`: %s", h, str(e))
+    except msgspec.ValidationError as e:
+        logging.error("hook `%s`: %s", h, str(e))
 
-    return active_hooks
+    return None
 
 
-__all__ = ["hooks", "PrerequisitesFailed", "get_hooks"]
+__all__ = ["hooks", "PrerequisitesFailed", "create_hook", "HookBase"]
diff --git a/entangled/hooks/base.py b/entangled/hooks/base.py
index 975ff27..d36efe6 100644
--- a/entangled/hooks/base.py
+++ b/entangled/hooks/base.py
@@ -2,7 +2,7 @@
 from typing import override
 from msgspec import Struct
 
-from ..document import ReferenceMap, CodeBlock
+from ..model import ReferenceMap, CodeBlock
 from ..io import Transaction
 
 
@@ -22,6 +22,10 @@ class Config(Struct):
     def __init__(self, config: Config):
         pass
 
+    @staticmethod
+    def priority() -> int:
+        return 50
+
     def check_prerequisites(self):
         """When prerequisites aren't met, raise PrerequisitesFailed."""
         pass
diff --git a/entangled/hooks/build.py b/entangled/hooks/build.py
index 925a2e2..079eb2c 100644
--- a/entangled/hooks/build.py
+++ b/entangled/hooks/build.py
@@ -8,15 +8,15 @@
 from __future__ import annotations
 from dataclasses import dataclass
 from msgspec import field
-from pathlib import Path
+from pathlib import Path, PurePath
 from subprocess import run, SubprocessError, DEVNULL
 import logging
 from typing import final, override
 
-from entangled.config.language import Language
-
-from ..properties import Property, get_attribute, get_classes
-from ..document import ReferenceId, ReferenceMap, CodeBlock
+from ..config.language import Language
+from ..io import Transaction
+from ..model.properties import Property, get_attribute, get_attribute_string, get_classes
+from ..model import ReferenceId, ReferenceMap, CodeBlock
 
 from .base import HookBase, PrerequisitesFailed
 
@@ -80,33 +80,32 @@ def check_prerequisites(self):
     @override
     def pre_tangle(self, refs: ReferenceMap):
         """Add a CodeBlock's target attribute to the list of targets."""
-        for (ref, cb) in refs.map.items():
+        for (ref, cb) in refs.items():
             logging.debug("build hook: passing: %s", ref)
             if "build" not in get_classes(cb.properties):
                 continue
-            target = get_attribute(cb.properties, "target")
+            target = get_attribute_string(cb.properties, "target")
             if target is None:
                 continue
             if cb.language is None:
                 continue
 
             logging.debug("build hook: target: %s", target)
-            script_file_name = get_attribute(cb.properties, "file")
+            script_file_name = get_attribute_string(cb.properties, "file")
             if script_file_name is None:
-                script_file_name = f".entangled/build/{ref.name}".replace(":", "_")
-                refs.index[script_file_name].append(ref)
-                refs.targets.add(script_file_name)
+                script_file_name = f".entangled/build/{ref.name.name}".replace(":", "_")
+                refs.register_target(PurePath(script_file_name), ref.name)
 
             deps = [str(s) for s in (get_attribute(cb.properties, "deps") or "").split()]
             self.recipes.append(Hook.Recipe(target, deps, cb.language, script_file_name))
 
     @override
-    def post_tangle(self, refs: ReferenceMap):
+    def on_tangle(self, t: Transaction, refs: ReferenceMap):
         """After all code is tangled: retrieve the build scripts and run it."""
         targets = " ".join([r.target for r in self.recipes])
         makefile = preamble.format(
             targets=targets,
             rules="\n\n".join(r.to_makefile(self.config) for r in self.recipes),
         )
-        Path(".entangled/build").mkdir(exist_ok=True, parents=True)
-        _ = Path(".entangled/build/Makefile").write_text(makefile)
+        t.write(Path(".entangled/build/Makefile"), makefile, [])
+
diff --git a/entangled/hooks/quarto_attributes.py b/entangled/hooks/quarto_attributes.py
index 7108f9e..ea333c3 100644
--- a/entangled/hooks/quarto_attributes.py
+++ b/entangled/hooks/quarto_attributes.py
@@ -1,13 +1,13 @@
 from __future__ import annotations
 import re
-import textwrap
-from typing import Any, final, override
+from typing import final, override, cast
 import yaml
+from os import linesep as eol
 
 from entangled.config.language import Language
 
-from ..properties import Attribute, Class, Id, Property
-from ..document import CodeBlock
+from ..model.properties import Attribute, Class, Id, Property
+from ..model import CodeBlock
 from .base import HookBase
 from ..logging import logger
 
@@ -17,8 +17,8 @@
 
 def split_yaml_header(language: Language, source: str) -> tuple[str, str, object]:
     """Split source into YAML header and body."""
-    trigger = re.escape(language.comment.open) + r"\s*\|(.*)"
-    lines = source.splitlines()
+    trigger: str = re.escape(language.comment.open) + r"\s*\|(.*)"
+    lines = source.splitlines(keepends=True)
     header_lines: list[str] = []
     body_start: int = 0
 
@@ -30,7 +30,9 @@ def split_yaml_header(language: Language, source: str) -> tuple[str, str, object
         body_start = i
         break
 
-    return "\n".join(lines[:body_start]), "\n".join(lines[body_start:]), yaml.safe_load("\n".join(header_lines))
+    return "".join(lines[:body_start]), \
+           "".join(lines[body_start:]), \
+           yaml.safe_load(eol.join(header_lines))
 
 
 def amend_code_properties(code_block: CodeBlock):
@@ -51,26 +53,28 @@ def amend_code_properties(code_block: CodeBlock):
         log.warning(f"tried to parse:\n{header}")
         return
 
-    if "id" in attrs.keys():
-        if not isinstance(attrs["id"], str):
+    attrs = cast(dict[str, object], attrs)
+    code_id = attrs.get("id", None)
+    if code_id is not None:
+        if not isinstance(code_id, str):
             log.warning(f"{code_block.origin}: Quarto id does not evaluate to string; skipping")
             log.warning(f"tried to parse:\n{header}")
             return
-        props.append(Id(attrs["id"]))
+        props.append(Id(code_id))
 
-    if "classes" in attrs.keys():
-        classes = attrs["classes"]
+    classes = attrs.get("classes", None)
+    if isinstance(classes, list):
         if not all(isinstance(c, str) for c in classes):
             log.warning(f"{code_block.origin}: Quarto classes do not evaluate to strings; skipping")
             log.warning(f"tried to parse:\n{header}")
             return
-        props.extend(Class(c) for c in classes)
+        props.extend(Class(cast(str, c)) for c in classes)
 
     props.extend(Attribute(str(k), v) for k, v in attrs.items()
                  if k not in ("id", "classes"))
 
     code_block.source = body
-    code_block.open_line += "\n" + header
+    code_block.open_line += header
     code_block.properties.extend(props)
 
 
@@ -80,7 +84,11 @@ def __init__(self, config: Hook.Config):
         super().__init__(config)
         self.config = config
 
+    @override
+    @staticmethod
+    def priority():
+        return 10
+
     @override
     def on_read(self, code: CodeBlock):
-        log.debug("quarto filter: %s", code)
         amend_code_properties(code)
diff --git a/entangled/hooks/repl.py b/entangled/hooks/repl.py
index 2333a36..1eab12a 100644
--- a/entangled/hooks/repl.py
+++ b/entangled/hooks/repl.py
@@ -11,8 +11,8 @@
 
 from ..logging import logger
 from ..io import Transaction
-from ..document import CodeBlock, ReferenceMap
-from ..properties import Class, get_attribute, get_id
+from ..model import CodeBlock, ReferenceMap
+from ..model.properties import Class, get_attribute, get_attribute_string, get_id
 
 
 log = logger()
@@ -46,6 +46,7 @@ def on_read(self, code: CodeBlock):
         """Called when the Markdown is being read, before the assembling of
         the reference map."""
         session_name = get_id(code.properties)
+        log.debug("repl-session %s", session_name)
         if Class("repl") not in code.properties and session_name not in self.sessions.keys():
             return
 
@@ -63,7 +64,7 @@ def on_read(self, code: CodeBlock):
             return
 
         if session_name not in self.sessions.keys():
-            filename = get_attribute(code.properties, "session")
+            filename = get_attribute_string(code.properties, "session")
             if filename is None:
                 log.error(f"{code.origin}: REPL hook session opened without session attribute.")
                 return
@@ -73,13 +74,16 @@ def on_read(self, code: CodeBlock):
         mime_type = get_attribute(code.properties, "mime-type") or "text/plain"
         self.sessions[session_name].commands.append(ReplCommand(
             strip_comments(code.source, code.language), output_type=mime_type))
+        log.debug("repl-session: %s", self.sessions[session_name])
 
     @override
     def on_tangle(self, t: Transaction, refs: ReferenceMap):
         """Executed after other targets were tangled, but during the same
         transaction. If you want to write a file, consider doing so as part of
         the transaction."""
+        log.debug("repl-session on-tangle %s", list(self.sessions.keys()))
         for s in self.sessions.values():
+            log.debug("repl-session: %s", s.filename)
             rs_json = msgspec.json.encode(ReplSession(
                 config = self.config[s.language],
                 commands = s.commands))
diff --git a/entangled/hooks/shebang.py b/entangled/hooks/shebang.py
index 568c8ab..d03655e 100644
--- a/entangled/hooks/shebang.py
+++ b/entangled/hooks/shebang.py
@@ -1,12 +1,13 @@
 from typing import final, override
-from ..document import CodeBlock
+from ..model import CodeBlock
 from .base import HookBase
 
+
 @final
 class Hook(HookBase):
     @override
     def on_read(self, code: CodeBlock):
-        lines = code.source.splitlines()
+        lines = code.source.splitlines(keepends=True)
         if lines and lines[0].startswith("#!"):
-            code.header = lines[0]
-            code.source = "\n".join(lines[1:])
+            code.header = (code.header or "") + lines[0]
+            code.source = "".join(lines[1:])
diff --git a/entangled/hooks/spdx_license.py b/entangled/hooks/spdx_license.py
index 4d8a776..1aeb9b2 100644
--- a/entangled/hooks/spdx_license.py
+++ b/entangled/hooks/spdx_license.py
@@ -1,12 +1,13 @@
 from typing import final, override
-from ..document import CodeBlock
+from ..model import CodeBlock
 from .base import HookBase
 
+
 @final
 class Hook(HookBase):
     @override
     def on_read(self, code: CodeBlock):
-        lines = code.source.splitlines()
+        lines = code.source.splitlines(keepends=True)
         if lines and "SPDX-License-Identifier" in lines[0]:
-            code.header = lines[0]
-            code.source = "\n".join(lines[1:])
+            code.header = (code.header or "") + lines[0]
+            code.source = "".join(lines[1:])
diff --git a/entangled/hooks/task.py b/entangled/hooks/task.py
index b2708e2..ba1bc31 100644
--- a/entangled/hooks/task.py
+++ b/entangled/hooks/task.py
@@ -1,51 +1,38 @@
 from __future__ import annotations
 from collections import defaultdict
-from dataclasses import dataclass, fields
+from dataclasses import dataclass
 import json
 from pathlib import Path
-from typing import Any, final, override
+from typing import final, override
 
 from ..config import AnnotationMethod
 from ..io import Transaction
 
-from ..document import CodeBlock, ReferenceId, ReferenceMap
-from ..properties import Class, Property, get_attribute, get_classes
+from ..model import ReferenceId, ReferenceMap
+from ..model.properties import Class, get_attribute_string, get_classes, get_typed_attribute
+from ..model.tangle import tangle_ref
 from .base import HookBase
 from ..logging import logger
-from ..tangle import tangle_ref
 
 log = logger()
 
 
-def ensure_list(strs: str | list[str]) -> list[str]:
-    """Some options may be given either as a list or as a single string,
-    where the string is supposed to have a whitespace separated list.
-    This function converts from either to a list of strings.
-    """
-    if isinstance(strs, str):
-        return strs.split()
-    elif isinstance(strs, list):
-        return strs
-    else:
-        raise ValueError(f"Expected `str` or `list[str]`, got: {strs}")
-
-
 @final
 class Hook(HookBase):
     @dataclass
     class Recipe:
-        description: str | None
-        creates: list[str] | None
-        requires: list[str] | None
-        runner: str | None
-        stdout: str | None
-        stdin: str | None
-        collect: str | None
         ref: ReferenceId
+        description: str | None = None
+        creates: list[str] | None = None
+        requires: list[str] | None = None
+        runner: str | None = None
+        stdout: str | None = None
+        stdin: str | None = None
+        collect: str | None = None
 
         def to_brei_task(self, refs: ReferenceMap):
-            cb = refs.get_codeblock(self.ref)
-            if (path := get_attribute(cb.properties, "file")) is None:
+            cb = refs[self.ref]
+            if (path := get_attribute_string(cb.properties, "file")) is None:
                 script, _ = tangle_ref(refs, self.ref.name, AnnotationMethod.NAKED)
             else:
                 script = None
@@ -70,7 +57,7 @@ def __init__(self, config: Hook.Config):
 
     @override
     def pre_tangle(self, refs: ReferenceMap):
-        for ref, cb in refs.map.items():
+        for ref, cb in refs.items():
             if "task" not in get_classes(cb.properties):
                 continue
 
@@ -84,18 +71,16 @@ def pre_tangle(self, refs: ReferenceMap):
                 case _:
                     continue
 
-            record: dict[str, Any] = {
-                f.name: get_attribute(cb.properties, f.name)
-                for f in fields(Hook.Recipe)
-            }
-
-            record["runner"] = record["runner"] or runner
-            record["creates"] = ensure_list(record["creates"]) if record["creates"] else None
-            record["requires"] = ensure_list(record["requires"]) if record["requires"] else None
-            record["ref"] = ref
-
-            log.debug(f"task: {record}")
-            recipe = Hook.Recipe(**record)
+            recipe = Hook.Recipe(
+                ref=ref,
+                description=get_typed_attribute(str, cb.properties, "description"),
+                creates=get_typed_attribute(list[str], cb.properties, "creates"),
+                requires=get_typed_attribute(list[str], cb.properties, "requires"),
+                runner=get_typed_attribute(str, cb.properties, "runner") or runner,
+                stdout=get_typed_attribute(str, cb.properties, "stdout"),
+                stdin=get_typed_attribute(str, cb.properties, "stdin"),
+                collect=get_typed_attribute(str, cb.properties, "collect")
+            )
             self.recipes.append(recipe)
             if recipe.collect:
                 targets = recipe.creates or []
diff --git a/entangled/interface/__init__.py b/entangled/interface/__init__.py
new file mode 100644
index 0000000..f739ed5
--- /dev/null
+++ b/entangled/interface/__init__.py
@@ -0,0 +1,4 @@
+from .document import Document
+from .context import Context, markdown
+
+__all__ = ["Document", "Context", "markdown"]
diff --git a/entangled/interface/context.py b/entangled/interface/context.py
new file mode 100644
index 0000000..4fb24d3
--- /dev/null
+++ b/entangled/interface/context.py
@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from collections.abc import Generator
+
+from ..config import Config, ConfigUpdate
+from ..hooks import HookBase, create_hook
+from ..model import Content, ReferenceMap
+from ..readers.yaml_header import get_config
+from ..readers import read_yaml_header, process_token, collect_plain_text, raw_markdown, InputStream
+
+from functools import partial
+import logging
+
+@dataclass
+class Context:
+    config: Config = Config()
+    _hooks: dict[str, HookBase] = field(default_factory=dict)
+    
+    def __post_init__(self):
+        for h in self.config.hooks:
+            if h not in self._hooks:
+                logging.debug("context: loading hook %s", h)
+                hook = create_hook(self.config, h)
+                if hook is None:
+                    continue
+                self._hooks[h] = hook
+
+    def __or__(self, update: ConfigUpdate | None) -> Context:
+        return Context(self.config | update, self._hooks)
+
+    @property
+    def hooks(self) -> list[HookBase]:
+        return sorted((self._hooks[h] for h in self.config.hooks),
+                      key=lambda h: h.priority())
+
+
+def markdown(context: Context, refs: ReferenceMap, input: InputStream) -> Generator[Content, None, ConfigUpdate | None]:
+    header = yield from read_yaml_header(input)
+    update = get_config(header)
+    context |= update
+
+    yield from map(
+        partial(process_token, context.hooks, refs),
+        collect_plain_text(raw_markdown(context.config, input)))
+
+    return update
diff --git a/entangled/interface/document.py b/entangled/interface/document.py
new file mode 100644
index 0000000..97627a2
--- /dev/null
+++ b/entangled/interface/document.py
@@ -0,0 +1,96 @@
+from dataclasses import dataclass, field
+from pathlib import PurePath, Path
+
+from ..config import Config, ConfigUpdate, get_input_files, read_config, AnnotationMethod
+from ..model import ReferenceMap, tangle_ref, Content, content_to_text
+from ..io import Transaction
+from ..readers import code
+from ..iterators import numbered_lines, run_generator
+
+from .context import Context, markdown
+import logging
+
+
+@dataclass
+class Document:
+    context: Context = field(default_factory=Context)
+    reference_map: ReferenceMap = field(default_factory=ReferenceMap)
+    content: dict[Path, list[Content]] = field(default_factory=dict)
+
+    @property
+    def config(self):
+        return self.context.config
+
+    @config.setter
+    def config(self, new_config: Config) -> None:
+        self.context.config = new_config
+
+    def __post_init__(self):
+        self.config |= read_config()
+
+    def input_files(self):
+        return get_input_files(self.config)
+
+    def source_text(self, path: Path) -> tuple[str, set[PurePath]]:
+        deps = set()
+        text = ""
+        for content in self.content[path]:
+            t, d = content_to_text(self.reference_map, content)
+            if d is not None:
+                deps.add(d)
+            text += t
+        return text, deps
+
+    def target_text(self, path: PurePath) -> tuple[str, set[PurePath]]:
+        ref_name = self.reference_map.select_by_target(path)
+        return tangle_ref(self.reference_map, ref_name, self.config.annotation)
+
+    def write_target(self, t: Transaction, path: Path, annotation: AnnotationMethod | None = None):
+        ref_name = self.reference_map.select_by_target(path)
+        refs = self.reference_map.select_by_name(ref_name)
+        main_block = self.reference_map[refs[0]]
+        annotation = self.config.annotation if annotation is None else annotation
+        text, deps = tangle_ref(self.reference_map, ref_name, annotation)
+        t.write(path, text, map(Path, deps), main_block.mode)
+
+    def load_source(self, t: Transaction, path: Path) -> ConfigUpdate | None:
+        reader = markdown(self.context, self.reference_map, numbered_lines(path, t.read(path)))
+        content, update = run_generator(reader)
+        logging.debug("got config update: %s", update)
+        self.content[path] = content
+        t.update(path)
+        return update
+
+    def load_code(self, t: Transaction, path: Path):
+        reader = code(numbered_lines(path, t.read(path)))
+        for block in reader:
+            self.reference_map[block.reference_id].source = block.content
+        t.update(path)
+
+    def load_all_code(self, t: Transaction):
+        for tgt in self.reference_map.targets():
+            if Path(tgt) in t.fs:
+                self.load_code(t, Path(tgt))
+
+    def load(self, t: Transaction):
+        for p in get_input_files(self.config):
+            self.load_source(t, p)
+
+    def tangle(self, t: Transaction, annotation: AnnotationMethod | None = None):
+        if annotation is None:
+            annotation = self.config.annotation
+
+        for h in self.context.hooks:
+            h.pre_tangle(self.reference_map)
+
+        for tgt in self.reference_map.targets():
+            self.write_target(t, Path(tgt), annotation)
+
+        for h in self.context.hooks:
+            h.on_tangle(t, self.reference_map)
+
+    def stitch(self, t: Transaction):
+        for path in self.content:
+            text, deps = self.source_text(path)
+            t.write(path, text, map(Path, deps))
+
diff --git a/entangled/io/__init__.py b/entangled/io/__init__.py
index 46dd297..497f88b 100644
--- a/entangled/io/__init__.py
+++ b/entangled/io/__init__.py
@@ -5,7 +5,7 @@
 
 from .transaction import transaction, Transaction, TransactionMode
 from .filedb import filedb
-from .virtual import FileCache
+from .virtual import FileCache, VirtualFS
 
 
-__all__ = ["FileCache", "filedb", "Transaction", "TransactionMode", "transaction"]
+__all__ = ["FileCache", "filedb", "Transaction", "TransactionMode", "transaction", "VirtualFS"]
diff --git a/entangled/io/filedb.py b/entangled/io/filedb.py
index a79bd60..05eb1ea 100644
--- a/entangled/io/filedb.py
+++ b/entangled/io/filedb.py
@@ -16,7 +16,7 @@
 
 from ..version import __version__
 from ..utility import normal_relative, ensure_parent
-from .virtual import FileCache
+from .virtual import AbstractFileCache
 from .stat import Stat, hexdigest
 
 
@@ -49,16 +49,16 @@ def managed_files(self) -> set[Path]:
         the markdown, so is considered to be managed."""
         return {Path(p) for p in self.targets}
 
-    def changed_files(self, fs: FileCache) -> Generator[Path]:
+    def changed_files(self, fs: AbstractFileCache) -> Generator[Path]:
         return (Path(p) for p, known_stat in self.files.items()
                 if fs[Path(p)].stat != known_stat)
 
-    def create_target(self, fs: FileCache, path: Path):
+    def create_target(self, fs: AbstractFileCache, path: Path):
         path = normal_relative(path)
         self.update(fs, path)
         self.targets.add(path.as_posix())
 
-    def update(self, fs: FileCache, path: Path):
+    def update(self, fs: AbstractFileCache, path: Path):
         path = normal_relative(path)
         self.files[path.as_posix()] = fs[path].stat
 
@@ -115,7 +115,11 @@ def write_filedb(db: FileDB):
 
 
 @contextmanager
-def filedb(readonly: bool = False, writeonly: bool = False):
+def filedb(readonly: bool = False, writeonly: bool = False, virtual: bool = False):
+    if virtual:
+        yield new_db()
+        return
+
     lock = FileLock(ensure_parent(FILEDB_LOCK_PATH))
     with lock:
         db = read_filedb() if not writeonly else new_db()
diff --git a/entangled/io/transaction.py b/entangled/io/transaction.py
index b9b99dc..5e383a3 100644
--- a/entangled/io/transaction.py
+++ b/entangled/io/transaction.py
@@ -1,4 +1,5 @@
 from abc import ABCMeta, abstractmethod
+from collections.abc import Iterable
 from dataclasses import dataclass, field
 from functools import cached_property
 from pathlib import Path
@@ -12,7 +13,7 @@
 from ..errors.internal import InternalError
 
 from .stat import Stat, hexdigest
-from .virtual import FileCache
+from .virtual import AbstractFileCache, FileCache, VirtualFS
 from .filedb import FileDB, filedb
 
 
@@ -31,24 +32,24 @@ class Action(metaclass=ABCMeta):
     target: Path
 
     @abstractmethod
-    def conflict(self, fs: FileCache, db: FileDB) -> Conflict | None:
+    def conflict(self, fs: AbstractFileCache, db: FileDB) -> Conflict | None:
         """Indicate wether the action might have conflicts. This could be
         inconsistency in the modification times of files, or overwriting
         a file that is not managed by Entangled."""
         ...
 
     @abstractmethod
-    def add_to_db(self, fs: FileCache, db: FileDB):
+    def add_to_db(self, fs: AbstractFileCache, db: FileDB):
         """Only perform the corresponding database action."""
         ...
 
     @abstractmethod
-    def run(self, fs: FileCache):
+    def run(self, fs: AbstractFileCache):
         """Run the action, if `interact` is `True` then confirmation is
         asked in case of a conflict."""
         ...
 
-    def target_stat(self, fs: FileCache) -> Stat | None:
+    def target_stat(self, fs: AbstractFileCache) -> Stat | None:
         if self.target not in fs:
             return None
         return fs[self.target].stat
@@ -65,13 +66,13 @@ def content_digest(self) -> str:
         return hexdigest(self.content)
 
     @override
-    def run(self, fs: FileCache):
+    def run(self, fs: AbstractFileCache):
         fs.write(self.target, self.content, self.mode)
 
 
 class Create(WriterBase):
     @override
-    def conflict(self, fs: FileCache, db: FileDB) -> Conflict | None:
+    def conflict(self, fs: AbstractFileCache, db: FileDB) -> Conflict | None:
         if self.target in fs:
             if (self.content_digest == fs[self.target].stat.hexdigest):
                 return None
@@ -79,7 +80,7 @@ def conflict(self, fs: FileCache, db: FileDB) -> Conflict | None:
         return None
 
     @override
-    def add_to_db(self, fs: FileCache, db: FileDB):
+    def add_to_db(self, fs: AbstractFileCache, db: FileDB):
         return db.create_target(fs, self.target)
 
     @override
@@ -89,7 +90,7 @@ def __str__(self):
 
 class Write(WriterBase):
     @override
-    def conflict(self, fs: FileCache, db: FileDB) -> Conflict | None:
+    def conflict(self, fs: AbstractFileCache, db: FileDB) -> Conflict | None:
         if self.target not in fs:
             return None
         if fs[self.target].stat != db[self.target]:
@@ -101,7 +102,7 @@ def conflict(self, fs: FileCache, db: FileDB) -> Conflict | None:
         return None
 
     @override
-    def add_to_db(self, fs: FileCache, db: FileDB):
+    def add_to_db(self, fs: AbstractFileCache, db: FileDB):
         db.update(fs, self.target)
 
     @override
@@ -111,17 +112,17 @@ def __str__(self):
 
 class Delete(Action):
     @override
-    def conflict(self, fs: FileCache, db: FileDB) -> Conflict | None:
+    def conflict(self, fs: AbstractFileCache, db: FileDB) -> Conflict | None:
         if fs[self.target].stat != db[self.target]:
             return Conflict(self.target, "changed outside the control of Entangled")
         return None
 
     @override
-    def add_to_db(self, fs: FileCache, db: FileDB):
+    def add_to_db(self, fs: AbstractFileCache, db: FileDB):
         del db[self.target]
 
     @override
-    def run(self, fs: FileCache):
+    def run(self, fs: AbstractFileCache):
         del fs[self.target]
 
     @override
@@ -137,7 +138,7 @@ class Transaction:
     manager function `transaction`.
     """
     db: FileDB
-    fs: FileCache = field(default_factory=FileCache)
+    fs: AbstractFileCache = field(default_factory=FileCache)
     updates: list[Path] = field(default_factory=list)
     actions: list[Action] = field(default_factory=list)
     passed: set[Path] = field(default_factory=set)
@@ -145,16 +146,16 @@ class Transaction:
     def update(self, path: Path):
         self.updates.append(path)
 
-    def write(self, path: Path, content: str, sources: list[Path], mode: int | None = None):
+    def write(self, path: Path, content: str, sources: Iterable[Path], mode: int | None = None):
         if path in self.passed:
             raise InternalError("Path is being written to twice", [path])
         self.passed.add(path)
         if path not in self.db:
             logging.debug("creating target `%s`", path)
-            self.actions.append(Create(path, content, mode, sources))
+            self.actions.append(Create(path, content, mode, list(sources)))
         elif not self.db.check(path, content):
             logging.debug("target `%s` changed", path)
-            self.actions.append(Write(path, content, mode, sources))
+            self.actions.append(Write(path, content, mode, list(sources)))
         else:
             logging.debug("target `%s` unchanged", path)
 
@@ -216,12 +217,17 @@ class TransactionMode(Enum):
 
 
 @contextmanager
-def transaction(mode: TransactionMode = TransactionMode.FAIL):
-    with filedb(writeonly = (mode == TransactionMode.RESETDB)) as db:
+def transaction(mode: TransactionMode = TransactionMode.FAIL, fs: AbstractFileCache | None = None):
+    if fs is None:
+        fs = FileCache()
+
+    with filedb(
+            writeonly = (mode == TransactionMode.RESETDB),
+            virtual = isinstance(fs, VirtualFS)) as db:
         if mode == TransactionMode.RESETDB:
             db.clear()
 
-        tr = Transaction(db)
+        tr = Transaction(db, fs)
 
         logging.debug("Open transaction")
         yield tr
diff --git a/entangled/io/virtual.py b/entangled/io/virtual.py
index 578759e..6c44cd9 100644
--- a/entangled/io/virtual.py
+++ b/entangled/io/virtual.py
@@ -2,13 +2,18 @@
 A virtual file system layer to cache file reads and stats.
 """
 
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import override
 from dataclasses import dataclass, field
 from pathlib import Path
+from datetime import datetime
 
 import os
 import tempfile
 
-from .stat import hexdigest, stat, FileData
+from .stat import hexdigest, stat, FileData, Stat
 
 
 def assure_final_newline(s: str) -> str:
@@ -35,8 +40,54 @@ def atomic_write(target: Path, content: str, mode: int | None):
     os.replace(f.name, target)
 
 
+class AbstractFileCache(ABC):
+    @abstractmethod
+    def __getitem__(self, key: Path) -> FileData:
+        ...
+
+    @abstractmethod
+    def __contains__(self, key: Path) -> bool:
+        ...
+
+    @abstractmethod
+    def __delitem__(self, key: Path):
+        ...
+
+    @abstractmethod
+    def write(self, key: Path, content: str, mode: int | None = None):
+        ...
+
+    def reset(self):
+        pass
+
+
+@dataclass
+class VirtualFS(AbstractFileCache):
+    _data: dict[Path, FileData] = field(default_factory=dict)
+
+    def __getitem__(self, key: Path) -> FileData:
+        return self._data[key]
+
+    def __contains__(self, key: Path) -> bool:
+        return key in self._data
+
+    def __delitem__(self, key: Path):
+        del self._data[key]
+
+    @override
+    def write(self, key: Path, content: str, mode: int | None = None):
+        self._data[key] = FileData(key, content, Stat(datetime.now(), hexdigest(content)))
+
+    @staticmethod
+    def from_dict(dir: dict[str, str]) -> VirtualFS:
+        result = VirtualFS()
+        for filename, content in dir.items():
+            result.write(Path(filename), content)
+        return result
+
+
 @dataclass
-class FileCache:
+class FileCache(AbstractFileCache):
     """
     A virtualization layer between the file system and the rest of Entangled. This is to
     give file IO a cleaner semantics, and also to cache reading file contents and computing
@@ -46,6 +97,7 @@ class FileCache:
     """
     _data: dict[Path, FileData] = field(default_factory=dict)
 
+    @override
     def __getitem__(self, key: Path) -> FileData:
         """
         Get `FileData` belonging to given `Path`. The data is cached inbetween calls.
@@ -57,12 +109,14 @@ def __getitem__(self, key: Path) -> FileData:
             self._data[key] = s
         return self._data[key]
 
+    @override
     def __contains__(self, key: Path) -> bool:
         """
         Check that a file exists.
         """
         return key.exists()
 
+    @override
     def __delitem__(self, key: Path):
         """
         Remove a file. If its parent directories are empty, these are also
@@ -76,22 +130,24 @@ def __delitem__(self, key: Path):
         if key in self._data:
             del self._data[key]
 
-    def write(self, key: Path, new_content: str, mode: int | None = None):
+    @override
+    def write(self, key: Path, content: str, mode: int | None = None):
         """
-        Write contents to a file. If `new_content` has the same digest as the known
+        Write contents to a file. If `content` has the same digest as the known
         contents, nothing is done. The entry is removed from the cache afterward.
 
         Nothing is done to prevent overwriting an existing file.
         """
         if key in self:
-            new_digest = hexdigest(new_content)
+            new_digest = hexdigest(content)
             if new_digest == self[key].stat.hexdigest:
                 return
             del self._data[key]
 
         key.parent.mkdir(parents=True, exist_ok=True)
-        atomic_write(key, new_content, mode)
+        atomic_write(key, content, mode)
 
+    @override
     def reset(self):
         """
         Reset the cache. Doesn't perform any IO.
diff --git a/entangled/iterators/__init__.py b/entangled/iterators/__init__.py
new file mode 100644
index 0000000..08d9226
--- /dev/null
+++ b/entangled/iterators/__init__.py
@@ -0,0 +1,6 @@
+from .lines import lines, numbered_lines
+from .peekable import Peekable
+from .run_generator import run_generator
+
+__all__ = ["Peekable", "lines", "numbered_lines", "run_generator"]
+
diff --git a/entangled/iterators/lines.py b/entangled/iterators/lines.py
new file mode 100644
index 0000000..d86e7ce
--- /dev/null
+++ b/entangled/iterators/lines.py
@@ -0,0 +1,28 @@
+from collections.abc import Generator
+from pathlib import PurePath
+
+from ..text_location import TextLocation
+
+from .peekable import peekable
+
+
+type InputToken = tuple[TextLocation, str]
+
+
+def lines(text: str) -> Generator[str]:
+    pos = 0
+    while (next_pos := text.find("\n", pos)) != -1:
+        yield text[pos:next_pos + 1]
+        pos = next_pos + 1
+
+    yield text[pos:]
+
+
+@peekable
+def numbered_lines(filename: PurePath, text: str) -> Generator[InputToken]:
+    """
+    Iterate the lines in a file. Doesn't strip newlines. Works with both
+    Windows and Unix line endings.
+    """
+    for n, line in enumerate(lines(text)):
+        yield (TextLocation(filename, n+1), line)
diff --git a/entangled/iterators/peekable.py b/entangled/iterators/peekable.py
new file mode 100644
index 0000000..6ee8577
--- /dev/null
+++ b/entangled/iterators/peekable.py
@@ -0,0 +1,43 @@
+from dataclasses import dataclass, field
+from collections.abc import Iterator, Callable
+import functools
+
+
+@dataclass
+class Peekable[T]:
+    """
+    An iterator that allows peeking one element into the future.
+    """
+    iterator: Iterator[T]
+    head: list[T] = field(default_factory=list)
+
+    def peek(self) -> T:
+        if not self.head:
+            try:
+                self.head.append(next(self.iterator))
+            except StopIteration:
+                raise
+        return self.head[0]
+
+    def __bool__(self):
+        if not self.head:
+            try:
+                _ = self.peek()
+            except StopIteration:
+                return False
+        return True
+
+    def __next__(self):
+        if self.head:
+            return self.head.pop()
+        return next(self.iterator)
+
+    def __iter__(self):
+        return self
+
+
+def peekable[**P, T](f: Callable[P, Iterator[T]]) -> Callable[P, Peekable[T]]:
+    @functools.wraps(f)
+    def peekabled(*args: P.args, **kwargs: P.kwargs) -> Peekable[T]:
+        return Peekable(f(*args, **kwargs))
+    return peekabled
diff --git a/entangled/iterators/run_generator.py b/entangled/iterators/run_generator.py
new file mode 100644
index 0000000..1eaf97b
--- /dev/null
+++ b/entangled/iterators/run_generator.py
@@ -0,0 +1,14 @@
+from collections.abc import Generator
+from typing import cast
+
+
+def run_generator[O, R](g: Generator[O, None, R]) -> tuple[list[O], R]:
+    result: R | None = None
+
+    def h() -> Generator[O]:
+        nonlocal result
+        result = yield from g
+
+    out = list(h())
+
+    return out, cast(R, result)
diff --git a/entangled/main.py b/entangled/main.py
index 3a9a211..ce290b7 100644
--- a/entangled/main.py
+++ b/entangled/main.py
@@ -1,45 +1,22 @@
-from .logging import configure, logger
+from .logging import logger
 
-import argh  # type: ignore
 import sys
 import traceback
-from rich_argparse import RichHelpFormatter
 
-from .commands import new, status, stitch, sync, tangle, watch, brei, reset
+from .commands import main
 from .errors.internal import bug_contact
 from .errors.user import HelpfulUserError, UserError
 from .version import __version__
 
 
 def cli():
-    import argparse
-
     try:
-        parser = argparse.ArgumentParser(formatter_class=RichHelpFormatter)
-        _ = parser.add_argument(
-            "-d", "--debug", action="store_true", help="enable debug messages"
-        )
-        _ = parser.add_argument(
-            "-v", "--version", action="store_true", help="show version number"
-        )
-        _ = argh.add_commands(parser, [new, brei, reset, status, stitch, sync, tangle, watch],
-            func_kwargs={"formatter_class": RichHelpFormatter})
-        args = parser.parse_args()
-
-        if args.version:
-            print(f"Entangled {__version__}")
-            sys.exit(0)
-
-        configure(args.debug)
-        _ = argh.dispatch(parser)
-
+        main()
     except KeyboardInterrupt:
         logger().info("Goodbye")
         sys.exit(0)
     except HelpfulUserError as e:
-        logger().error(e, exc_info=False)
-        e.func()
-        sys.exit(0)
+        e.handle()
     except UserError as e:
         logger().error(e, exc_info=False)
         sys.exit(0)
diff --git a/entangled/markdown_reader.py b/entangled/markdown_reader.py
deleted file mode 100644
index 005dea7..0000000
--- a/entangled/markdown_reader.py
+++ /dev/null
@@ -1,229 +0,0 @@
-from copy import copy
-from dataclasses import dataclass, field
-from pathlib import Path
-
-import re
-from typing import override
-import mawk
-import logging
-
-from entangled.config.language import Language
-from entangled.io.transaction import Transaction
-from entangled.io.virtual import FileCache
-
-from .config import config
-from .utility import first
-from .text_location import TextLocation
-from .document import CodeBlock, ReferenceMap, Content, PlainText, RawContent
-from .properties import Property, read_properties, get_attribute, get_classes, get_id
-from .hooks.base import HookBase
-from .errors.user import IndentationError
-from . import parsing
-
-
-@dataclass
-class PartialCodeBlock:
-    indent: str
-    open_line: str
-    origin: TextLocation
-    properties: list[Property] = field(default_factory=list)
-    close_line: str | None = None
-    source: str | None = None
-    language: Language | None = None
-    header: str | None = None
-    mode: int | None = None
-
-    def finalize(self) -> CodeBlock:
-        assert self.close_line is not None
-        assert self.source is not None
-
-        return CodeBlock(
-            properties = self.properties,
-            indent = self.indent,
-            open_line = self.open_line,
-            close_line = self.close_line,
-            source = self.source,
-            origin = self.origin,
-            language = self.language,
-            header = self.header,
-            mode = self.mode
-        )
-
-
-class MarkdownLexer(mawk.RuleSet):
-    """Reads a Markdown file, and splits it up into code blocks and other
-    content."""
-    def __init__(
-        self,
-        filename: Path
-    ):
-        self.location: TextLocation = TextLocation(filename)
-        self.raw_content: list[RawContent] = []
-        self.inside_codeblock: bool = False
-        self.current_content: list[str] = []
-        self.current_codeblock: PartialCodeBlock | None = None
-        self.ignore: bool = False
-
-    def flush_plain_text(self):
-        if self.current_content:
-            self.raw_content.append(PlainText("\n".join(self.current_content)))
-        self.current_content = []
-
-    @mawk.always
-    def on_next_line(self, _):
-        self.location.line_number += 1
-
-    @mawk.on_match(config.get.markers.begin_ignore)
-    def on_begin_ignore(self, _):
-        self.ignore = True
-        logging.debug("ignoring markdown block %s", self.location)
-
-    @mawk.on_match(config.get.markers.end_ignore)
-    def on_end_ignore(self, _):
-        self.ignore = False
-        logging.debug("end of ignore")
-
-    @mawk.on_match(config.get.markers.open)
-    def on_open_codeblock(self, m: re.Match[str]) -> list[str] | None:
-        if self.ignore:
-            return None
-        if self.inside_codeblock:
-            return None
-        logging.debug("triggered on codeblock: %s", m.group(0))
-        self.current_codeblock = PartialCodeBlock(
-            indent = m["indent"],
-            origin = copy(self.location),
-            open_line = m[0].removeprefix(m["indent"])
-        )
-        try:
-            self.current_codeblock.properties.extend(read_properties(m["properties"]))
-            logging.debug("properties: %s", self.current_codeblock.properties)
-            self.flush_plain_text()
-            self.inside_codeblock = True
-        except parsing.Failure as f:
-            logging.error("%s: Parsing error: %s", self.location, f)
-            logging.error("Continuing parsing rest of document.")
-        return []
-
-    @mawk.on_match(config.get.markers.close)
-    def on_close_codeblock(self, m: re.Match[str]) -> list[str] | None:
-        if self.ignore:
-            return None
-        if not self.inside_codeblock or self.current_codeblock is None:
-            return None
-
-        if len(m["indent"]) < len(self.current_codeblock.indent):
-            raise IndentationError(self.location)
-
-        if m["indent"] != self.current_codeblock.indent:
-            return None  # treat this as code-block content
-
-        language_class = first(get_classes(self.current_codeblock.properties))
-        language = config.get_language(language_class) if language_class else None
-        if language_class and not language:
-            logging.warning(f"`{self.location}`: language `{language_class}` unknown.")
-        self.current_codeblock.language = language
-
-        self.current_codeblock.source = "\n".join(
-            line.removeprefix(self.current_codeblock.indent)
-            for line in self.current_content
-        )
-
-        self.current_codeblock.close_line = m[0].removeprefix(self.current_codeblock.indent)
-
-        self.raw_content.append(self.current_codeblock.finalize())
-        self.current_content = []
-
-        self.current_codeblock = None
-        self.inside_codeblock = False
-        return []
-
-    @mawk.always
-    def add_line(self, line: str) -> list[str]:
-        self.current_content.append(line)
-        return []
-
-    @override
-    def on_eof(self) -> list[str]:
-        self.flush_plain_text()
-        return []
-
-def read_markdown_file(
-    t: Transaction,
-    path: Path,
-    refs: ReferenceMap | None = None,
-    hooks: list[HookBase] | None = None) \
-    -> tuple[ReferenceMap, list[Content]]:
-    """
-    Read a Markdown file.
-
-    Args:
-        path: Path to the file.
-        refs: If given, references are added to this existing reference map.
-        hooks: List of hooks to be processed.
-
-    Returns:
-        A reference map and a list of content.
-
-    This splits the Markdown file into code blocks and other text. The resulting
-    content is a list of `PlainText | ReferenceId`. Each `ReferenceId` can be
-    looked up in the reference map.
-    """
-    rel_path = path.resolve().relative_to(Path.cwd())
-    return read_markdown_string(t.read(rel_path), rel_path, refs, hooks)
-
-
-def read_markdown_string(
-        text: str,
-        path_str: Path | None = None,
-        refs: ReferenceMap | None = None,
-        hooks: list[HookBase] | None = None) \
-        -> tuple[ReferenceMap, list[Content]]:
-    """
-    Parse Markdown from a string.
-
-    Args:
-        text: Input string.
-        path: Path to the file from which the string was read, used for printing
-              error messages.
-        refs: If given, references are added to this existing reference map.
-        hooks: List of hooks to be processed.
-
-    Returns:
-        A reference map and a list of content.
-    """
-    path_str = path_str or Path("-")
-    md = MarkdownLexer(path_str)
-    _ = md.run(text)
-
-    hooks = hooks if hooks is not None else []
-    refs = refs if refs is not None else ReferenceMap()
-
-    def process(r: RawContent) -> Content:
-        match r:
-            case CodeBlock():
-                for h in hooks: h.on_read(r)
-                block_id = get_id(r.properties)
-                target_file = get_attribute(r.properties, "file")
-
-                if mode := get_attribute(r.properties, "mode"):
-                    r.mode = int(mode, 8)
-
-                ref_name = block_id or target_file
-                if ref_name is None:
-                    ref_name = f"unnamed-{r.origin}"
-                ref = refs.new_id(r.origin.filename, ref_name)
-
-                refs[ref] = r
-                if target_file is not None:
-                    refs.targets.add(target_file)
-                if target_file is not None and block_id is not None:
-                    refs.alias[target_file] = block_id
-
-                return ref
-
-            case PlainText(): return r
-
-    content = list(map(process, md.raw_content))
-    logging.debug("found ids: %s", list(refs.map.keys()))
-    return refs, content
diff --git a/entangled/model/__init__.py b/entangled/model/__init__.py
new file mode 100644
index 0000000..485f3db
--- /dev/null
+++ b/entangled/model/__init__.py
@@ -0,0 +1,23 @@
+from .content import PlainText, Content, RawContent, content_to_text
+from .code_block import CodeBlock
+from .properties import Id, Class, Attribute, Property
+from .reference_name import ReferenceName
+from .reference_id import ReferenceId
+from .reference_map import ReferenceMap
+from .tangle import tangle_ref
+
+__all__ = [
+    "Id",
+    "Class",
+    "Attribute",
+    "Property",
+    "PlainText",
+    "Content",
+    "RawContent",
+    "CodeBlock",
+    "ReferenceName",
+    "ReferenceId",
+    "ReferenceMap",
+    "tangle_ref",
+    "content_to_text"
+]
diff --git a/entangled/model/code_block.py b/entangled/model/code_block.py
new file mode 100644
index 0000000..2bcf8bc
--- /dev/null
+++ b/entangled/model/code_block.py
@@ -0,0 +1,79 @@
+from dataclasses import dataclass
+from typing import Literal
+
+import os
+
+from ..text_location import TextLocation
+from ..iterators.lines import lines
+from ..config.language import Language
+from .properties import Property
+
+
+def indent(prefix: str, text: str) -> str:
+    def indent_line(line: str):
+        if line.endswith("\r\n"):
+            eol = "\r\n"
+        elif line.endswith("\n"):
+            eol = "\n"
+        else:
+            eol = ""
+            if line.strip() == "":
+                return ""
+
+        if (prefix + line).strip() == "":
+            return eol
+
+        return prefix + line
+
+    return "".join(map(indent_line, lines(text)))
+
+
+@dataclass
+class CodeBlock:
+    """
+    Contains all distilled information on a codeblock.
+
+    Attributes:
+        properties: Id, classes and attributes.
+        indent: The indentation prefix.
+        open_line: One or more lines preceding the source. When `quatro_attributes`
+            are enabled, these attribute lines are appended onto `open_line`.
+        close_line: One or more lines after the source content of the code block.
+        source: Source code in this code block.
+        origin: Original location in markup source.
+        language: Detected programming language.
+        header: (assumes `file` attribute) Content at the top of the code block
+            that should appear before the first comment line at the top of a
+            file (shebang or spdx license).
+        mode: (assumes `file` attribute) The access mode of the file being
+            written as a string in octal numbers. Example: "0755" to make a
+            file executable.
+        namespace: The namespace of the markup file from which the code block
+            was read.
+    """
+    properties: list[Property]
+    indent: str
+    open_line: str
+    close_line: str
+    source: str
+    origin: TextLocation
+    language: Language | None = None
+    header: str | None = None
+    mode: int | None = None
+    namespace: tuple[str, ...] = ()
+
+    @property
+    def text(self) -> str:
+        """
+        The unindented text that should be identical to the text from which the
+        code block was extracted.
+        """
+        return self.open_line + (self.header or "") + self.source + self.close_line
+
+    @property
+    def indented_text(self) -> str:
+        """
+        The text that should be identical to the text from which the code block was
+        extracted, including the indentation.
+        """
+        return indent(self.indent, self.text)
diff --git a/entangled/model/content.py b/entangled/model/content.py
new file mode 100644
index 0000000..a9b32ea
--- /dev/null
+++ b/entangled/model/content.py
@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from pathlib import PurePath
+from .code_block import CodeBlock
+from .reference_id import ReferenceId
+from .reference_map import ReferenceMap
+
+
+@dataclass
+class PlainText:
+    content: str
+
+
+type RawContent = PlainText | CodeBlock
+type Content = PlainText | ReferenceId
+
+
+def content_to_text(r: ReferenceMap, c: Content) -> tuple[str, PurePath | None]:
+    """
+    Reconstruct original plain text from a piece of content.
+
+    Args:
+        r: the reference map.
+        c: the content.
+
+    Returns:
+        A string, usually not terminated by a newline.
+    """
+    match c:
+        case PlainText(s):
+            return s, None
+        case ReferenceId():
+            code_block = r[c]
+            return code_block.indented_text, code_block.origin.filename
+
diff --git a/entangled/properties.py b/entangled/model/properties.py
similarity index 81%
rename from entangled/properties.py
rename to entangled/model/properties.py
index 2d160e0..1b63319 100644
--- a/entangled/properties.py
+++ b/entangled/model/properties.py
@@ -6,9 +6,10 @@
 from typing import Any, cast, override
 from collections.abc import Iterable
 from dataclasses import dataclass
+from typeguard import check_type
 
 
-from .parsing import (
+from ..parsing import (
     Parser,
     many,
     tokenize,
@@ -90,3 +91,22 @@ def get_attribute(props: list[Property], key: str) -> Any:  # pyright: ignore[re
         return next(p.value for p in props if isinstance(p, Attribute) and p.key == key)  # pyright: ignore[reportAny]
     except StopIteration:
         return None
+
+
+def get_attribute_string(props: list[Property], key: str) -> str | None:
+    x = get_attribute(props, key)
+    if x is None:
+        return None
+    if isinstance(x, str):
+        return x
+    raise TypeError()
+
+
+def get_typed_attribute[T](dtype: type[T], props: list[Property], key: str) -> T | None:
+    x = get_attribute(props, key)
+    if x is None:
+        return None
+    if isinstance(x, str) and dtype == list[str]:
+        return cast(T, x.split(","))
+    return check_type(x, dtype)
+
diff --git a/entangled/model/reference_id.py b/entangled/model/reference_id.py
new file mode 100644
index 0000000..397c7cd
--- /dev/null
+++ b/entangled/model/reference_id.py
@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from pathlib import PurePath
+from typing import override
+
+from .reference_name import ReferenceName
+
+
+@dataclass(frozen=True)
+class ReferenceId:
+    """
+    The `ReferenceId` is the main key type into the `ReferenceMap`, and
+    uniquely identifies a single code block.
+
+    Attributes:
+        name: Full qualified name of the reference.
+        file: The markup source file of this reference.
+        ref_count: The index within the source file, in case of repeated entries.
+            This index starts at 0 for each input file using the same name.
+    """
+    name: ReferenceName
+    file: PurePath
+    ref_count: int
+
+    @override
+    def __hash__(self) -> int:
+        return hash((self.name, self.file, self.ref_count))
+
+    @override
+    def __str__(self) -> str:
+        return f"{self.name}[{self.ref_count}]"
+
diff --git a/entangled/model/reference_map.py b/entangled/model/reference_map.py
new file mode 100644
index 0000000..00f5b8f
--- /dev/null
+++ b/entangled/model/reference_map.py
@@ -0,0 +1,102 @@
+from collections import defaultdict
+from collections.abc import Iterable, Iterator, MutableMapping
+from dataclasses import dataclass, field
+from pathlib import PurePath
+from typing import override
+
+
+from ..errors.internal import InternalError
+
+from .code_block import CodeBlock
+from .properties import get_attribute_string
+from .reference_id import ReferenceId
+from .reference_name import ReferenceName
+
+
+def length[T](seq: Iterable[T]) -> int:
+    """Compute the length of an iterable."""
+    i = 0
+    for _ in seq:
+        i += 1
+    return i
+
+
+@dataclass
+class ReferenceMap(MutableMapping[ReferenceId, CodeBlock]):
+    """
+    Members:
+        `map`: maps references to actual code block content
+        `root`: namespace root
+        `targets`: lists filenames; a target should be in `index`
+
+    The `ReferenceMap` implements `Mapping[ReferenceId, CodeBlock]`. In
+    addition to that, we keep an index on `ReferenceName`.
+    """
+
+    _map: dict[ReferenceId, CodeBlock] = field(default_factory=dict)
+    _index: defaultdict[ReferenceName, list[ReferenceId]] \
+        = field(default_factory=lambda: defaultdict(list))
+    _targets: dict[PurePath, ReferenceName] = field(default_factory=dict)
+
+    def select_by_name(self, name: ReferenceName) -> list[ReferenceId]:
+        """Return a list of references with the same name."""
+        return self._index[name]
+
+    def has_name(self, key: ReferenceName) -> bool:
+        """Check that a name is present."""
+        return key in self._index
+
+    def new_id(self, filename: PurePath, name: ReferenceName) -> ReferenceId:
+        """Create a new `ReferenceId` with a `ref_count` succeeding the last one
+        by the same name."""
+        c = length(filter(lambda r: r.file == filename, self._index[name]))
+        return ReferenceId(name, filename, c)
+
+    def select_by_target(self, target: PurePath) -> ReferenceName:
+        return self._targets[target]
+
+    def register_target(self, target: PurePath, ref_name: ReferenceName):
+        self._targets[target] = ref_name
+
+    def targets(self) -> Iterable[PurePath]:
+        return self._targets.keys()
+
+    @override
+    def __contains__(self, key: object) -> bool:
+        return key in self._map
+
+    @override
+    def __setitem__(self, key: ReferenceId, value: CodeBlock):
+        if key in self._map:
+            raise InternalError("Duplicate key in ReferenceMap", [key])
+        self._map[key] = value
+        self._index[key.name].append(key)
+
+        if filename := get_attribute_string(value.properties, "file"):
+            self._targets[PurePath(filename)] = key.name
+
+    @override
+    def __getitem__(self, key: ReferenceId) -> CodeBlock:
+        return self._map[key]
+
+    @override
+    def __delitem__(self, key: ReferenceId):
+        if key not in self:
+            return
+
+        value = self._map[key]
+        if filename := get_attribute_string(value.properties, "file"):
+            del self._targets[PurePath(filename)]
+        self._index[key.name].remove(key)
+        del self._map[key]
+
+    @override
+    def __len__(self) -> int:
+        return len(self._map)
+
+    @override
+    def __iter__(self) -> Iterator[ReferenceId]:
+        return iter(self._map)
+
+    def __bool__(self) -> bool:
+        return bool(self._map)
diff --git a/entangled/model/reference_name.py b/entangled/model/reference_name.py
new file mode 100644
index 0000000..4f270cf
--- /dev/null
+++ b/entangled/model/reference_name.py
@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import override
+
+
+@dataclass(frozen=True)
+class ReferenceName:
+    """
+    Collects the concepts of a namespace and name into one object.
+    """
+    namespace: tuple[str, ...]
+    name: str
+
+    @override
+    def __hash__(self) -> int:
+        return hash((*self.namespace, self.name))
+
+    @override
+    def __str__(self):
+        if self.namespace:
+            return "::".join(self.namespace) + "::" + self.name
+        else:
+            return self.name
+
+    @staticmethod
+    def from_str(name: str, namespace: tuple[str, ...] = ()) -> ReferenceName:
+        path = name.split("::")
+        if len(path) == 1:
+            return ReferenceName(namespace, name)
+        else:
+            return ReferenceName(tuple(path[:-1]), path[-1])
diff --git a/entangled/model/tangle.py b/entangled/model/tangle.py
new file mode 100644
index 0000000..262736f
--- /dev/null
+++ b/entangled/model/tangle.py
@@ -0,0 +1,154 @@
+from collections.abc import Callable, Generator, Iterator
+from dataclasses import dataclass, field
+from contextlib import contextmanager
+from pathlib import PurePath
+
+import re
+import os
+from typing import override
+
+
+from ..config import AnnotationMethod
+from ..iterators.lines import lines
+from ..errors.user import UserError
+from ..text_location import TextLocation
+
+from .reference_map import ReferenceMap
+from .reference_id import ReferenceId
+from .reference_name import ReferenceName
+
+
+@dataclass
+class CyclicReference(UserError):
+    ref_name: str
+    cycle: list[str]
+
+    @override
+    def __str__(self):
+        cycle_str = " -> ".join(self.cycle)
+        return f"Cyclic reference in <<{self.ref_name}>>: {cycle_str}"
+
+
+@dataclass
+class MissingReference(UserError):
+    origin: TextLocation
+    ref_name: ReferenceName
+
+    @override
+    def __str__(self):
+        return f"{self.origin}: Missing reference `{self.ref_name}`"
+
+
+@dataclass
+class MissingLanguageError(UserError):
+    origin: TextLocation
+
+    @override
+    def __str__(self):
+        return f"{self.origin}: Missing language for code block."
+
+
+@dataclass
+class Visitor[T]:
+    _visited: dict[T, int] = field(default_factory=dict)
+
+    def in_order(self) -> list[T]:
+        return [k for k, _ in sorted(self._visited.items(), key=lambda kv: kv[1])]
+
+    @contextmanager
+    def visit(self, x: T):
+        if x in self._visited:
+            raise CyclicReference(str(x), [str(r) for r in self.in_order()])
+        self._visited[x] = len(self._visited)
+        yield
+        del self._visited[x]
+
+
+type Deps = set[PurePath]
+type Tangler = Callable[[Tangler, Deps, ReferenceId, bool, bool], Iterator[str]]
+
+
+def indent(prefix: str, g: Iterator[str]) -> Iterator[str]:
+    return map(lambda line: "" if not line else prefix + line, g)
+
+
+def naked_tangler(refs: ReferenceMap) -> Tangler:
+    visitor: Visitor[ReferenceId] = Visitor()
+
+    def tangler(
+        recur: Tangler, deps: set[PurePath], ref: ReferenceId, skip_header: bool, _: bool
+    ) -> Generator[str]:
+        code_block = refs[ref]
+        deps.add(code_block.origin.filename)
+
+        if code_block.header and not skip_header:
+            yield code_block.header
+
+        with visitor.visit(ref):
+            for line in lines(code_block.source):
+                if m := re.match(r"^(?P<indent>\s*)<<(?P<refname>[\w:-]+)>>\s*$", line.rstrip()):
+                    ref_name = ReferenceName.from_str(m["refname"], code_block.namespace)
+                    if not refs.has_name(ref_name):
+                        raise MissingReference(code_block.origin, ref_name)
+                    ref_lst = refs.select_by_name(ref_name)
+                    yield from indent(m["indent"], recur(recur, deps, ref_lst[0], False, True))
+                    for ref in ref_lst[1:]:
+                        yield from indent(m["indent"], recur(recur, deps, ref, False, False))
+                else:
+                    yield line
+
+    return tangler
+
+
+def annotated_tangler(refs: ReferenceMap) -> Tangler:
+    naked = naked_tangler(refs)
+
+    def tangler(
+        recur: Tangler, deps: set[PurePath], ref: ReferenceId, skip_header: bool, first: bool
+    ) -> Generator[str]:
+        code_block = refs[ref]
+        if code_block.language is None:
+            raise MissingLanguageError(code_block.origin)
+
+        language = code_block.language
+        open_comment = language.comment.open
+        close_comment = (
+            "" if language.comment.close is None else f" {language.comment.close}"
+        )
+
+        if code_block.header and not skip_header:
+            yield code_block.header
+        ref_count_str = "init" if first else str(ref.ref_count)
+        yield f"{open_comment} ~/~ begin <<{ref.file.as_posix()}#{ref.name}>>[{ref_count_str}]{close_comment}\n"
+        yield from naked(recur, deps, ref, True, first)
+        yield f"{open_comment} ~/~ end{close_comment}\n"
+
+    return tangler
+
+
+tanglers = {
+    AnnotationMethod.NAKED: naked_tangler,
+    AnnotationMethod.STANDARD: annotated_tangler,
+    AnnotationMethod.SUPPLEMENTED: annotated_tangler,
+}
+
+
+def tangle_ref(
+    refs: ReferenceMap,
+    name: ReferenceName,
+    annotation: AnnotationMethod = AnnotationMethod.STANDARD,
+) -> tuple[str, set[PurePath]]:
+    if not refs.has_name(name):
+        raise KeyError(name)
+    tangler = tanglers[annotation](refs)
+    deps: set[PurePath] = set()
+    out = ""
+
+    ref_lst = refs.select_by_name(name)
+    for line in tangler(tangler, deps, ref_lst[0], False, True):
+        out += line
+    for ref in ref_lst[1:]:
+        for line in tangler(tangler, deps, ref, False, False):
+            out += line
+
+    return out, deps
diff --git a/entangled/readers/__init__.py b/entangled/readers/__init__.py
new file mode 100644
index 0000000..47cc541
--- /dev/null
+++ b/entangled/readers/__init__.py
@@ -0,0 +1,16 @@
+from pathlib import PurePath
+
+from .yaml_header import read_yaml_header
+from .markdown import process_token, collect_plain_text, raw_markdown
+from .code import read_top_level as code
+from ..iterators import numbered_lines, run_generator
+from .types import Reader, InputStream
+
+
+def run_reader[O, T](reader: Reader[O, T], inp: str, filename: str = "-") -> tuple[list[O], T]:
+    return run_generator(reader(numbered_lines(PurePath(filename), inp)))
+
+
+__all__ = ["read_yaml_header", "process_token", "collect_plain_text", "raw_markdown",
+           "code", "run_reader", "InputStream"]
+
diff --git a/entangled/readers/code.py b/entangled/readers/code.py
new file mode 100644
index 0000000..ef719f3
--- /dev/null
+++ b/entangled/readers/code.py
@@ -0,0 +1,100 @@
+from collections.abc import Generator
+from dataclasses import dataclass
+from pathlib import PurePath
+
+import re
+
+from .types import InputStream
+from ..model import ReferenceId, ReferenceName
+from ..errors.user import ParseError, IndentationError
+
+
+@dataclass
+class Block:
+    reference_id: ReferenceId
+    content: str
+
+
+OPEN_BLOCK_EXPR = r"^(?P<indent>\s*).* ~/~ begin <<(?P<source>[^#<>]+)#(?P<ref_name>[^#<>]+)>>\[(?P<ref_count>\d+|init)\]"
+
+
+@dataclass
+class OpenBlockData:
+    ref: ReferenceId
+    is_init: bool
+    indent: str
+
+
+def open_block(line: str) -> OpenBlockData | None:
+    if not (m := re.match(OPEN_BLOCK_EXPR, line)):
+        return None
+
+    ref_name = ReferenceName.from_str(m["ref_name"])
+    md_source = PurePath(m["source"])
+    is_init = m["ref_count"] == "init"
+    ref_count = 0 if is_init else int(m["ref_count"])
+    return OpenBlockData(ReferenceId(ref_name, md_source, ref_count), is_init, m["indent"])
+
+
+CLOSE_BLOCK_EXPR = r"^(?P<indent>\s*).* ~/~ end"
+
+
+@dataclass
+class CloseBlockData:
+    indent: str
+
+
+def close_block(line: str) -> CloseBlockData | None:
+    if not (m := re.match(CLOSE_BLOCK_EXPR, line)):
+        return None
+    return CloseBlockData(m["indent"])
+
+
+def read_top_level(input: InputStream) -> Generator[Block]:
+    if not input:
+        return
+
+    while input:
+        r = yield from read_block((), "", input)
+        if r is None:
+            _ = next(input)
+
+
+def read_block(namespace: tuple[str, ...], indent: str, input: InputStream) -> Generator[Block, None, str | None]:
+    if not input:
+        return None
+
+    pos, line1 = input.peek()
+    if (block_data := open_block(line1)) is None:
+        return None
+    _ = next(input)
+    if block_data.indent < indent:
+        raise IndentationError(pos)
+
+    content = ""
+    while input:
+        line = yield from read_block(block_data.ref.name.namespace, block_data.indent, input)
+        if line is not None:
+            content += line
+            continue
+
+        pos, line = next(input)
+        if (close_block_data := close_block(line)) is None:
+            if not line.startswith(block_data.indent):
+                raise IndentationError(pos)
+            content += line.removeprefix(block_data.indent)
+        else:
+            if close_block_data.indent != block_data.indent:
+                raise IndentationError(pos)
+            yield Block(block_data.ref, content)
+
+            if block_data.is_init:
+                extra_indent = block_data.indent.removeprefix(indent)
+                ref = block_data.ref
+                ref_str = ref.name if ref.name.namespace == namespace else str(ref.name)
+                return f"{extra_indent}<<{ref_str}>>\n"
+            else:
+                return ""
+
+    raise ParseError(pos, "unexpected end of file")
+
diff --git a/entangled/readers/delimiters.py b/entangled/readers/delimiters.py
new file mode 100644
index 0000000..8fcef95
--- /dev/null
+++ b/entangled/readers/delimiters.py
@@ -0,0 +1,91 @@
+from dataclasses import dataclass
+from collections.abc import Callable
+
+import re
+
+from ..text_location import TextLocation
+from .types import InputStream
+from ..errors.user import ParseError
+
+
+@dataclass
+class DelimitedToken:
+    origin: TextLocation
+    open_line: str
+    open_match: re.Match[str]
+    content: str
+    close_line: str
+    close_match: re.Match[str]
+
+    @property
+    def string(self) -> str:
+        """
+        Reconstructs the original input string.
+        """
+        return self.open_line + self.content + self.close_line
+
+
+def const[T, **Args](value: T) -> Callable[Args, T]:
+    def const_fn(*_1: Args.args, **_2: Args.kwargs) -> T:
+        return value
+    return const_fn
+
+
+type DelimiterGuard = Callable[[TextLocation, re.Match[str], re.Match[str]], bool]
+
+
+def delimited_token_getter(
+        open: str,
+        close: str,
+        guard: DelimiterGuard | None = None
+    ) -> Callable[[InputStream], DelimitedToken | None]:
+    """
+    Creates a function that reads a given `DelimitedToken` from
+    the input stream or returns `None` if the stream does not start
+    with a match for the opening pattern.
+
+    Args:
+        open: a regex on which the token is triggered
+        close: a regex on which the enclosed content is closed
+        guard: an optional predicate for additional check on close pattern
+
+    Returns:
+        A `DelimitedToken` object containing the text location of
+        the token, the `re.Match` objects for both opening and closing
+        patterns, and the contained text.
+
+    The first line in the input stream is peeked. If it does not match
+    the `open` expression, `None` is returned. Otherwise the lines
+    upto and including the closing expression are consumed.
+    """
+    open_pattern = re.compile(open)
+    close_pattern = re.compile(close)
+    guard_fn: DelimiterGuard = guard or const(True)
+
+    def get(input: InputStream) -> DelimitedToken | None:
+        if not input:
+            return None
+
+        origin, open_line = input.peek()
+        open_match = open_pattern.match(open_line.rstrip())
+        if not open_match:
+            return None
+
+        _ = next(input)
+        content = ""
+
+        # We consumed the single buffered token, so we can
+        # iterate directly from the inner iterator.
+        for _, line in input.iterator:
+            close_match = close_pattern.match(line.rstrip())
+            if not close_match or not guard_fn(origin, open_match, close_match):
+                content += line
+            else:
+                close_line = line
+                return DelimitedToken(
+                    origin, open_line, open_match,
+                    content, close_line, close_match)
+
+        raise ParseError(origin, "unexpected end of file")
+
+    return get
diff --git a/entangled/readers/markdown.py b/entangled/readers/markdown.py
new file mode 100644
index 0000000..724fc45
--- /dev/null
+++ b/entangled/readers/markdown.py
@@ -0,0 +1,174 @@
+from collections.abc import Generator, Iterator
+from functools import partial
+
+from ..config.namespace_default import NamespaceDefault
+
+from ..model import CodeBlock, Content, RawContent, PlainText, ReferenceId, ReferenceMap, ReferenceName
+from ..model.properties import get_attribute_string, get_attribute, read_properties, get_classes, get_id
+from ..config import Config
+from ..errors.user import CodeAttributeError, IndentationError
+from ..utility import first
+from ..iterators.lines import lines
+from ..text_location import TextLocation
+from ..hooks import HookBase
+
+from .types import InputStream, Reader, RawMarkdownStream
+from .delimiters import delimited_token_getter
+from .yaml_header import read_yaml_header, get_config
+
+import re
+import logging
+
+
+def ignore_block(config: Config) -> Reader[RawContent, bool]:
+    get_raw_token = delimited_token_getter(
+        config.markers.begin_ignore, config.markers.end_ignore
+    )
+
+    def ignore_block_reader(input: InputStream) -> RawMarkdownStream[bool]:
+        block = get_raw_token(input)
+        if block is None:
+            return False
+        yield PlainText(block.string)
+        return True
+
+    return ignore_block_reader
+
+
+def code_block_guard(origin: TextLocation, open_match: re.Match[str], close_match: re.Match[str]) -> bool:
+    open_indent = open_match["indent"]
+    close_indent = close_match["indent"]
+    if len(close_indent) < len(open_indent):
+        raise IndentationError(origin)
+    if open_indent != close_indent:
+        return False
+    return True
+
+
+def dedent_line(location: TextLocation, indent: str, line: str):
+    if line.startswith(indent) or line.strip() == "":
+        return line.removeprefix(indent)
+    raise IndentationError(location)
+
+
+def dedent(location: TextLocation, source: str, indent: str) -> str:
+    return "".join(dedent_line(location, indent, line) for line in lines(source))
+
+
+def code_block(config: Config) -> Reader[RawContent, bool]:
+    get_raw_token = delimited_token_getter(
+        config.markers.open, config.markers.close, code_block_guard)
+
+    def code_block_reader(input: InputStream) -> RawMarkdownStream[bool]:
+        if not input:
+            return False
+
+        block = get_raw_token(input)
+        if block is None:
+            return False
+
+        if config.namespace is None:
+            match config.namespace_default:
+                case NamespaceDefault.GLOBAL:
+                    namespace: tuple[str, ...] = ()
+                case NamespaceDefault.PRIVATE:
+                    namespace = (block.origin.filename.as_posix(),)
+        else:
+            namespace = config.namespace
+
+        indent = block.open_match["indent"]
+        properties = read_properties(block.open_match["properties"])
+        language_class = first(get_classes(properties))
+        language = config.get_language(language_class) if language_class else None
+        if language_class and not language:
+            logging.warning(f"`{block.origin}`: language `{language_class}` unknown.")
+        source = dedent(block.origin, block.content, indent)
+
+        yield CodeBlock(
+            properties,
+            indent,
+            block.open_line.removeprefix(indent),
+            block.close_line.removeprefix(indent),
+            source,
+            block.origin,
+            language,
+            namespace = namespace
+        )
+
+        return True
+
+    return code_block_reader
+
+
+def raw_markdown(config: Config, input: InputStream) -> RawMarkdownStream[None]:
+    if not input:
+        return
+
+    ignore_block_reader = ignore_block(config)
+    code_block_reader = code_block(config)
+
+    while input:
+        if (yield from ignore_block_reader(input)):
+            continue
+        if (yield from code_block_reader(input)):
+            continue
+
+        _, line = next(input)
+        yield PlainText(line)
+
+
+def process_code_block(hooks: list[HookBase], refs: ReferenceMap, code_block: CodeBlock) -> ReferenceId:
+    for h in hooks:
+        h.on_read(code_block)
+
+    block_id = get_id(code_block.properties)
+
+    try:
+        target_file = get_attribute_string(code_block.properties, "file")
+    except TypeError:
+        raise CodeAttributeError(code_block.origin, "`file` attribute should have string type")
+
+    if mode := get_attribute(code_block.properties, "mode"):
+        if type(mode) is int:   # bool is a subtype of int, and we really want an int
+            code_block.mode = mode
+        elif isinstance(mode, str):
+            code_block.mode = int(mode, 8)
+        else:
+            raise CodeAttributeError(code_block.origin, "`mode` attribute should have string or integer type")
+
+    ref_name = block_id or target_file
+    if ref_name is None:
+        ref_name = f"unnamed-{code_block.origin}"
+    ref = refs.new_id(code_block.origin.filename, ReferenceName(code_block.namespace, ref_name))
+    refs[ref] = code_block
+
+    return ref
+
+
+def process_token(hooks: list[HookBase], refs: ReferenceMap, token: RawContent) -> Content:
+    match token:
+        case CodeBlock():
+            return process_code_block(hooks, refs, token)
+        case _:
+            return token
+
+
+def collect_plain_text[T](inp: Iterator[PlainText | T]) -> Generator[PlainText | T, None, None]:
+    plain_content: list[str] = []
+
+    def flush():
+        nonlocal plain_content
+        if plain_content:
+            yield(PlainText("".join(plain_content)))
+            plain_content = []
+
+    for token in inp:
+        match token:
+            case PlainText(t):
+                plain_content.append(t)
+            case _:
+                yield from flush()
+                yield token
+
+    yield from flush()
+
diff --git a/entangled/readers/types.py b/entangled/readers/types.py
new file mode 100644
index 0000000..4d4e76a
--- /dev/null
+++ b/entangled/readers/types.py
@@ -0,0 +1,14 @@
+from collections.abc import Callable, Generator
+
+from ..text_location import TextLocation
+from ..iterators.peekable import Peekable
+from ..model import Content, RawContent
+
+
+type InputToken = tuple[TextLocation, str]
+type InputStream = Peekable[InputToken]
+type Reader[OutputToken, Result] = Callable[[InputStream], Generator[OutputToken, None, Result]]
+type RawMarkdownStream[Result] = Generator[RawContent, None, Result]
+type MarkdownStream[Result] = Generator[Content, None, Result]
+
+
diff --git a/entangled/readers/yaml_header.py b/entangled/readers/yaml_header.py
new file mode 100644
index 0000000..aa45c06
--- /dev/null
+++ b/entangled/readers/yaml_header.py
@@ -0,0 +1,56 @@
+from typing import cast
+
+import logging
+import yaml
+import msgspec
+
+from ..config import Config, ConfigUpdate
+from ..model import PlainText
+from ..errors.user import ParseError, HelpfulUserError
+from .types import InputStream, MarkdownStream
+from .delimiters import delimited_token_getter
+
+
+get_yaml_header_token = delimited_token_getter("---", "---")
+
+
+def read_yaml_header(input: InputStream) -> MarkdownStream[object]:
+    """
+    Reads the YAML header that can be found at the top of a Markdown document.
+    """
+    delimited_token = get_yaml_header_token(input)
+    if delimited_token is None:
+        return None
+
+    yield PlainText(delimited_token.string)
+
+    try:
+        return yaml.safe_load(delimited_token.content)  # pyright: ignore[reportAny]
+    except yaml.YAMLError as e:
+        raise ParseError(delimited_token.origin, str(e))
+
+
+def get_config(header: object) -> ConfigUpdate | None:
+    """
+    Get the `entangled` component from the unstructured header data,
+    and convert it to a `Config` object.
+
+    If there was no YAML header or it contained no `entangled` member,
+    this will return `None`. If the given YAML header evaluated to something
+    other than an object/dictionary or the conversion to `Config` failed,
+    a `TypeError` is raised.
+    """
+    if isinstance(header, dict):
+        header = cast(dict[str, object], header)
+        if "entangled" not in header:
+            return None
+        try:
+            return msgspec.convert(header.get("entangled", None), ConfigUpdate)
+        except msgspec.ValidationError as e:
+            logging.error(e)
+            raise HelpfulUserError("unable to read config")
+
+    elif header is None:
+        return None
+    else:
+        raise HelpfulUserError(f"expected an object for config, got {type(header)}: {header}")
diff --git a/entangled/status.py b/entangled/status.py
index 279b4cb..db9f898 100644
--- a/entangled/status.py
+++ b/entangled/status.py
@@ -1,8 +1,7 @@
 from collections.abc import Iterable
-from .config import config
 from .io import filedb
+from .config import get_input_files, Config, read_config
 
-from itertools import chain
 from pathlib import Path
 
 
@@ -19,22 +18,14 @@ def safe_glob(pattern: str) -> Iterable[Path]:
 
 def find_watch_dirs():
     """List all directories that contain files that need watching."""
-    input_file_list = list_input_files()
+    cfg = Config() | read_config()
+    input_file_list = get_input_files(cfg)
     markdown_dirs = set(p.parent for p in input_file_list)
     with filedb(readonly=True) as db:
         code_dirs = set(p.parent for p in db.managed_files)
     return code_dirs.union(markdown_dirs)
 
 
-def list_input_files():
-    """List all input files."""
-    include_file_list = chain.from_iterable(map(safe_glob, config.get.watch_list))
-    exclude_file_list = list(
-        chain.from_iterable(map(safe_glob, config.get.ignore_list))
-    )
-    return [path for path in include_file_list if not path in exclude_file_list]
-
-
 def list_dependent_files():
     with filedb(readonly=True) as db:
         result = list(db.managed_files)
diff --git a/entangled/tangle.py b/entangled/tangle.py
deleted file mode 100644
index 9c04c37..0000000
--- a/entangled/tangle.py
+++ /dev/null
@@ -1,153 +0,0 @@
-from typing import TypeVar, Generic, override
-from dataclasses import dataclass, field
-from textwrap import indent
-from contextlib import contextmanager
-from copy import copy
-from pathlib import PurePath
-
-import re
-import mawk
-
-from .config import AnnotationMethod
-from .text_location import TextLocation
-from .document import (
-    ReferenceMap,
-    ReferenceId,
-    CodeBlock,
-)
-from .errors.user import CyclicReference, MissingReference
-from .config import config
-
-
-T = TypeVar("T")
-
-
-@dataclass
-class Visitor(Generic[T]):
-    _visited: dict[T, int] = field(default_factory=dict)
-
-    def in_order(self) -> list[T]:
-        return [k for k, _ in sorted(self._visited.items(), key=lambda kv: kv[1])]
-
-    @contextmanager
-    def visit(self, x: T):
-        if x in self._visited:
-            raise CyclicReference(str(x), list(map(str, self.in_order())))
-        self._visited[x] = len(self._visited)
-        yield
-        del self._visited[x]
-
-
-@dataclass
-class Tangler(mawk.RuleSet):
-    refs: ReferenceMap
-    ref: ReferenceId
-    init: bool
-    visited: Visitor[str]
-    deps: set[PurePath] = field(init=False)
-    cb: CodeBlock = field(init=False)
-    location: TextLocation = field(init=False)
-
-    def __post_init__(self):
-        self.cb = self.refs.get_codeblock(self.ref)
-        self.location = copy(self.cb.origin)
-        self.deps = { self.cb.origin.filename }
-
-    @mawk.always
-    def lineno(self, _):
-        self.location.line_number += 1
-
-    @override
-    def on_begin(self) -> list[str]:
-        if self.cb.header is not None:
-            return [self.cb.header]
-        else:
-            return []
-
-    @mawk.on_match(r"^(?P<indent>\s*)<<(?P<refname>[\w-]+)>>\s*$")
-    def on_noweb(self, m: re.Match[str]) -> list[str]:
-        try:
-            result, deps = tangle_ref(self.refs, m["refname"], type(self), self.visited)
-
-        except KeyError:
-            raise MissingReference(m["refname"], self.location)
-
-        self.deps.update(deps)
-        return [indent(result, m["indent"])]
-
-    def tangle(self):
-        return super().run(self.cb.source)
-
-
-@dataclass
-class AnnotatedTangler(Tangler):
-    close_comment: str = field(init=False)
-
-    def __post_init__(self):
-        super().__post_init__()
-        assert self.cb.language
-        self.close_comment = (
-            ""
-            if self.cb.language.comment.close is None
-            else f" {self.cb.language.comment.close}"
-        )
-
-    @override
-    def on_begin(self) -> list[str]:
-        assert self.cb.language
-        count = "init" if self.init else str(self.ref.ref_count)
-        result: list[str] = []
-        if self.cb.header is not None:
-            result.append(self.cb.header)
-        result.append(
-            f"{self.cb.language.comment.open} ~/~ begin <<{self.ref.file.as_posix()}#{self.ref.name}>>[{count}]{self.close_comment}"
-        )
-        return result
-
-    @override
-    def on_eof(self):
-        assert self.cb.language
-        return [f"{self.cb.language.comment.open} ~/~ end{self.close_comment}"]
-
-
-tanglers = {
-    AnnotationMethod.NAKED: Tangler,
-    AnnotationMethod.STANDARD: AnnotatedTangler,
-    AnnotationMethod.SUPPLEMENTED: AnnotatedTangler,
-}
-
-
-def tangle_ref(
-    refs: ReferenceMap,
-    ref_name: str,
-    annotation: type[Tangler] | AnnotationMethod | None = None,
-    _visited: Visitor[str] | None = None,
-) -> tuple[str, set[PurePath]]:
-    if annotation is None:
-        annotation = config.get.annotation
-
-    if ref_name in refs.alias:
-        ref_name = refs.alias[ref_name]
-
-    if ref_name not in refs:
-        raise KeyError(ref_name)
-    v = _visited or Visitor()
-
-    if isinstance(annotation, AnnotationMethod):
-        tangler = tanglers[annotation]
-    elif annotation is not None:
-        tangler = annotation
-    else:
-        raise ValueError("impossible code path")
-
-    with v.visit(ref_name):
-        init = True
-        result: list[str] = []
-        deps: set[PurePath] = set()
-        for ref in refs.index[ref_name]:
-            t = tangler(refs, ref, init, v)
-            result.append(t.tangle())
-            deps.update(t.deps)
-            init = False
-
-    return "\n".join(result), deps
diff --git a/entangled/text_location.py b/entangled/text_location.py
index 36f96ff..531aa90 100644
--- a/entangled/text_location.py
+++ b/entangled/text_location.py
@@ -2,11 +2,20 @@
 from pathlib import PurePath
 from typing import override
 
+
 @dataclass
 class TextLocation:
+    """
+    A dataclass to indicate the origin of a line. Because this is only used for
+    interfacing with humans, the filename is stored as a string, and line numbers
+    start at one.
+    """
     filename: PurePath
-    line_number: int = 0
+    line_number: int = 1
+
+    def increment(self):
+        self.line_number += 1
 
     @override
-    def __str__(self) -> str:
+    def __str__(self):
         return f"{self.filename}:{self.line_number}"
diff --git a/examples/.gitignore b/examples/.gitignore
new file mode 100644
index 0000000..efb682c
--- /dev/null
+++ b/examples/.gitignore
@@ -0,0 +1,2 @@
+**/.entangled/*
+
diff --git a/examples/cards-game/README.md b/examples/cards-game/README.md
new file mode 100644
index 0000000..15d5bfe
--- /dev/null
+++ b/examples/cards-game/README.md
@@ -0,0 +1,444 @@
+---
+entangled:
+    version: "2.4"
+    style: basic
+---
+
+A Silly Card Game
+=================
+
+Implements a silly game, counting how many cards we need to draw before reaching a Black Jack score of 42, counting aces as one point. This example uses principles from functional programming to solve this problem. Often introductions to functional programming emphasise the concept of immutability but not that of expressibility.
+
+This code demonstrates several principles (not all isolated to functional programming!):
+
+- **No illegal data.** Choose a type to represent your data that makes it
+  illegal to express illegal states. In this case we go the extra mile to
+  implement a `Card` data type composed of a `Suit` and `Kind` enum.
+- **Use dataclasses.** we define types to combine data meaningfully.
+  Preferably, a dataclass should be `frozen` to enforce immutability.
+- **Small functions that are (mostly) pure.** every function has a single
+  responsibility.
+- **Use iterators/generators to compute sequences lazily.** This is part of a
+  general tendency in functional programming to blur the boundary between
+  data and code. Generators are data masquerading as code. Python's
+  generator syntax makes this sort of programming particularly pretty.
+- **Encapsulated mutability.** In the `shuffled_deck` function, we use in-place
+  mutability of a list of cards, but this mutability is encapsulated to
+  that function.
+- **Use generic elemental functions that combine into more complex behaviour.**
+  Specifically, we use `accumulate`, `zip`, `map` and `enumerate` to
+  manipulate iterators.
+
+The game
+--------
+
+The problem is as follows: we have a stack of playing cards. Numbered cards have the value of their number (one through ten), and picture cards (Jack, Queen and King) have a value of ten. We keep drawing cards from the deck until we reach a value of 42 or higher. How many times do you need to draw a card?
+
+The following Python code sets up a Monte-Carlo experiment:
+
+```python
+import random
+
+def run_game() -> int:
+    deck = list(range(52))
+    random.shuffle(deck)
+    total = 0
+    count = 0
+
+    for card in deck:
+        count += 1
+
+        if card % 13 >= 10:
+            value = 10
+        else:
+            value = card % 13 + 1
+
+        total += value
+
+        if total >= 42:
+            return count
+```
+
+We can run the `run_game` function multiple times to build statistics. This code has several issues. For one, it comes straight out of the Fortran programmers handbook! Jokes asside, what are the problems here?
+
+- The code is hard to read. What do we mean by that? Some would claim that this is some of the most readable code out there! Well, the control-flow and logic are very clear, however not so our intent.
+- The code is hard to test. If there is an issue with this code somewhere, it is not so easy to spot, and since the function is monolithic, we can't test different parts for their logic.
+
+We might modularize the code and use better variable names to improve things a bit. Also, we can use some of the idioms in Python.
+
+```python
+def shuffled_deck() -> list[int]:
+    deck = range(52)
+    random.shuffle(deck)
+    return deck
+
+def card_value(card: int) -> int:
+    if card % 13 >= 10:
+        return 10
+    else:
+        return card % 13 + 1
+
+def run_game_2() -> int:
+    deck = shuffled_deck()
+
+    total = 0
+    for i, card in enumerate(deck, start=1):
+        total += card_value(card)
+        if total >= 42:
+            return i
+```
+
+Here we've used the `enumerate` function to create an enumerated for-loop, instead of hand-counting the number of cards, and moved some parts to separate functions. Things have improved now, but this is still nowhere near what a functional programmer would do. What follows now will feel silly for this problem, but it isn't there to solve the problem, it is there to teach you ways to think that you might not have seen before.
+
+Data representation
+-------------------
+
+In the previous example we represented our cards as integers. This is efficient, but it doesn't communicate what the logic in our program is about. You should prefer data structures that make it obvious what the data means and that make it impossible to represent states that should not exist. Enters the `enum` and the `dataclass`.
+
+```python
+#| file: src/cards_game/card.py
+from enum import Enum, StrEnum
+from dataclasses import dataclass
+
+
+class Suit(StrEnum):
+    SPADES = "spades"
+    CLOVES = "cloves"
+    HEARTS = "hearts"
+    DIAMONDS = "diamonds"
+
+    def __repr__(self) -> str:
+        return self.name[0]
+
+
+class Kind(Enum):
+    ACE = 1
+    TWO = 2
+    THREE = 3
+    FOUR = 4
+    FIVE = 5
+    SIX = 6
+    SEVEN = 7
+    EIGHT = 8
+    NINE = 9
+    TEN = 10
+    JACK = 11
+    QUEEN = 12
+    KING = 13
+
+    def __repr__(self) -> str:
+        if self.value <= 10:
+            return str(self.value)
+        else:
+            return self.name[0]
+
+
+@dataclass(frozen = True)
+class Card:
+    suit: Suit
+    kind: Kind
+
+    def __repr__(self) -> str:
+        return repr(self.suit) + repr(self.kind)
+```
+
+Yes, this is extremely verbose, but hey, now you can reuse the `Card` type when you feel like programming other card games! This demonstrates two types of enum in Python: the classic numeric enum, and the `StrEnum` that is backed by internal string values. Python has a way of optimizing short strings that are used as identifiers, so don't worry about efficiency here, worry about what makes sense!
+
+We could've implemented a method on the `Card` type to give us a card's value in the game of Black Jack, but this value is more a property of the game of Black Jack than that of the card itself. We keep the class empty and clean.
+
+### Note on using `__repr__`
+
+The `Suit`, `Kind`, and `Card` classes implement the `__repr__` method to get a nice representation in a Python REPL. In production code it is desirable that the `__repr__` method returns a representation of an
+object that would evaluate back to the original object, so:
+
+```python
+assert eval(repr(obj)) == obj
+```
+
+should always hold. Here that principle is violated for convenience.
+
+Encapsulating mutable state
+---------------------------
+
+Next we need to generate a deck of cards and shuffle it.
+
+```python
+def sorted_deck() -> Generator[Card]:
+    for suit in Suit:
+        for kind in Kind:
+            yield Card(suit, kind)
+```
+
+The `sorted_deck` function is a little **gem** of the Python language. In as few words as it would take to describe what it does, we have an implementation that is both readable and efficient. Seeing and writing functions like this should release a small dose of dopamine in your brain. If we would write this function in completely functional style, we get a function that is short, powerful, but arguably less "Pythonic".
+
+```python
+#| id: deck
+#| file: src/cards_game/deck.py
+from collections.abc import Iterator
+from itertools import starmap, product
+import random
+
+from .card import Suit, Kind, Card
+
+def sorted_deck() -> Iterator[Card]:
+    return starmap(Card, product(Suit, Kind))
+```
+
+To shuffle the deck we need to store it in a list, then call `random.shuffle`, which shuffles items in a list in-place, and return it.
+
+```python
+#| id: deck
+def shuffled_deck() -> list[Card]:
+    deck = list(sorted_deck())
+    random.shuffle(deck)
+    return deck
+```
+
+Here we used a mutating procedure, but it is encapsulated in a small function, so it won't affect the logic beyond the confines of this function.
+
+Higher order functions
+----------------------
+
+The `map`, `reduce` (better known as *fold*), `filter`, and similar functions are collectively known as *higher order functions*. This means that they take smaller functions as their input to produce more complex behaviour.
+
+The advantages of this approach are not as self-evident as some of the others in this tutorial. Often, writing code in terms of simple for-loops can be more readable. In a sense this is a good thing. The designers of Python found these patterns so important that they made syntax like list-comprehensions and generators, just to make this easier. What is important is that, as a programmer, you learn to think in terms of these abstract operations on sequences. Then, when you need to handle data that is a bit larger, you can abstract over these operations.
+
+Advantages of `itertools` functions over hand-rolling a loop:
+
+- **robustness**. You have a smaller chance of introducing subtle bugs.
+- **scalability**. If you need to scale up, you can consider using libraries like Dask to handle the computation.
+- **composability**. These routines form a kind of mini-language (also known as a domain-specific language or DSL) that allow for components to be reused and combined in new ways.
+
+Disadvantages or possible traps are:
+
+- **readability**. This can go either way. The danger is that when you start using `itertools` and relatives in earnest, you'll be tempted to go all-the-way, resulting in code that is very hard to read, especially for peers that don't use `itertools` every day.
+- **mental overhead**. For many programmers, remembering what each and every iterator adaptor is doing can be a burden. In this tutorial we use only a few functions, but checkout the [`more-itertools` package](https://more-itertools.readthedocs.io/en/stable/).
+- **off-by-one**. Many of these functions are variations on a theme. For instance, we'll use the `takewhile` function from `itertools`, but you might also want a version of that function that also includes the first item that fails the test. There is a `takewhile_inclusive` variant in `more-itertools`, but you don't need that if you roll your own generator.
+
+With that discussion out of the way, we'll now implement the rest of the game with maximum utilisation of the `itertools` library.
+
+One-liners
+----------
+
+```python
+#| id: forty-two
+#| file: src/cards_game/forty_two.py
+from .card import Card
+from collections.abc import Generator, Iterable
+from functools import reduce
+from dataclasses import dataclass
+from enum import Enum, StrEnum
+from itertools import accumulate, takewhile, repeat, starmap, product
+from collections import defaultdict
+```
+
+The functional programmer prefers all their functions to be one liners. This is also why they detest any control-flow like `for` loops and `if` statements. Sometimes though, it can't be helped: the `if` statement is a necessary part of any Turing complete system. Luckily, we have the ternary expression (no matter how ugly it is in Python).
+
+```python
+#| id: forty-two
+def black_jack_min_value(card: Card) -> int:
+    return card.kind.value if card.kind.value < 10 else 10
+```
+
+We'll define a little accumulator function to keep the score:
+
+```python
+#| id: forty-two
+def keep_score(score: int, card: Card) -> int:
+    return score + black_jack_min_value(card)
+```
+
+And a predicate (a function of one argument returning a `bool`) to indicate the end of the game:
+
+```python
+#| id: forty-two
+def game_continues(score: int) -> bool:
+    return score < 42
+```
+
+Now, to run the game, we have another one-liner:
+
+```python
+#| id: forty-two
+def run_game(deck: Iterable[Card]) -> Iterable[int]:
+    return takewhile(game_continues, accumulate(deck, keep_score, initial=0))
+```
+
+Now, that almost reads as plain English!
+
+Folding
+-------
+
+The `run_game` function is a one-liner. This is only possible because we carefully designed the `keep_score` function to fit in the *foldable* design pattern. The `keep_score` function takes a state and an update as input, and returns a new state:
+
+```python
+def update(s: State, ds: Delta) -> State:
+    pass
+```
+
+When we can model the progress of a game in such a function, we gain access to a plethora of *reducing* or *folding* functions:
+
+```python
+def fold[S, D](update: Callable[[S, D], S], iter: Iterable[D], state: S) -> S:
+    for item in iter:
+        state = update(state, item)
+    return state
+```
+
+In this case, we can use `itertools.accumulate` that yields intermediate results as well.
+
+Getting answers
+---------------
+
+To get a usable answer, we need two more one-liners.
+
+```python
+#| id: forty-two
+def length[T](iter: Iterable[T]) -> int:
+    return sum(1 for _ in iter)
+     
+def trace_game(deck: Iterable[Card]) -> list[tuple[Card, int]]:
+    return list(zip(deck, run_game(deck)))
+
+def trial() -> int:
+    return length(run_game(shuffled_deck()))
+
+def experiment(n: int) -> Iterable[int]:
+    return starmap(trial, repeat((), n))
+
+def histogram[T](iter: Iterable[T]) -> defaultdict[T, int]:
+    def tally[T](hist: defaultdict[T, int], item: T) -> defaultdict[T, int]:
+        hist[item] += 1
+        return hist
+
+    return reduce(tally, iter, defaultdict(lambda: 0))
+```
+
+The exact answer
+----------------
+
+As a little extra: what are the complete statistics of this game? We have 52 cards. At a minimum we need to draw five of them to get to 42 points, and at most 17 cards ($4 \times (1 + 2 + 3 + 4) + 5 = 45$), so that leaves between 311875200 and 7805769880904240998072320000 combinations to compute!
+
+Problems like these lend themselves really well to a technique called *dynamic programming*. That sounds fancy, but what it means is that we cache computations (also known as *memoization*) to speed things up. The `functools` library has a `cache` decorator.
+
+As a first example, we look at the factorial function. We put a print-statement in there to see when the function is being evaluated:
+
+```python
+from functools import cache
+
+@cache
+def factorial(x):
+    print(f"computing {x}!")
+    if n == 0:
+        return 1
+    return n * factorial(n - 1)
+```
+
+> [!TIP]
+> ### Exercise: compute the binomial coefficient
+> The binomial coefficient can be defined by the recursion,
+>
+> $$\binom{n}{k} = \binom{n-1}{k-1} + \binom{n-1}{k},$$
+>
+> with the base cases,
+>
+> $$\binom{n}{0} = 1\quad\textrm{and}\binom{n}{n} = 1.$$
+>
+> Implement this recursion with a cached function. Tip: the binomial coefficent has a symmetry that can make your implementation even more efficient,
+>
+> $$\binom{n}{k} = \binom{n}{n - k}.$$
+>
+> <details markdown=1><summary>Solution</summary>
+>
+> ```python
+> @cache
+> def binomial_coefficient(a: int, b: int) -> int:
+>     if b > a:
+>         return 0
+>     if a == 0:
+>         return 1
+>     if b > (a // 2):
+>         return binomial_coefficient(a, a - b)
+>     return binomial_coefficient(a-1, b-1) + binomial_coefficient(a-1, b)
+> ```
+>
+> </details>
+
+```python
+#| file: src/cards_game/exact.py
+from __future__ import annotations
+
+from collections.abc import Generator, Iterable
+from dataclasses import dataclass, field
+from functools import cache
+from copy import copy
+import numpy as np
+import numpy.typing as npt
+
+
+type UIntArray = npt.NDArray[np.uint64]
+type FloatArray = npt.NDArray[np.float64]
+
+
+MAX_HAND: UIntArray = np.array([4] * 9 + [16], dtype=np.uint64)
+HIST_SIZE: int = 13
+HIST_OFFSET: int = 5
+
+
+def histogram_zero() -> FloatArray:
+    return np.zeros(HIST_SIZE, dtype=np.float64)
+
+
+def histogram_singleton(n: int) -> FloatArray:
+    h = histogram_zero()
+    h[n - HIST_OFFSET] = 1
+    return h
+
+
+@dataclass
+class Hand:
+    n_cards: int = 0
+    score: int = 0
+    counts: IntArray = field(default_factory=lambda: np.zeros(10, dtype=np.uint64))
+
+    def __hash__(self) -> int:
+        h = 0
+        for (i, n) in enumerate(self.counts):
+            h |= int(n) << (3 * i)
+        return h
+
+    def __eq__(self, other) -> bool:
+        return (self.counts == other.counts).all()
+
+    def draw(self) -> Generator[tuple[int, Hand]]:
+        """Generates new hands with multiplicity."""
+        for i in range(len(self.counts)):
+            n = self.counts[i]
+            m = MAX_HAND[i]
+            if n < m:
+                c = copy(self.counts)
+                c[i] += 1
+                yield (m - n, Hand(self.n_cards + 1, self.score + i + 1, c))
+
+
+def compute_dist():
+    cache: dict[int, FloatArray] = dict()
+
+    def run(h: Hand) -> FloatArray:
+        x = hash(h)
+        if x not in cache:
+            if h.score >= 42:
+                cache[x] = histogram_singleton(h.n_cards)
+            else:
+                cache[x] = (1.0 / (52 - h.n_cards)) * sum((m * compute_dist(x, h2) \
+                    for (m, h2) in h.draw()), histogram_zero())
+        return cache[x]
+
+    return run(Hand())
+```
+
+Conclusion
+----------
+
+Python is a very flexible language, and it allows us to write some beautiful functional code. However, the language was not designed to be functional to this extend. Overuse of these techniques will negatively affect readability. The conclusion should be: there are times when to use and times when not to use this, and there is no golden rule that can tell you when that is. Go, and scroll up towards the crappy quasi-fortran discombobulation that we started with, and compare with the exquisite beauty we have crafted from it. Somehow, I'm still not sure which is better or worse.
+
diff --git a/examples/cards-game/src/cards_game/card.py b/examples/cards-game/src/cards_game/card.py
new file mode 100644
index 0000000..66df84c
--- /dev/null
+++ b/examples/cards-game/src/cards_game/card.py
@@ -0,0 +1,45 @@
+# ~/~ begin <<README.md#src/cards_game/card.py>>[init]
+from enum import Enum, StrEnum
+from dataclasses import dataclass
+
+
+class Suit(StrEnum):
+    SPADES = "spades"
+    CLOVES = "cloves"
+    HEARTS = "hearts"
+    DIAMONDS = "diamonds"
+
+    def __repr__(self) -> str:
+        return self.name[0]
+
+
+class Kind(Enum):
+    ACE = 1
+    TWO = 2
+    THREE = 3
+    FOUR = 4
+    FIVE = 5
+    SIX = 6
+    SEVEN = 7
+    EIGHT = 8
+    NINE = 9
+    TEN = 10
+    JACK = 11
+    QUEEN = 12
+    KING = 13
+
+    def __repr__(self) -> str:
+        if self.value <= 10:
+            return str(self.value)
+        else:
+            return self.name[0]
+
+
+@dataclass(frozen = True)
+class Card:
+    suit: Suit
+    kind: Kind
+
+    def __repr__(self) -> str:
+        return repr(self.suit) + repr(self.kind)
+# ~/~ end
diff --git a/examples/cards-game/src/cards_game/deck.py b/examples/cards-game/src/cards_game/deck.py
new file mode 100644
index 0000000..3a3fdf2
--- /dev/null
+++ b/examples/cards-game/src/cards_game/deck.py
@@ -0,0 +1,16 @@
+# ~/~ begin <<README.md#deck>>[init]
+from collections.abc import Iterator
+from itertools import starmap, product
+import random
+
+from .card import Suit, Kind, Card
+
+def sorted_deck() -> Iterator[Card]:
+    return starmap(Card, product(Suit, Kind))
+# ~/~ end
+# ~/~ begin <<README.md#deck>>[1]
+def shuffled_deck() -> list[Card]:
+    deck = list(sorted_deck())
+    random.shuffle(deck)
+    return deck
+# ~/~ end
diff --git a/examples/cards-game/src/cards_game/exact.py b/examples/cards-game/src/cards_game/exact.py
new file mode 100644
index 0000000..d7b8d0d
--- /dev/null
+++ b/examples/cards-game/src/cards_game/exact.py
@@ -0,0 +1,71 @@
+# ~/~ begin <<README.md#src/cards_game/exact.py>>[init]
+from __future__ import annotations
+
+from collections.abc import Generator, Iterable
+from dataclasses import dataclass, field
+from functools import cache
+from copy import copy
+import numpy as np
+import numpy.typing as npt
+
+
+type UIntArray = npt.NDArray[np.uint64]
+type FloatArray = npt.NDArray[np.float64]
+
+
+MAX_HAND: UIntArray = np.array([4] * 9 + [16], dtype=np.uint64)
+HIST_SIZE: int = 13
+HIST_OFFSET: int = 5
+
+
+def histogram_zero() -> FloatArray:
+    return np.zeros(HIST_SIZE, dtype=np.float64)
+
+
+def histogram_singleton(n: int) -> FloatArray:
+    h = histogram_zero()
+    h[n - HIST_OFFSET] = 1
+    return h
+
+
+@dataclass
+class Hand:
+    n_cards: int = 0
+    score: int = 0
+    counts: IntArray = field(default_factory=lambda: np.zeros(10, dtype=np.uint64))
+
+    def __hash__(self) -> int:
+        h = 0
+        for (i, n) in enumerate(self.counts):
+            h |= int(n) << (3 * i)
+        return h
+
+    def __eq__(self, other) -> bool:
+        return (self.counts == other.counts).all()
+
+    def draw(self) -> Generator[tuple[int, Hand]]:
+        """Generates new hands with multiplicity."""
+        for i in range(len(self.counts)):
+            n = self.counts[i]
+            m = MAX_HAND[i]
+            if n < m:
+                c = copy(self.counts)
+                c[i] += 1
+                yield (m - n, Hand(self.n_cards + 1, self.score + i + 1, c))
+
+
+def compute_dist():
+    cache: dict[int, FloatArray] = dict()
+
+    def run(h: Hand) -> FloatArray:
+        x = hash(h)
+        if x not in cache:
+            if h.score >= 42:
+                cache[x] = histogram_singleton(h.n_cards)
+            else:
+                cache[x] = (1.0 / (52 - h.n_cards)) * sum((m * compute_dist(x, h2) \
+                    for (m, h2) in h.draw()), histogram_zero())
+        return cache[x]
+
+    return run(Hand())
+# ~/~ end
diff --git a/examples/cards-game/src/cards_game/forty_two.py b/examples/cards-game/src/cards_game/forty_two.py
new file mode 100644
index 0000000..4e73ceb
--- /dev/null
+++ b/examples/cards-game/src/cards_game/forty_two.py
@@ -0,0 +1,45 @@
+# ~/~ begin <<README.md#forty-two>>[init]
+from .card import Card
+from collections.abc import Generator, Iterable
+from functools import reduce
+from dataclasses import dataclass
+from enum import Enum, StrEnum
+from itertools import accumulate, takewhile, repeat, starmap, product
+from collections import defaultdict
+# ~/~ end
+# ~/~ begin <<README.md#forty-two>>[1]
+def black_jack_min_value(card: Card) -> int:
+    return card.kind.value if card.kind.value < 10 else 10
+# ~/~ end
+# ~/~ begin <<README.md#forty-two>>[2]
+def keep_score(score: int, card: Card) -> int:
+    return score + black_jack_min_value(card)
+# ~/~ end
+# ~/~ begin <<README.md#forty-two>>[3]
+def game_continues(score: int) -> bool:
+    return score < 42
+# ~/~ end
+# ~/~ begin <<README.md#forty-two>>[4]
+def run_game(deck: Iterable[Card]) -> Iterable[int]:
+    return takewhile(game_continues, accumulate(deck, keep_score, initial=0))
+# ~/~ end
+# ~/~ begin <<README.md#forty-two>>[5]
+def length[T](iter: Iterable[T]) -> int:
+    return sum(1 for _ in iter)
+     
+def trace_game(deck: Iterable[Card]) -> list[tuple[Card, int]]:
+    return list(zip(deck, run_game(deck)))
+
+def trial() -> int:
+    return length(run_game(shuffled_deck()))
+
+def experiment(n: int) -> Iterable[int]:
+    return starmap(trial, repeat((), n))
+
+def histogram[T](iter: Iterable[T]) -> defaultdict[T, int]:
+    def tally[T](hist: defaultdict[T, int], item: T) -> defaultdict[T, int]:
+        hist[item] += 1
+        return hist
+
+    return reduce(tally, iter, defaultdict(lambda: 0))
+# ~/~ end
diff --git a/examples/standard/.editorconfig b/examples/standard/.editorconfig
new file mode 100644
index 0000000..46940b2
--- /dev/null
+++ b/examples/standard/.editorconfig
@@ -0,0 +1,4 @@
+[*]
+indent_style = space
+indent_size = 4
+
diff --git a/examples/standard/docs/index.md b/examples/standard/docs/index.md
new file mode 100644
index 0000000..2e0d4a9
--- /dev/null
+++ b/examples/standard/docs/index.md
@@ -0,0 +1,50 @@
+Computing Primes
+================
+
+We setup a sieve of size 100, and set 0 and 1 not to be primes:
+
+``` {.cpp #sieve}
+std::vector<bool> sieve(100, true);
+sieve[0] = false;
+sieve[1] = false;
+```
+
+Then we loop over half the numbers to deselect multiples of any prime:
+
+``` {.cpp #sieve}
+for (size_t i = 0; i < 50; ++i) {
+    <<deselect-multiples>>
+}
+```
+
+If a number is not a prime, we skip.
+
+``` {.cpp #deselect-multiples}
+if (!sieve[i]) {
+    continue;
+}
+```
+
+Otherwise, we print the number, and loop over all its multiples:
+
+``` {.cpp #deselect-multiples}
+std::cout << i << std::endl;
+
+for (size_t j = i*2; j < 100; j += i) {
+    sieve[j] = false;
+}
+```
+
+## Main
+
+``` {.cpp file=src/prime_sieve.cpp}
+#include <iostream>
+#include <vector>
+#include <cstdlib>
+
+int main() {
+    <<sieve>>
+    return EXIT_SUCCESS;
+}
+```
+
diff --git a/examples/standard/src/prime_sieve.cpp b/examples/standard/src/prime_sieve.cpp
new file mode 100644
index 0000000..5b7e825
--- /dev/null
+++ b/examples/standard/src/prime_sieve.cpp
@@ -0,0 +1,30 @@
+// ~/~ begin <<docs/index.md#src/prime_sieve.cpp>>[init]
+#include <iostream>
+#include <vector>
+#include <cstdlib>
+
+int main() {
+    // ~/~ begin <<docs/index.md#sieve>>[init]
+    std::vector<bool> sieve(100, true);
+    sieve[0] = false;
+    sieve[1] = false;
+    // ~/~ end
+    // ~/~ begin <<docs/index.md#sieve>>[1]
+    for (size_t i = 0; i < 50; ++i) {
+        // ~/~ begin <<docs/index.md#deselect-multiples>>[init]
+        if (!sieve[i]) {
+            continue;
+        }
+        // ~/~ end
+        // ~/~ begin <<docs/index.md#deselect-multiples>>[1]
+        std::cout << i << std::endl;
+        
+        for (size_t j = i*2; j < 100; j += i) {
+            sieve[j] = false;
+        }
+        // ~/~ end
+    }
+    // ~/~ end
+    return EXIT_SUCCESS;
+}
+// ~/~ end
diff --git a/man/entangled.1 b/man/entangled.1
new file mode 100644
index 0000000..b9dc72a
--- /dev/null
+++ b/man/entangled.1
@@ -0,0 +1,568 @@
+.\" Automatically generated by Pandoc 3.6.4
+.\"
+.TH "entangled" "1" "" "version 2.4" "User Commands"
+.SH NAME
+Entangled \- Your literate programming toolkit.
+.SH SYNOPSIS
+\f[CR]entangled [options] [command] [arguments]...\f[R]
+.SH DESCRIPTION
+Entangled helps you write Literate Programs in Markdown.
+You put all your code inside Markdown code blocks.
+Entangled automatically extracts the code and writes it to more
+traditional source files.
+You can then edit these generated files, and the changes are being fed
+back to the Markdown.
+.SH OPTIONS
+.TP
+\f[CR]\-\-help\f[R]
+Show the help message and exit.
+.TP
+\f[CR]\-v, \-\-version\f[R]
+Show version and exit.
+.TP
+\f[CR]\-d, \-\-debug\f[R]
+Print debug messages.
+.SH COMMANDS
+Each command has its own arguments and flags that can be inspected using
+\f[CR]entangled <command> \-\-help\f[R].
+.TP
+\f[CR]brei <target>\f[R]
+Build a Brei workflow target.
+See section BREI
+.TP
+\f[CR]new <template> <project\-path>\f[R]
+Create a new entangled project from a template in the given project
+path.
+.TP
+\f[CR]reset\f[R]
+Reset the file database.
+.TP
+\f[CR]status\f[R]
+Print a status overview.
+.TP
+\f[CR]stitch\f[R]
+Stitch code changes back into the documentation.
+.TP
+\f[CR]sync\f[R]
+Automatically detects ifBe smart wether to tangle or stich
+.TP
+\f[CR]tangle\f[R]
+Tangle codes from the documentation.
+.TP
+\f[CR]watch\f[R]
+Keep a loop running, watching for changes in the file system.
+.SH WRITING PROGRAMS
+Entangled enables a \f[B]documentation first\f[R] approach to
+programming.
+To write programs using Entangled, you start by writing documentation
+and in Markdown and then add code blocks.
+The code blocks can be marked with attributes to indicate where code
+should be written.
+.SS HELLO WORLD
+The combined code\-blocks in this example compose a compilable source
+code for \[lq]Hello World\[rq].
+For didactic reasons we don\[cq]t always give the listing of an entire
+source file in one go.
+In stead, we use a system of references known as \f[I]noweb\f[R] (after
+Ramsey 1994).
+.PP
+Inside source fragments you may encounter a line with \f[CR]<<...>>\f[R]
+marks like,
+.IP
+.EX
+\f[BI]\[ga]\[ga]\[ga] {.cpp file=hello_world.cc}\f[R]
+\f[BI]#include <cstdlib>\f[R]
+\f[BI]#include <iostream>\f[R]
+
+\f[BI]<<example\-main\-function>>\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+.EE
+.PP
+which is then elsewhere specified.
+Order doesn\[cq]t matter,
+.IP
+.EX
+\f[BI]\[ga]\[ga]\[ga] {.cpp #hello\-world}\f[R]
+\f[BI]std::cout << \[dq]Hello, World!\[dq] << std::endl;\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+.EE
+.PP
+So we can reference the \f[CR]<<hello\-world>>\f[R] code block later on.
+.IP
+.EX
+\f[BI]\[ga]\[ga]\[ga] {.cpp #example\-main\-function}\f[R]
+\f[BI]int main(int argc, char **argv)\f[R]
+\f[BI]{\f[R]
+\f[BI]    <<hello\-world>>\f[R]
+\f[BI]}\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+.EE
+.PP
+A definition can be appended with more code as follows (in this case,
+order does matter!):
+.IP
+.EX
+\f[BI]\[ga]\[ga]\[ga] {.cpp #hello\-world}\f[R]
+\f[BI]return EXIT_SUCCESS;\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+.EE
+.PP
+These blocks of code can be \f[B]tangled\f[R] into source files.
+.SS DEFAULT SYNTAX
+The standard syntax is aimed to work well together with Pandoc.
+Every code block is delimited with three back ticks.
+Added to the opening line is a sequence of space separated \f[B]code
+properties\f[R].
+These properties align with the CSS attributes that would end up in the
+generated HTML.
+For those unfamiliar with CSS:
+.IP \[bu] 2
+\f[CR]#identifier\f[R]; a name prefixed with a \f[CR]#\f[R] (sharp),
+identifies the object, only one of these should be present per item
+.IP \[bu] 2
+\f[CR].class\f[R]; a name prefixed with \f[CR].\f[R] (period), assigns
+the object to a class, a object can belong to any number of classes
+.IP \[bu] 2
+\f[CR]key=value\f[R]; a name suffixed with \f[CR]=\f[R] (equals),
+optionally followed by a value, adds any meta\-data attribute to the
+object
+.PP
+The complete syntax of a code block then looks like:
+.IP
+.EX
+\f[BI]\[ga]\[ga]\[ga] {[#<reference>|.<language>|<key>=<value>] ...}\f[R]
+\f[BI]<code> ...\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+.EE
+.PP
+The first class in the code properties is always interpreted to give the
+\f[B]programming language\f[R] of the code block.
+In Entangled, any code block is one of the following:
+.IP \[bu] 2
+A \f[B]referable\f[R] block: has exactly one \f[B]reference id\f[R]
+(\f[CR]#<reference>\f[R]) and a class giving the language of the code
+block (\f[CR].<language>\f[R]).
+Example:
+.RS 2
+.IP
+.EX
+\f[BI]\[ga]\[ga]\[ga] {.rust #hello\-rust}\f[R]
+\f[BI]println!(\[dq]Hello, Rust!\[dq]);\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+.EE
+.PP
+In some cases you may want to have additional classes to trigger hooks
+or a specific filter.
+Always the first class is interpreted to identify the language.
+.RE
+.IP \[bu] 2
+A \f[B]file\f[R] block: has a key\-value pair giving the path to the
+file (\f[CR]file=<path>\f[R]), absolute or relative to the directory in
+which \f[CR]entangled\f[R] runs.
+Again, there should be one class giving the language of the block
+(\f[CR].<language>\f[R]).
+Example:
+.RS 2
+.IP
+.EX
+\f[BI]\[ga]\[ga]\[ga] {.rust file=src/main.rs}\f[R]
+\f[BI]fn main() {\f[R]
+\f[BI]   <<hello\-rust>>\f[R]
+\f[BI]}\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+.EE
+.PP
+The identifier in a file block is optional.
+If it is left out, the identifier will silently be taken to be the file
+name.
+.RE
+.IP \[bu] 2
+An \f[B]ignored\f[R] block: anything not matching the previous two.
+.SS TANGLED CODE
+Entangled recognizes three parameters for every code block.
+These parameters are extracted from an opening line may be configured
+using regular expressions.
+Formally, every code block has three properties:
+.IP \[bu] 2
+\f[CR]Language\f[R]
+.IP \[bu] 2
+\f[CR]Identifier\f[R]
+.IP \[bu] 2
+\f[CR]Optional Filename\f[R]
+.PP
+Entangled should tangle your code following these rules:
+.IP "1." 3
+If an \f[B]identifier\f[R] is repeated the contents of the code blocks
+is concatenated in the order that they appear in the Markdown.
+If an identifier appears in multiple files, the order is dependent on
+the order by which the files appear in the configuration, or if they
+result from a glob\-pattern expansion, alphabetical order.
+.IP "2." 3
+\f[B]Noweb references\f[R] are \f[B]expanded\f[R].
+A noweb reference in Entangled should occupy a single line of code by
+itself, and is enclosed with double angle brackets, and maybe indented
+with white space.
+Space at the end of the line is ignored.
+.RS 4
+.IP
+.EX
++\-\-\- indentation \-\-\-+\-\-\- reference  \-\-\-+\-\-\- possible space \-\-\-+
+                    <<noweb\-reference>>
+.EE
+.PP
+The reference is expanded recursively, after which the indentation is
+prefixed to every line in the expanded reference content.
+.RE
+.IP "3." 3
+\f[B]Annotation\f[R]; Expanded and concatenated code blocks are
+annotated using comment lines.
+These lines should not be touched when editing the generated files.
+The default method of annotation follows an opening comment with
+\f[CR]\[ti]\[rs]\[ti] begin <<filename#identifier>>[n]\f[R], and a
+closing comment with \f[CR]\[ti]\[rs]\[ti] end\f[R].
+For example
+.RS 4
+.IP
+.EX
+\f[I]// \[ti]\[rs]\[ti] begin <<lit/index.md|main>>[1]\f[R]
+println!(\[dq]hello\[dq]);
+\f[I]// \[ti]\[rs]\[ti] end\f[R]
+.EE
+.RE
+.SH CONFIGURATION
+Global configuration is loaded from \f[CR]entangled.toml\f[R] in the
+current working directory, or from the YAML header of the Markdown file,
+if there is only one input file.
+In the case of multiple input files, the YAML header is local to that
+input file.
+.PP
+Configuration should match the following scheme:
+.TP
+\f[CR]version\f[R]
+(\f[CR]string\f[R]) the minimum version of Entangled.
+.TP
+\f[CR]style\f[R]
+(\f[CR]string\f[R]: \f[CR]default\f[R] | \f[CR]basic\f[R]) (default:
+\f[CR]default\f[R]) a configuration preset.
+See STYLES.
+.TP
+\f[CR]languages\f[R]
+(\f[CR]list[Language]\f[R]) additional language settings.
+.TP
+\f[CR]markers\f[R]
+(\f[CR]Markers\f[R]) override marker expressions for extracting code
+blocks.
+.TP
+\f[CR]watch_list\f[R]
+(\f[CR]list[string]\f[R]) sets a list of glob patterns for files to
+read.
+.TP
+\f[CR]ignore_list\f[R]
+(\f[CR]list[string]\f[R]) sets a list of glob patterns to exclude from
+reading.
+.TP
+\f[CR]annotation\f[R]
+(\f[CR]string\f[R]: \f[CR]standard\f[R] | \f[CR]naked\f[R] |
+\f[CR]supplemented\f[R]) sets the method for annotating tangled files.
+.TP
+\f[CR]annotation_format\f[R]
+(\f[CR]string\f[R]) set a format string for \f[CR]supplemented\f[R]
+annotation (not yet implemented).
+.TP
+\f[CR]use_line_directives\f[R]
+(\f[CR]bool\f[R]) wether to include line directives to point compilers
+to the Markdown input source (not yet implemented).
+.TP
+\f[CR]namespace\f[R]
+(\f[CR]string\f[R]) set the namespace for the current input file.
+Namespaces are separated with double colons \f[CR]::\f[R].
+.TP
+\f[CR]namespace_default\f[R]
+(\f[CR]string\f[R]: \f[CR]global\f[R] | \f[CR]private\f[R]) if the
+namespace is absent, this controls the scope of code block identifiers.
+.TP
+\f[CR]hooks\f[R]
+(\f[CR]list[string]\f[R]) set the hooks used.
+Prepend a hook name with a tilde \f[CR]\[ti]\f[R] to disable a hook
+locally.
+.TP
+\f[CR]hook\f[R]
+(\f[CR]object\f[R]) additional settings for enabled hooks.
+.TP
+\f[CR]brei\f[R]
+(\f[CR]Program\f[R]) create more Brei targets that are not listed in
+code blocks.
+The \f[CR]Program\f[R] API is specified by the \f[CR]brei\f[R] package.
+.SS LANGUAGE
+We can configure how a language is treated by setting comment
+characters.
+For example:
+.IP
+.EX
+\f[B][[languages]]\f[R]
+name = \[dq]Java\[dq]
+identifiers = [\[dq]java\[dq]]
+comment = { open = \[dq]//\[dq] }
+
+\f[I]# Some languages have comments that are not terminated by\f[R]
+\f[I]# newlines, like XML or CSS.\f[R]
+\f[B][[languages]]\f[R]
+name = \[dq]XML\[dq]
+identifiers = [\[dq]xml\[dq], \[dq]html\[dq], \[dq]svg\[dq]]
+comment = { open = \[dq]<!\-\-\[dq], close = \[dq]\-\->\[dq] }
+.EE
+.TP
+\f[CR]name\f[R]
+(\f[CR]string\f[R]) a unique name for the language.
+.TP
+\f[CR]identifiers\f[R]
+(\f[CR]list[string]\f[R]) a set of identifiers that are admissable as
+language classes for a code block using this language.
+.TP
+\f[CR]comment\f[R]
+(\f[CR]object[open: string, close: string = \[dq]\[dq]]\f[R]) how to
+write comments in this language.
+.SS MARKERS
+This configures how code blocks are detected.
+.TP
+\f[CR]open\f[R]
+(\f[CR]string\f[R]) opening regex for a code block.
+Python\[cq]s regex engine supports named groups using
+\f[CR](?P<name>...)\f[R] syntax.
+This expression should contain an \f[CR]indent\f[R] group and a
+\f[CR]properties\f[R] group.
+The returned indentation should contain only spaces, and
+\f[CR]properties\f[R] should at the minimum have the language identifier
+for the code block.
+.TP
+\f[CR]close\f[R]
+(\f[CR]string\f[R]) closing regex for a code block.
+This should contain a named pattern group \f[CR]indent\f[R].
+.SH STYLES
+There are two configuration styles available: \f[CR]default\f[R] and
+\f[CR]basic\f[R].
+.SS DEFAULT
+The default is to read code blocks with three back\-tics and attributes
+grouped in curly braces.
+For example:
+.IP
+.EX
+\f[BI]This is a code block:\f[R]
+
+\f[BI]\[ga]\[ga]\[ga] {.c #print\-hello}\f[R]
+\f[BI]printf(\[dq]Hello, World!\[dq]);\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+.EE
+.SS BASIC
+The basic style is less expressive but has better compatability with
+most standard Markdown syntaxes like Github.In this style only the
+language identifier is given after three back\-tics.
+Other attributes are passed using the \f[CR]quarto_attributes\f[R] hook.
+For example:
+.IP
+.EX
+\f[BI]This is a code block:\f[R]
+
+\f[BI]\[ga]\[ga]\[ga]c\f[R]
+\f[I]//| id: print\-hello\f[R]
+printf(\[dq]Hello, World!\[dq]);
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+.EE
+.SH HOOKS
+.SS BREI
+Entangled has an integrated build system called Brei, that can be used
+to produce figures or other artifacts.
+Targets and their dependencies can be specified in code blocks using the
+\f[CR]brei\f[R] hook.
+These tasks may depend on one another.
+Brei will run these when dependencies are newer than the target.
+Execution is lazy and in parallel.
+Brei supports:
+.IP \[bu] 2
+Running tasks by passing a script to any configured interpreter,
+e.g.\ Bash, Python, Lua etc.
+.IP \[bu] 2
+Redirecting \f[CR]stdout\f[R] or \f[CR]stdin\f[R] to or from files.
+.IP \[bu] 2
+Defining so called \[lq]phony\[rq] targets.
+.IP \[bu] 2
+Define \f[CR]template\f[R] for programmable reuse.
+.IP \[bu] 2
+\f[CR]include\f[R] other Brei files, even ones that need to be generated
+by another \f[CR]task\f[R].
+.IP \[bu] 2
+Variable substitution, including writing \f[CR]stdout\f[R] to variables.
+.PP
+Brei is available as a separate package, see \c
+.UR https://entangled.github.io/brei
+the Brei documentation
+.UE \c
+\&.
+.SS Examples
+To write out \[lq]Hello, World!\[rq] to a file \f[CR]msg.txt\f[R], we
+may do the following,
+.IP
+.EX
+\f[B][[task]]\f[R]
+stdout = \[dq]secret.txt\[dq]
+language = \[dq]Python\[dq]
+script = \[dq]\[dq]\[dq]
+print(\[dq]Uryyb, Jbeyq!\[dq])
+\[dq]\[dq]\[dq]
+.EE
+.PP
+To have this message decoded define a pattern,
+.IP
+.EX
+\f[B][pattern.rot13]\f[R]
+stdout = \[dq]{stdout}\[dq]
+stdin = \[dq]{stdin}\[dq]
+language = \[dq]Bash\[dq]
+script = \[dq]\[dq]\[dq]
+tr a\-zA\-Z n\-za\-mN\-ZA\-M
+\[dq]\[dq]\[dq]
+
+\f[B][[call]]\f[R]
+pattern = \[dq]rot13\[dq]
+  \f[B][call.args]\f[R]
+  stdin = \[dq]secret.txt\[dq]
+  stdout = \[dq]msg.txt\[dq]
+.EE
+.PP
+To define a phony target \[lq]all\[rq],
+.IP
+.EX
+\f[B][[task]]\f[R]
+name = \[dq]all\[dq]
+requires = [\[dq]msg.txt\[dq]]
+.EE
+.SS The Brei hook
+The following example uses both \f[CR]brei\f[R] and
+\f[CR]quatro_attributes\f[R] hooks.
+To add a Brei task, tag a code block with the \f[CR].task\f[R] class.
+.IP
+.EX
+First we generate some data.
+
+\f[BI]\[ga]\[ga]\[ga] {.python #some\-functions}\f[R]
+\f[BI]# define some functions\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+
+Now we show what that data would look like:
+
+\f[BI]\[ga]\[ga]\[ga] {.python .task}\f[R]
+\f[BI]#| description: Generate data\f[R]
+\f[BI]#| creates: data/data.npy\f[R]
+
+\f[BI]<<some\-functions>>\f[R]
+
+\f[BI]# generate and save data\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+
+Then we plot in another task.
+
+\f[BI]\[ga]\[ga]\[ga] {.python .task}\f[R]
+\f[BI]#| description: Plot data\f[R]
+\f[BI]#| creates: docs/fig/plot.svg\f[R]
+\f[BI]#| requires: data/data.npy\f[R]
+\f[BI]#| collect: figures\f[R]
+
+\f[BI]# load data and plot\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+.EE
+.PP
+The \f[CR]collect\f[R] attribute tells the Brei hook to add the
+\f[CR]docs/fig/plot.svg\f[R] target to the \f[CR]figures\f[R]
+collection.
+All figures can then be rendered as follows, having in
+\f[CR]entangled.toml\f[R]
+.IP
+.EX
+version = \[dq]2.0\[dq]
+watch_list = [\[dq]docs/**/*.md\[dq]]
+hooks = [\[dq]quatro_attributes\[dq], \[dq]brei\[dq]]
+
+\f[B][brei]\f[R]
+include = [\[dq].entangled/tasks.json\[dq]]
+.EE
+.PP
+And run
+.IP
+.EX
+entangled brei figures
+.EE
+.PP
+You can use \f[CR]${variable}\f[R] syntax inside Brei tasks just as you
+would in a stand\-alone Brei script.
+.SS QUARTO ATTRIBUTES
+Sometimes using the \f[CR]build\f[R] hook (or the \f[CR]brei\f[R] hook,
+see below), leads to long header lines.
+It is then better to specify attributes in a header section of your
+code.
+The Quarto project came up with a syntax, having the header be indicated
+by a comment with a vertical bar, e.g.\ \f[CR]#|\f[R] or \f[CR]//|\f[R]
+etc.
+The \f[CR]quarto_attributes\f[R] hook reads those attributes and adds
+them to the properties of the code block.
+.PP
+Example with the \f[CR]brei\f[R] hook:
+.IP
+.EX
+\f[BI]\[ga]\[ga]\[ga] {.python .task}\f[R]
+\f[BI]#| description: Draw a triangle\f[R]
+\f[BI]#| creates: docs/fig/triangle.svg\f[R]
+\f[BI]#| collect: figures\f[R]
+\f[BI]from matplotlib import pyplot as plt\f[R]
+\f[BI]plt.plot([[\-1, \-0.5], [1, \-0.5], [0, 1], [\-1, \-0.5]])\f[R]
+\f[BI]plt.savefig(\[dq]docs/fig/triangle.svg\[dq])\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+
+\f[B]![](fig/triangle.svg)\f[R]
+.EE
+.PP
+Using these attributes it is possible to write in Entangled using
+completely standard Markdown syntax.
+.PP
+The \f[CR]id\f[R] attribute is reserved for the code\[cq]s identifier
+(normally indicated with \f[CR]#\f[R]) and the \f[CR]classes\f[R]
+attribute can be used to indicate a list of classes in addition to the
+language class already given.
+.SS REPL (experimental)
+The \f[CR]repl\f[R] hook enables running code blocks in REPL sessions.
+The hook extracts these code blocks into a separate JSON session file
+that can be evaluated using the \f[CR]repl\-session\f[R] tool \c
+.UR https://entangled.github.io/repl-session
+.UE \c
+\&.
+The output needs to be processed by the documentation rendering system.
+The \f[CR]mkdocs\-entangled\-plugin\f[R] package handles \f[CR]repl\f[R]
+sessions and integrates the output into the rendered HTML.
+.SS SHEBANG
+If a code block starts with \f[CR]#!...\f[R] on the first line.
+This line is brought to the top of the tangled file.
+Together with the use of a \f[CR]mode\f[R] attribute, this enables
+coding executable scripts in Entangled.
+Example:
+.IP
+.EX
+\f[BI]A first Bash script:\f[R]
+
+\f[BI]\[ga]\[ga]\[ga] {.bash file=cowsay mode=0755}\f[R]
+\f[BI]#!/bin/bash\f[R]
+\f[BI]echo \[dq]Mooo!\[dq]\f[R]
+\f[BI]\[ga]\[ga]\[ga]\f[R]
+.EE
+.SS SPDX_LICENSE
+If a code block starts with a line containing the string
+\[lq]SPDX\-License\-Identifier\[rq].
+That line is put above the first annotation comment, similar to the
+\f[CR]shebang\f[R] hook.
+.SH BUGS
+Bugs can be reported at \c
+.UR https://github.com/entangled/entangled.py/issues
+github.com/entangled/entangled.py/issues
+.UE \c
+\&.
+.SH AUTHORS
+Entangled was written by Johan Hidding, with contributions by Ole
+Mussmann, Reggie Cushing, Olga Lyashevska and several others.
diff --git a/mkdocs.yml b/mkdocs.yml
index 65b80ab..66cddbc 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -4,4 +4,14 @@ plugins:
   - mkdocstrings
 
 theme:
-  name: readthedocs
+  name: material
+
+markdown_extensions:
+  - pymdownx.superfences:
+      custom_fences:
+        - name: mermaid
+          class: mermaid
+          format: !!python/name:pymdownx.superfences.fence_code_format
+  - def_list
+  - pymdownx.tasklist:
+      custom_checkbox: true 
diff --git a/pyproject.toml b/pyproject.toml
index d944e04..2085043 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "entangled-cli"
-version = "2.3.2"
+version = "2.4.0"
 description = "Literate Programming toolbox"
 authors = [{ name = "Johan Hidding", email = "j.hidding@esciencecenter.nl" }]
 requires-python = ">=3.12,<4"
@@ -20,6 +20,9 @@ dependencies = [
         "repl-session>=0.2.0",
         "msgspec>=0.19.0",
         "watchdog>=6.0.0",
+        "click>=8.3.0",
+        "rich-click>=1.9.4",
+        "typeguard>=4.4.4",
 ]
 
 [project.urls]
@@ -31,14 +34,14 @@ entangled = "entangled.main:cli"
 
 [dependency-groups]
 dev = [
-        "pytest>=7.3.1,<8",
+        "pytest>=9.0,<10",
         "mypy>=1.18,<2",
         "black>=23.3.0,<24",
         "pytest-cov>=4.0.0,<5",
         "mkdocs>=1.4.3,<2",
-        "mkdocs-material>=9.1.13,<10",
-        "mkdocstrings[python]>=0.21.2,<0.22",
-        "pytest-asyncio>=0.21.1,<0.22",
+        "mkdocs-material>=9.7,<10",
+        "mkdocstrings[python]>=0.30",
+        "pytest-asyncio>=1.3,<2",
         "ruff>=0.14",
         "types-pyyaml>=6.0.12.20240311,<7",
         "types-pygments>=2.18.0.20240506,<3",
@@ -48,6 +51,7 @@ dev = [
         "types-pexpect>=4.9.0.20250916",
         "types-PyYAML>=6.0.1,<7",
         "pytest-timeout>=2.4.0",
+        "ty>=0.0.1a24",
 ]
 
 [tool.hatch.build.targets.sdist]
@@ -56,6 +60,9 @@ include = ["entangled"]
 [tool.hatch.build.targets.wheel]
 include = ["entangled"]
 
+[tool.hatch.build.targets.wheel.shared-data]
+"man/entangled.1" = "man/man1/entangled.1"
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
@@ -65,3 +72,6 @@ testpaths = ["test"]
 
 [tool.mypy]
 packages = ["entangled"]
+
+[tool.uv.sources]
+msgspec = { git = "https://github.com/jcrist/msgspec" }
diff --git a/test/test_daemon.py b/test/commands/test_daemon.py
similarity index 91%
rename from test/test_daemon.py
rename to test/commands/test_daemon.py
index 97d47fa..b0483ae 100644
--- a/test/test_daemon.py
+++ b/test/commands/test_daemon.py
@@ -5,7 +5,6 @@
 import pytest
 import sys
 
-from entangled.config import config
 from entangled.io.stat import stat
 from entangled.commands.watch import _watch
 from entangled.logging import configure
@@ -36,12 +35,8 @@ def wait_for_stat_diff(md_stat, filename, timeout=5):
     return False
 
 
-# @pytest.mark.skipif(
-#    sys.platform=="win32" and sys.version.startswith("3.13"),
-#    reason="threading.Event seems to be broken")
 @pytest.mark.timeout(30)
 def test_daemon(tmp_path: Path):
-    config.read(force=True)
     with chdir(tmp_path):
         configure(debug=True)
         stop = threading.Event()
diff --git a/test/commands/test_main.py b/test/commands/test_main.py
new file mode 100644
index 0000000..ef18f92
--- /dev/null
+++ b/test/commands/test_main.py
@@ -0,0 +1,25 @@
+from entangled.commands import main
+from entangled.version import __version__
+
+import pytest
+import sys
+import logging
+
+from contextlib import chdir
+
+
+def test_version(capsys):
+    with pytest.raises(SystemExit):
+        main(args=["--version"])
+    captured = capsys.readouterr()
+    assert captured.out.strip() == f"Entangled {__version__}"
+
+
+def test_debug(caplog, tmpdir):
+    caplog.set_level(logging.DEBUG)
+    with chdir(tmpdir):
+        with pytest.raises(SystemExit):
+            main(args=["-d", "tangle"])
+
+        assert "Welcome to Entangled" in caplog.text
+
diff --git a/test/test_new.py b/test/commands/test_new.py
similarity index 92%
rename from test/test_new.py
rename to test/commands/test_new.py
index 8c24265..8f4881e 100644
--- a/test/test_new.py
+++ b/test/commands/test_new.py
@@ -11,12 +11,12 @@
 
 def test_print_available_templates() -> None:
     """Test if official template settings can be read"""
-    new(template="", project_path="", list_templates=True)
+    new.callback(template="", project_path="", list_templates=True)
 
 
 def test_pretend_template_copy() -> None:
     """Test dry run"""
-    new(
+    new.callback(
         template="./test/templates/minimal",
         project_path="_",
         data="project_name=my_project",
@@ -27,7 +27,7 @@ def test_pretend_template_copy() -> None:
 
 def test_multiple_data() -> None:
     """Test `-d/--data` syntax"""
-    new(
+    new.callback(
         template="./test/templates/minimal",
         project_path="_",
         data="project_name=my_project;key=value;",
@@ -38,7 +38,7 @@ def test_multiple_data() -> None:
 
 def test_minimal_template_copy(tmp_path) -> None:
     """Test if initializing a new project with a minimal template works"""
-    new(
+    new.callback(
         template="./test/templates/minimal",
         project_path=str(tmp_path),
         data="project_name=my_project",
@@ -48,7 +48,7 @@ def test_minimal_template_copy(tmp_path) -> None:
 
 def test_untrusted_template_pass(tmp_path) -> None:
     """Test if initializing a new project with an untrusted template fails"""
-    new(
+    new.callback(
         template="./test/templates/minimal_unsafe",
         project_path=str(tmp_path),
         data="project_name=my_project",
@@ -60,7 +60,7 @@ def test_untrusted_template_pass(tmp_path) -> None:
 def test_untrusted_template_fail(tmp_path) -> None:
     """Test if initializing a new project with an untrusted template fails"""
     with pytest.raises(HelpfulUserError, match="Template uses potentially unsafe"):
-        new(
+        new.callback(
             template="./test/templates/minimal_unsafe",
             project_path=str(tmp_path),
             data="project_name=my_project",
@@ -70,13 +70,13 @@ def test_untrusted_template_fail(tmp_path) -> None:
 
 def test_overwrite_template(tmp_path) -> None:
     """Force overwrite a project with different data"""
-    new(
+    new.callback(
         template="./test/templates/minimal",
         project_path=str(tmp_path),
         data="project_name=my_project",
         defaults=True,
     )
-    new(
+    new.callback(
         template="./test/templates/minimal",
         project_path=str(tmp_path),
         data="project_name=my_other_project",
@@ -91,7 +91,7 @@ def test_default_answers_file(tmp_path) -> None:
     f: IO
     with open(default_answers_file, "w") as f:
         f.write("project_name: default_project")
-    new(
+    new.callback(
         template="./test/templates/minimal",
         project_path=str(tmp_path),
         defaults=True,
@@ -105,7 +105,7 @@ def test_custom_answers_file(tmp_path) -> None:
     f: IO
     with open(my_answers_file, "w") as f:
         f.write("project_name: my_project")
-    new(
+    new.callback(
         template="./test/templates/minimal",
         project_path=str(tmp_path),
         answers_file=my_answers_file_name,
diff --git a/test/config/test_hooks.py b/test/config/test_hooks.py
new file mode 100644
index 0000000..e947345
--- /dev/null
+++ b/test/config/test_hooks.py
@@ -0,0 +1,9 @@
+from entangled.config import Config, ConfigUpdate
+
+
+def test_hooks_update():
+    cfg = Config(hooks={"brei", "quarto_attributes"})
+    cfg1 = cfg | ConfigUpdate(version="2.4", hooks=["~brei"])
+    assert cfg1.hooks == {"quarto_attributes"}
+    cfg2 = cfg | ConfigUpdate(version="2.4", hooks=["shebang"])
+    assert cfg2.hooks == {"brei", "quarto_attributes", "shebang"}
diff --git a/test/config/test_input_list.py b/test/config/test_input_list.py
new file mode 100644
index 0000000..19b3bfd
--- /dev/null
+++ b/test/config/test_input_list.py
@@ -0,0 +1,17 @@
+from entangled.config import Config, get_input_files
+from pathlib import Path
+from contextlib import chdir
+
+
+def test_input_files(tmpdir: Path):
+    tmpdir = Path(tmpdir)
+    (tmpdir / "a").mkdir()
+    (tmpdir / "b").mkdir()
+    (tmpdir / "a" / "x").touch()
+    (tmpdir / "a" / "y").touch()
+    (tmpdir / "b" / "x").touch()
+    with chdir(tmpdir):
+        assert get_input_files(Config(watch_list=["**/x"])) == [Path("a/x"), Path("b/x")]
+        assert get_input_files(Config(watch_list=["a/*"])) == [Path("a/x"), Path("a/y")]
+        assert get_input_files(Config(watch_list=["**/*"], ignore_list=["**/y"])) == \
+            [Path("a/x"), Path("b/x")]
diff --git a/test/config/test_language.py b/test/config/test_language.py
new file mode 100644
index 0000000..733848e
--- /dev/null
+++ b/test/config/test_language.py
@@ -0,0 +1,22 @@
+from entangled.config import Config, ConfigUpdate
+from entangled.config.language import Language, Comment
+
+
+def test_get_language():
+    cfg = Config()
+
+    lang1 = cfg.get_language("scheme")
+    assert lang1 is not None and lang1.name == "Lisp"
+
+    lang2 = cfg.get_language("brainfuck")
+    assert lang2 is None
+
+    # pick a language that we'll never support out of the box ;)
+    cobol = Language("COBOL", ["cobol"], Comment("*>"))
+    cfg1 = cfg | ConfigUpdate(
+        version="2.4",
+        languages=[cobol])
+    assert len(cfg1.languages) == len(cfg.languages) + 1
+    assert cfg.get_language("cobol") is None
+    assert cfg1.get_language("cobol") is cobol
+
diff --git a/test/config/test_read_config.py b/test/config/test_read_config.py
new file mode 100644
index 0000000..bbd8204
--- /dev/null
+++ b/test/config/test_read_config.py
@@ -0,0 +1,76 @@
+from entangled.config import read_config, read_config_from_toml, Config
+from entangled.config.version import Version
+from entangled.errors.user import UserError
+
+from pathlib import Path
+from contextlib import chdir
+
+import pytest
+import logging
+
+
+pyproject_toml = """
+[tool.entangled]
+version = "100"
+style = "basic"
+""".lstrip()
+
+
+def test_pyproject_toml(tmpdir: Path, caplog):
+    with chdir(tmpdir):
+        assert read_config() is None
+
+    filename = tmpdir / "pyproject.toml"
+    filename.write_text(pyproject_toml, encoding="utf-8")
+
+    config = Config() | read_config_from_toml(filename, "tool.entangled")
+    assert config.version == Version((100,))
+
+    with caplog.at_level(logging.DEBUG):
+        _ = read_config_from_toml(filename, "tool.not-entangled")
+        assert "tool.not-entangled" in caplog.text
+
+    with pytest.raises(UserError):
+        _ = read_config_from_toml(filename, None)
+
+    assert read_config_from_toml(tmpdir / "entangled.toml") is None
+
+    with chdir(tmpdir):
+        cfg = Config() | read_config()
+        assert cfg.version == Version((100,))
+
+
+entangled_toml = """
+version = "42"
+annotation = "naked"
+
+[[languages]]
+name = "Kernel"
+identifiers = ["kernel"]
+comment = {"open" = ";"}
+""".lstrip()
+
+
+def test_entangled_toml(tmpdir: Path, caplog):
+    with chdir(tmpdir):
+        assert read_config() is None
+
+    (tmpdir / "entangled.toml").write_text(entangled_toml, encoding="utf-8")
+
+    with chdir(tmpdir):
+        cfg = Config() | read_config()
+        assert cfg.version == Version((42,))
+        assert cfg.get_language("kernel").name == "Kernel"
+
+
+entangled_toml_error = """
+no_version_given = ""
+""".lstrip()
+
+
+def test_entangled_toml_error(tmpdir: Path, caplog):
+    (tmpdir / "entangled.toml").write_text(entangled_toml_error, encoding="utf-8")
+    with chdir(tmpdir):
+        with pytest.raises(UserError):
+            cfg = Config() | read_config()
+
diff --git a/test/config/test_style.py b/test/config/test_style.py
new file mode 100644
index 0000000..9e769ce
--- /dev/null
+++ b/test/config/test_style.py
@@ -0,0 +1,11 @@
+from entangled.config import Config, ConfigUpdate
+from entangled.config.document_style import DocumentStyle
+from entangled.config.markers import basic_markers
+
+
+def test_style():
+    cfg = Config()
+    cfg1 = cfg | ConfigUpdate(version="2.4", style=DocumentStyle.BASIC)
+    assert cfg1.markers is basic_markers
+    assert "quarto_attributes" in cfg1.hooks
+
diff --git a/test/config/test_templates.py b/test/config/test_templates.py
new file mode 100644
index 0000000..57eb6f9
--- /dev/null
+++ b/test/config/test_templates.py
@@ -0,0 +1,7 @@
+from entangled.config.templates import templates
+
+
+def test_templates():
+    assert isinstance(templates, list)
+    assert templates
+
diff --git a/test/config/test_update.py b/test/config/test_update.py
new file mode 100644
index 0000000..a5e46c6
--- /dev/null
+++ b/test/config/test_update.py
@@ -0,0 +1,7 @@
+from entangled.config import Config, ConfigUpdate
+
+
+def test_null():
+    cfg = Config()
+    assert cfg | None is cfg
+
diff --git a/test/config/test_version.py b/test/config/test_version.py
new file mode 100644
index 0000000..5ffcecb
--- /dev/null
+++ b/test/config/test_version.py
@@ -0,0 +1,8 @@
+from entangled.config.version import Version
+
+
+def test_version_class():
+    assert Version.from_str("1.2.3") == Version((1, 2, 3))
+    assert Version((2, 4, 1)).to_str() == "2.4.1"
+    assert Version.from_str("2.3") < Version.from_str("5.1")
+
diff --git a/test/conftest.py b/test/conftest.py
index b4437d0..8db1196 100644
--- a/test/conftest.py
+++ b/test/conftest.py
@@ -1,6 +1,5 @@
 import pytest
 from pathlib import Path
-from entangled.config import config
 
 
 @pytest.fixture
@@ -13,7 +12,3 @@ def markdown(request):
     with open(request.param, "r") as f:
         yield f.read()
 
-
-def pytest_configure():
-    config.read()
-
diff --git a/test/data/os_interop/src/euler_number.c b/test/data/os_interop/src/euler_number.c
index 6213772..b4e4a98 100644
--- a/test/data/os_interop/src/euler_number.c
+++ b/test/data/os_interop/src/euler_number.c
@@ -1,17 +1,17 @@
-/* ~/~ begin <<doc/index.md#src/euler_number.c>>[init] */
+// ~/~ begin <<doc/index.md#src/euler_number.c>>[init]
 #include <stdlib.h>
 #include <stdio.h>
 
 int main() {
-  /* ~/~ begin <<doc/index.md#series-expansion>>[init] */
+  // ~/~ begin <<doc/index.md#series-expansion>>[init]
   double euler_number = 1.0;
   int factorial = 1;
   for (int i = 1; i < 10; ++i) {
     factorial *= i;
     euler_number += 1.0 / factorial;
   }
-  /* ~/~ end */
+  // ~/~ end
   printf("Euler's number e = %e\n", euler_number);
   return EXIT_SUCCESS;
 }
-/* ~/~ end */
+// ~/~ end
diff --git a/test/data/os_interop/src/euler_number.c.edit b/test/data/os_interop/src/euler_number.c.edit
index 2a1530a..b2f3d3a 100644
--- a/test/data/os_interop/src/euler_number.c.edit
+++ b/test/data/os_interop/src/euler_number.c.edit
@@ -1,17 +1,17 @@
-/* ~/~ begin <<doc/index.md#src/euler_number.c>>[init] */
+// ~/~ begin <<doc/index.md#src/euler_number.c>>[init]
 #include <stdlib.h>
 #include <stdio.h>
 
 int main() {
-  /* ~/~ begin <<doc/index.md#series-expansion>>[init] */
+  // ~/~ begin <<doc/index.md#series-expansion>>[init]
   double euler_number = 1.0;
   int factorial = 1;
   for (int i = 1; i < 20; ++i) {
     factorial *= i;
     euler_number += 1.0 / factorial;
   }
-  /* ~/~ end */
+  // ~/~ end
   printf("Euler's number e = %e\n", euler_number);
   return EXIT_SUCCESS;
 }
-/* ~/~ end */
+// ~/~ end
diff --git a/test/data/repl-hook/entangled.toml b/test/data/repl-hook/entangled.toml
index 787d570..11f6f32 100644
--- a/test/data/repl-hook/entangled.toml
+++ b/test/data/repl-hook/entangled.toml
@@ -1,10 +1,7 @@
 version = "2.0"
 watch_list = ["README.md"]
-hooks = ["quarto_attributes", "repl"]
-
-[markers]
-open="^(?P<indent>\\s*)```(?P<properties>.*)$"
-close="^(?P<indent>\\s*)```\\s*$"
+style = "basic"
+hooks = ["repl"]
 
 [hook.repl.config.Python]
 command = "python -q"
diff --git a/test/data/typst/entangled.toml b/test/data/typst/entangled.toml
index 07befc4..008176f 100644
--- a/test/data/typst/entangled.toml
+++ b/test/data/typst/entangled.toml
@@ -1,7 +1,4 @@
 version="2.0"
 watch_list=["*.typ"]
-hooks=["quarto_attributes"]
+style="basic"
 
-[markers]
-open="^(?P<indent>\\s*)```(?P<properties>.*)$"
-close="^(?P<indent>\\s*)```\\s*$"
diff --git a/test/hooks/test_build_hook.py b/test/hooks/test_build_hook.py
new file mode 100644
index 0000000..330737b
--- /dev/null
+++ b/test/hooks/test_build_hook.py
@@ -0,0 +1,54 @@
+from entangled.interface import Document
+from entangled.io import transaction
+from entangled.logging import configure
+from contextlib import chdir
+
+import subprocess
+import pytest
+import sys
+
+from uuid import uuid4
+from pathlib import Path
+
+
+md_input = """
+---
+entangled:
+    version: "2.4"
+    hooks:
+        - build
+---
+
+Create a file:
+
+``` {{.python file=script.py}}
+print("{message}", end="")
+```
+
+``` {{.bash .build target="test.dat" deps="script.py"}}
+python script.py > test.dat
+```
+""".lstrip()
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="Skipped on Windows")
+def test_build(tmp_path):
+    configure(debug=True)
+    message = uuid4().hex
+    with chdir(tmp_path):
+        Path("test.md").write_text(md_input.format(message=message), encoding="utf-8")
+
+        doc = Document()
+        with transaction() as t:
+            doc.context |= doc.load_source(t, Path("test.md"))
+            doc.tangle(t)
+
+        for h in doc.context.hooks:
+            h.post_tangle(doc.reference_map)
+
+        print(Path(".entangled/build/Makefile").read_text())
+        subprocess.call(["make", "-f", ".entangled/build/Makefile"])
+
+        tgt = Path("test.dat")
+        assert tgt.exists()
+        assert tgt.read_text() == message
diff --git a/test/test_repl_hook.py b/test/hooks/test_repl_hook.py
similarity index 88%
rename from test/test_repl_hook.py
rename to test/hooks/test_repl_hook.py
index 12dbef6..5f029f1 100644
--- a/test/test_repl_hook.py
+++ b/test/hooks/test_repl_hook.py
@@ -9,7 +9,7 @@
 def test_tangle_ref(data, tmp_path):
     copytree(data / "repl-hook", tmp_path / "repl-hook")
     with chdir(tmp_path / "repl-hook"):
-        run([sys.executable, "-m", "entangled.main", "tangle"])
+        run([sys.executable, "-m", "entangled.main", "-d", "tangle"])
         assert Path("expected.yml").exists()
         assert Path("test.json").exists()
 
diff --git a/test/hooks/test_shebang.py b/test/hooks/test_shebang.py
new file mode 100644
index 0000000..71e1d1b
--- /dev/null
+++ b/test/hooks/test_shebang.py
@@ -0,0 +1,64 @@
+from entangled.config import ConfigUpdate
+from entangled.interface import Document
+from entangled.model import ReferenceName, ReferenceId
+from entangled.io import VirtualFS, transaction
+from pathlib import PurePath, Path
+
+
+eol = "\n"
+
+
+fs = VirtualFS.from_dict({
+    "input.md": """
+A script with a she-bang!
+
+``` {.bash file=test.sh}
+#!/bin/bash
+
+echo "Hello, World!"
+```
+""",
+
+    "test.sh": """#!/bin/bash
+# ~/~ begin <<input.md#test.sh>>[init]
+
+echo "Hello, World!"
+# ~/~ end
+""",
+
+    "test.sh.modified": """#!/bin/bash
+# ~/~ begin <<input.md#test.sh>>[init]
+
+echo "Hello, Universe!"
+# ~/~ end
+""",
+
+    "input.md.modified": """
+A script with a she-bang!
+
+``` {.bash file=test.sh}
+#!/bin/bash
+
+echo "Hello, Universe!"
+```
+"""})
+
+
+def test_shebang():
+    doc = Document()
+    doc.config |= ConfigUpdate(version="2.4", hooks=["shebang"])
+
+    with transaction(fs=fs) as t:
+        doc.load_source(t, Path("input.md"))
+
+        ref = ReferenceId(ReferenceName((), "test.sh"), PurePath("input.md"), 0)
+        assert ref in doc.reference_map
+
+        assert doc.reference_map[ref].header == "#!/bin/bash" + eol
+        code_content, _ = doc.target_text(PurePath("test.sh"))
+        assert code_content.strip() == t.fs[Path("test.sh")].content.strip()
+
+        doc.load_code(t, Path("test.sh.modified"))
+        md_content, _ = doc.source_text(Path("input.md"))
+        assert md_content.strip() == t.fs[Path("input.md.modified")].content.strip()
+
diff --git a/test/hooks/test_spdx_license.py b/test/hooks/test_spdx_license.py
new file mode 100644
index 0000000..b47cbd3
--- /dev/null
+++ b/test/hooks/test_spdx_license.py
@@ -0,0 +1,77 @@
+from entangled.config import ConfigUpdate
+from entangled.interface import Document
+from entangled.model import ReferenceName, ReferenceId
+from entangled.io import VirtualFS, transaction
+
+from pathlib import PurePath, Path
+
+eol = "\n"
+
+fs = VirtualFS.from_dict({
+    "input.md": """
+A C file with a license!
+
+``` {.c file=test.c}
+// SPDX-License-Identifier: MIT
+#include <stdio.h>
+
+int main() {
+    printf("Hello, World!\n");
+    return 0;
+}
+```
+""",
+
+    "output_test.c": """// SPDX-License-Identifier: MIT
+// ~/~ begin <<input.md#test.c>>[init]
+#include <stdio.h>
+
+int main() {
+    printf("Hello, World!\n");
+    return 0;
+}
+// ~/~ end
+""",
+
+    "output_test.c.modified": """// SPDX-License-Identifier: MIT
+// ~/~ begin <<input.md#test.c>>[init]
+
+int main() {
+    printf("Hello, World!\n");
+    return 0;
+}
+// ~/~ end
+""",
+
+    "input.md.modified": """
+A C file with a license!
+
+``` {.c file=test.c}
+// SPDX-License-Identifier: MIT
+
+int main() {
+    printf("Hello, World!\n");
+    return 0;
+}
+```
+"""})
+
+
+def test_spdx_license():
+    doc = Document()
+    doc.config |= ConfigUpdate(version="2.4", hooks=["spdx_license"])
+
+    with transaction(fs=fs) as t:
+        doc.load_source(t, Path("input.md"))
+
+        ref = ReferenceId(ReferenceName((), "test.c"), PurePath("input.md"), 0)
+        assert ref in doc.reference_map
+
+        assert doc.reference_map[ref].header == "// SPDX-License-Identifier: MIT" + eol
+        code_content, _ = doc.target_text(PurePath("test.c"))
+        assert code_content.strip() == t.fs[Path("output_test.c")].content.strip()
+
+        doc.load_code(t, Path("output_test.c.modified"))
+        md_content, _ = doc.source_text(Path("input.md"))
+        assert md_content.strip() == t.fs[Path("input.md.modified")].content.strip()
+
diff --git a/test/integration/test_attribute_types.py b/test/integration/test_attribute_types.py
new file mode 100644
index 0000000..e1ebf58
--- /dev/null
+++ b/test/integration/test_attribute_types.py
@@ -0,0 +1,82 @@
+from entangled.interface import Document
+from entangled.io import VirtualFS, transaction
+from entangled.errors.user import CodeAttributeError
+from entangled.model import ReferenceName, ReferenceId
+
+from pathlib import Path
+import pytest
+
+
+fs = VirtualFS.from_dict({
+    "wrongly_typed_attribute1.md": """
+---
+entangled:
+    version: "2.4"
+    style: basic
+---
+
+```python
+#| file: 3
+```
+""".lstrip(),
+
+
+    "octal_mode_attribute2.md": """
+---
+entangled:
+    version: "2.4"
+    style: basic
+---
+
+Note, the mode here is given in octal, and the YAML reader understands this, so this is
+supported.
+
+```python
+#| file: hello.py
+#| mode: 0755
+#!/usr/bin/env python
+print("Hello, World!")
+```
+""".lstrip(),
+
+
+    "octal_mode_attribute1.md": """
+``` {.python file=hello.py mode=0755}
+print("Hello, World!")
+```
+""".lstrip(),
+
+    "wrongly_typed_mode_attribute.md": """
+---
+entangled:
+    version: "2.4"
+    style: basic
+---
+
+```python
+#| file: hello.py
+#| mode: true
+print("Hello, World!")
+```
+""".lstrip()})
+
+
+def test_file_attribute_type():
+    doc = Document()
+    with transaction(fs=fs) as t:
+        refs = doc.reference_map
+
+        with pytest.raises(CodeAttributeError):
+            doc.load_source(t, Path("wrongly_typed_attribute1.md"))
+
+        with pytest.raises(CodeAttributeError):
+            doc.load_source(t, Path("wrongly_typed_mode_attribute.md"))
+
+        for i in range(1, 3):
+            src = Path(f"octal_mode_attribute{i}.md")
+            doc.load_source(t, src)
+            ref = ReferenceId(ReferenceName((), "hello.py"), src, 0)
+            assert ref in refs
+            assert refs[ref].mode == 0o755
+        
+
diff --git a/test/integration/test_namespace_x.py b/test/integration/test_namespace_x.py
new file mode 100644
index 0000000..17cad58
--- /dev/null
+++ b/test/integration/test_namespace_x.py
@@ -0,0 +1,59 @@
+from entangled.config import AnnotationMethod
+from entangled.io import VirtualFS, transaction
+from entangled.interface import Document
+from entangled.model import ReferenceName
+from pathlib import Path
+
+fs = VirtualFS.from_dict({
+    "q.md": """
+---
+entangled:
+    version: "2.4"
+    namespace: q
+---
+
+``` {.python #hello}
+print("hello")
+```
+""".strip(),
+
+    "p.md": """
+---
+entangled:
+    version: "2.4"
+    namespace: p
+---
+
+``` {.python #hello}
+print("world")
+```
+
+``` {.python file=combined.py}
+<<q::hello>>
+<<hello>>
+```
+""".strip()})
+
+def test_yaml_namespace():
+    doc = Document()
+    with transaction(fs=fs) as t:
+        update = doc.load_source(t, Path("q.md"))
+        assert update and update.namespace == "q"
+        update = doc.load_source(t, Path("p.md"))
+        assert update and update.namespace == "p"
+
+        refs = doc.reference_map
+        refq = ReferenceName.from_str("q::hello")
+        assert refs.has_name(refq)
+        cb = [refs[r] for r in refs.select_by_name(refq)]
+        assert cb[0].source == "print(\"hello\")\n"
+
+        refp = ReferenceName.from_str("p::hello")
+        assert refs.has_name(refp)
+        cb = [refs[r] for r in refs.select_by_name(refp)]
+        assert cb[0].source == "print(\"world\")\n"
+
+        doc.tangle(t, AnnotationMethod.NAKED)
+
+    assert fs[Path("combined.py")].content == "print(\"hello\")\nprint(\"world\")\n"
+
diff --git a/test/integration/test_os_interop.py b/test/integration/test_os_interop.py
new file mode 100644
index 0000000..27173df
--- /dev/null
+++ b/test/integration/test_os_interop.py
@@ -0,0 +1,25 @@
+from entangled.interface import Document
+from entangled.io import transaction
+from entangled.model import ReferenceName, ReferenceId
+
+from pathlib import Path, PurePath
+from shutil import copytree
+from contextlib import chdir
+
+
+def test_tangle_ref(data, tmp_path):
+    copytree(data / "os_interop", tmp_path / "os_interop")
+    with chdir(tmp_path / "os_interop"):
+        doc = Document()
+        with transaction() as t:
+            doc.load_source(t, Path("doc/index.md"))
+            euler_text, deps = doc.target_text(Path("src/euler_number.c"))
+            assert deps == {PurePath("doc/index.md")}
+            with open("src/euler_number.c", "r") as f:
+                assert f.read().strip() == euler_text.strip()
+
+        ref = ReferenceId(ReferenceName((), "series-expansion"), PurePath("doc/index.md"), 0)
+        cb_old = doc.reference_map[ref].source
+        doc.load_code(t, Path("src/euler_number.c.edit"))
+        cb_new = doc.reference_map[ref].source
+        assert cb_old != cb_new
diff --git a/test/test_typst.py b/test/integration/test_typst.py
similarity index 100%
rename from test/test_typst.py
rename to test/integration/test_typst.py
diff --git a/test/integration/test_unknown_language.py b/test/integration/test_unknown_language.py
new file mode 100644
index 0000000..94349d8
--- /dev/null
+++ b/test/integration/test_unknown_language.py
@@ -0,0 +1,22 @@
+from entangled.interface import Document
+from entangled.io import VirtualFS, transaction
+import logging
+from pathlib import Path
+
+fs = VirtualFS.from_dict({
+    "brainfuck.md": """
+``` {.brainfuck #hello-world}
+>++++++++[<+++++++++>-]<.>++++[<+++++++>-]<+.+++++++..+++.>>++++++[<+++++++>-]<+
++.------------.>++++++[<+++++++++>-]<+.<.+++.------.--------.>>>++++[<++++++++>-
+]<+.
+```
+""".strip()})
+
+
+def test_unknown_language(caplog):
+    doc = Document()
+    with transaction(fs=fs) as t:
+        with caplog.at_level(logging.WARNING):
+            doc.load_source(t, Path("brainfuck.md"))
+            assert "language `brainfuck` unknown" in caplog.text
+
diff --git a/test/interface/test_document.py b/test/interface/test_document.py
new file mode 100644
index 0000000..2d9201d
--- /dev/null
+++ b/test/interface/test_document.py
@@ -0,0 +1,77 @@
+from pathlib import Path
+
+from entangled.io import VirtualFS, transaction
+from entangled.config import ConfigUpdate, AnnotationMethod
+from entangled.interface import Document
+
+
+fs = VirtualFS.from_dict({
+    "fib.md": """
+---
+entangled:
+    version: "2.4"
+    style: basic
+    annotation: naked
+---
+
+This is a basic example of an Entangled document. We'll compute Fibonacci numbers
+in Haskell!
+
+```haskell
+-- | id: fibonacci
+fibonacci :: Int -> Int -> [Int]
+fibonacci a b = a : fibonacci b (a + b)
+```
+
+The ability to write lazy expressions like these is unparalelled in other languages.
+
+```haskell
+-- | file: fib.hs
+<<fibonacci>>
+
+main :: IO ()
+main = putStrLn $ show $ take 20 $ fibonacci 1 1
+```
+
+Enjoy!
+""".lstrip(),
+
+
+    "fib.hs": """
+fibonacci :: Int -> Int -> [Int]
+fibonacci a b = a : fibonacci b (a + b)
+
+main :: IO ()
+main = putStrLn $ show $ take 20 $ fibonacci 1 1
+""".lstrip(),
+
+
+    "fib_annot.hs": """
+-- ~/~ begin <<fib.md#fib.hs>>[init]
+-- ~/~ begin <<fib.md#fibonacci>>[init]
+fibonacci :: Int -> Int -> [Int]
+fibonacci a b = a : fibonacci b (a + b)
+-- ~/~ end
+
+main :: IO ()
+main = putStrLn $ show $ take 20 $ fibonacci 1 1
+-- ~/~ end
+""".lstrip()})
+
+
+def test_document():
+    doc = Document()
+
+    with transaction(fs=fs) as t:
+        path = Path("fib.md")
+        doc.load_source(t, path)
+        assert doc.source_text(path)[0] == fs[path].content
+        
+        doc.config |= ConfigUpdate(version="2.4", annotation=AnnotationMethod.NAKED)
+        fib_hs, _ = doc.target_text(Path("fib.hs"))
+        assert fib_hs == fs[Path("fib.hs")].content
+
+        doc.config |= ConfigUpdate(version="2.4", annotation=AnnotationMethod.STANDARD)
+        fib_hs, _ = doc.target_text(Path("fib.hs"))
+        assert fib_hs == fs[Path("fib_annot.hs")].content
+
diff --git a/test/test_filedb.py b/test/io/test_filedb.py
similarity index 100%
rename from test/test_filedb.py
rename to test/io/test_filedb.py
diff --git a/test/test_transaction.py b/test/io/test_transaction.py
similarity index 100%
rename from test/test_transaction.py
rename to test/io/test_transaction.py
diff --git a/test/iterators/test_lines.py b/test/iterators/test_lines.py
new file mode 100644
index 0000000..8f98f67
--- /dev/null
+++ b/test/iterators/test_lines.py
@@ -0,0 +1,23 @@
+from pathlib import PurePath
+from entangled.iterators import lines, numbered_lines, Peekable
+from entangled.text_location import TextLocation
+
+
+def test_lines():
+    def ll(inp: str):
+        return list(lines(inp))
+
+    assert ll("") == [""]
+    assert ll("\n") == ["\n", ""]
+    assert ll("a\nb") == ["a\n", "b"]
+    assert ll("a\nb\n") == ["a\n", "b\n", ""]
+    assert ll("a\r\nb\r\n") == ["a\r\n", "b\r\n", ""]
+
+
+def test_numbered_lines():
+    assert isinstance(numbered_lines(PurePath("-"), ""), Peekable)
+    assert list(numbered_lines(PurePath("-"), "a\nb\n")) == [
+        (TextLocation(PurePath("-"), 1), "a\n"),
+        (TextLocation(PurePath("-"), 2), "b\n"),
+        (TextLocation(PurePath("-"), 3), "")
+    ]
diff --git a/test/iterators/test_peekable.py b/test/iterators/test_peekable.py
new file mode 100644
index 0000000..beb5c77
--- /dev/null
+++ b/test/iterators/test_peekable.py
@@ -0,0 +1,24 @@
+from collections.abc import Generator
+import pytest
+from entangled.iterators.peekable import Peekable, peekable
+
+
+def test_peekable_class():
+    p = Peekable(iter(range(5)))
+    assert p
+    assert p.peek() == 0
+    assert next(p) == 0
+    assert p.peek() == 1
+    assert list(p) == [1, 2, 3, 4]
+    assert not p
+
+    with pytest.raises(StopIteration):
+        _ = p.peek()
+
+
+def test_peekable_decorator():
+    @peekable
+    def counter() -> Generator[int]:
+        yield from range(10)
+
+    assert isinstance(counter(), Peekable)
diff --git a/test/iterators/test_run_generator.py b/test/iterators/test_run_generator.py
new file mode 100644
index 0000000..c1ef4fc
--- /dev/null
+++ b/test/iterators/test_run_generator.py
@@ -0,0 +1,18 @@
+from entangled.iterators import run_generator
+
+
+def g():
+    yield 1
+    yield 2
+    return 3
+
+
+def h():
+    return 1
+    yield 0
+
+
+def test_run_generator():
+    assert run_generator(g()) == ([1, 2], 3)
+    assert run_generator(h()) == ([], 1)
+
diff --git a/test/model/test_code_block.py b/test/model/test_code_block.py
new file mode 100644
index 0000000..9e98325
--- /dev/null
+++ b/test/model/test_code_block.py
@@ -0,0 +1,52 @@
+from pathlib import PurePath
+from textwrap import indent
+from entangled.model.code_block import CodeBlock
+from entangled.text_location import TextLocation
+
+eol = "\n"
+
+expected_2 = """
++```
++hello
++
++goodbye
++```
+""".lstrip()
+
+
+expected_3 = """  ```
+  hello
+
+  goodbye
+  ```
+"""
+
+
+def test_code_block():
+    cb = CodeBlock(
+        properties=[],
+        open_line=f"```{eol}",
+        close_line=f"```{eol}",
+        source=f"hello{eol}",
+        indent="> ",
+        origin=TextLocation(PurePath("-"), 1)
+    )
+
+    expected = f"```{eol}hello{eol}```{eol}"
+    assert cb.text == expected
+    assert cb.indented_text == indent(expected.rstrip(), "> ") + "\n"
+
+    cb = CodeBlock(
+        properties=[],
+        open_line=f"```{eol}",
+        close_line=f"```{eol}",
+        source=f"hello{eol}{eol}goodbye{eol}",
+        indent="+",
+        origin=TextLocation(PurePath("-"), 1)
+    )
+    assert cb.indented_text == expected_2
+
+    cb.indent = "  "
+    assert cb.indented_text == expected_3
+
+
diff --git a/test/model/test_content.py b/test/model/test_content.py
new file mode 100644
index 0000000..65d8f99
--- /dev/null
+++ b/test/model/test_content.py
@@ -0,0 +1,15 @@
+from entangled.text_location import TextLocation
+from entangled.model import ReferenceMap, ReferenceId, ReferenceName, CodeBlock
+from entangled.model.content import PlainText, content_to_text
+
+from pathlib import PurePath
+
+def test_content_to_text():
+    refs = ReferenceMap()
+    ref = ReferenceId(ReferenceName((), "a"), PurePath("a.md"), 0)
+    code_block = CodeBlock(properties=[], indent="", open_line="", source="x", close_line="", origin=TextLocation(PurePath(""), 0))
+    refs[ref] = code_block
+
+    assert content_to_text(refs, ref)[0] == "x"
+    assert content_to_text(refs, PlainText("y"))[0] == "y"
+
diff --git a/test/model/test_cycles.py b/test/model/test_cycles.py
new file mode 100644
index 0000000..7b4076c
--- /dev/null
+++ b/test/model/test_cycles.py
@@ -0,0 +1,71 @@
+import pytest
+
+from entangled.interface import Document
+from entangled.io import VirtualFS, transaction
+from entangled.model import ReferenceName
+from entangled.model.tangle import tangle_ref, CyclicReference
+from entangled.config import AnnotationMethod
+
+from pathlib import Path
+
+
+fs = VirtualFS.from_dict({
+    "input.md": """
+This should raise a `CyclicReference` error.
+
+``` {.python #hello}
+<<hello>>
+```
+
+So should this:
+
+``` {.python #phobos}
+<<deimos>>
+```
+
+``` {.python #deimos}
+<<phobos>>
+```
+
+also when tangling from something else:
+
+``` {.python #mars}
+<<phobos>>
+```
+
+What should not throw an error is doubling a reference:
+
+``` {.python #helium}
+<<electron>>
+<<electron>>
+```
+
+``` {.python #electron}
+negative charge
+```
+"""})
+
+
+@pytest.mark.timeout(5)
+def test_cycles():
+    doc = Document()
+    with transaction(fs=fs) as t:
+        doc.load_source(t, Path("input.md"))
+
+    refs = doc.reference_map
+
+    with pytest.raises(CyclicReference):
+        _ = tangle_ref(refs, ReferenceName((), "hello"), AnnotationMethod.NAKED)
+
+    with pytest.raises(CyclicReference):
+        _ = tangle_ref(refs, ReferenceName((), "phobos"), AnnotationMethod.NAKED)
+
+    try:
+        _ = tangle_ref(refs, ReferenceName((), "mars"), AnnotationMethod.NAKED)
+    except CyclicReference as e:
+        assert e.cycle == ["mars[0]", "phobos[0]", "deimos[0]"]
+        assert all(planet in str(e) for planet in ["mars", "phobos", "deimos"])
+
+    result, _ = tangle_ref(refs, ReferenceName((), "helium"), AnnotationMethod.NAKED)
+    assert result == "negative charge\nnegative charge\n"
+
diff --git a/test/model/test_id_and_file_target.py b/test/model/test_id_and_file_target.py
new file mode 100644
index 0000000..208a489
--- /dev/null
+++ b/test/model/test_id_and_file_target.py
@@ -0,0 +1,76 @@
+from entangled.interface import Document
+from entangled.io import VirtualFS, transaction
+from entangled.config import AnnotationMethod
+from entangled.model import tangle_ref, ReferenceName
+
+from pathlib import PurePath, Path
+
+
+fs = VirtualFS.from_dict({
+    "input.md": """
+``` {.rust file=test1.rs #blockid1}
+fn main() {
+    println!("Hello, World!");
+}
+```
+
+``` {.rust #blockid2 file=test2.rs}
+fn main() {
+    println!("Hello, World!");
+}
+```
+
+``` {.rust #blockid3 file=test3.rs}
+fn fac(i: u64) -> u64 {
+    result: u64 = 1;
+    for j in 1..i {
+        result *= j;
+    }
+    return result;
+}
+```
+
+``` {.rust #blockid3}
+fn main() {
+    println!("42! = {}", fac(42));
+}
+```
+"""})
+
+result1_out = result2_out = """
+fn main() {
+    println!("Hello, World!");
+}
+"""
+
+result3_out = """
+fn fac(i: u64) -> u64 {
+    result: u64 = 1;
+    for j in 1..i {
+        result *= j;
+    }
+    return result;
+}
+fn main() {
+    println!("42! = {}", fac(42));
+}
+"""
+
+def test_id_and_file_target():
+    doc = Document()
+    with transaction(fs=fs) as t:
+        doc.load_source(t, Path("input.md"))
+
+    refs = doc.reference_map
+
+    content1, _ = tangle_ref(refs, ReferenceName((), "blockid1"), AnnotationMethod.NAKED)
+    assert content1.strip() == result1_out.strip()
+    content2, _ = tangle_ref(refs, ReferenceName((), "blockid2"), AnnotationMethod.NAKED)
+    assert content2.strip() == result2_out.strip()
+    content3, _ = tangle_ref(refs, ReferenceName((), "blockid3"), AnnotationMethod.NAKED)
+    assert content3.strip() == result3_out.strip()
+
+    assert sorted(refs.targets()) == [PurePath(f"test{i}.rs") for i in range(1, 4)]
+    for i in range(1, 4):
+        assert refs.select_by_target(PurePath(f"test{i}.rs")) == ReferenceName((), f"blockid{i}")
+
diff --git a/test/model/test_missing_ref.py b/test/model/test_missing_ref.py
new file mode 100644
index 0000000..82f2356
--- /dev/null
+++ b/test/model/test_missing_ref.py
@@ -0,0 +1,28 @@
+from entangled.interface import Document
+from entangled.io import VirtualFS, transaction
+from entangled.config import AnnotationMethod
+from entangled.model.tangle import tangle_ref, MissingReference
+from entangled.model import ReferenceName
+
+import pytest
+from pathlib import Path
+
+
+fs = VirtualFS.from_dict({
+    "input.md": """
+``` {.scheme #hello}
+(display "hello") (newline)
+<<goodbye>>
+```
+""".lstrip()})
+
+
+def test_missing_ref():
+    doc = Document()
+    with transaction(fs=fs) as t:
+        doc.load_source(t, Path("input.md"))
+
+    refs = doc.reference_map
+    with pytest.raises(MissingReference) as excinfo:
+        _ = tangle_ref(refs, ReferenceName((), "hello"), AnnotationMethod.NAKED)
+    assert "goodbye" in str(excinfo.value)
diff --git a/test/test_properties.py b/test/model/test_properties.py
similarity index 88%
rename from test/test_properties.py
rename to test/model/test_properties.py
index 8247800..6e3b12c 100644
--- a/test/test_properties.py
+++ b/test/model/test_properties.py
@@ -1,4 +1,4 @@
-from entangled.properties import read_properties, Id, Class, Attribute
+from entangled.model.properties import read_properties, Id, Class, Attribute
 
 
 def test_id():
diff --git a/test/model/test_reference_map.py b/test/model/test_reference_map.py
new file mode 100644
index 0000000..c11b906
--- /dev/null
+++ b/test/model/test_reference_map.py
@@ -0,0 +1,57 @@
+from entangled.model import CodeBlock, ReferenceName, ReferenceMap, Property, Attribute
+from entangled.model.reference_map import ReferenceMap
+from entangled.text_location import TextLocation
+from entangled.errors.internal import InternalError
+from entangled.model.properties import Attribute
+
+from pathlib import PurePath
+
+import pytest
+
+def mock_code_block(properties: list[Property] | None = None) -> CodeBlock:
+    return CodeBlock(properties=properties or [], indent="", open_line="", close_line="", source="", origin=TextLocation(PurePath("-"), 0))
+
+def ref(name: str) -> ReferenceName:
+    return ReferenceName((), name)
+
+def test_reference_map():
+    refs = ReferenceMap()
+    assert bool(refs) == False
+    r1 = refs.new_id(PurePath("x.md"), ref("a"))
+    cb1 = mock_code_block()
+    assert r1 not in refs
+    refs[r1] = cb1
+    assert r1 in refs
+    assert refs[r1] is cb1
+
+    with pytest.raises(InternalError):
+        refs[r1] = mock_code_block()
+
+    r2 = refs.new_id(PurePath("x.md"), ref("a"))
+    refs[r2] = mock_code_block()
+    assert r2.ref_count == 1
+    r3 = refs.new_id(PurePath("y.md"), ref("a"))
+    refs[r3] = mock_code_block()
+    assert r3.ref_count == 0
+    assert refs.select_by_name(ref("a")) == [r1, r2, r3]
+
+    assert list(refs.targets()) == []
+    refs.register_target(PurePath("a.py"), ref("a"))
+    assert refs.select_by_target(PurePath("a.py")) == ref("a")
+
+    cb2 = mock_code_block([Attribute("file", "b.py")])
+    r4 = refs.new_id(PurePath("x.md"), ref("b"))
+    refs[r4] = cb2
+    assert refs.select_by_target(PurePath("b.py")) == ref("b")
+    assert sorted(refs.targets()) == [PurePath("a.py"), PurePath("b.py")]
+
+    assert len(refs) == 4
+    assert set(refs) == { r1, r2, r3, r4 }
+
+    r5 = refs.new_id(PurePath("x.md"), ref("b"))
+    del refs[r5]
+    assert len(refs) == 4
+    del refs[r4]
+    assert len(refs) == 3
+    assert r4 not in refs 
+
diff --git a/test/model/test_reference_name.py b/test/model/test_reference_name.py
new file mode 100644
index 0000000..0432745
--- /dev/null
+++ b/test/model/test_reference_name.py
@@ -0,0 +1,16 @@
+from entangled.model.reference_name import ReferenceName
+
+
+def test_reference_name():
+    n1 = ReferenceName.from_str("a")
+    assert n1.namespace == ()
+    assert n1.name == "a"
+    assert str(n1) == "a"
+
+    n2 = ReferenceName.from_str("a::b::c")
+    assert n2.namespace == ("a", "b")
+    assert n2.name == "c"
+    assert str(n2) == "a::b::c"
+
+    assert hash(n1) != hash(n2)
+
diff --git a/test/model/test_tangle.py b/test/model/test_tangle.py
new file mode 100644
index 0000000..7e86666
--- /dev/null
+++ b/test/model/test_tangle.py
@@ -0,0 +1,135 @@
+from entangled.config import Config, AnnotationMethod
+from entangled.readers import run_reader
+from entangled.model import ReferenceMap, ReferenceName, ReferenceId, tangle_ref
+from entangled.model.tangle import MissingLanguageError, MissingReference
+from entangled.interface import Context, markdown
+
+from pathlib import PurePath
+from functools import partial
+
+import pytest
+import textwrap
+
+
+input1_md = """
+``` {.python #f}
+def f(n):
+    <<f-condition>>
+```
+
+``` {.python #f-condition}
+if n == 0:
+    <<f-base-case>>
+else:
+    <<f-recursion>>
+```
+
+``` {.python #f-base-case}
+return 1
+```
+
+``` {.python #f-recursion}
+return n * f(n - 1)
+```
+
+``` {.python #g}
+print('a')
+```
+
+``` {.python #g}
+print('b')
+```
+
+``` {.python #g}
+print('c')
+```
+
+``` {.python #main}
+#!/usr/bin/python
+
+if __name__ == "__main__":
+    <<g>>
+```
+
+``` {.python #e}
+<<not-here>>
+```
+""".lstrip()
+
+
+naked_tangle_1 = """
+def f(n):
+    if n == 0:
+        return 1
+    else:
+        return n * f(n - 1)
+""".lstrip()
+
+
+annot_tangle_1 = """
+# ~/~ begin <<-#f>>[init]
+def f(n):
+    # ~/~ begin <<-#f-condition>>[init]
+    if n == 0:
+        # ~/~ begin <<-#f-base-case>>[init]
+        return 1
+        # ~/~ end
+    else:
+        # ~/~ begin <<-#f-recursion>>[init]
+        return n * f(n - 1)
+        # ~/~ end
+    # ~/~ end
+# ~/~ end
+""".lstrip()
+
+
+def ref(name: str, num: int = 0) -> ReferenceId:
+    return ReferenceId(ReferenceName((), name), PurePath("-"), num)
+
+
+def test_nested_indent():
+    refs = ReferenceMap()
+    _ = run_reader(partial(markdown, Context(), refs), input1_md)
+    n1, _ = tangle_ref(refs, ReferenceName((), "f"), AnnotationMethod.NAKED)
+    assert n1 == naked_tangle_1
+    n1_annot, _ = tangle_ref(refs, ReferenceName((), "f"), AnnotationMethod.STANDARD)
+    print(n1_annot)
+    assert n1_annot == annot_tangle_1
+
+
+def test_missing_language():
+    # this should never happen, but the data model allows for it
+    refs = ReferenceMap()
+    _ = run_reader(partial(markdown, Context(), refs), input1_md)
+    code_block = refs[ref("f-condition")]
+    code_block.language = None
+
+    with pytest.raises(MissingLanguageError) as exc:
+        _ = tangle_ref(refs, ReferenceName((), "f"), AnnotationMethod.STANDARD)
+
+    assert "-:6" in str(exc.value)
+
+
+def test_sequence():
+    refs = ReferenceMap()
+    _ = run_reader(partial(markdown, Context(), refs), input1_md)
+    g1, _ = tangle_ref(refs, ReferenceName((), "g"), AnnotationMethod.NAKED)
+    assert g1 == "print('a')\nprint('b')\nprint('c')\n"
+    g2, _ = tangle_ref(refs, ReferenceName((), "main"), AnnotationMethod.NAKED)
+    assert g2 == "#!/usr/bin/python\n\nif __name__ == \"__main__\":\n" + textwrap.indent(g1, "    ")
+
+    g2_annot, _ = tangle_ref(refs, ReferenceName((), "main"))
+    assert g2_annot.startswith("#!/usr/bin/python\n")
+
+
+def test_absent_ref():
+    refs = ReferenceMap()
+    _ = run_reader(partial(markdown, Context(), refs), input1_md)
+
+    with pytest.raises(KeyError):
+        _ = tangle_ref(refs, ReferenceName((), "z"))
+
+    with pytest.raises(MissingReference) as exc:
+        _ = tangle_ref(refs, ReferenceName((), "e"))
+
+    assert "not-here" in str(exc.value)
diff --git a/test/readers/test_code.py b/test/readers/test_code.py
new file mode 100644
index 0000000..a21ee82
--- /dev/null
+++ b/test/readers/test_code.py
@@ -0,0 +1,142 @@
+from pathlib import PurePath
+
+from entangled.readers.code import read_top_level, read_block
+from entangled.readers import run_reader
+from entangled.model import ReferenceId, ReferenceName
+from entangled.errors.user import IndentationError, ParseError
+from entangled.iterators import run_generator, Peekable
+
+import pytest
+
+
+hs_tgt_annotated = """
+-- ~/~ begin <<fib.md#fib.hs>>[init]
+-- ~/~ begin <<fib.md#fibonacci>>[init]
+fibonacci :: Int -> Int -> [Int]
+fibonacci a b = a : fibonacci b (a + b)
+-- ~/~ end
+
+main :: IO ()
+main = putStrLn $ show $ take 20 $ fibonacci 1 1
+-- ~/~ end
+""".lstrip()
+
+
+block0 = """
+fibonacci :: Int -> Int -> [Int]
+fibonacci a b = a : fibonacci b (a + b)
+""".lstrip()
+
+
+block1 = """
+<<fibonacci>>
+
+main :: IO ()
+main = putStrLn $ show $ take 20 $ fibonacci 1 1
+""".lstrip()
+
+
+def test_code_reader():
+    blocks, _ = run_reader(read_top_level, hs_tgt_annotated)
+    assert blocks[0].reference_id == ReferenceId(ReferenceName((), "fibonacci"), PurePath("fib.md"), 0)
+    assert blocks[0].content == block0
+    assert blocks[1].reference_id == ReferenceId(ReferenceName((), "fib.hs"), PurePath("fib.md"), 0)
+    assert blocks[1].content == block1
+
+
+code2 = """
+# ~/~ begin <<a.md#a.py>>[init]
+only this:
+    # ~/~ begin <<a.md#a>>[init]
+    a1
+    # ~/~ end
+    # ~/~ begin <<a.md#a>>[1]
+    a2
+    # ~/~ end
+    # ~/~ begin <<a.md#a>>[init]
+    a1
+    # ~/~ end
+    # ~/~ begin <<a.md#a>>[1]
+    a2
+    # ~/~ end
+# ~/~ end
+""".lstrip()
+
+
+code2_apy = """
+only this:
+    <<a>>
+    <<a>>
+""".lstrip()
+
+
+def test_ref_twice():
+    blocks, _ = run_reader(read_top_level, code2)
+    assert blocks[0].reference_id == ReferenceId(ReferenceName((), "a"), PurePath("a.md"), 0)
+    assert blocks[4].content == code2_apy
+
+
+code3 = """
+#!shebang!
+# ~/~ begin <<a.md#a.py>>[init]
+and this
+# ~/~ end
+""".lstrip()
+
+
+hasshebang = """
+and this
+""".lstrip()
+
+
+def test_header():
+    blocks, _ = run_reader(read_top_level, code3)
+    assert blocks[0].content == hasshebang
+
+
+indent_error1 = """
+    # ~/~ begin <<a.md#a.py>>[init]
+This is an error
+    # ~/~ end
+"""
+
+indent_error2 = """
+# ~/~ begin <<a.md#a.py>>[init]
+This is an error
+    # ~/~ end
+"""
+
+indent_error3 = """
+    # ~/~ begin <<a.md#a.py>>[init]
+    This is an error
+# ~/~ end
+"""
+
+indent_error4 = """
+    # ~/~ begin <<a.md#a.py>>[init]
+# ~/~ begin <<a.md#b>>[init]
+This is an error
+# ~/~ end
+    # ~/~ end
+"""
+
+
+def test_indent_errors():
+    for inp in [indent_error1, indent_error2, indent_error3, indent_error4]:
+        with pytest.raises(IndentationError):
+            _ = run_reader(read_top_level, inp)
+
+
+def test_empty():
+    assert run_generator(read_top_level(Peekable(iter([])))) == ([], None)
+    assert run_generator(read_block((), "", Peekable(iter([])))) == ([], None)
+
+
+eof_error = """
+# ~/~ begin <<a.md#a.py>>[init]
+This is an error
+"""
+
+def test_eof():
+    with pytest.raises(ParseError):
+        _ = run_reader(read_top_level, eof_error)
diff --git a/test/readers/test_indentation.py b/test/readers/test_indentation.py
new file mode 100644
index 0000000..9f3f259
--- /dev/null
+++ b/test/readers/test_indentation.py
@@ -0,0 +1,66 @@
+from entangled.interface import Document
+from entangled.model import ReferenceId
+from entangled.io import VirtualFS, transaction
+from entangled.errors.user import UserError
+
+from pathlib import Path
+
+import pytest
+
+
+fs = VirtualFS.from_dict({
+    "a.md": """
+This code block is indented:
+
+    ``` {.python}
+    hello
+
+    goodbye
+    ```
+
+Note the lack of indentation due to a blank line.
+""".lstrip(),
+
+    "indent_error_1.md": """
+This code is indented, but contains a line that is not correctly indented:
+
+    ``` {.python}
+hello
+    ```
+""".lstrip(),
+
+    "indent_error_2.md": """
+This code is indented, but the closing fence indent doesn't match the opening:
+
+    ``` {.python}
+    hello
+      ```
+
+This should raise an `unexpected end of file`.
+""".lstrip(),
+
+    "indent_error_3.md": """
+This code is indented, but the closing fence indent doesn't match the opening:
+
+    ``` {.python}
+    hello
+  ```
+
+This should raise an `indentation error`.
+"""})
+
+
+def test_indentation():
+    doc = Document()
+    with transaction(fs=fs) as t:
+        doc.load_source(t, Path("a.md"))
+        ref = doc.content[Path("a.md")][1]
+        assert isinstance(ref, ReferenceId)
+        assert doc.reference_map[ref].indent == "    "
+
+        assert doc.source_text(Path("a.md"))[0] == fs[Path("a.md")].content
+
+        for i in range(1, 4):
+            with pytest.raises(UserError):
+                doc.load_source(t, Path(f"indent_error_{i}.md"))
+
diff --git a/test/readers/test_markdown.py b/test/readers/test_markdown.py
new file mode 100644
index 0000000..b2dcf0a
--- /dev/null
+++ b/test/readers/test_markdown.py
@@ -0,0 +1,118 @@
+from functools import partial
+
+from entangled.model import PlainText, CodeBlock, ReferenceId, ReferenceMap, ReferenceName
+from entangled.readers.markdown import code_block, collect_plain_text, ignore_block, raw_markdown
+from entangled.iterators import Peekable, run_generator
+from entangled.config import Config
+from entangled.readers import run_reader
+from entangled.interface import markdown, Context
+
+
+empty_stream = Peekable(iter([]))
+
+
+test0 = """
+abcdefg
+""".strip()
+
+
+test1 = """
+~~~markdown
+``` {.python}
+# this code block is ignored
+```
+~~~
+""".strip()
+
+
+def test_ignore_block():
+    ol, _ = run_generator(ignore_block(Config())(empty_stream))
+    assert not ol
+
+    ol, rv = run_reader(ignore_block(Config()), test0)
+    assert not rv and not ol
+
+    ol, rv = run_reader(ignore_block(Config()), test1)
+    assert rv
+    assert ol == [PlainText(test1)]
+
+
+test2 = """
+``` {.python}
+# this code block should be read
+```
+""".strip()
+
+
+test3 = """
+First we have some other input
+
+``` {.python #test}
+# so this should not be read directly by the `code_block` function
+# once we read with `raw_markdown` that should change
+```
+""".strip()
+
+
+def test_code_block():
+    ol, _ = run_generator(code_block(Config())(empty_stream))
+    assert not ol
+
+    ol, rv = run_reader(code_block(Config()), test0)
+    assert not rv and not ol
+
+    ol, rv = run_reader(code_block(Config()), test2)
+    assert rv
+
+    assert len(ol) == 1
+    assert isinstance(ol[0], CodeBlock)
+    assert ol[0].source.strip() == "# this code block should be read"
+
+    ol, rv = run_reader(code_block(Config()), test3)
+    assert not rv and not ol
+
+
+def test_raw_markdown():
+    ol, _ = run_generator(raw_markdown(Config(), empty_stream))
+    assert not ol
+
+    ol, _ = run_reader(partial(raw_markdown, Config()), test0)
+    assert len(ol) == 1
+    assert ol[0] == PlainText("abcdefg")
+
+    ol, _ = run_reader(partial(raw_markdown, Config()), test1)
+    assert not any(isinstance(x, CodeBlock) for x in ol)
+
+    ol, _ = run_reader(partial(raw_markdown, Config()), test2)
+    assert len(ol) == 1
+    assert isinstance(ol[0], CodeBlock)
+    assert ol[0].source.strip() == "# this code block should be read"
+
+    ol, _ = run_reader(partial(raw_markdown, Config()), test3)
+    assert isinstance(ol[0], PlainText)
+    assert ol[0].content.strip() == "First we have some other input"
+    assert isinstance(ol[-1], CodeBlock)
+
+
+def test_collect_plain_text():
+    assert list(collect_plain_text(iter([]))) == []
+    assert list(collect_plain_text(iter([PlainText("a"), PlainText("b"), 4, PlainText("c")]))) == \
+        [PlainText("ab"), 4, PlainText("c")]
+
+
+def test_markdown():
+    refs = ReferenceMap()
+    ol, _ = run_reader(partial(markdown, Context(), refs), test0)
+    assert len(ol) == 1
+    assert ol[0] == PlainText("abcdefg")
+    assert not refs
+
+    ol, _ = run_reader(partial(markdown, Context(), refs), test3)
+    assert isinstance(ol[-1], ReferenceId)
+    assert ol[-1].name.name == "test"
+    assert refs
+    assert refs.has_name(ReferenceName.from_str("test"))
+    assert ol[-1] in refs
+
+
+
diff --git a/test/readers/test_namespaces.py b/test/readers/test_namespaces.py
new file mode 100644
index 0000000..2edb9d8
--- /dev/null
+++ b/test/readers/test_namespaces.py
@@ -0,0 +1,84 @@
+from entangled.interface import Document
+from entangled.config import ConfigUpdate, NamespaceDefault, AnnotationMethod
+from entangled.model import ReferenceName
+from entangled.io import VirtualFS, transaction
+
+from pathlib import Path
+
+
+fs = VirtualFS.from_dict({
+    "a.md": """
+First input:
+
+``` {.python #a}
+# part a
+```
+
+``` {.python file=a.py}
+<<a>>
+```
+""".strip(),
+
+    "b.md": """
+Second input
+
+``` {.python #a}
+# part b
+```
+
+``` {.python file=b.py}
+<<a>>
+```
+""".strip()})
+
+
+def test_global_namespace():
+    doc = Document()
+
+    with transaction(fs=fs) as t:
+        doc.config |= ConfigUpdate(
+            version="2.4",
+            namespace_default=NamespaceDefault.GLOBAL,
+            annotation=AnnotationMethod.NAKED)
+
+        doc.load_source(t, Path("a.md"))
+        doc.load_source(t, Path("b.md"))
+
+        refs = doc.reference_map
+        cb = [refs[r] for r in refs.select_by_name(ReferenceName.from_str("a"))]
+        assert len(cb) == 2
+        assert cb[0].source.strip() == "# part a"
+        assert cb[1].source.strip() == "# part b"
+
+        source, _ = doc.target_text(Path("a.py"))
+        assert source.splitlines() == ["# part a", "# part b"]
+
+
+def test_private_namespace():
+    doc = Document()
+
+    with transaction(fs=fs) as t:
+        doc.config |= ConfigUpdate(
+            version="2.4",
+            namespace_default=NamespaceDefault.PRIVATE,
+            annotation=AnnotationMethod.NAKED)
+
+        doc.load_source(t, Path("a.md"))
+        doc.load_source(t, Path("b.md"))
+        
+        refs = doc.reference_map
+
+        cb = [refs[r] for r in refs.select_by_name(ReferenceName.from_str("a.md::a"))]
+        assert len(cb) == 1
+        assert cb[0].source.strip() == "# part a"
+
+        cb = [refs[r] for r in refs.select_by_name(ReferenceName.from_str("b.md::a"))]
+        assert len(cb) == 1
+        assert cb[0].source.strip() == "# part b"
+
+        source, _ = doc.target_text(Path("a.py"))
+        assert source.splitlines() == ["# part a"]
+
+        source, _ = doc.target_text(Path("b.py"))
+        assert source.splitlines() == ["# part b"]
+
diff --git a/test/readers/test_text_location.py b/test/readers/test_text_location.py
new file mode 100644
index 0000000..65d7a01
--- /dev/null
+++ b/test/readers/test_text_location.py
@@ -0,0 +1,12 @@
+from pathlib import PurePath
+from entangled.text_location import TextLocation
+
+
+def test_text_location():
+    pos = TextLocation(PurePath("foo"), 4)
+    assert str(pos) == "foo:4"
+    pos.increment()
+    assert str(pos) == "foo:5"
+    pos.increment()
+    assert pos.filename == PurePath("foo")
+    assert pos.line_number == 6
diff --git a/test/readers/test_yaml_header.py b/test/readers/test_yaml_header.py
new file mode 100644
index 0000000..3b360f6
--- /dev/null
+++ b/test/readers/test_yaml_header.py
@@ -0,0 +1,90 @@
+from pathlib import PurePath
+import pytest
+
+from entangled.readers.yaml_header import read_yaml_header, get_config
+from entangled.iterators import numbered_lines
+from entangled.errors.user import ParseError, UserError
+from entangled.readers.types import MarkdownStream
+
+
+input_correct = """---
+title: hello
+---
+
+more content
+"""
+
+input_non_terminating = """---
+title: hello
+
+there's no end to this header
+"""
+
+input_no_header = """
+Nothing to see here.
+"""
+
+input_not_on_top = """
+
+---
+title: hello
+---
+
+should this header be parsed or not?
+"""
+
+
+input_invalid_yaml = """---
+}
+---
+"""
+
+input_not_an_object = """
+---
+[1, 2, 3]
+---
+""".strip()
+
+input_invalid = """
+---
+entangled:
+    no_version_given: 0
+---
+""".strip()
+
+
+def get_yaml_header(input: str) -> object:
+    path = PurePath("-")
+    result = None
+
+    def reader() -> MarkdownStream[object]:
+         nonlocal result
+         result = yield from read_yaml_header(numbered_lines(path, input))
+         return
+
+    def run():
+        for _ in reader():
+            pass
+
+    run()
+    return result
+
+
+
+def test_read_yaml_header():
+    assert get_yaml_header(input_correct) == { "title": "hello" }
+    assert get_yaml_header(input_no_header) is None
+    assert get_yaml_header(input_not_on_top) is None
+
+    with pytest.raises(ParseError):
+        _ = get_yaml_header(input_invalid_yaml)
+
+    with pytest.raises(ParseError):
+        _ = get_yaml_header(input_non_terminating)
+
+    with pytest.raises(UserError):
+        _ = get_config(get_yaml_header(input_not_an_object))
+
+    with pytest.raises(UserError):
+        _ = get_config(get_yaml_header(input_invalid))
+
diff --git a/test/test_build_hook.py b/test/test_build_hook.py
deleted file mode 100644
index 3d5f134..0000000
--- a/test/test_build_hook.py
+++ /dev/null
@@ -1,49 +0,0 @@
-from contextlib import chdir
-import subprocess
-
-import pytest
-import sys
-
-from entangled.config import config
-from entangled.commands import tangle
-
-from uuid import uuid4
-from time import sleep
-from pathlib import Path
-
-
-md_input = """
-Create a file:
-
-``` {{.python file=script.py}}
-print("{message}", end="")
-```
-
-``` {{.bash .build target="test.dat" deps="script.py"}}
-python script.py > test.dat
-```
-"""
-
-
-@pytest.mark.skipif(sys.platform == "win32", reason="Skipped on Windows")
-def test_build(tmp_path):
-    message = uuid4().hex
-    with chdir(tmp_path):
-        with open("test.md", "w") as f:
-            f.write(md_input.format(message=message))
-
-        with config(hooks=["build"]):
-            tangle()
-
-        sleep(0.1)
-        with open(".entangled/build/Makefile", "r") as f_in:
-            for l in f_in.readlines():
-                print(l, end="")
-
-        subprocess.call(["make", "-f", ".entangled/build/Makefile"])
-        sleep(0.1)
-
-        tgt = Path("test.dat")
-        assert tgt.exists()
-        contents = open(tgt, "r").read()
-        assert contents == message
diff --git a/test/test_cli.py b/test/test_cli.py
deleted file mode 100644
index b309468..0000000
--- a/test/test_cli.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from entangled.main import cli
-from entangled.version import __version__
-
-from contextlib import contextmanager, chdir
-import sys
-import pytest
-from pathlib import Path
-from time import sleep
-
-
-@contextmanager
-def argv(*args):
-    old = sys.argv
-    sys.argv = ["entangled"] + list(args)
-    yield
-    sys.argv = old
-
-
-def test_version(capsys):
-    with argv("--version"):
-        with pytest.raises(SystemExit):
-            cli()
-        captured = capsys.readouterr()
-        assert captured.out.strip() == f"Entangled {__version__}"
-
-
-def test_watch(tmp_path):
-    with chdir(tmp_path):
-        Path("./entangled.toml").write_text("\n".join(['version="2.0"']))
-        Path("./test.md").write_text(
-            "\n".join(["``` {.python file=test.py}", 'print("hello")', "```"])
-        )
-
-        with argv("--debug", "tangle"):
-            cli()
-            assert Path("./test.py").exists()
diff --git a/test/test_config.py b/test/test_config.py
deleted file mode 100644
index 369172a..0000000
--- a/test/test_config.py
+++ /dev/null
@@ -1,111 +0,0 @@
-from typing import Any
-
-import msgspec
-from entangled.config.version import Version
-from entangled.config.language import Language, Comment
-from entangled.config import config, Config, AnnotationMethod, default
-from entangled.commands import tangle
-
-from contextlib import chdir
-from time import sleep
-from pathlib import Path
-
-
-def construct[T](cls: type[T], obj: object) -> T:
-    return msgspec.convert(obj, type=cls)
-
-
-def test_config_constructable():
-    assert construct(
-        Language,
-        {"name": "French", "identifiers": ["fr"], "comment": {"open": "excusez moi"}},
-    ) == Language("French", ["fr"], Comment("excusez moi"))
-    cfg1 = construct(Config, {"version": "2.0", "annotation": "naked"})
-    assert cfg1.version == Version(numbers=(2, 0))
-    assert cfg1.annotation == AnnotationMethod.NAKED
-
-
-config_with_language = """
-version = "2.0"
-annotation = "naked"
-
-[[languages]]
-name = "Fish"
-identifiers = ["fish"]
-comment = { open = "#" }
-"""
-
-md_source = """
-``` {.fish file=test.fish}
-echo hello world
-```
-"""
-
-
-def test_new_language(tmp_path):
-    with chdir(tmp_path):
-        Path("entangled.toml").write_text(config_with_language)
-        Path("test.md").write_text(md_source)
-        sleep(0.1)
-        config.read(force=True)
-        assert config.get.annotation == AnnotationMethod.NAKED
-        tangle()
-        sleep(0.1)
-        assert Path("test.fish").exists()
-        assert Path("test.fish").read_text() == "echo hello world\n"
-
-
-config_with_more = """
-# required: the minimum version of Entangled
-version = "2.0"
-
-# default watch_list is ["**/*.md"]
-watch_list = ["docs/**/*.md"]
-
-[[languages]]
-name = "Custom Java"
-identifiers = ["java"]
-comment = { open = "//" }
-
-[[languages]]
-name = "XML"
-identifiers = ["xml", "html", "svg"]
-comment = { open = "<!--", close = "-->" }
-"""
-
-
-def test_more_language(tmp_path):
-    with chdir(tmp_path):
-        Path("entangled.toml").write_text(config_with_more)
-        sleep(0.1)
-        config.read(force=True)
-
-        html = config.get_language("html")
-        assert html is not None
-        assert html.name == "XML"
-
-        java = config.get_language("java")
-        assert java is not None
-        assert java.name == "Custom Java"
-
-
-config_in_pyproject = """
-[tool.entangled]
-version = "2.0"
-watch_list = ["docs/*.md"]
-"""
-
-
-def test_pyproject_toml(tmp_path):
-    with chdir(tmp_path):
-        Path("pyproject.toml").write_text("answer=42")
-        sleep(0.1)
-        config.read(force=True)
-
-        assert config.get == default
-
-        Path("pyproject.toml").write_text(config_in_pyproject)
-        sleep(0.1)
-        config.read(force=True)
-
-        assert config.get.watch_list == ["docs/*.md"]
diff --git a/test/test_cycles.py b/test/test_cycles.py
deleted file mode 100644
index c686bd4..0000000
--- a/test/test_cycles.py
+++ /dev/null
@@ -1,63 +0,0 @@
-from pathlib import Path
-import pytest
-
-from entangled.tangle import tangle_ref
-from entangled.markdown_reader import read_markdown_string
-from entangled.errors.user import CyclicReference
-from entangled.config import AnnotationMethod
-
-
-md_source = """
-This should raise a `CyclicReference` error.
-
-``` {.python #hello}
-<<hello>>
-```
-
-So should this:
-
-``` {.python #phobos}
-<<deimos>>
-```
-
-``` {.python #deimos}
-<<phobos>>
-```
-
-also when tangling from something else:
-
-``` {.python #mars}
-<<phobos>>
-```
-
-What should not throw an error is doubling a reference:
-
-``` {.python #helium}
-<<electron>>
-<<electron>>
-```
-
-``` {.python #electron}
-negative charge
-```
-"""
-
-
-@pytest.mark.timeout(5)
-def test_cycles():
-    refs, _ = read_markdown_string(md_source)
-
-    with pytest.raises(CyclicReference):
-        tangle_ref(refs, "hello")
-
-    with pytest.raises(CyclicReference):
-        result, _ = tangle_ref(refs, "phobos")
-        print(result)
-
-    try:
-        tangle_ref(refs, "mars")
-    except CyclicReference as e:
-        assert e.cycle == ["mars", "phobos", "deimos"]
-
-    result, _ = tangle_ref(refs, "helium", AnnotationMethod.NAKED)
-    assert result == "negative charge\nnegative charge"
diff --git a/test/test_from_str.py b/test/test_from_str.py
deleted file mode 100644
index a457441..0000000
--- a/test/test_from_str.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from functools import cached_property
-from typing import Self, override
-from msgspec import Struct, convert, field
-from dataclasses import dataclass
-
-from entangled.from_str import FromStr, dec_hook
-
-
-@dataclass
-class Pt(FromStr):
-    x: int
-    y: int
-
-    @override
-    def to_str(self) -> str:
-        return f"{self.x},{self.y}"
-
-    @override
-    @classmethod
-    def from_str(cls, s: str) -> Self:
-        x, y = map(int, s.split(","))
-        return cls(x=x, y=y)
-
-
-class Spec(Struct, dict=True):
-    _pt: str = field(name = "pt")
-
-    @cached_property
-    def pt(self) -> Pt:
-        return Pt.from_str(self._pt)
-
-
-def test_from_str_msgspec():
-    assert convert({ "pt": "3,4" }, type=Spec, dec_hook=dec_hook).pt == Pt(3, 4)
diff --git a/test/test_id_and_file_target.py b/test/test_id_and_file_target.py
index fb377cf..80aae0b 100644
--- a/test/test_id_and_file_target.py
+++ b/test/test_id_and_file_target.py
@@ -1,5 +1,11 @@
-from entangled.markdown_reader import read_markdown_string
-from entangled.tangle import tangle_ref, AnnotationMethod
+from entangled.config import AnnotationMethod, Config
+from entangled.interface import Context, markdown
+from entangled.readers import run_reader
+from entangled.model import tangle_ref, ReferenceMap, ReferenceName
+
+from functools import partial
+from pathlib import PurePath
+
 
 md_in = """
 ``` {.rust file=test1.rs #blockid1}
@@ -51,19 +57,17 @@
 """
 
 def test_id_and_file_target():
-    refs, _ = read_markdown_string(md_in)
+    refs = ReferenceMap()
+    _ = run_reader(partial(markdown, Context(), refs), md_in)
 
-    content1, _ = tangle_ref(refs, "blockid1", AnnotationMethod.NAKED)
+    content1, _ = tangle_ref(refs, ReferenceName((), "blockid1"), AnnotationMethod.NAKED)
     assert content1.strip() == result1_out.strip()
-    content2, _ = tangle_ref(refs, "blockid2", AnnotationMethod.NAKED)
+    content2, _ = tangle_ref(refs, ReferenceName((), "blockid2"), AnnotationMethod.NAKED)
     assert content2.strip() == result2_out.strip()
-    content3, _ = tangle_ref(refs, "blockid3", AnnotationMethod.NAKED)
+    content3, _ = tangle_ref(refs, ReferenceName((), "blockid3"), AnnotationMethod.NAKED)
     assert content3.strip() == result3_out.strip()
 
-    assert refs.targets == {"test1.rs", "test2.rs", "test3.rs"}
+    assert sorted(refs.targets()) == [PurePath(f"test{i}.rs") for i in range(1, 4)]
     for i in range(1, 4):
-        ref = f"test{i}.rs"
-        bid = f"blockid{i}"
-        c, _ = tangle_ref(refs, ref, AnnotationMethod.NAKED)
-        d, _ = tangle_ref(refs, ref, AnnotationMethod.NAKED)
-        assert c == d
+        assert refs.select_by_target(PurePath(f"test{i}.rs")) == ReferenceName((), f"blockid{i}")
+
diff --git a/test/test_ignore_list.py b/test/test_ignore_list.py
deleted file mode 100644
index c5b7170..0000000
--- a/test/test_ignore_list.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from entangled.config import config
-from entangled.status import find_watch_dirs, list_input_files
-from contextlib import chdir
-from entangled.commands.tangle import tangle
-from pathlib import Path
-
-readme_md = """
-# README
-```{.python file=src/test.py}
-print("test")
-```
-"""
-
-index_md_1 = """
-# Test
-
-``` {.c file=src/test.c}
-#include <stdio.h>
-int main() { printf("Hello, World!\\n"); return 0; }
-```
-"""
-
-index_md_2 = """
-``` {.makefile file=Makefile}
-.RECIPEPREFIX = >
-
-%.o: %.c
-> gcc -c $< -o $@
-
-hello: test.o
-> gcc $^ -o $@
-```
-"""
-
-data_md = """
-Don't tangle me!
-```{.python file=src/test2.py}
-print("test2")
-```
-"""
-
-
-def test_watch_dirs(tmp_path):
-    with chdir(tmp_path):
-        Path("./docs").mkdir()
-        Path("./docs/data").mkdir()
-        Path("./docs/index.md").write_text(index_md_1)
-        Path("./docs/data/data.md").write_text(data_md)
-        Path("./docs/README.md").write_text(readme_md)
-        with config(watch_list=["**/*.md"], ignore_list=["**/data/*", "**/README.md"]):
-            tangle()
-            # data.md and README.md should not be entangled cause they are part
-            # of the ignore list while index.md should be so test2.py, test.py
-            # should not be created while test.c should be created.
-            assert not Path.exists(Path("./src/test2.py"))
-            assert not Path.exists(Path("./src/test.py"))
-            assert Path.exists(Path("./src/test.c"))
diff --git a/test/test_indentation_errors.py b/test/test_indentation_errors.py
deleted file mode 100644
index 9acbc37..0000000
--- a/test/test_indentation_errors.py
+++ /dev/null
@@ -1,107 +0,0 @@
-from entangled.commands import tangle, stitch
-from entangled.markdown_reader import read_markdown_string, read_markdown_file
-from entangled.code_reader import CodeReader
-from entangled.errors.user import IndentationError
-
-from contextlib import chdir
-from pathlib import Path, PurePath
-from time import sleep
-
-import pytest
-
-from entangled.tangle import tangle_ref
-
-md_source = """
-``` {.scheme file=hello.scm}
-(display "hello") (newline)
-
-(let (x 42)
-  <<print-x>>
-)
-```
-
-``` {.scheme #print-x}
-(display x)
-  <<newline>>
-```
-
-``` {.scheme #newline}
-(newline)
-```
-"""
-
-scm_output1 = """; ~/~ begin <<test.md#hello.scm>>[init]
-(display "hello") (newline)
-
-(let (x 42)
-  ; ~/~ begin <<test.md#print-x>>[init]
-  (display x)
-    ; ~/~ begin <<test.md#newline>>[init]
-    (newline)
-    ; ~/~ end
-  ; ~/~ end
-)
-; ~/~ end"""
-
-
-scm_changed1 = """; ~/~ begin <<test.md#hello.scm>>[init]
-(display "goodbye") (newline)
-
-(let (x 42)
-  ; ~/~ begin <<test.md#print-x>>[init]
-  (display x)
-    ; ~/~ begin <<test.md#newline>>[init]
-    (newline)
-    ; ~/~ end
-  ; ~/~ end
-)
-    ; ~/~ end"""
-
-
-scm_changed2 = """; ~/~ begin <<test.md#hello.scm>>[init]
-(display "hello") (newline)
-
-(let (x 42)
-  ; ~/~ begin <<test.md#print-x>>[init]
-  (display x)
-;   ; ~/~ begin <<test.md#newline>>[init]
-    (newline)
-    ; ~/~ end
-  ; ~/~ end
-)
-; ~/~ end"""
-
-
-scm_changed3 = """; ~/~ begin <<test.md#hello.scm>>[init]
-(display "hello") (newline)
-
-(let (x 42)
-  ; ~/~ begin <<test.md#print-x>>[init]
-  (display x)
-    ; ~/~ begin <<test.md#newline>>[init]
-  (newline)
-    ; ~/~ end
-  ; ~/~ end
-)
-; ~/~ end"""
-
-
-def test_code_indentation():
-    refs, _ = read_markdown_string(md_source, Path("test.md"))
-    source, _ = tangle_ref(refs, "hello.scm")
-    assert source == scm_output1
-    for errs in [scm_changed1, scm_changed2, scm_changed3]:
-        with pytest.raises(IndentationError):
-            _ = CodeReader(PurePath("-"), refs).run(errs)
-
-
-md_source_error = """
-  ``` {.scheme file=hello.scm}
-(display "hello") (newline)
-```
-"""
-
-
-def test_md_indentation():
-    with pytest.raises(IndentationError):
-        read_markdown_string(md_source_error)
diff --git a/test/test_markdown_reader.py b/test/test_markdown_reader.py
deleted file mode 100644
index 241eb66..0000000
--- a/test/test_markdown_reader.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from entangled.markdown_reader import read_markdown_file, read_markdown_string
-from entangled.commands.stitch import stitch_markdown
-from entangled.main import configure
-
-
-def test_retrieve_same_content(data):
-    file = data / "hello-world" / "hello-world.md"
-    with open(file, "r") as f:
-        markdown = f.read()
-        refs, content = read_markdown_string(markdown)
-        assert stitch_markdown(refs, content) == markdown
-
-
-md_ignore = """
-hello
-
-~~~markdown
-This should be ignored.
-
-``` {.python #hello}
-```
-~~~
-
-This shouldn't
-
-``` {.python #goodbye}
-```
-"""
-
-
-def test_ignore():
-    refs, _ = read_markdown_string(md_ignore)
-    assert "hello" not in refs
-    assert "goodbye" in refs
-
-
-md_backtics = """
-``` {.python #hello}
-  ```
-```
-"""
-
-
-def test_backtic_content():
-    refs, _ = read_markdown_string(md_backtics)
-    assert next(refs["hello"]).source == "  ```"
-
-
-md_unknown_lang = """
-``` {.too_obscure #hello}
-```
-"""
-
-
-def test_unknown_language():
-    refs, _ = read_markdown_string(md_unknown_lang)
-    # assert len(refs.map) == 0
diff --git a/test/test_missing_ref.py b/test/test_missing_ref.py
deleted file mode 100644
index 7211282..0000000
--- a/test/test_missing_ref.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from entangled.tangle import tangle_ref
-from entangled.config import AnnotationMethod
-from entangled.markdown_reader import read_markdown_string
-from entangled.errors.user import MissingReference
-
-import pytest
-
-md_source = """
-``` {.scheme #hello}
-(display "hello") (newline)
-<<goodbye>>
-```
-"""
-
-
-def test_missing_ref(tmp_path):
-    with pytest.raises(MissingReference):
-        refs, _ = read_markdown_string(md_source)
-        tangle_ref(refs, "hello", AnnotationMethod.NAKED)
diff --git a/test/test_modes.py b/test/test_modes.py
deleted file mode 100644
index eb9ffc0..0000000
--- a/test/test_modes.py
+++ /dev/null
@@ -1,71 +0,0 @@
-from contextlib import chdir
-from entangled.commands import tangle, stitch
-from entangled.config import config
-from entangled.io.stat import stat
-from entangled.errors.user import UserError
-
-import pytest
-from time import sleep
-from pathlib import Path
-
-
-def test_modes(tmp_path: Path):
-    with chdir(tmp_path):
-        (tmp_path / "entangled.toml").write_text(
-            'version = "2.0"\n' 'watch_list = ["docs/**/*.md"]\n'
-        )
-        config.read()
-        md = tmp_path / "docs" / "index.md"
-        md.parent.mkdir(parents=True, exist_ok=True)
-        md.write_text("``` {.python file=src/hello.py}\n" 'print("hello")\n' "```\n")
-
-        tangle()
-        sleep(0.1)
-        target = tmp_path / "src" / "hello.py"
-        assert target.exists()
-        hello_stat1 = stat(target)
-        assert hello_stat1
-        hello_src = target.read_text().splitlines()
-        assert hello_src[1] == 'print("hello")'
-
-        md.write_text("``` {.python file=src/hello.py}\n" 'print("goodbye")\n' "```\n")
-        sleep(0.1)
-        md_stat1 = stat(md)
-        assert md_stat1
-
-        tangle(show=True)
-        sleep(0.1)
-        hello_stat2 = stat(target)
-        assert hello_stat2
-        assert hello_stat2.stat == hello_stat1.stat
-        assert not (hello_stat2.stat > hello_stat1.stat)
-
-        hello_src[1] = 'print("bonjour")'
-        (tmp_path / "src" / "hello.py").write_text("\n".join(hello_src))
-        sleep(0.1)
-        hello_stat1 = stat(target)
-        assert hello_stat1
-
-        # with pytest.raises(UserError):
-        tangle()
-        sleep(0.1)
-        hello_stat2 = stat(target)
-        assert hello_stat2
-        assert hello_stat2.stat == hello_stat1.stat
-        assert not (hello_stat2.stat > hello_stat1.stat)
-
-        # with pytest.raises(UserError):
-        stitch()
-        sleep(0.1)
-        md_stat2 = stat(md)
-        assert md_stat2
-        print(md.read_text())
-        assert md_stat1.stat == md_stat2.stat
-        assert not (md_stat2.stat > md_stat1.stat)
-
-        stitch(force=True)
-        sleep(0.1)
-        md_stat2 = stat(md)
-        assert md_stat2
-        assert md_stat1.stat != md_stat2.stat
-        assert md_stat2.stat > md_stat1.stat
diff --git a/test/test_os_interop.py b/test/test_os_interop.py
deleted file mode 100644
index 611e79d..0000000
--- a/test/test_os_interop.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from entangled.markdown_reader import read_markdown_string
-from entangled.tangle import tangle_ref
-from entangled.code_reader import CodeReader
-
-from pathlib import Path, PurePath
-import os
-from shutil import copytree, move
-from contextlib import chdir
-
-
-def test_tangle_ref(data, tmp_path):
-    copytree(data / "os_interop", tmp_path / "os_interop")
-    with chdir(tmp_path / "os_interop"):
-        refs, _ = read_markdown_string(Path("doc/index.md").read_text(encoding="utf-8"), Path("doc/index.md"))
-        tangled, deps = tangle_ref(refs, "src/euler_number.c")
-        assert deps == {PurePath("doc/index.md")}
-        with open("src/euler_number.c", "r") as f:
-            assert f.read().strip() == tangled.strip()
-
-        cb_old = next(refs["series-expansion"]).source
-        cr = CodeReader("-", refs).run(Path("src/euler_number.c.edit").read_text())
-        cb_new = next(refs["series-expansion"]).source
-        assert cb_old != cb_new
diff --git a/test/test_quarto_attributes.py b/test/test_quarto_attributes.py
deleted file mode 100644
index 1d1a476..0000000
--- a/test/test_quarto_attributes.py
+++ /dev/null
@@ -1,82 +0,0 @@
-from pathlib import PurePath
-from entangled.code_reader import CodeReader
-from entangled.commands.stitch import stitch_markdown
-from entangled.config import AnnotationMethod, Markers, config
-from entangled.hooks import get_hooks
-from entangled.markdown_reader import read_markdown_string
-from entangled.tangle import tangle_ref
-from entangled.properties import Attribute, get_attribute
-
-
-md_in = """
-``` {.scheme}
-; | id: hello
-; | foo: bar
-(display "hello") (newline)
-```
-
-``` {.scheme}
-;| file: hello.scm
-<<hello>>
-(display "goodbye") (newline)
-```
-"""
-
-
-scm_out = """
-(display "hello") (newline)
-(display "goodbye") (newline)
-"""
-
-
-def test_quarto_attributes():
-    with config(
-        hooks=["quarto_attributes"]):
-        # it is currently not possible to change markers at run-time,
-        # because the config is passed to MarkdownLexer at module load time
-        # markers=Markers(
-        #     open=r"^(?P<indent>\s*)```(?P<properties>.*)$",
-        #     close=r"^(?P<indent>\s*)```\s*$")):
-        hooks = get_hooks()
-
-    print(hooks)
-    refs, _ = read_markdown_string(md_in, hooks=hooks)
-    assert get_attribute(next(iter(refs.by_name("hello"))).properties, "foo") == "bar"
-    result, _ = tangle_ref(refs, "hello.scm", AnnotationMethod.NAKED)
-    assert result.strip() == scm_out.strip()
-
-
-def test_quarto_attributes_stitch():
-    with config(hooks=["quarto_attributes"]):
-        hooks = get_hooks()
-
-    refs, content = read_markdown_string(md_in, hooks=hooks)
-    source, _ = tangle_ref(refs, "hello.scm")
-    _ = CodeReader(PurePath("-"), refs).run(source)
-    assert stitch_markdown(refs, content) == md_in
-
-
-malformed_attrs = """
-Test after issue 55
-
-``` {.scheme #test}
-;|blah:nospace
-42
-```
-"""
-
-
-def test_malformed_quarto_attributes():
-    with config(
-            hooks=["quarto_attributes"]):
-            # it is currently not possible to change markers at run-time,
-            # because the config is passed to MarkdownLexer at module load time
-            # markers=Markers(
-            #     open=r"^(?P<indent>\s*)```(?P<properties>.*)$",
-            #     close=r"^(?P<indent>\s*)```\s*$")):
-            hooks = get_hooks()
-
-    refs, _ = read_markdown_string(malformed_attrs, hooks=hooks)
-    assert "test" in refs
-    codeblock = next(refs["test"])
-    assert not any(isinstance(p, Attribute) for p in codeblock.properties)
diff --git a/test/test_shebang.py b/test/test_shebang.py
deleted file mode 100644
index ab18741..0000000
--- a/test/test_shebang.py
+++ /dev/null
@@ -1,53 +0,0 @@
-from entangled.markdown_reader import read_markdown_string
-from entangled.hooks.shebang import Hook as Shebang
-from entangled.tangle import tangle_ref, AnnotationMethod
-from entangled.code_reader import CodeReader
-from entangled.commands.stitch import stitch_markdown
-
-input_md = """
-A script with a she-bang!
-
-``` {.bash file=test.sh}
-#!/bin/bash
-
-echo "Hello, World!"
-```
-"""
-
-output_test_sh = """#!/bin/bash
-# ~/~ begin <<-#test.sh>>[init]
-
-echo "Hello, World!"
-# ~/~ end
-"""
-
-output_test_sh_modified = """#!/bin/bash
-# ~/~ begin <<-#test.sh>>[init]
-
-echo "Hello, Universe!"
-# ~/~ end
-"""
-
-input_md_modified = """
-A script with a she-bang!
-
-``` {.bash file=test.sh}
-#!/bin/bash
-
-echo "Hello, Universe!"
-```
-"""
-
-
-def test_shebang():
-    hooks = [Shebang(Shebang.Config())]
-    refs, content = read_markdown_string(input_md, hooks=hooks)
-    assert "test.sh" in refs
-    assert next(refs["test.sh"]).header == "#!/bin/bash"
-    code_content, _ = tangle_ref(refs, "test.sh", AnnotationMethod.STANDARD)
-    assert code_content.strip() == output_test_sh.strip()
-
-    cr = CodeReader("test.sh", refs)
-    cr.run(output_test_sh_modified)
-    md_content = stitch_markdown(refs, content)
-    assert md_content.strip() == input_md_modified.strip()
diff --git a/test/test_spdx_license.py b/test/test_spdx_license.py
deleted file mode 100644
index 8a47169..0000000
--- a/test/test_spdx_license.py
+++ /dev/null
@@ -1,70 +0,0 @@
-from entangled.markdown_reader import read_markdown_string
-from entangled.hooks.spdx_license import Hook as SPDXLicense
-from entangled.tangle import tangle_ref, AnnotationMethod
-from entangled.code_reader import CodeReader
-from entangled.commands.stitch import stitch_markdown
-
-input_md = """
-A C file with a license!
-
-``` {.c file=test.c}
-// SPDX-License-Identifier: MIT
-#include <stdio.h>
-
-int main() {
-    printf("Hello, World!\n");
-    return 0;
-}
-```
-"""
-
-output_test_c = """// SPDX-License-Identifier: MIT
-/* ~/~ begin <<-#test.c>>[init] */
-#include <stdio.h>
-
-int main() {
-    printf("Hello, World!\n");
-    return 0;
-}
-/* ~/~ end */
-"""
-
-output_test_c_modified = """// SPDX-License-Identifier: MIT
-# ~/~ begin <<-#test.c>>[init]
-
-int main() {
-    printf("Hello, World!\n");
-    return 0;
-}
-# ~/~ end
-"""
-
-input_md_modified = """
-A C file with a license!
-
-``` {.c file=test.c}
-// SPDX-License-Identifier: MIT
-
-int main() {
-    printf("Hello, World!\n");
-    return 0;
-}
-```
-"""
-
-
-def test_spdx_license():
-    hooks = [SPDXLicense(SPDXLicense.Config())]
-    refs, content = read_markdown_string(input_md, hooks=hooks)
-    assert "test.c" in refs
-    print(next(refs["test.c"]))
-    assert next(refs["test.c"]).header == "// SPDX-License-Identifier: MIT"
-    code_content, _ = tangle_ref(refs, "test.c", AnnotationMethod.STANDARD)
-    print(code_content.strip())
-    print(output_test_c.strip())
-    assert code_content.strip() == output_test_c.strip()
-
-    cr = CodeReader("test.c", refs)
-    cr.run(output_test_c_modified)
-    md_content = stitch_markdown(refs, content)
-    assert md_content.strip() == input_md_modified.strip()
diff --git a/test/test_tangle.py b/test/test_tangle.py
deleted file mode 100644
index f6bae7f..0000000
--- a/test/test_tangle.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from entangled.markdown_reader import read_markdown_string
-from entangled.tangle import tangle_ref
-from entangled.code_reader import CodeReader
-from pathlib import Path, PurePath
-import os
-from shutil import copytree, move
-from contextlib import chdir
-
-
-def test_tangle_ref(data, tmp_path):
-    copytree(data / "hello-world", tmp_path / "hello-world")
-    with chdir(tmp_path / "hello-world"):
-        refs, _ = read_markdown_string(Path("hello-world.md").read_text(encoding="utf-8"), Path("hello-world.md"))
-        tangled, deps = tangle_ref(refs, "hello_world.cc")
-        assert deps == {PurePath("hello-world.md")}
-        with open("hello_world.cc", "r") as f:
-            assert f.read() == tangled
-
-        cb_old = next(refs["hello-world"]).source
-        cr = CodeReader("-", refs).run(Path("hello_universe.cc").read_text())
-        cb_new = next(refs["hello-world"]).source
-        assert cb_old != cb_new
diff --git a/test/test_watch_dir.py b/test/test_watch_dir.py
deleted file mode 100644
index ee6a415..0000000
--- a/test/test_watch_dir.py
+++ /dev/null
@@ -1,49 +0,0 @@
-from entangled.config import config
-from entangled.status import find_watch_dirs, list_input_files
-from contextlib import chdir
-from entangled.commands.tangle import tangle
-from pathlib import Path
-
-index_md_1 = """
-# Test
-
-``` {.c file=src/test.c}
-#include <stdio.h>
-int main() { printf("Hello, World!\\n"); return 0; }
-```
-"""
-
-index_md_2 = """
-``` {.makefile file=Makefile}
-.RECIPEPREFIX = >
-
-%.o: %.c
-> gcc -c $< -o $@
-
-hello: test.o
-> gcc $^ -o $@
-```
-"""
-
-data_md = """
-Don't tangle me!
-"""
-
-
-def test_watch_dirs(tmp_path):
-    with chdir(tmp_path):
-        Path("./docs").mkdir()
-        Path("./data").mkdir()
-        Path("./docs/index.md").write_text(index_md_1)
-        Path("./data/data.md").write_text(data_md)
-        with config(watch_list=["docs/*.md"]):
-            assert set(find_watch_dirs()) == set([Path("./docs")])
-            tangle()
-            assert set(find_watch_dirs()) == set([Path("./docs"), Path("./src")])
-            Path("./docs/index.md").write_text(index_md_1 + "\n" + index_md_2)
-            tangle()
-            assert set(find_watch_dirs()) == set(
-                [Path("."), Path("./docs"), Path("./src")]
-            )
-
-            assert sorted(list_input_files()) == [Path("./docs/index.md")]
diff --git a/uv.lock b/uv.lock
index 1b9e197..38e1667 100644
--- a/uv.lock
+++ b/uv.lock
@@ -31,16 +31,16 @@ wheels = [
 
 [[package]]
 name = "backrefs"
-version = "5.9"
+version = "6.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/eb/a7/312f673df6a79003279e1f55619abbe7daebbb87c17c976ddc0345c04c7b/backrefs-5.9.tar.gz", hash = "sha256:808548cb708d66b82ee231f962cb36faaf4f2baab032f2fbb783e9c2fdddaa59", size = 5765857, upload-time = "2025-06-22T19:34:13.97Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/86/e3/bb3a439d5cb255c4774724810ad8073830fac9c9dee123555820c1bcc806/backrefs-6.1.tar.gz", hash = "sha256:3bba1749aafe1db9b915f00e0dd166cba613b6f788ffd63060ac3485dc9be231", size = 7011962, upload-time = "2025-11-15T14:52:08.323Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/19/4d/798dc1f30468134906575156c089c492cf79b5a5fd373f07fe26c4d046bf/backrefs-5.9-py310-none-any.whl", hash = "sha256:db8e8ba0e9de81fcd635f440deab5ae5f2591b54ac1ebe0550a2ca063488cd9f", size = 380267, upload-time = "2025-06-22T19:34:05.252Z" },
-    { url = "https://files.pythonhosted.org/packages/55/07/f0b3375bf0d06014e9787797e6b7cc02b38ac9ff9726ccfe834d94e9991e/backrefs-5.9-py311-none-any.whl", hash = "sha256:6907635edebbe9b2dc3de3a2befff44d74f30a4562adbb8b36f21252ea19c5cf", size = 392072, upload-time = "2025-06-22T19:34:06.743Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/12/4f345407259dd60a0997107758ba3f221cf89a9b5a0f8ed5b961aef97253/backrefs-5.9-py312-none-any.whl", hash = "sha256:7fdf9771f63e6028d7fee7e0c497c81abda597ea45d6b8f89e8ad76994f5befa", size = 397947, upload-time = "2025-06-22T19:34:08.172Z" },
-    { url = "https://files.pythonhosted.org/packages/10/bf/fa31834dc27a7f05e5290eae47c82690edc3a7b37d58f7fb35a1bdbf355b/backrefs-5.9-py313-none-any.whl", hash = "sha256:cc37b19fa219e93ff825ed1fed8879e47b4d89aa7a1884860e2db64ccd7c676b", size = 399843, upload-time = "2025-06-22T19:34:09.68Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/24/b29af34b2c9c41645a9f4ff117bae860291780d73880f449e0b5d948c070/backrefs-5.9-py314-none-any.whl", hash = "sha256:df5e169836cc8acb5e440ebae9aad4bf9d15e226d3bad049cf3f6a5c20cc8dc9", size = 411762, upload-time = "2025-06-22T19:34:11.037Z" },
-    { url = "https://files.pythonhosted.org/packages/41/ff/392bff89415399a979be4a65357a41d92729ae8580a66073d8ec8d810f98/backrefs-5.9-py39-none-any.whl", hash = "sha256:f48ee18f6252b8f5777a22a00a09a85de0ca931658f1dd96d4406a34f3748c60", size = 380265, upload-time = "2025-06-22T19:34:12.405Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/ee/c216d52f58ea75b5e1841022bbae24438b19834a29b163cb32aa3a2a7c6e/backrefs-6.1-py310-none-any.whl", hash = "sha256:2a2ccb96302337ce61ee4717ceacfbf26ba4efb1d55af86564b8bbaeda39cac1", size = 381059, upload-time = "2025-11-15T14:51:59.758Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9a/8da246d988ded941da96c7ed945d63e94a445637eaad985a0ed88787cb89/backrefs-6.1-py311-none-any.whl", hash = "sha256:e82bba3875ee4430f4de4b6db19429a27275d95a5f3773c57e9e18abc23fd2b7", size = 392854, upload-time = "2025-11-15T14:52:01.194Z" },
+    { url = "https://files.pythonhosted.org/packages/37/c9/fd117a6f9300c62bbc33bc337fd2b3c6bfe28b6e9701de336b52d7a797ad/backrefs-6.1-py312-none-any.whl", hash = "sha256:c64698c8d2269343d88947c0735cb4b78745bd3ba590e10313fbf3f78c34da5a", size = 398770, upload-time = "2025-11-15T14:52:02.584Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/95/7118e935b0b0bd3f94dfec2d852fd4e4f4f9757bdb49850519acd245cd3a/backrefs-6.1-py313-none-any.whl", hash = "sha256:4c9d3dc1e2e558965202c012304f33d4e0e477e1c103663fd2c3cc9bb18b0d05", size = 400726, upload-time = "2025-11-15T14:52:04.093Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/72/6296bad135bfafd3254ae3648cd152980a424bd6fed64a101af00cc7ba31/backrefs-6.1-py314-none-any.whl", hash = "sha256:13eafbc9ccd5222e9c1f0bec563e6d2a6d21514962f11e7fc79872fd56cbc853", size = 412584, upload-time = "2025-11-15T14:52:05.233Z" },
+    { url = "https://files.pythonhosted.org/packages/02/e3/a4fa1946722c4c7b063cc25043a12d9ce9b4323777f89643be74cef2993c/backrefs-6.1-py39-none-any.whl", hash = "sha256:a9e99b8a4867852cad177a6430e31b0f6e495d65f8c6c134b68c14c3c95bf4b0", size = 381058, upload-time = "2025-11-15T14:52:06.698Z" },
 ]
 
 [[package]]
@@ -79,11 +79,11 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2025.10.5"
+version = "2025.11.12"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4c/5b/b6ce21586237c77ce67d01dc5507039d444b630dd76611bbca2d8e5dcd91/certifi-2025.10.5.tar.gz", hash = "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43", size = 164519, upload-time = "2025-10-05T04:12:15.808Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/8c/58f469717fa48465e4a50c014a0400602d3c437d7c0c468e17ada824da3a/certifi-2025.11.12.tar.gz", hash = "sha256:d8ab5478f2ecd78af242878415affce761ca6bc54a22a27e026d7c25357c3316", size = 160538, upload-time = "2025-11-12T02:54:51.517Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286, upload-time = "2025-10-05T04:12:14.03Z" },
+    { url = "https://files.pythonhosted.org/packages/70/7d/9bc192684cea499815ff478dfcdc13835ddf401365057044fb721ec6bddb/certifi-2025.11.12-py3-none-any.whl", hash = "sha256:97de8790030bbd5c2d96b7ec782fc2f7820ef8dba6db909ccf95449f2d062d4b", size = 159438, upload-time = "2025-11-12T02:54:49.735Z" },
 ]
 
 [[package]]
@@ -145,14 +145,14 @@ wheels = [
 
 [[package]]
 name = "click"
-version = "8.3.0"
+version = "8.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/46/61/de6cd827efad202d7057d93e0fed9294b96952e188f7384832791c7b2254/click-8.3.0.tar.gz", hash = "sha256:e7b8232224eba16f4ebe410c25ced9f7875cb5f3263ffc93cc3e8da705e229c4", size = 276943, upload-time = "2025-09-18T17:32:23.696Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/db/d3/9dcc0f5797f070ec8edf30fbadfb200e71d9db6b84d211e3b2085a7589a0/click-8.3.0-py3-none-any.whl", hash = "sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc", size = 107295, upload-time = "2025-09-18T17:32:22.42Z" },
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
 ]
 
 [[package]]
@@ -190,76 +190,76 @@ wheels = [
 
 [[package]]
 name = "coverage"
-version = "7.11.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1c/38/ee22495420457259d2f3390309505ea98f98a5eed40901cf62196abad006/coverage-7.11.0.tar.gz", hash = "sha256:167bd504ac1ca2af7ff3b81d245dfea0292c5032ebef9d66cc08a7d28c1b8050", size = 811905, upload-time = "2025-10-15T15:15:08.542Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/db/86f6906a7c7edc1a52b2c6682d6dd9be775d73c0dfe2b84f8923dfea5784/coverage-7.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9c49e77811cf9d024b95faf86c3f059b11c0c9be0b0d61bc598f453703bd6fd1", size = 216098, upload-time = "2025-10-15T15:13:02.916Z" },
-    { url = "https://files.pythonhosted.org/packages/21/54/e7b26157048c7ba555596aad8569ff903d6cd67867d41b75287323678ede/coverage-7.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a61e37a403a778e2cda2a6a39abcc895f1d984071942a41074b5c7ee31642007", size = 216331, upload-time = "2025-10-15T15:13:04.403Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/19/1ce6bf444f858b83a733171306134a0544eaddf1ca8851ede6540a55b2ad/coverage-7.11.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:c79cae102bb3b1801e2ef1511fb50e91ec83a1ce466b2c7c25010d884336de46", size = 247825, upload-time = "2025-10-15T15:13:05.92Z" },
-    { url = "https://files.pythonhosted.org/packages/71/0b/d3bcbbc259fcced5fb67c5d78f6e7ee965f49760c14afd931e9e663a83b2/coverage-7.11.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:16ce17ceb5d211f320b62df002fa7016b7442ea0fd260c11cec8ce7730954893", size = 250573, upload-time = "2025-10-15T15:13:07.471Z" },
-    { url = "https://files.pythonhosted.org/packages/58/8d/b0ff3641a320abb047258d36ed1c21d16be33beed4152628331a1baf3365/coverage-7.11.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:80027673e9d0bd6aef86134b0771845e2da85755cf686e7c7c59566cf5a89115", size = 251706, upload-time = "2025-10-15T15:13:09.4Z" },
-    { url = "https://files.pythonhosted.org/packages/59/c8/5a586fe8c7b0458053d9c687f5cff515a74b66c85931f7fe17a1c958b4ac/coverage-7.11.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4d3ffa07a08657306cd2215b0da53761c4d73cb54d9143b9303a6481ec0cd415", size = 248221, upload-time = "2025-10-15T15:13:10.964Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/ff/3a25e3132804ba44cfa9a778cdf2b73dbbe63ef4b0945e39602fc896ba52/coverage-7.11.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a3b6a5f8b2524fd6c1066bc85bfd97e78709bb5e37b5b94911a6506b65f47186", size = 249624, upload-time = "2025-10-15T15:13:12.5Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/12/ff10c8ce3895e1b17a73485ea79ebc1896a9e466a9d0f4aef63e0d17b718/coverage-7.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:fcc0a4aa589de34bc56e1a80a740ee0f8c47611bdfb28cd1849de60660f3799d", size = 247744, upload-time = "2025-10-15T15:13:14.554Z" },
-    { url = "https://files.pythonhosted.org/packages/16/02/d500b91f5471b2975947e0629b8980e5e90786fe316b6d7299852c1d793d/coverage-7.11.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:dba82204769d78c3fd31b35c3d5f46e06511936c5019c39f98320e05b08f794d", size = 247325, upload-time = "2025-10-15T15:13:16.438Z" },
-    { url = "https://files.pythonhosted.org/packages/77/11/dee0284fbbd9cd64cfce806b827452c6df3f100d9e66188e82dfe771d4af/coverage-7.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:81b335f03ba67309a95210caf3eb43bd6fe75a4e22ba653ef97b4696c56c7ec2", size = 249180, upload-time = "2025-10-15T15:13:17.959Z" },
-    { url = "https://files.pythonhosted.org/packages/59/1b/cdf1def928f0a150a057cab03286774e73e29c2395f0d30ce3d9e9f8e697/coverage-7.11.0-cp312-cp312-win32.whl", hash = "sha256:037b2d064c2f8cc8716fe4d39cb705779af3fbf1ba318dc96a1af858888c7bb5", size = 218479, upload-time = "2025-10-15T15:13:19.608Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/55/e5884d55e031da9c15b94b90a23beccc9d6beee65e9835cd6da0a79e4f3a/coverage-7.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:d66c0104aec3b75e5fd897e7940188ea1892ca1d0235316bf89286d6a22568c0", size = 219290, upload-time = "2025-10-15T15:13:21.593Z" },
-    { url = "https://files.pythonhosted.org/packages/23/a8/faa930cfc71c1d16bc78f9a19bb73700464f9c331d9e547bfbc1dbd3a108/coverage-7.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:d91ebeac603812a09cf6a886ba6e464f3bbb367411904ae3790dfe28311b15ad", size = 217924, upload-time = "2025-10-15T15:13:23.39Z" },
-    { url = "https://files.pythonhosted.org/packages/60/7f/85e4dfe65e400645464b25c036a26ac226cf3a69d4a50c3934c532491cdd/coverage-7.11.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:cc3f49e65ea6e0d5d9bd60368684fe52a704d46f9e7fc413918f18d046ec40e1", size = 216129, upload-time = "2025-10-15T15:13:25.371Z" },
-    { url = "https://files.pythonhosted.org/packages/96/5d/dc5fa98fea3c175caf9d360649cb1aa3715e391ab00dc78c4c66fabd7356/coverage-7.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f39ae2f63f37472c17b4990f794035c9890418b1b8cca75c01193f3c8d3e01be", size = 216380, upload-time = "2025-10-15T15:13:26.976Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/f5/3da9cc9596708273385189289c0e4d8197d37a386bdf17619013554b3447/coverage-7.11.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7db53b5cdd2917b6eaadd0b1251cf4e7d96f4a8d24e174bdbdf2f65b5ea7994d", size = 247375, upload-time = "2025-10-15T15:13:28.923Z" },
-    { url = "https://files.pythonhosted.org/packages/65/6c/f7f59c342359a235559d2bc76b0c73cfc4bac7d61bb0df210965cb1ecffd/coverage-7.11.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:10ad04ac3a122048688387828b4537bc9cf60c0bf4869c1e9989c46e45690b82", size = 249978, upload-time = "2025-10-15T15:13:30.525Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/8c/042dede2e23525e863bf1ccd2b92689692a148d8b5fd37c37899ba882645/coverage-7.11.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4036cc9c7983a2b1f2556d574d2eb2154ac6ed55114761685657e38782b23f52", size = 251253, upload-time = "2025-10-15T15:13:32.174Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/a9/3c58df67bfa809a7bddd786356d9c5283e45d693edb5f3f55d0986dd905a/coverage-7.11.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7ab934dd13b1c5e94b692b1e01bd87e4488cb746e3a50f798cb9464fd128374b", size = 247591, upload-time = "2025-10-15T15:13:34.147Z" },
-    { url = "https://files.pythonhosted.org/packages/26/5b/c7f32efd862ee0477a18c41e4761305de6ddd2d49cdeda0c1116227570fd/coverage-7.11.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:59a6e5a265f7cfc05f76e3bb53eca2e0dfe90f05e07e849930fecd6abb8f40b4", size = 249411, upload-time = "2025-10-15T15:13:38.425Z" },
-    { url = "https://files.pythonhosted.org/packages/76/b5/78cb4f1e86c1611431c990423ec0768122905b03837e1b4c6a6f388a858b/coverage-7.11.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:df01d6c4c81e15a7c88337b795bb7595a8596e92310266b5072c7e301168efbd", size = 247303, upload-time = "2025-10-15T15:13:40.464Z" },
-    { url = "https://files.pythonhosted.org/packages/87/c9/23c753a8641a330f45f221286e707c427e46d0ffd1719b080cedc984ec40/coverage-7.11.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8c934bd088eed6174210942761e38ee81d28c46de0132ebb1801dbe36a390dcc", size = 247157, upload-time = "2025-10-15T15:13:42.087Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/42/6e0cc71dc8a464486e944a4fa0d85bdec031cc2969e98ed41532a98336b9/coverage-7.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5a03eaf7ec24078ad64a07f02e30060aaf22b91dedf31a6b24d0d98d2bba7f48", size = 248921, upload-time = "2025-10-15T15:13:43.715Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/1c/743c2ef665e6858cccb0f84377dfe3a4c25add51e8c7ef19249be92465b6/coverage-7.11.0-cp313-cp313-win32.whl", hash = "sha256:695340f698a5f56f795b2836abe6fb576e7c53d48cd155ad2f80fd24bc63a040", size = 218526, upload-time = "2025-10-15T15:13:45.336Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/d5/226daadfd1bf8ddbccefbd3aa3547d7b960fb48e1bdac124e2dd13a2b71a/coverage-7.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:2727d47fce3ee2bac648528e41455d1b0c46395a087a229deac75e9f88ba5a05", size = 219317, upload-time = "2025-10-15T15:13:47.401Z" },
-    { url = "https://files.pythonhosted.org/packages/97/54/47db81dcbe571a48a298f206183ba8a7ba79200a37cd0d9f4788fcd2af4a/coverage-7.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:0efa742f431529699712b92ecdf22de8ff198df41e43aeaaadf69973eb93f17a", size = 217948, upload-time = "2025-10-15T15:13:49.096Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/8b/cb68425420154e7e2a82fd779a8cc01549b6fa83c2ad3679cd6c088ebd07/coverage-7.11.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:587c38849b853b157706407e9ebdca8fd12f45869edb56defbef2daa5fb0812b", size = 216837, upload-time = "2025-10-15T15:13:51.09Z" },
-    { url = "https://files.pythonhosted.org/packages/33/55/9d61b5765a025685e14659c8d07037247de6383c0385757544ffe4606475/coverage-7.11.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b971bdefdd75096163dd4261c74be813c4508477e39ff7b92191dea19f24cd37", size = 217061, upload-time = "2025-10-15T15:13:52.747Z" },
-    { url = "https://files.pythonhosted.org/packages/52/85/292459c9186d70dcec6538f06ea251bc968046922497377bf4a1dc9a71de/coverage-7.11.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:269bfe913b7d5be12ab13a95f3a76da23cf147be7fa043933320ba5625f0a8de", size = 258398, upload-time = "2025-10-15T15:13:54.45Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/e2/46edd73fb8bf51446c41148d81944c54ed224854812b6ca549be25113ee0/coverage-7.11.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:dadbcce51a10c07b7c72b0ce4a25e4b6dcb0c0372846afb8e5b6307a121eb99f", size = 260574, upload-time = "2025-10-15T15:13:56.145Z" },
-    { url = "https://files.pythonhosted.org/packages/07/5e/1df469a19007ff82e2ca8fe509822820a31e251f80ee7344c34f6cd2ec43/coverage-7.11.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9ed43fa22c6436f7957df036331f8fe4efa7af132054e1844918866cd228af6c", size = 262797, upload-time = "2025-10-15T15:13:58.635Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/50/de216b31a1434b94d9b34a964c09943c6be45069ec704bfc379d8d89a649/coverage-7.11.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9516add7256b6713ec08359b7b05aeff8850c98d357784c7205b2e60aa2513fa", size = 257361, upload-time = "2025-10-15T15:14:00.409Z" },
-    { url = "https://files.pythonhosted.org/packages/82/1e/3f9f8344a48111e152e0fd495b6fff13cc743e771a6050abf1627a7ba918/coverage-7.11.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:eb92e47c92fcbcdc692f428da67db33337fa213756f7adb6a011f7b5a7a20740", size = 260349, upload-time = "2025-10-15T15:14:02.188Z" },
-    { url = "https://files.pythonhosted.org/packages/65/9b/3f52741f9e7d82124272f3070bbe316006a7de1bad1093f88d59bfc6c548/coverage-7.11.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:d06f4fc7acf3cabd6d74941d53329e06bab00a8fe10e4df2714f0b134bfc64ef", size = 258114, upload-time = "2025-10-15T15:14:03.907Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/8b/918f0e15f0365d50d3986bbd3338ca01178717ac5678301f3f547b6619e6/coverage-7.11.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:6fbcee1a8f056af07ecd344482f711f563a9eb1c2cad192e87df00338ec3cdb0", size = 256723, upload-time = "2025-10-15T15:14:06.324Z" },
-    { url = "https://files.pythonhosted.org/packages/44/9e/7776829f82d3cf630878a7965a7d70cc6ca94f22c7d20ec4944f7148cb46/coverage-7.11.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dbbf012be5f32533a490709ad597ad8a8ff80c582a95adc8d62af664e532f9ca", size = 259238, upload-time = "2025-10-15T15:14:08.002Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/b8/49cf253e1e7a3bedb85199b201862dd7ca4859f75b6cf25ffa7298aa0760/coverage-7.11.0-cp313-cp313t-win32.whl", hash = "sha256:cee6291bb4fed184f1c2b663606a115c743df98a537c969c3c64b49989da96c2", size = 219180, upload-time = "2025-10-15T15:14:09.786Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/e1/1a541703826be7ae2125a0fb7f821af5729d56bb71e946e7b933cc7a89a4/coverage-7.11.0-cp313-cp313t-win_amd64.whl", hash = "sha256:a386c1061bf98e7ea4758e4313c0ab5ecf57af341ef0f43a0bf26c2477b5c268", size = 220241, upload-time = "2025-10-15T15:14:11.471Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/d1/5ee0e0a08621140fd418ec4020f595b4d52d7eb429ae6a0c6542b4ba6f14/coverage-7.11.0-cp313-cp313t-win_arm64.whl", hash = "sha256:f9ea02ef40bb83823b2b04964459d281688fe173e20643870bb5d2edf68bc836", size = 218510, upload-time = "2025-10-15T15:14:13.46Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/06/e923830c1985ce808e40a3fa3eb46c13350b3224b7da59757d37b6ce12b8/coverage-7.11.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c770885b28fb399aaf2a65bbd1c12bf6f307ffd112d6a76c5231a94276f0c497", size = 216110, upload-time = "2025-10-15T15:14:15.157Z" },
-    { url = "https://files.pythonhosted.org/packages/42/82/cdeed03bfead45203fb651ed756dfb5266028f5f939e7f06efac4041dad5/coverage-7.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a3d0e2087dba64c86a6b254f43e12d264b636a39e88c5cc0a01a7c71bcfdab7e", size = 216395, upload-time = "2025-10-15T15:14:16.863Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/ba/e1c80caffc3199aa699813f73ff097bc2df7b31642bdbc7493600a8f1de5/coverage-7.11.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:73feb83bb41c32811973b8565f3705caf01d928d972b72042b44e97c71fd70d1", size = 247433, upload-time = "2025-10-15T15:14:18.589Z" },
-    { url = "https://files.pythonhosted.org/packages/80/c0/5b259b029694ce0a5bbc1548834c7ba3db41d3efd3474489d7efce4ceb18/coverage-7.11.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c6f31f281012235ad08f9a560976cc2fc9c95c17604ff3ab20120fe480169bca", size = 249970, upload-time = "2025-10-15T15:14:20.307Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/86/171b2b5e1aac7e2fd9b43f7158b987dbeb95f06d1fbecad54ad8163ae3e8/coverage-7.11.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9570ad567f880ef675673992222746a124b9595506826b210fbe0ce3f0499cd", size = 251324, upload-time = "2025-10-15T15:14:22.419Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/7e/7e10414d343385b92024af3932a27a1caf75c6e27ee88ba211221ff1a145/coverage-7.11.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8badf70446042553a773547a61fecaa734b55dc738cacf20c56ab04b77425e43", size = 247445, upload-time = "2025-10-15T15:14:24.205Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/3b/e4f966b21f5be8c4bf86ad75ae94efa0de4c99c7bbb8114476323102e345/coverage-7.11.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a09c1211959903a479e389685b7feb8a17f59ec5a4ef9afde7650bd5eabc2777", size = 249324, upload-time = "2025-10-15T15:14:26.234Z" },
-    { url = "https://files.pythonhosted.org/packages/00/a2/8479325576dfcd909244d0df215f077f47437ab852ab778cfa2f8bf4d954/coverage-7.11.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:5ef83b107f50db3f9ae40f69e34b3bd9337456c5a7fe3461c7abf8b75dd666a2", size = 247261, upload-time = "2025-10-15T15:14:28.42Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/d8/3a9e2db19d94d65771d0f2e21a9ea587d11b831332a73622f901157cc24b/coverage-7.11.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f91f927a3215b8907e214af77200250bb6aae36eca3f760f89780d13e495388d", size = 247092, upload-time = "2025-10-15T15:14:30.784Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/b1/bbca3c472544f9e2ad2d5116b2379732957048be4b93a9c543fcd0207e5f/coverage-7.11.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cdbcd376716d6b7fbfeedd687a6c4be019c5a5671b35f804ba76a4c0a778cba4", size = 248755, upload-time = "2025-10-15T15:14:32.585Z" },
-    { url = "https://files.pythonhosted.org/packages/89/49/638d5a45a6a0f00af53d6b637c87007eb2297042186334e9923a61aa8854/coverage-7.11.0-cp314-cp314-win32.whl", hash = "sha256:bab7ec4bb501743edc63609320aaec8cd9188b396354f482f4de4d40a9d10721", size = 218793, upload-time = "2025-10-15T15:14:34.972Z" },
-    { url = "https://files.pythonhosted.org/packages/30/cc/b675a51f2d068adb3cdf3799212c662239b0ca27f4691d1fff81b92ea850/coverage-7.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:3d4ba9a449e9364a936a27322b20d32d8b166553bfe63059bd21527e681e2fad", size = 219587, upload-time = "2025-10-15T15:14:37.047Z" },
-    { url = "https://files.pythonhosted.org/packages/93/98/5ac886876026de04f00820e5094fe22166b98dcb8b426bf6827aaf67048c/coverage-7.11.0-cp314-cp314-win_arm64.whl", hash = "sha256:ce37f215223af94ef0f75ac68ea096f9f8e8c8ec7d6e8c346ee45c0d363f0479", size = 218168, upload-time = "2025-10-15T15:14:38.861Z" },
-    { url = "https://files.pythonhosted.org/packages/14/d1/b4145d35b3e3ecf4d917e97fc8895bcf027d854879ba401d9ff0f533f997/coverage-7.11.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:f413ce6e07e0d0dc9c433228727b619871532674b45165abafe201f200cc215f", size = 216850, upload-time = "2025-10-15T15:14:40.651Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/d1/7f645fc2eccd318369a8a9948acc447bb7c1ade2911e31d3c5620544c22b/coverage-7.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:05791e528a18f7072bf5998ba772fe29db4da1234c45c2087866b5ba4dea710e", size = 217071, upload-time = "2025-10-15T15:14:42.755Z" },
-    { url = "https://files.pythonhosted.org/packages/54/7d/64d124649db2737ceced1dfcbdcb79898d5868d311730f622f8ecae84250/coverage-7.11.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cacb29f420cfeb9283b803263c3b9a068924474ff19ca126ba9103e1278dfa44", size = 258570, upload-time = "2025-10-15T15:14:44.542Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/3f/6f5922f80dc6f2d8b2c6f974835c43f53eb4257a7797727e6ca5b7b2ec1f/coverage-7.11.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:314c24e700d7027ae3ab0d95fbf8d53544fca1f20345fd30cd219b737c6e58d3", size = 260738, upload-time = "2025-10-15T15:14:46.436Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/5f/9e883523c4647c860b3812b417a2017e361eca5b635ee658387dc11b13c1/coverage-7.11.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:630d0bd7a293ad2fc8b4b94e5758c8b2536fdf36c05f1681270203e463cbfa9b", size = 262994, upload-time = "2025-10-15T15:14:48.3Z" },
-    { url = "https://files.pythonhosted.org/packages/07/bb/43b5a8e94c09c8bf51743ffc65c4c841a4ca5d3ed191d0a6919c379a1b83/coverage-7.11.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e89641f5175d65e2dbb44db15fe4ea48fade5d5bbb9868fdc2b4fce22f4a469d", size = 257282, upload-time = "2025-10-15T15:14:50.236Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/e5/0ead8af411411330b928733e1d201384b39251a5f043c1612970310e8283/coverage-7.11.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c9f08ea03114a637dab06cedb2e914da9dc67fa52c6015c018ff43fdde25b9c2", size = 260430, upload-time = "2025-10-15T15:14:52.413Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/66/03dd8bb0ba5b971620dcaac145461950f6d8204953e535d2b20c6b65d729/coverage-7.11.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce9f3bde4e9b031eaf1eb61df95c1401427029ea1bfddb8621c1161dcb0fa02e", size = 258190, upload-time = "2025-10-15T15:14:54.268Z" },
-    { url = "https://files.pythonhosted.org/packages/45/ae/28a9cce40bf3174426cb2f7e71ee172d98e7f6446dff936a7ccecee34b14/coverage-7.11.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:e4dc07e95495923d6fd4d6c27bf70769425b71c89053083843fd78f378558996", size = 256658, upload-time = "2025-10-15T15:14:56.436Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/7c/3a44234a8599513684bfc8684878fd7b126c2760f79712bb78c56f19efc4/coverage-7.11.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:424538266794db2861db4922b05d729ade0940ee69dcf0591ce8f69784db0e11", size = 259342, upload-time = "2025-10-15T15:14:58.538Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/e6/0108519cba871af0351725ebdb8660fd7a0fe2ba3850d56d32490c7d9b4b/coverage-7.11.0-cp314-cp314t-win32.whl", hash = "sha256:4c1eeb3fb8eb9e0190bebafd0462936f75717687117339f708f395fe455acc73", size = 219568, upload-time = "2025-10-15T15:15:00.382Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/76/44ba876e0942b4e62fdde23ccb029ddb16d19ba1bef081edd00857ba0b16/coverage-7.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b56efee146c98dbf2cf5cffc61b9829d1e94442df4d7398b26892a53992d3547", size = 220687, upload-time = "2025-10-15T15:15:02.322Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/0c/0df55ecb20d0d0ed5c322e10a441775e1a3a5d78c60f0c4e1abfe6fcf949/coverage-7.11.0-cp314-cp314t-win_arm64.whl", hash = "sha256:b5c2705afa83f49bd91962a4094b6b082f94aef7626365ab3f8f4bd159c5acf3", size = 218711, upload-time = "2025-10-15T15:15:04.575Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/04/642c1d8a448ae5ea1369eac8495740a79eb4e581a9fb0cbdce56bbf56da1/coverage-7.11.0-py3-none-any.whl", hash = "sha256:4b7589765348d78fb4e5fb6ea35d07564e387da2fc5efff62e0222971f155f68", size = 207761, upload-time = "2025-10-15T15:15:06.439Z" },
+version = "7.12.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/89/26/4a96807b193b011588099c3b5c89fbb05294e5b90e71018e065465f34eb6/coverage-7.12.0.tar.gz", hash = "sha256:fc11e0a4e372cb5f282f16ef90d4a585034050ccda536451901abfb19a57f40c", size = 819341, upload-time = "2025-11-18T13:34:20.766Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/bf/638c0427c0f0d47638242e2438127f3c8ee3cfc06c7fdeb16778ed47f836/coverage-7.12.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:29644c928772c78512b48e14156b81255000dcfd4817574ff69def189bcb3647", size = 217704, upload-time = "2025-11-18T13:32:28.906Z" },
+    { url = "https://files.pythonhosted.org/packages/08/e1/706fae6692a66c2d6b871a608bbde0da6281903fa0e9f53a39ed441da36a/coverage-7.12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8638cbb002eaa5d7c8d04da667813ce1067080b9a91099801a0053086e52b736", size = 218064, upload-time = "2025-11-18T13:32:30.161Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/8b/eb0231d0540f8af3ffda39720ff43cb91926489d01524e68f60e961366e4/coverage-7.12.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:083631eeff5eb9992c923e14b810a179798bb598e6a0dd60586819fc23be6e60", size = 249560, upload-time = "2025-11-18T13:32:31.835Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/a1/67fb52af642e974d159b5b379e4d4c59d0ebe1288677fbd04bbffe665a82/coverage-7.12.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:99d5415c73ca12d558e07776bd957c4222c687b9f1d26fa0e1b57e3598bdcde8", size = 252318, upload-time = "2025-11-18T13:32:33.178Z" },
+    { url = "https://files.pythonhosted.org/packages/41/e5/38228f31b2c7665ebf9bdfdddd7a184d56450755c7e43ac721c11a4b8dab/coverage-7.12.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e949ebf60c717c3df63adb4a1a366c096c8d7fd8472608cd09359e1bd48ef59f", size = 253403, upload-time = "2025-11-18T13:32:34.45Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/4b/df78e4c8188f9960684267c5a4897836f3f0f20a20c51606ee778a1d9749/coverage-7.12.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6d907ddccbca819afa2cd014bc69983b146cca2735a0b1e6259b2a6c10be1e70", size = 249984, upload-time = "2025-11-18T13:32:35.747Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/51/bb163933d195a345c6f63eab9e55743413d064c291b6220df754075c2769/coverage-7.12.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b1518ecbad4e6173f4c6e6c4a46e49555ea5679bf3feda5edb1b935c7c44e8a0", size = 251339, upload-time = "2025-11-18T13:32:37.352Z" },
+    { url = "https://files.pythonhosted.org/packages/15/40/c9b29cdb8412c837cdcbc2cfa054547dd83affe6cbbd4ce4fdb92b6ba7d1/coverage-7.12.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:51777647a749abdf6f6fd8c7cffab12de68ab93aab15efc72fbbb83036c2a068", size = 249489, upload-time = "2025-11-18T13:32:39.212Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/da/b3131e20ba07a0de4437a50ef3b47840dfabf9293675b0cd5c2c7f66dd61/coverage-7.12.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:42435d46d6461a3b305cdfcad7cdd3248787771f53fe18305548cba474e6523b", size = 249070, upload-time = "2025-11-18T13:32:40.598Z" },
+    { url = "https://files.pythonhosted.org/packages/70/81/b653329b5f6302c08d683ceff6785bc60a34be9ae92a5c7b63ee7ee7acec/coverage-7.12.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5bcead88c8423e1855e64b8057d0544e33e4080b95b240c2a355334bb7ced937", size = 250929, upload-time = "2025-11-18T13:32:42.915Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/00/250ac3bca9f252a5fb1338b5ad01331ebb7b40223f72bef5b1b2cb03aa64/coverage-7.12.0-cp312-cp312-win32.whl", hash = "sha256:dcbb630ab034e86d2a0f79aefd2be07e583202f41e037602d438c80044957baa", size = 220241, upload-time = "2025-11-18T13:32:44.665Z" },
+    { url = "https://files.pythonhosted.org/packages/64/1c/77e79e76d37ce83302f6c21980b45e09f8aa4551965213a10e62d71ce0ab/coverage-7.12.0-cp312-cp312-win_amd64.whl", hash = "sha256:2fd8354ed5d69775ac42986a691fbf68b4084278710cee9d7c3eaa0c28fa982a", size = 221051, upload-time = "2025-11-18T13:32:46.008Z" },
+    { url = "https://files.pythonhosted.org/packages/31/f5/641b8a25baae564f9e52cac0e2667b123de961985709a004e287ee7663cc/coverage-7.12.0-cp312-cp312-win_arm64.whl", hash = "sha256:737c3814903be30695b2de20d22bcc5428fdae305c61ba44cdc8b3252984c49c", size = 219692, upload-time = "2025-11-18T13:32:47.372Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/14/771700b4048774e48d2c54ed0c674273702713c9ee7acdfede40c2666747/coverage-7.12.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:47324fffca8d8eae7e185b5bb20c14645f23350f870c1649003618ea91a78941", size = 217725, upload-time = "2025-11-18T13:32:49.22Z" },
+    { url = "https://files.pythonhosted.org/packages/17/a7/3aa4144d3bcb719bf67b22d2d51c2d577bf801498c13cb08f64173e80497/coverage-7.12.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ccf3b2ede91decd2fb53ec73c1f949c3e034129d1e0b07798ff1d02ea0c8fa4a", size = 218098, upload-time = "2025-11-18T13:32:50.78Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/9c/b846bbc774ff81091a12a10203e70562c91ae71badda00c5ae5b613527b1/coverage-7.12.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b365adc70a6936c6b0582dc38746b33b2454148c02349345412c6e743efb646d", size = 249093, upload-time = "2025-11-18T13:32:52.554Z" },
+    { url = "https://files.pythonhosted.org/packages/76/b6/67d7c0e1f400b32c883e9342de4a8c2ae7c1a0b57c5de87622b7262e2309/coverage-7.12.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:bc13baf85cd8a4cfcf4a35c7bc9d795837ad809775f782f697bf630b7e200211", size = 251686, upload-time = "2025-11-18T13:32:54.862Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/75/b095bd4b39d49c3be4bffbb3135fea18a99a431c52dd7513637c0762fecb/coverage-7.12.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:099d11698385d572ceafb3288a5b80fe1fc58bf665b3f9d362389de488361d3d", size = 252930, upload-time = "2025-11-18T13:32:56.417Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f3/466f63015c7c80550bead3093aacabf5380c1220a2a93c35d374cae8f762/coverage-7.12.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:473dc45d69694069adb7680c405fb1e81f60b2aff42c81e2f2c3feaf544d878c", size = 249296, upload-time = "2025-11-18T13:32:58.074Z" },
+    { url = "https://files.pythonhosted.org/packages/27/86/eba2209bf2b7e28c68698fc13437519a295b2d228ba9e0ec91673e09fa92/coverage-7.12.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:583f9adbefd278e9de33c33d6846aa8f5d164fa49b47144180a0e037f0688bb9", size = 251068, upload-time = "2025-11-18T13:32:59.646Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/55/ca8ae7dbba962a3351f18940b359b94c6bafdd7757945fdc79ec9e452dc7/coverage-7.12.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b2089cc445f2dc0af6f801f0d1355c025b76c24481935303cf1af28f636688f0", size = 249034, upload-time = "2025-11-18T13:33:01.481Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/d7/39136149325cad92d420b023b5fd900dabdd1c3a0d1d5f148ef4a8cedef5/coverage-7.12.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:950411f1eb5d579999c5f66c62a40961f126fc71e5e14419f004471957b51508", size = 248853, upload-time = "2025-11-18T13:33:02.935Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/b6/76e1add8b87ef60e00643b0b7f8f7bb73d4bf5249a3be19ebefc5793dd25/coverage-7.12.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b1aab7302a87bafebfe76b12af681b56ff446dc6f32ed178ff9c092ca776e6bc", size = 250619, upload-time = "2025-11-18T13:33:04.336Z" },
+    { url = "https://files.pythonhosted.org/packages/95/87/924c6dc64f9203f7a3c1832a6a0eee5a8335dbe5f1bdadcc278d6f1b4d74/coverage-7.12.0-cp313-cp313-win32.whl", hash = "sha256:d7e0d0303c13b54db495eb636bc2465b2fb8475d4c8bcec8fe4b5ca454dfbae8", size = 220261, upload-time = "2025-11-18T13:33:06.493Z" },
+    { url = "https://files.pythonhosted.org/packages/91/77/dd4aff9af16ff776bf355a24d87eeb48fc6acde54c907cc1ea89b14a8804/coverage-7.12.0-cp313-cp313-win_amd64.whl", hash = "sha256:ce61969812d6a98a981d147d9ac583a36ac7db7766f2e64a9d4d059c2fe29d07", size = 221072, upload-time = "2025-11-18T13:33:07.926Z" },
+    { url = "https://files.pythonhosted.org/packages/70/49/5c9dc46205fef31b1b226a6e16513193715290584317fd4df91cdaf28b22/coverage-7.12.0-cp313-cp313-win_arm64.whl", hash = "sha256:bcec6f47e4cb8a4c2dc91ce507f6eefc6a1b10f58df32cdc61dff65455031dfc", size = 219702, upload-time = "2025-11-18T13:33:09.631Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/62/f87922641c7198667994dd472a91e1d9b829c95d6c29529ceb52132436ad/coverage-7.12.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:459443346509476170d553035e4a3eed7b860f4fe5242f02de1010501956ce87", size = 218420, upload-time = "2025-11-18T13:33:11.153Z" },
+    { url = "https://files.pythonhosted.org/packages/85/dd/1cc13b2395ef15dbb27d7370a2509b4aee77890a464fb35d72d428f84871/coverage-7.12.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:04a79245ab2b7a61688958f7a855275997134bc84f4a03bc240cf64ff132abf6", size = 218773, upload-time = "2025-11-18T13:33:12.569Z" },
+    { url = "https://files.pythonhosted.org/packages/74/40/35773cc4bb1e9d4658d4fb669eb4195b3151bef3bbd6f866aba5cd5dac82/coverage-7.12.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:09a86acaaa8455f13d6a99221d9654df249b33937b4e212b4e5a822065f12aa7", size = 260078, upload-time = "2025-11-18T13:33:14.037Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/ee/231bb1a6ffc2905e396557585ebc6bdc559e7c66708376d245a1f1d330fc/coverage-7.12.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:907e0df1b71ba77463687a74149c6122c3f6aac56c2510a5d906b2f368208560", size = 262144, upload-time = "2025-11-18T13:33:15.601Z" },
+    { url = "https://files.pythonhosted.org/packages/28/be/32f4aa9f3bf0b56f3971001b56508352c7753915345d45fab4296a986f01/coverage-7.12.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9b57e2d0ddd5f0582bae5437c04ee71c46cd908e7bc5d4d0391f9a41e812dd12", size = 264574, upload-time = "2025-11-18T13:33:17.354Z" },
+    { url = "https://files.pythonhosted.org/packages/68/7c/00489fcbc2245d13ab12189b977e0cf06ff3351cb98bc6beba8bd68c5902/coverage-7.12.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:58c1c6aa677f3a1411fe6fb28ec3a942e4f665df036a3608816e0847fad23296", size = 259298, upload-time = "2025-11-18T13:33:18.958Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b4/f0760d65d56c3bea95b449e02570d4abd2549dc784bf39a2d4721a2d8ceb/coverage-7.12.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4c589361263ab2953e3c4cd2a94db94c4ad4a8e572776ecfbad2389c626e4507", size = 262150, upload-time = "2025-11-18T13:33:20.644Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/71/9a9314df00f9326d78c1e5a910f520d599205907432d90d1c1b7a97aa4b1/coverage-7.12.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:91b810a163ccad2e43b1faa11d70d3cf4b6f3d83f9fd5f2df82a32d47b648e0d", size = 259763, upload-time = "2025-11-18T13:33:22.189Z" },
+    { url = "https://files.pythonhosted.org/packages/10/34/01a0aceed13fbdf925876b9a15d50862eb8845454301fe3cdd1df08b2182/coverage-7.12.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:40c867af715f22592e0d0fb533a33a71ec9e0f73a6945f722a0c85c8c1cbe3a2", size = 258653, upload-time = "2025-11-18T13:33:24.239Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/04/81d8fd64928acf1574bbb0181f66901c6c1c6279c8ccf5f84259d2c68ae9/coverage-7.12.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:68b0d0a2d84f333de875666259dadf28cc67858bc8fd8b3f1eae84d3c2bec455", size = 260856, upload-time = "2025-11-18T13:33:26.365Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/76/fa2a37bfaeaf1f766a2d2360a25a5297d4fb567098112f6517475eee120b/coverage-7.12.0-cp313-cp313t-win32.whl", hash = "sha256:73f9e7fbd51a221818fd11b7090eaa835a353ddd59c236c57b2199486b116c6d", size = 220936, upload-time = "2025-11-18T13:33:28.165Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/52/60f64d932d555102611c366afb0eb434b34266b1d9266fc2fe18ab641c47/coverage-7.12.0-cp313-cp313t-win_amd64.whl", hash = "sha256:24cff9d1f5743f67db7ba46ff284018a6e9aeb649b67aa1e70c396aa1b7cb23c", size = 222001, upload-time = "2025-11-18T13:33:29.656Z" },
+    { url = "https://files.pythonhosted.org/packages/77/df/c303164154a5a3aea7472bf323b7c857fed93b26618ed9fc5c2955566bb0/coverage-7.12.0-cp313-cp313t-win_arm64.whl", hash = "sha256:c87395744f5c77c866d0f5a43d97cc39e17c7f1cb0115e54a2fe67ca75c5d14d", size = 220273, upload-time = "2025-11-18T13:33:31.415Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/2e/fc12db0883478d6e12bbd62d481210f0c8daf036102aa11434a0c5755825/coverage-7.12.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a1c59b7dc169809a88b21a936eccf71c3895a78f5592051b1af8f4d59c2b4f92", size = 217777, upload-time = "2025-11-18T13:33:32.86Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/c1/ce3e525d223350c6ec16b9be8a057623f54226ef7f4c2fee361ebb6a02b8/coverage-7.12.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8787b0f982e020adb732b9f051f3e49dd5054cebbc3f3432061278512a2b1360", size = 218100, upload-time = "2025-11-18T13:33:34.532Z" },
+    { url = "https://files.pythonhosted.org/packages/15/87/113757441504aee3808cb422990ed7c8bcc2d53a6779c66c5adef0942939/coverage-7.12.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5ea5a9f7dc8877455b13dd1effd3202e0bca72f6f3ab09f9036b1bcf728f69ac", size = 249151, upload-time = "2025-11-18T13:33:36.135Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/1d/9529d9bd44049b6b05bb319c03a3a7e4b0a8a802d28fa348ad407e10706d/coverage-7.12.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fdba9f15849534594f60b47c9a30bc70409b54947319a7c4fd0e8e3d8d2f355d", size = 251667, upload-time = "2025-11-18T13:33:37.996Z" },
+    { url = "https://files.pythonhosted.org/packages/11/bb/567e751c41e9c03dc29d3ce74b8c89a1e3396313e34f255a2a2e8b9ebb56/coverage-7.12.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a00594770eb715854fb1c57e0dea08cce6720cfbc531accdb9850d7c7770396c", size = 253003, upload-time = "2025-11-18T13:33:39.553Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/b3/c2cce2d8526a02fb9e9ca14a263ca6fc074449b33a6afa4892838c903528/coverage-7.12.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5560c7e0d82b42eb1951e4f68f071f8017c824ebfd5a6ebe42c60ac16c6c2434", size = 249185, upload-time = "2025-11-18T13:33:42.086Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/a7/967f93bb66e82c9113c66a8d0b65ecf72fc865adfba5a145f50c7af7e58d/coverage-7.12.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d6c2e26b481c9159c2773a37947a9718cfdc58893029cdfb177531793e375cfc", size = 251025, upload-time = "2025-11-18T13:33:43.634Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/b2/f2f6f56337bc1af465d5b2dc1ee7ee2141b8b9272f3bf6213fcbc309a836/coverage-7.12.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:6e1a8c066dabcde56d5d9fed6a66bc19a2883a3fe051f0c397a41fc42aedd4cc", size = 248979, upload-time = "2025-11-18T13:33:46.04Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/7a/bf4209f45a4aec09d10a01a57313a46c0e0e8f4c55ff2965467d41a92036/coverage-7.12.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f7ba9da4726e446d8dd8aae5a6cd872511184a5d861de80a86ef970b5dacce3e", size = 248800, upload-time = "2025-11-18T13:33:47.546Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/b7/1e01b8696fb0521810f60c5bbebf699100d6754183e6cc0679bf2ed76531/coverage-7.12.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e0f483ab4f749039894abaf80c2f9e7ed77bbf3c737517fb88c8e8e305896a17", size = 250460, upload-time = "2025-11-18T13:33:49.537Z" },
+    { url = "https://files.pythonhosted.org/packages/71/ae/84324fb9cb46c024760e706353d9b771a81b398d117d8c1fe010391c186f/coverage-7.12.0-cp314-cp314-win32.whl", hash = "sha256:76336c19a9ef4a94b2f8dc79f8ac2da3f193f625bb5d6f51a328cd19bfc19933", size = 220533, upload-time = "2025-11-18T13:33:51.16Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/71/1033629deb8460a8f97f83e6ac4ca3b93952e2b6f826056684df8275e015/coverage-7.12.0-cp314-cp314-win_amd64.whl", hash = "sha256:7c1059b600aec6ef090721f8f633f60ed70afaffe8ecab85b59df748f24b31fe", size = 221348, upload-time = "2025-11-18T13:33:52.776Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/5f/ac8107a902f623b0c251abdb749be282dc2ab61854a8a4fcf49e276fce2f/coverage-7.12.0-cp314-cp314-win_arm64.whl", hash = "sha256:172cf3a34bfef42611963e2b661302a8931f44df31629e5b1050567d6b90287d", size = 219922, upload-time = "2025-11-18T13:33:54.316Z" },
+    { url = "https://files.pythonhosted.org/packages/79/6e/f27af2d4da367f16077d21ef6fe796c874408219fa6dd3f3efe7751bd910/coverage-7.12.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:aa7d48520a32cb21c7a9b31f81799e8eaec7239db36c3b670be0fa2403828d1d", size = 218511, upload-time = "2025-11-18T13:33:56.343Z" },
+    { url = "https://files.pythonhosted.org/packages/67/dd/65fd874aa460c30da78f9d259400d8e6a4ef457d61ab052fd248f0050558/coverage-7.12.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:90d58ac63bc85e0fb919f14d09d6caa63f35a5512a2205284b7816cafd21bb03", size = 218771, upload-time = "2025-11-18T13:33:57.966Z" },
+    { url = "https://files.pythonhosted.org/packages/55/e0/7c6b71d327d8068cb79c05f8f45bf1b6145f7a0de23bbebe63578fe5240a/coverage-7.12.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:ca8ecfa283764fdda3eae1bdb6afe58bf78c2c3ec2b2edcb05a671f0bba7b3f9", size = 260151, upload-time = "2025-11-18T13:33:59.597Z" },
+    { url = "https://files.pythonhosted.org/packages/49/ce/4697457d58285b7200de6b46d606ea71066c6e674571a946a6ea908fb588/coverage-7.12.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:874fe69a0785d96bd066059cd4368022cebbec1a8958f224f0016979183916e6", size = 262257, upload-time = "2025-11-18T13:34:01.166Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/33/acbc6e447aee4ceba88c15528dbe04a35fb4d67b59d393d2e0d6f1e242c1/coverage-7.12.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5b3c889c0b8b283a24d721a9eabc8ccafcfc3aebf167e4cd0d0e23bf8ec4e339", size = 264671, upload-time = "2025-11-18T13:34:02.795Z" },
+    { url = "https://files.pythonhosted.org/packages/87/ec/e2822a795c1ed44d569980097be839c5e734d4c0c1119ef8e0a073496a30/coverage-7.12.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8bb5b894b3ec09dcd6d3743229dc7f2c42ef7787dc40596ae04c0edda487371e", size = 259231, upload-time = "2025-11-18T13:34:04.397Z" },
+    { url = "https://files.pythonhosted.org/packages/72/c5/a7ec5395bb4a49c9b7ad97e63f0c92f6bf4a9e006b1393555a02dae75f16/coverage-7.12.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:79a44421cd5fba96aa57b5e3b5a4d3274c449d4c622e8f76882d76635501fd13", size = 262137, upload-time = "2025-11-18T13:34:06.068Z" },
+    { url = "https://files.pythonhosted.org/packages/67/0c/02c08858b764129f4ecb8e316684272972e60777ae986f3865b10940bdd6/coverage-7.12.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:33baadc0efd5c7294f436a632566ccc1f72c867f82833eb59820ee37dc811c6f", size = 259745, upload-time = "2025-11-18T13:34:08.04Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/04/4fd32b7084505f3829a8fe45c1a74a7a728cb251aaadbe3bec04abcef06d/coverage-7.12.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c406a71f544800ef7e9e0000af706b88465f3573ae8b8de37e5f96c59f689ad1", size = 258570, upload-time = "2025-11-18T13:34:09.676Z" },
+    { url = "https://files.pythonhosted.org/packages/48/35/2365e37c90df4f5342c4fa202223744119fe31264ee2924f09f074ea9b6d/coverage-7.12.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e71bba6a40883b00c6d571599b4627f50c360b3d0d02bfc658168936be74027b", size = 260899, upload-time = "2025-11-18T13:34:11.259Z" },
+    { url = "https://files.pythonhosted.org/packages/05/56/26ab0464ca733fa325e8e71455c58c1c374ce30f7c04cebb88eabb037b18/coverage-7.12.0-cp314-cp314t-win32.whl", hash = "sha256:9157a5e233c40ce6613dead4c131a006adfda70e557b6856b97aceed01b0e27a", size = 221313, upload-time = "2025-11-18T13:34:12.863Z" },
+    { url = "https://files.pythonhosted.org/packages/da/1c/017a3e1113ed34d998b27d2c6dba08a9e7cb97d362f0ec988fcd873dcf81/coverage-7.12.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e84da3a0fd233aeec797b981c51af1cabac74f9bd67be42458365b30d11b5291", size = 222423, upload-time = "2025-11-18T13:34:15.14Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/36/bcc504fdd5169301b52568802bb1b9cdde2e27a01d39fbb3b4b508ab7c2c/coverage-7.12.0-cp314-cp314t-win_arm64.whl", hash = "sha256:01d24af36fedda51c2b1aca56e4330a3710f83b02a5ff3743a6b015ffa7c9384", size = 220459, upload-time = "2025-11-18T13:34:17.222Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/a3/43b749004e3c09452e39bb56347a008f0a0668aad37324a99b5c8ca91d9e/coverage-7.12.0-py3-none-any.whl", hash = "sha256:159d50c0b12e060b15ed3d39f87ed43d4f7f7ad40b8a534f4dd331adbb51104a", size = 209503, upload-time = "2025-11-18T13:34:18.892Z" },
 ]
 
 [[package]]
@@ -289,11 +289,12 @@ wheels = [
 
 [[package]]
 name = "entangled-cli"
-version = "2.3.2"
+version = "2.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "argh" },
     { name = "brei" },
+    { name = "click" },
     { name = "copier" },
     { name = "filelock" },
     { name = "mawk" },
@@ -303,7 +304,9 @@ dependencies = [
     { name = "repl-session" },
     { name = "rich" },
     { name = "rich-argparse" },
+    { name = "rich-click" },
     { name = "tomlkit" },
+    { name = "typeguard" },
     { name = "watchdog" },
 ]
 
@@ -321,6 +324,7 @@ dev = [
     { name = "pytest-timeout" },
     { name = "python-lsp-server" },
     { name = "ruff" },
+    { name = "ty" },
     { name = "types-colorama" },
     { name = "types-pexpect" },
     { name = "types-pygments" },
@@ -331,16 +335,19 @@ dev = [
 requires-dist = [
     { name = "argh", specifier = ">=0.30,<0.31" },
     { name = "brei", specifier = ">=0.2.3,<0.3" },
+    { name = "click", specifier = ">=8.3.0" },
     { name = "copier", specifier = ">=9,<10" },
     { name = "filelock", specifier = ">=3.12.0,<4" },
     { name = "mawk", specifier = ">=0.1.7,<0.2" },
-    { name = "msgspec", specifier = ">=0.19.0" },
+    { name = "msgspec", git = "https://github.com/jcrist/msgspec" },
     { name = "pexpect", specifier = ">=4.9.0,<5" },
     { name = "pyyaml", specifier = ">=6.0.1,<7" },
     { name = "repl-session", specifier = ">=0.2.0" },
     { name = "rich", specifier = ">=13.3.5,<14" },
     { name = "rich-argparse", specifier = ">=1.4.0,<2" },
+    { name = "rich-click", specifier = ">=1.9.4" },
     { name = "tomlkit", specifier = ">=0.12.1,<0.13" },
+    { name = "typeguard", specifier = ">=4.4.4" },
     { name = "watchdog", specifier = ">=6.0.0" },
 ]
 
@@ -348,16 +355,17 @@ requires-dist = [
 dev = [
     { name = "black", specifier = ">=23.3.0,<24" },
     { name = "mkdocs", specifier = ">=1.4.3,<2" },
-    { name = "mkdocs-material", specifier = ">=9.1.13,<10" },
-    { name = "mkdocstrings", extras = ["python"], specifier = ">=0.21.2,<0.22" },
+    { name = "mkdocs-material", specifier = ">=9.7,<10" },
+    { name = "mkdocstrings", extras = ["python"], specifier = ">=0.30" },
     { name = "mypy", specifier = ">=1.18,<2" },
     { name = "pyright", specifier = ">=1.1.405" },
-    { name = "pytest", specifier = ">=7.3.1,<8" },
-    { name = "pytest-asyncio", specifier = ">=0.21.1,<0.22" },
+    { name = "pytest", specifier = ">=9.0,<10" },
+    { name = "pytest-asyncio", specifier = ">=1.3,<2" },
     { name = "pytest-cov", specifier = ">=4.0.0,<5" },
     { name = "pytest-timeout", specifier = ">=2.4.0" },
     { name = "python-lsp-server", specifier = ">=1.13.1" },
     { name = "ruff", specifier = ">=0.14" },
+    { name = "ty", specifier = ">=0.0.1a24" },
     { name = "types-colorama", specifier = ">=0.4.15.20240311,<0.5" },
     { name = "types-pexpect", specifier = ">=4.9.0.20250916" },
     { name = "types-pygments", specifier = ">=2.18.0.20240506,<3" },
@@ -397,14 +405,14 @@ wheels = [
 
 [[package]]
 name = "griffe"
-version = "1.14.0"
+version = "1.15.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ec/d7/6c09dd7ce4c7837e4cdb11dce980cb45ae3cd87677298dc3b781b6bce7d3/griffe-1.14.0.tar.gz", hash = "sha256:9d2a15c1eca966d68e00517de5d69dd1bc5c9f2335ef6c1775362ba5b8651a13", size = 424684, upload-time = "2025-09-05T15:02:29.167Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/0d/0c/3a471b6e31951dce2360477420d0a8d1e00dea6cf33b70f3e8c3ab6e28e1/griffe-1.15.0.tar.gz", hash = "sha256:7726e3afd6f298fbc3696e67958803e7ac843c1cfe59734b6251a40cdbfb5eea", size = 424112, upload-time = "2025-11-10T15:03:15.52Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/b1/9ff6578d789a89812ff21e4e0f80ffae20a65d5dd84e7a17873fe3b365be/griffe-1.14.0-py3-none-any.whl", hash = "sha256:0e9d52832cccf0f7188cfe585ba962d2674b241c01916d780925df34873bceb0", size = 144439, upload-time = "2025-09-05T15:02:27.511Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/83/3b1d03d36f224edded98e9affd0467630fc09d766c0e56fb1498cbb04a9b/griffe-1.15.0-py3-none-any.whl", hash = "sha256:6f6762661949411031f5fcda9593f586e6ce8340f0ba88921a0f2ef7a81eb9a3", size = 150705, upload-time = "2025-11-10T15:03:13.549Z" },
 ]
 
 [[package]]
@@ -476,11 +484,11 @@ wheels = [
 
 [[package]]
 name = "markdown"
-version = "3.5.2"
+version = "3.10"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/11/28/c5441a6642681d92de56063fa7984df56f783d3f1eba518dc3e7a253b606/Markdown-3.5.2.tar.gz", hash = "sha256:e1ac7b3dc550ee80e602e71c1d168002f062e49f1b11e26a36264dafd4df2ef8", size = 349398, upload-time = "2024-01-10T15:19:38.261Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/7dd27d9d863b3376fcf23a5a13cb5d024aed1db46f963f1b5735ae43b3be/markdown-3.10.tar.gz", hash = "sha256:37062d4f2aa4b2b6b32aefb80faa300f82cc790cb949a35b8caede34f2b68c0e", size = 364931, upload-time = "2025-11-03T19:51:15.007Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/42/f4/f0031854de10a0bc7821ef9fca0b92ca0d7aa6fbfbf504c5473ba825e49c/Markdown-3.5.2-py3-none-any.whl", hash = "sha256:d43323865d89fc0cb9b20c75fc8ad313af307cc087e84b657d9eec768eddeadd", size = 103870, upload-time = "2024-01-10T15:19:36.071Z" },
+    { url = "https://files.pythonhosted.org/packages/70/81/54e3ce63502cd085a0c556652a4e1b919c45a446bd1e5300e10c44c8c521/markdown-3.10-py3-none-any.whl", hash = "sha256:b5b99d6951e2e4948d939255596523444c0e677c669700b1d17aa4a8a464cb7c", size = 107678, upload-time = "2025-11-03T19:51:13.887Z" },
 ]
 
 [[package]]
@@ -639,7 +647,7 @@ wheels = [
 
 [[package]]
 name = "mkdocs-material"
-version = "9.6.22"
+version = "9.7.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "babel" },
@@ -654,9 +662,9 @@ dependencies = [
     { name = "pymdown-extensions" },
     { name = "requests" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5f/5d/317e37b6c43325cb376a1d6439df9cc743b8ee41c84603c2faf7286afc82/mkdocs_material-9.6.22.tar.gz", hash = "sha256:87c158b0642e1ada6da0cbd798a3389b0bc5516b90e5ece4a0fb939f00bacd1c", size = 4044968, upload-time = "2025-10-15T09:21:15.409Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/9c/3b/111b84cd6ff28d9e955b5f799ef217a17bc1684ac346af333e6100e413cb/mkdocs_material-9.7.0.tar.gz", hash = "sha256:602b359844e906ee402b7ed9640340cf8a474420d02d8891451733b6b02314ec", size = 4094546, upload-time = "2025-11-11T08:49:09.73Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/82/6fdb9a7a04fb222f4849ffec1006f891a0280825a20314d11f3ccdee14eb/mkdocs_material-9.6.22-py3-none-any.whl", hash = "sha256:14ac5f72d38898b2f98ac75a5531aaca9366eaa427b0f49fc2ecf04d99b7ad84", size = 9206252, upload-time = "2025-10-15T09:21:12.175Z" },
+    { url = "https://files.pythonhosted.org/packages/04/87/eefe8d5e764f4cf50ed91b943f8e8f96b5efd65489d8303b7a36e2e79834/mkdocs_material-9.7.0-py3-none-any.whl", hash = "sha256:da2866ea53601125ff5baa8aa06404c6e07af3c5ce3d5de95e3b52b80b442887", size = 9283770, upload-time = "2025-11-11T08:49:06.26Z" },
 ]
 
 [[package]]
@@ -670,7 +678,7 @@ wheels = [
 
 [[package]]
 name = "mkdocstrings"
-version = "0.21.2"
+version = "0.30.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jinja2" },
@@ -680,9 +688,9 @@ dependencies = [
     { name = "mkdocs-autorefs" },
     { name = "pymdown-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d2/a1/d08d776e8fa2508b299fad8165374317dc742a58880398ed2f9a7ecddefc/mkdocstrings-0.21.2.tar.gz", hash = "sha256:304e56a2e90595708a38a13a278e538a67ad82052dd5c8b71f77a604a4f3d911", size = 28991, upload-time = "2023-04-06T14:06:40.012Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c5/33/2fa3243439f794e685d3e694590d28469a9b8ea733af4b48c250a3ffc9a0/mkdocstrings-0.30.1.tar.gz", hash = "sha256:84a007aae9b707fb0aebfc9da23db4b26fc9ab562eb56e335e9ec480cb19744f", size = 106350, upload-time = "2025-09-19T10:49:26.446Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/04/ca/7630aa270d8af95eadccc13836e5471a0d639d41555ec894e78a83d1a4cd/mkdocstrings-0.21.2-py3-none-any.whl", hash = "sha256:949ef8da92df9d692ca07be50616459a6b536083a25520fd54b00e8814ce019b", size = 26326, upload-time = "2023-04-06T14:06:38.435Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2c/f0dc4e1ee7f618f5bff7e05898d20bf8b6e7fa612038f768bfa295f136a4/mkdocstrings-0.30.1-py3-none-any.whl", hash = "sha256:41bd71f284ca4d44a668816193e4025c950b002252081e387433656ae9a70a82", size = 36704, upload-time = "2025-09-19T10:49:24.805Z" },
 ]
 
 [package.optional-dependencies]
@@ -692,39 +700,22 @@ python = [
 
 [[package]]
 name = "mkdocstrings-python"
-version = "1.9.1"
+version = "1.19.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "griffe" },
-    { name = "markdown" },
+    { name = "mkdocs-autorefs" },
     { name = "mkdocstrings" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/92/47/9d771f91359e5377cf19385a056aa4da43324995d72b1fac9d77c840d423/mkdocstrings_python-1.9.1.tar.gz", hash = "sha256:077188fa43eab3b689826b15da7da6753501224b2482e4eca3ce4412ce3b71cb", size = 34013, upload-time = "2024-04-02T16:48:24.939Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/75/1c/3af8413919b0839b96a78f60e8bd0dfd26c844d3717eeb77f80b43f5be1c/mkdocstrings_python-1.19.0.tar.gz", hash = "sha256:917aac66cf121243c11db5b89f66b0ded6c53ec0de5318ff5e22424eb2f2e57c", size = 204010, upload-time = "2025-11-10T13:30:55.915Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/99/e1/1498edc8323a2967dea48bd9366df861507dbafcd36a58f59db86fec615f/mkdocstrings_python-1.9.1-py3-none-any.whl", hash = "sha256:bf2406ed37ff19c9f8e0acc9d72c41953fb789bfb4ae10eb00ee17e537eeb220", size = 58554, upload-time = "2024-04-02T16:48:21.426Z" },
+    { url = "https://files.pythonhosted.org/packages/98/5c/2597cef67b6947b15c47f8dba967a0baf19fbdfdc86f6e4a8ba7af8b581a/mkdocstrings_python-1.19.0-py3-none-any.whl", hash = "sha256:395c1032af8f005234170575cc0c5d4d20980846623b623b35594281be4a3059", size = 143417, upload-time = "2025-11-10T13:30:54.164Z" },
 ]
 
 [[package]]
 name = "msgspec"
-version = "0.19.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cf/9b/95d8ce458462b8b71b8a70fa94563b2498b89933689f3a7b8911edfae3d7/msgspec-0.19.0.tar.gz", hash = "sha256:604037e7cd475345848116e89c553aa9a233259733ab51986ac924ab1b976f8e", size = 216934, upload-time = "2024-12-27T17:40:28.597Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b2/5f/a70c24f075e3e7af2fae5414c7048b0e11389685b7f717bb55ba282a34a7/msgspec-0.19.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f98bd8962ad549c27d63845b50af3f53ec468b6318400c9f1adfe8b092d7b62f", size = 190485, upload-time = "2024-12-27T17:39:44.974Z" },
-    { url = "https://files.pythonhosted.org/packages/89/b0/1b9763938cfae12acf14b682fcf05c92855974d921a5a985ecc197d1c672/msgspec-0.19.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:43bbb237feab761b815ed9df43b266114203f53596f9b6e6f00ebd79d178cdf2", size = 183910, upload-time = "2024-12-27T17:39:46.401Z" },
-    { url = "https://files.pythonhosted.org/packages/87/81/0c8c93f0b92c97e326b279795f9c5b956c5a97af28ca0fbb9fd86c83737a/msgspec-0.19.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4cfc033c02c3e0aec52b71710d7f84cb3ca5eb407ab2ad23d75631153fdb1f12", size = 210633, upload-time = "2024-12-27T17:39:49.099Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/ef/c5422ce8af73928d194a6606f8ae36e93a52fd5e8df5abd366903a5ca8da/msgspec-0.19.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d911c442571605e17658ca2b416fd8579c5050ac9adc5e00c2cb3126c97f73bc", size = 213594, upload-time = "2024-12-27T17:39:51.204Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2b/4137bc2ed45660444842d042be2cf5b18aa06efd2cda107cff18253b9653/msgspec-0.19.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:757b501fa57e24896cf40a831442b19a864f56d253679f34f260dcb002524a6c", size = 214053, upload-time = "2024-12-27T17:39:52.866Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/e6/8ad51bdc806aac1dc501e8fe43f759f9ed7284043d722b53323ea421c360/msgspec-0.19.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5f0f65f29b45e2816d8bded36e6b837a4bf5fb60ec4bc3c625fa2c6da4124537", size = 219081, upload-time = "2024-12-27T17:39:55.142Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/ef/27dd35a7049c9a4f4211c6cd6a8c9db0a50647546f003a5867827ec45391/msgspec-0.19.0-cp312-cp312-win_amd64.whl", hash = "sha256:067f0de1c33cfa0b6a8206562efdf6be5985b988b53dd244a8e06f993f27c8c0", size = 187467, upload-time = "2024-12-27T17:39:56.531Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/cb/2842c312bbe618d8fefc8b9cedce37f773cdc8fa453306546dba2c21fd98/msgspec-0.19.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f12d30dd6266557aaaf0aa0f9580a9a8fbeadfa83699c487713e355ec5f0bd86", size = 190498, upload-time = "2024-12-27T17:40:00.427Z" },
-    { url = "https://files.pythonhosted.org/packages/58/95/c40b01b93465e1a5f3b6c7d91b10fb574818163740cc3acbe722d1e0e7e4/msgspec-0.19.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82b2c42c1b9ebc89e822e7e13bbe9d17ede0c23c187469fdd9505afd5a481314", size = 183950, upload-time = "2024-12-27T17:40:04.219Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/f0/5b764e066ce9aba4b70d1db8b087ea66098c7c27d59b9dd8a3532774d48f/msgspec-0.19.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19746b50be214a54239aab822964f2ac81e38b0055cca94808359d779338c10e", size = 210647, upload-time = "2024-12-27T17:40:05.606Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/87/bc14f49bc95c4cb0dd0a8c56028a67c014ee7e6818ccdce74a4862af259b/msgspec-0.19.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60ef4bdb0ec8e4ad62e5a1f95230c08efb1f64f32e6e8dd2ced685bcc73858b5", size = 213563, upload-time = "2024-12-27T17:40:10.516Z" },
-    { url = "https://files.pythonhosted.org/packages/53/2f/2b1c2b056894fbaa975f68f81e3014bb447516a8b010f1bed3fb0e016ed7/msgspec-0.19.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac7f7c377c122b649f7545810c6cd1b47586e3aa3059126ce3516ac7ccc6a6a9", size = 213996, upload-time = "2024-12-27T17:40:12.244Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/5a/4cd408d90d1417e8d2ce6a22b98a6853c1b4d7cb7669153e4424d60087f6/msgspec-0.19.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a5bc1472223a643f5ffb5bf46ccdede7f9795078194f14edd69e3aab7020d327", size = 219087, upload-time = "2024-12-27T17:40:14.881Z" },
-    { url = "https://files.pythonhosted.org/packages/23/d8/f15b40611c2d5753d1abb0ca0da0c75348daf1252220e5dda2867bd81062/msgspec-0.19.0-cp313-cp313-win_amd64.whl", hash = "sha256:317050bc0f7739cb30d257ff09152ca309bf5a369854bbf1e57dffc310c1f20f", size = 187432, upload-time = "2024-12-27T17:40:16.256Z" },
-]
+version = "0.19.1.dev41+ge72caf336"
+source = { git = "https://github.com/jcrist/msgspec#e72caf3361ffe344c8bc10aa7b6bf206b375557c" }
 
 [[package]]
 name = "mypy"
@@ -844,14 +835,14 @@ wheels = [
 
 [[package]]
 name = "plumbum"
-version = "1.9.0"
+version = "1.10.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f0/5d/49ba324ad4ae5b1a4caefafbce7a1648540129344481f2ed4ef6bb68d451/plumbum-1.9.0.tar.gz", hash = "sha256:e640062b72642c3873bd5bdc3effed75ba4d3c70ef6b6a7b907357a84d909219", size = 319083, upload-time = "2024-10-05T05:59:27.059Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/dc/c8/11a5f792704b70f071a3dbc329105a98e9cc8d25daaf09f733c44eb0ef8e/plumbum-1.10.0.tar.gz", hash = "sha256:f8cbf0ecec0b73ff4e349398b65112a9e3f9300e7dc019001217dcc148d5c97c", size = 320039, upload-time = "2025-10-31T05:02:48.697Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4f/9d/d03542c93bb3d448406731b80f39c3d5601282f778328c22c77d270f4ed4/plumbum-1.9.0-py3-none-any.whl", hash = "sha256:9fd0d3b0e8d86e4b581af36edf3f3bbe9d1ae15b45b8caab28de1bcb27aaa7f5", size = 127970, upload-time = "2024-10-05T05:59:25.102Z" },
+    { url = "https://files.pythonhosted.org/packages/79/ad/45312df6b63ba64ea35b8d8f5f0c577aac16e6b416eafe8e1cb34e03f9a7/plumbum-1.10.0-py3-none-any.whl", hash = "sha256:9583d737ac901c474d99d030e4d5eec4c4e6d2d7417b1cf49728cf3be34f6dc8", size = 127383, upload-time = "2025-10-31T05:02:47.002Z" },
 ]
 
 [[package]]
@@ -877,7 +868,7 @@ wheels = [
 
 [[package]]
 name = "pydantic"
-version = "2.12.3"
+version = "2.12.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-types" },
@@ -885,76 +876,80 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/1e/4f0a3233767010308f2fd6bd0814597e3f63f1dc98304a9112b8759df4ff/pydantic-2.12.3.tar.gz", hash = "sha256:1da1c82b0fc140bb0103bc1441ffe062154c8d38491189751ee00fd8ca65ce74", size = 819383, upload-time = "2025-10-17T15:04:21.222Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/ad/a17bc283d7d81837c061c49e3eaa27a45991759a1b7eae1031921c6bd924/pydantic-2.12.4.tar.gz", hash = "sha256:0f8cb9555000a4b5b617f66bfd2566264c4984b27589d3b845685983e8ea85ac", size = 821038, upload-time = "2025-11-05T10:50:08.59Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a1/6b/83661fa77dcefa195ad5f8cd9af3d1a7450fd57cc883ad04d65446ac2029/pydantic-2.12.3-py3-none-any.whl", hash = "sha256:6986454a854bc3bc6e5443e1369e06a3a456af9d339eda45510f517d9ea5c6bf", size = 462431, upload-time = "2025-10-17T15:04:19.346Z" },
+    { url = "https://files.pythonhosted.org/packages/82/2f/e68750da9b04856e2a7ec56fc6f034a5a79775e9b9a81882252789873798/pydantic-2.12.4-py3-none-any.whl", hash = "sha256:92d3d202a745d46f9be6df459ac5a064fdaa3c1c4cd8adcfa332ccf3c05f871e", size = 463400, upload-time = "2025-11-05T10:50:06.732Z" },
 ]
 
 [[package]]
 name = "pydantic-core"
-version = "2.41.4"
+version = "2.41.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/df/18/d0944e8eaaa3efd0a91b0f1fc537d3be55ad35091b6a87638211ba691964/pydantic_core-2.41.4.tar.gz", hash = "sha256:70e47929a9d4a1905a67e4b687d5946026390568a8e952b92824118063cee4d5", size = 457557, upload-time = "2025-10-14T10:23:47.909Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/81/d3b3e95929c4369d30b2a66a91db63c8ed0a98381ae55a45da2cd1cc1288/pydantic_core-2.41.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:ab06d77e053d660a6faaf04894446df7b0a7e7aba70c2797465a0a1af00fc887", size = 2099043, upload-time = "2025-10-14T10:20:28.561Z" },
-    { url = "https://files.pythonhosted.org/packages/58/da/46fdac49e6717e3a94fc9201403e08d9d61aa7a770fab6190b8740749047/pydantic_core-2.41.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c53ff33e603a9c1179a9364b0a24694f183717b2e0da2b5ad43c316c956901b2", size = 1910699, upload-time = "2025-10-14T10:20:30.217Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/63/4d948f1b9dd8e991a5a98b77dd66c74641f5f2e5225fee37994b2e07d391/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:304c54176af2c143bd181d82e77c15c41cbacea8872a2225dd37e6544dce9999", size = 1952121, upload-time = "2025-10-14T10:20:32.246Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/a7/e5fc60a6f781fc634ecaa9ecc3c20171d238794cef69ae0af79ac11b89d7/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:025ba34a4cf4fb32f917d5d188ab5e702223d3ba603be4d8aca2f82bede432a4", size = 2041590, upload-time = "2025-10-14T10:20:34.332Z" },
-    { url = "https://files.pythonhosted.org/packages/70/69/dce747b1d21d59e85af433428978a1893c6f8a7068fa2bb4a927fba7a5ff/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b9f5f30c402ed58f90c70e12eff65547d3ab74685ffe8283c719e6bead8ef53f", size = 2219869, upload-time = "2025-10-14T10:20:35.965Z" },
-    { url = "https://files.pythonhosted.org/packages/83/6a/c070e30e295403bf29c4df1cb781317b6a9bac7cd07b8d3acc94d501a63c/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd96e5d15385d301733113bcaa324c8bcf111275b7675a9c6e88bfb19fc05e3b", size = 2345169, upload-time = "2025-10-14T10:20:37.627Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/83/06d001f8043c336baea7fd202a9ac7ad71f87e1c55d8112c50b745c40324/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98f348cbb44fae6e9653c1055db7e29de67ea6a9ca03a5fa2c2e11a47cff0e47", size = 2070165, upload-time = "2025-10-14T10:20:39.246Z" },
-    { url = "https://files.pythonhosted.org/packages/14/0a/e567c2883588dd12bcbc110232d892cf385356f7c8a9910311ac997ab715/pydantic_core-2.41.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ec22626a2d14620a83ca583c6f5a4080fa3155282718b6055c2ea48d3ef35970", size = 2189067, upload-time = "2025-10-14T10:20:41.015Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/1d/3d9fca34273ba03c9b1c5289f7618bc4bd09c3ad2289b5420481aa051a99/pydantic_core-2.41.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3a95d4590b1f1a43bf33ca6d647b990a88f4a3824a8c4572c708f0b45a5290ed", size = 2132997, upload-time = "2025-10-14T10:20:43.106Z" },
-    { url = "https://files.pythonhosted.org/packages/52/70/d702ef7a6cd41a8afc61f3554922b3ed8d19dd54c3bd4bdbfe332e610827/pydantic_core-2.41.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:f9672ab4d398e1b602feadcffcdd3af44d5f5e6ddc15bc7d15d376d47e8e19f8", size = 2307187, upload-time = "2025-10-14T10:20:44.849Z" },
-    { url = "https://files.pythonhosted.org/packages/68/4c/c06be6e27545d08b802127914156f38d10ca287a9e8489342793de8aae3c/pydantic_core-2.41.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:84d8854db5f55fead3b579f04bda9a36461dab0730c5d570e1526483e7bb8431", size = 2305204, upload-time = "2025-10-14T10:20:46.781Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/e5/35ae4919bcd9f18603419e23c5eaf32750224a89d41a8df1a3704b69f77e/pydantic_core-2.41.4-cp312-cp312-win32.whl", hash = "sha256:9be1c01adb2ecc4e464392c36d17f97e9110fbbc906bcbe1c943b5b87a74aabd", size = 1972536, upload-time = "2025-10-14T10:20:48.39Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/c2/49c5bb6d2a49eb2ee3647a93e3dae7080c6409a8a7558b075027644e879c/pydantic_core-2.41.4-cp312-cp312-win_amd64.whl", hash = "sha256:d682cf1d22bab22a5be08539dca3d1593488a99998f9f412137bc323179067ff", size = 2031132, upload-time = "2025-10-14T10:20:50.421Z" },
-    { url = "https://files.pythonhosted.org/packages/06/23/936343dbcba6eec93f73e95eb346810fc732f71ba27967b287b66f7b7097/pydantic_core-2.41.4-cp312-cp312-win_arm64.whl", hash = "sha256:833eebfd75a26d17470b58768c1834dfc90141b7afc6eb0429c21fc5a21dcfb8", size = 1969483, upload-time = "2025-10-14T10:20:52.35Z" },
-    { url = "https://files.pythonhosted.org/packages/13/d0/c20adabd181a029a970738dfe23710b52a31f1258f591874fcdec7359845/pydantic_core-2.41.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:85e050ad9e5f6fe1004eec65c914332e52f429bc0ae12d6fa2092407a462c746", size = 2105688, upload-time = "2025-10-14T10:20:54.448Z" },
-    { url = "https://files.pythonhosted.org/packages/00/b6/0ce5c03cec5ae94cca220dfecddc453c077d71363b98a4bbdb3c0b22c783/pydantic_core-2.41.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7393f1d64792763a48924ba31d1e44c2cfbc05e3b1c2c9abb4ceeadd912cced", size = 1910807, upload-time = "2025-10-14T10:20:56.115Z" },
-    { url = "https://files.pythonhosted.org/packages/68/3e/800d3d02c8beb0b5c069c870cbb83799d085debf43499c897bb4b4aaff0d/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94dab0940b0d1fb28bcab847adf887c66a27a40291eedf0b473be58761c9799a", size = 1956669, upload-time = "2025-10-14T10:20:57.874Z" },
-    { url = "https://files.pythonhosted.org/packages/60/a4/24271cc71a17f64589be49ab8bd0751f6a0a03046c690df60989f2f95c2c/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:de7c42f897e689ee6f9e93c4bec72b99ae3b32a2ade1c7e4798e690ff5246e02", size = 2051629, upload-time = "2025-10-14T10:21:00.006Z" },
-    { url = "https://files.pythonhosted.org/packages/68/de/45af3ca2f175d91b96bfb62e1f2d2f1f9f3b14a734afe0bfeff079f78181/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:664b3199193262277b8b3cd1e754fb07f2c6023289c815a1e1e8fb415cb247b1", size = 2224049, upload-time = "2025-10-14T10:21:01.801Z" },
-    { url = "https://files.pythonhosted.org/packages/af/8f/ae4e1ff84672bf869d0a77af24fd78387850e9497753c432875066b5d622/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d95b253b88f7d308b1c0b417c4624f44553ba4762816f94e6986819b9c273fb2", size = 2342409, upload-time = "2025-10-14T10:21:03.556Z" },
-    { url = "https://files.pythonhosted.org/packages/18/62/273dd70b0026a085c7b74b000394e1ef95719ea579c76ea2f0cc8893736d/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1351f5bbdbbabc689727cb91649a00cb9ee7203e0a6e54e9f5ba9e22e384b84", size = 2069635, upload-time = "2025-10-14T10:21:05.385Z" },
-    { url = "https://files.pythonhosted.org/packages/30/03/cf485fff699b4cdaea469bc481719d3e49f023241b4abb656f8d422189fc/pydantic_core-2.41.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1affa4798520b148d7182da0615d648e752de4ab1a9566b7471bc803d88a062d", size = 2194284, upload-time = "2025-10-14T10:21:07.122Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/7e/c8e713db32405dfd97211f2fc0a15d6bf8adb7640f3d18544c1f39526619/pydantic_core-2.41.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7b74e18052fea4aa8dea2fb7dbc23d15439695da6cbe6cfc1b694af1115df09d", size = 2137566, upload-time = "2025-10-14T10:21:08.981Z" },
-    { url = "https://files.pythonhosted.org/packages/04/f7/db71fd4cdccc8b75990f79ccafbbd66757e19f6d5ee724a6252414483fb4/pydantic_core-2.41.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:285b643d75c0e30abda9dc1077395624f314a37e3c09ca402d4015ef5979f1a2", size = 2316809, upload-time = "2025-10-14T10:21:10.805Z" },
-    { url = "https://files.pythonhosted.org/packages/76/63/a54973ddb945f1bca56742b48b144d85c9fc22f819ddeb9f861c249d5464/pydantic_core-2.41.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:f52679ff4218d713b3b33f88c89ccbf3a5c2c12ba665fb80ccc4192b4608dbab", size = 2311119, upload-time = "2025-10-14T10:21:12.583Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/03/5d12891e93c19218af74843a27e32b94922195ded2386f7b55382f904d2f/pydantic_core-2.41.4-cp313-cp313-win32.whl", hash = "sha256:ecde6dedd6fff127c273c76821bb754d793be1024bc33314a120f83a3c69460c", size = 1981398, upload-time = "2025-10-14T10:21:14.584Z" },
-    { url = "https://files.pythonhosted.org/packages/be/d8/fd0de71f39db91135b7a26996160de71c073d8635edfce8b3c3681be0d6d/pydantic_core-2.41.4-cp313-cp313-win_amd64.whl", hash = "sha256:d081a1f3800f05409ed868ebb2d74ac39dd0c1ff6c035b5162356d76030736d4", size = 2030735, upload-time = "2025-10-14T10:21:16.432Z" },
-    { url = "https://files.pythonhosted.org/packages/72/86/c99921c1cf6650023c08bfab6fe2d7057a5142628ef7ccfa9921f2dda1d5/pydantic_core-2.41.4-cp313-cp313-win_arm64.whl", hash = "sha256:f8e49c9c364a7edcbe2a310f12733aad95b022495ef2a8d653f645e5d20c1564", size = 1973209, upload-time = "2025-10-14T10:21:18.213Z" },
-    { url = "https://files.pythonhosted.org/packages/36/0d/b5706cacb70a8414396efdda3d72ae0542e050b591119e458e2490baf035/pydantic_core-2.41.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ed97fd56a561f5eb5706cebe94f1ad7c13b84d98312a05546f2ad036bafe87f4", size = 1877324, upload-time = "2025-10-14T10:21:20.363Z" },
-    { url = "https://files.pythonhosted.org/packages/de/2d/cba1fa02cfdea72dfb3a9babb067c83b9dff0bbcb198368e000a6b756ea7/pydantic_core-2.41.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a870c307bf1ee91fc58a9a61338ff780d01bfae45922624816878dce784095d2", size = 1884515, upload-time = "2025-10-14T10:21:22.339Z" },
-    { url = "https://files.pythonhosted.org/packages/07/ea/3df927c4384ed9b503c9cc2d076cf983b4f2adb0c754578dfb1245c51e46/pydantic_core-2.41.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d25e97bc1f5f8f7985bdc2335ef9e73843bb561eb1fa6831fdfc295c1c2061cf", size = 2042819, upload-time = "2025-10-14T10:21:26.683Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/ee/df8e871f07074250270a3b1b82aad4cd0026b588acd5d7d3eb2fcb1471a3/pydantic_core-2.41.4-cp313-cp313t-win_amd64.whl", hash = "sha256:d405d14bea042f166512add3091c1af40437c2e7f86988f3915fabd27b1e9cd2", size = 1995866, upload-time = "2025-10-14T10:21:28.951Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/de/b20f4ab954d6d399499c33ec4fafc46d9551e11dc1858fb7f5dca0748ceb/pydantic_core-2.41.4-cp313-cp313t-win_arm64.whl", hash = "sha256:19f3684868309db5263a11bace3c45d93f6f24afa2ffe75a647583df22a2ff89", size = 1970034, upload-time = "2025-10-14T10:21:30.869Z" },
-    { url = "https://files.pythonhosted.org/packages/54/28/d3325da57d413b9819365546eb9a6e8b7cbd9373d9380efd5f74326143e6/pydantic_core-2.41.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:e9205d97ed08a82ebb9a307e92914bb30e18cdf6f6b12ca4bedadb1588a0bfe1", size = 2102022, upload-time = "2025-10-14T10:21:32.809Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/24/b58a1bc0d834bf1acc4361e61233ee217169a42efbdc15a60296e13ce438/pydantic_core-2.41.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:82df1f432b37d832709fbcc0e24394bba04a01b6ecf1ee87578145c19cde12ac", size = 1905495, upload-time = "2025-10-14T10:21:34.812Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/a4/71f759cc41b7043e8ecdaab81b985a9b6cad7cec077e0b92cff8b71ecf6b/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc3b4cc4539e055cfa39a3763c939f9d409eb40e85813257dcd761985a108554", size = 1956131, upload-time = "2025-10-14T10:21:36.924Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/64/1e79ac7aa51f1eec7c4cda8cbe456d5d09f05fdd68b32776d72168d54275/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b1eb1754fce47c63d2ff57fdb88c351a6c0150995890088b33767a10218eaa4e", size = 2052236, upload-time = "2025-10-14T10:21:38.927Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/e3/a3ffc363bd4287b80f1d43dc1c28ba64831f8dfc237d6fec8f2661138d48/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e6ab5ab30ef325b443f379ddb575a34969c333004fca5a1daa0133a6ffaad616", size = 2223573, upload-time = "2025-10-14T10:21:41.574Z" },
-    { url = "https://files.pythonhosted.org/packages/28/27/78814089b4d2e684a9088ede3790763c64693c3d1408ddc0a248bc789126/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:31a41030b1d9ca497634092b46481b937ff9397a86f9f51bd41c4767b6fc04af", size = 2342467, upload-time = "2025-10-14T10:21:44.018Z" },
-    { url = "https://files.pythonhosted.org/packages/92/97/4de0e2a1159cb85ad737e03306717637842c88c7fd6d97973172fb183149/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a44ac1738591472c3d020f61c6df1e4015180d6262ebd39bf2aeb52571b60f12", size = 2063754, upload-time = "2025-10-14T10:21:46.466Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/50/8cb90ce4b9efcf7ae78130afeb99fd1c86125ccdf9906ef64b9d42f37c25/pydantic_core-2.41.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d72f2b5e6e82ab8f94ea7d0d42f83c487dc159c5240d8f83beae684472864e2d", size = 2196754, upload-time = "2025-10-14T10:21:48.486Z" },
-    { url = "https://files.pythonhosted.org/packages/34/3b/ccdc77af9cd5082723574a1cc1bcae7a6acacc829d7c0a06201f7886a109/pydantic_core-2.41.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:c4d1e854aaf044487d31143f541f7aafe7b482ae72a022c664b2de2e466ed0ad", size = 2137115, upload-time = "2025-10-14T10:21:50.63Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/ba/e7c7a02651a8f7c52dc2cff2b64a30c313e3b57c7d93703cecea76c09b71/pydantic_core-2.41.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b568af94267729d76e6ee5ececda4e283d07bbb28e8148bb17adad93d025d25a", size = 2317400, upload-time = "2025-10-14T10:21:52.959Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/ba/6c533a4ee8aec6b812c643c49bb3bd88d3f01e3cebe451bb85512d37f00f/pydantic_core-2.41.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:6d55fb8b1e8929b341cc313a81a26e0d48aa3b519c1dbaadec3a6a2b4fcad025", size = 2312070, upload-time = "2025-10-14T10:21:55.419Z" },
-    { url = "https://files.pythonhosted.org/packages/22/ae/f10524fcc0ab8d7f96cf9a74c880243576fd3e72bd8ce4f81e43d22bcab7/pydantic_core-2.41.4-cp314-cp314-win32.whl", hash = "sha256:5b66584e549e2e32a1398df11da2e0a7eff45d5c2d9db9d5667c5e6ac764d77e", size = 1982277, upload-time = "2025-10-14T10:21:57.474Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/dc/e5aa27aea1ad4638f0c3fb41132f7eb583bd7420ee63204e2d4333a3bbf9/pydantic_core-2.41.4-cp314-cp314-win_amd64.whl", hash = "sha256:557a0aab88664cc552285316809cab897716a372afaf8efdbef756f8b890e894", size = 2024608, upload-time = "2025-10-14T10:21:59.557Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/61/51d89cc2612bd147198e120a13f150afbf0bcb4615cddb049ab10b81b79e/pydantic_core-2.41.4-cp314-cp314-win_arm64.whl", hash = "sha256:3f1ea6f48a045745d0d9f325989d8abd3f1eaf47dd00485912d1a3a63c623a8d", size = 1967614, upload-time = "2025-10-14T10:22:01.847Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/c2/472f2e31b95eff099961fa050c376ab7156a81da194f9edb9f710f68787b/pydantic_core-2.41.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6c1fe4c5404c448b13188dd8bd2ebc2bdd7e6727fa61ff481bcc2cca894018da", size = 1876904, upload-time = "2025-10-14T10:22:04.062Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/07/ea8eeb91173807ecdae4f4a5f4b150a520085b35454350fc219ba79e66a3/pydantic_core-2.41.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:523e7da4d43b113bf8e7b49fa4ec0c35bf4fe66b2230bfc5c13cc498f12c6c3e", size = 1882538, upload-time = "2025-10-14T10:22:06.39Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/29/b53a9ca6cd366bfc928823679c6a76c7a4c69f8201c0ba7903ad18ebae2f/pydantic_core-2.41.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5729225de81fb65b70fdb1907fcf08c75d498f4a6f15af005aabb1fdadc19dfa", size = 2041183, upload-time = "2025-10-14T10:22:08.812Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/3d/f8c1a371ceebcaf94d6dd2d77c6cf4b1c078e13a5837aee83f760b4f7cfd/pydantic_core-2.41.4-cp314-cp314t-win_amd64.whl", hash = "sha256:de2cfbb09e88f0f795fd90cf955858fc2c691df65b1f21f0aa00b99f3fbc661d", size = 1993542, upload-time = "2025-10-14T10:22:11.332Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/ac/9fc61b4f9d079482a290afe8d206b8f490e9fd32d4fc03ed4fc698214e01/pydantic_core-2.41.4-cp314-cp314t-win_arm64.whl", hash = "sha256:d34f950ae05a83e0ede899c595f312ca976023ea1db100cd5aa188f7005e3ab0", size = 1973897, upload-time = "2025-10-14T10:22:13.444Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/48/ae937e5a831b7c0dc646b2ef788c27cd003894882415300ed21927c21efa/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:4f5d640aeebb438517150fdeec097739614421900e4a08db4a3ef38898798537", size = 2112087, upload-time = "2025-10-14T10:22:56.818Z" },
-    { url = "https://files.pythonhosted.org/packages/5e/db/6db8073e3d32dae017da7e0d16a9ecb897d0a4d92e00634916e486097961/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:4a9ab037b71927babc6d9e7fc01aea9e66dc2a4a34dff06ef0724a4049629f94", size = 1920387, upload-time = "2025-10-14T10:22:59.342Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/c1/dd3542d072fcc336030d66834872f0328727e3b8de289c662faa04aa270e/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4dab9484ec605c3016df9ad4fd4f9a390bc5d816a3b10c6550f8424bb80b18c", size = 1951495, upload-time = "2025-10-14T10:23:02.089Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/c6/db8d13a1f8ab3f1eb08c88bd00fd62d44311e3456d1e85c0e59e0a0376e7/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8a5028425820731d8c6c098ab642d7b8b999758e24acae03ed38a66eca8335", size = 2139008, upload-time = "2025-10-14T10:23:04.539Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
 ]
 
 [[package]]
@@ -968,55 +963,57 @@ wheels = [
 
 [[package]]
 name = "pymdown-extensions"
-version = "10.7.1"
+version = "10.17.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markdown" },
     { name = "pyyaml" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b0/ec/e3d966cfb286d5a48e7c43a559a297b857ab935209ee9072e5a5492706c9/pymdown_extensions-10.7.1.tar.gz", hash = "sha256:c70e146bdd83c744ffc766b4671999796aba18842b268510a329f7f64700d584", size = 811769, upload-time = "2024-03-05T01:24:11.296Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/d9/a987e4d549c6c82353fce5fa5f650229bb60ea4c0d1684a2714a509aef58/pymdown_extensions-10.17.1.tar.gz", hash = "sha256:60d05fe55e7fb5a1e4740fc575facad20dc6ee3a748e8d3d36ba44142e75ce03", size = 845207, upload-time = "2025-11-11T21:44:58.815Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ff/4b/4ebb08f36e83e91b31117fe8f67844bac7f5c7d11ed151ae5db807be363f/pymdown_extensions-10.7.1-py3-none-any.whl", hash = "sha256:f5cc7000d7ff0d1ce9395d216017fa4df3dde800afb1fb72d1c7d3fd35e710f4", size = 250794, upload-time = "2024-03-05T01:24:08.433Z" },
+    { url = "https://files.pythonhosted.org/packages/81/40/b2d7b9fdccc63e48ae4dbd363b6b89eb7ac346ea49ed667bb71f92af3021/pymdown_extensions-10.17.1-py3-none-any.whl", hash = "sha256:1f160209c82eecbb5d8a0d8f89a4d9bd6bdcbde9a8537761844cfc57ad5cd8a6", size = 266310, upload-time = "2025-11-11T21:44:56.809Z" },
 ]
 
 [[package]]
 name = "pyright"
-version = "1.1.406"
+version = "1.1.407"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "nodeenv" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f7/16/6b4fbdd1fef59a0292cbb99f790b44983e390321eccbc5921b4d161da5d1/pyright-1.1.406.tar.gz", hash = "sha256:c4872bc58c9643dac09e8a2e74d472c62036910b3bd37a32813989ef7576ea2c", size = 4113151, upload-time = "2025-10-02T01:04:45.488Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/1b/0aa08ee42948b61745ac5b5b5ccaec4669e8884b53d31c8ec20b2fcd6b6f/pyright-1.1.407.tar.gz", hash = "sha256:099674dba5c10489832d4a4b2d302636152a9a42d317986c38474c76fe562262", size = 4122872, upload-time = "2025-10-24T23:17:15.145Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f6/a2/e309afbb459f50507103793aaef85ca4348b66814c86bc73908bdeb66d12/pyright-1.1.406-py3-none-any.whl", hash = "sha256:1d81fb43c2407bf566e97e57abb01c811973fdb21b2df8df59f870f688bdca71", size = 5980982, upload-time = "2025-10-02T01:04:43.137Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/93/b69052907d032b00c40cb656d21438ec00b3a471733de137a3f65a49a0a0/pyright-1.1.407-py3-none-any.whl", hash = "sha256:6dd419f54fcc13f03b52285796d65e639786373f433e243f8b94cf93a7444d21", size = 5997008, upload-time = "2025-10-24T23:17:13.159Z" },
 ]
 
 [[package]]
 name = "pytest"
-version = "7.4.4"
+version = "9.0.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
     { name = "iniconfig" },
     { name = "packaging" },
     { name = "pluggy" },
+    { name = "pygments" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/80/1f/9d8e98e4133ffb16c90f3b405c43e38d3abb715bb5d7a63a5a684f7e46a3/pytest-7.4.4.tar.gz", hash = "sha256:2cf0005922c6ace4a3e2ec8b4080eb0d9753fdc93107415332f50ce9e7994280", size = 1357116, upload-time = "2023-12-31T12:00:18.035Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/07/56/f013048ac4bc4c1d9be45afd4ab209ea62822fb1598f40687e6bf45dcea4/pytest-9.0.1.tar.gz", hash = "sha256:3e9c069ea73583e255c3b21cf46b8d3c56f6e3a1a8f6da94ccb0fcf57b9d73c8", size = 1564125, upload-time = "2025-11-12T13:05:09.333Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/51/ff/f6e8b8f39e08547faece4bd80f89d5a8de68a38b2d179cc1c4490ffa3286/pytest-7.4.4-py3-none-any.whl", hash = "sha256:b090cdf5ed60bf4c45261be03239c2c1c22df034fbffe691abe93cd80cea01d8", size = 325287, upload-time = "2023-12-31T12:00:13.963Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/8b/6300fb80f858cda1c51ffa17075df5d846757081d11ab4aa35cef9e6258b/pytest-9.0.1-py3-none-any.whl", hash = "sha256:67be0030d194df2dfa7b556f2e56fb3c3315bd5c8822c6951162b92b32ce7dad", size = 373668, upload-time = "2025-11-12T13:05:07.379Z" },
 ]
 
 [[package]]
 name = "pytest-asyncio"
-version = "0.21.2"
+version = "1.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ae/53/57663d99acaac2fcdafdc697e52a9b1b7d6fcf36616281ff9768a44e7ff3/pytest_asyncio-0.21.2.tar.gz", hash = "sha256:d67738fc232b94b326b9d060750beb16e0074210b98dd8b58a5239fa2a154f45", size = 30656, upload-time = "2024-04-29T13:23:24.738Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9c/ce/1e4b53c213dce25d6e8b163697fbce2d43799d76fa08eea6ad270451c370/pytest_asyncio-0.21.2-py3-none-any.whl", hash = "sha256:ab664c88bb7998f711d8039cacd4884da6430886ae8bbd4eded552ed2004f16b", size = 13368, upload-time = "2024-04-29T13:23:23.126Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
 ]
 
 [[package]]
@@ -1215,40 +1212,54 @@ wheels = [
 
 [[package]]
 name = "rich-argparse"
-version = "1.7.1"
+version = "1.7.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "rich" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4c/f7/1c65e0245d4c7009a87ac92908294a66e7e7635eccf76a68550f40c6df80/rich_argparse-1.7.2.tar.gz", hash = "sha256:64fd2e948fc96e8a1a06e0e72c111c2ce7f3af74126d75c0f5f63926e7289cd1", size = 38500, upload-time = "2025-11-01T10:35:44.232Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/80/97b6f357ac458d9ad9872cc3183ca09ef7439ac89e030ea43053ba1294b6/rich_argparse-1.7.2-py3-none-any.whl", hash = "sha256:0559b1f47a19bbeb82bf15f95a057f99bcbbc98385532f57937f9fc57acc501a", size = 25476, upload-time = "2025-11-01T10:35:42.681Z" },
+]
+
+[[package]]
+name = "rich-click"
+version = "1.9.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "click" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/71/a6/34460d81e5534f6d2fc8e8d91ff99a5835fdca53578eac89e4f37b3a7c6d/rich_argparse-1.7.1.tar.gz", hash = "sha256:d7a493cde94043e41ea68fb43a74405fa178de981bf7b800f7a3bd02ac5c27be", size = 38094, upload-time = "2025-05-25T20:20:35.335Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/bf/d8/f2c1b7e9a645ba40f756d7a5b195fc104729bc6b19061ba3ab385f342931/rich_click-1.9.4.tar.gz", hash = "sha256:af73dc68e85f3bebb80ce302a642b9fe3b65f3df0ceb42eb9a27c467c1b678c8", size = 73632, upload-time = "2025-10-25T01:08:49.142Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/31/f6/5fc0574af5379606ffd57a4b68ed88f9b415eb222047fe023aefcc00a648/rich_argparse-1.7.1-py3-none-any.whl", hash = "sha256:a8650b42e4a4ff72127837632fba6b7da40784842f08d7395eb67a9cbd7b4bf9", size = 25357, upload-time = "2025-05-25T20:20:33.793Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/6a/1f03adcb3cc7beb6f63aecc21565e9d515ccee653187fc4619cd0b42713b/rich_click-1.9.4-py3-none-any.whl", hash = "sha256:d70f39938bcecaf5543e8750828cbea94ef51853f7d0e174cda1e10543767389", size = 70245, upload-time = "2025-10-25T01:08:47.939Z" },
 ]
 
 [[package]]
 name = "ruff"
-version = "0.14.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9e/58/6ca66896635352812de66f71cdf9ff86b3a4f79071ca5730088c0cd0fc8d/ruff-0.14.1.tar.gz", hash = "sha256:1dd86253060c4772867c61791588627320abcb6ed1577a90ef432ee319729b69", size = 5513429, upload-time = "2025-10-16T18:05:41.766Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8d/39/9cc5ab181478d7a18adc1c1e051a84ee02bec94eb9bdfd35643d7c74ca31/ruff-0.14.1-py3-none-linux_armv6l.whl", hash = "sha256:083bfc1f30f4a391ae09c6f4f99d83074416b471775b59288956f5bc18e82f8b", size = 12445415, upload-time = "2025-10-16T18:04:48.227Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/2e/1226961855ccd697255988f5a2474890ac7c5863b080b15bd038df820818/ruff-0.14.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:f6fa757cd717f791009f7669fefb09121cc5f7d9bd0ef211371fad68c2b8b224", size = 12784267, upload-time = "2025-10-16T18:04:52.515Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/ea/fd9e95863124ed159cd0667ec98449ae461de94acda7101f1acb6066da00/ruff-0.14.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d6191903d39ac156921398e9c86b7354d15e3c93772e7dbf26c9fcae59ceccd5", size = 11781872, upload-time = "2025-10-16T18:04:55.396Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/5a/e890f7338ff537dba4589a5e02c51baa63020acfb7c8cbbaea4831562c96/ruff-0.14.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed04f0e04f7a4587244e5c9d7df50e6b5bf2705d75059f409a6421c593a35896", size = 12226558, upload-time = "2025-10-16T18:04:58.166Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/7a/8ab5c3377f5bf31e167b73651841217542bcc7aa1c19e83030835cc25204/ruff-0.14.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5c9e6cf6cd4acae0febbce29497accd3632fe2025c0c583c8b87e8dbdeae5f61", size = 12187898, upload-time = "2025-10-16T18:05:01.455Z" },
-    { url = "https://files.pythonhosted.org/packages/48/8d/ba7c33aa55406955fc124e62c8259791c3d42e3075a71710fdff9375134f/ruff-0.14.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a6fa2458527794ecdfbe45f654e42c61f2503a230545a91af839653a0a93dbc6", size = 12939168, upload-time = "2025-10-16T18:05:04.397Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/c2/70783f612b50f66d083380e68cbd1696739d88e9b4f6164230375532c637/ruff-0.14.1-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:39f1c392244e338b21d42ab29b8a6392a722c5090032eb49bb4d6defcdb34345", size = 14386942, upload-time = "2025-10-16T18:05:07.102Z" },
-    { url = "https://files.pythonhosted.org/packages/48/44/cd7abb9c776b66d332119d67f96acf15830d120f5b884598a36d9d3f4d83/ruff-0.14.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7382fa12a26cce1f95070ce450946bec357727aaa428983036362579eadcc5cf", size = 13990622, upload-time = "2025-10-16T18:05:09.882Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/56/4259b696db12ac152fe472764b4f78bbdd9b477afd9bc3a6d53c01300b37/ruff-0.14.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd0bf2be3ae8521e1093a487c4aa3b455882f139787770698530d28ed3fbb37c", size = 13431143, upload-time = "2025-10-16T18:05:13.46Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/35/266a80d0eb97bd224b3265b9437bd89dde0dcf4faf299db1212e81824e7e/ruff-0.14.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cabcaa9ccf8089fb4fdb78d17cc0e28241520f50f4c2e88cb6261ed083d85151", size = 13132844, upload-time = "2025-10-16T18:05:16.1Z" },
-    { url = "https://files.pythonhosted.org/packages/65/6e/d31ce218acc11a8d91ef208e002a31acf315061a85132f94f3df7a252b18/ruff-0.14.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:747d583400f6125ec11a4c14d1c8474bf75d8b419ad22a111a537ec1a952d192", size = 13401241, upload-time = "2025-10-16T18:05:19.395Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/b5/dbc4221bf0b03774b3b2f0d47f39e848d30664157c15b965a14d890637d2/ruff-0.14.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:5a6e74c0efd78515a1d13acbfe6c90f0f5bd822aa56b4a6d43a9ffb2ae6e56cd", size = 12132476, upload-time = "2025-10-16T18:05:22.163Z" },
-    { url = "https://files.pythonhosted.org/packages/98/4b/ac99194e790ccd092d6a8b5f341f34b6e597d698e3077c032c502d75ea84/ruff-0.14.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:0ea6a864d2fb41a4b6d5b456ed164302a0d96f4daac630aeba829abfb059d020", size = 12139749, upload-time = "2025-10-16T18:05:25.162Z" },
-    { url = "https://files.pythonhosted.org/packages/47/26/7df917462c3bb5004e6fdfcc505a49e90bcd8a34c54a051953118c00b53a/ruff-0.14.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:0826b8764f94229604fa255918d1cc45e583e38c21c203248b0bfc9a0e930be5", size = 12544758, upload-time = "2025-10-16T18:05:28.018Z" },
-    { url = "https://files.pythonhosted.org/packages/64/d0/81e7f0648e9764ad9b51dd4be5e5dac3fcfff9602428ccbae288a39c2c22/ruff-0.14.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:cbc52160465913a1a3f424c81c62ac8096b6a491468e7d872cb9444a860bc33d", size = 13221811, upload-time = "2025-10-16T18:05:30.707Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/07/3c45562c67933cc35f6d5df4ca77dabbcd88fddaca0d6b8371693d29fd56/ruff-0.14.1-py3-none-win32.whl", hash = "sha256:e037ea374aaaff4103240ae79168c0945ae3d5ae8db190603de3b4012bd1def6", size = 12319467, upload-time = "2025-10-16T18:05:33.261Z" },
-    { url = "https://files.pythonhosted.org/packages/02/88/0ee4ca507d4aa05f67e292d2e5eb0b3e358fbcfe527554a2eda9ac422d6b/ruff-0.14.1-py3-none-win_amd64.whl", hash = "sha256:59d599cdff9c7f925a017f6f2c256c908b094e55967f93f2821b1439928746a1", size = 13401123, upload-time = "2025-10-16T18:05:35.984Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/81/4b6387be7014858d924b843530e1b2a8e531846807516e9bea2ee0936bf7/ruff-0.14.1-py3-none-win_arm64.whl", hash = "sha256:e3b443c4c9f16ae850906b8d0a707b2a4c16f8d2f0a7fe65c475c5886665ce44", size = 12436636, upload-time = "2025-10-16T18:05:38.995Z" },
+version = "0.14.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/fa/fbb67a5780ae0f704876cb8ac92d6d76da41da4dc72b7ed3565ab18f2f52/ruff-0.14.5.tar.gz", hash = "sha256:8d3b48d7d8aad423d3137af7ab6c8b1e38e4de104800f0d596990f6ada1a9fc1", size = 5615944, upload-time = "2025-11-13T19:58:51.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/31/c07e9c535248d10836a94e4f4e8c5a31a1beed6f169b31405b227872d4f4/ruff-0.14.5-py3-none-linux_armv6l.whl", hash = "sha256:f3b8248123b586de44a8018bcc9fefe31d23dda57a34e6f0e1e53bd51fd63594", size = 13171630, upload-time = "2025-11-13T19:57:54.894Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/5c/283c62516dca697cd604c2796d1487396b7a436b2f0ecc3fd412aca470e0/ruff-0.14.5-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:f7a75236570318c7a30edd7f5491945f0169de738d945ca8784500b517163a72", size = 13413925, upload-time = "2025-11-13T19:57:59.181Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/f3/aa319f4afc22cb6fcba2b9cdfc0f03bbf747e59ab7a8c5e90173857a1361/ruff-0.14.5-py3-none-macosx_11_0_arm64.whl", hash = "sha256:6d146132d1ee115f8802356a2dc9a634dbf58184c51bff21f313e8cd1c74899a", size = 12574040, upload-time = "2025-11-13T19:58:02.056Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/7f/cb5845fcc7c7e88ed57f58670189fc2ff517fe2134c3821e77e29fd3b0c8/ruff-0.14.5-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2380596653dcd20b057794d55681571a257a42327da8894b93bbd6111aa801f", size = 13009755, upload-time = "2025-11-13T19:58:05.172Z" },
+    { url = "https://files.pythonhosted.org/packages/21/d2/bcbedbb6bcb9253085981730687ddc0cc7b2e18e8dc13cf4453de905d7a0/ruff-0.14.5-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2d1fa985a42b1f075a098fa1ab9d472b712bdb17ad87a8ec86e45e7fa6273e68", size = 12937641, upload-time = "2025-11-13T19:58:08.345Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/58/e25de28a572bdd60ffc6bb71fc7fd25a94ec6a076942e372437649cbb02a/ruff-0.14.5-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88f0770d42b7fa02bbefddde15d235ca3aa24e2f0137388cc15b2dcbb1f7c7a7", size = 13610854, upload-time = "2025-11-13T19:58:11.419Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/24/43bb3fd23ecee9861970978ea1a7a63e12a204d319248a7e8af539984280/ruff-0.14.5-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:3676cb02b9061fee7294661071c4709fa21419ea9176087cb77e64410926eb78", size = 15061088, upload-time = "2025-11-13T19:58:14.551Z" },
+    { url = "https://files.pythonhosted.org/packages/23/44/a022f288d61c2f8c8645b24c364b719aee293ffc7d633a2ca4d116b9c716/ruff-0.14.5-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b595bedf6bc9cab647c4a173a61acf4f1ac5f2b545203ba82f30fcb10b0318fb", size = 14734717, upload-time = "2025-11-13T19:58:17.518Z" },
+    { url = "https://files.pythonhosted.org/packages/58/81/5c6ba44de7e44c91f68073e0658109d8373b0590940efe5bd7753a2585a3/ruff-0.14.5-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f55382725ad0bdb2e8ee2babcbbfb16f124f5a59496a2f6a46f1d9d99d93e6e2", size = 14028812, upload-time = "2025-11-13T19:58:20.533Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/ef/41a8b60f8462cb320f68615b00299ebb12660097c952c600c762078420f8/ruff-0.14.5-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7497d19dce23976bdaca24345ae131a1d38dcfe1b0850ad8e9e6e4fa321a6e19", size = 13825656, upload-time = "2025-11-13T19:58:23.345Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/00/207e5de737fdb59b39eb1fac806904fe05681981b46d6a6db9468501062e/ruff-0.14.5-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:410e781f1122d6be4f446981dd479470af86537fb0b8857f27a6e872f65a38e4", size = 13959922, upload-time = "2025-11-13T19:58:26.537Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/7e/fa1f5c2776db4be405040293618846a2dece5c70b050874c2d1f10f24776/ruff-0.14.5-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:c01be527ef4c91a6d55e53b337bfe2c0f82af024cc1a33c44792d6844e2331e1", size = 12932501, upload-time = "2025-11-13T19:58:29.822Z" },
+    { url = "https://files.pythonhosted.org/packages/67/d8/d86bf784d693a764b59479a6bbdc9515ae42c340a5dc5ab1dabef847bfaa/ruff-0.14.5-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f66e9bb762e68d66e48550b59c74314168ebb46199886c5c5aa0b0fbcc81b151", size = 12927319, upload-time = "2025-11-13T19:58:32.923Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/de/ee0b304d450ae007ce0cb3e455fe24fbcaaedae4ebaad6c23831c6663651/ruff-0.14.5-py3-none-musllinux_1_2_i686.whl", hash = "sha256:d93be8f1fa01022337f1f8f3bcaa7ffee2d0b03f00922c45c2207954f351f465", size = 13206209, upload-time = "2025-11-13T19:58:35.952Z" },
+    { url = "https://files.pythonhosted.org/packages/33/aa/193ca7e3a92d74f17d9d5771a765965d2cf42c86e6f0fd95b13969115723/ruff-0.14.5-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:c135d4b681f7401fe0e7312017e41aba9b3160861105726b76cfa14bc25aa367", size = 13953709, upload-time = "2025-11-13T19:58:39.002Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/f1/7119e42aa1d3bf036ffc9478885c2e248812b7de9abea4eae89163d2929d/ruff-0.14.5-py3-none-win32.whl", hash = "sha256:c83642e6fccfb6dea8b785eb9f456800dcd6a63f362238af5fc0c83d027dd08b", size = 12925808, upload-time = "2025-11-13T19:58:42.779Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/9d/7c0a255d21e0912114784e4a96bf62af0618e2190cae468cd82b13625ad2/ruff-0.14.5-py3-none-win_amd64.whl", hash = "sha256:9d55d7af7166f143c94eae1db3312f9ea8f95a4defef1979ed516dbb38c27621", size = 14331546, upload-time = "2025-11-13T19:58:45.691Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/80/69756670caedcf3b9be597a6e12276a6cf6197076eb62aad0c608f8efce0/ruff-0.14.5-py3-none-win_arm64.whl", hash = "sha256:4b700459d4649e2594b31f20a9de33bc7c19976d4746d8d0798ad959621d64a4", size = 13433331, upload-time = "2025-11-13T19:58:48.434Z" },
 ]
 
 [[package]]
@@ -1269,6 +1280,43 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/73/6d/b5406752c4e4ba86692b22fab0afed8b48f16bdde8f92e1d852976b61dc6/tomlkit-0.12.5-py3-none-any.whl", hash = "sha256:af914f5a9c59ed9d0762c7b64d3b5d5df007448eb9cd2edc8a46b1eafead172f", size = 37685, upload-time = "2024-05-08T13:50:17.343Z" },
 ]
 
+[[package]]
+name = "ty"
+version = "0.0.1a27"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8f/65/3592d7c73d80664378fc90d0a00c33449a99cbf13b984433c883815245f3/ty-0.0.1a27.tar.gz", hash = "sha256:d34fe04979f2c912700cbf0919e8f9b4eeaa10c4a2aff7450e5e4c90f998bc28", size = 4516059, upload-time = "2025-11-18T21:55:18.381Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/05/7945aa97356446fd53ed3ddc7ee02a88d8ad394217acd9428f472d6b109d/ty-0.0.1a27-py3-none-linux_armv6l.whl", hash = "sha256:3cbb735f5ecb3a7a5f5b82fb24da17912788c109086df4e97d454c8fb236fbc5", size = 9375047, upload-time = "2025-11-18T21:54:31.577Z" },
+    { url = "https://files.pythonhosted.org/packages/69/4e/89b167a03de0e9ec329dc89bc02e8694768e4576337ef6c0699987681342/ty-0.0.1a27-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:4a6367236dc456ba2416563301d498aef8c6f8959be88777ef7ba5ac1bf15f0b", size = 9169540, upload-time = "2025-11-18T21:54:34.036Z" },
+    { url = "https://files.pythonhosted.org/packages/38/07/e62009ab9cc242e1becb2bd992097c80a133fce0d4f055fba6576150d08a/ty-0.0.1a27-py3-none-macosx_11_0_arm64.whl", hash = "sha256:8e93e231a1bcde964cdb062d2d5e549c24493fb1638eecae8fcc42b81e9463a4", size = 8711942, upload-time = "2025-11-18T21:54:36.3Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/43/f35716ec15406f13085db52e762a3cc663c651531a8124481d0ba602eca0/ty-0.0.1a27-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5b6a8166b60117da1179851a3d719cc798bf7e61f91b35d76242f0059e9ae1d", size = 8984208, upload-time = "2025-11-18T21:54:39.453Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/79/486a3374809523172379768de882c7a369861165802990177fe81489b85f/ty-0.0.1a27-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfbe8b0e831c072b79a078d6c126d7f4d48ca17f64a103de1b93aeda32265dc5", size = 9157209, upload-time = "2025-11-18T21:54:42.664Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/08/9a7c8efcb327197d7d347c548850ef4b54de1c254981b65e8cd0672dc327/ty-0.0.1a27-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:90e09678331552e7c25d7eb47868b0910dc5b9b212ae22c8ce71a52d6576ddbb", size = 9519207, upload-time = "2025-11-18T21:54:45.311Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/9d/7b4680683e83204b9edec551bb91c21c789ebc586b949c5218157ee474b7/ty-0.0.1a27-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:88c03e4beeca79d85a5618921e44b3a6ea957e0453e08b1cdd418b51da645939", size = 10148794, upload-time = "2025-11-18T21:54:48.329Z" },
+    { url = "https://files.pythonhosted.org/packages/89/21/8b961b0ab00c28223f06b33222427a8e31aa04f39d1b236acc93021c626c/ty-0.0.1a27-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3ece5811322789fefe22fc088ed36c5879489cd39e913f9c1ff2a7678f089c61", size = 9900563, upload-time = "2025-11-18T21:54:51.214Z" },
+    { url = "https://files.pythonhosted.org/packages/85/eb/95e1f0b426c2ea8d443aa923fcab509059c467bbe64a15baaf573fea1203/ty-0.0.1a27-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2f2ccb4f0fddcd6e2017c268dfce2489e9a36cb82a5900afe6425835248b1086", size = 9926355, upload-time = "2025-11-18T21:54:53.927Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/78/40e7f072049e63c414f2845df780be3a494d92198c87c2ffa65e63aecf3f/ty-0.0.1a27-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33450528312e41d003e96a1647780b2783ab7569bbc29c04fc76f2d1908061e3", size = 9480580, upload-time = "2025-11-18T21:54:56.617Z" },
+    { url = "https://files.pythonhosted.org/packages/18/da/f4a2dfedab39096808ddf7475f35ceb750d9a9da840bee4afd47b871742f/ty-0.0.1a27-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a0a9ac635deaa2b15947701197ede40cdecd13f89f19351872d16f9ccd773fa1", size = 8957524, upload-time = "2025-11-18T21:54:59.085Z" },
+    { url = "https://files.pythonhosted.org/packages/21/ea/26fee9a20cf77a157316fd3ab9c6db8ad5a0b20b2d38a43f3452622587ac/ty-0.0.1a27-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:797fb2cd49b6b9b3ac9f2f0e401fb02d3aa155badc05a8591d048d38d28f1e0c", size = 9201098, upload-time = "2025-11-18T21:55:01.845Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/53/e14591d1275108c9ae28f97ac5d4b93adcc2c8a4b1b9a880dfa9d07c15f8/ty-0.0.1a27-py3-none-musllinux_1_2_i686.whl", hash = "sha256:7fe81679a0941f85e98187d444604e24b15bde0a85874957c945751756314d03", size = 9275470, upload-time = "2025-11-18T21:55:04.23Z" },
+    { url = "https://files.pythonhosted.org/packages/37/44/e2c9acecac70bf06fb41de285e7be2433c2c9828f71e3bf0e886fc85c4fd/ty-0.0.1a27-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:355f651d0cdb85535a82bd9f0583f77b28e3fd7bba7b7da33dcee5a576eff28b", size = 9592394, upload-time = "2025-11-18T21:55:06.542Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/a7/4636369731b24ed07c2b4c7805b8d990283d677180662c532d82e4ef1a36/ty-0.0.1a27-py3-none-win32.whl", hash = "sha256:61782e5f40e6df622093847b34c366634b75d53f839986f1bf4481672ad6cb55", size = 8783816, upload-time = "2025-11-18T21:55:09.648Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/1d/b76487725628d9e81d9047dc0033a5e167e0d10f27893d04de67fe1a9763/ty-0.0.1a27-py3-none-win_amd64.whl", hash = "sha256:c682b238085d3191acddcf66ef22641562946b1bba2a7f316012d5b2a2f4de11", size = 9616833, upload-time = "2025-11-18T21:55:12.457Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/db/c7cd5276c8f336a3cf87992b75ba9d486a7cf54e753fcd42495b3bc56fb7/ty-0.0.1a27-py3-none-win_arm64.whl", hash = "sha256:e146dfa32cbb0ac6afb0cb65659e87e4e313715e68d76fe5ae0a4b3d5b912ce8", size = 9137796, upload-time = "2025-11-18T21:55:15.897Z" },
+]
+
+[[package]]
+name = "typeguard"
+version = "4.4.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c7/68/71c1a15b5f65f40e91b65da23b8224dad41349894535a97f63a52e462196/typeguard-4.4.4.tar.gz", hash = "sha256:3a7fd2dffb705d4d0efaed4306a704c89b9dee850b688f060a8b1615a79e5f74", size = 75203, upload-time = "2025-06-18T09:56:07.624Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/a9/e3aee762739c1d7528da1c3e06d518503f8b6c439c35549b53735ba52ead/typeguard-4.4.4-py3-none-any.whl", hash = "sha256:b5f562281b6bfa1f5492470464730ef001646128b180769880468bd84b68b09e", size = 34874, upload-time = "2025-06-18T09:56:05.999Z" },
+]
+
 [[package]]
 name = "types-colorama"
 version = "0.4.15.20250801"
@@ -1280,11 +1328,11 @@ wheels = [
 
 [[package]]
 name = "types-docutils"
-version = "0.22.2.20251006"
+version = "0.22.3.20251115"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/30/79/3b5419ad9af32d99c1a953f2c96faa396280fddba22201d3788ff5b41b8a/types_docutils-0.22.2.20251006.tar.gz", hash = "sha256:c36c0459106eda39e908e9147bcff9dbd88535975cde399433c428a517b9e3b2", size = 56658, upload-time = "2025-10-06T02:55:19.477Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/eb/d7/576ec24bf61a280f571e1f22284793adc321610b9bcfba1bf468cf7b334f/types_docutils-0.22.3.20251115.tar.gz", hash = "sha256:0f79ea6a7bd4d12d56c9f824a0090ffae0ea4204203eb0006392906850913e16", size = 56828, upload-time = "2025-11-15T02:59:57.371Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/47/c1eed8aef21d010e8d726855c1a6346f526c40ce1f76ceabf5cd6775f6a1/types_docutils-0.22.2.20251006-py3-none-any.whl", hash = "sha256:1e61afdeb4fab4ae802034deea3e853ced5c9b5e1d156179000cb68c85daf384", size = 91880, upload-time = "2025-10-06T02:55:18.119Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/01/61ac9eb38f1f978b47443dc6fd2e0a3b0f647c2da741ddad30771f1b2b6f/types_docutils-0.22.3.20251115-py3-none-any.whl", hash = "sha256:c6e53715b65395d00a75a3a8a74e352c669bc63959e65a207dffaa22f4a2ad6e", size = 91951, upload-time = "2025-11-15T02:59:56.413Z" },
 ]
 
 [[package]]