salix 0.1.0a1__tar.gz

salix-0.1.0a1/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+- Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+- The use of sexualized language or imagery, and sexual attention or advances
+  of any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards
+of acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for
+moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+jphutchins@gmail.com. All complaints will be reviewed and investigated
+promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external
+channels like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited
+interaction with those enforcing the Code of Conduct, is allowed during this
+period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

salix-0.1.0a1/LICENSE

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

salix-0.1.0a1/MANIFEST.in

@@ -0,0 +1,10 @@
+include CODE_OF_CONDUCT.md
+include build_config.py
+recursive-include src *.h
+
+# A workspace member directory that ships without its pyproject.toml makes the
+# sdist uninstallable under uv. The members are development scopes; an sdist
+# exists to build the wheel.
+prune bench
+prune tests
+prune tools

salix-0.1.0a1/PKG-INFO

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: salix
+Version: 0.1.0a1
+Summary: A C-backed, inheritable Struct base class for Python — fast import, fast type creation
+Author-email: JP Hutchins <jphutchins@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/JPHutchins/salix
+Project-URL: Issues, https://github.com/JPHutchins/salix/issues
+Keywords: struct,dataclass,slots,frozen,immutable,import-time,free-threading,c-extension
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: C
+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: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Free Threading :: 3 - Stable
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# salix
+
+A C-backed, inheritable `Struct` base class for Python, for programs that pay
+for their imports.
+
+```python
+>>> from salix import Struct
+
+>>> class Point(Struct):
+...     x: float
+...     y: float = 0.0
+
+>>> Point(1.0, 2.0)
+Point(x=1.0, y=2.0)
+
+```
+
+## Install
+
+```sh
+pip install salix
+```
+
+`nix/python-targets.nix` is the wheel matrix — Windows, macOS, and glibc
+Linux on x86_64 and arm64, across the supported CPythons — and wheels are
+published for its cells once the interpreter's ABI is frozen. A pre-release
+interpreter's wheels are built and tested but held back until its rc, and a
+configuration missing from the matrix has no wheel. salix supports CPython
+3.10 through 3.15, including the free-threaded builds. On a machine PyPI has
+no wheel for, pip compiles the sdist — which needs setuptools and a C
+compiler — except on Windows, where MSVC cannot compile this source. PyPy
+and GraalPy satisfy the version floor and have no wheels, and whether the
+sdist builds there is untested.
+
+## What salix is and is not
+
+A struct's fields are the annotated names of its class body, and the
+constructor takes them in that order. Instances are frozen by default: reads,
+value equality, hashing, and a repr come with the class; writes do not.
+A body-written `__init__` — inherited or not, and not `object.__init__` —
+replaces the field constructor; writing `object.__init__` back restores the
+generated one, and on a frozen struct the body fills fields with `set_field`
+(see Caching a computed value — the example there runs in `__post_init__`),
+since assignment raises. Inheritance extends the field list
+— a subclass adds its fields after its base's — and the metadata reads back:
+`_struct_fields_`,
+`_struct_defaults_`, `_struct_annotations_`, and `_struct_metadata_`, with
+`__`-prefixed spellings of the same four names answering the same values.
+
+The keywords opt out of the defaults. `frozen=False` opens the record for
+writes and drops the hashing — under the default `eq=True` a writable struct
+is unhashable, and a body `__hash__` still stands. `eq=False` drops the value
+equality and hashing, leaving identity — the exceptions are named in Caching
+a computed value. `order=True` adds the field-order comparisons and requires
+`eq=True`. `repr`, `match_args`, and `weakref` default to `True`, `True`, and
+`False` and stand in for the `__repr__`, the pattern-matching signature, and
+the `__weakref__` slot. The six are consumed by the machinery; a class keyword
+it does not own reaches `__init_subclass__` in the usual way, and one the
+hierarchy does not claim still fails the class.
+
+salix is not the libraries that do more. `dataclasses` builds the same record
+in pure Python. `attrs` layers converters, validators, and a plugin ecosystem
+on top. `NamedTuple` is the tuple-shaped predecessor. `msgspec` is a
+serialization library whose `Struct` validates. salix does the record and
+nothing else — no serialization, no field-value validation, no coercion — in
+C, which is where its import and type-creation times come from. Programs that
+need those features need those libraries; salix is for the ones that only
+need the record. `salix/__init__.pyi` is the whole of the API.
+
+## Defaults
+
+An empty default of `list`, `dict`, `set`, or `bytearray` is copied per
+instance, not shared:
+
+```python
+>>> from salix import Struct
+
+>>> class Box(Struct):
+...     items: list = []
+
+>>> left, right = Box(), Box()
+>>> left.items.append("left")
+>>> right.items
+[]
+
+```
+
+A default of the four (and their subclasses) is copied per instance: a
+non-empty one is deep-copied, so an inner list in `x: tuple = (1, [])` is
+not shared, and an empty one copies through the declared type's own
+constructor (seeded with a base copy, so the constructor cannot retain or
+mutate the class-body object), preserving a subclass and falling back to a
+base-type copy when the constructor signature is not the iterable one — a
+`defaultdict` falls back and becomes a plain `dict`, its factory dropped.
+A value a deepcopy cannot carry (a writable memoryview — one uncarryable
+element shares the whole container) or one whose hash fails by recursing
+falls back to sharing the declared object. A type outside
+the four that declares `__hash__ = None` is shared. A field without a
+default cannot
+follow one that has it: append defaulted fields, or default the new field
+too. For the four, `__struct_defaults__` holds the
+class's own copy, severed from whatever the class body named: appending to
+the module-level object afterwards does not reach the class. The getters hand
+the stored objects out, not copies: do not mutate what `__struct_defaults__`
+returns.
+
+## ClassVar and InitVar
+
+A name annotated `ClassVar[...]` at the top level is a class variable:
+with an assigned value it is kept in the class dict and excluded from
+the field plan, the constructor, and every metadata table; without one
+it is refused, because a class variable is a constant. An inherited
+field name stays a field: the inheritance rule outranks the ClassVar
+annotation, so re-annotating one re-declares the field. `InitVar[...]`
+is refused, and so is a `ClassVar` nested inside another annotation.
+A protocol is satisfied structurally, never inherited: a struct may not
+list a Protocol among its bases, because the two metaclasses conflict.
+The check walks the annotation's forms when it arrives as an object;
+when it arrives as source text — a quoted string, or a
+future-annotations string — the check is a spelling match, and the two
+paths differ at the edges:
+
+| annotation | object path | text path |
+| --- | --- | --- |
+| an alias of `ClassVar`, `CV[int]` | the form itself: kept with a value, refused without | accepted; the field swallows a positional |
+| a type of yours actually named `ClassVar` | accepted | kept with a value, refused without |
+| `Annotated[int, ClassVar]` | accepted | refused, though the `ClassVar` there is metadata |
+| `Optional[Annotated[ClassVar[int], "m"]]` | refused | refused |
+
+3.14 evaluates resolvable annotations by default, so there the alias
+reaches the object path and is the form; a name whose root cannot be
+resolved arrives as an object too, and is accepted, while any other
+evaluation error still fails the class. Every row is pinned in
+`tests/test_classvar_paths.py`.
+
+## Caching a computed value
+
+`functools.cached_property` caches into an instance `__dict__`; a struct has
+none unless a non-struct base carries one, and without one a slotted
+dataclass refuses it the same way. Two answers: `functools.cache` on the
+method, or a field that `__post_init__` fills:
+
+```python
+>>> import functools
+>>> from salix import Struct, set_field
+
+>>> class Computed(Struct):
+...     x: int
+...
+...     @functools.cache
+...     def double(self) -> int:
+...         return self.x * 2
+
+>>> Computed(3).double()
+6
+
+>>> class Filled(Struct):
+...     x: int
+...     double: int = 0
+...
+...     def __post_init__(self) -> None:
+...         set_field(self, "double", self.x * 2)
+
+>>> Filled(4).double
+8
+
+```
+
+Under the default eq=True the method cache keys on the value, not the
+instance: value-equal structs share one entry, and a `set_field` that
+changes the value misses — the cache then holds the old entry and the new
+one. With eq=False the struct hashes by identity — unless the body defines
+its own `__eq__` without a `__hash__`, which makes it unhashable, or its
+own `__hash__`, which replaces the identity hash — and `set_field` after
+a hit returns the stale cached value while the hash is unchanged; a body
+`__hash__` over field values changes the hash and the lookup misses. The
+cache refuses an unhashable struct — anything that makes `hash()` raise:
+a body `__eq__` without a body `__hash__`, a body `__hash__` that
+refuses, `frozen=False`, an unhashable field value, or equality inherited
+from a struct base that defines `__eq__`. An `__init__` that is not
+`object.__init__` — a body-written one, inherited or not — replaces the
+constructor that runs `__post_init__`, so the field answer only works
+without one. The table and the caching behaviors above are pinned in
+`tests/test_classvar_paths.py`.
+
+## Working in the repo
+
+The contributor loop is documented in `CONTRIBUTING.md`, and community
+standards in `CODE_OF_CONDUCT.md`. `uv run camas benchmark` says what it
+costs.
+
+## License
+
+MIT

