chunkedte 0.2.0__tar.gz

chunkedte-0.2.0/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

chunkedte-0.2.0/.github/FUNDING.yml

@@ -0,0 +1 @@
+buy_me_a_coffee: jlianesglrs

chunkedte-0.2.0/.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Third-party reference files, fetched locally by scripts/fetch_upstream.py; only the manifest is tracked.
+tests/upstream/*
+!tests/upstream/MANIFEST.json

chunkedte-0.2.0/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.0]
+
+### Added
+
+- `Limits` and `LimitError`: bounds on one size line, all chunk extensions of a message,
+  the chunk size (below 2**63 by default), the body and the trailer section.
+- `Decoder.trailers` returns the trailer fields in arrival order; `Decoder.unused_data`
+  holds the bytes after the message (a pipelined request, for example).
+- `Encoder` streams chunks and closes the message with optional trailer fields; `encode`
+  takes `trailers` too. Trailer names, values and framing fields are validated.
+- `is_chunked` decides from Transfer-Encoding and Content-Length whether a body is chunked
+  (RFC 9112 sections 6.1 and 6.3) and rejects the combinations used for smuggling.
+- `chunkedte decode` and `chunkedte encode` on the command line, also `python -m chunkedte`.
+- `decode`, `Decoder.feed` and `encode` accept `bytearray` and `memoryview`.
+
+### Changed
+
+- The decoder follows RFC 9112 section 7.1 strictly: the size is hex digits only (no `+`,
+  `0x`, `_` or whitespace), extensions must match the grammar, only CRLF ends a line (bare
+  LF and bare CR are errors), exactly CRLF must follow chunk data, and trailer lines must be
+  valid field lines without obs-fold.
+- `decode` raises when bytes follow the message; bytes fed to a finished `Decoder` go to
+  `unused_data` instead of raising.
+- A `Decoder` that raised keeps raising on every later `feed`.
+- Lines split over many reads are scanned once, so decoding is linear in the input.
+- `encode` rejects a non-int `chunk_size` and non bytes-like data with `TypeError`.
+
+## [0.1.0]
+
+- `encode` frames a byte string as a chunked body split into fixed-size pieces.
+- `Decoder` incrementally decodes chunked bytes fed in any split, ignoring chunk
+  extensions and trailer fields (RFC 7230 section 4.1).
+- `decode` decodes a complete message in one call.
+- `ChunkedError` is raised on a malformed size line or broken framing.

chunkedte-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# Contributing
+
+Thanks for taking the time. This project keeps a small, predictable shape.
+
+## Setup
+
+```
+pip install -r requirements-dev.txt
+```
+
+## Before you open a pull request
+
+- Keep public API in `src/chunkedte/__init__.py`; internals live in `_`-prefixed modules.
+- Add a test for the behaviour you change. Tests inject time, disk and network; they
+  never touch the real thing.
+- Run `scripts/check.ps1` (format, lint, types, tests) and make sure it passes.
+- One logical change per commit, imperative subject line.
+
+Open an issue first if the change is large or shifts the public API.

chunkedte-0.2.0/IMPROVEMENTS-round.md

@@ -0,0 +1,144 @@
+# chunkedte improvement round
+
+Progress:
+- [x] Brainstorm ranked improvements (this file)
+- [x] Strict chunk-size line: HEXDIG only, chunk-ext grammar, CRLF only, size cap
+- [x] Strict framing after chunk data and in the trailer section (field-line grammar, no obs-fold)
+- [x] Limits (`Limits`, `LimitError`): line, total extensions, chunk size, body, trailer section
+- [x] Linear time on hostile input (no rescans of buffered bytes)
+- [x] Trailers exposed, bytes after the message kept apart (`unused_data`), `decode` rejects them
+- [x] Encoder: incremental `Encoder`, trailers on `encode`, field validation
+- [x] `is_chunked` for Transfer-Encoding and Content-Length (RFC 9112 section 6.1 and 6.3)
+- [x] Command line tool (`python -m chunkedte`)
+- [x] Contracts: fetched RFC grammar, advisory payloads, differential fuzz, typing, README, wheel e2e
+- [x] Mutation run (guards removed one at a time, each must fail the suite)
+- [x] Docs: README, CHANGELOG, docstrings, packaging metadata
+- [x] Gates: ruff format, ruff check, mypy --strict, pytest
+- [x] Independent review findings fixed with regression tests
+- [x] Pull request opened (#2), guard clean
+
+## Starting point
+
+`0.1.0` (not on PyPI) ships `encode`, `decode`, `Decoder` and `ChunkedError`. Read as an
+HTTP server or proxy author who feeds it attacker bytes, it has these gaps:
+
+- The size is parsed with `int(token.strip(), 16)`. Python's `int` takes `+5`, `0x5`, `5_0`
+  and surrounding whitespace, none of which is `1*HEXDIG`. This is the exact bug class of
+  the waitress advisory below: two parsers that disagree on a chunk size disagree on where
+  the next request starts.
+- Everything after `;` is dropped unchecked, so a size line such as `5;\nxx` or `5;a b`
+  passes. Lines are split on CRLF only, so a bare LF inside an extension is swallowed, the
+  pattern of the aiohttp and netty advisories.
+- Trailer lines are read but never checked: obs-fold, whitespace before the colon, a line
+  without a colon and control bytes all pass. Trailers are thrown away, with no way to read
+  them.
+- No limits: an endless size line, endless extensions or an endless trailer section are
+  buffered without bound (the Node.js advisory below), and the chunk size has no cap.
+- A line split over many small feeds is searched from the start on every feed: quadratic.
+- Bytes after the terminator stay in the buffer silently; `decode(b"0\r\n\r\nGET /")`
+  returns `b""` with no error.
+- The encoder cannot send trailers or stream; there is no help for the Transfer-Encoding
+  and Content-Length decision that decides whether chunked applies at all.
+- Packaging: no keywords or Python classifiers, README examples never run, no wheel test.
+
+## Sources (fetched 2026-10-13)
+
+- RFC 9112, https://www.rfc-editor.org/rfc/rfc9112.txt (sha256 `e4f426ba...`): section 7.1
+  (chunked-body, chunk, chunk-size = 1*HEXDIG, last-chunk = 1*("0"), recipients must cope
+  with large numerals), 7.1.1 (chunk-ext with BWS around `;` and `=`, token or quoted-string
+  values, a server ought to limit the total extension length), 7.1.2 (trailer-section =
+  *( field-line CRLF )), 7.1.3 (decoding pseudo-code), 2.2 (CRLF; a recipient MAY accept a
+  bare LF, a bare CR is invalid), 5 and 5.1 (field-line, no whitespace before the colon),
+  5.2 (obs-fold), 6.1 and 6.3 (Transfer-Encoding overrides Content-Length, both together
+  ought to be an error, chunked must be the final coding of a request).
+- RFC 9112 errata, https://www.rfc-editor.org/errata/rfc9112: two verified editorial errata
+  (obs-text reference, a missing changes note), none on section 7. The page also lists
+  RFC 9931 (March 2026) as updating RFC 9112; fetched from
+  https://www.rfc-editor.org/rfc/rfc9931.txt, it covers optimistic protocol upgrades, not
+  the chunked coding.
+- RFC 9110, https://www.rfc-editor.org/rfc/rfc9110.txt (sha256 `21c1cdce...`): 5.5
+  (field-value, field-vchar, obs-text), 5.6.2 (token, tchar), 5.6.3 (OWS, BWS), 5.6.4
+  (quoted-string, qdtext, quoted-pair), 6.5 and 6.5.1 (trailer fields; fields for framing
+  and routing cannot be sent as trailers).
+- GHSA-4f7p-27jc-3c36 (waitress, CVE-2022-24761): `int()` accepted `+10` and `0x01` as
+  sizes; extensions were dropped without validation.
+- GHSA-vqfr-h8mv-ghfj (h11, CVE-2025-43859): any two bytes accepted after chunk data instead
+  of CRLF; the advisory's payload `5\r\nAAAAAXX2\r\n45\r\n0\r\n\r\n` smuggles a request.
+- GHSA-8495-4g3g-x7pr (aiohttp, CVE-2024-52304) and GHSA-fghv-69vj-qj49 (netty,
+  CVE-2025-58056): a bare LF inside a chunk extension ended the size line.
+- GHSA-g9pc-8g42-g6vq (Go net/http via RoadRunner, CVE-2025-22871): a bare LF accepted as the
+  size line terminator.
+- GHSA-prhj-8562-p8gj (Node.js, CVE-2024-22019): unbounded chunk extension bytes across a
+  message exhausted CPU and bandwidth.
+- GHSA-cggh-pq45-6h9x (llhttp, CVE-2023-30589): a bare CR accepted as a line terminator.
+
+The RFC text is third-party: `scripts/fetch_upstream.py` fetches it into a gitignored
+`tests/upstream/` folder checked against a tracked `MANIFEST.json` (URL, size, sha256,
+licence); the tests that read it skip when it is absent. Advisory payloads are short test
+vectors, cited with their URL next to them.
+
+## Ranked brainstorm
+
+1. **Strict size line** (correctness, smuggling). Size must fullmatch `1*HEXDIG`; extensions
+   must match the RFC 9112 grammar exactly (BWS, token, quoted-string); the line ends only at
+   CRLF; bare LF and bare CR are errors. No lenient switch: the advisories show that every
+   leniency here is a desync with some other parser.
+2. **Strict data terminator and trailer section.** Exactly CRLF after chunk data, failing on
+   the first wrong byte. Trailer lines must be `token ":" OWS field-value OWS`; a line that
+   starts with SP or HTAB (obs-fold) is rejected, as are control bytes.
+3. **Limits** with safe defaults and a distinct `LimitError` (maps to 413/431 rather than
+   400): one size line, total extension bytes per message, chunk size (default below
+   2**63 so a value never wraps in a downstream 64-bit parser), body size, trailer section.
+4. **Linear time.** Keep a scan offset so a line split over n feeds costs O(n), and fail as
+   soon as the buffered line passes its limit instead of waiting for a CRLF.
+5. **Trailers and pipelining.** `Decoder.trailers` returns the parsed fields in order;
+   bytes after the final CRLF go to `Decoder.unused_data` (the next pipelined message), and
+   `decode` raises if there are any.
+6. **Encoder.** `Encoder.write` and `Encoder.finish(trailers)` for streaming; `encode` takes
+   trailers. Names must be tokens, values field-values, and framing or routing fields
+   (Content-Length, Transfer-Encoding, Trailer, Host) are refused as trailers.
+7. **`is_chunked(transfer_encoding, content_length, request=True)`** applies RFC 9112 6.1
+   and 6.3: both fields together is an error, chunked twice or not last in a request is an
+   error, chunked with parameters is an error, a response with chunked not last is read to
+   close (returns False).
+8. **Typed API**: bytes-like input, `Limits` frozen dataclass, `py.typed`, mypy snippet test.
+9. **CLI**: `python -m chunkedte decode|encode` over stdin and stdout, trailers on stderr.
+10. **Contracts**: grammar classes checked against the fetched RFC ABNF, advisory payloads,
+    a differential fuzz against an independent whole-message reference parser over random
+    mutations and random splits, README examples executed, installed-wheel e2e, mutation run.
+11. **Packaging**: keywords, classifiers, console script, CHANGELOG, version 0.2.0.
+
+Out of scope: content codings (gzip inside chunked), HTTP header parsing beyond the two
+framing fields, and any lenient mode.
+
+## Mutation run
+
+66 hand-written mutants (one guard, bound or grammar class changed at a time) over every
+module, each run against the whole suite with bytecode writes off, `__pycache__` purged
+and a per-mutant timeout; the suite was green before and after. 63 were killed at once.
+Of the three survivors, one exposed a weak test (`unused_data` before completion was
+checked with an empty buffer) and is now killed; one was a redundant type check in
+`is_chunked` that the regex already enforces, now removed; the last (`\Z` to `$` in the
+Transfer-Encoding list parser) is equivalent, because the zero-length-match guard rejects
+the trailing newline either way.
+
+## Independent review
+
+One medium and eight low findings, all handled:
+
+- `is_chunked` backtracked quadratically on long whitespace runs (two adjacent OWS runs in
+  the list regex). Fixed by moving the trailing OWS inside the optional coding group;
+  regression tests with 64 KiB of spaces and tabs.
+- Transfer-Encoding errors echoed the whole field; now cut to 64 characters, with a test.
+- The encoder refused only framing and routing trailers; it now refuses every RFC 9110
+  section 6.5.1 category (authentication, request modifiers, response controls, content
+  format), tested.
+- The CLI failed on a latin-1 trailer with an ASCII terminal; trailer bytes outside ASCII
+  are now escaped, tested.
+- Documented: received trailers must stay apart from the header section, `feed` drops the
+  pieces of the call that raises, the CLI may leave a truncated body on stdout on failure,
+  and `is_chunked` leaves HEAD, 1xx, 204, 304, CONNECT and HTTP/1.0 to the caller.
+- Kept on purpose: two wall-clock tests with generous bounds (they are the only way to
+  catch a quadratic regression, and the mutation run showed they bite), CLI tests that use
+  `tmp_path`, and Python 3.10 as the floor (the code uses `X | Y` type aliases).
+

chunkedte-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javier Lianes
+
+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.

chunkedte-0.2.0/PKG-INFO

@@ -0,0 +1,198 @@
+Metadata-Version: 2.5
+Name: chunkedte
+Version: 0.2.0
+Summary: Strict, incremental, typed, zero-dependency codec for HTTP/1.1 chunked transfer coding
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/chunkedte
+Project-URL: Issues, https://github.com/JaviLianes8/chunkedte/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/chunkedte/blob/main/CHANGELOG.md
+Project-URL: LinkedIn, https://www.linkedin.com/in/jlianes/
+Project-URL: Funding, https://buymeacoffee.com/jlianesglrs
+Author-email: Javier Lianes <javier@lianes8studio.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: chunked,codec,http,request-smuggling,rfc9112,trailers,transfer-encoding
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# chunkedte
+
+Strict, incremental, typed, zero-dependency codec for HTTP/1.1 chunked transfer coding
+(RFC 9112 section 7.1).
+
+## Install
+
+```
+pip install chunkedte
+```
+
+Python 3.10 or newer. No dependencies.
+
+## Usage
+
+Decode a complete message in one call. `decode` raises `ChunkedError` if the message is
+malformed, unfinished, or followed by more bytes:
+
+```python
+from chunkedte import ChunkedError, decode
+
+print(decode(b"5\r\nhello\r\n0\r\n\r\n"))
+try:
+    decode(b"0x5\r\nhello\r\n0\r\n\r\n")
+except ChunkedError as error:
+    print(error)
+# b'hello'
+# malformed chunk-size line: b'0x5'
+```
+
+Decode incrementally as bytes arrive off a socket. `Decoder.feed` takes any split and
+returns the body pieces available so far; trailer fields and whatever follows the message
+(a pipelined request, say) are kept apart:
+
+```python
+from chunkedte import Decoder
+
+decoder = Decoder()
+body = b""
+for part in [b"4\r\nwi", b"ki\r\n5;sig=ab\r\npedia\r\n0\r\nDigest: x\r\n", b"\r\nGET /"]:
+    for piece in decoder.feed(part):
+        body += piece
+print(body, decoder.is_complete)
+print(decoder.trailers, decoder.unused_data)
+# b'wikipedia' True
+# [('Digest', 'x')] b'GET /'
+```
+
+Bound what a peer can make you buffer. Passing a bound raises `LimitError`, a subclass of
+`ChunkedError`, so a server can answer 413 or 431 instead of 400:
+
+```python
+from chunkedte import Decoder, LimitError, Limits
+
+decoder = Decoder(Limits(max_body_size=1024, max_trailer_size=4096))
+try:
+    decoder.feed(b"10000\r\n")
+except LimitError as error:
+    print(error)
+print(Limits())
+# body exceeds max_body_size
+# Limits(max_line_size=4096, max_extensions_size=16384, max_chunk_size=9223372036854775807, max_body_size=None, max_trailer_size=16384)
+```
+
+Encode in one call, or stream with `Encoder` and close with optional trailer fields:
+
+```python
+from chunkedte import Encoder, encode
+
+print(encode(b"abcd", chunk_size=2))
+encoder = Encoder()
+print(encoder.write(b"hello") + encoder.finish({"X-Checksum": "42"}))
+# b'2\r\nab\r\n2\r\ncd\r\n0\r\n\r\n'
+# b'5\r\nhello\r\n0\r\nX-Checksum: 42\r\n\r\n'
+```
+
+Decide whether a message body is chunked at all from its Transfer-Encoding and
+Content-Length values (`None` when absent). `is_chunked` applies RFC 9112 sections 6.1 and
+6.3 and raises `ChunkedError` on the combinations used for request smuggling:
+
+```python
+from chunkedte import ChunkedError, is_chunked
+
+print(is_chunked("gzip, chunked"), is_chunked(None, "12"))
+print(is_chunked("gzip", request=False))
+for te, cl in [("chunked", "12"), ("chunked, chunked", None), ("chunked, gzip", None)]:
+    try:
+        is_chunked(te, cl)
+    except ChunkedError as error:
+        print(error)
+# True False
+# False
+# both Transfer-Encoding and Content-Length are present
+# chunked is applied more than once
+# chunked is not the final transfer coding of a request
+```
+
+### Command line
+
+```
+$ printf '5\r\nhello\r\n0\r\nX-Sum: 1\r\n\r\n' | chunkedte decode
+hello
+X-Sum: 1
+$ printf 'abc' | chunkedte encode --chunk-size 2 --trailer "X-Sum: 1"
+```
+
+`decode` writes the body to stdout and the trailer fields to stderr; `encode` frames stdin
+(or a file) as a chunked body. Both exit with status 1 and a message on bad input; body
+bytes decoded before the error may already be on stdout, so treat the output of a failed
+run as truncated. Trailer bytes outside printable ASCII are written as escapes.
+`python -m chunkedte` works too.
+
+## What "strict" means here
+
+Every leniency in a chunked parser is a way for two HTTP processors to disagree on where a
+message ends, which is how request smuggling works. So the decoder rejects:
+
+- a chunk size that is not only hex digits (`+5`, `0x5`, `5_0`, ` 5`, `5 `);
+- chunk extensions that do not follow the grammar (whitespace is allowed only around `;`
+  and `=`, values are tokens or quoted strings);
+- a bare LF or a bare CR anywhere a CRLF is expected, including inside an extension;
+- anything other than CRLF right after the chunk data;
+- trailer lines that are not `name: value`, with whitespace before the colon, with control
+  bytes, or folded onto a continuation line (obs-fold).
+
+Extensions are validated and then ignored, as RFC 9112 asks. The default `Limits` cap one
+size line at 4 KiB, all extensions of a message at 16 KiB, the trailer section at 16 KiB and
+a chunk size below 2**63 (so a forwarded size never wraps in a 64-bit parser); the body is
+unbounded unless you set `max_body_size`. A line split over many small reads is scanned
+once, so decoding stays linear in the input. When `feed` raises, the pieces decoded in that
+call are dropped with it. Received trailers are returned as they came: RFC 9110 section
+6.5.2 says not to merge them into the header section, so keep them apart (a `Content-Length`
+trailer, say, must never reach your framing logic). The encoder refuses trailer names that
+are not tokens, values with control bytes or edge whitespace, and the fields RFC 9110
+section 6.5.1 needs before the content: framing and routing (Content-Length,
+Transfer-Encoding, Trailer, TE, Host, Connection, Keep-Alive, Upgrade, Max-Forwards),
+authentication (Authorization, Proxy-Authorization, WWW-Authenticate, Proxy-Authenticate,
+Cookie, Set-Cookie), request modifiers and response controls (Expect, Range,
+Cache-Control) and content format (Content-Type, Content-Encoding, Content-Range).
+`is_chunked` leaves the rest of RFC 9112 section 6.3 to you: responses to HEAD, 1xx, 204,
+304 and 2xx to CONNECT carry no body, and an HTTP/1.0 message with Transfer-Encoding has
+faulty framing. There is no lenient mode.
+
+## Why
+
+Chunked transfer coding is simple to frame and easy to get subtly wrong: the terminating
+`0` chunk, the closing blank line, extensions and trailers are routinely mishandled, and
+the security advisories of the last few years (waitress, h11, aiohttp, netty, Go net/http,
+Node.js) are all variations on a parser accepting bytes another parser reads differently.
+The existing Python options are tied to one HTTP stack (`h11`, `aiohttp`) or to one server.
+This is a standalone, typed, zero-dependency codec with the strict behaviour by default:
+reach for it when you move chunked framing yourself and do not want a whole HTTP stack.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

chunkedte-0.2.0/README.md

@@ -0,0 +1,162 @@
+# chunkedte
+
+Strict, incremental, typed, zero-dependency codec for HTTP/1.1 chunked transfer coding
+(RFC 9112 section 7.1).
+
+## Install
+
+```
+pip install chunkedte
+```
+
+Python 3.10 or newer. No dependencies.
+
+## Usage
+
+Decode a complete message in one call. `decode` raises `ChunkedError` if the message is
+malformed, unfinished, or followed by more bytes:
+
+```python
+from chunkedte import ChunkedError, decode
+
+print(decode(b"5\r\nhello\r\n0\r\n\r\n"))
+try:
+    decode(b"0x5\r\nhello\r\n0\r\n\r\n")
+except ChunkedError as error:
+    print(error)
+# b'hello'
+# malformed chunk-size line: b'0x5'
+```
+
+Decode incrementally as bytes arrive off a socket. `Decoder.feed` takes any split and
+returns the body pieces available so far; trailer fields and whatever follows the message
+(a pipelined request, say) are kept apart:
+
+```python
+from chunkedte import Decoder
+
+decoder = Decoder()
+body = b""
+for part in [b"4\r\nwi", b"ki\r\n5;sig=ab\r\npedia\r\n0\r\nDigest: x\r\n", b"\r\nGET /"]:
+    for piece in decoder.feed(part):
+        body += piece
+print(body, decoder.is_complete)
+print(decoder.trailers, decoder.unused_data)
+# b'wikipedia' True
+# [('Digest', 'x')] b'GET /'
+```
+
+Bound what a peer can make you buffer. Passing a bound raises `LimitError`, a subclass of
+`ChunkedError`, so a server can answer 413 or 431 instead of 400:
+
+```python
+from chunkedte import Decoder, LimitError, Limits
+
+decoder = Decoder(Limits(max_body_size=1024, max_trailer_size=4096))
+try:
+    decoder.feed(b"10000\r\n")
+except LimitError as error:
+    print(error)
+print(Limits())
+# body exceeds max_body_size
+# Limits(max_line_size=4096, max_extensions_size=16384, max_chunk_size=9223372036854775807, max_body_size=None, max_trailer_size=16384)
+```
+
+Encode in one call, or stream with `Encoder` and close with optional trailer fields:
+
+```python
+from chunkedte import Encoder, encode
+
+print(encode(b"abcd", chunk_size=2))
+encoder = Encoder()
+print(encoder.write(b"hello") + encoder.finish({"X-Checksum": "42"}))
+# b'2\r\nab\r\n2\r\ncd\r\n0\r\n\r\n'
+# b'5\r\nhello\r\n0\r\nX-Checksum: 42\r\n\r\n'
+```
+
+Decide whether a message body is chunked at all from its Transfer-Encoding and
+Content-Length values (`None` when absent). `is_chunked` applies RFC 9112 sections 6.1 and
+6.3 and raises `ChunkedError` on the combinations used for request smuggling:
+
+```python
+from chunkedte import ChunkedError, is_chunked
+
+print(is_chunked("gzip, chunked"), is_chunked(None, "12"))
+print(is_chunked("gzip", request=False))
+for te, cl in [("chunked", "12"), ("chunked, chunked", None), ("chunked, gzip", None)]:
+    try:
+        is_chunked(te, cl)
+    except ChunkedError as error:
+        print(error)
+# True False
+# False
+# both Transfer-Encoding and Content-Length are present
+# chunked is applied more than once
+# chunked is not the final transfer coding of a request
+```
+
+### Command line
+
+```
+$ printf '5\r\nhello\r\n0\r\nX-Sum: 1\r\n\r\n' | chunkedte decode
+hello
+X-Sum: 1
+$ printf 'abc' | chunkedte encode --chunk-size 2 --trailer "X-Sum: 1"
+```
+
+`decode` writes the body to stdout and the trailer fields to stderr; `encode` frames stdin
+(or a file) as a chunked body. Both exit with status 1 and a message on bad input; body
+bytes decoded before the error may already be on stdout, so treat the output of a failed
+run as truncated. Trailer bytes outside printable ASCII are written as escapes.
+`python -m chunkedte` works too.
+
+## What "strict" means here
+
+Every leniency in a chunked parser is a way for two HTTP processors to disagree on where a
+message ends, which is how request smuggling works. So the decoder rejects:
+
+- a chunk size that is not only hex digits (`+5`, `0x5`, `5_0`, ` 5`, `5 `);
+- chunk extensions that do not follow the grammar (whitespace is allowed only around `;`
+  and `=`, values are tokens or quoted strings);
+- a bare LF or a bare CR anywhere a CRLF is expected, including inside an extension;
+- anything other than CRLF right after the chunk data;
+- trailer lines that are not `name: value`, with whitespace before the colon, with control
+  bytes, or folded onto a continuation line (obs-fold).
+
+Extensions are validated and then ignored, as RFC 9112 asks. The default `Limits` cap one
+size line at 4 KiB, all extensions of a message at 16 KiB, the trailer section at 16 KiB and
+a chunk size below 2**63 (so a forwarded size never wraps in a 64-bit parser); the body is
+unbounded unless you set `max_body_size`. A line split over many small reads is scanned
+once, so decoding stays linear in the input. When `feed` raises, the pieces decoded in that
+call are dropped with it. Received trailers are returned as they came: RFC 9110 section
+6.5.2 says not to merge them into the header section, so keep them apart (a `Content-Length`
+trailer, say, must never reach your framing logic). The encoder refuses trailer names that
+are not tokens, values with control bytes or edge whitespace, and the fields RFC 9110
+section 6.5.1 needs before the content: framing and routing (Content-Length,
+Transfer-Encoding, Trailer, TE, Host, Connection, Keep-Alive, Upgrade, Max-Forwards),
+authentication (Authorization, Proxy-Authorization, WWW-Authenticate, Proxy-Authenticate,
+Cookie, Set-Cookie), request modifiers and response controls (Expect, Range,
+Cache-Control) and content format (Content-Type, Content-Encoding, Content-Range).
+`is_chunked` leaves the rest of RFC 9112 section 6.3 to you: responses to HEAD, 1xx, 204,
+304 and 2xx to CONNECT carry no body, and an HTTP/1.0 message with Transfer-Encoding has
+faulty framing. There is no lenient mode.
+
+## Why
+
+Chunked transfer coding is simple to frame and easy to get subtly wrong: the terminating
+`0` chunk, the closing blank line, extensions and trailers are routinely mishandled, and
+the security advisories of the last few years (waitress, h11, aiohttp, netty, Go net/http,
+Node.js) are all variations on a parser accepting bytes another parser reads differently.
+The existing Python options are tied to one HTTP stack (`h11`, `aiohttp`) or to one server.
+This is a standalone, typed, zero-dependency codec with the strict behaviour by default:
+reach for it when you move chunked framing yourself and do not want a whole HTTP stack.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/