https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

cibuildwheel v1.12.0 does not have cp27 manylinux images for
aarch64, so restrict the 2.7 build step to x86_64 only.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

Expand the module state struct to hold ALL constants (string literals,
RawJSONType, JSONDecodeError, JSON_itemgetter0) in addition to the
heap type objects already there.

Thread state through all functions using local shadow variables that
override the file-scope globals on 3.13+, minimizing changes to
function bodies. Utility functions (raise_errmsg, join_list_unicode,
_encoded_const, is_raw_json, scanstring_unicode) get extra parameters
on 3.13+ with convenience macros at call sites.

Add module_ref (strong ref to owning module) to PyScannerObject and
PyEncoderObject for accessing per-module state from any scanner or
encoder method.

Use PyType_FromModuleAndSpec to bind heap types to their module.
Initialize all constants in module_exec instead of init_constants().

Pre-3.13 code path remains completely unchanged.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

The workflow was refactored to split builds by architecture, which
changed the job names. Add gate jobs that aggregate the new granular
jobs under the old names expected by branch protection rules:
- "Build wheels on ubuntu-latest" (also gates on free-threading + pure python tests)
- "Build wheels on windows-latest"
- "Build wheels on macos-latest"

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

Now that the C extension declares Py_MOD_GIL_NOT_USED and has heap
types + per-module state, the speedups are safe to use on 3.14t. The
is_gil_enabled() guard was only a temporary workaround while the C
extension was unsafe under free-threading.

Removing the guard means _speedups is actually loaded and exercised
on cp314t in CI, which is what we need to be testing.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

The previous commit removed file-scope statics like JSON_NaN,
JSON_Infinity, JSON_NegInfinity, JSONDecodeError, etc. but missed
that the Python 2 scanner code paths reference some of them
directly as bare names.

Fixes for Python 2:
- Rename raise_errmsg() function to raise_errmsg_impl() so a Python
  2-only macro can re-introduce the 3-arg form, transparently pulling
  JSONDecodeError from _speedups_static_state. All existing
  raise_errmsg(msg, s, end) call sites in Python 2 scanner functions
  keep working without modification.
- Add a shadow block at the top of scan_once_str (Python 2 only) for
  JSON_NaN, JSON_Infinity, JSON_NegInfinity, mirroring the pattern
  used by scan_once_unicode.

Verified: all 153 tests still pass with C speedups on Python 3.11.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

Previously PyScannerType and PyEncoderType lived in the struct only
on 3.13+. On pre-3.13 they stayed as file-scope statics referenced
directly via &PyScannerType. That left the state struct layout
slightly different across versions for no real reason.

Now the type fields are always in the struct. On pre-3.13 they
hold borrowed pointers to the (eternal) static PyTypeObject
instances. No refcounting or GC tracking is needed — static types
live forever — but the struct layout is fully uniform.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

Two regressions from bumping cibuildwheel 3.2.1 -> 3.4.1:

1. cibuildwheel 3.4.1 ships a newer bundled virtualenv that fails to
   bootstrap Python 3.8 on Windows, so cp38-win32 and cp38-win_amd64
   builds crash during virtualenv creation. Python 3.8 has been EOL
   since October 2024, and skipping it on Windows only (rather than
   all platforms) minimizes the impact on existing users.

2. The previous CIBW_SKIP: 'pp*' line was accidentally dropped when
   splitting the matrix by architecture. PyPy wheels were never part
   of the release set -- PyPy is covered by the test_pure_python job.

This is purely a CI environment fix; no code changes.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

- Remove CIBW_ENABLE: 'cpython-freethreading'. cibuildwheel warns
  that this option is deprecated and should be removed; in 3.4+
  free-threaded builds are the default for cp313t/cp314t.
- Revert the cp38-win* skip; the Windows failure was a timeout,
  not a Python 3.8 virtualenv issue as I previously assumed.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

Two new test files, kept separate from test_speedups.py because
they exercise Python runtime features (concurrent threads,
subinterpreters) rather than C-extension internals:

simplejson/tests/test_free_threading.py (TestFreeThreading)
- test_concurrent_encode / test_concurrent_decode: 8 threads x 500
  iterations each, verifying stable output
- test_concurrent_encode_decode: mixes encode and decode on the
  same data across threads