salix-0.1.0a1/README.md

@@ -0,0 +1,194 @@
+# salix
+
+A C-backed, inheritable `Struct` base class for Python, for programs that pay
+for their imports.
+
+```python
+>>> from salix import Struct
+
+>>> class Point(Struct):
+...     x: float
+...     y: float = 0.0
+
+>>> Point(1.0, 2.0)
+Point(x=1.0, y=2.0)
+
+```
+
+## Install
+
+```sh
+pip install salix
+```
+
+`nix/python-targets.nix` is the wheel matrix — Windows, macOS, and glibc
+Linux on x86_64 and arm64, across the supported CPythons — and wheels are
+published for its cells once the interpreter's ABI is frozen. A pre-release
+interpreter's wheels are built and tested but held back until its rc, and a
+configuration missing from the matrix has no wheel. salix supports CPython
+3.10 through 3.15, including the free-threaded builds. On a machine PyPI has
+no wheel for, pip compiles the sdist — which needs setuptools and a C
+compiler — except on Windows, where MSVC cannot compile this source. PyPy
+and GraalPy satisfy the version floor and have no wheels, and whether the
+sdist builds there is untested.
+
+## What salix is and is not
+
+A struct's fields are the annotated names of its class body, and the
+constructor takes them in that order. Instances are frozen by default: reads,
+value equality, hashing, and a repr come with the class; writes do not.
+A body-written `__init__` — inherited or not, and not `object.__init__` —
+replaces the field constructor; writing `object.__init__` back restores the
+generated one, and on a frozen struct the body fills fields with `set_field`
+(see Caching a computed value — the example there runs in `__post_init__`),
+since assignment raises. Inheritance extends the field list
+— a subclass adds its fields after its base's — and the metadata reads back:
+`_struct_fields_`,
+`_struct_defaults_`, `_struct_annotations_`, and `_struct_metadata_`, with
+`__`-prefixed spellings of the same four names answering the same values.
+
+The keywords opt out of the defaults. `frozen=False` opens the record for
+writes and drops the hashing — under the default `eq=True` a writable struct
+is unhashable, and a body `__hash__` still stands. `eq=False` drops the value
+equality and hashing, leaving identity — the exceptions are named in Caching
+a computed value. `order=True` adds the field-order comparisons and requires
+`eq=True`. `repr`, `match_args`, and `weakref` default to `True`, `True`, and
+`False` and stand in for the `__repr__`, the pattern-matching signature, and
+the `__weakref__` slot. The six are consumed by the machinery; a class keyword
+it does not own reaches `__init_subclass__` in the usual way, and one the
+hierarchy does not claim still fails the class.
+
+salix is not the libraries that do more. `dataclasses` builds the same record
+in pure Python. `attrs` layers converters, validators, and a plugin ecosystem
+on top. `NamedTuple` is the tuple-shaped predecessor. `msgspec` is a
+serialization library whose `Struct` validates. salix does the record and
+nothing else — no serialization, no field-value validation, no coercion — in
+C, which is where its import and type-creation times come from. Programs that
+need those features need those libraries; salix is for the ones that only
+need the record. `salix/__init__.pyi` is the whole of the API.
+
+## Defaults
+
+An empty default of `list`, `dict`, `set`, or `bytearray` is copied per
+instance, not shared:
+
+```python
+>>> from salix import Struct
+
+>>> class Box(Struct):
+...     items: list = []
+
+>>> left, right = Box(), Box()
+>>> left.items.append("left")
+>>> right.items
+[]
+
+```
+
+A default of the four (and their subclasses) is copied per instance: a
+non-empty one is deep-copied, so an inner list in `x: tuple = (1, [])` is
+not shared, and an empty one copies through the declared type's own
+constructor (seeded with a base copy, so the constructor cannot retain or
+mutate the class-body object), preserving a subclass and falling back to a
+base-type copy when the constructor signature is not the iterable one — a
+`defaultdict` falls back and becomes a plain `dict`, its factory dropped.
+A value a deepcopy cannot carry (a writable memoryview — one uncarryable
+element shares the whole container) or one whose hash fails by recursing
+falls back to sharing the declared object. A type outside
+the four that declares `__hash__ = None` is shared. A field without a
+default cannot
+follow one that has it: append defaulted fields, or default the new field
+too. For the four, `__struct_defaults__` holds the
+class's own copy, severed from whatever the class body named: appending to
+the module-level object afterwards does not reach the class. The getters hand
+the stored objects out, not copies: do not mutate what `__struct_defaults__`
+returns.
+
+## ClassVar and InitVar
+
+A name annotated `ClassVar[...]` at the top level is a class variable:
+with an assigned value it is kept in the class dict and excluded from
+the field plan, the constructor, and every metadata table; without one
+it is refused, because a class variable is a constant. An inherited
+field name stays a field: the inheritance rule outranks the ClassVar
+annotation, so re-annotating one re-declares the field. `InitVar[...]`
+is refused, and so is a `ClassVar` nested inside another annotation.
+A protocol is satisfied structurally, never inherited: a struct may not
+list a Protocol among its bases, because the two metaclasses conflict.
+The check walks the annotation's forms when it arrives as an object;
+when it arrives as source text — a quoted string, or a
+future-annotations string — the check is a spelling match, and the two
+paths differ at the edges:
+
+| annotation | object path | text path |
+| --- | --- | --- |
+| an alias of `ClassVar`, `CV[int]` | the form itself: kept with a value, refused without | accepted; the field swallows a positional |
+| a type of yours actually named `ClassVar` | accepted | kept with a value, refused without |
+| `Annotated[int, ClassVar]` | accepted | refused, though the `ClassVar` there is metadata |
+| `Optional[Annotated[ClassVar[int], "m"]]` | refused | refused |
+
+3.14 evaluates resolvable annotations by default, so there the alias
+reaches the object path and is the form; a name whose root cannot be
+resolved arrives as an object too, and is accepted, while any other
+evaluation error still fails the class. Every row is pinned in
+`tests/test_classvar_paths.py`.
+
+## Caching a computed value
+
+`functools.cached_property` caches into an instance `__dict__`; a struct has
+none unless a non-struct base carries one, and without one a slotted
+dataclass refuses it the same way. Two answers: `functools.cache` on the
+method, or a field that `__post_init__` fills:
+
+```python
+>>> import functools
+>>> from salix import Struct, set_field
+
+>>> class Computed(Struct):
+...     x: int
+...
+...     @functools.cache
+...     def double(self) -> int:
+...         return self.x * 2
+
+>>> Computed(3).double()
+6
+
+>>> class Filled(Struct):
+...     x: int
+...     double: int = 0
+...
+...     def __post_init__(self) -> None:
+...         set_field(self, "double", self.x * 2)
+
+>>> Filled(4).double
+8
+
+```
+
+Under the default eq=True the method cache keys on the value, not the
+instance: value-equal structs share one entry, and a `set_field` that
+changes the value misses — the cache then holds the old entry and the new
+one. With eq=False the struct hashes by identity — unless the body defines
+its own `__eq__` without a `__hash__`, which makes it unhashable, or its
+own `__hash__`, which replaces the identity hash — and `set_field` after
+a hit returns the stale cached value while the hash is unchanged; a body
+`__hash__` over field values changes the hash and the lookup misses. The
+cache refuses an unhashable struct — anything that makes `hash()` raise:
+a body `__eq__` without a body `__hash__`, a body `__hash__` that
+refuses, `frozen=False`, an unhashable field value, or equality inherited
+from a struct base that defines `__eq__`. An `__init__` that is not
+`object.__init__` — a body-written one, inherited or not — replaces the
+constructor that runs `__post_init__`, so the field answer only works
+without one. The table and the caching behaviors above are pinned in
+`tests/test_classvar_paths.py`.
+
+## Working in the repo
+
+The contributor loop is documented in `CONTRIBUTING.md`, and community
+standards in `CODE_OF_CONDUCT.md`. `uv run camas benchmark` says what it
+costs.
+
+## License
+
+MIT

