jsonatapy 2.2.11__tar.gz → 2.2.12__tar.gz

{jsonatapy-2.2.11 → jsonatapy-2.2.12}/.gitignore

@@ -63,10 +63,11 @@ benchmarks/javascript/package-lock.json
 # Test artifacts
 # tests/jsonata-js/ - Now a git submodule, don't ignore
 
-# Claude Code local settings (personal per-developer permissions/config,
-# not meant to be shared across the team)
-.claude/settings.local.json
-.claude/worktrees/
+# Claude Code local state (personal per-developer permissions/config, worktrees
+# and lock files, not meant to be shared across the team). Nothing under here is
+# tracked; the previous two-line form left stray lock files showing up as
+# untracked on every `git status`.
+.claude/
 
 # Temporary files
 *.tmp

{jsonatapy-2.2.11 → jsonatapy-2.2.12}/.serena/.gitignore

@@ -1,2 +1,3 @@
 /cache
 /project.local.yml
+project.yml

{jsonatapy-2.2.11 → jsonatapy-2.2.12}/.serena/memories/conventions.md

@@ -23,10 +23,10 @@
   non-negotiable), `Result<T, E>` for fallible ops, rustdoc `///` on public APIs, comments should
   explain *deviations from JS behavior*, not restate what code does.
 - **Python style**: PEP 8 via ruff, type hints required on public APIs (mypy strict), ruff
-  double-quote/100-col formatting — no black despite CLAUDE.MD mentioning it (ruff format is
+  double-quote/100-col formatting — no black despite CLAUDE.md mentioning it (ruff format is
   what's actually configured in pyproject.toml).
 - **Test-driven against the JS suite**: the JSONata-js reference suite
   (`tests/python/test_reference_suite.py` over the `tests/jsonata-js` submodule) is the
   compatibility oracle. Any evaluator/compiler change should be checked against the FULL
-  1258-case suite, not just a hand-picked subset — subtle regressions have historically hidden
+  1686-case suite, not just a hand-picked subset — subtle regressions have historically hidden
   in low-frequency edge cases (e.g. lambda id aliasing at ~0.5% call frequency).

{jsonatapy-2.2.11 → jsonatapy-2.2.12}/.serena/memories/core.md

@@ -1,10 +1,10 @@
 ## jsonatapy: source map
 
 Rust-based Python extension implementing JSONata (JSON query/transform language), targeting
-100% compatibility with the reference `jsonata-js` v2.1.0 test suite (1258/1258 passing).
+near-100% compatibility with the reference `jsonata-js` v2.2.2 test suite (1686/1686 passing).
 Two published artifacts from one codebase: `jsonata-core` (crates.io, pure Rust) and
-`jsonatapy` (PyPI, PyO3 wrapper). See root `CLAUDE.MD` for full project charter/design goals —
-this memory only covers what CLAUDE.MD omits or what changes faster than that doc.
+`jsonatapy` (PyPI, PyO3 wrapper). See root `CLAUDE.md` for full project charter/design goals —
+this memory only covers what CLAUDE.md omits or what changes faster than that doc.
 
 ### Layout
 - `src/` — Rust crate (`jsonata-core`). Core files: `ast.rs`, `parser.rs` (+ `src/parser/README.md`),
@@ -14,7 +14,7 @@ this memory only covers what CLAUDE.MD omits or what changes faster than that do
   `signature.rs`, `lib.rs` (PyO3 Python boundary).
 - `python/jsonatapy/` — thin Python package; `__init__.py` re-exports the compiled `_jsonatapy`
   extension module and adds optional orjson-backed `json_dumps`/`json_loads`.
-- `tests/jsonata-js/` — git submodule, the upstream JS reference suite (source of the 1258 cases).
+- `tests/jsonata-js/` — git submodule, the upstream JS reference suite (source of the 1686 cases).
 - `tests/python/test_reference_suite.py` — runs the submodule's cases against the compiled extension.
 - `tests/integration_test.rs` — Rust-side integration tests (separate from inline `#[cfg(test)]`).
 - `benchmarks/` — cross-language perf comparisons (Python/JS/Rust) driving the "faster than JS" claim.

{jsonatapy-2.2.11 → jsonatapy-2.2.12}/.serena/memories/suggested_commands.md

@@ -10,7 +10,7 @@ maturin build --release      # produce a wheel in dist/
 ### Test
 ```bash
 cargo test                                              # Rust unit + tests/integration_test.rs
-uv run pytest tests/python/test_reference_suite.py       # 1258 JSONata-js reference cases (primary compat gate)
+uv run pytest tests/python/test_reference_suite.py       # 1686 JSONata-js reference cases (primary compat gate; 1686 pass)
 uv run pytest tests/python/ -v                           # full Python suite
 uv run pytest tests/python/test_functions.py::test_string_functions -v   # single test
 ```

{jsonatapy-2.2.11 → jsonatapy-2.2.12}/.serena/memories/task_completion.md

@@ -8,7 +8,7 @@ cargo fmt --check          # or `cargo fmt` to auto-fix, then verify
 cargo clippy -- -D warnings
 cargo test
 maturin develop --release  # rebuild extension so Python tests exercise the new Rust code
-uv run pytest tests/python/test_reference_suite.py   # full 1258-case JS compat suite
+uv run pytest tests/python/test_reference_suite.py   # full 1686-case JS compat suite (1686 pass)
 uv run pytest tests/python/ -v                       # rest of the Python suite
 uv run ruff check python/ tests/
 uv run mypy python/
@@ -20,4 +20,4 @@ fast path is bypassed (forcing the tree-walker) — see `mem:architecture` for h
 verified this dual-path parity.
 
 If the change is user-facing (new function, new signature, changed error), update
-`CHANGELOG.md` per Keep a Changelog format (per CLAUDE.MD).
+`CHANGELOG.md` per Keep a Changelog format (per CLAUDE.md).

{jsonatapy-2.2.11 → jsonatapy-2.2.12}/.serena/memories/tech_stack.md

@@ -1,7 +1,7 @@
 ## Tech stack
 
 - **Rust**: edition 2021, `rust-version = "1.70"` (stable channel only, no nightly features per
-  CLAUDE.MD). Crate name `jsonata-core` (lib name `jsonata_core`), cdylib+rlib.
+  CLAUDE.md). Crate name `jsonata-core` (lib name `jsonata_core`), cdylib+rlib.
 - **Key Rust deps**: `pyo3` 0.29 (optional, feature `python`), `serde`/`serde_json` (preserve_order),
   `simd-json` 0.17 (optional, feature `simd`, default-on — SIMD JSON parsing fast path),
   `indexmap` (ordered maps for JSONata objects), `regex`, `chrono`, `thiserror`, `stacker`
@@ -15,5 +15,5 @@
   mypy (strict mode), pytest (+pytest-cov, pytest-xdist for parallel runs).
 - **Benchmarking**: Criterion (Rust, `cargo bench`, `evaluator_bench`), plus Python-side
   benchmarks comparing against `jsonata` (JS) and `jsonata-rs`.
-- **Docs**: mkdocs + mkdocs-material (`docs/`, `mkdocs.yml`), not Sphinx despite CLAUDE.MD
+- **Docs**: mkdocs + mkdocs-material (`docs/`, `mkdocs.yml`), not Sphinx despite CLAUDE.md
   mentioning Sphinx — mkdocs is what's actually wired up in pyproject.toml `[project.optional-dependencies.docs]`.