- test_shared_encoder_instance: a single JSONEncoder and
  JSONDecoder instance used by many threads

These pass with the GIL enabled, but exist to catch data races on
free-threaded builds (PEP 703). The test_free_threading CI job
runs them with PYTHON_GIL=0 on 3.14t.

simplejson/tests/test_subinterpreters.py (TestSubinterpreters)
- import, encode, decode in a fresh subinterpreter
- multiple subinterpreters used concurrently
- destroying one subinterpreter while another still uses the module
- heap types stay heap types inside a subinterpreter (3.13+)

Skipped on Python < 3.12 (subinterpreters require PEP 684).

CI workflow (.github/workflows/build-and-deploy.yml):
- New 'Verify Python is a free-threaded build' step in the
  test_free_threading job asserts sysconfig.Py_GIL_DISABLED == 1,
  so the job fails loudly if setup-python ever gives us a
  GIL-enabled build under the 3.14t moniker.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

Helper functions that previously took individual state fields as
arguments now take a single _speedups_state pointer and dereference
what they need:

- raise_errmsg_impl(msg, s, end, state)
- _encoded_const(obj, state)
- is_raw_json(obj, state)
- join_list_unicode(lst, state)
- scanstring_unicode(..., state)

The convenience macros RAISE_ERRMSG, ENCODED_CONST, IS_RAW_JSON,
JOIN_LIST_UNICODE, SCANSTRING_UNICODE are now pointless pass-throughs
and are deleted. Call sites use the function names directly.

Caller functions no longer need per-field shadow declarations
(PyObject *JSON_s_null = _st->JSON_s_null; etc.). They only need
the _st pointer itself, which is passed through.

JSON_Accu now stores the state pointer instead of a borrowed
empty_unicode reference, keeping the struct version-independent
and letting flush_accumulator pass state to join_list_unicode
directly.

The Python 2 raise_errmsg macro shim remains but is simpler:
it now passes &_speedups_static_state instead of resolving
JSONDecodeError at the macro site.

Net: 130 lines removed, 78 added. All 163 tests still pass.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

Three polish items after the state-based helper refactor:

1. Rename all local _speedups_state pointers from '_st' to 'state'
   for consistency with the parameter name used in helper signatures.

2. Rename raise_errmsg_impl back to raise_errmsg. This required
   updating every Python 2 scanner function (scanstring_str,
   _parse_object_str, _parse_array_str, _match_number_str,
   scan_once_str, py_scanstring) to thread 'state' explicitly
   instead of relying on a macro shim that resolved state from
   the static instance. scanstring_str and join_list_string grew
   an explicit state parameter. The Python 2 raise_errmsg macro
   is gone.

3. Remove the state field from JSON_Accu. JSON_Accu_Init is back
   to taking just the accu, and state flows through
   JSON_Accu_Accumulate, JSON_Accu_FinishAsList, flush_accumulator,
   and _steal_accumulate as an explicit parameter. The encoder
   call sites already had state in scope, so the extra arg is
   free.

Net diff: 129 deletions, 127 additions. All 163 tests still pass.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

Context/environment arguments are conventionally placed first, not
last. Reorder every helper that takes _speedups_state so that
state is the first parameter:

- raise_errmsg(state, msg, s, end)
- _encoded_const(state, obj)
- is_raw_json(state, obj)
- join_list_unicode(state, lst)
- join_list_string(state, lst)
- scanstring_unicode(state, pystr, end, strict, next_end_ptr)
- scanstring_str(state, pystr, end, encoding, strict, next_end_ptr)
- flush_accumulator(state, acc)
- JSON_Accu_Accumulate(state, acc, unicode)
- JSON_Accu_FinishAsList(state, acc)
- _steal_accumulate(state, accu, stolen)

init_speedups_state(state, module) already had state first.

Pure reordering: 106 insertions, 106 deletions. All 163 tests pass.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

actions/setup-python@v5 automatically resolves to the latest v5.x
release (currently v5.6.0), so the exact pin is unnecessary. This
matches the convention on master.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

Three warnings flagged by -Wshadow (pre-existing, not from the
free-threading refactor, but easy to fix):

- scanstring_unicode: local 'digit' shadowed the 'digit' type
  from Python's longintrepr.h. Renamed to 'hex_digit' (4 sites
  across the Python 2 and Python 3 hex-decoding loops).

