tesserae-dl 0.1.0__tar.gz

tesserae_dl-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.py[cod]
+.venv/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+# graphify knowledge-graph output (built by `graphify update .`; local cache and paths)
+graphify-out/

tesserae_dl-0.1.0/CHANGELOG.md

@@ -0,0 +1,52 @@
+# Changelog
+
+All notable changes to the package. Versions follow [Semantic Versioning](https://semver.org); below
+1.0 a minor version may break the API. The language version is separate and is 0.1 for every release
+here (`docs/versioning.md`).
+
+## 0.1.0
+
+The first release: everything in the first-slice plan, steps 1 to 8.
+
+### The language
+
+- A file is a metadata block (`TDL:`, `Name:` and other keys) and exactly one root block. Blocks,
+  properties, `If`/`Else`/`For`, comments, and the values word, string, number, percentage, call,
+  list, `{{ slot }}` and template. The reference is `docs/language.md`; the 32 decisions behind it
+  are in `docs/decisions.md`.
+- 22 error codes with a plain message, a hint and a position (18 language codes and four for
+  what the library will not read: `tdl-too-large`, `tdl-too-deep`, `tdl-unsupported-version`,
+  `tdl-bad-encoding`).
+
+### The library
+
+- `loads`, `load`, `parse`, `dumps`, `dump`. `parse` never raises for a syntax error: it returns the
+  best tree it could build and every error found, in source order, up to 50.
+- A lossless tree: `Document`, `Metadata`, `Block`, `Property`, `If`, `For`, `Comment` and the value
+  classes, immutable and carrying where they came from. `dumps(loads(text)) == text`, byte for byte:
+  comments, blank lines, indentation, `\n` and `\r\n` per line, a byte-order mark and a missing
+  final newline are all kept.
+- Edits that change only the bytes they name: `Document.with_metadata`, `without_metadata`,
+  `replace` and `Block.with_property`, and `Document.find` for a dotted path of `Name:` values. An
+  edit that would break the file raises and returns nothing.
+- `Limits`: 1 MiB of text, 50 errors, 64 levels of nesting.
+- Python 3.14 or later, no dependencies, typed (`py.typed`).
+
+### The conformance corpus
+
+- `tests/corpus/`: 54 valid files with their normalised content, 57 files with errors and their
+  positions, 13 edits with their results. It ships in the source distribution.
+
+### Measured
+
+- A 100 KB file reads in 13 ms and a file at the 1 MiB limit in 140 ms; time grows linearly, and no
+  input built to be slow (`benchmarks/bench.py`) is super-linear. See `docs/benchmarks.md`.
+
+### Not in this release
+
+- Checking keys or types against a schema, and anything that knows what a block means: that is the
+  program that reads the file.
+- Building a tree in code and formatting it, `canonical()` on such a tree, `to_data()`, a command
+  line, a TextMate grammar and a language server (`docs/api.md`, open questions).
+- `Block.properties`, `Block.blocks`, `Block.get`, `Block.walk` and `Document.imports`, listed in
+  `docs/api.md` but in no step of the first slice.

tesserae_dl-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mind Derivative
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tesserae_dl-0.1.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.5
+Name: tesserae-dl
+Version: 0.1.0
+Summary: TDL, the Tesserae Data Language: a lossless parser for the files the Tesserae Shell reads.
+Project-URL: Repository, https://github.com/mindderivative/tess-dl
+Project-URL: Issues, https://github.com/mindderivative/tess-dl/issues
+Author: Mind Derivative
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# TDL
+
+TDL, the Tesserae Data Language, is a small structure-only language for the files the Tesserae
+Shell reads: blocks, properties and values. `tdl` is the Python library that reads it into a tree
+that keeps everything in the file (comments, layout, positions), reports every mistake with
+`file:line:column`, and writes the text back unchanged except for an edit you ask for.
+
+> **Status:** alpha, package 0.1.0 (not yet published), language version 0.1. The API may change
+> before 1.0 (a minor version may break it; see [`docs/versioning.md`](docs/versioning.md)).
+> The language is in [`docs/language.md`](docs/language.md), the API in [`docs/api.md`](docs/api.md),
+> the reasons for the choices in [`docs/decisions.md`](docs/decisions.md).
+
+`tdl` needs Python 3.14 or later and has no dependencies:
+
+```sh
+pip install tesserae-dl
+```
+
+```python
+import tdl
+
+text = """\
+---
+TDL: 0.1
+Name: Shell_Root
+---
+Shell {
+  Bar { Name: Top_Bar, Height: 32 }   # pixels
+}
+"""
+
+doc = tdl.loads(text, path="Main_Shell.tdl")  # raises TDLSyntaxError on the first mistake
+doc.root.type  # 'Shell'
+doc.find("Shell_Root.Top_Bar").name  # 'Top_Bar'
+assert tdl.dumps(doc) == text  # the exact text back, byte for byte
+
+broken = text.replace("Height: 32", "Height 32")
+result = tdl.parse(broken)  # never raises for a syntax error
+[str(e) for e in result.errors]  # every error, in source order, up to 50
+
+doc2 = doc.with_metadata("UID", "0192d3c4")  # one edit: every other byte is unchanged
+doc3 = doc.find("Shell_Root.Top_Bar").with_property("Height", "40")
+```
+
+- `loads`, `load` (a binary file object), `parse`, `dumps`, `dump`.
+- A tree of `Document`, `Metadata`, `Block`, `Property`, `If`, `For` and `Comment`, with `Word`,
+  `String`, `Number`, `Percent`, `Call`, `List`, `Slot` and `Template` for values. Nodes are
+  immutable, keep where they came from (`node.origin`), and are safe to share between threads.
+- Edits return a new `Document` and change only the bytes they name: `with_metadata`,
+  `without_metadata`, `Block.with_property`, `replace`. An edit that would break the file raises.
+- 22 error codes, each with a plain message, a hint and a position (`tdl-bare-hash`:
+  "This colour needs quotes. Quote the colour: "#ffffff""). The list is in
+  [`docs/language.md`](docs/language.md#errors).
+- Limits (`tdl.Limits`): 1 MiB of text, 50 errors, 64 levels of nesting.
+- Not in 0.1: checking keys or types (that is the program's, such as the shell), building a tree
+  in code and formatting it, `to_data()`, a command line. See [`docs/api.md`](docs/api.md).
+
+A 100 KB file reads in about 13 ms and a file at the 1 MiB limit in about 140 ms
+([`docs/benchmarks.md`](docs/benchmarks.md)).
+
+PyPI name: `tesserae-dl`. Import name: `tdl`.
+
+## The conformance corpus
+
+`tests/corpus/` holds the files and expected results that define the language: valid files with
+their normalised content, files with each error and its position, and edits with their result. It
+ships in the source distribution (not in the wheel) as test data, and the Tesserae Shell reads it.
+New cases come from a `TDL-REQ-###` through the maintainer; see
+[`.agents/skills/conformance-corpus/SKILL.md`](.agents/skills/conformance-corpus/SKILL.md).
+
+## Development
+
+```sh
+uv pip install -e . --group dev   # into the active venv (Python 3.14+)
+python tools/check.py             # ruff, format check, mypy (strict), pytest: what CI runs
+python benchmarks/bench.py        # timing against the budget (docs/benchmarks.md)
+```
+
+Work is tracked on the [Tesserae Data Language board](https://github.com/users/mindderivative/projects/5)
+(`python tools/board.py status`). Agent instructions are in [`AGENTS.md`](AGENTS.md); project skills
+are in `.agents/skills/`.
+
+## Versioning
+
+See [`docs/versioning.md`](docs/versioning.md).
+
+## Licence
+
+[MIT](LICENSE)

tesserae_dl-0.1.0/README.md

@@ -0,0 +1,89 @@
+# TDL
+
+TDL, the Tesserae Data Language, is a small structure-only language for the files the Tesserae
+Shell reads: blocks, properties and values. `tdl` is the Python library that reads it into a tree
+that keeps everything in the file (comments, layout, positions), reports every mistake with
+`file:line:column`, and writes the text back unchanged except for an edit you ask for.
+
+> **Status:** alpha, package 0.1.0 (not yet published), language version 0.1. The API may change
+> before 1.0 (a minor version may break it; see [`docs/versioning.md`](docs/versioning.md)).
+> The language is in [`docs/language.md`](docs/language.md), the API in [`docs/api.md`](docs/api.md),
+> the reasons for the choices in [`docs/decisions.md`](docs/decisions.md).
+
+`tdl` needs Python 3.14 or later and has no dependencies:
+
+```sh
+pip install tesserae-dl
+```
+
+```python
+import tdl
+
+text = """\
+---
+TDL: 0.1
+Name: Shell_Root
+---
+Shell {
+  Bar { Name: Top_Bar, Height: 32 }   # pixels
+}
+"""
+
+doc = tdl.loads(text, path="Main_Shell.tdl")  # raises TDLSyntaxError on the first mistake
+doc.root.type  # 'Shell'
+doc.find("Shell_Root.Top_Bar").name  # 'Top_Bar'
+assert tdl.dumps(doc) == text  # the exact text back, byte for byte
+
+broken = text.replace("Height: 32", "Height 32")
+result = tdl.parse(broken)  # never raises for a syntax error
+[str(e) for e in result.errors]  # every error, in source order, up to 50
+
+doc2 = doc.with_metadata("UID", "0192d3c4")  # one edit: every other byte is unchanged
+doc3 = doc.find("Shell_Root.Top_Bar").with_property("Height", "40")
+```
+
+- `loads`, `load` (a binary file object), `parse`, `dumps`, `dump`.
+- A tree of `Document`, `Metadata`, `Block`, `Property`, `If`, `For` and `Comment`, with `Word`,
+  `String`, `Number`, `Percent`, `Call`, `List`, `Slot` and `Template` for values. Nodes are
+  immutable, keep where they came from (`node.origin`), and are safe to share between threads.
+- Edits return a new `Document` and change only the bytes they name: `with_metadata`,
+  `without_metadata`, `Block.with_property`, `replace`. An edit that would break the file raises.
+- 22 error codes, each with a plain message, a hint and a position (`tdl-bare-hash`:
+  "This colour needs quotes. Quote the colour: "#ffffff""). The list is in
+  [`docs/language.md`](docs/language.md#errors).
+- Limits (`tdl.Limits`): 1 MiB of text, 50 errors, 64 levels of nesting.
+- Not in 0.1: checking keys or types (that is the program's, such as the shell), building a tree
+  in code and formatting it, `to_data()`, a command line. See [`docs/api.md`](docs/api.md).
+
+A 100 KB file reads in about 13 ms and a file at the 1 MiB limit in about 140 ms
+([`docs/benchmarks.md`](docs/benchmarks.md)).
+
+PyPI name: `tesserae-dl`. Import name: `tdl`.
+
+## The conformance corpus
+
+`tests/corpus/` holds the files and expected results that define the language: valid files with
+their normalised content, files with each error and its position, and edits with their result. It
+ships in the source distribution (not in the wheel) as test data, and the Tesserae Shell reads it.
+New cases come from a `TDL-REQ-###` through the maintainer; see
+[`.agents/skills/conformance-corpus/SKILL.md`](.agents/skills/conformance-corpus/SKILL.md).
+
+## Development
+
+```sh
+uv pip install -e . --group dev   # into the active venv (Python 3.14+)
+python tools/check.py             # ruff, format check, mypy (strict), pytest: what CI runs
+python benchmarks/bench.py        # timing against the budget (docs/benchmarks.md)
+```
+
+Work is tracked on the [Tesserae Data Language board](https://github.com/users/mindderivative/projects/5)
+(`python tools/board.py status`). Agent instructions are in [`AGENTS.md`](AGENTS.md); project skills
+are in `.agents/skills/`.
+
+## Versioning
+
+See [`docs/versioning.md`](docs/versioning.md).
+
+## Licence
+
+[MIT](LICENSE)

tesserae_dl-0.1.0/docs/api.md

@@ -0,0 +1,206 @@
+# TDL Library API
+
+> Moved here from the Tesserae Shell design vault on 2026-11-02. This file is now the source of truth; the vault keeps a short pointer. Names of vault notes and decisions (D1 to D94, the ADR-0014 file layout and so on) refer to that vault and are not links.
+
+> [!NOTE]
+> The public Python API of the TDL library: repository and folder `tess-dl`, PyPI package `tesserae-dl`, import name `tdl` (ADR-0014 Shell File Language > Open Items, maintainer, 2026-11-02). The library reads TDL text into a tree that keeps everything in the file (comments, layout, positions), reports errors with `file:line:column`, and writes the text back unchanged except for a requested edit. It knows nothing about bars, monitors, tre, or the shell's keys. This note is a proposal for the maintainer, written so the `tess-dl` session can start from it. Names follow the Python standard library where a library does the same job (`json`, `tomllib`), because the maintainer asked that a person from another framework finds a familiar shape (ADR-0014 Shell File Language > Ninth-Round Decisions (2026-11-02) D68).
+
+## Purpose and Scope
+
+- Define the functions, classes, errors and guarantees that the shell, an editor tool and a test can rely on.
+- Out of scope, by design: checking keys and types against a schema, typing a value (a length, a colour, a boolean), reading other files for `Import`, evaluating `{{ }}` slots (TEL does that), and talking to tre. All of those belong to the shell (Data Flow > Loading a Shell).
+- The library takes text, not paths: file reading, `Import` and the config directory are the shell's (AGENTS > 3. Layering Principle, "Data in, not files").
+
+## Where the Library Sits
+
+```mermaid
+flowchart LR
+    T[".tdl text"] --> P["tdl: parse"]
+    P --> D["Document tree\n(lossless, with positions)"]
+    D --> S["Shell: schema check,\ntyping, Import, UIDs"]
+    S --> E["TEL: compile each slot"]
+    E --> M["Shell model"]
+    M --> R["tre nodes and windows"]
+    D -. "edit (UID)" .-> W["tdl: dumps"]
+    W --> F[".tdl text, unchanged\nexcept the edit"]
+```
+
+The tree is not something tre can render. It describes the file. The shell turns it into its own model and only then into tre nodes (Layers and Components).
+
+## Behaviour
+
+### The Entry Points
+
+| Function | Does | Familiar from |
+|---|---|---|
+| `tdl.loads(text, *, path=None, limits=None)` | Parses a string. Returns a `Document`. Raises `TDLError` on the first syntax error | `json.loads`, `tomllib.loads` |
+| `tdl.load(fp, *, path=None, limits=None)` | Same, from a binary file object the caller opened (UTF-8; a byte-order mark is accepted). The library never opens a path itself | `tomllib.load` |
+| `tdl.parse(text, *, path=None, limits=None)` | Parses and never raises for a syntax error. Returns a `ParseResult(document, errors)`: the best tree it could build (`None` when the metadata or root block cannot be read, a limit stops the file or the cap is reached) and every error found, in source order, up to `Limits.max_errors`. For editors and for the shell's "collect every error, then stop" rule | `ast.parse` (but tolerant) |
+| `tdl.dumps(document)` | Returns the text of a document. For a document from `loads`, the result is exactly the input, byte for byte | `json.dumps` |
+| `tdl.dump(document, fp)` | Writes that text to a binary file object | `json.dump` |
+
+`path` is a label for error messages (`Top_Bar_Module.tdl`). It is never opened.
+
+### Errors
+
+One base class, `TDLError`, with a subclass `TDLSyntaxError`. Every error has:
+
+| Field | Meaning |
+|---|---|
+| `code` | A stable slug such as `tdl-unclosed-block` ([TDL Language > Errors](language.md), D52) |
+| `message` | One sentence saying what is wrong, in plain words |
+| `hint` | What to write instead |
+| `origin` | An `Origin`: `file`, `line`, `column` (both 1-based), and `end_line`, `end_column`, `offset` |
+| `related` | Other `Origin`s the error mentions; a duplicate key names both places |
+
+`str(error)` is `file:line:column: message (hint)`. The message follows the wording rules in [Wording and Familiar Names](#wording-and-familiar-names). The error list is the one in [TDL Language > Errors](language.md): the 17 accepted in D52, `tdl-unexpected-text` (G13) and four limit and input codes (`tdl-too-large`, `tdl-too-deep`, `tdl-unsupported-version`, `tdl-bad-encoding`, G18), all accepted by the maintainer on 2026-11-02, 22 in all.
+
+> [!NOTE]
+> **The suffix check is the shell's (maintainer, 2026-11-02, D91)**
+> The library does not look at file names. Comparing the root block with the suffix (`_Shell.tdl`, `_Module.tdl`) is done by the shell, or by Tesserae UI for its own types, and the shell's error is `shell-root-suffix`. The library keeps 18 language errors and four limit and input codes (22 in all).
+
+### Limits
+
+`tdl.Limits(max_bytes=1_048_576, max_errors=50, max_depth=64)`. All three are decided: 1 MiB and 50 errors (Validation and Errors > Parsing) and depth 64, counting the root block as 1 (G11). A file over a limit stops with `tdl-too-large` or, for depth, `tdl-too-deep`. TEL uses a `Limits` class the same way.
+
+### The Tree
+
+All classes are importable from `tdl`. Nodes are immutable: they can be shared between threads, and an edit makes a new document.
+
+| Class | Fields | Notes |
+|---|---|---|
+| `Document` | `metadata`, `root`, `path`, `text`, `language_version` | `text` is the source |
+| `Metadata` | mapping from key to `Value`; `origin` | Keeps unknown keys. Reading is by key: `doc.metadata["Name"]` |
+| `Block` | `type`, `entries`, `origin`, `name` | `type` is the word before the brace. `name` is the value of `Name:` or `None` |
+| `Property` | `key`, `value`, `key_origin`, `value_origin` | `Key: value` |
+| `If` | `condition: Slot`, `body`, `else_body` (or `None`), `origin` | `If {{ c }} { } Else { }` |
+| `For` | `variable: str`, `items: Slot`, `key: Slot`, `body`, `name`, `origin` | `For x In {{ xs }} Key {{ x.id }} { }` |
+| `Comment` | `text`, `origin` | A `#` comment, kept where it stands |
+
+`Block.entries` holds `Property`, `Block`, `If`, `For` and `Comment` in source order. Helpers: `Block.properties` (a mapping by key; a repeated key is an error, D9), `Block.blocks` (child blocks only), `Block.get(key, default=None)`, `Block.walk()` (every descendant), and `Document.find("Shell_Root.Main.Top_Bar")` (a dotted path of `Name:` values, D28).
+
+`Children` is an ordinary block named `Children`; `Import: file` is an ordinary property. `Document.imports()` lists the names so the shell does not search for them, and the library does not open them.
+
+### Values
+
+The library gives each value a lexical kind and the text it came from. It does not decide what the text means; that is the schema's job in the shell (a proposal, [Open Questions](#open-questions) 1).
+
+| Class | Written as | Fields |
+|---|---|---|
+| `Word` | `TOP`, `true`, `Top_Bar`, `Battery` (unquoted) | `text`. Booleans, `null` and enums are words until the schema types them (D2, D33) |
+| `String` | `"..."` or `'...'` | `value` (escapes resolved), `text` (as written) |
+| `Number` | `16`, `-4`, `0.9` | `value` (`int` or `float`), `text` |
+| `Percent` | `50%` | `value` (`int`), `text` |
+| `Call` | `rgba(0 0 0 0.5)` | `name`, `args` (values separated by spaces) |
+| `List` | `[a, b, c]` | `items` |
+| `Slot` | `{{ expression }}` | `text` (what is between the braces), `text_origin` (where that text starts, for TEL), `origin` |
+| `Template` | `Battery {{ battery.percent }}%` | `parts`: strings and `Slot`s, in order |
+
+A value that is exactly one slot is a `Slot`; text with a slot inside is a `Template`, matching the rule in [TDL Language > Values](language.md).
+
+`Slot.text_origin` is built to be handed to TEL. The library does not import TEL. The shell converts: `tel.Origin(file=o.file, line=o.line, column=o.column)`.
+
+### Editing
+
+A document never changes in place. An edit returns a new `Document` whose text equals the old text with one change.
+
+| Call | Does |
+|---|---|
+| `document.with_metadata(key, value)` | Sets a metadata key. A new `UID` goes directly after the last version line (`TDL` or `Shell`, D10, G24); any other new key goes just before the closing `---`; an existing key changes only its value. `value` is plain text: a bare word when it reads back the same, else a quoted string (G32) |
+| `document.without_metadata(key)` | Removes the whole line of a metadata key; unchanged if the key is absent |
+| `block.with_property(key, value)` | Sets a property and returns the new `Document`. `value` is the TDL text of one value on one line. An existing property changes only its value; a new one goes on a line after the last property with that property's indentation and line ending, or inline in a block written on one line (G24, G32) |
+| `document.replace(start, end, text)` | Replaces `document.text[start:end]` (character offsets) and reparses; the escape hatch |
+| `document.find(path)` | The block at a dotted path of `Name:` values; the first name is the file's own `Name` and stands for the root block. Raises `KeyError` if there is none (D28, G32) |
+
+Every edit keeps comments, blank lines, indentation and the order of everything it did not touch (this is what the UID write needs; R-06 in Risk Register). An edit that would make the file invalid raises `TDLError` and returns nothing. A call that is wrong whatever the file holds (a key that is not a name, a reserved word as a property key, a value that is not one value, a span outside the text, a block built in code) raises `ValueError`. Edits reread the result with the default `Limits`.
+
+### Plain Data View
+
+`document.to_data()` and `block.to_data()` return plain dicts, lists and strings, with no comments or positions, for tools and tests that only need the content. The shape is the library's first-slice decision. The tree is the main API; this is a convenience.
+
+### Building a Tree in Code
+
+The Python builder (Python Builder) must produce the same tree as the parser, so the nodes can be constructed directly: `Block("Bar", [Property("Edge", Word("TOP"))])`. A constructed node has no position. `tdl.dumps` formats a constructed tree with the library's standard layout (two-space indent). `node.canonical()` returns a normalised plain structure with trivia and positions dropped, so a parity test compares two trees by `==`. Names follow TEL's `canonical` (Expression Language Requirements > TEL 0.1.0 Released (2026-11-02)). Whether the formatter is in v0.1 is open.
+
+### Wording and Familiar Names
+
+The maintainer's rule (2026-11-02): the names and the prose are for people from the UI design world, who expect a thing to behave as it does in another framework. In this library that means:
+
+- Function names come from `json` and `tomllib` (`loads`, `load`, `dumps`, `dump`), and node names from the file's own words (`Block`, `Property`, `Comment`), not from compiler jargon (`Token`, `Production`, `Lexeme` stay private).
+- An error message says what happened in one plain sentence and the hint says what to write. It names the thing the author wrote, not the parser state: "This colour needs quotes. Write "#ffffff"." and not "unexpected token HASH".
+- The language reference in `tess-dl` explains each construct with a short example before any rule, and says where TDL behaves differently from CSS, QML or Flutter (Familiar Names Audit when written).
+
+## Configuration
+
+None. The only inputs are the arguments above and the `Limits`.
+
+## Python Contract
+
+| Item | Value |
+|---|---|
+| Import | `import tdl`; every public name is in `tdl.__all__` |
+| Version | `tdl.__version__` (package) and `tdl.LANGUAGE_VERSION` (`"0.1"`); a file with a newer major version raises `tdl-unsupported-version` |
+| Python | 3.14 or later; no runtime dependencies (maintainer, 2026-11-02) |
+| Typing | Fully typed; ships `py.typed` |
+| Threads | Pure functions on immutable data: safe to call from any thread; the shell may parse on the watcher thread and hand the `Document` to the loop with `call_soon` (Process Model and Threading) |
+| Stability | Before 1.0, a minor version may change the API; every change is listed in the changelog and in a `TDL-REQ-###` when the shell asks for it (AGENTS > 6. Requests Between Projects) |
+| Private | Anything not in `__all__`, and the whole lexer |
+
+## Integration
+
+- The shell calls `tdl.parse` for every file at load, collects the errors, then walks the tree with its schema (Validation and Errors).
+- The shell calls `document.with_metadata("UID", uuid)` and writes the result with its own file code when it registers a file (Config Discovery and Registry).
+- TEL receives `slot.text` and an origin built from `slot.text_origin`; the shell adds nothing to the position because a slot sits on one line (Validation and Errors).
+- A TextMate grammar and any later editor tool use `tdl.parse` and the codes.
+
+## Design
+
+None. This is a library without a user interface. The language it reads is designed in [TDL Language](language.md) and, after the move, in the `tess-dl` repository.
+
+## Accessibility
+
+Error messages are plain sentences that a screen reader reads whole: no colour or symbol carries meaning, and the position is in text (`file:line:column`).
+
+## Performance Budget
+
+- Parsing is one pass over the text. Budget: a 100 KB file in under 20 ms and a file at the 1 MiB limit in under 250 ms. Measured on 2026-11-03 (Python 3.14.8, AMD Ryzen AI 9 HX 370): 13.1 ms and 140.3 ms, growing linearly; no adversarial input is super-linear. The tree the reader keeps is about 19 times the size of the text. The figures, the method and the command are in [benchmarks.md](benchmarks.md); Performance Budgets in the vault holds the ledger.
+- `loads` of the same text twice gives equal documents; a cache is the shell's business (a warm cache keys on the file's hash, as the schema cache does).
+- The library allocates no thread and no timer.
+
+## Failure Modes and Recovery
+
+| Failure | Result |
+|---|---|
+| Invalid UTF-8 in `load` | `TDLSyntaxError` `tdl-bad-encoding`, with the byte offset |
+| Syntax error | `loads` raises at the first one it meets; `parse` records it and carries on (G31, [TDL Language > Errors](language.md)): a bad entry is skipped to the end of its line or the `}` that closes its block |
+| More than 50 errors | The list stops at the limit, the last entry says `The list stops at 50 errors.`, and nothing more is read |
+| An edit would break the file | `TDLError`; the original document is untouched |
+| A newer language version | `tdl-unsupported-version`, with the library's version in the message |
+
+## Open Questions
+
+1. [x] **Values stay lexical** (maintainer, 2026-11-02, "yes", D74). The reasoning was: the library returns `Word`, `String`, `Number`, `Percent`, `Call`, `List`, `Slot` and `Template`, and the schema in the shell types them. The alternative is for the library to know lengths and colours, which makes it carry shell meaning.
+2. [x] The suffix check is the shell's, as `shell-root-suffix` (maintainer, 2026-11-02, D91).
+3. [ ] Whether the formatter and `canonical()` are in the first release or follow when the Python builder starts.
+4. [ ] The shape of `to_data()`.
+5. [x] The extra codes `tdl-unsupported-version`, `tdl-too-large`, `tdl-too-deep` and `tdl-bad-encoding` are accepted (maintainer, 2026-11-02, G18), with `tdl-unexpected-text` (G13).
+6. [ ] A `tdl` command (`tdl check file.tdl`, `tdl format`) for authors and editors: recommended after the first release, not in it.
+7. [ ] Build tooling and CI for `tess-dl` (the TEL project's choices are the starting point).
+
+## Acceptance Criteria
+
+- [x] `tdl.dumps(tdl.loads(text)) == text` for every file in the conformance corpus (comments, blank lines, indentation, a final newline or none). *Tests:* `test_corpus.py::test_ok_case_round_trips_byte_for_byte` (54 files), `test_roundtrip.py` (generated files).
+- [x] The 22 error codes each have a corpus file that raises it with the stated `line` and `column`. *Tests:* `test_corpus_files.py::test_every_code_has_a_case`, `test_corpus.py::test_error_case_loads_raises_the_first_listed_error` and `..._load_raises_the_same_first_error`; `tdl-too-large` and `tdl-too-deep` are built in `test_limits.py`.
+- [x] `Width 32` raises `tdl-unexpected-text`, pointing at the first character that does not fit. *Tests:* corpus case `errors/unexpected-text-no-colon`; `test_acceptance.py`.
+- [x] `tdl.parse` on a file with six deliberate mistakes returns six errors with the right positions (JSON Schema and Editor Support). *Test:* corpus case `errors/six-mistakes` through `test_error_case_parse_lists_every_listed_error`.
+- [x] `with_metadata("UID", x)` puts `UID` directly after the last version field and changes no other byte. *Tests:* corpus cases `edits/uid-after-last-version`, `uid-after-tdl-only`; `test_edits.py` (one changed span, generated files).
+- [x] `Color: #fff` raises `tdl-bare-hash`; `Color: "#fff"   # note` is a `String` and a `Comment`. *Tests:* `test_acceptance.py`; corpus cases `errors/bare-hash`, `strings/hash-and-comment`.
+- [x] `Text: {{ max(a, b) }}` is one `Slot` with text ` max(a, b) `; `{{ '}}' }}` ends at the second `}}`; `{{ {'a': {'b': 1}} }}` ends at the first `}}` and leaves the rest to TEL. *Tests:* `test_acceptance.py`; corpus cases `slots/one-slot`, `slots/quoted-close`, `errors/slot-ends-at-first-close`.
+- [x] `}}` where two blocks close raises `tdl-double-close` and the hint says `} }`. *Tests:* `test_acceptance.py`; corpus case `errors/double-close`.
+- [x] A file at 1 MiB parses within the budget; one byte over raises `tdl-too-large`. *Tests:* `test_limits.py` (exact size, one byte more, growth ratio); the measured time is in [benchmarks.md](benchmarks.md).
+- [x] Importing `tdl` imports no other third-party package, and `tdl.__all__` lists every public name. *Tests:* `test_acceptance.py` (a clean interpreter with `-I`, and the list of public names).
+- [ ] A tree built in code and the same file parsed give equal `canonical()` results. *Not in 0.1:* building a tree in code, the formatter and `canonical()` on such a tree wait for open question 3 (G26); `canonical()` on a parsed document is in 0.1.
+
+## Links
+
+- 42 Python API · ADR-0014 Shell File Language · [TDL Language](language.md) · Python Builder · Validation and Errors · Data Flow · Risk Register

tesserae_dl-0.1.0/docs/benchmarks.md

@@ -0,0 +1,55 @@
+# Benchmarks
+
+Measured against the budget in [api.md](api.md#performance-budget): a 100 KB file in under 20 ms and a file at the 1 MiB limit in under 250 ms. The script is `benchmarks/bench.py` (standard library only, not shipped).
+
+## Run of 2026-11-03
+
+| | |
+|---|---|
+| Python | 3.14.8 |
+| Machine | AMD Ryzen AI 9 HX 370 (24 threads), Linux 7.3 (CachyOS), idle |
+| Code | commit `5f3da64` (step 7), `benchmarks/bench.py` as added in step 8 |
+| Command | `~/Projects/pyDev/pyEnvs/tess-dl/bin/python benchmarks/bench.py --runs 15` |
+| Method | best of 15 timed runs after one warm-up, garbage collector off while timing; memory by `tracemalloc` after `loads` returns |
+
+### Budget
+
+| Input | Size | `loads` | Budget | |
+|---|---|---|---|---|
+| Realistic file (monitors, bars, slots, `If`/`For`, comments) | 99,749 B | 13.11 ms | 20 ms | within |
+| The same mix at the limit | 1,048,522 B | 140.30 ms | 250 ms | within |
+
+Other calls on the same two files: `parse` 12.93 ms and 139.93 ms (the same as `loads` when there are no errors); `with_metadata` 13.09 ms and 140.78 ms (an edit rereads the whole file, so it costs one `loads`); `dumps` under 0.01 ms (it returns the stored text). The tree the reader keeps is about 19 times the size of the text (1,859 KiB for 100 KB, 19,429 KiB for 1 MiB).
+
+### Scaling
+
+| Input | 1x (99,749 B) | 2x | 4x |
+|---|---|---|---|
+| Realistic file, `loads` | 13.20 ms | 26.48 ms (x2.01) | 53.97 ms (x4.09) |
+
+Growth is linear.
+
+### Adversarial inputs
+
+About 1 MB each; `parse` time at 250 KB, 500 KB and 1 MB, and the ratio per doubling (linear is x2).
+
+| Input | 250 KB | 500 KB | 1 MB | Per doubling |
+|---|---|---|---|---|
+| Many `{{ a }}` on one line | 35.68 ms | 72.68 ms | 145.42 ms | x2.04, x2.00 |
+| One very long word | 3.03 ms | 5.83 ms | 11.46 ms | x1.92, x1.96 |
+| One long string | 0.25 ms | 0.45 ms | 0.86 ms | x1.77, x1.94 |
+| A list of 330,000 numbers | 139.28 ms | 278.67 ms | 558.31 ms | x2.00, x2.00 |
+| A long run of `}` | 0.13 ms | 0.14 ms | 0.14 ms | the cap stops it after 50 errors |
+| Many small blocks | 52.11 ms | 105.89 ms | 214.13 ms | x2.03, x2.02 |
+| Many comments | 50.10 ms | 100.67 ms | 203.12 ms | x2.01, x2.02 |
+| Many mistakes, one per line (cap) | 3.13 ms | 6.14 ms | 12.46 ms | x1.96, x2.03 (the line index is built over the whole text) |
+| Mistakes on one line | 0.24 ms | 0.45 ms | 0.84 ms | x1.85, x1.88 (one error: the rest of a bad line is skipped) |
+| 64 levels of blocks | 0.11 ms | 0.11 ms | 0.11 ms | a size cannot grow it |
+
+No input is super-linear. The slowest, a list of 330,000 numbers at 558 ms, is over the 250 ms figure but that figure is for a realistic file; it grows linearly and the file is at the size limit.
+
+## What was not done
+
+No tuning: every budget is met, so nothing was changed for speed (`perf-baseline`: no tuning before a number misses). The vault's "Performance Budgets" ledger is the maintainer's; the figures above are for a `TDL-REQ` to update it.
+
+`tests/test_limits.py` pins the guards with generous ceilings (a 1 MiB file reads in under 3 s, about 20 times the measured time) so a quadratic step would fail the suite without making it flaky.

tesserae_dl-0.1.0/docs/decisions.md

@@ -0,0 +1,50 @@
+# Design decisions
+
+Decisions made for the language and the library, newest last. The reason is kept with each one. Syntax, grammar and boundary changes are recorded here, in this repo, not left in the vault.
+
+`G` rows answer the 12 grammar ambiguities of the First Slice note (vault: `41 TDL Reference/tess-dl First Slice.md`). The note leaves them to the `tess-dl` session: each takes the note's recommendation unless the Notes column says otherwise. The maintainer answered the open questions on 2026-11-02; they are G13 to G18.
+
+## 2026-11-02 (grammar, plan step 1)
+
+| # | Decision | Notes |
+|---|---|---|
+| G1 | **An unquoted value is one kind, `Word`**, whose text is the whole run (spaces inside kept, outer whitespace dropped). A word whose text is a number is a `Number`. | The rule "an unquoted value runs to the end of the line, the next `,`, a closing brace or a comment" implies one run. `Hello world` is one word; `1st` is a word; `16` is a number. |
+| G2 | **In the metadata block every bare value is a `Word`**, never a number. `0.1` is the text `0.1`. | Versions are strings (ADR-0014 layout rule 3): `0.10` and `0.1` must not be the same value. |
+| G3 | **Numbers are `16`, `-4`, `0.9`**: an optional `-`, digits, optionally `.` and digits. No exponent, hex, digit separators, leading `+`, `.5` or `5.`. A word that only starts with digits (`16px`) is a word. | Smallest set the shell's lengths and opacities need. More can be added later without breaking a file. |
+| G4 | **`Call` starts at any word written directly against `(`**; the arguments are values separated by spaces, to the `)`, on one line. | The shell, not the parser, knows which call names exist, so it can say "unknown colour function". |
+| G5 | **String escapes:** `\\`, `\"`, `\'`, `\n`, `\t`, `\u` plus four hex digits. Anything else is `tdl-bad-escape`. | As recommended. |
+| G6 | **Line endings, tabs, BOM:** `\n` and `\r\n` are both accepted and each line keeps its own; a tab is whitespace; a leading BOM is accepted and kept; a lone `\r` is plain whitespace; a `---` line may have trailing spaces or tabs. | A lossless tree must keep all of them. The lone `\r` and trailing-space details go beyond the recommendation; they are the least surprising reading. |
+| G7 | **A slot is on one line.** A line end before `}}` is `tdl-unclosed-slot`. | D54 of the vault's ADR-0014. |
+| G8 | **A list may span lines;** items are separated by `,` or a newline, with an optional trailing `,`. | As recommended; matches how entries are separated in a block. |
+| G9 | **`Children` is an ordinary block** and `Import` an ordinary property. Only `If`, `Else`, `For`, `In` and `Key` are reserved. | The parser stays free of the shell's meaning. |
+| G10 | **Key characters:** a letter, then letters, digits and `_`. The same rule serves block heads, `For` variables and `Name:` values. | D4 forbids numeric keys. One rule for every name keeps `tdl-bad-name` simple. |
+| G11 | **Maximum nesting depth is 64**, counting the root block as 1; blocks, `If`/`For` bodies and lists each add a level. | Proposed by the note. A stack-safe parser must reach it without a `RecursionError`. |
+| G12 | **Trivia is kept in source spans, not modelled.** Comments are entries in their block in source order; blank lines and indentation live in the spans between nodes. | Keeps the tree small and makes the exact round trip a property of the spans (`lossless-roundtrip`). |
+| G13 | **One more language code: `tdl-unexpected-text`**, for text that is not valid where it stands: a missing colon (`Width 32`), a key with no value, an `Else` with no `If`, a `For` without `In` or `Key`, an unclosed `(` in a call, a stray `{` in an unquoted value. The message and hint say which case. | Answers Q1 (maintainer, 2026-11-02). It makes 18 language errors; the vault's "17" and its `TDL Language` error table need the new row. |
+| G14 | **In value position, a `#` followed directly by a non-space character is `tdl-bare-hash`;** a `#` followed by whitespace or the end of the line is a comment. | Answers Q2 (maintainer). `Color: #fff` is an error; `Color: # note` is an empty value (G16) and a comment. |
+| G15 | **`{{ }}` inside a quoted string is plain text.** A quoted string never holds a slot; a template is written unquoted. | Answers Q3 (maintainer). Quotes switch slots off. |
+| G16 | **A property with no value is an error** (`tdl-unexpected-text`). | Answers Q4 (maintainer). |
+| G17 | **`Else` follows the `If` body's closing brace,** on the same line or after newlines and comments. | Answers Q5 (maintainer). |
+| G18 | **The four extra codes are accepted:** `tdl-too-large` (over 1 MiB, checked before parsing), `tdl-too-deep` (over 64 levels), `tdl-unsupported-version` (the `TDL:` version is newer than the library's), `tdl-bad-encoding` (invalid UTF-8 in `load`, with the byte offset). | Answers Q6 (maintainer). Together with G13 the library has 22 codes. |
+
+## 2026-11-02 (corpus, plan step 2)
+
+| # | Decision | Notes |
+|---|---|---|
+| G19 | **`}}` rule.** An adjacent `}}` outside a slot and outside a string is always `tdl-double-close`, pointing at the first `}` of the pair, whatever the number of open blocks. | Keeps the rule lexical. `{{ {'a': {'b': 1}} }}` ends the slot at the first `}}` and the trailing `}}` is then `tdl-double-close`. |
+| G20 | **Positions of the two vague "points at" rows.** `tdl-no-root` points at the first character after the closing `---` line, including its line ending (5:1 when `---` is line 4 and ends with `\n`; 4:4 if the file ends right after the `---`). `tdl-unexpected-text`: a missing value, at the first non-whitespace character after the `:` (the `#` of a comment, or the line end); a key with no `:`, at the first character after the key and its whitespace; an unclosed `(`, at the line end; `For` without `Key`, at the `{` that opens the body; `For` without `In`, at the first `{{` after the variable; `Else` without `If`, at the `Else`; a stray `{` in an unquoted value, at that `{`. | The note leaves both open; each position is the first character that does not fit. |
+| G21 | **`tdl-bad-encoding` position.** Line and column are computed from the valid UTF-8 prefix before the first bad byte (line = 1 + newlines in the prefix; column = 1 + characters since the last newline). | The bad byte itself cannot be counted in characters. |
+| G22 | **`canonical()` shape** (what `expect.json` `"canonical"` holds): `{"metadata": {KEY: VALUE, ...}, "root": BLOCK}`, comments dropped. Value: `{"word": text}`, `{"string": resolved_value}`, `{"number": 16}` (JSON int) or `{"number": 0.9}` (JSON float), `{"percent": 50}`, `{"call": name, "args": [value, ...]}`, `{"list": [value, ...]}`, `{"slot": text}` (exactly as between the braces), `{"template": [{"text": "Battery "}, {"slot": " battery.percent "}, {"text": "%"}]}`. Entry: `{"block": type, "entries": [entry, ...]}`, `{"property": key, "value": value}`, `{"if": slot_value, "body": [entry...], "else": [entry...] or null}`, `{"for": variable, "in": slot_value, "key": slot_value, "body": [entry...]}`. A metadata value is a `word` or a `string`. The runner compares `json.dumps(x, sort_keys=True)` of both sides, so `16` and `16.0` differ. | One shape for the runner and the shell to read; no positions and no comments. |
+| G23 | **Edit cases** are three files: `<case>.tdl`, `<case>.expect.json` holding `{"edit": {"call": ..., ...}}`, and `<case>.result.tdl`. Calls: `with_metadata` (`key`, `value`), `without_metadata` (`key`), `with_property` (`block`: dotted path of `Name:` values as `Document.find` takes, `key`, `value`: the TDL text of the value), `replace` (`start`, `end`: character offsets, `text`). Every call returns a `Document`; `with_property` is run as `doc.find(block).with_property(key, value)` and the returned `Document` is the result. A refused edit is `{"edit": {...}, "raises": "tdl-no-name"}` with no `.result.tdl`. | The vault says an edit returns a new Document. `replace` offsets and the `with_property` return type are the choices the maintainer may want to change. |
+| G24 | **Metadata insert rules for edits.** `with_metadata("UID", v)` with no `UID` inserts `UID: v` on a new line directly after the last metadata line whose key is `TDL` or a version key (`Shell`). With a `UID` present only the value bytes change. Any other new key goes on a new line directly before the closing `---`. A new line has no indentation and takes the line ending of the line before it. `with_property` adds `Key: value` on a new line after the last property of the block, with that property's indentation and the file's line ending there. | Keeps an edit to the bytes it must change (`lossless-roundtrip`). |
+| G25 | **Cap entry.** With `Limits(max_errors=50)`, a file with 60 mistakes gives `len(result.errors) == 50` and the message of the last entry contains the text `50`. | The vault says only "the last entry says so". |
+| G26 | **Step 3 follows the brief's row boundary.** Step 3 is the tree, the parser and `canonical()` on a parsed document; it is done when `loads` plus `canonical()` match for every `ok` case (`test_ok_case_reads_to_the_canonical_tree`). `dumps`, `load` and the byte-for-byte round trip are step 5 (`test_ok_case_round_trips_byte_for_byte`). `canonical()` on a document read from text is in the first release because the corpus needs it; the formatter and `canonical()` on a tree built in code stay out until API Open Question 3 is answered. | The brief lists `canonical()` under "Not in the First Slice", meaning the Python-builder use. The corpus is read by the shell and needs it on parsed trees. |
+| G27 | **Calls count as nesting levels,** like blocks, bodies and lists: `f(f(f(...)))` deeper than 64 is `tdl-too-deep` at the `f` that passes the limit. | A call can nest inside a call, so without a level count a long run of `f(` would overflow Python's stack. G11 listed only blocks, bodies and lists. |
+| G28 | **Step 4 follows the brief's row boundary.** `loads` is the step 4 check: it raises the first listed error with its code, position, related origins, message and hint (`test_error_case_loads_raises_the_first_listed_error`, all text cases). `tdl-bad-encoding` needs bytes, so its error is built by a private decoder in step 4 and `load` is wired to it in step 5 (`test_error_case_load_raises_the_same_first_error`). The full list through `parse` is step 7 (`test_error_case_parse_lists_every_listed_error`). | The brief says step 4 is done when the error cases pass, but `load` is step 5 and `parse` step 7; one test per step keeps each step checkable on its own. |
+| G29 | **Every `tdl-unexpected-text` kind is documented and has a corpus case.** The reader had 24 places that raise it; the list in `language.md` now names all the kinds and where each points (G20 extended), and `tests/corpus/errors/` has a case for each. Also: a `#` or `,` inside a call is an error (a `#` followed by a non-space is `tdl-bare-hash`); an unclosed `[` points at the `}` or end of file that reaches it; a `TDL:` value that does not start with a number is `tdl-unsupported-version`. | Step 4's audit. These are positions and kinds, not new codes, so they stay inside the session's decisions. |
+| G30 | **`dumps` returns the source text; `load` reads at most `max_bytes` + 1 bytes; a `str` that cannot be UTF-8 is `tdl-bad-encoding`.** `dumps(doc)` is `doc.text` (no re-rendering), `dump` writes it as UTF-8 with the byte-order mark kept. `load` refuses a longer input as `tdl-too-large` without reading it whole. `loads` on text with a lone surrogate raises `tdl-bad-encoding` at that character instead of `UnicodeEncodeError`. | The API promises `loads` raises only `TDLError`; a Python `str` can hold characters that no UTF-8 file can (found in step 4). The code's wording said "`load` only", which now means bytes or text that cannot be UTF-8. |
+| G32 | **How the edit calls behave where G23 and G24 are silent.** (1) A metadata `value` is plain text: written as a bare word when it reads back the same (non-empty, no outer space, no leading quote or `#`, no line end, no ` #`), else as a double-quoted string with `\\`, `\"`, `\n`, `\t` and `\u000d` escapes. (2) `with_property` takes the TDL text of exactly one value on one line; it is checked by reading it alone, so `1 }`, `a, b` and `1 # c` are refused with `ValueError`. (3) `with_property` adds inline (`Panel { A: 1, H: 40 }`) when the last property shares its line with something other than a comment, puts a first property after the `{` line with the first entry's indentation (or the head's plus two spaces), and inline after the `{` in a one-line block. (4) `Document.find(path)`: the first name is the metadata `Name` and stands for the root block; each next name is the `Name:` of a block directly inside the one before; the first match wins; none raises `KeyError`. (5) `without_metadata` of an absent key returns the same document. (6) A call that is wrong whatever the file holds raises `ValueError`; a result that is not a valid file raises `TDLError`. | G23 and G24 give the corpus cases; these are the rules the cases leave open, chosen so an edit can never silently change anything but the named bytes. |
+| G31 | **How `parse` recovers.** `parse` returns `ParseResult(document, errors)` with the errors in source order. A bad entry is skipped to the end of its line or to the `}` that closes its block, skipping braces the bad line opened itself; a bad metadata line is skipped and the next read; `}}` is reported once and closes up to two open blocks; each unclosed `{` is reported when the file ends; a second root block is reported and read; the limit errors stop the file with one error. The cap keeps the first 50 errors found; the 50th says `The list stops at 50 errors.` only when there was a 51st; nothing is read after it. `document` is the tree without the bad entries, or `None`. `loads` stops at the first mistake it meets, which `parse` lists too. The corpus case `slot-ends-at-first-close` now lists two errors: after `{{ {'a': {'b': 1}} }}` the trailing `}}` closes the root block and the file's last `}` is a stray one. | G25 left open how the cap is marked and what the tree holds. Cascades from one mistake are kept small by balanced-brace skipping; a mistake that opens a block on its own line (`If { `) can still cascade, which the cap bounds. |
+| G33 | **The conformance corpus ships in the source distribution, not in the wheel.** `tests/` (with `tests/corpus/`) is in the sdist; the wheel holds only `src/tdl`, `py.typed` and the licence. The shell reads the corpus of a released version from the sdist or the tag. | A wheel that installed `tests/corpus/` would put a top-level `tests` directory in every environment. The First Slice brief says the shell installs the package's test data or copies a released version; this takes the second. The maintainer may prefer a separate `tesserae-dl-corpus` package. |
+
+No questions are open.