Fires when a scheduled item's availableAt time passes — i.e. an
item written with availableAt in the future has just become
visible on the wire. Carries the item's owner + id so the
listener can refetch it via AtCollection.getOrNull.
Fires leadTime before an item's expiresAt. Useful for
reminder / alarm UIs that need to nudge the user before a record
disappears (the atServer expires items hard at expiresAt, so
once that moment arrives the record is already gone).
Fires when a remote atSign posts a receipt for an item we can
observe. owner + id identify the PARENT item being read (the
thing the receipt is about — not the receipt sub-item itself), so
they match the owner + id of the corresponding CItem.
from is the reader; readAt is the moment the notification was
received (not the moment the reader wrote it).
Event emitted on AtClient.dataEvents whenever a keystore
mutation passes through LocalSecondary's chokepoint methods
(_update / _delete). Subscribers see every change driven by
this client — local app writes AND sync-applied remote changes —
in a single uniform stream.
A keystore record was created or updated. Carries the metadata
constructed from the UpdateVerbBuilder that drove the write so
listeners (e.g. an event-driven expiry timer) can read expiresAt
without re-fetching the record.
Represents a local key
Local key are confined to the client(device)/server it is created.
The key does not sync between the local-secondary and the cloud-secondary.
Contains methods to execute verb on local secondary storage using executeVerb
Set AtClientPreference.isLocalStoreRequired to true and other preferences that your app needs.
Delete and Update commands will be synced to the server
Root of the typed-predicate AST. Mint with the operator methods on
PathField (e.g. field.eq(value)); compose with and / or /
not. Pass to Query.wherePath to apply.
Immutable description of one level in a sub-collection tree. Used
with Query.watchWithTree to declare a parent → children → ...
shape that the library will live-orchestrate.
One node in the snapshot returned by Query.watchWithTree. Carries
the parentCItem<T> and the per-sub-collection branches —
each branch keyed by its SubSpec.subName and holding the current
list of children at that level (which are themselves TreeNodes,
recursing all the way down).
One row in the snapshot returned by Query.watchWithSub — a
parent CItem<P> alongside the current list of its children
CItem<C> from a single named sub-collection.
Comparison operator carried by a CmpPredicate. Stored as a value
(rather than encoded in the subclass) so switch over op stays
exhaustive at evaluation time and indexed-executor pushdown can
pattern-match on it.
Identifies the origin of a SyncRequest. Every sync request is
idempotent — "what to push" is owned by LocalSecondary's
AtSyncQueue, so requests are just "please drain" triggers that
can be coalesced wholesale at end-of-round.
Adds waitUntilCaughtUp to every SyncService without forcing
existing implementers to add a method to satisfy a new abstract
member. Implemented as an extension (not a method on SyncService
or a mixin) so:
Clears the process-global factory registry so tests can start from
a known empty state. The registry is a static cache on
AtCollection used by registerFactory / setUpFromAtSign; tests
call this in setUp/tearDown to avoid cross-test pollution.
Builds a CmpPredicate with the given parts, bypassing the
PathField operator path. Tests use this to exercise reserved
PredicateOp values that don't yet have a corresponding operator.
Constructs an AtCollection<T> on the EventSource.both path
with both source streams injected: tests drive each path
independently and assert un-deduplicated dual emission.
Constructs an AtCollection<T> with an injected notification
stream — required so tests drive notification events without an
active server connection. Callers supply notifications (typically
a StreamController.broadcast() they own); the produced collection
subscribes to it as if it were the live monitor stream.
Opens spec on parentItem using parentColl's context. Test-only
because the production call-site is hidden behind
AtCollection.subCollection — the spec object isn't directly
constructed by app code.
Constructs a sub-collection of parent with an injected
notification stream. Same semantics as
collectionWithInjectedNotifications but for nested collections.
