@framers/agentos-ext-account-sources 0.10.0 → 0.11.1

package/README.md

@@ -206,16 +206,16 @@ await store.control(scope, { type: 'grant_ready', use: { searchAskEnabled: true,
 const handle = await store.claim(scope, 'scheduled'); // null unless the connection is due and free
 ```
 
-`SqlAccountSourceSyncStore` keeps each connection's state, policy, open checkpoint, lease and barrier, the cycle's work rows, the provenance of retained sources and the connection's exclusions in the tables `sourceSyncSchema(prefix)` creates: eight statements, with a prefix of a lower-case letter and at most 31 lower-case letters, digits or underscores (`agentos_source_sync` unless given). Besides the four tables and the due and expiry indexes, two indexes of the work rows, one by disposition and source id and one of the waiting rows by retry time, let `takeWork` and `pendingRetry` read one row however many items a cycle queued. A database whose migration ran an earlier release's statements has no work indexes: the store is correct there and each take reads more rows, and running the statements again adds them. It needs a PostgreSQL adapter with transactions and runs no DDL. Its `fence` is the core `SqlSourceDerivationStore` on the same adapter, over the tables of `sourceDerivationSchema(derivationPrefix)`: every change to an owner's sources runs under that owner's fence, the one that also commits and delivers results derived from them.
+`SqlAccountSourceSyncStore` keeps each connection's state, policy, open checkpoint, lease and barrier, the cycle's work rows, the provenance of retained sources, the connection's exclusions and each source's charge record in the host's indexing period in the tables `sourceSyncSchema(prefix)` creates: ten statements, with a prefix of a lower-case letter and at most 31 lower-case letters, digits or underscores (`agentos_source_sync` unless given). Besides the five tables and the due and expiry indexes, two indexes of the work rows, one by disposition and source id and one of the waiting rows by retry time, let `takeWork` and `pendingRetry` read one row however many items a cycle queued, and an index of the charge records by the end of their period serves their removal once it ends. A database whose migration ran an earlier release's statements may lack the work indexes and the charges table: the store is correct there, each take reads more rows and each read is weighed against the copies the store holds alone, with no deferral, and running the statements again adds them. It needs a PostgreSQL adapter with transactions and runs no DDL. Its `fence` is the core `SqlSourceDerivationStore` on the same adapter, over the tables of `sourceDerivationSchema(derivationPrefix)`: every change to an owner's sources runs under that owner's fence, the one that also commits and delivers results derived from them.
 
 The host supplies seven bindings, and may supply an eighth, `refresh`. The store calls each inside its own transaction, on the transaction adapter it passes:
 
 | Binding | What it does |
 |---|---|
 | `active(tx, owner)` | Answers false for an account that is deleted or being deleted, whose admission is off or whose purge is pending; the store then claims, commits and reactivates nothing for it and answers no source state |
-| `allowance(tx, scope)` | Answers the connection's document and held-character ceilings after unrelated sources, and the remaining indexing balance |
+| `allowance(tx, scope)` | Answers the connection's document and held-character ceilings after unrelated sources, the remaining indexing balance, and optionally `indexingPeriodEndsAt`, the first millisecond after the period that balance belongs to (below) |
 | `write(tx, scope, dependency, document, prepared)` | Writes the document's text and the host's prepared passages and vectors |
-| `chargeIndexed(tx, scope, characters)` | Charges the characters a committed write adds to index: a read's whole text, or, against a copy the store still holds, the read's new and changed messages and the text beside them (a changed header line or separator counts, as does the separator of a message that moved after another neighbour); never called for a read that adds nothing |
+| `chargeIndexed(tx, scope, characters)` | Charges the characters a committed write adds to index: a read's whole text, or, against a copy the store holds or the text it indexed for the source in the host's named indexing period, the read's new and changed messages and the text beside them (a changed header line or separator counts, as does the separator of a message that moved after another neighbour); never called for a read that adds nothing |
 | `purge(tx, owner, affected)` | Deletes the host's text, passages and vectors in the affected scope |
 | `purgeResults(tx, owner, ids)` | Deletes the host's rows for these derived results |
 | `rebind(tx, scope, generation)` | Moves the connection's host rows to a new generation without changing their content, version or expiry |
@@ -223,11 +223,13 @@ The host supplies seven bindings, and may supply an eighth, `refresh`. The store
 
 Provider reads, embedding and model calls run between store calls, never inside a binding.
 
-A sync holds a lease. `claim(scope, trigger)` answers a handle only when the owner is active, the `active` binding agrees, no barrier or live lease is set and `sourceSyncDue` holds; `renew(handle)` extends the lease by `leaseMs`; `release(handle, event?)` gives it up, records a deferral or a fixed failure when one is given, and keeps the checkpoint and work for the next claim. `openCycle` opens a checkpoint, with the cycle's running counts at zero (`tally`, below), or answers the one already open; `page` records a page and queues its ids in one transaction (the same page sent again right after answers the same checkpoint; any other stale revision answers null), and an id the cycle already queued is queued again, keeping its failures while the provider has not answered it since; and `takeWork` marks the next due item attempted before the read: the first pending item by source id, then the one whose wait passed first, so a read that keeps failing never holds back one that has not failed; an item that reached five attempts without a recorded result is not taken but waits `pollMs` as a `storage_unavailable` retry. Every call made with a handle checks the owner fence, the lease token and expiry, the generation and the `active` binding in the same transaction; once any of them has moved on, `release(handle)` answers false and every other call answers null.
+A sync holds a lease. `claim(scope, trigger)` answers a handle only when the owner is active, the `active` binding agrees, no barrier or live lease is set and `sourceSyncDue` holds; `renew(handle)` extends the lease by `leaseMs`; `release(handle, event?)` gives it up, records a deferral or a fixed failure when one is given, and keeps the checkpoint and work for the next claim. `openCycle` opens a checkpoint, with the cycle's running counts at zero (`tally`, below), or answers the one already open; `page` records a page and queues its ids in one transaction (the same page sent again right after answers the same checkpoint; any other stale revision answers null), and an id the cycle already queued is queued again, keeping its failures while the provider has not answered it since, and a source an `indexing_limit` skip deferred is queued settled as that skip (below); and `takeWork` marks the next due item attempted before the read: the first pending item by source id, then the one whose wait passed first, so a read that keeps failing never holds back one that has not failed; an item that reached five attempts without a recorded result is not taken but waits `pollMs` as a `storage_unavailable` retry. Every call made with a handle checks the owner fence, the lease token and expiry, the generation and the `active` binding in the same transaction; once any of them has moved on, `release(handle)` answers false and every other call answers null.
 
 `applyResult(handle, work, result, prepared)` keeps a `retry` result unresolved and counts it in the row's `failures`, across the counts of attempts `takeWork` starts again after a `pollMs` wait. From the tenth failure on, it records the read as skipped with `attempt_limit` in place of the wait once the failures are evidently the read's own. A failure at the provider counts as the read's own once the provider has answered another read of the cycle (applied, gone or skipped for a reason other than an exclusion) in the run of the read's first such failure, from the claim of that run's lease, or in any run after it; a `storage_unavailable` failure, a preparation's or the store's, once another document of the cycle has been prepared and written in that run or after it. During an outage of the provider or of preparation nothing is answered or prepared, so no read is given up until its cycle has been open for `reconcileMs`; from then on a read's next failure, from its tenth, gives it up, so the cycle ends and a reconcile can follow. A document whose cache lifetime has ended by the store's clock when it is weighed, as one admitted with a few seconds of it left and applied again after a longer preparation, is recorded as skipped with `expired`, never refused as malformed: the skip is terminal, so the cycle commits and the next scheduled sync stays, and the source is read again the next time a cycle lists it: a later history change that names it, or a scan that finds it, such as a reconcile's. A `document` result is weighed first: the store ranks this connection's retained sources and the new one by activity time, newest first with ties broken by source id, and keeps those inside `maxRetainedDocuments`, `maxHeldCharacters` and the allowance. A document that does not fit is recorded as skipped with `document_limit`, `held_limit` or `indexing_limit`, and an excluded one with `excluded`. A document that fits replaces the source's previous copy in the same transaction (host write, indexing charge and provenance), after that copy and every derived result that depends on it are removed through the fence, and this connection's other sources the limits no longer admit are removed with it, never another connection's. A read that repeats the text and message spans of a copy the store still holds, within its expiry and window, adds nothing to index: it is charged nothing and is not weighed against the indexing allowance, so neither a reconcile that reads every retained source again nor a change to a source's labels or history spends any of it. Any other read of such a copy is weighed against the indexing allowance and charged by its new and changed messages: the store keeps the hash of each message's text, and a message the copy holds with the same id, text hash, cut and length is free, as is the text before it (its separator and any header lines) when that text is the copy's and the message before it is the one the copy has there, itself unchanged (`leadHash` on each span); a changed header line or separator is charged, and so are the separator after an edited message and the separator of a message that follows another neighbour than it did. A reply is charged its separator and text, a message edited in place is charged with the separators beside it, and a read that only drops messages is charged nothing, since the messages it keeps follow the same neighbours among those kept (a message that becomes the first keeps its header lines but loses its separator, so those lines are charged once). A connector that caps a thread's text and spends it on the newest messages first, as Gmail's does under its `maxThreadCharacters`, cuts the oldest message shorter at each reply near the cap: that message is charged again at its new length, with the lead of the message after it (its separator and any header lines), and the rest of the thread is not. A copy whose messages keep no text hash, as an earlier release wrote it, is weighed by the hash of its whole text instead: a read that begins with that text, every message of the copy at the same span, is charged what follows it, and any other read, like every read of a copy without either hash, is charged in full. When the read also repeats the copy's version and content hash, the `refresh` binding keeps the copy in place, with every result derived from it, and gives it the read's expiry and message windows; otherwise, and for a host without the binding, the copy is written again from a fresh preparation. A `gone` result, a skip and an excluded document remove the source's previous copy, except an `indexing_limit` skip whose previous copy is within its expiry and window, still admitted as it is by the retained limits, and where the new read begins: the read's text starts with the copy's text, by the hash the store keeps of it, and holds every message of it at the same span. That copy, admitted and charged under an earlier read, stays with the shorter of its own and the read's expiry and message windows until a later read of the source finds room in the allowance (a change to it, or a reconcile) or the copy expires; a read that lost or changed one of its messages removes it. A reply that cuts the oldest message of a thread at the cap changes that message, so with the allowance spent it removes the thread's copy, and the thread stays out of the store until a read of it fits the allowance whole. A `gone` result, a skip the provider answers and an `expired` skip withdraw the previous copy first, in a transaction of their own: its expiry moves to the store's clock, so from then on `readCurrent` answers it expired and the fence neither commits nor delivers anything derived from it, even when the removal that follows fails, as when the host's `purge` binding throws. A withdrawn copy is past its expiry, so the next `expire` or `sweepExpired` removes it, as does the read's retry. A read the store gives up withdraws nothing and keeps the previous copy within its own expiry and window: the read saw nothing of the source, so nothing is decided about the copy, and a later read of the source replaces it. `attempt_limit` is the store's own reason, and a result that carries it is refused as `invalid_response`. A copy past its expiry or window counts as not held, whether or not `expire` has removed it yet. Given `prepared` as null, a document the store has to write answers `pending` with the same handle and records nothing; apply it again with its prepared value. Such a document reaches the `allowance` binding in both calls, so keep that binding to reads. A failing binding rolls the whole application back, apart from such a withdrawal. The answer carries a new handle whenever a removal advanced the owner's fence; later calls use it. `finish` commits the cycle's target cursor once every work item is terminal, counting the cycle's work rows in the database. `progress` records the counts so far without reading a work row: the checkpoint keeps the cycle's running counts (`tally`, a `SourceSyncTally`), which each transaction that settles an item or queues one again changes with it, and the retained sources are counted in the database, so a cycle of many reads costs each read a few rows. A checkpoint an earlier release wrote, without the counts, is counted from its work rows once.
 
-Controls run with the owner blocked, a tune (below) aside. `control(scope, event, policy?)` applies `connect_started`, `grant_ready`, `pause`, `resume`, `use_changed`, `policy_changed` (with the new policy), `grant_lost` or `disconnect`: it records a content-free barrier and drops the open cycle in one transaction, then completes the barrier and reactivates the owner. Connecting, grant loss and disconnecting remove the connection's sources, their derived results and its exclusions. Pause, resume, a use change and a policy change move retained content to the new generation with its version kept and its expiry never extended, so no result derived before the change can be delivered again; a policy change also removes the sources the new limits leave out and shortens the expiry of the rest to the new window. `exclude(scope, sourceId)` removes one source and keeps a content-free exclusion; `resetExclusions(scope)` clears them. Both raise the generation and keep the committed cursor, and make a reconcile the next cycle: a fresh bounded scan, then history replayed from that cursor, so a change made since it reaches the store even for an item the scan does not list. A control other than disconnecting throws `stale_source_sync` while the `active` binding refuses the owner. A barrier left by a failure blocks claims and reactivation until `recoverControl(scope)` completes it, and a lifecycle worker calls it even for a paused connection. `expire(scope, limit)` removes retained sources whose expiry has passed, also while the connection is paused or the owner's fence is inactive, as for a suspended account, which stays inactive, then the owner's expired derived results; reads refuse an expired source either way. Each source goes in a transaction of its own. When a removal or the results' expiry fails, `expire` throws the failure; once it had removed a source, it throws a `SourceSyncExpiryError` with the failure's message and `cause`, whose `partial` counts the removals made before it in `removed` and names their sources in `sourceIds`, in the order they went. Those removals committed, so a host that counts what `expire` removed adds `partial.removed` in its catch, as `maintain` does. `sweepExpired(limit?, owner?)` does the same across every connection, or one owner's, the earliest expiry first and by the store's own expiry, however far a maintenance walk is from them, and answers `{ removed, failed }`: an owner whose removal fails, as when its host purge keeps failing, is counted and left out of the call's later reads, so a call with up to `limit` such owners never holds back another owner's copies. An owner whose derived results then fail to expire is counted too, once; the call still answers every source it removed, and the other owners' results still expire. `removeOwner(owner, remove?)` removes a stopped owner's rows in one transaction: each of its connections, with its work rows, provenance and exclusions, once every one is disconnected with no barrier, lease, work or retained source, after running the lifecycle's own `remove` in the same transaction; the core fence's owner row and deletion records stay, since they hold no content and a restore replays the deletion from them.
+A host that charges indexing by the month, or by any period, names the period's end in its allowance: `indexingPeriodEndsAt`, the first millisecond after the period, as integer UTC epoch milliseconds. With it named and the charges table in place, the store keeps one charge record for each source it indexed in the period: the provenance of the newest text it wrote or refreshed for the source there, with the message ids, spans, counts and hashes the documents table keeps, never text. A read is weighed against that record as well as against the copy the store holds, by the same rules, and charged the smaller amount, so a copy that expires and is removed does not take its charge with it: a thread read again unchanged in the same period is stored again at no charge, and a reply to it is charged its separator and text. A copy held from an earlier period and refreshed or written in this one becomes this period's text the same way, so a source the index has held since an earlier period is charged again only for what changes. An `indexing_limit` skip that leaves no copy records a deferral with the room the allowance gave the read, the smaller of `maxIndexedCharacters` and the balance, and the time of the skip. For a source the period already indexed, the record keeps the provenance of that text beside the deferral, so the read once the room grows is weighed against that recorded text by the same rules and charged only what differs from it: a thread charged 1,000 characters whose copy expired, and whose reply of 100 was deferred with 10 left, is charged the reply alone once the allowance grows. The record holds the newest text the period wrote, not every version it charged, so a read that returns to an earlier version is charged by its difference from the newest. For a source the period never indexed, the record keeps the deferral alone, so nothing in it confirms a text the store never held. While the period lasts, the connection keeps its generation, the allowance leaves no more room and less than the policy's `reconcileMs` has passed since the skip, `page` queues the source settled as the same skip, with no read, no purge and no deletion record, counted among the cycle's settled and skipped items and never as a provider's answer; once the period turns, the room grows, the generation moves or the reconcile interval has passed, the source is read again, so a change at the source, a deletion or an edit that makes it fit, reaches the store within about one reconcile interval. `page` reads the `allowance` binding for that only when a listed source holds a deferral. A record goes with its connection and its owner, when a read finds the source gone or the provider skips it, when the source is excluded, and once its period has ended: `expire` and `sweepExpired` remove up to `limit` ended records after the copies. A `gone` result and a provider's skip remove the record in the transaction that withdraws the copy, before the application, and for a source with no copy held as well, so a host `purge` that throws in the application cannot keep it. A copy's own expiry and replacement leave the record in place until its period ends. A host that names no period, or a database without the charges table, has each read weighed against the copies the store holds alone, with no deferral.
+
+Controls run with the owner blocked, a tune (below) aside. `control(scope, event, policy?)` applies `connect_started`, `grant_ready`, `pause`, `resume`, `use_changed`, `policy_changed` (with the new policy), `grant_lost` or `disconnect`: it records a content-free barrier and drops the open cycle in one transaction, then completes the barrier and reactivates the owner. Connecting, grant loss and disconnecting remove the connection's sources, their derived results, its exclusions and its charge records. Pause, resume, a use change and a policy change move retained content to the new generation with its version kept and its expiry never extended, so no result derived before the change can be delivered again; a policy change also removes the sources the new limits leave out and shortens the expiry of the rest to the new window. `exclude(scope, sourceId)` removes one source and keeps a content-free exclusion; `resetExclusions(scope)` clears them. Both raise the generation and keep the committed cursor, and make a reconcile the next cycle: a fresh bounded scan, then history replayed from that cursor, so a change made since it reaches the store even for an item the scan does not list. A control other than disconnecting throws `stale_source_sync` while the `active` binding refuses the owner. A barrier left by a failure blocks claims and reactivation until `recoverControl(scope)` completes it, and a lifecycle worker calls it even for a paused connection. `expire(scope, limit)` removes retained sources whose expiry has passed, also while the connection is paused or the owner's fence is inactive, as for a suspended account, which stays inactive, then the owner's expired derived results, then up to `limit` of the connection's charge records whose period has ended; reads refuse an expired source either way. Each source goes in a transaction of its own. When a removal or the results' expiry fails, `expire` throws the failure; once it had removed a source, it throws a `SourceSyncExpiryError` with the failure's message and `cause`, whose `partial` counts the removals made before it in `removed` and names their sources in `sourceIds`, in the order they went. Those removals committed, so a host that counts what `expire` removed adds `partial.removed` in its catch, as `maintain` does. `sweepExpired(limit?, owner?)` does the same across every connection, or one owner's, the earliest expiry first and by the store's own expiry, however far a maintenance walk is from them, and answers `{ removed, failed }`: an owner whose removal fails, as when its host purge keeps failing, is counted and left out of the call's later reads, so a call with up to `limit` such owners never holds back another owner's copies. An owner whose derived results then fail to expire is counted too, once; the call still answers every source it removed, and the other owners' results still expire. Last, it removes up to `limit` charge records whose period has ended, every owner's or the one owner's, the earliest end first, and a failure there counts once in `failed`. `removeOwner(owner, remove?)` removes a stopped owner's rows in one transaction: each of its connections, with its work rows, provenance, exclusions and charge records, once every one is disconnected with no barrier, lease, work or retained source, after running the lifecycle's own `remove` in the same transaction; the core fence's owner row and deletion records stay, since they hold no content and a restore replays the deletion from them.
 
 ```ts
 import { sourceSyncContentChanges } from '@framers/agentos-ext-account-sources';
@@ -241,7 +243,7 @@ const after = await store.control(scope, { type }, next); // a tune is null whil
 
 A tune changes a policy's operating bounds without a reset. `control(scope, { type: 'policy_tuned' }, policy)` stores a policy that differs from the stored one only in `SOURCE_SYNC_OPERATING_BOUNDS`, in one transaction under the owner fence's row lock and the connection's, and changes nothing else: it records no barrier and moves neither the generation nor the owner's epoch, so every fence ticket and derived result stays valid, and the cursor, `revalidationRequired`, progress, schedule and retained sources stay as they were, in any state. A connection `readCurrent` answered as connected is still connected, so search and delivery go on. Any other difference throws a `SourceSyncPolicyTuneError` whose `bounds` names the differing keys, as `sourceSyncContentChanges` answers them, and changes nothing: a change to what a connection keeps takes `policy_changed`. The new bounds apply from the next lease. While a lease is live a tune that would change the policy changes nothing and answers null: a sync keeps the policy it claimed its lease with, which a provider may check against the stored one before each request, as Gmail's does. Tune again once that sync ends. A lease past its time by the store's clock ends with the tune, as a claim would replace it, so a worker whose clock runs behind holds a handle no later call accepts: its next call, and the end of a request it already has in flight, are refused, and neither can be handed on as a lost grant once a provider sees the new policy. A cycle left open between leases goes on under the new bounds, except that its scan ends there, as a bounded scan ends, before its history, when it has already reached a lower `maxScanPages` or `maxCandidates`, or when the new `scanPageSize` is below the size its next page token was read under (`pageTokenSize`; for a checkpoint written before that field, the stored policy's size, which the first tune that leaves the scan open keeps as its `pageTokenSize`). The next sync stays when it was scheduled, so a new `pollMs` counts from the sync after it. A tune stores the whole policy it is given, as a policy change does, so of two tunes made from one snapshot the later one's policy stands. A tune to the stored policy answers the snapshot and changes nothing, under a live lease too, and a tune throws `stale_source_sync` while the `active` binding refuses the owner or a barrier is set, which it never completes.
 
-`readCurrent(tx, derivation)` answers the current state of a derivation's sources for the fence's commit and delivery checks, and a connection with a barrier or pending revalidation reads as disconnected. The store's provenance decides a source's expiry: a policy change's prune and an `indexing_limit` skip that keeps a copy shorten it there without calling a binding, so a host that reads its own rows takes the earlier of its row's expiry and the one `readCurrent` answers. `snapshot(scope)` answers metadata for authenticated controls and `documents(scope)` the retained provenance; neither authorizes delivery. Work rows and barriers hold ids and fixed values only. The documents table holds provenance, message timing, counts and hashes, never text. A copy's text hash, the text hash and lead hash of each of its messages (the lead holding a message's header lines) and a connector's content hash each confirm a guessed text, a short message most easily, so treat the table as content, like the host's own tables, for access, retention and backups.
+`readCurrent(tx, derivation)` answers the current state of a derivation's sources for the fence's commit and delivery checks, and a connection with a barrier or pending revalidation reads as disconnected. The store's provenance decides a source's expiry: a policy change's prune and an `indexing_limit` skip that keeps a copy shorten it there without calling a binding, so a host that reads its own rows takes the earlier of its row's expiry and the one `readCurrent` answers. `snapshot(scope)` answers metadata for authenticated controls and `documents(scope)` the retained provenance; neither authorizes delivery. Work rows and barriers hold ids and fixed values only. The documents table holds provenance, message timing, counts and hashes, never text, and the charges table holds the same of each source's period text, or a deferral's generation, room and time alone. A copy's text hash, the text hash and lead hash of each of its messages (the lead holding a message's header lines) and a connector's content hash each confirm a guessed text, a short message most easily, so treat both tables as content, like the host's own tables, for access, retention and backups.
 
 ### Request quotas
 

package/dist/sync/SqlAccountSourceSyncStore.d.ts

@@ -31,6 +31,18 @@ export interface SourceSyncAllowance {
     readonly maximumConnectionDocuments: number;
     readonly maximumConnectionHeldCharacters: number;
     readonly additionalIndexedCharacters: number;
+    /**
+     * Optional. When the indexing period whose balance `additionalIndexedCharacters` is ends: the first millisecond after
+     * it, as integer UTC epoch milliseconds, such as the start of the next month for a host that charges by the month.
+     * With it named, a period that has not ended by the store's clock, and the charges table of `sourceSyncSchema` in
+     * place, the store keeps each source's charge record for the period: a read is weighed against the newest text the
+     * store wrote or refreshed for the source in the period as well as against the copy it holds, so a source read again
+     * after its copy expired is charged only what it adds, and a source an `indexing_limit` skip leaves with no copy is
+     * settled as that skip with no read until the period turns, the allowance leaves more room, the connection's
+     * generation moves or the policy's `reconcileMs` has passed since the skip. Without it the store charges as it always
+     * has.
+     */
+    readonly indexingPeriodEndsAt?: number;
 }
 /**
  * The host's table bindings. The store calls each one inside the owner fence, on the transaction adapter it is given
@@ -44,14 +56,19 @@ export interface SourceSyncStorageBindings<Prepared> {
      * claims, commits and reactivates nothing for the owner and answers no source state.
      */
     active(tx: StorageAdapter, scope: SourceOwnerScope): Promise<boolean>;
-    /** Absolute ceilings for this connection after subtracting unrelated sources; indexing is the remaining period balance. All writers take the owner fence first. */
+    /**
+     * Absolute ceilings for this connection after subtracting unrelated sources; indexing is the remaining period balance,
+     * and `indexingPeriodEndsAt`, when given, the end of that period. All writers take the owner fence first. The store
+     * reads it to weigh a document, and in `page` when a listed source holds a deferral, so keep it to reads.
+     */
     allowance(tx: StorageAdapter, scope: SourceSyncScope): Promise<SourceSyncAllowance>;
     /** Writes the document's content and the prepared value under this dependency, on the given transaction. */
     write(tx: StorageAdapter, scope: SourceSyncScope, dependency: SourceDependency, document: SourceSyncDocument, prepared: Prepared): Promise<void>;
     /**
      * Charges the sanitized characters a committed write adds to index to the owner's indexing allowance: a read's whole
-     * text, or, against a copy the store still holds, the read's new and changed messages and the text beside them, as
-     * `applyResult` weighs them. The store does not call it for a read that adds nothing.
+     * text, or, against a copy the store holds or the text it indexed for the source in the host's named indexing
+     * period, the read's new and changed messages and the text beside them, as `applyResult` weighs them. The store does
+     * not call it for a read that adds nothing.
      */
     chargeIndexed(tx: StorageAdapter, scope: SourceSyncScope, characters: number): Promise<void>;
     /** Removes the host's source content in the affected scope: text, passages and vectors. */
@@ -163,8 +180,11 @@ export declare class SourceSyncExpiryError extends Error {
  * before purging it, so a purge that fails leaves nothing derived from it deliverable. A read that repeats the text of
  * a copy the store holds is never charged again, one that changes it is charged, by the hash the store keeps of each
  * message's text, its new and changed messages and the text beside them, and with the host's `refresh` binding a read
- * of that very copy keeps it in place. Provider reads, embedding and model calls stay outside the store. The
- * constructor runs no DDL: the host's migration runs `sourceSyncSchema` and core's `sourceDerivationSchema` first.
+ * of that very copy keeps it in place. A host whose allowance names the end of its indexing period has each source's
+ * indexed text weighed for the rest of the period too, past its copy's expiry, and a source the allowance could not
+ * take settled with no read until it can, for a reconcile interval at a time. Provider reads, embedding and model calls
+ * stay outside the store. The constructor runs no DDL: the host's migration runs `sourceSyncSchema` and core's
+ * `sourceDerivationSchema` first.
  *
  * @typeParam Prepared - The host's in-memory value for one document, passed through to its `write` binding.
  */
@@ -186,6 +206,35 @@ export declare class SqlAccountSourceSyncStore<Prepared = unknown> {
      */
     constructor(db: StorageAdapter, options: SourceSyncStoreOptions<Prepared>);
     private now;
+    /** Whether the charges table was found in place; a table found stays found, one missing is looked for again. */
+    private chargesTable;
+    /**
+     * Whether the charges table of `sourceSyncSchema` is in place, which a database migrated by an earlier release's
+     * statements lacks: without it the store records no charge and no deferral.
+     */
+    private chargesHeld;
+    /** The source's charge record in the period ending at `period`, or null when it has none there. */
+    private chargeRecord;
+    /** Writes the source's charge record for the period ending at `period`, in place of any earlier one. */
+    private recordCharge;
+    /** Removes the source's charge record, when the table is in place. */
+    private forgetCharge;
+    /** Whether the source has a charge record, in any period, when the table is in place. */
+    private recorded;
+    /**
+     * Removes up to `limit` charge records whose period has ended by the store's clock, the earliest first: every
+     * owner's, or `owner`'s alone, or only those of `connectionId` of that owner. Answers how many went.
+     */
+    private forgetEnded;
+    /**
+     * The listed sources `page` settles as `indexing_limit` skips with no read: each holds a deferral of the host's
+     * current indexing period at the connection's generation, recorded less than the policy's `reconcileMs` ago, the store
+     * holds no copy of it within its expiry, and the room the allowance leaves is no larger than the room it was skipped
+     * with. The allowance is read only when a listed source holds such a deferral. Past the reconcile interval the source
+     * is read again, so a change at the source, a deletion or an edit that makes it fit, reaches the store, as a
+     * reconcile reads every listed source again.
+     */
+    private deferredOf;
     private fenceOn;
     private row;
     private save;
@@ -248,8 +297,17 @@ export declare class SqlAccountSourceSyncStore<Prepared = unknown> {
      * counts they are weighed against, so a read given up before is given up again at its next failure; a read the
      * provider answered starts a count of its own.
      *
+     * A source an `indexing_limit` skip deferred in the host's current indexing period is queued settled, as the same
+     * skip, with no read, no purge and no deletion record, while the connection keeps the generation of the skip, less
+     * than the policy's `reconcileMs` has passed since it, the store holds no copy of the source and the allowance leaves
+     * no more room than the skip had: the host's `allowance` binding is read for that, only when a listed source holds
+     * such a deferral. The skip counts among the cycle's settled and skipped items, and not as a provider's answer. Once
+     * the period turns, the room grows, the generation moves or the reconcile interval has passed, the source is queued
+     * pending and read again, so a change at the source reaches the store within about one reconcile interval.
+     *
      * @throws {SourceSyncFault} `invalid_response` for an id longer than 512 characters, and the page rules'
      *   `invalid_source_sync_page` for a page the checkpoint does not admit.
+     * @throws {Error} `invalid_source_allowance` when the allowance read for a deferral is not valid.
      */
     page(h: SourceSyncHandle, expected: SourceSyncCheckpoint, page: SourceSyncPage): Promise<SourceSyncCheckpoint | null>;
     private putWork;
@@ -349,6 +407,16 @@ export declare class SqlAccountSourceSyncStore<Prepared = unknown> {
      * does not begin with the copy's text, so with the allowance spent it removes the thread's copy, and the thread stays
      * out of the store until a read of it fits the allowance whole.
      *
+     * An allowance that names the end of the host's indexing period (`indexingPeriodEndsAt`), with the charges table in
+     * place, has the read weighed against the newest text the store wrote or refreshed for the source in that period as
+     * well, by the same rules, and charged the smaller amount: a source read again after its copy expired and was
+     * removed is charged nothing when its text is unchanged and only what it adds otherwise, as a reply's separator and
+     * text. Each written or refreshed read becomes the period's text for the source. An `indexing_limit` skip that keeps
+     * no copy records a deferral with the room the allowance left it and the time, which `page` honours for a reconcile
+     * interval, and the record then keeps no provenance: nothing in it confirms the text of a source the store holds no
+     * copy of. A `gone` result and a skip the provider answers remove the source's record, before the application and
+     * with the withdrawal below, so a host purge that throws cannot keep it; the store's own skips keep it.
+     *
      * A `gone` result and a skip the provider answers withdraw the old copy before that, in a transaction of their own
      * (`withdraw`), and so does an `expired` skip, before its application runs again: the copy's expiry moves to the
      * store's clock, so from then on `readCurrent` answers it expired and the fence neither commits nor delivers a result
@@ -364,9 +432,10 @@ export declare class SqlAccountSourceSyncStore<Prepared = unknown> {
      *   stale handle or work item.
      * @throws {SourceSyncFault} `invalid_response` for a result that does not match its work item or is malformed, a skip
      *   that carries `attempt_limit` among them.
-     * @throws {Error} `invalid_source_allowance` when the host's allowance is not made of nonnegative safe integers, and
-     *   `invalid_source_sync_charge` should the characters a read adds come out below zero or fractional, which the
-     *   ordered spans of a valid read and an intact copy rule out; nothing is charged or written.
+     * @throws {Error} `invalid_source_allowance` when the host's allowance is not made of nonnegative safe integers, its
+     *   period's end included when given, and `invalid_source_sync_charge` should the characters a read adds come out
+     *   below zero or fractional, which the ordered spans of a valid read and an intact copy rule out; nothing is charged
+     *   or written.
      */
     applyResult(h: SourceSyncHandle, work: SourceSyncWork, result: SourceSyncReadResult, prepared: Prepared | null): Promise<SourceSyncApplication | null>;
     /** Whether the connection holds a copy of the source within its expiry, read without a lock. */
@@ -376,7 +445,9 @@ export declare class SqlAccountSourceSyncStore<Prepared = unknown> {
      * before the one that removes it: the copy's expiry, and its dependency's, move to the store's clock. `readCurrent`
      * then answers it expired, so the fence neither commits nor delivers a result derived from it, and `expire` and
      * `sweepExpired` remove it should the removal fail. The handle, the work item and the result are checked as
-     * `applyResult` checks them, and a copy already past its expiry is left as it is.
+     * `applyResult` checks them, and a copy already past its expiry is left as it is. With `forget`, for a provider's
+     * answer, the source's charge record goes in the same transaction, so its message ids and hashes are gone whatever
+     * the removal after it does; the store's own `expired` skip keeps it.
      *
      * @returns True once the copy is withdrawn or none is held within its expiry; null for a stale handle or work item.
      * @throws {SourceSyncFault} `invalid_response` for a result that does not match its work item or a skip reason the
@@ -474,7 +545,12 @@ export declare class SqlAccountSourceSyncStore<Prepared = unknown> {
      * or a skip withdrew reads as expired until it is removed.
      */
     readCurrent(tx: StorageAdapter, derivation: SourceDerivation): Promise<readonly SourceDependencyState[]>;
-    /** Removes the host's content and this store's provenance in the affected scope; the fence calls it inside an invalidation. */
+    /**
+     * Removes the host's content and this store's provenance in the affected scope; the fence calls it inside an
+     * invalidation. A connection's or an owner's purge removes their charge records too. One source's purge, which its
+     * expiry and every replacement of its copy run, leaves the source's record: the record outlives the copy until its
+     * period ends, and `exclude` and a provider's `gone` or skip remove it themselves.
+     */
     purgeSources(tx: StorageAdapter, scope: SourceOwnerScope, affected: SourceInvalidation): Promise<void>;
     /**
      * Applies a host control: completes any earlier barrier, then blocks the owner, moves the connection, records a
@@ -522,8 +598,9 @@ export declare class SqlAccountSourceSyncStore<Prepared = unknown> {
     private exclusionsChanged;
     /**
      * Removes one source and every result derived from it, and keeps a content-free exclusion so later syncs skip it.
-     * The connection moves to a new generation and its open cycle is dropped. Its committed cursor is kept, and the next
-     * cycle is a reconcile: a fresh bounded scan, then history replayed from that cursor.
+     * The source's charge record goes in the same transaction as the exclusion. The connection moves to a new generation
+     * and its open cycle is dropped. Its committed cursor is kept, and the next cycle is a reconcile: a fresh bounded
+     * scan, then history replayed from that cursor.
      *
      * @throws {SourceSyncFault} `invalid_response` for an empty id or one longer than 512 characters.
      */
@@ -538,13 +615,15 @@ export declare class SqlAccountSourceSyncStore<Prepared = unknown> {
      * Removes retained sources whose expiry has passed, with every result derived from them, also while the connection
      * is paused or the owner's fence is inactive, then expires the owner's derived results. An inactive owner, such as a
      * suspended account or one a control's barrier holds, stays inactive; reads refuse an expired source regardless.
-     * Each source goes in a transaction of its own, so a later failure leaves the removals before it in place.
+     * Each source goes in a transaction of its own, so a later failure leaves the removals before it in place. Last, it
+     * removes up to `limit` of the connection's charge records whose indexing period has ended by the store's clock.
      *
-     * @param limit - At most this many sources, an integer from 1 to 1,000.
+     * @param limit - At most this many sources, and this many ended charge records, an integer from 1 to 1,000.
      * @returns How many sources were removed.
-     * @throws {Error} `invalid_sync_batch` for another limit, and the failure itself when a removal or the results'
-     *   expiry fails: once a source was removed, a `SourceSyncExpiryError` with the failure's message, the failure as its
-     *   `cause` and the removals made before it in `partial`, counted in `removed` and named in `sourceIds`.
+     * @throws {Error} `invalid_sync_batch` for another limit, and the failure itself when a removal, the results' expiry
+     *   or the removal of ended charge records fails: once a source was removed, a `SourceSyncExpiryError` with the
+     *   failure's message, the failure as its `cause` and the removals made before it in `partial`, counted in `removed`
+     *   and named in `sourceIds`.
      */
     expire(scope: SourceSyncScope, limit?: number): Promise<number>;
     /**
@@ -563,18 +642,21 @@ export declare class SqlAccountSourceSyncStore<Prepared = unknown> {
      * indexing skip that keeps a copy may have shortened. An owner whose removal fails, as when its host purge keeps
      * failing, is counted and left out of the call's later reads, so a call with up to `limit` such owners never holds
      * back another owner's copies. An owner whose derived results then fail to expire is counted too, once; the call
-     * still answers every source it removed, and the other owners' results still expire.
+     * still answers every source it removed, and the other owners' results still expire. Last, it removes up to `limit`
+     * charge records whose indexing period has ended by the store's clock, every owner's or `owner`'s, the earliest end
+     * first; a failure there counts once, after every copy the call could remove has gone.
      *
-     * @param limit - At most this many sources, an integer from 1 to 1,000.
+     * @param limit - At most this many sources, and this many ended charge records, an integer from 1 to 1,000.
      * @param owner - The owner whose sources alone are swept, or null for every owner.
-     * @returns The sources removed, and the owners whose removal or whose derived results' expiry failed.
+     * @returns The sources removed, and the owners whose removal or whose derived results' expiry failed, with one more
+     *   when the removal of ended charge records failed.
      * @throws {Error} `invalid_sync_batch` for another limit.
      */
     sweepExpired(limit?: number, owner?: SourceOwnerScope | null): Promise<SourceSyncSweep>;
     /**
      * Removes a stopped owner's rows from the store in one transaction: every connection of the owner, with its work
-     * rows, retained-source provenance and exclusions, once each connection is disconnected with no barrier, lease, work
-     * or retained source. `remove` runs first in the same transaction, after the owner fence's row lock and the
+     * rows, retained-source provenance, exclusions and charge records, once each connection is disconnected with no
+     * barrier, lease, work or retained source. `remove` runs first in the same transaction, after the owner fence's row lock and the
      * connections' row locks, for a lifecycle's own rows; `SourceRevocations.removeOwner` passes its own. The core
      * fence's owner row and its deletion records stay: they hold no content, keep the owner's epoch ahead of any old
      * handle, and a restore replays the deletion from them.

package/dist/sync/SqlAccountSourceSyncStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SqlAccountSourceSyncStore.d.ts","sourceRoot":"","sources":["../../src/sync/SqlAccountSourceSyncStore.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EACL,wBAAwB,EACxB,KAAK,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,KAAK,gBAAgB,EACxE,KAAK,gBAAgB,EAAE,KAAK,kBAAkB,EAAE,KAAK,iBAAiB,EACvE,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EACV,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,iBAAiB,EACtF,oBAAoB,EAAE,oBAAoB,EAAE,cAAc,EAAE,cAAc,EAC1E,kBAAkB,EAAyB,2BAA2B,EAAE,oBAAoB,EAC5F,yBAAyB,EAAE,oBAAoB,EAA+C,qBAAqB,EAEpH,MAAM,YAAY,CAAC;AAOpB,OAAO,KAAK,EAAE,0BAA0B,EAA4B,MAAM,uBAAuB,CAAC;AAElG;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,QAAQ,CAAC,QAAQ,EAAE,SAAS,2BAA2B,EAAE,CAAC;IAC1D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AACD,0GAA0G;AAC1G,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,0BAA0B,EAAE,MAAM,CAAC;IAC5C,QAAQ,CAAC,+BAA+B,EAAE,MAAM,CAAC;IACjD,QAAQ,CAAC,2BAA2B,EAAE,MAAM,CAAC;CAC9C;AACD;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB,CAAC,QAAQ;IACjD;;;OAGG;IACH,MAAM,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACtE,mKAAmK;IACnK,SAAS,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACpF,4GAA4G;IAC5G,KAAK,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,gBAAgB,EAC5E,QAAQ,EAAE,kBAAkB,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnE;;;;OAIG;IACH,aAAa,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7F,2FAA2F;IAC3F,KAAK,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChG,yEAAyE;IACzE,YAAY,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,gBAAgB,EAAE,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjG,+GAA+G;IAC/G,MAAM,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtF;;;;;OAKG;IACH,OAAO,CAAC,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,gBAAgB,EAC/E,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD;AACD,2DAA2D;AAC3D,MAAM,WAAW,sBAAsB,CAAC,QAAQ;IAC9C,qHAAqH;IACrH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,4HAA4H;IAC5H,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;IAC9B,iCAAiC;IACjC,QAAQ,CAAC,QAAQ,EAAE,yBAAyB,CAAC,QAAQ,CAAC,CAAC;CACxD;AACD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;CACjC;AACD;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,oBAAoB,EAAE;IAC5D,IAAI,EAAE,iBAAiB,GAAG,aAAa,GAAG,OAAO,GAAG,QAAQ,GAAG,aAAa,GACxE,gBAAgB,GAAG,cAAc,GAAG,YAAY,GAAG,YAAY,CAAC;CACrE,CAAC,CAAC;AACH;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,CAAC;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AACD;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACjD,QAAQ,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC3C;;;OAGG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;CACzC;AACD;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,yBAAyB,CAAC;CACjD;AACD;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AACD;;;;;GAKG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,CAAC;IAC/G;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,GAAE,SAAS,MAAM,EAAO;CAK/E;AAsHD;;;;;;;;;;;;GAYG;AACH,qBAAa,yBAAyB,CAAC,QAAQ,GAAG,OAAO;IAc3C,OAAO,CAAC,QAAQ,CAAC,EAAE;IAAkB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAbzE,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAsC;IACxD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,wBAAwB,CAAC;IACzC;;;;;OAKG;gBAC0B,EAAE,EAAE,cAAc,EAAmB,OAAO,EAAE,sBAAsB,CAAC,QAAQ,CAAC;IAM3G,OAAO,CAAC,GAAG;IAGX,OAAO,CAAC,OAAO;YAUD,GAAG;YAKH,IAAI;YAQJ,UAAU;YAIV,QAAQ;IAQtB;;;;;;OAMG;IACG,MAAM,CAAC,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAY7E,wFAAwF;IAClF,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAM1E,+EAA+E;IACzE,MAAM,CAAC,KAAK,GAAE,eAAe,GAAG,IAAW,EAAE,KAAK,SAAM,GAAG,OAAO,CAAC,SAAS,eAAe,EAAE,CAAC;IACpG;;;;;OAKG;IACG,GAAG,CAAC,KAAK,SAAM,GAAG,OAAO,CAAC,SAAS,eAAe,EAAE,CAAC;IAO3D;;;;;;;OAOG;IACG,KAAK,CAAC,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;YAwBnF,OAAO;YAUP,UAAU;IAMxB;;;;OAIG;IACG,KAAK,CAAC,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAMlE;;;;;;;;OAQG;IACG,SAAS,CAAC,CAAC,EAAE,gBAAgB,EAAE,KAAK,EAAE,IAAI,CAAC,oBAAoB,EAAE,MAAM,GAAG,YAAY,CAAC,GAAG;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,EACrJ,qBAAqB,UAAQ,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IActE;;;;;;;;;;OAUG;IACG,IAAI,CAAC,CAAC,EAAE,gBAAgB,EAAE,QAAQ,EAAE,oBAAoB,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;YA4C7G,OAAO;IAKrB;;;;;;;;;;;;;OAaG;IACG,QAAQ,CAAC,CAAC,EAAE,gBAAgB,EAAE,EAAE,GAAE,MAAM,GAAG,IAAW,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAsD7F;;;;;;;;;;OAUG;IACG,gBAAgB,CAAC,CAAC,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,0BAA0B,GAAG,IAAI,CAAC;IA8B7G;;;;;;;OAOG;IACG,cAAc,CAAC,CAAC,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAC7E,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBnE;;;;OAIG;IACG,YAAY,CAAC,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,qBAAqB,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;YAW7F,WAAW;IAUzB,OAAO,CAAC,UAAU;YAkCJ,YAAY;IAK1B,mIAAmI;YACrH,aAAa;IAK3B,0FAA0F;IACpF,SAAS,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,wBAAwB,EAAE,CAAC;IAGrF,oEAAoE;IAC9D,UAAU,CAAC,KAAK,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAItE,OAAO,CAAC,MAAM;IAWd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2DG;IACG,WAAW,CAAC,CAAC,EAAE,gBAAgB,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,oBAAoB,EACvF,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;IAgLnE,gGAAgG;YAClF,KAAK;IAInB;;;;;;;;;;OAUG;YACW,QAAQ;IAoBtB;;;OAGG;YACW,UAAU;YAaV,OAAO;IAMrB;;;;;OAKG;YACW,UAAU;IAcxB,kHAAkH;YACpG,OAAO;IAIrB;;;;;;;OAOG;IACG,QAAQ,CAAC,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAYpE;;;;;OAKG;IACG,MAAM,CAAC,CAAC,EAAE,gBAAgB,EAAE,QAAQ,EAAE,oBAAoB,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAgBlG;;;;;OAKG;IACG,OAAO,CAAC,CAAC,EAAE,gBAAgB,EAAE,KAAK,GAAE,OAAO,CAAC,oBAAoB,EAAE;QAAE,IAAI,EAAE,eAAe,GAAG,aAAa,CAAA;KAAE,CAAC,GAAG,IAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAQnJ;;;;;;OAMG;IACG,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,cAAc,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAG5G;;;;;;;;;;OAUG;IACG,SAAS,CAAC,KAAK,EAAE,eAAe,EACpC,KAAK,EAAE,OAAO,CAAC,oBAAoB,EAAE;QAAE,IAAI,EAAE,YAAY,GAAG,YAAY,CAAA;KAAE,CAAC,EAC3E,KAAK,EAAE,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,EACpE,QAAQ,EAAE,gBAAgB,GAAG,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgCxD;;;;OAIG;IACG,cAAc,CAAC,KAAK,EAAE,gBAAgB,EAC1C,KAAK,EAAE,CAAC,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS,eAAe,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBlG;;;;;;OAMG;IACG,YAAY,CAAC,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,EAC3D,QAAQ,EAAE,CAAC,EAAE,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAWpE;;;;;;OAMG;IACG,SAAS,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAO5F;;;;;OAKG;IACG,WAAW,CAAC,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,gBAAgB,GAAG,OAAO,CAAC,SAAS,qBAAqB,EAAE,CAAC;IAe9G,+HAA+H;IACzH,YAAY,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5G;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,OAAO,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAoB9H;;;;OAIG;YACW,IAAI;YA2CJ,MAAM;IASpB,+FAA+F;IACzF,cAAc,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAyC3D;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAKzB;;;;;;OAMG;IACG,OAAO,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IActE;;;;OAIG;IACG,eAAe,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAa5D;;;;;;;;;;;OAWG;IACG,MAAM,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,SAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAelE;;;;;;OAMG;YACW,YAAY;IAY1B;;;;;;;;;;;;;;OAcG;IACG,YAAY,CAAC,KAAK,SAAM,EAAE,KAAK,GAAE,gBAAgB,GAAG,IAAW,GAAG,OAAO,CAAC,eAAe,CAAC;IAsChG;;;;;;;;;;;OAWG;IACG,WAAW,CAAC,KAAK,EAAE,gBAAgB,EACvC,MAAM,GAAE,CAAC,EAAE,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAoB,GAAG,OAAO,CAAC,OAAO,CAAC;CAqBzF"}
+{"version":3,"file":"SqlAccountSourceSyncStore.d.ts","sourceRoot":"","sources":["../../src/sync/SqlAccountSourceSyncStore.ts"],"names":[],"mappings":"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"}