- encoder_listencode_obj: inner 'PyObject *newobj' declaration
  shadowed an outer one. The outer variable is reused by the
  inner block; the earlier branches that use it (for_json,
  _asdict) always DECREF before falling through, so it's safe
  to drop the inner redeclaration.

The extension now compiles cleanly under -Wall -Wextra -Wshadow
-Wstrict-prototypes with no new warnings.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

Builds CPython 3.14.0 from source with --with-pydebug, caches the
install prefix (~10 min first run, ~10 sec on cache hit), and runs
the test suite against it. This catches:

- Refcount leaks (via TestRefcountLeaks, auto-enabled when
  sys.gettotalrefcount is present)
- Py_DECREF asserts, NULL-pointer dereferences, and internal
  consistency checks that release builds skip
- Shadow/strict warnings (-Wall -Wextra -Wshadow -Werror)

Stock Ubuntu python3-dbg only offers 3.12, and neither
actions/setup-python nor the deadsnakes PPA ships -dbg packages
for 3.13/3.14, so building from source (with caching) is the
only route to a 3.14 debug interpreter.

New simplejson/tests/test_speedups.py::TestRefcountLeaks covers:
- dumps / loads round-trip
- Scanner / Encoder construction
- Error paths in scanner_new / encoder_new (module_ref release)

The class is guarded by @skipUnless(hasattr(sys, 'gettotalrefcount'))
so it's inert on release builds and skips silently.

gate_ubuntu now depends on test_debug_build so the aggregate job
used by branch protection waits for it too.

TSan and a suppression-clean valgrind run would both require
further custom CPython builds and remain future work.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

3.14.4 is the latest stable release.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

…tring_bitcount

The Python 3.14 debug CI failure was -Werror=shift-negative-value on
this line in encoder_new:

    s->min_long_size = PyLong_FromLongLong(-1LL << n);

Left-shifting a negative value is undefined behavior in C. It was
latent before because no prior build used -Wextra + -Werror, but it's
an actual bug. Fixed by computing -(2^n) as:

    -(long long)((1ULL << n) - 1ULL) - 1LL

which stays defined for the whole n in 1..63 range and produces
LLONG_MIN at n == 63 (the boundary case). Verified with
int_as_string_bitcount = 1, 8, 32, 62, 63 that the boundary values
stringify correctly.

CI: switch test_debug_build from building CPython 3.14.4 from
source (~8 min cold) to `uv python install cpython-3.14.4+debug`,
which pulls a prebuilt debug interpreter from python-build-standalone
in under 10 seconds. No cache dance, no apt build-deps, no sudo.

Also bring back -Werror + -Wshadow + -Wstrict-prototypes on the
debug build now that the shift-negative-value bug is fixed.

No YAML changes needed for the earlier action bumps: upload-artifact
v4->v7 and download-artifact v4->v8 didn't rename or remove any
inputs we use (name, path, merge-multiple all still work).

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

v8.0.0 is the newest setup-uv release but the floating v8 tag has
not been published yet, so @v8 fails to resolve. Pinning to the
exact tag.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

REQUIRE_SPEEDUPS only affects setup.py's build fallback behavior -
it's a no-op on test invocations. If a built _speedups.so happens
to be importable but c_make_encoder/c_make_scanner don't get wired
into simplejson.encoder/simplejson.scanner (e.g. missing export,
stale cached .so), the test suite's TestMissingSpeedups silently
skipTest()s instead of failing CI.

Add explicit wiring checks to both test_free_threading and
test_debug_build that verify:
  simplejson.encoder.c_make_encoder is _speedups.make_encoder
  simplejson.scanner.c_make_scanner is _speedups.make_scanner

If either fails the job fails loudly instead of silent-skipping
every C-extension test.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

test_boundary_at_max_bitcount exercises each of n = 1, 8, 31, 32, 62,
63 with values at and just inside +/- 2**n. The n = 63 case is the
regression test for the -Wshift-negative-value UB I fixed earlier
in encoder_new; if anyone ever reintroduces -1LL << n the LLONG_MIN
boundary case will fail this test instead of silently misbehaving.

The test uses the full +/- 2**n range including the sign bit position
(n = 63), which is precisely where the old computation was undefined.

