cendor-squeeze 0.5.1__tar.gz

cendor_squeeze-0.5.1/.gitignore

@@ -0,0 +1,19 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+.uv/
+.ruff_cache/
+.pytest_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+.idea/
+.vscode/
+.DS_Store
+*.log
+
+# MkDocs build output (local preview only)
+site/

cendor_squeeze-0.5.1/CHANGELOG.md

@@ -0,0 +1,59 @@
+# Changelog — cendor-squeeze
+
+Format: [Keep a Changelog](https://keepachangelog.com).
+
+## [0.5.1] — 2026-06-27
+### Changed
+- Docs only: headline compression ratios are the benchmark-harness figures (`docs/benchmarks.md`: JSON ~49% / logs ~97% / code ~53% / prose ~51% on realistic corpora) — synthetic, highly-repetitive demo figures (e.g. ~94% on one repeated string) are not representative. Also clarified that `target_tokens` truncation is lossy in the emitted output but fully reversible via `handle.expand()` (the content-addressed store keeps the byte-exact original).
+
+## [0.5.0] — 2026-06-24
+### Fixed
+- **`target_tokens` is now never exceeded — for every kind, including prose.** The prose compressor always keeps its top-ranked sentence; it previously returned that sentence (and the ≤1-sentence / `fidelity="lossless"` / invalid-JSON-fallback paths) *without* truncating, so the output could blow past the budget (e.g. 23 tokens for a `target_tokens=5`). All paths now apply a final truncate. A new property test asserts `count(small) <= target` across json/logs/code/prose.
+- **The code compressor no longer corrupts string literals.** Comment stripping was a blind regex (`(?://|#).*`) that cut inside strings — `"https://example.com"` became `"https:` and `"color #ff0000"` became `"color`. It's now a string-aware, single-pass scanner (single/double/backtick quotes with escapes); `#` preprocessor directives (`#include`, `#define`, …) and `#!` shebang lines are preserved. Reversibility was always intact; now the *compressed* text is valid too.
+- **Log dedup keeps chronological order under a `target_tokens` budget.** It used to re-sort surviving lines by frequency (scrambling the timeline); it now selects the noisiest patterns to keep but renders them back in original order.
+
+### Added
+- `Handle.to_dict()` / `Handle.from_dict()` — serialize a handle (not the original) so, paired with a durable `SQLiteStore`, you can `expand()` after the process restarts. `Handle.technique` exposes the recorded technique.
+
+### Changed
+- `SQLiteStore` opens with `check_same_thread=False` (usable from a threaded server; CCR writes are idempotent) and gained `__len__` for parity with `MemoryStore`.
+- Internal truncation uses a binary search over the cut length instead of an iterative shrink — far fewer tokenizer calls on large inputs.
+
+## [0.4.3] — 2026-06-23
+### Changed
+- Packaging: `LICENSE` and `NOTICE` are now bundled in the distribution (`dist-info/licenses/`), so the Apache-2.0 terms — including the §7 warranty disclaimer and §8 liability limitation — travel inside every wheel/sdist. The README footer states the "as is" / no-warranty / use-at-your-own-risk terms. No code changes.
+
+## [0.4.2] — 2026-06-23
+### Changed
+- README repositioned around squeeze's lane: the **deterministic, zero-dependency, no-model-download** compressor that is the default backend behind contextkit's `Compressor` protocol — swap in any other backend (e.g. an ML-based compressor) via `contextkit.use_compressor(...)`. Honest, content-dependent ratio framing (see the benchmarks). No code changes.
+
+## [0.4.1] — 2026-06-23
+### Changed
+- Relicensed from MIT to Apache-2.0 — adds an explicit patent grant and contribution terms, a better fit for a public library suite.
+- README links to the docs page and CHANGELOG are now absolute GitHub URLs so they resolve on PyPI (they previously broke as repo-relative paths).
+
+## [0.4.0] — 2026-06-23
+### Added
+- Bounded CCR store: `MemoryStore(max_items=...)` evicts oldest originals (FIFO) so the store doesn't grow unbounded. Expanding an evicted handle raises `KeyError` (documented trade-off).
+
+## [0.3.0] — 2026-06-23
+### Added
+- Pluggable CCR store backends via `use_store(...)`: `store.MemoryStore` (default) and `store.SQLiteStore` (originals persist across processes, deduped by hash).
+
+## [0.2.0] — 2026-06-23
+### Added
+- `code` compressor (strip comments / blank lines; keep structure) + code detection in `kind="auto"`.
+- `fidelity` dial (`lossless` / `balanced` / `aggressive`) across json / prose / code.
+
+## [0.1.0] — 2026-06-23
+### Added
+- Initial release: `compress()`/`decompress()`/`detect()` for JSON (minify + drop nulls), logs (normalize + dedup), and prose (extractive), with a reversible `Handle`/`expand()` backed by a content-addressed store. `SqueezeCompressor` satisfies core's `Compressor`; wires into contextkit via `contextkit[squeeze]`.
+
+[0.5.0]: https://pypi.org/project/cendor-squeeze/0.5.0/
+[0.4.3]: https://pypi.org/project/cendor-squeeze/0.4.3/
+[0.4.2]: https://pypi.org/project/cendor-squeeze/0.4.2/
+[0.4.1]: https://pypi.org/project/cendor-squeeze/0.4.1/
+[0.4.0]: https://pypi.org/project/cendor-squeeze/0.4.0/
+[0.3.0]: https://pypi.org/project/cendor-squeeze/0.3.0/
+[0.2.0]: https://pypi.org/project/cendor-squeeze/0.2.0/
+[0.1.0]: https://pypi.org/project/cendor-squeeze/0.1.0/

cendor_squeeze-0.5.1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Raghav Mishra (PowerAI Labs)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

cendor_squeeze-0.5.1/NOTICE

@@ -0,0 +1,7 @@
+PowerAI Labs
+Copyright 2026 Raghav Mishra (PowerAI Labs)
+
+This product includes software developed by Raghav Mishra (PowerAI Labs).
+
+Licensed under the Apache License, Version 2.0. See the LICENSE file for the
+full terms.

cendor_squeeze-0.5.1/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: cendor-squeeze
+Version: 0.5.1
+Summary: Compress: shrink verbose context (JSON/logs/prose) 60-90% — reversibly. compress() returns a handle; expand() restores the original.
+Author: Raghav Mishra
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Requires-Python: >=3.11
+Requires-Dist: cendor-core<0.2,>=0.1
+Description-Content-Type: text/markdown
+
+# cendor-squeeze
+
+Shrink verbose context — JSON, logs, code, prose — without throwing anything away. Compression
+returns a *handle*; the original is always restorable. Content-aware: each type gets a
+purpose-built, **deterministic** compressor — **no LLM, no model download, byte-reproducible**.
+
+**Up to 97% smaller, 100% reversible — zero dependencies, deterministic output.**
+
+![PyPI](https://img.shields.io/pypi/v/cendor-squeeze) ![license](https://img.shields.io/badge/license-Apache_2.0-blue) · `pip install cendor-squeeze`
+
+```python
+from cendor.squeeze import compress
+
+small, handle = compress(huge_json, kind="auto")                 # detect + route
+small, handle = compress(source_code, kind="code", fidelity="aggressive")
+small, handle = compress(logs, kind="logs", target_tokens=400)   # compress to a budget
+original = handle.expand()                                        # restore, byte-for-byte
+```
+
+## Highlights
+
+- **Four purpose-built compressors** — JSON (minify + drop nulls), logs (normalize timestamps/UUIDs + dedup repeats into `(×N)`, chronological), code (strip comments — *string-aware*, so a `//` or `#` inside a literal stays put; keeps preprocessor & shebang), prose (extractive ranking). `detect()` auto-routes.
+- **Compress to a budget** — `target_tokens` is **never exceeded**; `fidelity="lossless" | "balanced" | "aggressive"`. No LLM, no download, byte-reproducible.
+- **100% reversible** — a content-addressed store (deduped by hash) keeps every original; `handle.expand()` restores it byte-for-byte no matter how hard you squeeze.
+- **Survives restarts** — `handle.to_dict()` / `Handle.from_dict()` next to a durable `squeeze.store.SQLiteStore`; or a bounded `MemoryStore(max_items=…)` via `use_store(...)`.
+- **The deterministic default, swappable** — wired through core's `Compressor` protocol (not a hard import), so `contextkit.use_compressor(...)` can replace it globally with any backend (even a heavier ML compressor). squeeze stays the pick for reproducible, offline, audit-friendly output.
+
+**Inbound** — usually `contextkit` calls it for you (`Block(evict="compress")`). Ratios are content-dependent (logs compress most, structured JSON least) — see the [benchmarks](https://github.com/PowerAI-Labs/Cendor/blob/main/docs/benchmarks.md).
+
+See [`docs/squeeze.md`](https://github.com/PowerAI-Labs/Cendor/blob/main/docs/squeeze.md) · [CHANGELOG](https://github.com/PowerAI-Labs/Cendor/blob/main/packages/cendor-squeeze/CHANGELOG.md). *Part of the Cendor stack — [github.com/PowerAI-Labs/Cendor](https://github.com/PowerAI-Labs/Cendor). Powered by PowerAI Labs. Apache-2.0; provided "as is", without warranty — use at your own risk (LICENSE §7–8).*

cendor_squeeze-0.5.1/README.md

@@ -0,0 +1,30 @@
+# cendor-squeeze
+
+Shrink verbose context — JSON, logs, code, prose — without throwing anything away. Compression
+returns a *handle*; the original is always restorable. Content-aware: each type gets a
+purpose-built, **deterministic** compressor — **no LLM, no model download, byte-reproducible**.
+
+**Up to 97% smaller, 100% reversible — zero dependencies, deterministic output.**
+
+![PyPI](https://img.shields.io/pypi/v/cendor-squeeze) ![license](https://img.shields.io/badge/license-Apache_2.0-blue) · `pip install cendor-squeeze`
+
+```python
+from cendor.squeeze import compress
+
+small, handle = compress(huge_json, kind="auto")                 # detect + route
+small, handle = compress(source_code, kind="code", fidelity="aggressive")
+small, handle = compress(logs, kind="logs", target_tokens=400)   # compress to a budget
+original = handle.expand()                                        # restore, byte-for-byte
+```
+
+## Highlights
+
+- **Four purpose-built compressors** — JSON (minify + drop nulls), logs (normalize timestamps/UUIDs + dedup repeats into `(×N)`, chronological), code (strip comments — *string-aware*, so a `//` or `#` inside a literal stays put; keeps preprocessor & shebang), prose (extractive ranking). `detect()` auto-routes.
+- **Compress to a budget** — `target_tokens` is **never exceeded**; `fidelity="lossless" | "balanced" | "aggressive"`. No LLM, no download, byte-reproducible.
+- **100% reversible** — a content-addressed store (deduped by hash) keeps every original; `handle.expand()` restores it byte-for-byte no matter how hard you squeeze.
+- **Survives restarts** — `handle.to_dict()` / `Handle.from_dict()` next to a durable `squeeze.store.SQLiteStore`; or a bounded `MemoryStore(max_items=…)` via `use_store(...)`.
+- **The deterministic default, swappable** — wired through core's `Compressor` protocol (not a hard import), so `contextkit.use_compressor(...)` can replace it globally with any backend (even a heavier ML compressor). squeeze stays the pick for reproducible, offline, audit-friendly output.
+
+**Inbound** — usually `contextkit` calls it for you (`Block(evict="compress")`). Ratios are content-dependent (logs compress most, structured JSON least) — see the [benchmarks](https://github.com/PowerAI-Labs/Cendor/blob/main/docs/benchmarks.md).
+
+See [`docs/squeeze.md`](https://github.com/PowerAI-Labs/Cendor/blob/main/docs/squeeze.md) · [CHANGELOG](https://github.com/PowerAI-Labs/Cendor/blob/main/packages/cendor-squeeze/CHANGELOG.md). *Part of the Cendor stack — [github.com/PowerAI-Labs/Cendor](https://github.com/PowerAI-Labs/Cendor). Powered by PowerAI Labs. Apache-2.0; provided "as is", without warranty — use at your own risk (LICENSE §7–8).*

cendor_squeeze-0.5.1/pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "cendor-squeeze"
+version = "0.5.1"
+description = "Compress: shrink verbose context (JSON/logs/prose) 60-90% — reversibly. compress() returns a handle; expand() restores the original."
+requires-python = ">=3.11"
+license = "Apache-2.0"
+authors = [{ name = "Raghav Mishra" }]
+readme = "README.md"
+dependencies = ["cendor-core>=0.1,<0.2"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cendor"]     # contributes cendor/squeeze only — NEVER add src/cendor/__init__.py

cendor_squeeze-0.5.1/src/cendor/squeeze/__init__.py

@@ -0,0 +1,445 @@
+"""cendor.squeeze — content-aware, reversible context compression.
+
+Shrink verbose context without throwing anything away: :func:`compress` returns ``(small, handle)``
+and ``handle.expand()`` restores the original on demand. Content is routed by type — JSON, logs,
+and prose each get a purpose-built, deterministic compressor (no LLM). Reversibility is guaranteed
+by a **content-addressed store** (CCR): every original is kept keyed by its hash, deduped across
+calls, so ``expand()`` is always exact no matter how hard we squeeze.
+
+Satisfies ``cendor.core.protocols.Compressor`` by shape, so ``contextkit`` uses it for
+``Block(evict="compress")`` via the ``contextkit[squeeze]`` extra — without importing this package.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import uuid
+from dataclasses import dataclass, field
+from typing import Any
+
+from cendor.core import tokens
+
+from .store import MemoryStore
+
+__all__ = ["compress", "decompress", "detect", "use_store", "Handle", "SqueezeCompressor"]
+
+# Active content-addressed store (CCR): sha256(original) -> original. Deduped; the basis of
+# reversibility. Default in-process; swap via use_store() for a persistent backend.
+_backend: Any = MemoryStore()
+
+
+def use_store(store: Any) -> Any:
+    """Swap the CCR backend (e.g. ``store.SQLiteStore``); returns the previous one. (docs §5)
+
+    A backend is any object with ``get(key) -> str`` and ``put(key, value) -> None``. Handles
+    expand against whichever backend is active at expand time.
+    """
+    global _backend
+    previous, _backend = _backend, store
+    return previous
+
+
+@dataclass
+class Handle:
+    """Restore handle for a compression. ``expand()`` returns the exact original. (docs §5)"""
+
+    id: str
+    kind: str
+    original_ref: str  # CCR key into the content store
+    restore_map: dict = field(default_factory=dict)
+
+    def expand(self) -> str:
+        """Return the original content, byte-for-byte (from the active CCR backend)."""
+        return _backend.get(self.original_ref)
+
+    @property
+    def technique(self) -> str:
+        """The compression technique recorded for this handle (e.g. ``"minify+dropnulls"``)."""
+        return str(self.restore_map.get("technique", ""))
+
+    def to_dict(self) -> dict:
+        """Serialize the handle (not the original). Persist it alongside a durable store
+        (e.g. :class:`store.SQLiteStore`) to :meth:`expand` after the process restarts."""
+        return {
+            "id": self.id,
+            "kind": self.kind,
+            "original_ref": self.original_ref,
+            "restore_map": dict(self.restore_map),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Handle:
+        """Rebuild a handle from :meth:`to_dict`; ``expand()`` resolves via the active store."""
+        return cls(
+            id=data["id"],
+            kind=data["kind"],
+            original_ref=data["original_ref"],
+            restore_map=dict(data.get("restore_map", {})),
+        )
+
+
+def _store(original: str) -> str:
+    key = hashlib.sha256(original.encode("utf-8")).hexdigest()
+    _backend.put(key, original)
+    return key
+
+
+# --------------------------------------------------------------------------- detection
+
+_TS = re.compile(r"\b\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b")
+_UUID = re.compile(r"\b[0-9a-fA-F]{8}-(?:[0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}\b")
+_LEVEL = re.compile(r"\b(?:DEBUG|INFO|WARN|WARNING|ERROR|CRITICAL|TRACE|FATAL)\b")
+
+_FIDELITY = ("lossless", "balanced", "aggressive")
+_CODE_MARKERS = (
+    "def ",
+    "class ",
+    "function ",
+    "func ",
+    "import ",
+    "from ",
+    "return ",
+    "const ",
+    "let ",
+    "var ",
+    "public ",
+    "private ",
+    "#include",
+    "=>",
+    "</",
+)
+# Preprocessor/import directives that begin with `#` but must NOT be stripped as comments.
+_PREPROC = re.compile(
+    r"#\s*(?:include|define|undef|ifdef|ifndef|endif|else|elif|if|pragma|error|line|import)\b"
+)
+
+
+def _strip_comments(code: str) -> str:
+    """Remove ``//``, ``/* */`` and ``#`` comments while leaving string/char literals intact.
+
+    A single-pass, string-aware scanner (handles single/double/backtick quotes with escapes),
+    so a ``//`` or ``#`` *inside* a literal — a URL, a color, a path — is preserved instead of
+    being cut. ``#`` preprocessor directives (``#include``, ``#define``, …) and shebang (``#!``)
+    lines are kept; otherwise ``#`` begins a line comment (Python/shell style). Not a parser — a
+    deterministic heuristic; reversibility is unaffected (the original is always in the CCR store).
+    """
+    out: list[str] = []
+    i, n = 0, len(code)
+    quote: str | None = None
+    in_block = False
+    at_line_start = True  # no non-space char seen yet on the current line
+    while i < n:
+        ch = code[i]
+        nxt = code[i + 1] if i + 1 < n else ""
+        if in_block:
+            if ch == "*" and nxt == "/":
+                in_block = False
+                i += 2
+            else:
+                if ch == "\n":
+                    out.append(ch)
+                i += 1
+            continue
+        if quote is not None:
+            out.append(ch)
+            if ch == "\\" and i + 1 < n:
+                out.append(nxt)
+                i += 2
+                continue
+            if ch == quote:
+                quote = None
+            i += 1
+            continue
+        if ch in "\"'`":
+            quote = ch
+            out.append(ch)
+            at_line_start = False
+            i += 1
+            continue
+        if ch == "/" and nxt == "/":
+            while i < n and code[i] != "\n":
+                i += 1
+            continue
+        if ch == "/" and nxt == "*":
+            in_block = True
+            i += 2
+            continue
+        if ch == "#" and not ((at_line_start and nxt == "!") or _PREPROC.match(code, i)):
+            while i < n and code[i] != "\n":
+                i += 1
+            continue
+        if ch == "\n":
+            at_line_start = True
+        elif not ch.isspace():
+            at_line_start = False
+        out.append(ch)
+        i += 1
+    return "".join(out)
+
+
+def detect(content: str) -> str:
+    """Detect the content kind: ``"json"`` | ``"logs"`` | ``"code"`` | ``"prose"``. (docs §4)"""
+    s = content.strip()
+    if not s:
+        return "prose"
+    if s[0] in "{[":
+        try:
+            json.loads(s)
+            return "json"
+        except (ValueError, TypeError):
+            pass
+    if _looks_like_logs(s):
+        return "logs"
+    if _looks_like_code(s):
+        return "code"
+    return "prose"
+
+
+def _looks_like_logs(s: str) -> bool:
+    lines = [ln for ln in s.splitlines() if ln.strip()]
+    if len(lines) < 3:
+        return False
+    hits = sum(1 for ln in lines if _TS.search(ln) or _LEVEL.search(ln))
+    return hits >= len(lines) * 0.5
+
+
+def _looks_like_code(s: str) -> bool:
+    lines = [ln for ln in s.splitlines() if ln.strip()]
+    if not lines:
+        return False
+    hits = sum(
+        1
+        for ln in lines
+        if any(m in ln for m in _CODE_MARKERS) or ln.strip().endswith(("{", "}", ";", ":"))
+    )
+    return hits >= max(1, len(lines) * 0.3)
+
+
+# --------------------------------------------------------------------------- public API
+
+
+def compress(
+    content: Any,
+    kind: str = "auto",
+    target_tokens: int | None = None,
+    model: str = "gpt-4o",
+    fidelity: str = "balanced",
+) -> tuple[str, Handle]:
+    """Compress ``content`` and return ``(small, handle)``. ``handle.expand()`` restores it.
+
+    Args:
+        content: A string, or a JSON-serializable object (dict/list).
+        kind: ``"auto"`` (detect) or one of ``"json"`` | ``"logs"`` | ``"code"`` | ``"prose"``.
+        target_tokens: If given, compress *to* this budget (best effort, never exceeds it).
+        model: Model id used for token counting.
+        fidelity: How hard to squeeze — ``"lossless"`` (structural only), ``"balanced"`` (default),
+            or ``"aggressive"``. Reversibility is unaffected; the original is always in the handle.
+    """
+    if fidelity not in _FIDELITY:
+        raise ValueError(f"fidelity must be one of {_FIDELITY}, got {fidelity!r}")
+    if isinstance(content, str):
+        original = content
+    else:
+        original = json.dumps(content, ensure_ascii=False, separators=(",", ":"))
+        if kind == "auto":
+            kind = "json"
+
+    if kind == "auto":
+        kind = detect(original)
+
+    if kind == "json":
+        small, restore_map = _compress_json(original, target_tokens, model, fidelity)
+    elif kind == "logs":
+        small, restore_map = _compress_logs(original, target_tokens, model)
+    elif kind == "code":
+        small, restore_map = _compress_code(original, target_tokens, model, fidelity)
+    else:
+        small, restore_map = _compress_prose(original, target_tokens, model, fidelity)
+
+    handle = Handle(
+        id=uuid.uuid4().hex,
+        kind=kind,
+        original_ref=_store(original),
+        restore_map=restore_map,
+    )
+    return small, handle
+
+
+def decompress(handle: Handle) -> str:
+    """Restore the original content for a handle (same as ``handle.expand()``)."""
+    return handle.expand()
+
+
+class SqueezeCompressor:
+    """Object form satisfying ``core.protocols.Compressor`` (delegates to :func:`compress`)."""
+
+    def compress(
+        self,
+        content: Any,
+        *,
+        target_tokens: int | None = None,
+        model: str | None = None,
+        kind: str = "auto",
+        fidelity: str = "balanced",
+    ) -> tuple[str, Handle]:
+        return compress(
+            content,
+            kind=kind,
+            target_tokens=target_tokens,
+            model=model or "gpt-4o",
+            fidelity=fidelity,
+        )
+
+
+# --------------------------------------------------------------------------- compressors
+
+
+def _strip_nulls(obj: Any) -> Any:
+    if isinstance(obj, dict):
+        return {k: _strip_nulls(v) for k, v in obj.items() if v is not None}
+    if isinstance(obj, list):
+        return [_strip_nulls(v) for v in obj]
+    return obj
+
+
+def _compress_json(
+    text: str, target_tokens: int | None, model: str, fidelity: str = "balanced"
+) -> tuple[str, dict]:
+    """Minify whitespace; drop null-valued keys unless ``fidelity="lossless"``. Original in CCR."""
+    try:
+        obj = json.loads(text)
+    except (ValueError, TypeError):
+        return _compress_prose(text, target_tokens, model)
+    shaped = obj if fidelity == "lossless" else _strip_nulls(obj)
+    small = json.dumps(shaped, ensure_ascii=False, separators=(",", ":"))
+    if target_tokens is not None and tokens.count(small, model) > target_tokens:
+        small = _truncate_to_tokens(small, target_tokens, model)
+    technique = "minify" if fidelity == "lossless" else "minify+dropnulls"
+    return small, {"technique": technique}
+
+
+def _compress_code(
+    text: str, target_tokens: int | None, model: str, fidelity: str = "balanced"
+) -> tuple[str, dict]:
+    """Strip comments + blank lines (and, when aggressive, internal whitespace); keep structure."""
+    code = text
+    if fidelity != "lossless":
+        code = _strip_comments(code)
+    out: list[str] = []
+    for raw in code.splitlines():
+        line = raw.rstrip()
+        if not line.strip():
+            continue
+        if fidelity == "aggressive":
+            stripped = line.lstrip()
+            indent = line[: len(line) - len(stripped)]
+            line = indent + re.sub(r"[ \t]{2,}", " ", stripped)
+        out.append(line)
+    small = "\n".join(out)
+    if target_tokens is not None and tokens.count(small, model) > target_tokens:
+        small = _truncate_to_tokens(small, target_tokens, model)
+    return small, {"technique": f"code:{fidelity}"}
+
+
+def _compress_logs(text: str, target_tokens: int | None, model: str) -> tuple[str, dict]:
+    """Normalize volatile fields (timestamps/UUIDs) then dedup repeated lines into ``(×N)``.
+
+    Under a ``target_tokens`` budget, the noisiest patterns are kept (most repeats first) but they
+    are rendered back in original **chronological** order, so the timeline stays readable.
+    """
+    counts: dict[str, int] = {}
+    order: list[str] = []
+    for line in text.splitlines():
+        norm = _UUID.sub("<uuid>", _TS.sub("<ts>", line))
+        if norm not in counts:
+            order.append(norm)
+        counts[norm] = counts.get(norm, 0) + 1
+
+    rendered = {norm: f"{norm} (×{counts[norm]})" if counts[norm] > 1 else norm for norm in order}
+    if target_tokens is None:
+        kept = order
+    else:
+        # Select which patterns survive by frequency (cheap additive estimate), then restore
+        # chronological order; the final truncate enforces the hard token cap.
+        chosen: set[str] = set()
+        running = 0
+        for norm in sorted(order, key=lambda ln: counts[ln], reverse=True):
+            cost = tokens.count(rendered[norm], model) + 1  # +1 for the line separator
+            if running + cost > target_tokens and chosen:
+                break
+            chosen.add(norm)
+            running += cost
+        kept = [norm for norm in order if norm in chosen]
+
+    small = "\n".join(rendered[norm] for norm in kept)
+    if target_tokens is not None and tokens.count(small, model) > target_tokens:
+        small = _truncate_to_tokens(small, target_tokens, model)
+    return small, {"technique": "normalize+dedup", "patterns": len(order)}
+
+
+_SENT = re.compile(r"(?<=[.!?])\s+")
+_STOP = frozenset(
+    "the a an and or but of to in on for with is are was were be been it this that as at by".split()
+)
+
+
+def _compress_prose(
+    text: str, target_tokens: int | None, model: str, fidelity: str = "balanced"
+) -> tuple[str, dict]:
+    """Extractive: rank sentences by keyword density, keep the top ones in original order."""
+    sentences = [s for s in _SENT.split(text.strip()) if s.strip()]
+    if len(sentences) <= 1 or fidelity == "lossless":
+        # Nothing to rank, but still honor the budget (e.g. one long sentence, or lossless).
+        small = text
+        if target_tokens is not None and tokens.count(small, model) > target_tokens:
+            small = _truncate_to_tokens(small, target_tokens, model)
+        return small, {"technique": "extractive", "kept": len(sentences), "of": len(sentences)}
+
+    freq: dict[str, int] = {}
+    for word in re.findall(r"[a-zA-Z']+", text.lower()):
+        if word not in _STOP:
+            freq[word] = freq.get(word, 0) + 1
+
+    def score(sentence: str) -> float:
+        words = re.findall(r"[a-zA-Z']+", sentence.lower())
+        if not words:
+            return 0.0
+        return sum(freq.get(w, 0) for w in words) / len(words)
+
+    ranked = sorted(range(len(sentences)), key=lambda i: score(sentences[i]), reverse=True)
+
+    if target_tokens is not None:
+        keep: set[int] = set()
+        for i in ranked:
+            trial = " ".join(sentences[j] for j in sorted(keep | {i}))
+            if tokens.count(trial, model) > target_tokens and keep:
+                break
+            keep.add(i)
+    else:
+        divisor = 3 if fidelity == "aggressive" else 2  # aggressive: top third, balanced: top half
+        keep = set(ranked[: max(1, len(sentences) // divisor)])
+
+    small = " ".join(sentences[i] for i in sorted(keep))
+    # The top-ranked sentence is always kept; truncate so target_tokens is never exceeded.
+    if target_tokens is not None and tokens.count(small, model) > target_tokens:
+        small = _truncate_to_tokens(small, target_tokens, model)
+    return small, {"technique": "extractive", "kept": len(keep), "of": len(sentences)}
+
+
+def _truncate_to_tokens(text: str, target: int, model: str) -> str:
+    """Binary-search the longest prefix of ``text`` that fits ``target`` tokens (deterministic)."""
+    if target <= 0:
+        return ""
+    if tokens.count(text, model) <= target:
+        return text
+    lo, hi, best = 0, len(text), ""
+    while lo <= hi:
+        mid = (lo + hi) // 2
+        cand = text[:mid]
+        if tokens.count(cand, model) <= target:
+            best, lo = cand, mid + 1
+        else:
+            hi = mid - 1
+    return best

cendor_squeeze-0.5.1/src/cendor/squeeze/store.py

@@ -0,0 +1,75 @@
+"""Content-addressed store (CCR) backends for squeeze. docs/squeeze.md §5, §7.
+
+The original of every compression is kept keyed by its hash so ``handle.expand()`` is exact.
+``MemoryStore`` (the default) keeps originals in-process; ``SQLiteStore`` persists them to a local
+file so they survive the process and dedupe across runs — both stdlib, no network. A backend is
+any object with ``get(key) -> str`` and ``put(key, value) -> None``; swap one in via
+``squeeze.use_store(...)``.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+
+class MemoryStore:
+    """In-process CCR store (the default). Fast, ephemeral, deduped by key.
+
+    ``max_items`` bounds the store: once exceeded, the oldest originals are evicted (FIFO) so it
+    doesn't grow unbounded. Expanding a handle whose original was evicted raises ``KeyError`` —
+    the documented trade-off of a capped store. ``None`` (default) means unbounded.
+    """
+
+    def __init__(self, max_items: int | None = None) -> None:
+        self._data: dict[str, str] = {}
+        self._max = max_items
+
+    def get(self, key: str) -> str:
+        return self._data[key]
+
+    def put(self, key: str, value: str) -> None:
+        if key in self._data:
+            return
+        self._data[key] = value
+        if self._max is not None:
+            while len(self._data) > self._max:
+                del self._data[next(iter(self._data))]  # evict oldest insertion (FIFO)
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._data
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+
+class SQLiteStore:
+    """Local SQLite CCR store: originals persist across processes, deduped by key (stdlib).
+
+    Opened with ``check_same_thread=False`` so a single store can serve a threaded server; writes
+    are idempotent ``INSERT OR IGNORE``s (content-addressed), so concurrent puts of the same content
+    are safe.
+    """
+
+    def __init__(self, path: str) -> None:
+        self.conn = sqlite3.connect(path, check_same_thread=False)
+        self.conn.execute("CREATE TABLE IF NOT EXISTS ccr (key TEXT PRIMARY KEY, value TEXT)")
+        self.conn.commit()
+
+    def get(self, key: str) -> str:
+        row = self.conn.execute("SELECT value FROM ccr WHERE key = ?", (key,)).fetchone()
+        if row is None:
+            raise KeyError(key)
+        return row[0]
+
+    def put(self, key: str, value: str) -> None:
+        self.conn.execute("INSERT OR IGNORE INTO ccr (key, value) VALUES (?, ?)", (key, value))
+        self.conn.commit()
+
+    def __contains__(self, key: str) -> bool:
+        return self.conn.execute("SELECT 1 FROM ccr WHERE key = ?", (key,)).fetchone() is not None
+
+    def __len__(self) -> int:
+        return int(self.conn.execute("SELECT count(*) FROM ccr").fetchone()[0])
+
+    def close(self) -> None:
+        self.conn.close()

cendor_squeeze-0.5.1/tests/test_squeeze.py

@@ -0,0 +1,236 @@
+"""Compression is content-aware, deterministic, and 100% reversible. No network."""
+
+import json
+
+import pytest
+from cendor.core import protocols, tokens
+from cendor.squeeze import SqueezeCompressor, compress, decompress, detect
+
+
+@pytest.fixture(autouse=True)
+def _heuristic_tokens(monkeypatch):
+    monkeypatch.setattr(tokens, "_tiktoken_encoding", lambda model: None)
+    yield
+
+
+def test_detect():
+    assert detect('{"a": 1}') == "json"
+    assert detect("[1, 2, 3]") == "json"
+    logs = "\n".join(f"2026-06-01T00:00:0{i} INFO started worker" for i in range(5))
+    assert detect(logs) == "logs"
+    assert detect("The cat sat on the mat. It was a sunny day.") == "prose"
+
+
+def test_json_compression_is_smaller_and_reversible():
+    obj = {"name": "alice", "age": 30, "note": None, "tags": ["x", "y"], "extra": None}
+    pretty = json.dumps(obj, indent=4)
+    small, handle = compress(pretty, kind="auto")
+    assert detect(pretty) == "json"
+    assert len(small) < len(pretty)  # whitespace + nulls gone
+    assert "note" not in small and "null" not in small  # nulls dropped
+    assert handle.expand() == pretty  # exact original restored
+
+
+def test_logs_dedup_collapses_repeats():
+    logs = "\n".join(["2026-06-01T00:00:00Z INFO retry attempt"] * 20)
+    small, handle = compress(logs, kind="logs")
+    assert "(×20)" in small
+    assert tokens.count(small, "gpt-4o") < tokens.count(logs, "gpt-4o")
+    assert handle.expand() == logs
+
+
+def test_prose_extractive_hits_target_tokens():
+    text = (
+        "Refunds are processed within five business days. "
+        "The weather today is mild and pleasant. "
+        "Customers must contact support to request a refund. "
+        "Our office cat is named Mittens. "
+        "Refund eligibility depends on the purchase date."
+    )
+    target = 20
+    small, handle = compress(text, kind="prose", target_tokens=target)
+    assert tokens.count(small, "gpt-4o") <= target
+    assert len(small) < len(text)
+    assert handle.expand() == text  # original always restorable
+
+
+def test_object_input_serialized_and_restored():
+    small, handle = compress({"k": "v", "n": None}, kind="auto")
+    assert "null" not in small
+    restored = json.loads(handle.expand())
+    assert restored == {"k": "v", "n": None}
+
+
+def test_decompress_matches_expand():
+    small, handle = compress("hello world. goodbye world.", kind="prose")
+    assert decompress(handle) == handle.expand()
+
+
+def test_ccr_store_dedupes_identical_originals():
+    import cendor.squeeze as sq
+
+    before = len(sq._backend)
+    _, h1 = compress("identical content here", kind="prose")
+    _, h2 = compress("identical content here", kind="prose")
+    assert h1.original_ref == h2.original_ref  # same hash key
+    assert len(sq._backend) == before + 1  # stored once
+
+
+def test_memory_store_eviction_cap():
+    import cendor.squeeze as sq
+    from cendor.squeeze.store import MemoryStore
+
+    previous = sq.use_store(MemoryStore(max_items=2))
+    try:
+        _, h1 = compress("first original content here", kind="prose")
+        _, h2 = compress("second original content here", kind="prose")
+        _, h3 = compress("third original content here", kind="prose")  # evicts the first
+        assert len(sq._backend) == 2
+        assert h2.expand() and h3.expand()  # newest two survive
+        with pytest.raises(KeyError):
+            h1.expand()  # oldest was evicted (documented trade-off of a capped store)
+    finally:
+        sq.use_store(previous)
+
+
+def test_sqlite_store_backend_persists_and_expands(tmp_path):
+    import cendor.squeeze as sq
+    from cendor.squeeze.store import SQLiteStore
+
+    store = SQLiteStore(str(tmp_path / "ccr.db"))
+    previous = sq.use_store(store)
+    try:
+        original = '{"name": "alice", "age": 30, "note": null}'
+        small, handle = compress(original, kind="json")
+        assert len(small) < len(original)
+        assert handle.original_ref in store  # original persisted to SQLite
+        assert handle.expand() == original  # restored from the SQLite backend
+    finally:
+        sq.use_store(previous)
+        store.close()
+
+
+def test_satisfies_core_compressor_protocol():
+    assert isinstance(SqueezeCompressor(), protocols.Compressor)
+    small, handle = SqueezeCompressor().compress("a. b. c. d.", target_tokens=5, model="gpt-4o")
+    assert isinstance(handle.expand(), str)
+
+
+def test_detect_code():
+    src = "def add(a, b):\n    # sum them\n    return a + b\n"
+    assert detect(src) == "code"
+    js = "function f(x) {\n  return x * 2;\n}\n"
+    assert detect(js) == "code"
+
+
+def test_code_compression_strips_comments_and_is_reversible():
+    src = "def add(a, b):\n    # add two numbers\n    return a + b\n\n// trailing\n"
+    small, handle = compress(src, kind="code")
+    assert "# add two numbers" not in small
+    assert "// trailing" not in small
+    assert "" not in small.split("\n")  # blank lines gone
+    assert "return a + b" in small  # structure kept
+    assert handle.expand() == src  # exact original restorable
+    assert tokens.count(small, "gpt-4o") < tokens.count(src, "gpt-4o")
+
+
+def test_code_lossless_keeps_comments():
+    src = "def f():\n    # keep me\n    return 1\n"
+    small, _ = compress(src, kind="code", fidelity="lossless")
+    assert "# keep me" in small  # comments preserved at lossless fidelity
+
+
+def test_fidelity_dial_on_prose():
+    text = ". ".join(f"Sentence {i} about refunds and billing matters" for i in range(12)) + "."
+    lossless, _ = compress(text, kind="prose", fidelity="lossless")
+    balanced, _ = compress(text, kind="prose", fidelity="balanced")
+    aggressive, _ = compress(text, kind="prose", fidelity="aggressive")
+    assert lossless == text  # lossless prose is a no-op (whitespace aside)
+    t = lambda s: tokens.count(s, "gpt-4o")  # noqa: E731
+    assert t(aggressive) <= t(balanced) <= t(lossless)
+
+
+def test_invalid_fidelity_rejected():
+    with pytest.raises(ValueError):
+        compress("x", fidelity="ultra")
+
+
+def test_json_lossless_keeps_nulls():
+    small, _ = compress('{"a": 1, "b": null}', kind="json", fidelity="lossless")
+    assert "null" in small  # nulls retained at lossless fidelity
+
+
+def test_prose_never_exceeds_target_even_with_one_dominant_sentence():
+    # The top-ranked sentence is always kept; it must still be truncated to honor target_tokens.
+    text = (
+        "refund refund refund refund refund refund refund refund refund refund policy here. "
+        "The cat sat. A dog ran. Birds fly."
+    )
+    small, handle = compress(text, kind="prose", target_tokens=5)
+    assert tokens.count(small, "gpt-4o") <= 5
+    assert handle.expand() == text  # still fully reversible
+
+
+def test_code_comment_stripping_preserves_string_literals():
+    src = 'url = "https://example.com/path"  // trailing\nkey = "color #ff0000"\nreturn url\n'
+    small, handle = compress(src, kind="code")
+    assert "https://example.com/path" in small  # // inside a string is not a comment
+    assert "#ff0000" in small  # # inside a string is not a comment
+    assert "// trailing" not in small  # the real comment is gone
+    assert handle.expand() == src
+
+
+def test_code_keeps_preprocessor_and_shebang():
+    src = "#!/usr/bin/env python\n#include <stdio.h>\nx = 1  # a real comment\nreturn x\n"
+    small, _ = compress(src, kind="code")
+    assert "#!/usr/bin/env python" in small  # shebang kept
+    assert "#include <stdio.h>" in small  # preprocessor directive kept
+    assert "# a real comment" not in small  # ordinary # comment stripped
+
+
+def test_logs_preserve_chronological_order_under_target():
+    logs = "\n".join(
+        [
+            "2026-06-01T00:00:01Z INFO alpha first",
+            "2026-06-01T00:00:02Z INFO beta second",
+            "2026-06-01T00:00:03Z ERROR gamma",
+            "2026-06-01T00:00:04Z ERROR gamma",
+            "2026-06-01T00:00:05Z ERROR gamma",
+        ]
+    )
+    small, _ = compress(logs, kind="logs", target_tokens=1000)
+    assert small.splitlines()[0].endswith("INFO alpha first")  # chronological, not freq-sorted
+    assert tokens.count(small, "gpt-4o") <= 1000
+
+
+def test_handle_to_dict_round_trips_with_persistent_store():
+    import cendor.squeeze as sq
+    from cendor.squeeze import Handle
+    from cendor.squeeze.store import SQLiteStore
+
+    store = SQLiteStore(":memory:")
+    previous = sq.use_store(store)
+    try:
+        original = '{"a": 1, "b": null}'
+        _small, handle = compress(original, kind="json")
+        rebuilt = Handle.from_dict(handle.to_dict())  # e.g. loaded from disk next process
+        assert rebuilt.expand() == original
+        assert rebuilt.technique == handle.technique
+        assert len(store) == 1
+    finally:
+        sq.use_store(previous)
+        store.close()
+
+
+def test_contextkit_compress_routes_through_squeeze():
+    # End-to-end: contextkit discovers squeeze by shape via the [squeeze] extra (both installed).
+    from cendor.contextkit import Block, Context
+
+    ctx = Context(budget_tokens=30, model="gpt-4o")
+    ctx.add(Block("keep me", priority=10, role="system"))
+    big = " ".join(f"Sentence number {i} about refunds and billing." for i in range(20))
+    ctx.add(Block(big, priority=1, role="user", evict="compress"))
+    ctx.assemble()
+    decision = next(d for d in ctx.report().decisions if d.role == "user")
+    assert decision.action == "compressed"
+    assert decision.tokens_after < decision.tokens_before

cendor_squeeze-0.5.1/tests/test_squeeze_properties.py

@@ -0,0 +1,32 @@
+"""Property test (Layer E): compression is always exactly reversible, for any input. No network."""
+
+from cendor.core import tokens
+from cendor.squeeze import compress
+from hypothesis import given
+from hypothesis import strategies as st
+
+
+@given(s=st.text(max_size=2000))
+def test_compress_then_expand_round_trips(s):
+    # Whatever the content (and however hard it's squeezed), the original restores byte-for-byte.
+    _small, handle = compress(s, kind="auto")
+    assert handle.expand() == s
+
+
+@given(
+    s=st.text(min_size=1, max_size=2000),
+    kind=st.sampled_from(["json", "logs", "code", "prose"]),
+    target=st.integers(1, 200),
+)
+def test_target_tokens_is_never_exceeded(s, kind, target):
+    # "compress to a budget, never exceeds it" — for every content kind, including prose.
+    small, _handle = compress(s, kind=kind, target_tokens=target)
+    assert tokens.count(small, "gpt-4o") <= target
+
+
+@given(
+    s=st.text(min_size=1, max_size=2000), kind=st.sampled_from(["json", "logs", "code", "prose"])
+)
+def test_reversible_for_every_kind(s, kind):
+    _small, handle = compress(s, kind=kind)
+    assert handle.expand() == s