mostlyright-data 0.9.0__py3-none-any.whl

mostlyright/data_harness/sources/catalog/packed_writer.py

@@ -0,0 +1,2802 @@
+"""The streaming packed publisher, and the only place a packed generation's work is counted.
+
+This module turns one classified sweep into one packed generation.  Its inputs are exactly the
+delta's classification shards, the successor identity generation
+behind them, and the authored shards the classification was computed from -- and its output is the
+range-local schema in :mod:`packed_catalog`.
+
+Four properties are load-bearing.
+
+*One pack in, one pack out.*  The three publishable classification streams are already ascending by
+provider record, so publication is a merge rather than a join: at most one shard per classification,
+one authored shard, one identity pack, one predecessor range and one range under construction are
+ever resident.  Nothing is indexed and nothing is sorted.
+
+*Encoding happens exactly once per nonempty fresh range, layer and backend.*  A range that contains
+at least one new or changed entry issues one bounded ``encode_many`` invocation per layer per
+backend, carrying exactly that range's fresh texts; an unchanged entry's four layer vectors are read
+back out of the predecessor's packs instead.  So the totals are equations rather than observations
+after the fact: ``batch_invocations = nonempty_fresh_range_count * 4 * backend_count`` and
+``encoded_layer_items = fresh_entries * 4 * backend_count``, and this module refuses to install a
+head whose counters do not satisfy them.
+
+*The counters are produced, never accepted.*  There is no parameter through which a caller can hand
+this function a work total.  Every number comes from a seam-minted :class:`BatchEncodeResult` this
+module summed in order, and when a publication spans several invocations the head carries each
+invocation's record beside the ordered sum of them.
+
+*A publication is complete, resumable, or nothing.*  Members are immutable and content-addressed;
+after each range is durable, a typed-incomplete work journal binds the output root, the ordered
+completed-range member digests and this invocation's counter record.  An explicit resume validates
+the journal's own digest, re-reads every already-emitted member and refuses one whose bytes moved,
+and continues from the first missing one without re-encoding a pre-head complete range.  Before the
+head is installed, a terminal record captures the exact final journal and packed-receipt inputs; the
+head binds that record's digest.  Recovering that mutable terminal state deterministically replays
+the generation before completing its evidence transaction.  A crash therefore leaves either
+ordinary range work to resume or a head-bound state that can be verified and completed exactly.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import stat
+import time
+from collections.abc import Callable, Iterator, Mapping, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from mostlyright.data_harness.canonical import (
+    CanonicalJSONError,
+    canonical_json_bytes,
+    canonical_sha256,
+    parse_canonical_json,
+    sha256_bytes,
+)
+from mostlyright.data_harness.sources.catalog.admission import admit_public_fact_bytes
+from mostlyright.data_harness.sources.catalog.authoring_policy import (
+    AUTHORING_DISPOSITIONS,
+    AUTHORING_REASON_CODES,
+    MAX_LAYER_TEXT_BYTES,
+)
+from mostlyright.data_harness.sources.catalog.authoring_shards import (
+    AUTHORING_MANIFEST_SCHEMA,
+    AUTHORING_SHARD_SCHEMA,
+    MANIFEST_FILENAME,
+    MAX_AUTHORING_MANIFEST_BYTES,
+    MAX_AUTHORING_SHARD_BYTES,
+    SHARDS_DIRNAME,
+    shard_descriptor_is_valid,
+)
+from mostlyright.data_harness.sources.catalog.bounded_io import (
+    BoundedReadFailure,
+    read_bounded_at,
+    read_bounded_path,
+)
+from mostlyright.data_harness.sources.catalog.contracts import EMBEDDING_LAYERS
+from mostlyright.data_harness.sources.catalog.coverage import coverage_is_valid
+from mostlyright.data_harness.sources.catalog.embedding import (
+    BOUNDED_SCALAR_ADAPTER,
+    BatchEncodeResult,
+    EmbeddingBackend,
+)
+from mostlyright.data_harness.sources.catalog.entry_v2 import catalog_entry_v2_from_dict
+from mostlyright.data_harness.sources.catalog.identity_history import (
+    IdentityHistory,
+    IdentityHistoryStore,
+    derive_entry_id,
+)
+from mostlyright.data_harness.sources.catalog.packed_catalog import (
+    COUNTER_MEMBERS,
+    MAX_BACKEND_DIMENSION,
+    MAX_FACTS_MEMBER_BYTES,
+    MAX_HISTORY_MEMBER_BYTES,
+    MAX_PACKED_BACKENDS,
+    MAX_PACKED_HEAD_BYTES,
+    MAX_POSTING_SEGMENT_BYTES,
+    MAX_RANGE_DESCRIPTORS,
+    MAX_RANGE_MANIFEST_BYTES,
+    MAX_VECTOR_MEMBER_BYTES,
+    MEMBER_HEADER_BYTES,
+    PACKED_HEAD_FILENAME,
+    RANGE_ENTRIES,
+    BuiltPackedRange,
+    CatalogPackedRefused,
+    PackedBackend,
+    PackedDirectory,
+    PackedRangeDescriptor,
+    PackedRangeInput,
+    VerifiedPackedGeneration,
+    bound_segment_bytes,
+    build_packed_head,
+    build_packed_range,
+    encode_layer_batch,
+    member_descriptor_from_dict,
+    parse_vector_member,
+    range_binding_sha256,
+    range_descriptor_from_dict,
+    ranges_chain_sha256,
+    verify_packed_generation,
+    verify_packed_range,
+)
+from mostlyright.data_harness.sources.catalog.streaming_delta import (
+    DELTA_IDENTITY_DIRNAME,
+    DELTA_MANIFEST_FILENAME,
+    DELTA_MANIFEST_SCHEMA,
+    DELTA_SHARDS_DIRNAME,
+    MAX_DELTA_MANIFEST_BYTES,
+    MAX_DELTA_SHARD_BYTES,
+)
+from mostlyright.data_harness.sources.contracts import SourceContractError
+
+PACKED_JOURNAL_SCHEMA = "harness-catalog-packed-journal.v1"
+PACKED_JOURNAL_FILENAME = "packed-journal.json"
+PACKED_RECEIPT_SCHEMA = "mr-data-catalog-packed.v1"
+PACKED_TERMINAL_SCHEMA = "harness-catalog-packed-terminal.v1"
+PACKED_TERMINAL_FILENAME = "packed-terminal.json"
+MAX_PACKED_JOURNAL_BYTES = 8 * 1024 * 1024
+MAX_PACKED_TERMINAL_BYTES = 16 * 1024 * 1024
+
+#: The three classifications that put an entry in a packed generation. ``absent`` describes a
+#: predecessor record that is gone, and the three non-admitted dispositions never had an entry.
+PUBLISHABLE_CLASSIFICATIONS = ("changed", "new", "unchanged")
+FRESH_CLASSIFICATIONS = ("changed", "new")
+
+#: Each member kind's own byte ceiling, so a journal reverification allocates a kind's exact bound
+#: rather than the largest bound any kind has.
+MEMBER_MAXIMUM_BYTES = {
+    "facts": MAX_FACTS_MEMBER_BYTES,
+    "history": MAX_HISTORY_MEMBER_BYTES,
+    "vector": MAX_VECTOR_MEMBER_BYTES,
+    "posting": MAX_POSTING_SEGMENT_BYTES,
+    "bound": bound_segment_bytes(dimensions=MAX_BACKEND_DIMENSION),
+    "range": MAX_RANGE_MANIFEST_BYTES,
+}
+
+_OPEN_MEMBER = os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_CLOEXEC", 0)
+_OPEN_DIRECTORY = _OPEN_MEMBER | getattr(os, "O_DIRECTORY", 0)
+
+
+def _refuse(code: str, path: str, detail: str) -> CatalogPackedRefused:
+    return CatalogPackedRefused(code, path, detail)
+
+
+def _is_digest(value: Any) -> bool:
+    return (
+        isinstance(value, str) and len(value) == 64 and all(c in "0123456789abcdef" for c in value)
+    )
+
+
+@dataclass(frozen=True)
+class PackedLimits:
+    """Every bound one publication may consume, stated before it consumes any of them."""
+
+    max_ranges: int = MAX_RANGE_DESCRIPTORS
+    max_entries: int = MAX_RANGE_DESCRIPTORS * RANGE_ENTRIES
+    max_terms_per_segment: int | None = None
+    max_disk_bytes: int = 64 * 1024 * 1024 * 1024
+    max_wall_seconds: int = 24 * 60 * 60
+
+    def __post_init__(self) -> None:
+        if type(self.max_ranges) is not int or not 1 <= self.max_ranges <= MAX_RANGE_DESCRIPTORS:
+            raise _refuse(
+                "PACKED_LIMIT",
+                "limits.max_ranges",
+                f"a generation holds 1 to {MAX_RANGE_DESCRIPTORS} ranges",
+            )
+        if type(self.max_entries) is not int or self.max_entries < 1:
+            raise _refuse("PACKED_LIMIT", "limits.max_entries", "must be a positive integer")
+        if type(self.max_disk_bytes) is not int or self.max_disk_bytes < 1:
+            raise _refuse("PACKED_LIMIT", "limits.max_disk_bytes", "must be a positive integer")
+        if type(self.max_wall_seconds) is not int or self.max_wall_seconds < 1:
+            raise _refuse("PACKED_LIMIT", "limits.max_wall_seconds", "must be a positive integer")
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "max_ranges": self.max_ranges,
+            "max_entries": self.max_entries,
+            "max_terms_per_segment": self.max_terms_per_segment,
+            "max_disk_bytes": self.max_disk_bytes,
+            "max_wall_seconds": self.max_wall_seconds,
+        }
+
+
+@dataclass(frozen=True)
+class PackedRangeProgress:
+    """One range that is durable on disk, handed to the caller's observer after it is installed."""
+
+    range_index: int
+    first_key: str
+    last_key: str
+    entry_count: int
+    fresh_entries: int
+    reused_entries: int
+    range_binding_sha256: str
+    posting_backend_coordinate: str
+    manifest_sha256: str
+    member_sha256s: tuple[tuple[str, str], ...]
+
+
+@dataclass(frozen=True)
+class PackedPublicationResult:
+    """One publication's exact durable outcome and its non-forgeable work evidence."""
+
+    status: str
+    head_sha256: str | None
+    journal_sha256: str
+    counters: dict[str, int]
+    counts: dict[str, int]
+    receipt: dict[str, Any]
+
+
+# ------------------------------------------------------------------------------------------
+# The publisher's only door to encoding
+# ------------------------------------------------------------------------------------------
+
+
+@dataclass
+class _Counters:
+    """Ordered sums of seam-minted records. Nothing here is ever set from an argument."""
+
+    batch_invocations: int = 0
+    encoded_layer_items: int = 0
+    backend_scalar_invocations: int = 0
+    encoded_utf8_bytes: int = 0
+    reused_layer_items: int = 0
+
+    def absorb(self, record: BatchEncodeResult) -> None:
+        self.batch_invocations += record.batch_invocations
+        self.encoded_layer_items += len(record.vectors)
+        self.backend_scalar_invocations += record.scalar_invocations
+        self.encoded_utf8_bytes += record.encoded_utf8_bytes
+
+    def absorb_record(self, record: Mapping[str, int]) -> None:
+        for name in COUNTER_MEMBERS:
+            setattr(self, name, getattr(self, name) + record[name])
+
+    def to_dict(self) -> dict[str, int]:
+        return {name: getattr(self, name) for name in COUNTER_MEMBERS}
+
+
+class _CountingSeam:
+    """One backend behind one counted door.
+
+    Every vector this publisher writes for a fresh entry comes through here, and every invocation
+    leaves its own seam-minted record behind. There is deliberately no other method: a second
+    encoding path would be a second accounting path.
+    """
+
+    def __init__(self, backend: EmbeddingBackend, counters: _Counters) -> None:
+        self._backend = backend
+        self._counters = counters
+        self.coordinate = backend.descriptor.coordinate
+        self.dimensions = backend.descriptor.dimensions
+
+    def encode_many(self, texts: Sequence[str]) -> tuple[tuple[int, ...], ...]:
+        vectors, record = encode_layer_batch(
+            self._backend,
+            texts,
+            entry_count=len(texts),
+            dimensions=self.dimensions,
+        )
+        if record.backend_coordinate != self.coordinate:
+            raise _refuse(
+                "PACKED_COUNTER_MISMATCH",
+                "packed.encode.record",
+                "a counter record names another backend than the one that was asked",
+            )
+        if record.adapter_mode != BOUNDED_SCALAR_ADAPTER:
+            raise _refuse(
+                "PACKED_COUNTER_ADAPTER",
+                "packed.encode.record.adapter_mode",
+                f"the only encoding adapter is {BOUNDED_SCALAR_ADAPTER!r}",
+            )
+        self._counters.absorb(record)
+        return vectors
+
+
+# ------------------------------------------------------------------------------------------
+# Bounded inputs
+# ------------------------------------------------------------------------------------------
+
+
+def _read_bounded(path: Path, *, maximum: int) -> bytes | None:
+    try:
+        return read_bounded_path(path, maximum=maximum, missing_ok=True)
+    except BoundedReadFailure as error:
+        raise _refuse(
+            "PACKED_INPUT_PATH",
+            "packed.input",
+            "input members must be stable bounded single-link regular files",
+        ) from error
+
+
+def _read_bounded_at(parent_descriptor: int, name: str, *, maximum: int) -> bytes | None:
+    try:
+        return read_bounded_at(parent_descriptor, name, maximum=maximum, missing_ok=True)
+    except BoundedReadFailure as error:
+        raise _refuse(
+            "PACKED_INPUT_PATH",
+            "packed.input",
+            "input members must be stable bounded single-link regular files",
+        ) from error
+
+
+@contextlib.contextmanager
+def _opened_directory_at(parent_descriptor: int, name: str) -> Iterator[int]:
+    descriptor = -1
+    try:
+        descriptor = os.open(name, _OPEN_DIRECTORY, dir_fd=parent_descriptor)
+        info = os.fstat(descriptor)
+        if not stat.S_ISDIR(info.st_mode):
+            raise OSError
+    except OSError as error:
+        if descriptor >= 0:
+            os.close(descriptor)
+        raise _refuse(
+            "PACKED_INPUT_PATH", "packed.input", "input directory is unreadable"
+        ) from error
+    try:
+        yield descriptor
+    finally:
+        os.close(descriptor)
+
+
+def _read_manifest(
+    path: Path,
+    *,
+    expected_sha256: str,
+    maximum: int,
+    schema: str,
+    label: str,
+    parent_descriptor: int | None = None,
+    name: str | None = None,
+) -> dict[str, Any]:
+    raw = (
+        _read_bounded(path, maximum=maximum)
+        if parent_descriptor is None
+        else _read_bounded_at(parent_descriptor, name or path.name, maximum=maximum)
+    )
+    if raw is None:
+        raise _refuse("PACKED_INPUT_MANIFEST", label, "no readable manifest at this root")
+    if sha256_bytes(raw) != expected_sha256:
+        raise _refuse(
+            "PACKED_INPUT_DIGEST", label, "the retained generation is not the caller's exact one"
+        )
+    try:
+        manifest = parse_canonical_json(raw)
+    except CanonicalJSONError as error:
+        raise _refuse("PACKED_INPUT_MANIFEST", label, "manifest is not canonical") from error
+    if (
+        not isinstance(manifest, dict)
+        or manifest.get("schema_version") != schema
+        or not _is_digest(manifest.get("root_sha256"))
+    ):
+        raise _refuse("PACKED_INPUT_MANIFEST", label, "manifest contract differs")
+    body = {key: value for key, value in manifest.items() if key != "root_sha256"}
+    if canonical_sha256(body) != manifest["root_sha256"]:
+        raise _refuse("PACKED_INPUT_MANIFEST", label, "manifest root digest differs")
+    return manifest
+
+
+class _ClassificationStream:
+    """The three publishable classification streams, merged into one ascending record stream."""
+
+    def __init__(
+        self,
+        root: Path,
+        manifest: Mapping[str, Any],
+        *,
+        shards_descriptor: int | None = None,
+    ) -> None:
+        self._root = Path(root) / DELTA_SHARDS_DIRNAME
+        self._shards_descriptor = shards_descriptor
+        shards = manifest["outputs"]["shards"]
+        if not isinstance(shards, list):
+            raise _refuse(
+                "PACKED_INPUT_MANIFEST", "delta.manifest.outputs.shards", "shard list differs"
+            )
+        self._descriptors: dict[str, list[Mapping[str, Any]]] = {
+            name: [] for name in PUBLISHABLE_CLASSIFICATIONS
+        }
+        for descriptor in shards:
+            if (
+                not isinstance(descriptor, dict)
+                or not _is_digest(descriptor.get("sha256"))
+                or type(descriptor.get("bytes")) is not int
+                or not 1 <= descriptor["bytes"] <= MAX_DELTA_SHARD_BYTES
+                or type(descriptor.get("item_count")) is not int
+                or descriptor["item_count"] < 1
+                or not isinstance(descriptor.get("classification"), str)
+            ):
+                raise _refuse(
+                    "PACKED_INPUT_MANIFEST",
+                    "delta.manifest.outputs.shards[]",
+                    "shard descriptor is invalid",
+                )
+            if descriptor["classification"] in self._descriptors:
+                self._descriptors[descriptor["classification"]].append(descriptor)
+        self._iterators = {name: self._items(name) for name in PUBLISHABLE_CLASSIFICATIONS}
+        self._peeked: dict[str, dict[str, Any] | None] = dict.fromkeys(PUBLISHABLE_CLASSIFICATIONS)
+        self._exhausted: dict[str, bool] = dict.fromkeys(PUBLISHABLE_CLASSIFICATIONS, False)
+        self._loaded: dict[str, bool] = dict.fromkeys(PUBLISHABLE_CLASSIFICATIONS, False)
+        self.max_resident_packs = 0
+
+    def _observe_residency(self) -> None:
+        resident = sum(1 for value in self._loaded.values() if value)
+        self.max_resident_packs = max(self.max_resident_packs, resident)
+
+    def _items(self, classification: str) -> Iterator[dict[str, Any]]:
+        last: bytes | None = None
+        for descriptor in self._descriptors[classification]:
+            name = f"{descriptor['sha256']}.json"
+            raw = (
+                _read_bounded(
+                    self._root / name,
+                    maximum=MAX_DELTA_SHARD_BYTES,
+                )
+                if self._shards_descriptor is None
+                else _read_bounded_at(
+                    self._shards_descriptor,
+                    name,
+                    maximum=MAX_DELTA_SHARD_BYTES,
+                )
+            )
+            if (
+                raw is None
+                or len(raw) != descriptor["bytes"]
+                or sha256_bytes(raw) != descriptor["sha256"]
+            ):
+                raise _refuse(
+                    "PACKED_INPUT_SHARD", "delta.shard", "a committed delta shard differs"
+                )
+            try:
+                payload = parse_canonical_json(raw)
+            except CanonicalJSONError as error:
+                raise _refuse(
+                    "PACKED_INPUT_SHARD", "delta.shard", "shard is not canonical"
+                ) from error
+            if (
+                not isinstance(payload, dict)
+                or not isinstance(payload.get("items"), list)
+                or len(payload["items"]) != descriptor["item_count"]
+                or payload.get("classification") != classification
+            ):
+                raise _refuse("PACKED_INPUT_SHARD", "delta.shard", "shard contract differs")
+            self._loaded[classification] = True
+            self._observe_residency()
+            for item in payload["items"]:
+                if (
+                    not isinstance(item, dict)
+                    or not isinstance(item.get("provider_record_id"), str)
+                    or not isinstance(item.get("entry_id"), str)
+                    or item.get("classification") != classification
+                ):
+                    raise _refuse(
+                        "PACKED_INPUT_SHARD", "delta.shard.items[]", "a delta item contract differs"
+                    )
+                key = item["provider_record_id"].encode("utf-8")
+                if last is not None and key <= last:
+                    raise _refuse(
+                        "PACKED_INPUT_ORDER",
+                        "delta.shards",
+                        "a classification stream must ascend by provider record",
+                    )
+                last = key
+                yield item
+            self._loaded[classification] = False
+            self._observe_residency()
+
+    def _peek(self, classification: str) -> dict[str, Any] | None:
+        if self._peeked[classification] is None and not self._exhausted[classification]:
+            self._peeked[classification] = next(self._iterators[classification], None)
+            if self._peeked[classification] is None:
+                self._exhausted[classification] = True
+        return self._peeked[classification]
+
+    def __iter__(self) -> Iterator[dict[str, Any]]:
+        last: bytes | None = None
+        while True:
+            live = {
+                name: item
+                for name in PUBLISHABLE_CLASSIFICATIONS
+                if (item := self._peek(name)) is not None
+            }
+            if not live:
+                return
+            key = min(item["provider_record_id"] for item in live.values())
+            owners = [name for name, item in live.items() if item["provider_record_id"] == key]
+            if len(owners) != 1:
+                raise _refuse(
+                    "PACKED_INPUT_ORDER",
+                    "delta.shards",
+                    "one provider record may hold only one publishable classification",
+                )
+            encoded = key.encode("utf-8")
+            if last is not None and encoded <= last:
+                raise _refuse(
+                    "PACKED_INPUT_ORDER", "delta.shards", "the merged stream must ascend by key"
+                )
+            last = encoded
+            item = self._peeked[owners[0]]
+            self._peeked[owners[0]] = None
+            assert item is not None
+            yield item
+
+
+class _AuthoredStream:
+    """One authored generation as one ascending record stream, one shard resident."""
+
+    def __init__(self, root: Path, manifest: Mapping[str, Any]) -> None:
+        self._root = Path(root)
+        self._manifest = manifest
+        if not isinstance(manifest.get("shards"), list):
+            raise _refuse(
+                "PACKED_INPUT_MANIFEST", "authoring.manifest.shards", "shard list differs"
+            )
+        self._iterator = self._records()
+        self._peeked: dict[str, Any] | None = None
+        self._exhausted = False
+        self.max_resident_shards = 0
+
+    def _records(self) -> Iterator[dict[str, Any]]:
+        last: bytes | None = None
+        for descriptor in self._manifest["shards"]:
+            if not shard_descriptor_is_valid(descriptor):
+                raise _refuse(
+                    "PACKED_INPUT_MANIFEST",
+                    "authoring.manifest.shards[]",
+                    "shard descriptor is invalid",
+                )
+            raw = _read_bounded(
+                self._root / SHARDS_DIRNAME / f"{descriptor['sha256']}.json",
+                maximum=MAX_AUTHORING_SHARD_BYTES,
+            )
+            if (
+                raw is None
+                or len(raw) != descriptor["bytes"]
+                or sha256_bytes(raw) != descriptor["sha256"]
+            ):
+                raise _refuse(
+                    "PACKED_INPUT_SHARD", "authoring.shard", "a committed authored shard differs"
+                )
+            try:
+                payload = parse_canonical_json(raw)
+            except CanonicalJSONError as error:
+                raise _refuse(
+                    "PACKED_INPUT_SHARD", "authoring.shard", "shard is not canonical"
+                ) from error
+            if (
+                not isinstance(payload, dict)
+                or payload.get("schema_version") != AUTHORING_SHARD_SCHEMA
+                or payload.get("policy_sha256") != self._manifest.get("policy_sha256")
+                or not isinstance(payload.get("items"), list)
+                or len(payload["items"]) != descriptor["item_count"]
+                or payload.get("first_provider_record_id") != descriptor["first_provider_record_id"]
+                or payload.get("last_provider_record_id") != descriptor["last_provider_record_id"]
+                or not payload["items"]
+                or not isinstance(payload["items"][0], dict)
+                or not isinstance(payload["items"][-1], dict)
+                or payload["items"][0].get("provider_record_id")
+                != descriptor["first_provider_record_id"]
+                or payload["items"][-1].get("provider_record_id")
+                != descriptor["last_provider_record_id"]
+                or sum(
+                    1
+                    for item in payload["items"]
+                    if isinstance(item, dict) and item.get("entry") is not None
+                )
+                != descriptor["entry_count"]
+            ):
+                raise _refuse("PACKED_INPUT_SHARD", "authoring.shard", "shard contract differs")
+            self.max_resident_shards = max(self.max_resident_shards, 1)
+            for item in payload["items"]:
+                if not isinstance(item, dict) or not isinstance(
+                    item.get("provider_record_id"), str
+                ):
+                    raise _refuse(
+                        "PACKED_INPUT_SHARD",
+                        "authoring.shard.items[]",
+                        "an authored item contract differs",
+                    )
+                key = item["provider_record_id"].encode("utf-8")
+                if last is not None and key <= last:
+                    raise _refuse(
+                        "PACKED_INPUT_ORDER",
+                        "authoring.shards",
+                        "an authored generation must ascend by provider record",
+                    )
+                last = key
+                yield item
+
+    def advance_to(self, record_id: str) -> dict[str, Any]:
+        while True:
+            if self._peeked is None and not self._exhausted:
+                self._peeked = next(self._iterator, None)
+                if self._peeked is None:
+                    self._exhausted = True
+            if self._peeked is None:
+                raise _refuse(
+                    "PACKED_INPUT_AUTHORING",
+                    "authoring.shards",
+                    "a classified record has no authored entry in this generation",
+                )
+            found = self._peeked["provider_record_id"]
+            if found == record_id:
+                item = self._peeked
+                self._peeked = None
+                return item
+            if found.encode("utf-8") > record_id.encode("utf-8"):
+                raise _refuse(
+                    "PACKED_INPUT_AUTHORING",
+                    "authoring.shards",
+                    "a classified record has no authored entry in this generation",
+                )
+            self._peeked = None
+
+
+class _HistoryStream:
+    """The successor identity generation as one ascending stream, one pack resident."""
+
+    def __init__(self, store: IdentityHistoryStore) -> None:
+        self._store = store
+        self._iterator = store.stream()
+        self._peeked: IdentityHistory | None = None
+        self._exhausted = False
+        self.max_resident_packs = 0
+
+    def advance_to(self, record_id: str) -> IdentityHistory:
+        while True:
+            if self._peeked is None and not self._exhausted:
+                self._peeked = next(self._iterator, None)
+                self.max_resident_packs = max(self.max_resident_packs, self._store.resident_packs)
+                if self._peeked is None:
+                    self._exhausted = True
+            if self._peeked is None:
+                raise _refuse(
+                    "PACKED_INPUT_IDENTITY",
+                    "identity.records",
+                    "a classified record has no identity history in this generation",
+                )
+            found = self._peeked.identity.provider_record_id
+            if found == record_id:
+                history = self._peeked
+                self._peeked = None
+                return history
+            if found.encode("utf-8") > record_id.encode("utf-8"):
+                raise _refuse(
+                    "PACKED_INPUT_IDENTITY",
+                    "identity.records",
+                    "a classified record has no identity history in this generation",
+                )
+            self._peeked = None
+
+
+class _PredecessorPacks:
+    """One predecessor packed generation, read one range at a time in ascending key order."""
+
+    def __init__(self, directory: PackedDirectory, head: Mapping[str, Any]) -> None:
+        self._directory = directory
+        self._descriptors = [
+            range_descriptor_from_dict(value, path=f"predecessor.head.ranges[{index}]")
+            for index, value in enumerate(head["ranges"])
+        ]
+        self._backends = {item["coordinate"]: item["dimensions"] for item in head["backends"]}
+        self._position = 0
+        self._resident: int | None = None
+        self._ordinals: dict[str, int] = {}
+        self._vectors: dict[str, dict[str, tuple[tuple[int, ...], ...]]] = {}
+        self.max_resident_ranges = 0
+
+    def require_backends(self, coordinates: Sequence[str]) -> None:
+        missing = [name for name in coordinates if name not in self._backends]
+        if missing:
+            raise _refuse(
+                "PACKED_REUSE_BACKEND",
+                "predecessor.backends",
+                "the predecessor generation has no packs for a backend this publication reuses",
+            )
+
+    def lookup(self, key: str) -> dict[str, dict[str, tuple[int, ...]]]:
+        encoded = key.encode("utf-8")
+        while self._position < len(self._descriptors):
+            if encoded <= self._descriptors[self._position].last_key.encode("utf-8"):
+                break
+            self._position += 1
+        if self._position >= len(self._descriptors):
+            raise _refuse(
+                "PACKED_REUSE_MISSING",
+                "predecessor.ranges",
+                "an unchanged entry has no predecessor pack to reuse",
+            )
+        if self._resident != self._position:
+            self._load(self._position)
+        ordinal = self._ordinals.get(key)
+        if ordinal is None:
+            raise _refuse(
+                "PACKED_REUSE_MISSING",
+                "predecessor.ranges",
+                "an unchanged entry has no predecessor pack to reuse",
+            )
+        return {
+            coordinate: {layer: vectors[ordinal] for layer, vectors in layers.items()}
+            for coordinate, layers in self._vectors.items()
+        }
+
+    def _load(self, position: int) -> None:
+        descriptor = self._descriptors[position]
+        raw = self._directory.read_member(
+            descriptor.manifest_sha256, kind="range", maximum=MAX_RANGE_MANIFEST_BYTES
+        )
+        if raw is None or sha256_bytes(raw) != descriptor.manifest_sha256:
+            raise _refuse(
+                "PACKED_REUSE_MEMBER",
+                "predecessor.range.manifest",
+                "a predecessor range manifest is not the manifest its head binds",
+            )
+        manifest = parse_canonical_json(raw)
+        members = [
+            member_descriptor_from_dict(value, path="predecessor.range.members[]")
+            for value in manifest["members"]
+        ]
+        facts = self._member(_only(members, "facts"), maximum=MAX_FACTS_MEMBER_BYTES)
+        payload = parse_canonical_json(facts)
+        self._ordinals = {item["key"]: ordinal for ordinal, item in enumerate(payload["entries"])}
+        vectors: dict[str, dict[str, tuple[tuple[int, ...], ...]]] = {}
+        for member in members:
+            if member.kind != "vector":
+                continue
+            raw_member = self._member(member, maximum=MAX_VECTOR_MEMBER_BYTES)
+            parsed = parse_vector_member(raw_member, descriptor=member)
+            vectors.setdefault(member.backend_coordinate or "", {})[parsed.layer] = parsed.vectors
+        self._vectors = vectors
+        self._resident = position
+        self.max_resident_ranges = max(self.max_resident_ranges, 1)
+
+    def _member(self, descriptor: Any, *, maximum: int) -> bytes:
+        raw = self._directory.read_member(descriptor.sha256, kind=descriptor.kind, maximum=maximum)
+        if raw is None or len(raw) != descriptor.bytes or sha256_bytes(raw) != descriptor.sha256:
+            raise _refuse(
+                "PACKED_REUSE_MEMBER",
+                "predecessor.range.members[]",
+                "a predecessor member is not the member its descriptor binds",
+            )
+        return raw
+
+
+def _only(descriptors: Sequence[Any], kind: str) -> Any:
+    found = [descriptor for descriptor in descriptors if descriptor.kind == kind]
+    if len(found) != 1:
+        raise _refuse(
+            "PACKED_REUSE_MEMBER",
+            "predecessor.range.members[]",
+            f"a predecessor range carries exactly one {kind} member",
+        )
+    return found[0]
+
+
+# ------------------------------------------------------------------------------------------
+# The work journal
+# ------------------------------------------------------------------------------------------
+
+
+#: Exactly what one completed-range record carries. A resume reads nothing else from it, and a
+#: record carrying anything else is a record this publisher did not write.
+_COMPLETED_RANGE_MEMBERS = frozenset(
+    {
+        "range_index",
+        "first_key",
+        "last_key",
+        "entry_count",
+        "facts_sha256",
+        "range_binding_sha256",
+        "range_manifest_sha256",
+        "range_manifest_bytes",
+        "member_sha256s",
+        "vector_payload_sha256s",
+    }
+)
+
+
+@dataclass
+class _Journal:
+    """The typed work journal an interruption leaves behind and a resume validates."""
+
+    output_root: str
+    generation: dict[str, Any]
+    completed_ranges: list[dict[str, Any]] = field(default_factory=list)
+    invocations: list[dict[str, Any]] = field(default_factory=list)
+
+    def body(self, *, status: str, head_sha256: str | None) -> dict[str, Any]:
+        return {
+            "schema_version": PACKED_JOURNAL_SCHEMA,
+            "status": status,
+            "output_root": self.output_root,
+            "generation": self.generation,
+            "completed_ranges": list(self.completed_ranges),
+            "invocations": list(self.invocations),
+            "head_sha256": head_sha256,
+        }
+
+    def document(self, *, status: str, head_sha256: str | None) -> dict[str, Any]:
+        body = self.body(status=status, head_sha256=head_sha256)
+        return {**body, "root_sha256": canonical_sha256(body)}
+
+
+def _read_journal(directory: PackedDirectory) -> dict[str, Any] | None:
+    raw = directory.read(PACKED_JOURNAL_FILENAME, maximum=MAX_PACKED_JOURNAL_BYTES)
+    if raw is None:
+        return None
+    try:
+        journal = parse_canonical_json(raw)
+    except CanonicalJSONError as error:
+        raise _refuse(
+            "PACKED_JOURNAL_DIGEST", "packed.journal", "the work journal is not canonical"
+        ) from error
+    if (
+        not isinstance(journal, dict)
+        or journal.get("schema_version") != PACKED_JOURNAL_SCHEMA
+        or not _is_digest(journal.get("root_sha256"))
+        or not isinstance(journal.get("completed_ranges"), list)
+        or not isinstance(journal.get("invocations"), list)
+        or not isinstance(journal.get("generation"), dict)
+    ):
+        raise _refuse(
+            "PACKED_JOURNAL_DIGEST", "packed.journal", "the work journal contract differs"
+        )
+    body = {key: value for key, value in journal.items() if key != "root_sha256"}
+    if canonical_sha256(body) != journal["root_sha256"]:
+        raise _refuse(
+            "PACKED_JOURNAL_DIGEST",
+            "packed.journal.root_sha256",
+            "the work journal does not reproduce its own digest",
+        )
+    # The journal's digest is its own, not a secret's, so a rewriter can mint a consistent one.
+    # Every record it carries is therefore re-derived rather than believed: the counter records
+    # below only survive because the equations at the end of a publication must still hold.
+    for position, record in enumerate(journal["invocations"]):
+        if not isinstance(record, dict) or set(record) != set(COUNTER_MEMBERS):
+            raise _refuse(
+                "PACKED_JOURNAL_COUNTER",
+                f"packed.journal.invocations[{position}]",
+                f"one invocation record carries exactly {list(COUNTER_MEMBERS)}",
+            )
+        for name in COUNTER_MEMBERS:
+            if type(record[name]) is not int or record[name] < 0:
+                raise _refuse(
+                    "PACKED_JOURNAL_COUNTER",
+                    f"packed.journal.invocations[{position}].{name}",
+                    "a work counter is a non-negative integer",
+                )
+    return journal
+
+
+def _resume_from(
+    directory: PackedDirectory,
+    journal: dict[str, Any],
+    *,
+    output_root: Path,
+    generation: Mapping[str, Any],
+) -> _Journal:
+    if journal["status"] != "incomplete" or journal["head_sha256"] is not None:
+        raise _refuse(
+            "PACKED_JOURNAL_STATUS",
+            "packed.journal.status",
+            "only a typed-incomplete journal may be resumed",
+        )
+    if journal["output_root"] != os.path.abspath(os.fspath(output_root)):
+        raise _refuse(
+            "PACKED_JOURNAL_ROOT",
+            "packed.journal.output_root",
+            "the journal was written for another output root",
+        )
+    if journal["generation"] != dict(generation):
+        raise _refuse(
+            "PACKED_JOURNAL_GENERATION",
+            "packed.journal.generation",
+            "the journal was written for another generation coordinate",
+        )
+    for position, completed in enumerate(journal["completed_ranges"]):
+        if (
+            not isinstance(completed, dict)
+            or set(completed) != _COMPLETED_RANGE_MEMBERS
+            or completed["range_index"] != position
+            or not _is_digest(completed["range_manifest_sha256"])
+            or not _is_digest(completed["facts_sha256"])
+            or not _is_digest(completed["range_binding_sha256"])
+            or not isinstance(completed["member_sha256s"], list)
+            or not isinstance(completed["vector_payload_sha256s"], list)
+            or type(completed["entry_count"]) is not int
+        ):
+            raise _refuse(
+                "PACKED_JOURNAL_RANGE",
+                f"packed.journal.completed_ranges[{position}]",
+                "a completed range record contract differs",
+            )
+        payloads: list[str] = []
+        for entry in [
+            ["range", completed["range_manifest_sha256"]],
+            *completed["member_sha256s"],
+        ]:
+            if not isinstance(entry, list) or len(entry) != 2:
+                raise _refuse(
+                    "PACKED_JOURNAL_RANGE",
+                    f"packed.journal.completed_ranges[{position}].member_sha256s[]",
+                    "a completed member record is exactly one kind and one digest",
+                )
+            kind, sha256 = entry
+            if kind not in MEMBER_MAXIMUM_BYTES or not _is_digest(sha256):
+                raise _refuse(
+                    "PACKED_JOURNAL_RANGE",
+                    f"packed.journal.completed_ranges[{position}].member_sha256s[]",
+                    "a completed member record names a known kind and an exact digest",
+                )
+            raw = directory.read_member(sha256, kind=kind, maximum=MEMBER_MAXIMUM_BYTES[kind])
+            if raw is None or sha256_bytes(raw) != sha256:
+                raise _refuse(
+                    "PACKED_JOURNAL_MEMBER",
+                    f"packed.journal.completed_ranges[{position}]",
+                    "an already-emitted immutable member does not read back exactly",
+                )
+            if kind == "vector":
+                payloads.append(sha256_bytes(raw[MEMBER_HEADER_BYTES:]))
+        # The receipt states these, so they are recomputed from the member bytes this loop just
+        # read rather than carried over from a journal that a rewriter could have restated.
+        if payloads != list(completed["vector_payload_sha256s"]):
+            raise _refuse(
+                "PACKED_JOURNAL_MEMBER",
+                f"packed.journal.completed_ranges[{position}].vector_payload_sha256s",
+                "a completed range's vector payload digests are not the digests of its own packs",
+            )
+    return _Journal(
+        output_root=journal["output_root"],
+        generation=dict(journal["generation"]),
+        completed_ranges=list(journal["completed_ranges"]),
+        invocations=list(journal["invocations"]),
+    )
+
+
+def _verify_recovery_ranges(
+    directory: PackedDirectory,
+    installed: VerifiedPackedGeneration,
+    *,
+    completed_ranges: Sequence[Mapping[str, Any]],
+    delta_root: Path,
+    delta_manifest: Mapping[str, Any],
+    delta_shards_descriptor: int | None,
+    identity_descriptor: int | None,
+    authoring_root: Path,
+    authoring_manifest: Mapping[str, Any],
+    identity_manifest_sha256: str,
+    packed_backends: Sequence[PackedBackend],
+    seam_backends: Sequence[EmbeddingBackend],
+    posting_backend: PackedBackend,
+    predecessor: _PredecessorPacks | None,
+    limits: PackedLimits,
+    deadline: float,
+) -> tuple[dict[str, int], dict[str, int]]:
+    """Replay the exact retained generation and bind every installed range to those inputs."""
+
+    classification = _ClassificationStream(
+        delta_root, delta_manifest, shards_descriptor=delta_shards_descriptor
+    )
+    authored = _AuthoredStream(authoring_root, authoring_manifest)
+    identity = _HistoryStream(
+        IdentityHistoryStore.open(
+            delta_root / DELTA_IDENTITY_DIRNAME,
+            expected_manifest_sha256=identity_manifest_sha256,
+            root_descriptor=identity_descriptor,
+        )
+    )
+    counters = _Counters()
+    seams = {
+        backend.descriptor.coordinate: _CountingSeam(backend, counters) for backend in seam_backends
+    }
+    counts = {
+        "ranges": 0,
+        "entries": 0,
+        "fresh_ranges": 0,
+        "new": 0,
+        "changed": 0,
+        "unchanged": 0,
+        "members": 0,
+    }
+    for range_index, entries in enumerate(_ranges(classification, authored, identity)):
+        if range_index >= limits.max_ranges:
+            raise _refuse(
+                "PACKED_RANGE_LIMIT",
+                "packed.terminal",
+                "terminal recovery exceeds the declared range bound",
+            )
+        if time.monotonic() >= deadline:
+            raise _refuse(
+                "PACKED_WALL_LIMIT",
+                "packed.terminal",
+                "terminal recovery exceeded its declared wall bound",
+            )
+        if range_index >= len(completed_ranges) or range_index >= len(installed.head["ranges"]):
+            raise _refuse(
+                "PACKED_TERMINAL_RANGE",
+                "packed.terminal.journal.completed_ranges",
+                "the terminal record omits a range produced by the retained inputs",
+            )
+        range_input = PackedRangeInput(
+            range_index=range_index, entries=tuple(item.to_entry() for item in entries)
+        )
+        completed = completed_ranges[range_index]
+        _verify_completed_range(directory, completed, range_input)
+
+        fresh = tuple(
+            position
+            for position, item in enumerate(entries)
+            if item.classification in FRESH_CLASSIFICATIONS
+        )
+        fresh_positions = set(fresh)
+        reused = tuple(
+            position for position in range(len(entries)) if position not in fresh_positions
+        )
+        if reused and predecessor is None:
+            raise _refuse(
+                "PACKED_PREDECESSOR_REQUIRED",
+                "predecessor",
+                "an unchanged entry can only be verified against the packs it reuses",
+            )
+        recovered: dict[int, dict[str, dict[str, tuple[int, ...]]]] = {}
+        for position in reused:
+            assert predecessor is not None
+            recovered[position] = predecessor.lookup(entries[position].key)
+
+        # All terminal files are locally rewriteable. For a fresh entry no retained artifact other
+        # than a deterministic backend replay can prove that a vector came from its exact layer
+        # text, so recovery performs that replay before it mutates the journal.
+        vectors: dict[str, dict[str, tuple[tuple[int, ...], ...]]] = {}
+        for backend in packed_backends:
+            seam = seams[backend.coordinate]
+            layers: dict[str, tuple[tuple[int, ...], ...]] = {}
+            for layer in EMBEDDING_LAYERS:
+                column: list[tuple[int, ...] | None] = [None] * len(entries)
+                if fresh:
+                    encoded = seam.encode_many(
+                        tuple(entries[position].layer_texts[layer] for position in fresh)
+                    )
+                    for position, vector in zip(fresh, encoded, strict=True):
+                        column[position] = vector
+                for position in reused:
+                    vector = recovered[position].get(backend.coordinate, {}).get(layer)
+                    if vector is None or len(vector) != backend.dimensions:
+                        raise _refuse(
+                            "PACKED_REUSE_MISSING",
+                            "predecessor.ranges",
+                            "an unchanged entry has no reusable layer vector for this backend",
+                        )
+                    column[position] = vector
+                layers[layer] = tuple(value for value in column if value is not None)
+                if len(layers[layer]) != len(entries):  # pragma: no cover - filled above
+                    raise _refuse(
+                        "PACKED_RANGE_ENTRY",
+                        "packed.range.vectors",
+                        "a layer member does not cover every entry in its range",
+                    )
+            vectors[backend.coordinate] = layers
+
+        built = build_packed_range(
+            range_input,
+            vectors,
+            backends=packed_backends,
+            posting_backend_coordinate=posting_backend.coordinate,
+            max_terms_per_segment=limits.max_terms_per_segment,
+        )
+        expected_completed = _completed_range_record(built)
+        if dict(completed) != expected_completed or installed.head["ranges"][range_index] != (
+            built.descriptor.to_dict()
+        ):
+            raise _refuse(
+                "PACKED_TERMINAL_RANGE",
+                f"packed.terminal.journal.completed_ranges[{range_index}]",
+                "an installed range is not the exact range reproduced from the retained inputs",
+            )
+        counts["ranges"] += 1
+        counts["entries"] += len(entries)
+        counts["fresh_ranges"] += 1 if fresh else 0
+        counts["members"] += len(built.members)
+        counters.reused_layer_items += len(reused) * len(EMBEDDING_LAYERS) * len(packed_backends)
+        for item in entries:
+            counts[item.classification] += 1
+
+    if len(completed_ranges) != counts["ranges"] or counts["entries"] > limits.max_entries:
+        raise _refuse(
+            "PACKED_TERMINAL_RANGE",
+            "packed.terminal.journal.completed_ranges",
+            "the terminal range list differs from the retained generation",
+        )
+    if (
+        counts["ranges"] != installed.range_count
+        or counts["entries"] != installed.entry_count
+        or counts["members"] != installed.member_count
+        or counts["fresh_ranges"] != installed.fresh_range_count
+        or {name: counts[name] for name in PUBLISHABLE_CLASSIFICATIONS}
+        != dict(installed.classification_counts)
+    ):
+        raise _refuse(
+            "PACKED_TERMINAL_COUNTER",
+            "packed.terminal.receipt.counts",
+            "terminal recovery inputs do not reproduce the installed generation",
+        )
+    _verify_counter_equations(counters, counts, backend_count=len(packed_backends))
+    return counts, counters.to_dict()
+
+
+def _canonical_residency(
+    counts: Mapping[str, int], generation: Mapping[str, Any]
+) -> dict[str, int]:
+    """State deterministic streaming bounds, not unauthenticatable process observations."""
+
+    return {
+        "max_resident_classification_packs": sum(
+            1 for name in PUBLISHABLE_CLASSIFICATIONS if counts[name] > 0
+        ),
+        "max_resident_authoring_shards": 1,
+        "max_resident_identity_packs": 1,
+        "max_resident_output_ranges": 1,
+        "max_resident_predecessor_ranges": (
+            0 if generation["predecessor_head_sha256"] is None else 1
+        ),
+    }
+
+
+def _verified_receipt_outputs(installed: VerifiedPackedGeneration) -> dict[str, Any]:
+    """Derive every receipt output from the generation's independently verified bytes."""
+
+    return {
+        "range_count": installed.range_count,
+        "entry_count": installed.entry_count,
+        "member_count": installed.member_count,
+        "posting_term_count": installed.posting_term_count,
+        "ranges": list(installed.head["ranges"]),
+        "ranges_chain_sha256": installed.head["ranges_chain_sha256"],
+        "vector_member_sha256s": list(installed.vector_payload_sha256s),
+        "posting_member_sha256s": list(installed.posting_member_sha256s),
+        "bound_member_sha256s": list(installed.bound_member_sha256s),
+    }
+
+
+def _verify_recovery_evidence(
+    installed: VerifiedPackedGeneration,
+    *,
+    terminal: Mapping[str, Any],
+    journal_template: Mapping[str, Any],
+    journal: Mapping[str, Any],
+    expected_counts: Mapping[str, int],
+    expected_counters: Mapping[str, int],
+    delta_manifest: Mapping[str, Any],
+    packed_backends: Sequence[PackedBackend],
+    posting_backend: PackedBackend,
+    limits: PackedLimits,
+) -> None:
+    """Rebuild every terminal receipt claim from caller inputs and verified member bytes."""
+
+    receipt = terminal.get("receipt")
+    if not isinstance(receipt, Mapping):
+        raise _refuse("PACKED_TERMINAL_SCHEMA", "packed.terminal.receipt", "receipt differs")
+    invocations = receipt.get("invocations")
+    canonical_invocations = [dict(expected_counters)]
+    expected_outputs = _verified_receipt_outputs(installed)
+    expected_receipt = {
+        "schema_version": PACKED_RECEIPT_SCHEMA,
+        "status": "complete",
+        "provider_id": terminal["generation"]["provider_id"],
+        "adapter_mode": BOUNDED_SCALAR_ADAPTER,
+        # Rebuilt from the *installed head*, not carried over from the retained receipt, so a
+        # recovery reconciles the two documents against each other rather than believing either.
+        # `_parse_head` has already required the head's statement to be a coverage at all.
+        "coverage": dict(installed.head["coverage"]),
+        "inputs": {
+            "delta_manifest_sha256": terminal["generation"]["delta_manifest_sha256"],
+            "delta_root_sha256": delta_manifest["root_sha256"],
+            "authoring_manifest_sha256": terminal["generation"]["authoring_manifest_sha256"],
+            "identity_manifest_sha256": terminal["generation"]["identity_manifest_sha256"],
+            "predecessor_head_sha256": terminal["generation"]["predecessor_head_sha256"],
+            "publication_binding_sha256": terminal["generation"].get("publication_binding_sha256"),
+        },
+        "backends": [backend.to_dict() for backend in packed_backends],
+        "posting_backend_coordinate": posting_backend.coordinate,
+        "counts": dict(expected_counts),
+        "counters": dict(expected_counters),
+        "invocations": canonical_invocations,
+        "outputs": expected_outputs,
+        "residency": _canonical_residency(expected_counts, terminal["generation"]),
+        "limits": limits.to_dict(),
+    }
+    if (
+        dict(receipt) != expected_receipt
+        or installed.head.get("provider_id") != terminal["generation"]["provider_id"]
+        or installed.head.get("generation_sha256")
+        != terminal["generation"]["delta_manifest_sha256"]
+        or installed.head.get("predecessor_head_sha256")
+        != terminal["generation"]["predecessor_head_sha256"]
+        or installed.head.get("backends") != expected_receipt["backends"]
+        or installed.head.get("posting_backend_coordinate") != posting_backend.coordinate
+        or installed.head.get("counters") != dict(expected_counters)
+        or invocations != canonical_invocations
+        or installed.head.get("invocations") != canonical_invocations
+        or journal_template.get("invocations") != canonical_invocations
+        or journal.get("invocations") != canonical_invocations
+    ):
+        raise _refuse(
+            "PACKED_TERMINAL_COUNTER",
+            "packed.terminal.receipt",
+            "terminal work evidence does not reproduce from the installed generation",
+        )
+
+
+def _recover_terminal_publication(
+    directory: PackedDirectory,
+    *,
+    output_root: Path,
+    generation: Mapping[str, Any],
+    head_raw: bytes,
+    delta_root: Path,
+    delta_manifest: Mapping[str, Any],
+    delta_shards_descriptor: int | None,
+    identity_descriptor: int | None,
+    authoring_root: Path,
+    authoring_manifest: Mapping[str, Any],
+    packed_backends: Sequence[PackedBackend],
+    seam_backends: Sequence[EmbeddingBackend],
+    posting_backend: PackedBackend,
+    predecessor: _PredecessorPacks | None,
+    limits: PackedLimits,
+    deadline: float,
+) -> PackedPublicationResult:
+    """Finish the evidence transaction a hard kill left after installing the packed head."""
+
+    head_sha256 = sha256_bytes(head_raw)
+    installed = verify_packed_generation(
+        output_root,
+        expected_head_sha256=head_sha256,
+        root_descriptor=directory.root_descriptor,
+    )
+    terminal_raw = directory.read(PACKED_TERMINAL_FILENAME, maximum=MAX_PACKED_TERMINAL_BYTES)
+    if terminal_raw is None or sha256_bytes(terminal_raw) != installed.head["terminal_sha256"]:
+        raise _refuse(
+            "PACKED_TERMINAL_DIGEST",
+            "packed.terminal",
+            "the published head does not have its exact terminal record",
+        )
+    terminal = _parse_terminal(terminal_raw)
+    if terminal["generation"] != dict(generation):
+        raise _refuse(
+            "PACKED_TERMINAL_GENERATION",
+            "packed.terminal.generation",
+            "the published terminal record belongs to another generation",
+        )
+    template = terminal["journal"]
+    if (
+        set(template) != {"output_root", "generation", "completed_ranges", "invocations"}
+        or template["output_root"] != os.path.abspath(os.fspath(output_root))
+        or template["generation"] != dict(generation)
+        or not isinstance(template["completed_ranges"], list)
+        or not isinstance(template["invocations"], list)
+    ):
+        raise _refuse(
+            "PACKED_TERMINAL_SCHEMA",
+            "packed.terminal.journal",
+            "the terminal journal template differs from this generation",
+        )
+    existing = _read_journal(directory)
+    if existing is None:
+        raise _refuse(
+            "PACKED_JOURNAL_MISSING",
+            "packed.journal",
+            "terminal recovery requires the publication journal",
+        )
+    if existing["completed_ranges"] != template["completed_ranges"]:
+        raise _refuse(
+            "PACKED_JOURNAL_DIGEST",
+            "packed.journal.completed_ranges",
+            "the publication journal differs from the head-bound terminal ranges",
+        )
+    expected_counts, expected_counters = _verify_recovery_ranges(
+        directory,
+        installed,
+        completed_ranges=existing["completed_ranges"],
+        delta_root=delta_root,
+        delta_manifest=delta_manifest,
+        delta_shards_descriptor=delta_shards_descriptor,
+        identity_descriptor=identity_descriptor,
+        authoring_root=authoring_root,
+        authoring_manifest=authoring_manifest,
+        identity_manifest_sha256=generation["identity_manifest_sha256"],
+        packed_backends=packed_backends,
+        seam_backends=seam_backends,
+        posting_backend=posting_backend,
+        predecessor=predecessor,
+        limits=limits,
+        deadline=deadline,
+    )
+    _verify_recovery_evidence(
+        installed,
+        terminal=terminal,
+        journal_template=template,
+        journal=existing,
+        expected_counts=expected_counts,
+        expected_counters=expected_counters,
+        delta_manifest=delta_manifest,
+        packed_backends=packed_backends,
+        posting_backend=posting_backend,
+        limits=limits,
+    )
+    final_journal = _Journal(
+        output_root=template["output_root"],
+        generation=dict(template["generation"]),
+        completed_ranges=[dict(item) for item in template["completed_ranges"]],
+        invocations=[dict(item) for item in template["invocations"]],
+    ).document(status="complete", head_sha256=head_sha256)
+    journal_sha256 = sha256_bytes(canonical_json_bytes(final_journal))
+    if existing.get("status") == "incomplete" and existing.get("head_sha256") is None:
+        incomplete = _Journal(
+            output_root=template["output_root"],
+            generation=dict(template["generation"]),
+            completed_ranges=[dict(item) for item in template["completed_ranges"]],
+            invocations=[dict(item) for item in template["invocations"]],
+        ).document(status="incomplete", head_sha256=None)
+        if existing != incomplete:
+            raise _refuse(
+                "PACKED_JOURNAL_DIGEST",
+                "packed.journal",
+                "the incomplete journal differs from the head-bound terminal record",
+            )
+        if (
+            directory.publish(
+                PACKED_JOURNAL_FILENAME, final_journal, maximum=MAX_PACKED_JOURNAL_BYTES
+            )
+            != journal_sha256
+        ):
+            raise _refuse(
+                "PACKED_JOURNAL_DIGEST",
+                "packed.journal",
+                "the completed journal differs from the head-bound terminal record",
+            )
+    elif existing != final_journal:
+        raise _refuse(
+            "PACKED_JOURNAL_DIGEST",
+            "packed.journal",
+            "the complete journal differs from the head-bound terminal record",
+        )
+    receipt = _receipt_from_terminal(
+        terminal, head_sha256=head_sha256, journal_sha256=journal_sha256
+    )
+    verify_packed_receipt(receipt, root=output_root, root_descriptor=directory.root_descriptor)
+    counts = receipt.get("counts")
+    counters = receipt.get("counters")
+    if not isinstance(counts, dict) or not isinstance(counters, dict):
+        raise _refuse("PACKED_TERMINAL_SCHEMA", "packed.terminal.receipt", "work totals differ")
+    return PackedPublicationResult(
+        status="complete",
+        head_sha256=head_sha256,
+        journal_sha256=journal_sha256,
+        counters=dict(counters),
+        counts=dict(counts),
+        receipt=receipt,
+    )
+
+
+# ------------------------------------------------------------------------------------------
+# Publication
+# ------------------------------------------------------------------------------------------
+
+
+def publish_packed_generation(
+    *,
+    delta_root: Path,
+    expected_delta_manifest_sha256: str,
+    authoring_root: Path,
+    expected_authoring_manifest_sha256: str,
+    output_root: Path,
+    output_descriptor: int | None = None,
+    delta_descriptor: int | None = None,
+    backends: Sequence[EmbeddingBackend],
+    predecessor_root: Path | None = None,
+    expected_predecessor_head_sha256: str | None = None,
+    expected_predecessor_generation_sha256: str | None = None,
+    limits: PackedLimits | None = None,
+    resume: bool = False,
+    publication_binding_sha256: str | None = None,
+    after_range: Callable[[PackedRangeProgress], None] | None = None,
+) -> PackedPublicationResult:
+    """Publish one classified sweep as one packed generation, counting its own work exactly."""
+
+    bounds = PackedLimits() if limits is None else limits
+    if not isinstance(bounds, PackedLimits):
+        raise _refuse("PACKED_LIMIT", "limits", "must be PackedLimits")
+    if type(resume) is not bool:
+        raise _refuse("PACKED_CONTRACT", "resume", "must be a boolean")
+    if publication_binding_sha256 is not None and not _is_digest(publication_binding_sha256):
+        raise _refuse(
+            "PACKED_CONTRACT",
+            "publication_binding_sha256",
+            "must be a lowercase SHA-256 when the caller binds external generation evidence",
+        )
+    packed_backends, seam_backends = _resolve_backends(backends)
+    posting_backend = _posting_backend(packed_backends)
+    predecessor_coordinates = (
+        predecessor_root,
+        expected_predecessor_head_sha256,
+        expected_predecessor_generation_sha256,
+    )
+    if any(value is None for value in predecessor_coordinates) and not all(
+        value is None for value in predecessor_coordinates
+    ):
+        raise _refuse(
+            "PACKED_PREDECESSOR_REQUIRED",
+            "predecessor",
+            "a predecessor is named by its root, exact head digest, and exact generation digest, "
+            "or not at all",
+        )
+    if expected_predecessor_generation_sha256 is not None and not _is_digest(
+        expected_predecessor_generation_sha256
+    ):
+        raise _refuse(
+            "PACKED_PREDECESSOR_GENERATION",
+            "predecessor.generation_sha256",
+            "must be a lowercase SHA-256 digest",
+        )
+    deadline = time.monotonic() + bounds.max_wall_seconds
+
+    delta_manifest = _read_manifest(
+        Path(delta_root) / DELTA_MANIFEST_FILENAME,
+        expected_sha256=expected_delta_manifest_sha256,
+        maximum=MAX_DELTA_MANIFEST_BYTES,
+        schema=DELTA_MANIFEST_SCHEMA,
+        label="delta.manifest",
+        parent_descriptor=delta_descriptor,
+        name=DELTA_MANIFEST_FILENAME,
+    )
+    authoring_manifest = _read_manifest(
+        Path(authoring_root) / MANIFEST_FILENAME,
+        expected_sha256=expected_authoring_manifest_sha256,
+        maximum=MAX_AUTHORING_MANIFEST_BYTES,
+        schema=AUTHORING_MANIFEST_SCHEMA,
+        label="authoring.manifest",
+    )
+    if delta_manifest["inputs"]["authoring_manifest_sha256"] != expected_authoring_manifest_sha256:
+        raise _refuse(
+            "PACKED_INPUT_GENERATION",
+            "authoring.manifest",
+            "the classification was computed from another authored generation",
+        )
+    admit_authored_generation(Path(authoring_root), authoring_manifest)
+    # Validate every classification descriptor while output is still absent. Shard bytes stay
+    # lazy and bounded, but no caller-controlled size can defer a fixed-ceiling refusal until
+    # publication has opened or mutated its output root.
+    _ClassificationStream(Path(delta_root), delta_manifest)
+    identity_manifest_sha256 = delta_manifest["outputs"]["identity_manifest_sha256"]
+    provider_id = delta_manifest["inputs"]["provider_id"]
+
+    generation = {
+        "authoring_manifest_sha256": expected_authoring_manifest_sha256,
+        "backends": [backend.coordinate for backend in packed_backends],
+        "delta_manifest_sha256": expected_delta_manifest_sha256,
+        "identity_manifest_sha256": identity_manifest_sha256,
+        "posting_backend_coordinate": posting_backend.coordinate,
+        "predecessor_head_sha256": expected_predecessor_head_sha256,
+        "provider_id": provider_id,
+    }
+    if publication_binding_sha256 is not None:
+        generation["publication_binding_sha256"] = publication_binding_sha256
+
+    # Authenticate the complete predecessor coordinate before the output root is opened. The
+    # predecessor is opened again under the publication stack below so its descriptor remains
+    # retained while vectors are read; both reads require the same exact head bytes and generation.
+    if predecessor_root is not None:
+        predecessor_preflight = PackedDirectory(Path(predecessor_root))
+        with predecessor_preflight.opened():
+            _read_predecessor_head(
+                predecessor_preflight,
+                expected_predecessor_head_sha256,
+                expected_predecessor_generation_sha256,
+            )
+
+    directory = PackedDirectory(Path(output_root), root_descriptor=output_descriptor)
+    with directory.opened(), contextlib.ExitStack() as input_stack:
+        delta_shards_descriptor = None
+        identity_descriptor = None
+        if delta_descriptor is not None:
+            delta_shards_descriptor = input_stack.enter_context(
+                _opened_directory_at(delta_descriptor, DELTA_SHARDS_DIRNAME)
+            )
+            identity_descriptor = input_stack.enter_context(
+                _opened_directory_at(delta_descriptor, DELTA_IDENTITY_DIRNAME)
+            )
+        head_raw = directory.read(PACKED_HEAD_FILENAME, maximum=MAX_PACKED_HEAD_BYTES)
+        if head_raw is not None and resume:
+            with contextlib.ExitStack() as stack:
+                predecessor: _PredecessorPacks | None = None
+                if predecessor_root is not None:
+                    predecessor_directory = PackedDirectory(Path(predecessor_root))
+                    stack.enter_context(predecessor_directory.opened())
+                    predecessor_head = _read_predecessor_head(
+                        predecessor_directory,
+                        expected_predecessor_head_sha256,
+                        expected_predecessor_generation_sha256,
+                    )
+                    predecessor = _PredecessorPacks(predecessor_directory, predecessor_head)
+                    predecessor.require_backends(
+                        [backend.coordinate for backend in packed_backends]
+                    )
+                return _recover_terminal_publication(
+                    directory,
+                    output_root=Path(output_root),
+                    generation=generation,
+                    head_raw=head_raw,
+                    delta_root=Path(delta_root),
+                    delta_manifest=delta_manifest,
+                    delta_shards_descriptor=delta_shards_descriptor,
+                    identity_descriptor=identity_descriptor,
+                    authoring_root=Path(authoring_root),
+                    authoring_manifest=authoring_manifest,
+                    packed_backends=packed_backends,
+                    seam_backends=seam_backends,
+                    posting_backend=posting_backend,
+                    predecessor=predecessor,
+                    limits=bounds,
+                    deadline=deadline,
+                )
+        if head_raw is not None:
+            raise _refuse(
+                "PACKED_OUTPUT_EXISTS",
+                "packed.output",
+                "a published generation is immutable; publish into a new output root",
+            )
+        existing = _read_journal(directory)
+        if resume:
+            if existing is None:
+                raise _refuse(
+                    "PACKED_JOURNAL_MISSING",
+                    "packed.journal",
+                    "an explicit resume needs the work journal its interruption left behind",
+                )
+            journal = _resume_from(
+                directory,
+                existing,
+                output_root=Path(output_root),
+                generation=generation,
+            )
+        else:
+            if existing is not None:
+                raise _refuse(
+                    "PACKED_OUTPUT_EXISTS",
+                    "packed.output",
+                    "this root holds an in-flight publication; resume it explicitly",
+                )
+            journal = _Journal(
+                output_root=os.path.abspath(os.fspath(output_root)), generation=dict(generation)
+            )
+
+        with contextlib.ExitStack() as stack:
+            predecessor: _PredecessorPacks | None = None
+            if predecessor_root is not None:
+                predecessor_directory = PackedDirectory(Path(predecessor_root))
+                stack.enter_context(predecessor_directory.opened())
+                head = _read_predecessor_head(
+                    predecessor_directory,
+                    expected_predecessor_head_sha256,
+                    expected_predecessor_generation_sha256,
+                )
+                predecessor = _PredecessorPacks(predecessor_directory, head)
+                predecessor.require_backends([backend.coordinate for backend in packed_backends])
+            return _publish(
+                directory=directory,
+                journal=journal,
+                delta_root=Path(delta_root),
+                delta_manifest=delta_manifest,
+                delta_shards_descriptor=delta_shards_descriptor,
+                identity_descriptor=identity_descriptor,
+                authoring_root=Path(authoring_root),
+                authoring_manifest=authoring_manifest,
+                identity_manifest_sha256=identity_manifest_sha256,
+                packed_backends=packed_backends,
+                seam_backends=seam_backends,
+                posting_backend=posting_backend,
+                predecessor=predecessor,
+                provider_id=provider_id,
+                generation=generation,
+                limits=bounds,
+                deadline=deadline,
+                after_range=after_range,
+            )
+
+
+def _resolve_backends(
+    backends: Sequence[EmbeddingBackend],
+) -> tuple[tuple[PackedBackend, ...], tuple[EmbeddingBackend, ...]]:
+    if not isinstance(backends, Sequence) or not 1 <= len(backends) <= MAX_PACKED_BACKENDS:
+        raise _refuse(
+            "PACKED_BACKEND",
+            "backends",
+            f"a packed generation carries 1 to {MAX_PACKED_BACKENDS} backends",
+        )
+    resolved = []
+    for backend in backends:
+        descriptor = backend.descriptor
+        resolved.append(
+            (
+                PackedBackend(
+                    coordinate=descriptor.coordinate,
+                    dimensions=descriptor.dimensions,
+                    quantization=descriptor.quantization,
+                    query_safe=descriptor.query_safe,
+                ),
+                backend,
+            )
+        )
+    resolved.sort(key=lambda pair: pair[0].coordinate)
+    coordinates = [packed.coordinate for packed, _backend in resolved]
+    if len(set(coordinates)) != len(coordinates):
+        raise _refuse("PACKED_BACKEND", "backends", "backends must be distinct coordinates")
+    return tuple(packed for packed, _ in resolved), tuple(backend for _, backend in resolved)
+
+
+def admit_authored_generation(root: Path, manifest: Mapping[str, Any]) -> None:
+    """Reconcile and scan every authored record before opening the output directory."""
+
+    expected_counts = {
+        "records": 0,
+        "authored": 0,
+        "flagged": 0,
+        "skipped": 0,
+        "failed": 0,
+        "layer_text_truncated": 0,
+    }
+    expected_digests: dict[str, str | None] = dict.fromkeys(EMBEDDING_LAYERS)
+    for item in _AuthoredStream(root, manifest)._records():
+        _admit_authored_item(item)
+        disposition = item["disposition"]
+        expected_counts["records"] += 1
+        expected_counts[disposition] += 1
+        expected_counts["layer_text_truncated"] += len(item["layer_text_truncated"])
+        entry = item["entry"]
+        if entry is not None:
+            for layer, text in _layer_texts(item).items():
+                expected_digests[layer] = _authored_layer_chain(
+                    expected_digests[layer], entry["entry_id"], layer, text
+                )
+    staging = manifest.get("staging")
+    coverage = manifest.get("coverage")
+    if (
+        manifest.get("counts") != expected_counts
+        or manifest.get("layer_text_digests") != expected_digests
+        or not isinstance(staging, Mapping)
+        or type(staging.get("record_index_count")) is not int
+        or staging["record_index_count"] < expected_counts["records"]
+    ):
+        raise _refuse(
+            "PACKED_INPUT_MANIFEST",
+            "authoring.manifest",
+            "authored manifest totals do not reproduce from its exact shard records",
+        )
+    # This used to be `staging["unique_records"] != expected_counts["records"]`: the sweep found
+    # exactly as many records as the shards hold. That is the exhaustive case of the two
+    # statements below, and it was the only case the pipeline could publish. Stated as two, a
+    # bounded generation is admissible and still has to account for itself exactly -- the corpus
+    # it claims to have drawn from is the one its own staging coordinate names, and the selection
+    # it claims to have taken is the population its own shards actually contain.
+    if (
+        not coverage_is_valid(coverage)
+        or coverage["corpus_records"] != staging.get("unique_records")
+        or coverage["selected_records"] != expected_counts["records"]
+    ):
+        raise _refuse(
+            "PACKED_INPUT_COVERAGE",
+            "authoring.manifest.coverage",
+            "the authored generation's stated coverage does not reproduce from its own staging "
+            "coordinate and shard records",
+        )
+
+
+def _authored_layer_chain(previous: str | None, entry_id: str, layer: str, text: str) -> str:
+    return canonical_sha256(
+        {
+            "previous_sha256": previous,
+            "entry_id": entry_id,
+            "layer": layer,
+            "text_sha256": sha256_bytes(text.encode("utf-8")),
+        }
+    )
+
+
+_AUTHORED_ITEM_MEMBERS = frozenset(
+    {
+        "provider_record_id",
+        "disposition",
+        "reason_code",
+        "entry",
+        "layer_texts",
+        "layer_text_truncated",
+    }
+)
+
+_REASON_CODES_BY_DISPOSITION = {
+    "authored": frozenset({"AUTHOR_OK"}),
+    "flagged": frozenset(
+        {
+            "AUTHOR_RIGHTS_ABSENT",
+            "AUTHOR_RIGHTS_CONDITIONAL",
+            "AUTHOR_RIGHTS_PROHIBITED",
+            "AUTHOR_RIGHTS_PROSE",
+            "AUTHOR_RIGHTS_UNMAPPED",
+        }
+    ),
+    "skipped": frozenset(
+        {
+            "AUTHOR_IDENTIFIER_UNSAFE",
+            "AUTHOR_TITLE_ABSENT",
+            "AUTHOR_TITLE_LIMIT",
+            "AUTHOR_TITLE_UNSAFE",
+        }
+    ),
+    "failed": frozenset(
+        {
+            "AUTHOR_ENTRY_CONTRACT",
+            "AUTHOR_RECORD_DIGEST",
+            "AUTHOR_RECORD_FIELDS",
+            "AUTHOR_RECORD_SCHEMA",
+        }
+    ),
+}
+
+assert frozenset().union(*_REASON_CODES_BY_DISPOSITION.values()) == AUTHORING_REASON_CODES
+
+
+def _admit_authored_item(item: Mapping[str, Any]) -> None:
+    """Validate one closed authored-record shape and scan every unconstrained public string."""
+
+    if not isinstance(item, dict) or set(item) != _AUTHORED_ITEM_MEMBERS:
+        raise _refuse(
+            "PACKED_INPUT_ENTRY",
+            "authoring.shard.items[]",
+            "an authored item must carry exactly the authored-record members",
+        )
+    disposition = item["disposition"]
+    if disposition not in AUTHORING_DISPOSITIONS:
+        raise _refuse(
+            "PACKED_INPUT_ENTRY",
+            "authoring.shard.items[].disposition",
+            "an authored item disposition differs",
+        )
+    provider_record_id = item["provider_record_id"]
+    reason_code = item["reason_code"]
+    if not isinstance(provider_record_id, str) or not isinstance(reason_code, str):
+        raise _refuse(
+            "PACKED_INPUT_ENTRY",
+            "authoring.shard.items[]",
+            "an authored item has invalid public strings",
+        )
+    if reason_code not in _REASON_CODES_BY_DISPOSITION[disposition]:
+        raise _refuse(
+            "PACKED_INPUT_ENTRY",
+            "authoring.shard.items[].reason_code",
+            "an authored item reason does not match its disposition",
+        )
+    for field_name, value in (
+        ("provider_record_id", provider_record_id),
+        ("reason_code", reason_code),
+    ):
+        admit_public_fact_bytes(canonical_json_bytes({field_name: value}))
+
+    truncated = item["layer_text_truncated"]
+    if (
+        not isinstance(truncated, list)
+        or any(not isinstance(layer, str) or layer not in EMBEDDING_LAYERS for layer in truncated)
+        or len(set(truncated)) != len(truncated)
+    ):
+        raise _refuse(
+            "PACKED_LAYER_TEXTS",
+            "authoring.shard.items[].layer_text_truncated",
+            "truncated layers must be a unique subset of the embedding layers",
+        )
+
+    if disposition in {"skipped", "failed"}:
+        if item["entry"] is not None or item["layer_texts"] != [] or truncated:
+            raise _refuse(
+                "PACKED_INPUT_ENTRY",
+                "authoring.shard.items[]",
+                "a skipped or failed item cannot carry public facts",
+            )
+        return
+
+    entry = item["entry"]
+    if not isinstance(entry, dict):
+        raise _refuse(
+            "PACKED_INPUT_ENTRY",
+            "authoring.shard.items[].entry",
+            "an authored or flagged item must carry one public entry",
+        )
+    _admit_entry_prose(entry, provider_record_id=provider_record_id)
+    for text in _layer_texts(item).values():
+        admit_public_fact_bytes(text.encode("utf-8"))
+
+
+_PUBLIC_PROSE_FACTS = (
+    "title",
+    "publisher",
+    "description",
+    "spatial_scope",
+    "data_formats",
+    "access_kind",
+    "authentication_required",
+    "rights",
+    "declared_columns",
+    "declared_vocabulary",
+    "declared_row_count",
+    "profiles",
+)
+
+
+def _admit_entry_prose(entry: Mapping[str, Any], *, provider_record_id: str) -> None:
+    """Classify publishable semantic values without treating verified digests as prose."""
+
+    try:
+        captured = catalog_entry_v2_from_dict(entry)
+    except SourceContractError as error:
+        raise _refuse(error.code, error.path, error.detail) from error
+    canonical_entry = captured.to_dict()
+    if canonical_entry != entry:
+        raise _refuse(
+            "PACKED_INPUT_ENTRY",
+            "authoring.shard.items[].entry",
+            "the authored entry is not its strict canonical contract spelling",
+        )
+    identity = captured.provider_record
+    if identity.provider_record_id != provider_record_id:
+        raise _refuse(
+            "PACKED_INPUT_IDENTITY",
+            "authoring.shard.items[].provider_record_id",
+            "the authored item key differs from its provider identity",
+        )
+    if captured.entry_id != derive_entry_id(identity.provider_id, provider_record_id):
+        raise _refuse(
+            "PACKED_INPUT_IDENTITY",
+            "authoring.shard.items[].entry.entry_id",
+            "the entry id is not derived from the authored provider identity",
+        )
+    admit_public_fact_bytes(canonical_json_bytes({"provider_record_id": provider_record_id}))
+    for fact_name in _PUBLIC_PROSE_FACTS:
+        fact = canonical_entry[fact_name]
+        # Keep the field name next to its exact value so assignment-shaped content is still
+        # classified, while authenticated coordinates, digests and evidence identifiers cannot
+        # become accidental prose findings.
+        admit_public_fact_bytes(canonical_json_bytes({fact_name: fact["value"]}))
+    for path, value in _publishable_strings(canonical_entry):
+        admit_public_fact_bytes(canonical_json_bytes({path: value}))
+
+
+def _publishable_strings(value: Any, *, path: tuple[str, ...] = ()) -> Iterator[tuple[str, str]]:
+    """Yield source-controlled strings, excluding only validated digests and derived labels."""
+
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if key in {"schema_version", "entry_id"}:
+                continue
+            if key.endswith(("_sha256", "_digest")):
+                if item is not None and not _is_digest(item):
+                    raise _refuse(
+                        "PACKED_INPUT_ENTRY",
+                        ".".join((*path, key)),
+                        "a digest field is not a lowercase SHA-256 digest",
+                    )
+                continue
+            yield from _publishable_strings(item, path=(*path, key))
+        return
+    if isinstance(value, list):
+        for item in value:
+            yield from _publishable_strings(item, path=path)
+        return
+    if isinstance(value, str):
+        yield (".".join(path), value)
+
+
+def _posting_backend(backends: Sequence[PackedBackend]) -> PackedBackend:
+    query_safe = [backend for backend in backends if backend.query_safe]
+    if len(query_safe) != 1:
+        raise _refuse(
+            "PACKED_POSTING_BACKEND",
+            "backends",
+            "postings are derived from exactly one query-safe backend",
+        )
+    return query_safe[0]
+
+
+def _read_predecessor_head(
+    directory: PackedDirectory,
+    expected: str | None,
+    expected_generation_sha256: str | None,
+) -> dict[str, Any]:
+    raw = directory.read(PACKED_HEAD_FILENAME, maximum=MAX_PACKED_HEAD_BYTES)
+    if raw is None:
+        raise _refuse(
+            "PACKED_PREDECESSOR_REQUIRED",
+            "predecessor.head",
+            "no readable packed head at the predecessor root",
+        )
+    if sha256_bytes(raw) != expected:
+        raise _refuse(
+            "PACKED_PREDECESSOR_DIGEST",
+            "predecessor.head",
+            "the predecessor generation is not the caller's exact head",
+        )
+    head = parse_canonical_json(raw)
+    if not isinstance(head, dict) or not isinstance(head.get("ranges"), list):
+        raise _refuse(
+            "PACKED_PREDECESSOR_DIGEST", "predecessor.head", "predecessor head contract differs"
+        )
+    if head.get("generation_sha256") != expected_generation_sha256:
+        raise _refuse(
+            "PACKED_PREDECESSOR_GENERATION",
+            "predecessor.head.generation_sha256",
+            "the predecessor packed head was not published from the named history generation",
+        )
+    return head
+
+
+def _publish(
+    *,
+    directory: PackedDirectory,
+    journal: _Journal,
+    delta_root: Path,
+    delta_manifest: Mapping[str, Any],
+    delta_shards_descriptor: int | None,
+    identity_descriptor: int | None,
+    authoring_root: Path,
+    authoring_manifest: Mapping[str, Any],
+    identity_manifest_sha256: str,
+    packed_backends: tuple[PackedBackend, ...],
+    seam_backends: tuple[EmbeddingBackend, ...],
+    posting_backend: PackedBackend,
+    predecessor: _PredecessorPacks | None,
+    provider_id: str,
+    generation: Mapping[str, Any],
+    limits: PackedLimits,
+    deadline: float,
+    after_range: Callable[[PackedRangeProgress], None] | None,
+) -> PackedPublicationResult:
+    counters = _Counters()
+    seams = {
+        backend.descriptor.coordinate: _CountingSeam(backend, counters) for backend in seam_backends
+    }
+    classification = _ClassificationStream(
+        delta_root, delta_manifest, shards_descriptor=delta_shards_descriptor
+    )
+    authored = _AuthoredStream(authoring_root, authoring_manifest)
+    identity = _HistoryStream(
+        IdentityHistoryStore.open(
+            delta_root / DELTA_IDENTITY_DIRNAME,
+            expected_manifest_sha256=identity_manifest_sha256,
+            root_descriptor=identity_descriptor,
+        )
+    )
+    already = len(journal.completed_ranges)
+    counts = {
+        "ranges": 0,
+        "entries": 0,
+        "fresh_ranges": 0,
+        "new": 0,
+        "changed": 0,
+        "unchanged": 0,
+        "members": 0,
+    }
+    for record in journal.invocations:
+        counters.absorb_record(record)
+    invocation_start = counters.to_dict()
+    descriptors: list[PackedRangeDescriptor] = []
+    vector_payload_sha256s: list[str] = []
+    for range_index, entries in enumerate(_ranges(classification, authored, identity)):
+        if range_index >= limits.max_ranges:
+            raise _refuse(
+                "PACKED_RANGE_LIMIT", "packed.ranges", "the generation exceeds its range bound"
+            )
+        range_input = PackedRangeInput(
+            range_index=range_index, entries=tuple(item.to_entry() for item in entries)
+        )
+        fresh = tuple(
+            position
+            for position, item in enumerate(entries)
+            if item.classification in FRESH_CLASSIFICATIONS
+        )
+        encoded_positions = set(fresh)
+        reused = tuple(
+            position for position in range(len(entries)) if position not in encoded_positions
+        )
+        # Every range this generation contains is counted here, whether this invocation built it
+        # or a previous one did, so the counter equations hold across a resume as written.
+        counts["ranges"] += 1
+        counts["entries"] += len(entries)
+        counts["fresh_ranges"] += 1 if fresh else 0
+        for item in entries:
+            counts[item.classification] += 1
+        if range_index < already:
+            completed = journal.completed_ranges[range_index]
+            _verify_completed_range(directory, completed, range_input)
+            descriptors.append(_completed_descriptor(completed))
+            vector_payload_sha256s.extend(completed["vector_payload_sha256s"])
+            counts["members"] += len(completed["member_sha256s"])
+            continue
+        if time.monotonic() >= deadline:
+            raise _refuse(
+                "PACKED_WALL_LIMIT", "packed.output", "publication exceeded its wall bound"
+            )
+        if reused and predecessor is None:
+            raise _refuse(
+                "PACKED_PREDECESSOR_REQUIRED",
+                "predecessor",
+                "an unchanged entry can only be published against the packs it reuses",
+            )
+        recovered: dict[int, dict[str, dict[str, tuple[int, ...]]]] = {}
+        for position in reused:
+            assert predecessor is not None
+            recovered[position] = predecessor.lookup(entries[position].key)
+
+        vectors: dict[str, dict[str, tuple[tuple[int, ...], ...]]] = {}
+        for backend in packed_backends:
+            seam = seams[backend.coordinate]
+            layers: dict[str, tuple[tuple[int, ...], ...]] = {}
+            for layer in EMBEDDING_LAYERS:
+                column: list[tuple[int, ...] | None] = [None] * len(entries)
+                if fresh:
+                    encoded = seam.encode_many(
+                        tuple(entries[position].layer_texts[layer] for position in fresh)
+                    )
+                    for position, vector in zip(fresh, encoded, strict=True):
+                        column[position] = vector
+                for position in reused:
+                    vector = recovered[position].get(backend.coordinate, {}).get(layer)
+                    if vector is None or len(vector) != backend.dimensions:
+                        raise _refuse(
+                            "PACKED_REUSE_MISSING",
+                            "predecessor.ranges",
+                            "an unchanged entry has no reusable layer vector for this backend",
+                        )
+                    column[position] = vector
+                layers[layer] = tuple(value for value in column if value is not None)
+                if len(layers[layer]) != len(entries):
+                    raise _refuse(  # pragma: no cover - every position is filled above
+                        "PACKED_RANGE_ENTRY",
+                        "packed.range.vectors",
+                        "a layer member does not cover every entry in its range",
+                    )
+            vectors[backend.coordinate] = layers
+
+        built = build_packed_range(
+            range_input,
+            vectors,
+            backends=packed_backends,
+            posting_backend_coordinate=posting_backend.coordinate,
+            max_terms_per_segment=limits.max_terms_per_segment,
+        )
+        member_sha256s = _install_range(directory, built)
+        if directory.bytes_written > limits.max_disk_bytes:
+            raise _refuse(
+                "PACKED_DISK_LIMIT", "packed.output", "publication exceeds its local disk bound"
+            )
+        counters.reused_layer_items += len(reused) * len(EMBEDDING_LAYERS) * len(packed_backends)
+        payloads = _vector_payload_sha256s(built)
+        completed = _completed_range_record(built)
+        if completed["member_sha256s"] != [list(item) for item in member_sha256s]:
+            raise _refuse(  # pragma: no cover - installation checks every built descriptor
+                "PACKED_OUTPUT_READBACK",
+                "packed.output.member",
+                "installed member coordinates differ from the range that produced them",
+            )
+        journal.completed_ranges.append(completed)
+        descriptors.append(built.descriptor)
+        vector_payload_sha256s.extend(payloads)
+        counts["members"] += len(built.members)
+        _write_journal(directory, journal, counters, invocation_start, status="incomplete")
+        if after_range is not None:
+            after_range(
+                PackedRangeProgress(
+                    range_index=range_index,
+                    first_key=built.first_key,
+                    last_key=built.last_key,
+                    entry_count=built.entry_count,
+                    fresh_entries=len(fresh),
+                    reused_entries=len(reused),
+                    range_binding_sha256=built.range_binding_sha256,
+                    posting_backend_coordinate=posting_backend.coordinate,
+                    manifest_sha256=built.manifest_sha256,
+                    member_sha256s=member_sha256s,
+                )
+            )
+
+    if not descriptors:
+        raise _refuse(
+            "PACKED_INPUT_EMPTY",
+            "delta.shards",
+            "a classification with no publishable entry publishes no generation",
+        )
+    if counts["ranges"] < already:
+        raise _refuse(
+            "PACKED_JOURNAL_RANGE",
+            "packed.journal.completed_ranges",
+            "the journal completed more ranges than this classification produces",
+        )
+    if counts["entries"] > limits.max_entries:
+        raise _refuse(
+            "PACKED_ENTRY_LIMIT", "packed.entries", "the generation exceeds its entry bound"
+        )
+
+    # The independent final reader: every emitted pack is re-read from disk and its accelerators
+    # recomputed, before any head exists to point at them.
+    posting_term_count = 0
+    posting_member_sha256s: list[str] = []
+    bound_member_sha256s: list[str] = []
+    for descriptor in descriptors:
+        verified = verify_packed_range(
+            directory,
+            descriptor.manifest_sha256,
+            backends=packed_backends,
+            posting_backend_coordinate=posting_backend.coordinate,
+        )
+        if (
+            verified.entry_count != descriptor.entry_count
+            or verified.facts_sha256 != descriptor.facts_sha256
+            or verified.first_key != descriptor.first_key
+            or verified.last_key != descriptor.last_key
+        ):
+            raise _refuse(
+                "PACKED_RANGE_DIGEST",
+                "packed.range",
+                "an emitted range does not read back as the range its descriptor names",
+            )
+        posting_term_count += verified.posting_term_count
+        posting_member_sha256s.extend(verified.posting_sha256s)
+        bound_member_sha256s.extend(verified.bound_sha256s)
+
+    _verify_counter_equations(counters, counts, backend_count=len(packed_backends))
+
+    # Invocation boundaries are process history and cannot be authenticated after a hard kill.
+    # The durable representation is therefore one canonical aggregate, which is independently
+    # reproducible from the exact inputs and the classifications in the immutable facts members.
+    invocations = [counters.to_dict()]
+    residency = _canonical_residency(counts, generation)
+    terminal = _terminal_document(
+        provider_id=provider_id,
+        generation=generation,
+        coverage=authoring_manifest["coverage"],
+        delta_manifest=delta_manifest,
+        packed_backends=packed_backends,
+        posting_backend=posting_backend,
+        counters=counters,
+        counts=counts,
+        invocations=invocations,
+        descriptors=descriptors,
+        posting_term_count=posting_term_count,
+        vector_payload_sha256s=vector_payload_sha256s,
+        posting_member_sha256s=posting_member_sha256s,
+        bound_member_sha256s=bound_member_sha256s,
+        limits=limits,
+        residency=residency,
+        journal=journal,
+    )
+    terminal_sha256 = sha256_bytes(canonical_json_bytes(terminal))
+    head = build_packed_head(
+        provider_id=provider_id,
+        generation_sha256=generation["delta_manifest_sha256"],
+        predecessor_head_sha256=generation["predecessor_head_sha256"],
+        backends=packed_backends,
+        posting_backend_coordinate=posting_backend.coordinate,
+        ranges=descriptors,
+        coverage=authoring_manifest["coverage"],
+        counters=counters.to_dict(),
+        invocations=invocations,
+        terminal_sha256=terminal_sha256,
+    )
+    head_sha256 = sha256_bytes(canonical_json_bytes(head))
+    complete_journal = _Journal(
+        output_root=journal.output_root,
+        generation=journal.generation,
+        completed_ranges=journal.completed_ranges,
+        invocations=invocations,
+    ).document(status="complete", head_sha256=head_sha256)
+    journal_sha256 = sha256_bytes(canonical_json_bytes(complete_journal))
+    receipt = _receipt_from_terminal(
+        terminal, head_sha256=head_sha256, journal_sha256=journal_sha256
+    )
+
+    final_incomplete_journal = _Journal(
+        output_root=journal.output_root,
+        generation=journal.generation,
+        completed_ranges=journal.completed_ranges,
+        invocations=invocations,
+    ).document(status="incomplete", head_sha256=None)
+    directory.publish(
+        PACKED_JOURNAL_FILENAME,
+        final_incomplete_journal,
+        maximum=MAX_PACKED_JOURNAL_BYTES,
+    )
+    installed_terminal_sha256 = directory.publish(
+        PACKED_TERMINAL_FILENAME, terminal, maximum=MAX_PACKED_TERMINAL_BYTES
+    )
+    if installed_terminal_sha256 != terminal_sha256:
+        raise _refuse(
+            "PACKED_TERMINAL_DIGEST",
+            "packed.terminal",
+            "installed terminal record differs from the record the head names",
+        )
+    installed_head_sha256 = directory.publish(
+        PACKED_HEAD_FILENAME, head, maximum=MAX_PACKED_HEAD_BYTES
+    )
+    if installed_head_sha256 != head_sha256:
+        raise _refuse(
+            "PACKED_HEAD_MISMATCH", "packed.head", "installed head differs from its coordinate"
+        )
+    installed = verify_packed_generation(
+        directory.root,
+        expected_head_sha256=head_sha256,
+        root_descriptor=directory.root_descriptor,
+    )
+    if (
+        installed.entry_count != counts["entries"]
+        or installed.range_count != counts["ranges"]
+        or installed.member_count != counts["members"]
+    ):
+        raise _refuse(
+            "PACKED_HEAD_EXPECTED",
+            "packed.head",
+            "the installed head does not read back as the generation just written",
+        )
+
+    installed_journal_sha256 = directory.publish(
+        PACKED_JOURNAL_FILENAME, complete_journal, maximum=MAX_PACKED_JOURNAL_BYTES
+    )
+    if installed_journal_sha256 != journal_sha256:
+        raise _refuse(
+            "PACKED_JOURNAL_DIGEST",
+            "packed.journal",
+            "installed complete journal differs from the terminal record",
+        )
+    return PackedPublicationResult(
+        status="complete",
+        head_sha256=head_sha256,
+        journal_sha256=journal_sha256,
+        counters=counters.to_dict(),
+        counts=counts,
+        receipt=receipt,
+    )
+
+
+@dataclass(frozen=True)
+class _PublishableEntry:
+    """One classified entry with everything the packed schema needs and nothing it does not."""
+
+    key: str
+    entry_id: str
+    classification: str
+    semantic_facts_digest: str
+    entry: dict[str, Any]
+    history: dict[str, Any]
+    layer_texts: dict[str, str]
+
+    def to_entry(self) -> dict[str, Any]:
+        return {
+            "key": self.key,
+            "entry_id": self.entry_id,
+            "classification": self.classification,
+            "semantic_facts_digest": self.semantic_facts_digest,
+            "entry": self.entry,
+            "history": self.history,
+        }
+
+
+def _ranges(
+    classification: _ClassificationStream,
+    authored: _AuthoredStream,
+    identity: _HistoryStream,
+) -> Iterator[list[_PublishableEntry]]:
+    buffer: list[_PublishableEntry] = []
+    for item in classification:
+        buffer.append(_publishable(item, authored, identity))
+        if len(buffer) == RANGE_ENTRIES:
+            yield buffer
+            buffer = []
+    if buffer:
+        yield buffer
+
+
+def _publishable(
+    item: Mapping[str, Any], authored: _AuthoredStream, identity: _HistoryStream
+) -> _PublishableEntry:
+    record_id = item["provider_record_id"]
+    authored_item = authored.advance_to(record_id)
+    history = identity.advance_to(record_id)
+    entry = authored_item.get("entry")
+    if not isinstance(entry, dict) or entry.get("entry_id") != item["entry_id"]:
+        raise _refuse(
+            "PACKED_INPUT_ENTRY",
+            "authoring.shard.items[].entry",
+            "a classified entry does not match the authored entry it names",
+        )
+    if history.identity.entry_id != item["entry_id"]:
+        raise _refuse(
+            "PACKED_INPUT_IDENTITY",
+            "identity.records",
+            "a classified entry does not match the identity history it names",
+        )
+    layer_texts = _layer_texts(authored_item)
+    return _PublishableEntry(
+        key=record_id,
+        entry_id=item["entry_id"],
+        classification=item["classification"],
+        semantic_facts_digest=item["semantic_facts_digest"],
+        entry=entry,
+        history=history.to_dict(),
+        layer_texts=layer_texts,
+    )
+
+
+def _layer_texts(authored_item: Mapping[str, Any]) -> dict[str, str]:
+    """Read the exact four authored texts whose UTF-8 bytes the encoding seam meters."""
+
+    texts = authored_item.get("layer_texts")
+    if not isinstance(texts, list) or len(texts) != len(EMBEDDING_LAYERS):
+        raise _refuse(
+            "PACKED_LAYER_TEXTS",
+            "authoring.shard.items[].layer_texts",
+            f"a published entry carries exactly the four layer texts {list(EMBEDDING_LAYERS)}",
+        )
+    layer_texts: dict[str, str] = {}
+    for text in texts:
+        if (
+            not isinstance(text, dict)
+            or set(text) != {"layer", "text"}
+            or text.get("layer") not in EMBEDDING_LAYERS
+            or not isinstance(text.get("text"), str)
+            or not text["text"]
+            or len(text["text"].encode("utf-8")) > MAX_LAYER_TEXT_BYTES
+        ):
+            raise _refuse(
+                "PACKED_LAYER_TEXTS",
+                "authoring.shard.items[].layer_texts[]",
+                "each layer text names its layer and carries text",
+            )
+        layer_texts[text["layer"]] = text["text"]
+    if set(layer_texts) != set(EMBEDDING_LAYERS) or [text["layer"] for text in texts] != list(
+        EMBEDDING_LAYERS
+    ):
+        raise _refuse(
+            "PACKED_LAYER_TEXTS",
+            "authoring.shard.items[].layer_texts",
+            f"a published entry carries exactly the four layer texts {list(EMBEDDING_LAYERS)}",
+        )
+    return layer_texts
+
+
+def _install_range(
+    directory: PackedDirectory, built: BuiltPackedRange
+) -> tuple[tuple[str, str], ...]:
+    installed: list[tuple[str, str]] = []
+    for member in built.members:
+        digest, size = directory.write_member_bytes(member.raw, kind=member.descriptor.kind)
+        if digest != member.descriptor.sha256 or size != member.descriptor.bytes:
+            raise _refuse(  # pragma: no cover - content addressing makes this unreachable
+                "PACKED_OUTPUT_READBACK",
+                "packed.output.member",
+                "an installed member is not the member it was built as",
+            )
+        installed.append((member.descriptor.kind, digest))
+    manifest_sha256, _size = directory.write_member_bytes(built.manifest_raw, kind="range")
+    if manifest_sha256 != built.manifest_sha256:
+        raise _refuse(  # pragma: no cover - content addressing makes this unreachable
+            "PACKED_OUTPUT_READBACK",
+            "packed.output.manifest",
+            "an installed range manifest is not the manifest it was built as",
+        )
+    return tuple(installed)
+
+
+def _vector_payload_sha256s(built: BuiltPackedRange) -> tuple[str, ...]:
+    """Digest each layer member's fixed-width vector payload, header excluded, in published order.
+
+    The header binds a member to its range, so two generations that reuse the same vectors publish
+    different member digests: the facts a range carries move even when its vectors do not. The
+    payload is the part reuse is a claim about, so this is the digest a receipt states when it says
+    an unchanged entry's packs are the predecessor's bytes.
+    """
+
+    return tuple(
+        sha256_bytes(member.raw[MEMBER_HEADER_BYTES:])
+        for member in built.members
+        if member.descriptor.kind == "vector"
+    )
+
+
+def _completed_range_record(built: BuiltPackedRange) -> dict[str, Any]:
+    """State the exact durable range record derived from one deterministic build."""
+
+    return {
+        "range_index": built.range_index,
+        "first_key": built.first_key,
+        "last_key": built.last_key,
+        "entry_count": built.entry_count,
+        "facts_sha256": built.facts_sha256,
+        "range_binding_sha256": built.range_binding_sha256,
+        "range_manifest_sha256": built.manifest_sha256,
+        "range_manifest_bytes": len(built.manifest_raw),
+        "member_sha256s": [
+            [member.descriptor.kind, member.descriptor.sha256] for member in built.members
+        ],
+        "vector_payload_sha256s": list(_vector_payload_sha256s(built)),
+    }
+
+
+def _completed_descriptor(completed: Mapping[str, Any]) -> PackedRangeDescriptor:
+    return PackedRangeDescriptor(
+        range_index=completed["range_index"],
+        first_key=completed["first_key"],
+        last_key=completed["last_key"],
+        entry_count=completed["entry_count"],
+        facts_sha256=completed["facts_sha256"],
+        range_binding_sha256=completed["range_binding_sha256"],
+        manifest_sha256=completed["range_manifest_sha256"],
+        manifest_bytes=completed["range_manifest_bytes"],
+        member_count=len(completed["member_sha256s"]),
+    )
+
+
+def _verify_completed_range(
+    directory: PackedDirectory, completed: Mapping[str, Any], range_input: PackedRangeInput
+) -> None:
+    """Prove one already-emitted range is the range this stream produces, encoding nothing.
+
+    An ordinary pre-head resume must not re-encode a complete range, so this first proof is drawn
+    entirely from bytes that already exist: the journal states the interval, size and facts order;
+    the range binding has to reproduce from exactly those; and the installed facts member has to
+    list exactly these entries carrying exactly these canonical documents. Terminal recovery adds
+    a deterministic full-range replay after this inexpensive facts check.
+    """
+
+    path = f"packed.journal.completed_ranges[{range_input.range_index}]"
+    if (
+        completed["range_index"] != range_input.range_index
+        or completed["first_key"] != range_input.first_key
+        or completed["last_key"] != range_input.last_key
+        or completed["entry_count"] != len(range_input.entries)
+    ):
+        raise _refuse(
+            "PACKED_JOURNAL_RANGE",
+            path,
+            "a completed range does not describe the range this stream produces",
+        )
+    if completed["range_binding_sha256"] != range_binding_sha256(
+        range_index=range_input.range_index,
+        first_key=range_input.first_key,
+        last_key=range_input.last_key,
+        entry_count=len(range_input.entries),
+        facts_sha256=completed["facts_sha256"],
+    ):
+        raise _refuse(
+            "PACKED_JOURNAL_RANGE",
+            f"{path}.range_binding_sha256",
+            "a completed range's binding does not reproduce from its own interval and facts order",
+        )
+    raw = directory.read_member(
+        completed["facts_sha256"], kind="facts", maximum=MAX_FACTS_MEMBER_BYTES
+    )
+    if raw is None or sha256_bytes(raw) != completed["facts_sha256"]:
+        raise _refuse(
+            "PACKED_JOURNAL_MEMBER",
+            f"{path}.facts_sha256",
+            "an already-emitted immutable member does not read back exactly",
+        )
+    try:
+        payload = parse_canonical_json(raw)
+    except CanonicalJSONError as error:
+        raise _refuse(
+            "PACKED_JOURNAL_RANGE", f"{path}.facts_sha256", "a facts member is not canonical"
+        ) from error
+    items = payload.get("entries") if isinstance(payload, dict) else None
+    if not isinstance(items, list) or len(items) != len(range_input.entries):
+        raise _refuse(
+            "PACKED_JOURNAL_RANGE",
+            f"{path}.facts_sha256",
+            "a completed range's facts member does not cover this stream's entries",
+        )
+    for position, (item, entry) in enumerate(zip(items, range_input.entries, strict=True)):
+        try:
+            entry_sha256 = sha256_bytes(canonical_json_bytes(entry["entry"]))
+        except CanonicalJSONError as error:
+            raise _refuse(
+                "PACKED_FACTS_LIMIT",
+                f"packed.range.entries[{position}].entry",
+                "a range document is not canonically representable",
+            ) from error
+        if (
+            not isinstance(item, dict)
+            or item.get("key") != entry["key"]
+            or item.get("entry_id") != entry["entry_id"]
+            or item.get("classification") != entry["classification"]
+            or item.get("semantic_facts_digest") != entry["semantic_facts_digest"]
+            or item.get("entry_sha256") != entry_sha256
+        ):
+            raise _refuse(
+                "PACKED_JOURNAL_RANGE",
+                f"{path}.entries[{position}]",
+                "a completed range does not carry the entry this stream produces",
+            )
+
+
+def _invocation_record(counters: _Counters, start: Mapping[str, int]) -> dict[str, int]:
+    return {name: getattr(counters, name) - start[name] for name in COUNTER_MEMBERS}
+
+
+def _write_journal(
+    directory: PackedDirectory,
+    journal: _Journal,
+    counters: _Counters,
+    start: Mapping[str, int],
+    *,
+    status: str,
+    head_sha256: str | None = None,
+) -> str:
+    document = _journal_document(journal, counters, start, status=status, head_sha256=head_sha256)
+    return directory.publish(PACKED_JOURNAL_FILENAME, document, maximum=MAX_PACKED_JOURNAL_BYTES)
+
+
+def _journal_document(
+    journal: _Journal,
+    counters: _Counters,
+    start: Mapping[str, int],
+    *,
+    status: str,
+    head_sha256: str | None = None,
+) -> dict[str, Any]:
+    """Build the exact journal document before choosing when to install it."""
+
+    invocations = list(journal.invocations)
+    if status == "incomplete":
+        invocations.append(_invocation_record(counters, start))
+    return _Journal(
+        output_root=journal.output_root,
+        generation=journal.generation,
+        completed_ranges=journal.completed_ranges,
+        invocations=invocations,
+    ).document(status=status, head_sha256=head_sha256)
+
+
+def _verify_counter_equations(
+    counters: _Counters, counts: Mapping[str, int], *, backend_count: int
+) -> None:
+    fresh_entries = counts["new"] + counts["changed"]
+    layers = len(EMBEDDING_LAYERS)
+    expected = {
+        "batch_invocations": counts["fresh_ranges"] * layers * backend_count,
+        "encoded_layer_items": fresh_entries * layers * backend_count,
+        "backend_scalar_invocations": fresh_entries * layers * backend_count,
+        "reused_layer_items": counts["unchanged"] * layers * backend_count,
+    }
+    for name, value in expected.items():
+        if getattr(counters, name) != value:
+            raise _refuse(
+                "PACKED_COUNTER_MISMATCH",
+                f"packed.counters.{name}",
+                f"the publisher's own work does not satisfy its equation: "
+                f"{getattr(counters, name)} != {value}",
+            )
+
+
+def _terminal_document(
+    *,
+    provider_id: str,
+    generation: Mapping[str, Any],
+    coverage: Mapping[str, Any],
+    delta_manifest: Mapping[str, Any],
+    packed_backends: Sequence[PackedBackend],
+    posting_backend: PackedBackend,
+    counters: _Counters,
+    counts: Mapping[str, int],
+    invocations: Sequence[Mapping[str, int]],
+    descriptors: Sequence[PackedRangeDescriptor],
+    posting_term_count: int,
+    vector_payload_sha256s: Sequence[str],
+    posting_member_sha256s: Sequence[str],
+    bound_member_sha256s: Sequence[str],
+    limits: PackedLimits,
+    residency: Mapping[str, int],
+    journal: _Journal,
+) -> dict[str, Any]:
+    """Persist everything needed to finish evidence after the packed head is durable.
+
+    ``outputs.vector_member_sha256s`` is the ordered digest of every layer member's vector payload
+    -- see :func:`_vector_payload_sha256s` -- so a successor that reused a predecessor's vectors
+    states the same list the predecessor did, and one that silently re-encoded cannot. The posting
+    and bound digests beside it are the independent final reader's, not the builder's: they name
+    the accelerator members that reader recomputed from the pack bytes it read back.
+
+    ``adapter_mode`` is stated rather than inferred. Every vector in this generation came back on a
+    :class:`BatchEncodeResult` that could only have been minted by the bounded scalar adapter, so
+    the receipt says which implementation produced them instead of leaving a reader to assume.
+    """
+
+    receipt = {
+        "schema_version": PACKED_RECEIPT_SCHEMA,
+        "status": "complete",
+        "provider_id": provider_id,
+        "adapter_mode": BOUNDED_SCALAR_ADAPTER,
+        # The head and this receipt both state the coverage, and the installed-catalogue reader
+        # requires them to agree. A duplicated summary nothing reconciles is the weak kind; this
+        # one is compared member-for-member in `packed_retrieval._bound_receipt`.
+        "coverage": dict(coverage),
+        "inputs": {
+            "delta_manifest_sha256": generation["delta_manifest_sha256"],
+            "delta_root_sha256": delta_manifest["root_sha256"],
+            "authoring_manifest_sha256": generation["authoring_manifest_sha256"],
+            "identity_manifest_sha256": generation["identity_manifest_sha256"],
+            "predecessor_head_sha256": generation["predecessor_head_sha256"],
+            "publication_binding_sha256": generation.get("publication_binding_sha256"),
+        },
+        "backends": [backend.to_dict() for backend in packed_backends],
+        "posting_backend_coordinate": posting_backend.coordinate,
+        "counts": dict(counts),
+        "counters": counters.to_dict(),
+        "invocations": [dict(record) for record in invocations],
+        "outputs": {
+            "range_count": counts["ranges"],
+            "entry_count": counts["entries"],
+            "member_count": counts["members"],
+            "posting_term_count": posting_term_count,
+            "ranges": [descriptor.to_dict() for descriptor in descriptors],
+            "ranges_chain_sha256": ranges_chain_sha256(descriptors),
+            "vector_member_sha256s": list(vector_payload_sha256s),
+            "posting_member_sha256s": list(posting_member_sha256s),
+            "bound_member_sha256s": list(bound_member_sha256s),
+        },
+        "residency": dict(residency),
+        "limits": limits.to_dict(),
+    }
+    body = {
+        "schema_version": PACKED_TERMINAL_SCHEMA,
+        "generation": dict(generation),
+        "journal": {
+            "output_root": journal.output_root,
+            "generation": dict(journal.generation),
+            "completed_ranges": list(journal.completed_ranges),
+            "invocations": [dict(record) for record in invocations],
+        },
+        "receipt": receipt,
+    }
+    return {**body, "root_sha256": canonical_sha256(body)}
+
+
+def _receipt_from_terminal(
+    terminal: Mapping[str, Any], *, head_sha256: str, journal_sha256: str
+) -> dict[str, Any]:
+    """Complete the packed receipt from the head-bound terminal record."""
+
+    stated = terminal.get("receipt")
+    if not isinstance(stated, Mapping):
+        raise _refuse(
+            "PACKED_TERMINAL_SCHEMA", "packed.terminal.receipt", "terminal receipt differs"
+        )
+    outputs = stated.get("outputs")
+    if not isinstance(outputs, Mapping):
+        raise _refuse("PACKED_TERMINAL_SCHEMA", "packed.terminal.receipt.outputs", "outputs differ")
+    body = {
+        **dict(stated),
+        "outputs": {
+            "head_sha256": head_sha256,
+            "journal_sha256": journal_sha256,
+            **dict(outputs),
+        },
+    }
+    return {**body, "coordinate_sha256": canonical_sha256(body)}
+
+
+def _parse_terminal(raw: bytes) -> dict[str, Any]:
+    """Read one head-bound terminal record without accepting an alternate spelling."""
+
+    if len(raw) > MAX_PACKED_TERMINAL_BYTES:
+        raise _refuse("PACKED_TERMINAL_LIMIT", "packed.terminal", "terminal record exceeds its cap")
+    try:
+        terminal = parse_canonical_json(raw)
+    except CanonicalJSONError as error:
+        raise _refuse(
+            "PACKED_TERMINAL_SCHEMA", "packed.terminal", "terminal record is not canonical"
+        ) from error
+    if (
+        not isinstance(terminal, dict)
+        or set(terminal) != {"schema_version", "generation", "journal", "receipt", "root_sha256"}
+        or terminal.get("schema_version") != PACKED_TERMINAL_SCHEMA
+        or not isinstance(terminal.get("generation"), dict)
+        or not isinstance(terminal.get("journal"), dict)
+        or not isinstance(terminal.get("receipt"), dict)
+        or not _is_digest(terminal.get("root_sha256"))
+    ):
+        raise _refuse(
+            "PACKED_TERMINAL_SCHEMA", "packed.terminal", "terminal record contract differs"
+        )
+    body = {key: value for key, value in terminal.items() if key != "root_sha256"}
+    if canonical_sha256(body) != terminal["root_sha256"]:
+        raise _refuse(
+            "PACKED_TERMINAL_DIGEST",
+            "packed.terminal.root_sha256",
+            "terminal record does not reproduce its own digest",
+        )
+    return terminal
+
+
+def verify_packed_receipt(
+    receipt: Mapping[str, Any], *, root: Path, root_descriptor: int | None = None
+) -> None:
+    """Refuse a receipt that is not the exact coordinate of the generation installed at ``root``."""
+
+    if not isinstance(receipt, Mapping) or receipt.get("schema_version") != PACKED_RECEIPT_SCHEMA:
+        raise _refuse("PACKED_RECEIPT_SCHEMA", "packed.receipt", "receipt contract differs")
+    if receipt.get("adapter_mode") != BOUNDED_SCALAR_ADAPTER:
+        raise _refuse(
+            "PACKED_RECEIPT_ADAPTER",
+            "packed.receipt.adapter_mode",
+            f"a packed generation may claim only the {BOUNDED_SCALAR_ADAPTER!r} adapter",
+        )
+    body = {key: value for key, value in receipt.items() if key != "coordinate_sha256"}
+    if canonical_sha256(body) != receipt.get("coordinate_sha256"):
+        raise _refuse(
+            "PACKED_RECEIPT_COORDINATE",
+            "packed.receipt.coordinate_sha256",
+            "the receipt does not reproduce its own coordinate",
+        )
+    installed = verify_packed_generation(
+        Path(root),
+        expected_head_sha256=receipt["outputs"]["head_sha256"],
+        root_descriptor=root_descriptor,
+    )
+    directory = PackedDirectory(Path(root), root_descriptor=root_descriptor)
+    with directory.opened():
+        terminal_raw = directory.read(PACKED_TERMINAL_FILENAME, maximum=MAX_PACKED_TERMINAL_BYTES)
+        journal_raw = directory.read(PACKED_JOURNAL_FILENAME, maximum=MAX_PACKED_JOURNAL_BYTES)
+        if (
+            terminal_raw is None
+            or journal_raw is None
+            or sha256_bytes(terminal_raw) != installed.head["terminal_sha256"]
+            or sha256_bytes(journal_raw) != receipt["outputs"]["journal_sha256"]
+        ):
+            raise _refuse(
+                "PACKED_RECEIPT_MISMATCH",
+                "packed.receipt.outputs",
+                "the receipt does not bind the installed terminal record and journal",
+            )
+        terminal = _parse_terminal(terminal_raw)
+        journal = _read_journal(directory)
+        if (
+            journal is None
+            or journal.get("status") != "complete"
+            or journal.get("head_sha256") != installed.head_sha256
+            or _receipt_from_terminal(
+                terminal,
+                head_sha256=installed.head_sha256,
+                journal_sha256=sha256_bytes(journal_raw),
+            )
+            != dict(receipt)
+        ):
+            raise _refuse(
+                "PACKED_RECEIPT_MISMATCH",
+                "packed.receipt",
+                "the receipt is not the head-bound terminal publication",
+            )
+    if (
+        receipt.get("outputs")
+        != {
+            "head_sha256": installed.head_sha256,
+            "journal_sha256": receipt["outputs"]["journal_sha256"],
+            **_verified_receipt_outputs(installed),
+        }
+        or installed.head["counters"] != receipt["counters"]
+        or installed.head["backends"] != receipt.get("backends")
+        or installed.head["posting_backend_coordinate"] != receipt.get("posting_backend_coordinate")
+        or installed.head["provider_id"] != receipt.get("provider_id")
+    ):
+        raise _refuse(
+            "PACKED_RECEIPT_MISMATCH",
+            "packed.receipt.outputs",
+            "the receipt does not describe the generation installed at this root",
+        )