b24api 2.0.0__tar.gz → 2.1.0__tar.gz

{b24api-2.0.0/b24api.egg-info → b24api-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b24api
-Version: 2.0.0
+Version: 2.1.0
 Summary: Bitrix24 API
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -43,6 +43,15 @@ idempotent and closes active streams before the owned transport.
 Use `call()` for detached decoded JSON and `call_response()` when you also need the immutable
 response envelope: `result`, `total`, `next`, timing and bounded diagnostic evidence.
 
+Use `call_bytes()` when a successful method response is a file rather than a Bitrix JSON envelope.
+The operation is explicit and never hides malformed JSON by falling back to bytes.
+
+<!-- tested: tests/client_findings_3_test.py::test_binary_call_returns_every_success_byte_without_json_sniffing -->
+```python
+archive = await client.call_bytes(Request("example.export.download", replay_safety=ReplaySafety.SAFE))
+payload = archive.body
+```
+
 <!-- tested: tests/client_v2_test.py::test_call_and_call_response_have_stable_detached_types -->
 ```python
 from b24api import ReplaySafety
@@ -132,7 +141,7 @@ more specialized mechanics have explicit names and explicit preconditions.
 |---|---|---|---|
 | `iter_list` | The method supports ordinary offset pagination. | Pages are requested sequentially using server `next`; no separate count request is made. | Continuation and empty terminal page; add identity for duplicate detection. |
 | `iter_list_counted` | The first response provides an exact filtered `total` and stable offset pages. | Head page is direct; all known tail offsets are grouped into physical Bitrix batches. | Exact total, ranges and identities. |
-| `iter_list_keyset` | The method may omit `total`, but reliably supports ordering and filtering by a unique identity. | Sequential pages advance an identity boundary; no count request. | Strict monotonic identity and empty terminal page. |
+| `iter_list_keyset` | The method may omit `total`, but reliably supports ordering and filtering by a unique integer identity. | Sequential by default; explicit range, partitioned, or auto execution may batch bounded work after a planning barrier. | Caller-asserted keyset contract, strict monotonic identity, bounded-plan canaries, and terminal empty confirmation. |
 | `iter_list_cursor` | Each next request depends on a cursor from the previous response. | Sequential dependent cursor requests. | Strict unique monotonic cursor and empty terminal page. |
 | `iter_references` | The same list method must run for many parent parameter sets, such as comments per owner or messages per chat. | Bindings are scheduled with direct or physical-batch dispatch; each binding has its own traversal state. | Per-binding rows, completion/failure and caller correlation. |
 
@@ -169,6 +178,24 @@ async with stream:
 Without `identity`, successful exhaustion is reported as `MECHANICS_ONLY`: pagination completed,
 but the client cannot prove that the portal did not duplicate or substitute rows.
 
+Mapping-backed collections are explicit as well. `MAPPING_VALUES` yields values from a selected
+mapping in insertion order; `MAPPING_VALUES_OR_EMPTY` additionally accepts only an empty terminal
+sequence and records that degradation in the operation report.
+
+<!-- tested: tests/client_findings_3_test.py::test_shape_rejection_is_retained_as_zero_admission_page_evidence -->
+```python
+from b24api import ResultCollectionShape
+
+stream = client.iter_list(
+    Request("example.dictionary.list", replay_safety=ReplaySafety.SAFE),
+    selector=ResultSelector(("items",)),
+    collection_shape=ResultCollectionShape.MAPPING_VALUES,
+)
+async with stream:
+    async for value in stream:
+        consume(value)
+```
+
 ### Counted, physically batched tail
 
 The first direct page must contain an exact filtered `total` and, when more rows exist, `next`.
@@ -191,13 +218,23 @@ range, overlap, duplicate identity or total contradiction raises `IncompleteTrav
 
 ### No-count keyset
 
-Keyset traversal does not ask the server for a count. The method must honor ordering and a strict
-identity boundary such as `filter[>ID]`. It is intentionally sequential because a future boundary
-cannot be known safely before the preceding page arrives.
+Keyset traversal is sequential by default, preserving the compatible request shape and first-pull
+behavior. An explicit execution contract can instead capture both ordered boundaries, validate five
+capability canaries, and batch numeric ranges or occupied-anchor partitions. Planning completes
+before any row is emitted, so partial consumption still pays that barrier cost. Fast execution fails
+synchronously when its declared controls or policy capacity are ineligible.
+
+The caller must assert that the endpoint has a stable, unique integer key, honors strict numeric
+bounds and ordering, and satisfies the chosen page-completion rule. Concurrent mutation outside the
+captured middle is handled by the finishing sweep; mutation inside it is outside this assertion.
+An advisory `total` may only raise an automatic cost estimate and never proves completion. Reports
+record the selected strategy and reason: unbounded auto continuation has the same
+`ordered_prefix_only` assurance as sequential traversal, while bounded plans additionally report
+`canary_verified_bounds`.
 
 <!-- tested: tests/client_v2_test.py::test_keyset_and_cursor_are_explicit_strict_alternatives -->
 ```python
-from b24api import KeysetSpec, ParameterPath
+from b24api import AutoKeysetExecution, KeysetSpec, ParameterPath, StableIntegerKeysetContract
 
 stream = client.iter_list_keyset(
     Request("example.item.list", replay_safety=ReplaySafety.SAFE),
@@ -207,6 +244,7 @@ stream = client.iter_list_keyset(
         filter_path=ParameterPath(("filter",)),
         order_path=ParameterPath(("order",)),
     ),
+    execution=AutoKeysetExecution(contract=StableIntegerKeysetContract()),
 )
 ```
 
@@ -235,6 +273,10 @@ stream = client.iter_list_cursor(
 Cursor values must be unique and strictly monotonic. If an endpoint exposes only a non-unique
 boundary, use an application-owned direct-call workflow or supply a unique tie-breaker.
 
+See [architecture](docs/architecture.md), [migration](docs/migration.md),
+[performance](docs/performance.md), and [endpoint recipes](docs/recipes.md) for the complete
+contracts and selection guidance.
+
 ### One list method across many parent entities
 
 `Binding` applies exact parameter updates to a base request and carries parent correlation. The

{b24api-2.0.0 → b24api-2.1.0}/README.md

@@ -31,6 +31,15 @@ idempotent and closes active streams before the owned transport.
 Use `call()` for detached decoded JSON and `call_response()` when you also need the immutable
 response envelope: `result`, `total`, `next`, timing and bounded diagnostic evidence.
 
+Use `call_bytes()` when a successful method response is a file rather than a Bitrix JSON envelope.
+The operation is explicit and never hides malformed JSON by falling back to bytes.
+
+<!-- tested: tests/client_findings_3_test.py::test_binary_call_returns_every_success_byte_without_json_sniffing -->
+```python
+archive = await client.call_bytes(Request("example.export.download", replay_safety=ReplaySafety.SAFE))
+payload = archive.body
+```
+
 <!-- tested: tests/client_v2_test.py::test_call_and_call_response_have_stable_detached_types -->
 ```python
 from b24api import ReplaySafety
@@ -120,7 +129,7 @@ more specialized mechanics have explicit names and explicit preconditions.
 |---|---|---|---|
 | `iter_list` | The method supports ordinary offset pagination. | Pages are requested sequentially using server `next`; no separate count request is made. | Continuation and empty terminal page; add identity for duplicate detection. |
 | `iter_list_counted` | The first response provides an exact filtered `total` and stable offset pages. | Head page is direct; all known tail offsets are grouped into physical Bitrix batches. | Exact total, ranges and identities. |
-| `iter_list_keyset` | The method may omit `total`, but reliably supports ordering and filtering by a unique identity. | Sequential pages advance an identity boundary; no count request. | Strict monotonic identity and empty terminal page. |
+| `iter_list_keyset` | The method may omit `total`, but reliably supports ordering and filtering by a unique integer identity. | Sequential by default; explicit range, partitioned, or auto execution may batch bounded work after a planning barrier. | Caller-asserted keyset contract, strict monotonic identity, bounded-plan canaries, and terminal empty confirmation. |
 | `iter_list_cursor` | Each next request depends on a cursor from the previous response. | Sequential dependent cursor requests. | Strict unique monotonic cursor and empty terminal page. |
 | `iter_references` | The same list method must run for many parent parameter sets, such as comments per owner or messages per chat. | Bindings are scheduled with direct or physical-batch dispatch; each binding has its own traversal state. | Per-binding rows, completion/failure and caller correlation. |
 
@@ -157,6 +166,24 @@ async with stream:
 Without `identity`, successful exhaustion is reported as `MECHANICS_ONLY`: pagination completed,
 but the client cannot prove that the portal did not duplicate or substitute rows.
 
+Mapping-backed collections are explicit as well. `MAPPING_VALUES` yields values from a selected
+mapping in insertion order; `MAPPING_VALUES_OR_EMPTY` additionally accepts only an empty terminal
+sequence and records that degradation in the operation report.
+
+<!-- tested: tests/client_findings_3_test.py::test_shape_rejection_is_retained_as_zero_admission_page_evidence -->
+```python
+from b24api import ResultCollectionShape
+
+stream = client.iter_list(
+    Request("example.dictionary.list", replay_safety=ReplaySafety.SAFE),
+    selector=ResultSelector(("items",)),
+    collection_shape=ResultCollectionShape.MAPPING_VALUES,
+)
+async with stream:
+    async for value in stream:
+        consume(value)
+```
+
 ### Counted, physically batched tail
 
 The first direct page must contain an exact filtered `total` and, when more rows exist, `next`.
@@ -179,13 +206,23 @@ range, overlap, duplicate identity or total contradiction raises `IncompleteTrav
 
 ### No-count keyset
 
-Keyset traversal does not ask the server for a count. The method must honor ordering and a strict
-identity boundary such as `filter[>ID]`. It is intentionally sequential because a future boundary
-cannot be known safely before the preceding page arrives.
+Keyset traversal is sequential by default, preserving the compatible request shape and first-pull
+behavior. An explicit execution contract can instead capture both ordered boundaries, validate five
+capability canaries, and batch numeric ranges or occupied-anchor partitions. Planning completes
+before any row is emitted, so partial consumption still pays that barrier cost. Fast execution fails
+synchronously when its declared controls or policy capacity are ineligible.
+
+The caller must assert that the endpoint has a stable, unique integer key, honors strict numeric
+bounds and ordering, and satisfies the chosen page-completion rule. Concurrent mutation outside the
+captured middle is handled by the finishing sweep; mutation inside it is outside this assertion.
+An advisory `total` may only raise an automatic cost estimate and never proves completion. Reports
+record the selected strategy and reason: unbounded auto continuation has the same
+`ordered_prefix_only` assurance as sequential traversal, while bounded plans additionally report
+`canary_verified_bounds`.
 
 <!-- tested: tests/client_v2_test.py::test_keyset_and_cursor_are_explicit_strict_alternatives -->
 ```python
-from b24api import KeysetSpec, ParameterPath
+from b24api import AutoKeysetExecution, KeysetSpec, ParameterPath, StableIntegerKeysetContract
 
 stream = client.iter_list_keyset(
     Request("example.item.list", replay_safety=ReplaySafety.SAFE),
@@ -195,6 +232,7 @@ stream = client.iter_list_keyset(
         filter_path=ParameterPath(("filter",)),
         order_path=ParameterPath(("order",)),
     ),
+    execution=AutoKeysetExecution(contract=StableIntegerKeysetContract()),
 )
 ```
 
@@ -223,6 +261,10 @@ stream = client.iter_list_cursor(
 Cursor values must be unique and strictly monotonic. If an endpoint exposes only a non-unique
 boundary, use an application-owned direct-call workflow or supply a unique tie-breaker.
 
+See [architecture](docs/architecture.md), [migration](docs/migration.md),
+[performance](docs/performance.md), and [endpoint recipes](docs/recipes.md) for the complete
+contracts and selection guidance.
+
 ### One list method across many parent entities
 
 `Binding` applies exact parameter updates to a base request and carries parent correlation. The

{b24api-2.0.0 → b24api-2.1.0}/b24api/__init__.py

@@ -2,14 +2,23 @@
 
 from b24api.client import Bitrix24
 from b24api.contracts import (
+    AmbiguityPolicy,
+    AmbiguityReason,
+    AutoKeysetExecution,
     BatchDispatch,
+    BinaryEvidence,
+    BinaryResponse,
     Binding,
+    BodyEncoding,
+    ClosureWitness,
     Command,
     CommandFailure,
     CommandNotExecuted,
     CommandOutcome,
     CommandOutcomeUnknown,
     CommandSuccess,
+    CompositeIdentitySpec,
+    ConsistencyPolicy,
     CountedTraversal,
     CursorSpec,
     CursorTraversal,
@@ -17,16 +26,31 @@ from b24api.contracts import (
     DirectDispatch,
     ExecutionPolicy,
     IdentityCoercion,
+    IdentityComponent,
     IdentitySpec,
+    KeysetAssuranceSource,
+    KeysetExecution,
+    KeysetExecutionKind,
+    KeysetExecutionReport,
+    KeysetPageCompletion,
+    KeysetPhase,
+    KeysetSelectionReason,
     KeysetSpec,
     KeysetTraversal,
     NotExecutedReason,
+    OffsetContinuation,
     OffsetSpec,
     OperationReport,
     OperationStream,
+    PageDispatch,
+    PageOutcome,
+    PageRecord,
+    PageRejectionCode,
     ParameterPath,
     ParameterUpdate,
     PartialResult,
+    PartitionedKeysetExecution,
+    RangeKeysetExecution,
     ReferenceComplete,
     ReferenceEvent,
     ReferenceFailure,
@@ -36,16 +60,31 @@ from b24api.contracts import (
     ReferenceOutcomeUnknown,
     ReplaySafety,
     Request,
+    RequestHeaders,
+    RequestSummary,
     Response,
     ResultCollectionShape,
+    ResultErrorShape,
+    ResultErrorSpec,
     ResultSelector,
+    RetryPolicy,
+    SequentialKeysetExecution,
     SequentialTraversal,
+    SplitOrderSpec,
+    StableIntegerKeysetContract,
     TerminalState,
+    TotalHintMode,
+    TotalTermination,
+    TraceClass,
     TraversalAssurance,
+    TraversalIdentity,
+    UnknownRequestAudit,
+    UnknownRequestCollector,
     Violation,
     ViolationSeverity,
     partition_command_outcomes,
     partition_reference_outcomes,
+    traversal_control_paths,
 )
 from b24api.errors import (
     AmbiguousExecutionError,
@@ -55,57 +94,86 @@ from b24api.errors import (
     BatchFailed,
     BudgetExceededError,
     CapabilityError,
+    EnvelopeContractError,
     HTTPGatewayError,
+    IdentityContractError,
     IncompleteTraversalError,
     InputSourceError,
     PaginationError,
     ProtocolError,
     ReferenceFailed,
     ResponseTooLargeError,
+    ResultShapeError,
     TransportError,
 )
 from b24api.settings import Settings
-from b24api.transport import Transport, WireResponse
+from b24api.transport import Transport, TransportCapabilities, WireRequest, WireResponse, WireTransport
 
 __all__ = [
+    "AmbiguityPolicy",
+    "AmbiguityReason",
     "AmbiguousExecutionError",
     "ApiResponseError",
+    "AutoKeysetExecution",
     "B24ApiError",
     "BatchCommandError",
     "BatchDispatch",
     "BatchFailed",
+    "BinaryEvidence",
+    "BinaryResponse",
     "Binding",
     "Bitrix24",
+    "BodyEncoding",
     "BudgetExceededError",
     "CapabilityError",
+    "ClosureWitness",
     "Command",
     "CommandFailure",
     "CommandNotExecuted",
     "CommandOutcome",
     "CommandOutcomeUnknown",
     "CommandSuccess",
+    "CompositeIdentitySpec",
+    "ConsistencyPolicy",
     "CountedTraversal",
     "CursorSpec",
     "CursorTraversal",
     "DeliveryOrder",
     "DirectDispatch",
+    "EnvelopeContractError",
     "ExecutionPolicy",
     "HTTPGatewayError",
     "IdentityCoercion",
+    "IdentityComponent",
+    "IdentityContractError",
     "IdentitySpec",
     "IncompleteTraversalError",
     "InputSourceError",
+    "KeysetAssuranceSource",
+    "KeysetExecution",
+    "KeysetExecutionKind",
+    "KeysetExecutionReport",
+    "KeysetPageCompletion",
+    "KeysetPhase",
+    "KeysetSelectionReason",
     "KeysetSpec",
     "KeysetTraversal",
     "NotExecutedReason",
+    "OffsetContinuation",
     "OffsetSpec",
     "OperationReport",
     "OperationStream",
+    "PageDispatch",
+    "PageOutcome",
+    "PageRecord",
+    "PageRejectionCode",
     "PaginationError",
     "ParameterPath",
     "ParameterUpdate",
     "PartialResult",
+    "PartitionedKeysetExecution",
     "ProtocolError",
+    "RangeKeysetExecution",
     "ReferenceComplete",
     "ReferenceEvent",
     "ReferenceFailed",
@@ -116,19 +184,38 @@ __all__ = [
     "ReferenceOutcomeUnknown",
     "ReplaySafety",
     "Request",
+    "RequestHeaders",
+    "RequestSummary",
     "Response",
     "ResponseTooLargeError",
     "ResultCollectionShape",
+    "ResultErrorShape",
+    "ResultErrorSpec",
     "ResultSelector",
+    "ResultShapeError",
+    "RetryPolicy",
+    "SequentialKeysetExecution",
     "SequentialTraversal",
     "Settings",
+    "SplitOrderSpec",
+    "StableIntegerKeysetContract",
     "TerminalState",
+    "TotalHintMode",
+    "TotalTermination",
+    "TraceClass",
     "Transport",
+    "TransportCapabilities",
     "TransportError",
     "TraversalAssurance",
+    "TraversalIdentity",
+    "UnknownRequestAudit",
+    "UnknownRequestCollector",
     "Violation",
     "ViolationSeverity",
+    "WireRequest",
     "WireResponse",
+    "WireTransport",
     "partition_command_outcomes",
     "partition_reference_outcomes",
+    "traversal_control_paths",
 ]

b24api-2.1.0/b24api/_audit.py

@@ -0,0 +1,78 @@
+"""Lazy admission-time observation for logical command sources."""
+
+from __future__ import annotations
+from collections.abc import AsyncIterable, AsyncIterator, Callable, Iterable, Iterator
+from typing import TYPE_CHECKING, Protocol, Self, runtime_checkable
+
+from b24api.contracts.command import Command
+
+if TYPE_CHECKING:
+    from b24api.contracts.report import Violation
+    from b24api.contracts.request import Request
+
+
+@runtime_checkable
+class _SyncClosable(Protocol):
+    def close(self) -> None: ...
+
+
+@runtime_checkable
+class _AsyncClosable(Protocol):
+    async def aclose(self) -> None: ...
+
+
+class _SyncAuditSource[C](Iterator[Command[C]]):
+    def __init__(self, source: Iterable[Command[C]], audit: Callable[[Request], Violation | None]) -> None:
+        self._iterator = iter(source)
+        self._audit = audit
+        self.violations: list[Violation] = []
+
+    def __iter__(self) -> Self:
+        return self
+
+    def __next__(self) -> Command[C]:
+        command = next(self._iterator)
+        if isinstance(command, Command):
+            violation = self._audit(command.request)
+            if violation is not None:
+                self.violations.append(violation)
+        return command
+
+    def close(self) -> None:
+        if isinstance(self._iterator, _SyncClosable):
+            self._iterator.close()
+
+
+class _AsyncAuditSource[C](AsyncIterator[Command[C]]):
+    def __init__(self, source: AsyncIterable[Command[C]], audit: Callable[[Request], Violation | None]) -> None:
+        self._iterator = aiter(source)
+        self._audit = audit
+        self.violations: list[Violation] = []
+
+    def __aiter__(self) -> Self:
+        return self
+
+    async def __anext__(self) -> Command[C]:
+        command = await anext(self._iterator)
+        if isinstance(command, Command):
+            violation = self._audit(command.request)
+            if violation is not None:
+                self.violations.append(violation)
+        return command
+
+    async def aclose(self) -> None:
+        if isinstance(self._iterator, _AsyncClosable):
+            await self._iterator.aclose()
+
+
+def audit_command_source[C](
+    source: Iterable[Command[C]] | AsyncIterable[Command[C]],
+    audit: Callable[[Request], Violation | None],
+) -> Iterable[Command[C]] | AsyncIterable[Command[C]]:
+    """Observe each command exactly when its lazy source admits it."""
+    if isinstance(source, AsyncIterable):
+        return _AsyncAuditSource(source, audit)
+    return _SyncAuditSource(source, audit)
+
+
+__all__ = ["audit_command_source"]

b24api-2.1.0/b24api/_client_traversal.py

@@ -0,0 +1,170 @@
+"""Stateless traversal operation helpers for the public facade."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from b24api.contracts.keyset_execution import KeysetExecution, SequentialKeysetExecution
+from b24api.contracts.request import IdentitySpec, RequestLike, ResultSelector, TraversalIdentity, canonical_request
+from b24api.contracts.response import ResultCollectionShape
+from b24api.contracts.traversal import CursorSpec, KeysetSpec, OffsetSpec, TotalTermination
+from b24api.traversal.facade import counted_stream, cursor_stream, keyset_stream, sequential_stream
+
+if TYPE_CHECKING:
+    from b24api.contracts.json import JsonValue
+    from b24api.contracts.policy import ExecutionPolicy
+    from b24api.contracts.report import Violation
+    from b24api.contracts.request import Request
+    from b24api.contracts.stream import OperationStream
+    from b24api.execution import Executor
+
+_ROOT_SELECTOR = ResultSelector.root()
+_DEFAULT_OFFSET = OffsetSpec()
+_DEFAULT_COUNTED_OFFSET = OffsetSpec(total_termination=TotalTermination.EXACT_QUALIFIED)
+_DEFAULT_KEYSET = KeysetSpec()
+_DEFAULT_SEQUENTIAL_KEYSET_EXECUTION = SequentialKeysetExecution()
+
+
+class _TraversalFacade:
+    """Traversal methods sharing the lifecycle owned by ``Bitrix24``."""
+
+    _executor: Executor
+    _default_policy: ExecutionPolicy
+
+    def _require_open(self) -> None:
+        raise NotImplementedError
+
+    def _audit_unknown(self, request: Request) -> Violation | None:
+        raise NotImplementedError
+
+    def _register_stream[T](self, stream: OperationStream[T]) -> OperationStream[T]:
+        raise NotImplementedError
+
+    def _discard_stream(self, stream: object) -> None:
+        raise NotImplementedError
+
+    def iter_list(  # noqa: PLR0913
+        self,
+        request: RequestLike,
+        *,
+        selector: ResultSelector = _ROOT_SELECTOR,
+        identity: TraversalIdentity | None = None,
+        collection_shape: ResultCollectionShape = ResultCollectionShape.SEQUENCE,
+        page_size: int = 50,
+        offset: OffsetSpec = _DEFAULT_OFFSET,
+        policy: ExecutionPolicy | None = None,
+    ) -> OperationStream[JsonValue]:
+        """Return conservative sequential offset/server-next traversal."""
+        self._require_open()
+        canonical = canonical_request(request)
+        audit_violation = self._audit_unknown(canonical)
+        return self._register_stream(
+            sequential_stream(
+                self._executor,
+                canonical,
+                selector=selector,
+                identity=identity,
+                collection_shape=collection_shape,
+                page_size=page_size,
+                offset=offset,
+                policy=policy or self._default_policy,
+                deregister=self._discard_stream,
+                audit_violations=(() if audit_violation is None else (audit_violation,)),
+            ),
+        )
+
+    def iter_list_counted(  # noqa: PLR0913
+        self,
+        request: RequestLike,
+        *,
+        identity: TraversalIdentity | None = None,
+        selector: ResultSelector = _ROOT_SELECTOR,
+        collection_shape: ResultCollectionShape = ResultCollectionShape.SEQUENCE,
+        page_size: int = 50,
+        batch_size: int | None = None,
+        offset: OffsetSpec = _DEFAULT_COUNTED_OFFSET,
+        policy: ExecutionPolicy | None = None,
+    ) -> OperationStream[JsonValue]:
+        """Return exact direct-head plus physically batched counted traversal."""
+        self._require_open()
+        canonical = canonical_request(request)
+        audit_violation = self._audit_unknown(canonical)
+        return self._register_stream(
+            counted_stream(
+                self._executor,
+                canonical,
+                identity=identity,
+                selector=selector,
+                collection_shape=collection_shape,
+                page_size=page_size,
+                batch_size=batch_size,
+                offset=offset,
+                policy=policy or self._default_policy,
+                deregister=self._discard_stream,
+                audit_violations=(() if audit_violation is None else (audit_violation,)),
+            ),
+        )
+
+    def iter_list_keyset(  # noqa: PLR0913
+        self,
+        request: RequestLike,
+        *,
+        selector: ResultSelector,
+        identity: IdentitySpec,
+        collection_shape: ResultCollectionShape = ResultCollectionShape.SEQUENCE,
+        page_size: int = 50,
+        keyset: KeysetSpec = _DEFAULT_KEYSET,
+        execution: KeysetExecution = _DEFAULT_SEQUENTIAL_KEYSET_EXECUTION,
+        policy: ExecutionPolicy | None = None,
+    ) -> OperationStream[JsonValue]:
+        """Return exact sequential no-count keyset traversal."""
+        self._require_open()
+        canonical = canonical_request(request)
+        audit_violation = self._audit_unknown(canonical)
+        return self._register_stream(
+            keyset_stream(
+                self._executor,
+                canonical,
+                selector=selector,
+                identity=identity,
+                collection_shape=collection_shape,
+                page_size=page_size,
+                keyset=keyset,
+                execution=execution,
+                policy=policy or self._default_policy,
+                deregister=self._discard_stream,
+                audit_violations=(() if audit_violation is None else (audit_violation,)),
+            ),
+        )
+
+    def iter_list_cursor(  # noqa: PLR0913
+        self,
+        request: RequestLike,
+        *,
+        selector: ResultSelector,
+        cursor: CursorSpec,
+        identity: IdentitySpec | None = None,
+        collection_shape: ResultCollectionShape = ResultCollectionShape.SEQUENCE,
+        page_size: int = 50,
+        policy: ExecutionPolicy | None = None,
+    ) -> OperationStream[JsonValue]:
+        """Return strict dependent cursor traversal with empty confirmation."""
+        self._require_open()
+        canonical = canonical_request(request)
+        audit_violation = self._audit_unknown(canonical)
+        return self._register_stream(
+            cursor_stream(
+                self._executor,
+                canonical,
+                selector=selector,
+                cursor=cursor,
+                identity=identity,
+                collection_shape=collection_shape,
+                page_size=page_size,
+                policy=policy or self._default_policy,
+                deregister=self._discard_stream,
+                audit_violations=(() if audit_violation is None else (audit_violation,)),
+            ),
+        )
+
+
+__all__: list[str] = []