(I also considered a TestRefcountLeaks.test_module_reload_no_leak for
the init_speedups_state reload-safety fix, but CPython's import
machinery caches extension modules for normal reload and the only
scenario that actually re-runs module_exec on pre-3.13 is a
subinterpreter import on 3.5-3.11, which I can't drive from a
unit test portably. The fix is kept as defense-in-depth.)

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

python-build-standalone ships both cpython-3.14.4+debug and
cpython-3.14.4+freethreaded+debug, so add a matrix dimension to the
test_debug_build job and run both. The free-threaded variant stacks
three coverage modes in a single job:

- Debug interpreter (refcount asserts, TestRefcountLeaks active)
- Free-threading (Py_GIL_DISABLED=1, GIL can be disabled)
- Strict compile warnings (-Wall -Wextra -Wshadow -Werror)

For the free-threaded variant we additionally:
- Assert sysconfig.Py_GIL_DISABLED == 1 so a regression in the
  python-build-standalone asset naming can't silently give us a
  GIL-enabled debug build
- Run the test suite again with PYTHON_GIL=0 to surface any data
  races that the GIL was still papering over

Verified locally against cpython-3.14.4+freethreaded+debug: 344 tests
pass both with the GIL on and with PYTHON_GIL=0, clean compile with
full strict warnings.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

join_list_string used a function-local static PyObject *joinfn to
cache the bound method for ''.join on first call. Move it into
_speedups_state as JSON_EmptyStr_join, populated in
init_speedups_state alongside JSON_EmptyStr and released in
reset_speedups_state_constants.

Python 2 only, so no behavioral change on modern Python. Now
consistent with every other cached object in the module, and
init_speedups_state fails eagerly if the .join lookup fails at
module load time instead of on the first call site.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

Factor the four _str/_unicode function pairs out of _speedups.c and
into a new templated header, _speedups_scan.h, that's #included twice
from _speedups.c with different macro settings: once for the unicode
variant (used by all Python 3 and Py2 unicode input) and once more on
Python 2 for the bytes variant.

The two variants only ever differed in:
- Character read: PyString byte vs PyUnicode_READ codepoint
- Data/length accessors: PyString_AS_STRING / PyString_GET_SIZE vs
  PyUnicode_DATA / PyUnicode_GET_LENGTH (+ PyUnicode_KIND)
- scanstring call: the str path passes an extra `encoding` arg
- Number fast paths: _str uses PyOS_string_to_double + PyInt_FromString
  on the underlying char buffer; _unicode goes through the
  parse_int / parse_float callables (with a PyFloat_FromString
  fast path). Factored into four small inline helpers
  (_match_number_{float,int}_fast_{str,unicode}).
- numstr substring creation: PyString_FromStringAndSize vs
  PyUnicode_Substring (or PyUnicode_FromUnicode on Py2 narrow)

Everything else -- the whole decode state machine, the error paths,
the recursion guards, the memoization -- is shared. 951 lines of
duplicated code removed from _speedups.c, 514 lines added in
_speedups_scan.h, for a net diff of -368 lines and one authoritative
source of truth for the parser logic.

scanstring_str and scanstring_unicode are intentionally NOT templated:
scanstring_str has Py2-specific hybrid return-type logic (bytes when
input is ASCII-only, unicode otherwise) that's structurally different
from the unicode path. That duplication remains as future work.

Verified on release Python 3.11 (169 tests) and on Python 3.14.4
debug + free-threaded debug under strict compile warnings
(-Wall -Wextra -Wshadow -Wstrict-prototypes -Werror). Py2 is
verified by inspection only since Py2 isn't available locally;
the macro expansion is straightforwardly equivalent to the deleted
_str functions.

Build wiring:
- setup.py lists _speedups_scan.h in Extension.depends so changes
  trigger a rebuild