salix-0.1.0a1/build_config.py

@@ -0,0 +1,88 @@
+import sys
+from pathlib import Path
+from typing import Final, NamedTuple
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+VERSION: Final = tomllib.loads(
+    Path(__file__).resolve().with_name("pyproject.toml").read_text(encoding="utf-8")
+)["project"]["version"]
+
+
+class BuildConfig(NamedTuple):
+    sources: tuple[str, ...]
+    c_flags: tuple[str, ...]
+
+
+BUILD: Final = BuildConfig(
+    sources=(
+        "src/salix.c",
+        "src/annotations.c",
+        "src/compare.c",
+        "src/construct/construct.c",
+        "src/construct/binding.c",
+        "src/construct/defaults.c",
+        "src/construct/exceptions.c",
+        "src/fields.c",
+        "src/hash.c",
+        "src/meta/meta.c",
+        "src/meta/bases.c",
+        "src/meta/namespace.c",
+        "src/meta/class/create.c",
+        "src/meta/class/install.c",
+        "src/meta/settle/settle.c",
+        "src/meta/settle/comparison.c",
+        "src/meta/settle/restore.c",
+        "src/mixin.c",
+        "src/mixin/copy.c",
+        "src/options.c",
+        "src/repr.c",
+    ),
+    # -Wno-unused-parameter: CPython slot signatures are fixed by the API and
+    # routinely ignore an argument.
+    # -std=c2x, not -std=c23: they select the same language mode -- both give
+    # __STDC_VERSION__ 202311 -- but c2x is accepted by GCC 9+ and Clang 9+
+    # while c23 needs GCC 14+ or Clang 18+. An sdist has to compile on whatever
+    # the machine has, and Ubuntu 24.04 LTS still ships GCC 13.
+    c_flags=(
+        f"-DSALIX_VERSION={VERSION}",
+        "-std=c2x",
+        "-O2",
+        "-Wdouble-promotion",
+        "-Wall",
+        "-Wextra",
+        "-Wno-unused-parameter",
+    ),
+)
+
+# setup.py passes these after CFLAGS, so an sdist build cannot override them.
+# One new warning in a future compiler would then turn `pip install salix` into
+# a failure, on the machines that have no wheel and must compile.
+STRICT: Final = ("-Werror",)
+
+# 84% of a published payload was DWARF that nothing on the far end reads. Not
+# in c_flags, so a local build stays debuggable.
+SHIPPED: Final = ("-g0",)
+
+
+if __name__ == "__main__":
+    import sys
+
+    match sys.argv[1:]:
+        case ["sources"]:
+            print("\n".join(BUILD.sources))
+        case ["c-flags"]:
+            print("\n".join(BUILD.c_flags))
+        case ["c-flags", "--strict"]:
+            print("\n".join(BUILD.c_flags + STRICT))
+        case ["c-flags", "--strict", "--shipped"]:
+            print("\n".join(BUILD.c_flags + STRICT + SHIPPED))
+        case ["c-flags", "--shipped", *_]:
+            raise SystemExit("build_config.py: --shipped only follows --strict")
+        case _:
+            raise SystemExit(
+                "usage: build_config.py {sources|c-flags [--strict [--shipped]]}"
+            )