@@ -5,6 +5,7 @@
 **Changed**:
 
 - `env.finalize()` now returns `self` instead of `None`, so it can be chained: `e = env(x=42).finalize()`. Matches the existing instance passthrough on `<<`.
+- **Python 3.15 is supported**, and `requires-python` moves from `<3.15` to `<3.16`. The macros needed no changes for the new syntax: `lazify`, `autocurry` and `tco` all pass through comprehension unpacking (`{**mapping for x in xs}`, `[*items for item in xs]`, and the set and generator forms) correctly, and there are now tests to keep it that way. Requires `mcpyrate` 4.2.1 or newer, since earlier versions cannot import anything at all under 3.15.
 
 **Fixed**:
 
 
@@ -90,7 +90,24 @@ kept rather than rediscovered, and move the version metadata.
 
 ## Work items
 
-Items 1-3 are settled as above and need tests rather than fixes. Python 3.15.0rc1 is installed on the personal machine.
+Items 1-3 are settled as above and need tests rather than fixes. Python 3.15.0rc1 is installed on both machines.
+
+**Release ordering is forced, and the CI matrix has to wait for it.** `unpythonic` declares
+`mcpyrate>=4.2.0`, and **mcpyrate 4.2.0 as published cannot import any module under 3.15** —
+verified by installing it into a clean 3.15 venv, where importing an ordinary module dies with
+`TypeError: source_to_xcode() takes 3 positional arguments but 4 were given`. So a 3.15 job in
+`unpythonic`'s CI would resolve `mcpyrate` from PyPI, get 4.2.0, and fail for reasons that have
+nothing to do with the code under test. The sequence is therefore:
+
+1. Land unpythonic's code changes — tests, `requires-python` cap, classifier. No CI matrix entry.
+2. Release **mcpyrate 4.2.1** (its work is already done and waiting).
+3. In `unpythonic`, bump the pin to `mcpyrate>=4.2.1` **and** add `"3.15"` to the CI matrix with
+   `allow-prereleases: true`, in one commit. Only now can that job pass.
+4. Release **unpythonic 2.3.1**.
+
+"Released together" therefore means same sitting, verified against each other — not simultaneous.
+The verification itself is already done: unpythonic's suite was run against the working-tree
+mcpyrate and passed 3862/3862.
 
 1. **`lazify` with a `Starred` comprehension element.** `lazify.py` has no comprehension-specific handling at all, and its `Starred` handling is scoped to call arguments (line 537) and container literals (line 770). A `Starred` in `elt` position is a new shape reaching the generic path. The hazard is wrapping the starred value in a promise, since `*promise` fails at unpacking. Test `with lazify:` over all four new comprehension forms.
 2. **`autocurry` and `tailtools` over the same forms.** Same question, same reason; `tailtools.py:1011,1026` already reasons about `Starred` in a different context.
 
@@ -4,7 +4,7 @@ description = "Supercharge your Python with parts of Lisp and Haskell."
 authors = [
     { name = "Juha Jeronen", email = "juha.m.jeronen@gmail.com" },
 ]
-requires-python = ">=3.10,<3.15"
+requires-python = ">=3.10,<3.16"
 
 # the `read` function and long_description_content_type from setup.py are no longer needed,
 # modern build tools like pdm/hatch already know how to handle markdown if you point them at a .md file
@@ -38,6 +38,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
     "Topic :: Software Development :: Libraries",
@@ -96,6 +97,12 @@ exclude = [
     "build",
     "dist",
     ".venv",
+    # PEP 798 comprehension unpacking, which ruff 0.15.10 cannot handle, and a syntax
+    # error cannot be silenced with `# noqa`. Two separate obstacles: it rejects the
+    # list form as too new for `target-version` above, and it cannot parse the dict,
+    # set and generator forms at all ("Expected `}`, found `for`"). Retry dropping
+    # this once ruff both parses those and is told a new enough target.
+    "unpythonic/syntax/tests/test_comprehension_unpacking_3_15.py",
 ]
 
 [tool.ruff.lint]
 
@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+"""The macros pass through Python 3.15's new comprehension unpacking (PEP 798).
+
+These tests require Python 3.15+ because the unpacking syntax won't parse on
+earlier versions.
+
+`lazify`, `autocurry` and `tco` have no comprehension-specific handling, so the
+new forms reach their generic paths. Two shapes are new there: a `Starred` in the
+element position of a list/set/generator comprehension, and a `DictComp` whose
+`value` is `None` because the mapping expression sits in `key` instead.
+
+The hazard worth guarding against is specific to `lazify`: if it wrapped the
+starred value in a promise, `*promise` would fail at unpacking. It does not, and
+these tests are here to keep it that way — the existing suite cannot catch a
+regression here, since nothing else in it contains this syntax.
+
+TODO: Merge into the per-macro test modules when the floor bumps to Python 3.15+.
+"""
+
+from ...syntax import macros, test, the  # noqa: F401
+from ...test.fixtures import session, testset
+
+from ...syntax import macros, lazify, autocurry, tco  # noqa: F401, F811
+
+
+def _items(k):
+    return [k, k]
+
+
+def _mapping(k):
+    return {k: k}
+
+
+with lazify:
+    def lazy_starred_list(ks):
+        return [*_items(k) for k in ks]
+
+    def lazy_starred_set(ks):
+        return {*_items(k) for k in ks}
+
+    def lazy_starred_genexpr(ks):
+        return list((*_items(k) for k in ks))
+
+    def lazy_dict_unpacking(ks):
+        return {**_mapping(k) for k in ks}
+
+    def lazy_ordinary_dictcomp(ks):
+        return {k: _items(k) for k in ks}
+
+
+with autocurry:
+    def curried_starred_list(ks):
+        return [*_items(k) for k in ks]
+
+    def curried_dict_unpacking(ks):
+        return {**_mapping(k) for k in ks}
+
+
+with tco:
+    def tco_starred_list(ks):
+        return [*_items(k) for k in ks]
+
+    def tco_dict_unpacking(ks):
+        return {**_mapping(k) for k in ks}
+
+
+def runtests():
+    with testset("lazify: starred comprehension elements"):
+        test[lazy_starred_list([1, 2]) == [1, 1, 2, 2]]
+        test[lazy_starred_set([1, 2]) == {1, 2}]
+        test[lazy_starred_genexpr([1, 2]) == [1, 1, 2, 2]]
+
+    with testset("lazify: dict-unpacking comprehension"):
+        test[lazy_dict_unpacking([1, 2]) == {1: 1, 2: 2}]
+        # Control: the `k: v` form goes through the `value` field the unpacking
+        # form leaves empty, so this catches a fix that skipped that field.
+        test[lazy_ordinary_dictcomp([1, 2]) == {1: [1, 1], 2: [2, 2]}]
+
+    with testset("autocurry: new comprehension forms"):
+        test[curried_starred_list([1, 2]) == [1, 1, 2, 2]]
+        test[curried_dict_unpacking([1, 2]) == {1: 1, 2: 2}]
+
+    with testset("tco: new comprehension forms"):
+        test[tco_starred_list([1, 2]) == [1, 1, 2, 2]]
+        test[tco_dict_unpacking([1, 2]) == {1: 1, 2: 2}]
+
+
+if __name__ == '__main__':  # pragma: no cover
+    with session(__file__):
+        runtests()