- MANIFEST.in includes simplejson/*.h so the header ships in sdist

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

cibuildwheel v3.x disables PyPy by default and v3.4 errors out with
'Invalid skip selector: "pp*". This selector matches a group that
wasn't enabled.' when you explicitly skip it. Remove the line from
the v3.4.1 step.

The Python 2.7 step still needs CIBW_SKIP 'pp*' because it uses
cibuildwheel v1.12.0, which builds PyPy by default.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

The scanstring_str template macro referenced a local `encoding` variable
that was only declared in _parse_object_str (via the now-removed
JSON_SCAN_MAYBE_ENCODING_DECL). scan_once_str and, by inheritance, any
other function that used the JSON_SCAN_SCANSTRING_CALL macro didn't
declare `encoding`, so the _str template expansion referenced an
undefined identifier on Py2 builds.

Original scan_once_str side-stepped this by passing
PyString_AS_STRING(s->encoding) inline at the call site. Copy that
pattern into the JSON_SCAN_SCANSTRING_CALL macro so every _str
template expansion resolves `encoding` lookups via `s->encoding`
directly. The JSON_SCAN_MAYBE_ENCODING_DECL macro and its single
use in _parse_object become unnecessary and are deleted.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

…type checks, cached attribute names

Five small improvements from the post-refactor review:

1. Fix -Wdeclaration-after-statement at two sites:
   - get_speedups_state wraps its 3.13+ path in an inner block so
     `void *state = PyModule_GetState(module);` is at the top of a
     scope (mixed-decl-and-code blocker was my earlier assert(module)
     statement preceding the declaration).
   - maybe_quote_bigint declares `int ge, le;` at the top instead of
     interleaving.
   The file is now clean under -Wdeclaration-after-statement so it
   can be built against strict C89 too.

2. Consolidate duplicated test helpers. has_speedups() and
   skip_if_speedups_missing() were defined verbatim in
   test_speedups.py, test_free_threading.py, and test_subinterpreters.py.
   Moved to simplejson/tests/_helpers.py and imported from all three.

3. Drop trailing semicolons from the PyObject_CallNoArgs and
   PyObject_CallOneArg compat macros. The stray `;` made
   `return PyObject_CallOneArg(...)` expand to a statement followed
   by a null statement, which worked but was sloppy and would break
   inside expression contexts.

4. Remove the static `PyTypeObject PyScannerType` / `PyEncoderType`
   tentative forward declarations on pre-3.13. The four type-check
   macros now route through `_speedups_static_state.PyScannerType`
   etc, which matches the 3.13+ pattern of looking up the type via
   state. module_exec still sets `state->PyScannerType = (PyObject *)
   &PyScannerType` using the full static type body defined later in
   the file; no forward decl needed because the bodies come before
   module_exec in source order.

5. Cache hot-path attribute names in module state. Every call to
   _call_json_method used to call PyObject_GetAttrString("for_json")
   or "_asdict" which interned the C string on each call. Similarly
   encoder_dict_iteritems did GetAttrString("sort") per sorted dict,
   and encoder_listencode_obj did GetAttrString("encoded_json") per
   RawJSON value. Added four new state fields (JSON_attr_for_json,
   JSON_attr_asdict, JSON_attr_sort, JSON_attr_encoded_json),
   initialized once via JSON_InternFromString, visited/cleared as
   usual. _call_json_method now takes a PyObject * instead of
   const char * and uses PyObject_GetAttr directly. The old
   FOR_JSON_METHOD_NAME and ASDICT_METHOD_NAME #defines are gone.

Verified: 169 tests on Python 3.11 release, 342 on 3.14.4 debug,
344 on 3.14.4 free-threaded debug (both GIL on and PYTHON_GIL=0),
all under -Wall -Wextra -Wshadow -Wstrict-prototypes -Werror.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

Collects the things that aren't obvious from reading the source but
that come up repeatedly when working on this project:

- How to get alternate Python variants (debug, free-threaded debug)
  via uv + python-build-standalone in ~10 seconds instead of
  building CPython from source
- Why _cibw_runner must be used instead of unittest discover (it
  re-runs the suite with speedups disabled to exercise the pure-
  Python path)
- No local way to test Py2.7 and the implied feedback-loop cost
- CI raw logs require admin perms; debugging workflow when only the
  step annotation is visible
- cibuildwheel v3 vs v1.12 PyPy default-enable differences
- Extension module reload doesn't actually re-run module_exec
- Refcount leak tests on 3.14 debug need a two-phase measurement
- Python 3.14 release adds -Wunreachable-code to default CFLAGS
- _speedups_scan.h is #included twice and relies on #undef cleanup
- Don't Py_CLEAR type fields in reset_speedups_state_constants
- REQUIRE_SPEEDUPS only affects setup.py, not tests; hence the
  explicit wiring check in test_free_threading / test_debug_build
- GH Actions floating v8 tag for setup-uv doesn't exist (yet)
- Test helpers are in simplejson/tests/_helpers.py

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

…cro, encoder format string, more

Eight assorted improvements from the second post-refactor review:

1. Delete the unused PY3_UNUSED macro (defined twice under
   PY_MAJOR_VERSION, never referenced anywhere).

2. Merge the `static\nPyTypeObject Foo = {` two-line header into
   one line for the pre-3.13 type bodies. Purely cosmetic.

3. Extract encoder_steal_encode() helper for the for_json / _asdict
   recursive-encode dance. Both paths in encoder_listencode_obj were
   ~12 lines of repeated "check newobj != NULL, Py_EnterRecursiveCall,
   recurse, Py_DECREF, Py_LeaveRecursiveCall" boilerplate. The
   helper takes an as_dict flag to select between encoder_listencode_
   obj (for_json) and encoder_listencode_dict + TypeError-on-non-dict
   (_asdict). The two call sites collapse to one line each.

4. Scanner_new grew a local LOAD_ATTR(field, name) macro that
   consolidates the "getattr or goto bail" pattern into a single
   line per attribute, replacing 7 three-line blocks with 6
   one-line loads (the encoding attr still has its own handling
   because it goes through JSON_ParseEncoding).

5. encoder_new's 20-char "OOOOOOOOOOOOOOOOOOOO:make_encoder" format
   string is now built from per-argument pieces, each on its own
   line with a comment naming the parameter. Adding/removing an
   encoder argument now touches one line instead of requiring a
   mental count of O's in a string literal.

6. JSON_Accu_Destroy gained a comment documenting that it's safe to
   call after JSON_Accu_FinishAsList (which already cleared
   small_strings and transferred large_strings).

7. maybe_quote_bigint inverted its top-level condition for an early
   return on the common "int_as_string_bitcount is None" fast path,
   reducing the nested indentation for the whole function body.
   Also dropped an intermediate `encoded = quoted;` assignment in
   favor of a direct `return quoted;`.

8. _speedups_scan.h now requires the caller to `#define
   JSON_SPEEDUPS_SCAN_INCLUDING 1` before #include and `#undef` it
   after. Accidentally including the template file from anywhere
   other than _speedups.c (or forgetting the setup preamble) is
   now a hard #error. Added an example block to the file header.

Verified: 169 tests on Python 3.11 release, 344 on 3.14.4 debug,
344 on 3.14.4 free-threaded debug (both GIL on and PYTHON_GIL=0),
all under -Wall -Wextra -Wshadow -Wstrict-prototypes -Werror.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95

… note

Item A: encoder_listencode_dict key_memo cache was storing non-string
key encodings under `key` (original) while looking them up under
`kstr` (stringified form), so the cache was write-only for int / bool
/ Decimal / float keys. The pre-existing comment already said
"Only cache the encoding of string keys" — the code now matches
intent: take the cache branch only when key is a str (or bytes on
Py2), otherwise encode straight through without touching key_memo.
Pure efficiency fix; output is byte-for-byte identical, and output
tests for string, int, bool, mixed, float, and Decimal keys verify
the branch split.

Item B: six new TestRefcountLeaks subtests exercise error paths
that the previous cleanup batches touched:

  - test_circular_reference_no_leak: ValueError mid-encode must not
    leak the markers entry or the ident PyLong.
  - test_asdict_returning_non_dict_no_leak: the TypeError path in
    encoder_steal_encode must release the stolen newobj.
  - test_for_json_raising_no_leak: exception inside the for_json()
    body must not leak the method binding.
  - test_non_string_dict_keys_no_leak: exercises the new non-cached
    key_memo branch from item A.
  - test_bigint_as_string_no_leak: maybe_quote_bigint's quoted-return
    path must release the replaced `encoded`.

All six pass on cpython-3.14.4+debug with phase2 delta within the
100-ref tolerance.

Item I: AGENTS.md "Useful CFLAGS combinations" now documents that
-Wdeclaration-after-statement trips on cp314t's own refcount.h
(mixed decls + code around line 113) and can only be used against
the standard and standard-debug builds.

https://claude.ai/code/session_01EoWzUsmRRvrZBF2nwQhF95