web-cortex-framework 0.3.0__cp313-cp313-win_amd64.whl

web_cortex_framework-0.3.0.dist-info/METADATA

@@ -0,0 +1,390 @@
+Metadata-Version: 2.4
+Name: web-cortex-framework
+Version: 0.3.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading :: 3 - Stable
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Dist: pytest>=8 ; extra == 'dev'
+Requires-Dist: httpx>=0.27 ; extra == 'dev'
+Provides-Extra: dev
+License-File: LICENSE
+Summary: A Rust-cored Python web framework where every route is also an agent tool.
+Keywords: web,framework,api,agent,mcp,rust,free-threaded
+Home-Page: https://github.com/slimboi34/web_cortex_framework
+License: Apache-2.0
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/slimboi34/web_cortex_framework/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/slimboi34/web_cortex_framework
+Project-URL: Repository, https://github.com/slimboi34/web_cortex_framework
+Project-URL: Security, https://github.com/slimboi34/web_cortex_framework/blob/main/SECURITY.md
+
+# WebCortex
+
+> **Status: pre-release.** Not yet published; build from source. Once released it
+> installs as **`web-cortex-framework`** and imports as **`webcortex`** — the same
+> split as `djangorestframework` → `import rest_framework`.
+
+**📖 [Documentation](https://slimboi34.github.io/web_cortex_framework/)** ·
+[Tutorial](https://slimboi34.github.io/web_cortex_framework/tutorial/) ·
+[Use cases](https://slimboi34.github.io/web_cortex_framework/use-cases/) ·
+[Security](https://slimboi34.github.io/web_cortex_framework/security/)
+
+A Python web framework with a Rust core, built on one idea:
+
+> **If you declared it, Rust can run it — and an agent can call it.**
+
+Django and Rails were designed when the only client was a browser. Today the
+client is just as likely to be a model. WebCortex treats that as the primary case
+rather than something you bolt on with a second, hand-maintained tool server.
+
+```python
+# api.py
+from webcortex import WebCortex
+
+app = WebCortex("bookstore", database="sqlite://./app.db")
+
+app.api_key("WEBCORTEX_API_KEY", id="service", scopes=["read", "write"])
+app.rate_limit(per_second=50)
+app.anonymous_scopes("read")
+
+app.resource(
+    "books",
+    fields={"id": int, "title": str, "author": str, "year": int},
+    tools=True,
+    read_scopes=["read"],
+    write_scopes=["write"],
+)
+
+@app.get("/books/{id}/blurb", tool=True, scopes=["read"])
+def blurb(id: int) -> str:
+    """One-line pitch for a book."""
+    return f"Book {id} — highly recommended."
+```
+
+```
+$ webcortex dev
+```
+
+You now have a REST API, an OpenAPI 3.1 document, **a live MCP server exposing
+all six endpoints as tools**, authentication, rate limiting, and security
+headers. No second file, no schema written twice, no drift.
+
+---
+
+## Start here
+
+```bash
+# Not yet on PyPI — see Status below. For now, build from source:
+git clone https://github.com/slimboi34/web_cortex_framework && cd webcortex
+uv venv --python 3.14 && uv pip install maturin && maturin develop --uv
+
+webcortex new myapp                # --template api | fullstack | agent | behaviour
+cd myapp
+export WEBCORTEX_API_KEY=$(webcortex keygen)
+webcortex dev
+```
+
+## Why a Rust core, specifically
+
+Most Rust-accelerated Python servers put Rust at the socket and call Python for
+every request. You get faster parsing; your handler is still interpreted.
+
+WebCortex puts the boundary somewhere more useful. **Python is a declaration
+language that compiles to a plan the Rust runtime executes.** A route whose work
+is expressible as data — a query, a proxy, a rendered page, a static file, an
+agent invocation — runs entirely in Rust and *never enters the interpreter at
+request time*. In practice that is most of a CRUD API.
+
+```
+$ webcortex check
+  12 routes, 9 served without touching Python
+```
+
+When a route genuinely needs Python, it crosses onto a pool of free-threaded
+interpreter workers (CPython 3.13+/3.14, GIL disabled), each running its own
+event loop. Handlers run in real parallel — **measured at 4.82× vs 1.38× under
+the GIL** ([DESIGN.md](DESIGN.md) has the numbers and their caveats).
+
+WebCortex runs correctly on a GIL build too, and tells you which mode it is in.
+
+## Behaviours
+
+A "skill" written as a prompt is a *suggestion*. The model reads it and may
+ignore it, and "if X then Y" fails silently when it does.
+
+A **Behaviour** inverts that. The control flow is real Python — a `for` loop is
+a loop, an `if` is a branch, and both execute whether or not a model would have
+chosen to. Only the *leaves* are probabilistic:
+
+```python
+@app.behaviour("triage", tools=["list_tickets", "update_tickets"],
+               max_steps=100, token_budget=100_000)
+def triage(ctx, input):
+    """Classify every open ticket and escalate the urgent ones."""
+    tickets = ctx.call("list_tickets", limit=50)
+    escalated = []
+
+    for ticket in tickets:                        # a real loop
+        verdict = ctx.ask(                        # a model call
+            f"Grade this ticket:\n{ticket['body']}",
+            schema={
+                "type": "object",
+                "properties": {
+                    "urgency": {"type": "integer"},
+                    "category": {"enum": ["bug", "billing", "other"]},
+                },
+                "required": ["urgency", "category"],
+            },
+        )
+        if verdict["urgency"] >= input.get("threshold", 7):   # a real branch
+            escalated.append(ticket["id"])
+        ctx.call("update_tickets", id=ticket["id"], body=ticket["body"],
+                 urgency=verdict["urgency"],
+                 state="escalated" if ticket["id"] in escalated else "triaged")
+
+    return {"escalated": escalated, "usage": ctx.usage}
+```
+
+You get a procedure with **deterministic structure and probabilistic steps**,
+rather than a probabilistic procedure.
+
+`ctx` is how a behaviour reaches the world:
+
+| | |
+|---|---|
+| `ctx.call(tool, **kwargs)` | invoke one of the app's tools, in-process |
+| `ctx.ask(prompt, schema=...)` | a model call; a schema **forces** the shape, so branches switch on real values |
+| `ctx.log(msg)` / `ctx.halt(reason)` | narrate or stop deliberately |
+| `ctx.usage` / `ctx.trace` | budget consumed and every leaf executed, readable mid-run |
+| `ctx.user` / `ctx.tools` | the delegated principal and what it may call |
+
+**A behaviour is a tool.** It registers as a route, so it is automatically an
+MCP tool, an OpenAPI operation, and something an agent — or another behaviour —
+can call. Composition is just a tool call, so budgets and scopes still apply.
+
+**The runtime enforces the limits, not your diligence:**
+
+- `max_steps` caps total leaf operations. A loop that would run 100 times with
+  `max_steps=3` stops at 3 and returns `{"halted": true, "reason": ...}`.
+- `token_budget` caps spend.
+- A behaviour cannot call a tool it did not declare.
+- An approval-gated tool cannot be laundered through a behaviour — the gate
+  halts the run, exactly as it halts an agent.
+- Scopes are delegated by intersection, never unioned.
+
+```bash
+webcortex new myapp --template behaviour
+```
+
+## The seven kinds of route
+
+| Kind | Declared with | Runs in |
+|---|---|---|
+| Static | `app.static(...)` | Rust |
+| Query | `app.query(...)`, `app.resource(...)` | Rust |
+| Page | `app.page(...)` | Rust (minijinja) |
+| Files | `app.static_files(...)` | Rust |
+| Proxy | `app.proxy(...)` | Rust |
+| Agent | `app.agent(..., expose_at=...)` | Rust |
+| Behaviour | `@app.behaviour(...)` | Python worker pool |
+| Python | `@app.get(...)` | Python worker pool |
+
+## Every route is a tool
+
+Mark a route `tool=True` and it appears in MCP `tools/list`, with an input
+schema derived from the handler's own type hints. Agents declared in the same
+app call those tools **in-process** — a function call through the same
+dispatcher the HTTP server uses, not a loopback request.
+
+```python
+app.agent(
+    "librarian",
+    model="claude-opus-5",
+    tools=["list_books", "get_books"],
+    scopes=["read"],          # what a run may do
+    expose_scopes=["read"],   # who may start one
+    max_steps=8,
+    token_budget=50_000,
+    expose_at="/ask",
+)
+```
+
+A typo in `tools` fails at boot with a "did you mean" suggestion.
+
+## What makes agents safe to deploy
+
+These are enforced by the runtime, not by your diligence:
+
+**Delegated authority.** An agent run executes as
+`caller.delegate_to_agent(...)`, whose scopes are *intersected* with the
+caller's — never unioned. An anonymous caller cannot launch a privileged agent.
+This is the confused-deputy defence, and it is a property of the type, not a
+convention.
+
+**Human approval gates.** Mark a route `approval="required"` and an agent asking
+for it does not get it — the run suspends and records an approval request. The
+gate also applies to direct MCP calls, so it cannot be stepped around.
+
+```python
+@app.delete("/books/all", tool=True, scopes=["write"], approval="required")
+def clear_catalogue(confirm: bool = False) -> dict: ...
+```
+
+**Runtime-enforced budgets.** `max_steps` and `token_budget` are checked before
+each provider call. A looping model costs a bounded amount.
+
+**Scope-filtered tool lists.** `tools/list` shows only what *that caller* can
+invoke. A reader sees three tools where an admin sees six.
+
+**A full audit trail**, including refused calls, at `GET /_webcortex/audit`.
+
+## Security defaults
+
+Deny-by-default throughout; relaxing something costs a line, tightening it costs
+nothing. API keys are referenced by environment variable, hashed with SHA-256,
+and compared in constant time. JWT (HS/RS) with mandatory expiry validation.
+Per-principal token-bucket rate limiting. Security headers on every response.
+CORS that refuses `*` with credentials *at boot*. Path traversal, symlink
+escapes, and dotfiles refused by the static server.
+
+`webcortex security` prints exactly what is reachable without a credential:
+
+```
+$ webcortex security
+{"auth_configured": true, "public_routes": ["GET /"], "gated_tools": ["DELETE /books/all"]}
+```
+
+## The frontend, without the mess
+
+Two clean paths sharing one data layer, chosen per route:
+
+**Server-rendered pages**, executed in Rust:
+
+```python
+app.page("/", "index.html", sql="SELECT * FROM books LIMIT 20", bind="books")
+app.static_files("/assets", "static")
+```
+
+The rule that keeps this clean: **a template receives a data object and nothing
+else.** It has no database handle and cannot call Python, so it cannot grow
+logic. Data is resolved *before* rendering, from a constant, a query, or a
+Python handler. Autoescaping is on and derived from the file extension.
+
+**A typed TypeScript client** for SPA frontends, from the same route table:
+
+```bash
+$ webcortex typegen          # writes client/api.ts
+```
+
+Zero dependencies, `fetch`-based, with auth built in. Pages and static mounts
+are excluded — they are not part of the JSON API surface.
+
+## Commands
+
+```
+webcortex new <name>      scaffold a project (api | fullstack | agent | behaviour)
+webcortex dev             run with a startup report
+webcortex check           routes, tools, and the public attack surface
+webcortex security        what is reachable without a credential
+webcortex tools           the agent tool manifest
+webcortex typegen         generate a typed TypeScript client
+webcortex openapi         the OpenAPI 3.1 document
+webcortex sql             DDL for declared resources
+webcortex keygen          mint an API key
+```
+
+## Security
+
+WebCortex has been through an adversarial review of its own controls — auth,
+authorization, injection, traversal, SSRF, exhaustion, disclosure — plus stress
+and soak testing. **Six issues were found and fixed**, each with a regression
+test in `tests/test_pentest.py`:
+
+| | Severity |
+|---|---|
+| Remote DoS + total auth failure via a JWT library panic | Critical |
+| No panic boundary on the request path | High |
+| Proxy path traversal usable as an SSRF primitive | High |
+| Unbounded behaviour recursion exhausting the worker pool | High |
+| Python tracebacks returned to clients | Medium |
+| Client input faults reported as 500s | Low |
+
+Soak: **1,786,805 requests, 0 errors, 0 panics**, memory at steady state.
+
+[`SECURITY.md`](SECURITY.md) has the full report — including what was *not*
+tested and the known limits.
+
+## Status
+
+v0.3. Working and tested: the manifest IR, router, native ops (static / query /
+proxy / page / files), the free-threaded Python bridge, authentication and
+scopes, rate limiting, CORS, security headers, graceful shutdown, Behaviours,
+the agent runtime with approval gates and budgets, the audit trail, OpenAPI, the
+MCP server, and TypeScript generation. **251 tests** (66 Rust, 185 Python,
+including a 54-test adversarial suite), clippy clean.
+
+Not yet: Postgres, SSE streaming, durable agent runs, local model supervision.
+See [DESIGN.md](DESIGN.md) for the roadmap, honest risk grading, and — just as
+importantly — what is deliberately **not** being built.
+
+## Known issue: CPython 3.14.7 with the GIL enabled
+
+On CPython **3.14.7 specifically, with the GIL enabled**, the compiled extension
+fails to import:
+
+```
+ValueError: module functions cannot set METH_CLASS or METH_STATIC
+```
+
+3.12, 3.13, 3.14.6 and the **free-threaded** 3.14.7 build (`3.14t`) are all
+unaffected. 3.14.7 was released on 5 August 2026; the failure began the same day.
+
+This is not a version-resolution accident on your machine — `uv` resolves `3.14`
+to the newest patch build available when it runs, so an environment that worked
+yesterday can stop working today without anything in your project changing. Pin
+to 3.13, or use the free-threaded 3.14 build, until this is resolved.
+
+The investigation so far, including what has been ruled out, is in
+[AGENTS.md §11](AGENTS.md#11-known-issue-cpython-3147-with-the-gil-enabled).
+
+## For AI coding tools
+
+[**AGENTS.md**](AGENTS.md) is the machine-facing reference: the complete API
+surface with exact signatures and defaults, the binding and scope rules, the
+constraints the runtime enforces, and the specific mistakes that are cheap to
+make and expensive to debug. Claude Code, Cursor, Codex, Aider and Copilot
+Workspace all read it by convention.
+
+It is written to be correct rather than welcoming. Humans should start with the
+[docs site](https://slimboi34.github.io/web_cortex_framework/) instead.
+
+## Building from source
+
+```bash
+# 3.13 is the recommended toolchain today — see "Known issue" above.
+uv venv --python 3.13
+uv pip install maturin pytest
+.venv/bin/maturin develop --uv
+.venv/bin/python -m pytest tests/
+```
+
+The free-threaded build is also supported and is the configuration the bridge was
+designed around:
+
+```bash
+uv venv --python 3.14t
+```
+
+## License
+
+Apache-2.0
+

web_cortex_framework-0.3.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+web_cortex_framework-0.3.0.dist-info/METADATA,sha256=lAR2x6paiejmJE2GrLoDJn9r8cY_MagpCag1_dhRp5M,15456
+web_cortex_framework-0.3.0.dist-info/WHEEL,sha256=z3sDn4xNPtieBDo9mUKkT1e80gbhCuRsQQi1_g6mdQM,97
+web_cortex_framework-0.3.0.dist-info/entry_points.txt,sha256=93iJfcs9sw0ARrzvZ_88QBaO51j0nMcEABoEFJYzWuk,47
+web_cortex_framework-0.3.0.dist-info/licenses/LICENSE,sha256=G2ZDBHXGF64oHA55EuVICzSok7So1NPaPQqL2HdpwQk,11545
+web_cortex_framework-0.3.0.dist-info/sboms/webcortex-py.cyclonedx.json,sha256=CJ_mYPFwXSU1XQoynEozc85qoVBy7iqyuVR3J2YomD0,330569
+webcortex/__init__.py,sha256=0UQ0c7U_nLmUGjVIUC-Z8hUJLX4_flf_L32twdiJNvA,817
+webcortex/_bridge.py,sha256=GIJhMtwTnj1K4GjDq5fABdka-JPdIKO_YQtQcKIImCo,12738
+webcortex/_core.cp313-win_amd64.pyd,sha256=V9w3BLUDRV6jo9-f61BUF9N-pYvs-nB-ubilYZAazoQ,12303360
+webcortex/app.py,sha256=a2bF5w6Z8JDoVT_FArZfGEtqeN3nrIDg9_PKP58YFko,42138
+webcortex/cli.py,sha256=TMPPGH1lAPBG1vQIL9OAGS9cm31wGSxWH3OtUjCkzFg,9354
+webcortex/schema.py,sha256=HsQV65m4HgJGnKXn7O1gtytDEePhV8ZKtaMKZ4GExy0,7101
+webcortex/starters.py,sha256=7rbjTLbiThNHR4etNO9SS12Kkj2AT3cmT5V3DiMvVcs,14899
+web_cortex_framework-0.3.0.dist-info/RECORD,,

web_cortex_framework-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.14.1)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64

web_cortex_framework-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+webcortex=webcortex.cli:main

web_cortex_framework-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Joshua Harty
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.