@zukhruf/snapshot-differential 0.0.0-stage → 0.3.25

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ezzabuzaid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,196 @@
-# Temporary Holding Version
+# @zukhruf/snapshot-differential
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An upstream with no change log, such as the SQLite store of a desktop app, can give only a list of its records. To load only what changed, you compare each new list with the last one. This package does that comparison: it is a snapshot differential (Labio and Garcia-Molina, "Efficient Snapshot Differential Algorithms for Data Warehousing", VLDB 1996), also known as change data capture by diff compare. A record that is not in the new list is not always deleted. A cache holds only part of its records, and an upstream with a time to live drops old records. Thus a deletion policy judges each such key.
+
+The words in these documents have one meaning each. See the glossary in [CONTEXT.md](./CONTEXT.md).
+
+## A diff yields the changes, then the snapshot
+
+Make one `SnapshotDifferential` for each scan. Give it the primary key fields, a function that makes the key of a record, and a deletion policy. Then give `diff` the scan and the snapshot that the last committed scan saved:
+
+```ts
+import {
+  ClosedWorld,
+  SnapshotDifferential,
+} from '@zukhruf/snapshot-differential';
+
+type Contact = { id: string; name: string };
+
+const differential = new SnapshotDifferential<Contact>({
+  name: 'contacts',
+  primaryKey: ['id'],
+  key: (contact) => JSON.stringify([contact.id]),
+  policy: new ClosedWorld(),
+});
+for await (const change of differential.diff(contacts, saved)) {
+  if (change.type === 'upsert') await upsert(change.record);
+  else if (change.type === 'delete') await remove(change.key);
+  else await save(change.state);
+}
+```
+
+- Give `null` as the snapshot for the first scan.
+- The diff yields an upsert for each new or changed record, and nothing for a record that did not change.
+- The diff yields the new snapshot last. Save it only after you applied the changes before it.
+- Equal scans give byte-identical snapshots, in any order of records.
+- A failed read must throw. An empty scan makes every key a vanished key.
+
+## A deletion policy judges each vanished key
+
+A vanished key is a key that the snapshot has and the scan does not list. The diff asks the policy about each one, and the policy gives one verdict:
+
+| Verdict   | Meaning                                                                    | The diff                                       |
+| --------- | -------------------------------------------------------------------------- | ---------------------------------------------- |
+| `deleted` | The upstream deleted the record (the closed-world assumption).             | Yields a delete. The key leaves the snapshot.  |
+| `unknown` | The scan cannot tell (the open-world assumption).                          | Yields nothing. The key stays in the snapshot. |
+| `expired` | The upstream dropped the record for good, with no deletion, as a TTL does. | Yields nothing. The key leaves the snapshot.   |
+
+The package has three policies:
+
+- `ClosedWorld`: the scan lists every record, so each vanished key was deleted.
+- `Retention(horizon)`: the upstream keeps records from the horizon on. A key whose expiry is before the horizon expired. Each other key was deleted. Give the differential the `expiresBy` field, so that the snapshot keeps the expiry of each key.
+- `Coverage(covers)`: the upstream holds only part of its records, as a cache does. A vanished key that `covers` accepts was deleted. Each other key is unknown.
+
+To judge keys in a different way, write a subclass of `DeletionPolicy`:
+
+```ts
+import {
+  DeletionPolicy,
+  type VanishedRecord,
+  type Verdict,
+} from '@zukhruf/snapshot-differential';
+
+// The app keeps a channel's messages only while the channel is open.
+class OpenChannels extends DeletionPolicy {
+  readonly open: ReadonlySet<string>;
+
+  constructor(open: ReadonlySet<string>) {
+    super();
+    this.open = open;
+  }
+
+  override vanished({ key }: VanishedRecord): Verdict {
+    return this.open.has(String(key.channel)) ? 'deleted' : 'unknown';
+  }
+}
+```
+
+## An unknown key stays until a scan can tell
+
+The policy judges an unknown key again at each scan:
+
+- When a later scan covers the key and does not list it, the verdict is `deleted`, and the diff yields a delete.
+- When a later scan lists the record again with the same fingerprint, the diff yields no upsert.
+
+For example, a chat app drops a thread from its cache. Then a reply in that thread is deleted. Then the app loads the thread again. The reply is not in the thread, and the scan covers it, so the diff deletes it.
+
+The snapshot keeps each unknown key. Thus the snapshot grows with the records that the upstream holds no more and that no scan can judge.
+
+## A group with the same fingerprint is not read
+
+When a scan comes from inputs that you can fingerprint cheaply, such as files by their size and time, give `diffGroups` one group for each input:
+
+```ts
+for await (const change of differential.diffGroups(
+  files.map((file) => ({
+    key: file.path,
+    fingerprint: `${file.size}:${file.mtimeMs}`,
+    records: () => parse(file.path),
+  })),
+  saved,
+)) {
+  // …
+}
+```
+
+- A group with the same fingerprint as in the snapshot keeps its records. The diff does not call its `records`.
+- A group with a `null` fingerprint is always read.
+- A record that moves to a different group, with the same fingerprint, gets no upsert.
+- The policy judges the vanished keys of the complete scan, also the keys of groups that are not in the scan.
+
+## A lookback window keeps only what the next scan reads again
+
+Some scans read a window, and the next scan reads only part of it again, such as the days that an upstream can still restate. Give `diff` a `rereads` function. Only the records that it accepts stay in the snapshot. A record outside the window leaves the snapshot, and the diff never deletes it.
+
+```ts
+differential.diff(days, saved, {
+  rereads: (day) => day.date >= settled,
+});
+```
+
+## A scan in parts deletes only at its last part
+
+Some upstreams cannot list all their records in one call: an API that pages slowly and stops a client that reads too much. Give `diff` or `diffGroups` the option `continues: true` for each call that lists one part of the scan, and leave it out for the call that lists the last part:
+
+```ts
+for await (const page of profile.pages(after)) {
+  for await (const change of differential.diff(page.posts, saved, {
+    continues: page.hasNext,
+  })) {
+    // …
+  }
+}
+```
+
+- A part yields an upsert for each new or changed record that it lists. It does not wait for the last part.
+- A part that continues the scan judges no vanished key. Its snapshot keeps every key, and the keys that the open scan listed so far.
+- The last part judges each saved key that no part of the scan listed.
+- In `diffGroups`, a record that leaves a group that a part reads again waits in the snapshot for the last part's judgment.
+- Two parts can list the same key. One part cannot list a key twice.
+- The parts can be in different runs. Save the snapshot after each part, and give it to the next part.
+- The next scan starts with no listed keys.
+
+## When something fails
+
+Each failure is a `TypeError`, and the diff yields no snapshot:
+
+- One call lists one key twice: `Snapshot <name> returned <key> twice in one scan`. In a scan in parts, this applies to each part.
+- `diffGroups` gets one group key twice: `Snapshot <name> returned group <key> twice in one scan`.
+- A record has a value that JSON cannot hold without a change, such as `undefined` or a `Date`.
+- A record has no timestamp in its `expiresBy` field, in the format of `Date#toISOString`.
+- The saved state is not a snapshot that this package wrote.
+- `Retention` gets a horizon that is not a timestamp.
+
+## The same concepts in other systems
+
+| This package             | Other systems                                                                                                                    |
+| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------- |
+| Snapshot differential    | Labio and Garcia-Molina, VLDB 1996; change data capture by diff compare in Kimball and Caserta, _The Data Warehouse ETL Toolkit_ |
+| `DeletionPolicy`         | The Strategy pattern of Gamma et al., _Design Patterns_, which also names it Policy                                              |
+| `deleted`, `ClosedWorld` | The closed-world assumption of Reiter, "On Closed World Data Bases" (1978)                                                       |
+| `unknown`, `Coverage`    | The open-world assumption                                                                                                        |
+| `expired`, `Retention`   | Cassandra's TTL; Kafka's `retention.ms`                                                                                          |
+| `rereads`                | The lookback of dbt incremental models; the re-sync window of Fivetran                                                           |
+| `continues`              | The incremental marking of a mark-and-sweep garbage collector: each part marks, and the last part sweeps                         |
+| Groups and fingerprints  | The up-to-date checks of Make and Bazel                                                                                          |
+
+Airbyte has no equivalent. Outside change data capture, it deletes only when it replaces a complete stream, and its state decides what to read again, never what to delete.
+
+## Documentation
+
+- [ADR 0001: A vanished key is judged by a deletion policy](./docs/adr/0001-a-vanished-key-is-judged-by-a-deletion-policy.md)
+- [ADR 0002: A scan can be listed in parts](./docs/adr/0002-a-scan-can-be-listed-in-parts.md)
+- [ADR 0003: The differential is a zukhruf package](./docs/adr/0003-the-differential-is-a-zukhruf-package.md)
+
+## Development
+
+Run the commands from the workspace root.
+
+```sh
+npx nx run snapshot-differential:test        # builds, then runs the tests in dist/
+npx nx run snapshot-differential:typecheck   # formats, lints, then type checks
+```
+
+```
+src/
+  snapshot-differential.ts   SnapshotDifferential: diff, diffGroups, and the judgment of vanished keys
+  snapshot-state.ts          the saved snapshot and its guards
+  deletion-policy.ts         DeletionPolicy, VanishedRecord, Verdict
+  closed-world.ts            ClosedWorld
+  retention.ts               Retention
+  coverage.ts                Coverage
+  fingerprint.ts             fingerprints over canonical JSON
+  timestamp.ts               the timestamp check
+  index.ts                   the public exports
+  snapshot-differential.test.ts   the tests
+```

package/dist/closed-world.d.ts

@@ -0,0 +1,5 @@
+import { DeletionPolicy, type Verdict } from './deletion-policy.ts';
+export declare class ClosedWorld extends DeletionPolicy {
+    vanished(): Verdict;
+}
+//# sourceMappingURL=closed-world.d.ts.map

package/dist/closed-world.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closed-world.d.ts","sourceRoot":"","sources":["../src/closed-world.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAGpE,qBAAa,WAAY,SAAQ,cAAc;IACpC,QAAQ,IAAI,OAAO;CAG7B"}

package/dist/closed-world.js

@@ -0,0 +1,8 @@
+import { DeletionPolicy } from "./deletion-policy.js";
+// A scan that lists every record: a key it does not list was deleted.
+export class ClosedWorld extends DeletionPolicy {
+    vanished() {
+        return 'deleted';
+    }
+}
+//# sourceMappingURL=closed-world.js.map

package/dist/closed-world.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"closed-world.js","sourceRoot":"","sources":["../src/closed-world.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAgB,MAAM,sBAAsB,CAAC;AAEpE,sEAAsE;AACtE,MAAM,OAAO,WAAY,SAAQ,cAAc;IACpC,QAAQ;QACf,OAAO,SAAS,CAAC;IACnB,CAAC;CACF"}

package/dist/coverage.d.ts

@@ -0,0 +1,7 @@
+import { DeletionPolicy, type VanishedRecord, type Verdict } from './deletion-policy.ts';
+export declare class Coverage extends DeletionPolicy {
+    #private;
+    constructor(covers: (record: VanishedRecord) => boolean);
+    vanished(record: VanishedRecord): Verdict;
+}
+//# sourceMappingURL=coverage.d.ts.map

package/dist/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,KAAK,cAAc,EACnB,KAAK,OAAO,EACb,MAAM,sBAAsB,CAAC;AAK9B,qBAAa,QAAS,SAAQ,cAAc;;gBAG9B,MAAM,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,OAAO;IAK9C,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO;CAGnD"}

package/dist/coverage.js

@@ -0,0 +1,15 @@
+import { DeletionPolicy, } from "./deletion-policy.js";
+// An upstream that holds only part of its records and says which part, as a
+// cache does: a vanished key the scan covers was deleted; one it does not
+// cover is unknown until a later scan covers it or lists it again.
+export class Coverage extends DeletionPolicy {
+    #covers;
+    constructor(covers) {
+        super();
+        this.#covers = covers;
+    }
+    vanished(record) {
+        return this.#covers(record) ? 'deleted' : 'unknown';
+    }
+}
+//# sourceMappingURL=coverage.js.map

package/dist/coverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.js","sourceRoot":"","sources":["../src/coverage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,GAGf,MAAM,sBAAsB,CAAC;AAE9B,4EAA4E;AAC5E,0EAA0E;AAC1E,mEAAmE;AACnE,MAAM,OAAO,QAAS,SAAQ,cAAc;IACjC,OAAO,CAAsC;IAEtD,YAAY,MAA2C;QACrD,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACxB,CAAC;IAEQ,QAAQ,CAAC,MAAsB;QACtC,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC;IACtD,CAAC;CACF"}

package/dist/deletion-policy.d.ts

@@ -0,0 +1,10 @@
+export type KeyValue = string | number | boolean;
+export type VanishedRecord = {
+    readonly key: Readonly<Record<string, KeyValue>>;
+    readonly expiresBy?: string;
+};
+export type Verdict = 'deleted' | 'unknown' | 'expired';
+export declare abstract class DeletionPolicy {
+    abstract vanished(record: VanishedRecord): Verdict;
+}
+//# sourceMappingURL=deletion-policy.d.ts.map

package/dist/deletion-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deletion-policy.d.ts","sourceRoot":"","sources":["../src/deletion-policy.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAGjD,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IAEjD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAOF,MAAM,MAAM,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAGxD,8BAAsB,cAAc;IAClC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO;CACnD"}

package/dist/deletion-policy.js

@@ -0,0 +1,4 @@
+// The Strategy a snapshot differential asks about each vanished key.
+export class DeletionPolicy {
+}
+//# sourceMappingURL=deletion-policy.js.map

package/dist/deletion-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deletion-policy.js","sourceRoot":"","sources":["../src/deletion-policy.ts"],"names":[],"mappings":"AAgBA,qEAAqE;AACrE,MAAM,OAAgB,cAAc;CAEnC"}

package/dist/fingerprint.d.ts

@@ -0,0 +1,3 @@
+export declare function fingerprintOf(name: string, record: Record<string, unknown>): string;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=fingerprint.d.ts.map

package/dist/fingerprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprint.d.ts","sourceRoot":"","sources":["../src/fingerprint.ts"],"names":[],"mappings":"AAIA,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAOR;AAaD,wBAAgB,aAAa,CAC3B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAOlC"}

package/dist/fingerprint.js

@@ -0,0 +1,27 @@
+import { createHash } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+// A record's SHA-256 over its canonical JSON, so equal records hash equally.
+export function fingerprintOf(name, record) {
+    const serialized = JSON.parse(JSON.stringify(record));
+    if (!isDeepStrictEqual(serialized, record))
+        throw new TypeError(`Snapshot ${name} records must be losslessly JSON serializable to diff snapshots`);
+    return createHash('sha256').update(canonical(serialized)).digest('base64url');
+}
+// JSON with object keys sorted at every depth.
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(',')}]`;
+    if (isPlainObject(value))
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+            .join(',')}}`;
+    return JSON.stringify(value);
+}
+export function isPlainObject(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        Object.getPrototypeOf(value) === Object.prototype);
+}
+//# sourceMappingURL=fingerprint.js.map

package/dist/fingerprint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprint.js","sourceRoot":"","sources":["../src/fingerprint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,6EAA6E;AAC7E,MAAM,UAAU,aAAa,CAC3B,IAAY,EACZ,MAA+B;IAE/B,MAAM,UAAU,GAAY,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/D,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,MAAM,CAAC;QACxC,MAAM,IAAI,SAAS,CACjB,YAAY,IAAI,iEAAiE,CAClF,CAAC;IACJ,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;AAChF,CAAC;AAED,+CAA+C;AAC/C,SAAS,SAAS,CAAC,KAAc;IAC/B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;IACvE,IAAI,aAAa,CAAC,KAAK,CAAC;QACtB,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;aAC1B,IAAI,EAAE;aACN,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;aAC/D,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;IAClB,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC;AAED,MAAM,UAAU,aAAa,CAC3B,KAAc;IAEd,OAAO,CACL,KAAK,KAAK,IAAI;QACd,OAAO,KAAK,KAAK,QAAQ;QACzB,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACrB,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,SAAS,CAClD,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { ClosedWorld } from './closed-world.ts';
+export { Coverage } from './coverage.ts';
+export { DeletionPolicy, type KeyValue, type VanishedRecord, type Verdict, } from './deletion-policy.ts';
+export { Retention } from './retention.ts';
+export { type SnapshotChange, SnapshotDifferential, type SnapshotDifferentialOptions, type SnapshotGroup, } from './snapshot-differential.ts';
+export type { GroupedSnapshotState, SnapshotState } from './snapshot-state.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EACL,cAAc,EACd,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,OAAO,GACb,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EACL,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,2BAA2B,EAChC,KAAK,aAAa,GACnB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { ClosedWorld } from "./closed-world.js";
+export { Coverage } from "./coverage.js";
+export { DeletionPolicy, } from "./deletion-policy.js";
+export { Retention } from "./retention.js";
+export { SnapshotDifferential, } from "./snapshot-differential.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EACL,cAAc,GAIf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAEL,oBAAoB,GAGrB,MAAM,4BAA4B,CAAC"}

package/dist/retention.d.ts

@@ -0,0 +1,7 @@
+import { DeletionPolicy, type VanishedRecord, type Verdict } from './deletion-policy.ts';
+export declare class Retention extends DeletionPolicy {
+    readonly horizon: string;
+    constructor(horizon: string);
+    vanished({ expiresBy }: VanishedRecord): Verdict;
+}
+//# sourceMappingURL=retention.d.ts.map

package/dist/retention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retention.d.ts","sourceRoot":"","sources":["../src/retention.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,KAAK,cAAc,EACnB,KAAK,OAAO,EACb,MAAM,sBAAsB,CAAC;AAM9B,qBAAa,SAAU,SAAQ,cAAc;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM;IAOlB,QAAQ,CAAC,EAAE,SAAS,EAAE,EAAE,cAAc,GAAG,OAAO;CAK1D"}

package/dist/retention.js

@@ -0,0 +1,20 @@
+import { DeletionPolicy, } from "./deletion-policy.js";
+import { isTimestamp } from "./timestamp.js";
+// An upstream that keeps records from a horizon on and drops older ones
+// without a deletion, as a time to live does: a key that vanished with an
+// expiry before the horizon expired, any other was deleted.
+export class Retention extends DeletionPolicy {
+    horizon;
+    constructor(horizon) {
+        super();
+        if (!isTimestamp(horizon))
+            throw new TypeError(`Retention horizon ${horizon} is not a timestamp`);
+        this.horizon = horizon;
+    }
+    vanished({ expiresBy }) {
+        return expiresBy === undefined || expiresBy >= this.horizon
+            ? 'deleted'
+            : 'expired';
+    }
+}
+//# sourceMappingURL=retention.js.map

package/dist/retention.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retention.js","sourceRoot":"","sources":["../src/retention.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,GAGf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,wEAAwE;AACxE,0EAA0E;AAC1E,4DAA4D;AAC5D,MAAM,OAAO,SAAU,SAAQ,cAAc;IAClC,OAAO,CAAS;IAEzB,YAAY,OAAe;QACzB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;YACvB,MAAM,IAAI,SAAS,CAAC,qBAAqB,OAAO,qBAAqB,CAAC,CAAC;QACzE,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAEQ,QAAQ,CAAC,EAAE,SAAS,EAAkB;QAC7C,OAAO,SAAS,KAAK,SAAS,IAAI,SAAS,IAAI,IAAI,CAAC,OAAO;YACzD,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;CACF"}

package/dist/snapshot-differential.d.ts

@@ -0,0 +1,40 @@
+import type { DeletionPolicy, KeyValue } from './deletion-policy.ts';
+import { type GroupedSnapshotState, type SnapshotState } from './snapshot-state.ts';
+export type SnapshotDifferentialOptions<Data> = {
+    readonly name: string;
+    readonly primaryKey: readonly string[];
+    readonly key: (record: Data) => string;
+    readonly expiresBy?: string | undefined;
+    readonly policy: DeletionPolicy;
+};
+export type SnapshotGroup<Data> = {
+    readonly key: string;
+    readonly fingerprint: string | null;
+    records(): AsyncIterable<Data> | Iterable<Data>;
+};
+export type SnapshotChange<Data, State> = {
+    readonly type: 'upsert';
+    readonly record: Data;
+} | {
+    readonly type: 'delete';
+    readonly key: Readonly<Record<string, KeyValue>>;
+} | {
+    readonly type: 'state';
+    readonly state: State;
+};
+export declare class SnapshotDifferential<Data extends Record<string, unknown>> {
+    #private;
+    readonly name: string;
+    readonly primaryKey: readonly string[];
+    readonly expiresBy: string | undefined;
+    readonly policy: DeletionPolicy;
+    constructor({ name, primaryKey, key, expiresBy, policy, }: SnapshotDifferentialOptions<Data>);
+    diff(records: AsyncIterable<Data> | Iterable<Data>, state: unknown, { rereads, continues, }?: {
+        readonly rereads?: (record: Data) => boolean;
+        readonly continues?: boolean;
+    }): AsyncGenerator<SnapshotChange<Data, SnapshotState>>;
+    diffGroups(groups: AsyncIterable<SnapshotGroup<Data>> | Iterable<SnapshotGroup<Data>>, state: unknown, { continues }?: {
+        readonly continues?: boolean;
+    }): AsyncGenerator<SnapshotChange<Data, GroupedSnapshotState>>;
+}
+//# sourceMappingURL=snapshot-differential.d.ts.map

package/dist/snapshot-differential.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-differential.d.ts","sourceRoot":"","sources":["../src/snapshot-differential.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,QAAQ,EAET,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,KAAK,oBAAoB,EAGzB,KAAK,aAAa,EAKnB,MAAM,qBAAqB,CAAC;AAG7B,MAAM,MAAM,2BAA2B,CAAC,IAAI,IAAI;IAE9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAEvC,QAAQ,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,IAAI,KAAK,MAAM,CAAC;IAGvC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;CACjC,CAAC;AAIF,MAAM,MAAM,aAAa,CAAC,IAAI,IAAI;IAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,OAAO,IAAI,aAAa,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;CACjD,CAAC;AAEF,MAAM,MAAM,cAAc,CAAC,IAAI,EAAE,KAAK,IAClC;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,GAClD;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;CAClD,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAOtD,qBAAa,oBAAoB,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;IACpE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;gBAGpB,EACV,IAAI,EACJ,UAAU,EACV,GAAG,EACH,SAAS,EACT,MAAM,GACP,EAAE,2BAA2B,CAAC,IAAI,CAAC;IAe7B,IAAI,CACT,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,EAC7C,KAAK,EAAE,OAAO,EACd,EACE,OAAO,EACP,SAAiB,GAClB,GAAE;QACD,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,KAAK,OAAO,CAAC;QAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;KACzB,GACL,cAAc,CAAC,cAAc,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;IAmC/C,UAAU,CACf,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,EAC1E,KAAK,EAAE,OAAO,EACd,EAAE,SAAiB,EAAE,GAAE;QAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAO,GAC3D,cAAc,CAAC,cAAc,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC;CAiJ9D"}

package/dist/snapshot-differential.js

@@ -0,0 +1,184 @@
+import { fingerprintOf } from "./fingerprint.js";
+import { fingerprintIn, readGroups, readSnapshot, sorted, } from "./snapshot-state.js";
+import { isTimestamp } from "./timestamp.js";
+// A snapshot differential (Labio and Garcia-Molina, VLDB 1996): change data
+// capture for an upstream with no change log. It compares one complete scan
+// with the previous snapshot and yields each new or changed record, a delete
+// for each key the policy judges deleted, and the new snapshot last. An empty
+// scan judges every key, so a failed read must throw, never yield nothing.
+export class SnapshotDifferential {
+    name;
+    primaryKey;
+    expiresBy;
+    policy;
+    #key;
+    constructor({ name, primaryKey, key, expiresBy, policy, }) {
+        this.name = name;
+        this.primaryKey = primaryKey;
+        this.#key = key;
+        this.expiresBy = expiresBy;
+        this.policy = policy;
+    }
+    // rereads names the lookback window: a scan the next one repeats only in
+    // part, such as days an upstream may still restate. Only records the next
+    // scan reads again stay in the snapshot; one left out is never deleted.
+    // continues makes this call one part of a scan that later calls go on
+    // with, for an upstream that cannot list everything at once: the part
+    // judges no vanished key and saves the keys it listed, and the part that
+    // ends the scan judges every saved key that no part listed.
+    async *diff(records, state, { rereads, continues = false, } = {}) {
+        const { snapshot: previous, listed } = readSnapshot(this.name, state);
+        const seen = new Set();
+        const current = new Map();
+        for await (const record of records) {
+            const key = this.#claim(seen, record);
+            const fingerprint = fingerprintOf(this.name, record);
+            if (rereads?.(record) ?? true)
+                current.set(key, this.#entry(record, fingerprint));
+            if (fingerprintIn(previous.get(key)) !== fingerprint)
+                yield { type: 'upsert', record };
+        }
+        const listedSoFar = new Set([...listed, ...seen]);
+        for (const [key, entry] of previous)
+            if (!seen.has(key) && (continues || listed.has(key)))
+                current.set(key, entry);
+        if (continues) {
+            yield {
+                type: 'state',
+                state: {
+                    snapshot: sorted(current),
+                    listed: [...listedSoFar].sort(),
+                },
+            };
+            return;
+        }
+        yield* this.#judge(previous, listedSoFar, current);
+        yield { type: 'state', state: { snapshot: sorted(current) } };
+    }
+    // diff for a scan whose records come from inputs the source fingerprints
+    // cheaply. A group whose fingerprint matches the last committed scan keeps
+    // its records without reading them; every other group is read and diffed
+    // record by record. Vanished keys are judged over the complete scan.
+    // continues makes this call one part of a scan in parts, as for diff.
+    async *diffGroups(groups, state, { continues = false } = {}) {
+        const previous = readGroups(this.name, state);
+        // Every saved entry by key, so a record that moves between groups or
+        // comes back from unknown is compared with its previous fingerprint.
+        const saved = new Map([
+            ...[...previous.groups.values()].flatMap(({ snapshot }) => Object.entries(snapshot)),
+            ...previous.unknown,
+        ]);
+        const seen = new Set();
+        const current = new Map();
+        for await (const group of groups) {
+            if (current.has(group.key))
+                throw new TypeError(`Snapshot ${this.name} returned group ${group.key} twice in one scan`);
+            const before = previous.groups.get(group.key);
+            if (group.fingerprint !== null &&
+                before?.fingerprint === group.fingerprint) {
+                for (const key of Object.keys(before.snapshot))
+                    this.#claimKey(seen, key);
+                current.set(group.key, before);
+                continue;
+            }
+            const snapshot = new Map();
+            for await (const record of group.records()) {
+                const key = this.#claim(seen, record);
+                const fingerprint = fingerprintOf(this.name, record);
+                snapshot.set(key, this.#entry(record, fingerprint));
+                if (fingerprintIn(saved.get(key)) !== fingerprint)
+                    yield { type: 'upsert', record };
+            }
+            current.set(group.key, {
+                fingerprint: group.fingerprint,
+                snapshot: sorted(snapshot),
+            });
+        }
+        const listedSoFar = new Set([...previous.listed, ...current.keys()]);
+        // A group this call did not list keeps what the scan saw of it while the
+        // scan goes on, or when an earlier part listed it; a record that moved
+        // into a group this call listed leaves it.
+        for (const [key, before] of previous.groups) {
+            if (current.has(key) || !(continues || previous.listed.has(key)))
+                continue;
+            const snapshot = Object.entries(before.snapshot).filter(([recordKey]) => !seen.has(recordKey));
+            for (const [recordKey] of snapshot)
+                seen.add(recordKey);
+            current.set(key, {
+                fingerprint: before.fingerprint,
+                snapshot: Object.fromEntries(snapshot),
+            });
+        }
+        const unknown = new Map();
+        if (continues) {
+            // A key no group holds any more, such as one that vanished from a
+            // group this part read again, waits for the last part's judgment.
+            const grouped = new Set([...current.values()].flatMap(({ snapshot }) => Object.keys(snapshot)));
+            for (const [key, entry] of saved)
+                if (!seen.has(key) && !grouped.has(key))
+                    unknown.set(key, entry);
+        }
+        else {
+            yield* this.#judge(saved, seen, unknown);
+        }
+        yield {
+            type: 'state',
+            state: {
+                groups: sorted(current),
+                ...(unknown.size === 0 ? {} : { unknown: sorted(unknown) }),
+                ...(continues ? { listed: [...listedSoFar].sort() } : {}),
+            },
+        };
+    }
+    // Asks the policy about every saved key the scan did not list. A deleted
+    // one yields a delete, an unknown one stays in kept, an expired one leaves.
+    *#judge(saved, seen, kept) {
+        for (const [key, entry] of saved) {
+            if (seen.has(key))
+                continue;
+            const record = typeof entry === 'string'
+                ? { key: this.#keyObject(key) }
+                : { key: this.#keyObject(key), expiresBy: entry[1] };
+            const verdict = this.policy.vanished(record);
+            if (verdict === 'deleted')
+                yield { type: 'delete', key: record.key };
+            else if (verdict === 'unknown')
+                kept.set(key, entry);
+        }
+    }
+    #claim(seen, record) {
+        const key = this.#key(record);
+        this.#claimKey(seen, key);
+        return key;
+    }
+    #claimKey(seen, key) {
+        if (seen.has(key))
+            throw new TypeError(`Snapshot ${this.name} returned ${this.#keyText(key)} twice in one scan`);
+        seen.add(key);
+    }
+    #entry(record, fingerprint) {
+        if (this.expiresBy === undefined)
+            return fingerprint;
+        const expiresBy = record[this.expiresBy];
+        if (!isTimestamp(expiresBy))
+            throw new TypeError(`Snapshot ${this.name} records must carry ${this.expiresBy} as a timestamp to expire`);
+        return [fingerprint, expiresBy];
+    }
+    // A key as its primary key fields, from the JSON of its values.
+    #keyObject(key) {
+        const values = JSON.parse(key);
+        return Object.fromEntries(this.primaryKey.map((field, index) => {
+            const value = values[index];
+            if (value === undefined)
+                throw new TypeError(`Snapshot key ${key} does not match ${this.name}'s primary key`);
+            return [field, value];
+        }));
+    }
+    // A key as people read it: each field with its value, a string as it is.
+    #keyText(key) {
+        return Object.entries(this.#keyObject(key))
+            .map(([field, value]) => `${field} ${typeof value === 'string' ? value : JSON.stringify(value)}`)
+            .join(', ');
+    }
+}
+//# sourceMappingURL=snapshot-differential.js.map

package/dist/snapshot-differential.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-differential.js","sourceRoot":"","sources":["../src/snapshot-differential.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAKL,aAAa,EACb,UAAU,EACV,YAAY,EACZ,MAAM,GACP,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AA+B7C,4EAA4E;AAC5E,4EAA4E;AAC5E,6EAA6E;AAC7E,8EAA8E;AAC9E,2EAA2E;AAC3E,MAAM,OAAO,oBAAoB;IACtB,IAAI,CAAS;IACb,UAAU,CAAoB;IAC9B,SAAS,CAAqB;IAC9B,MAAM,CAAiB;IACvB,IAAI,CAA2B;IAExC,YAAY,EACV,IAAI,EACJ,UAAU,EACV,GAAG,EACH,SAAS,EACT,MAAM,GAC4B;QAClC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,yEAAyE;IACzE,0EAA0E;IAC1E,wEAAwE;IACxE,sEAAsE;IACtE,sEAAsE;IACtE,yEAAyE;IACzE,4DAA4D;IAC5D,KAAK,CAAC,CAAC,IAAI,CACT,OAA6C,EAC7C,KAAc,EACd,EACE,OAAO,EACP,SAAS,GAAG,KAAK,MAIf,EAAE;QAEN,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACtE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;QAC/B,MAAM,OAAO,GAAG,IAAI,GAAG,EAAsB,CAAC;QAC9C,IAAI,KAAK,EAAE,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YACnC,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YACtC,MAAM,WAAW,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YACrD,IAAI,OAAO,EAAE,CAAC,MAAM,CAAC,IAAI,IAAI;gBAC3B,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;YACrD,IAAI,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,WAAW;gBAClD,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;QACrC,CAAC;QACD,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;QAClD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,QAAQ;YACjC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAClD,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC5B,IAAI,SAAS,EAAE,CAAC;YACd,MAAM;gBACJ,IAAI,EAAE,OAAO;gBACb,KAAK,EAAE;oBACL,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC;oBACzB,MAAM,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,IAAI,EAAE;iBAChC;aACF,CAAC;YACF,OAAO;QACT,CAAC;QACD,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;QACnD,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;IAChE,CAAC;IAED,yEAAyE;IACzE,2EAA2E;IAC3E,yEAAyE;IACzE,qEAAqE;IACrE,sEAAsE;IACtE,KAAK,CAAC,CAAC,UAAU,CACf,MAA0E,EAC1E,KAAc,EACd,EAAE,SAAS,GAAG,KAAK,KAAuC,EAAE;QAE5D,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC9C,qEAAqE;QACrE,qEAAqE;QACrE,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC;YACpB,GAAG,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CACxD,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CACzB;YACD,GAAG,QAAQ,CAAC,OAAO;SACpB,CAAC,CAAC;QACH,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;QAC/B,MAAM,OAAO,GAAG,IAAI,GAAG,EAAsB,CAAC;QAC9C,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YACjC,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC;gBACxB,MAAM,IAAI,SAAS,CACjB,YAAY,IAAI,CAAC,IAAI,mBAAmB,KAAK,CAAC,GAAG,oBAAoB,CACtE,CAAC;YACJ,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAC9C,IACE,KAAK,CAAC,WAAW,KAAK,IAAI;gBAC1B,MAAM,EAAE,WAAW,KAAK,KAAK,CAAC,WAAW,EACzC,CAAC;gBACD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;oBAC5C,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;gBAC5B,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;gBAC/B,SAAS;YACX,CAAC;YACD,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAsB,CAAC;YAC/C,IAAI,KAAK,EAAE,MAAM,MAAM,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;gBAC3C,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;gBACtC,MAAM,WAAW,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;gBACrD,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;gBACpD,IAAI,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,WAAW;oBAC/C,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;YACrC,CAAC;YACD,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE;gBACrB,WAAW,EAAE,KAAK,CAAC,WAAW;gBAC9B,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC;aAC3B,CAAC,CAAC;QACL,CAAC;QACD,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QACrE,yEAAyE;QACzE,uEAAuE;QACvE,2CAA2C;QAC3C,KAAK,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;YAC5C,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,SAAS,IAAI,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAC9D,SAAS;YACX,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,CACrD,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CACtC,CAAC;YACF,KAAK,MAAM,CAAC,SAAS,CAAC,IAAI,QAAQ;gBAAE,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACxD,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE;gBACf,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC;aACvC,CAAC,CAAC;QACL,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,GAAG,EAAsB,CAAC;QAC9C,IAAI,SAAS,EAAE,CAAC;YACd,kEAAkE;YAClE,kEAAkE;YAClE,MAAM,OAAO,GAAG,IAAI,GAAG,CACrB,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CACvE,CAAC;YACF,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,KAAK;gBAC9B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;oBAAE,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACrE,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QAC3C,CAAC;QACD,MAAM;YACJ,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACL,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC;gBACvB,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC3D,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aAC1D;SACF,CAAC;IACJ,CAAC;IAED,yEAAyE;IACzE,4EAA4E;IAC5E,CAAC,MAAM,CACL,KAAsC,EACtC,IAAyB,EACzB,IAA6B;QAE7B,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,KAAK,EAAE,CAAC;YACjC,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,SAAS;YAC5B,MAAM,MAAM,GACV,OAAO,KAAK,KAAK,QAAQ;gBACvB,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;gBAC/B,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;YACzD,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;YAC7C,IAAI,OAAO,KAAK,SAAS;gBAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC;iBAChE,IAAI,OAAO,KAAK,SAAS;gBAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;IAED,MAAM,CAAC,IAAiB,EAAE,MAAY;QACpC,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC9B,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC1B,OAAO,GAAG,CAAC;IACb,CAAC;IAED,SAAS,CAAC,IAAiB,EAAE,GAAW;QACtC,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;YACf,MAAM,IAAI,SAAS,CACjB,YAAY,IAAI,CAAC,IAAI,aAAa,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,oBAAoB,CACzE,CAAC;QACJ,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,CAAC,MAAY,EAAE,WAAmB;QACtC,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS;YAAE,OAAO,WAAW,CAAC;QACrD,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACzC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;YACzB,MAAM,IAAI,SAAS,CACjB,YAAY,IAAI,CAAC,IAAI,uBAAuB,IAAI,CAAC,SAAS,2BAA2B,CACtF,CAAC;QACJ,OAAO,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;IAClC,CAAC;IAED,gEAAgE;IAChE,UAAU,CAAC,GAAW;QACpB,MAAM,MAAM,GAAe,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC3C,OAAO,MAAM,CAAC,WAAW,CACvB,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YACnC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;YAC5B,IAAI,KAAK,KAAK,SAAS;gBACrB,MAAM,IAAI,SAAS,CACjB,gBAAgB,GAAG,mBAAmB,IAAI,CAAC,IAAI,gBAAgB,CAChE,CAAC;YACJ,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACxB,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,yEAAyE;IACzE,QAAQ,CAAC,GAAW;QAClB,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;aACxC,GAAG,CACF,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CACjB,GAAG,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAC1E;aACA,IAAI,CAAC,IAAI,CAAC,CAAC;IAChB,CAAC;CACF"}

package/dist/snapshot-state.d.ts

@@ -0,0 +1,26 @@
+export type SavedEntry = string | readonly [fingerprint: string, expiresBy: string];
+export type SnapshotState = {
+    readonly snapshot: Readonly<Record<string, SavedEntry>>;
+    readonly listed?: readonly string[];
+};
+export type SavedGroup = {
+    readonly fingerprint: string | null;
+    readonly snapshot: Readonly<Record<string, SavedEntry>>;
+};
+export type GroupedSnapshotState = {
+    readonly groups: Readonly<Record<string, SavedGroup>>;
+    readonly unknown?: Readonly<Record<string, SavedEntry>>;
+    readonly listed?: readonly string[];
+};
+export declare function readSnapshot(name: string, state: unknown): {
+    snapshot: Map<string, SavedEntry>;
+    listed: Set<string>;
+};
+export declare function readGroups(name: string, state: unknown): {
+    groups: Map<string, SavedGroup>;
+    unknown: Map<string, SavedEntry>;
+    listed: Set<string>;
+};
+export declare function sorted<Value>(values: ReadonlyMap<string, Value>): Record<string, Value>;
+export declare function fingerprintIn(entry: SavedEntry | undefined): string | undefined;
+//# sourceMappingURL=snapshot-state.d.ts.map

package/dist/snapshot-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-state.d.ts","sourceRoot":"","sources":["../src/snapshot-state.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,UAAU,GACpB,MAAM,GAAG,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;AAK7D,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;IACxD,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;CACzD,CAAC;AAMF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;IACtD,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;IACxD,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC,CAAC;AAIF,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,GACb;IAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAO5D;AAID,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,GACb;IACD,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAChC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACjC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACrB,CAuBA;AAGD,wBAAgB,MAAM,CAAC,KAAK,EAC1B,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,GACjC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAEvB;AASD,wBAAgB,aAAa,CAC3B,KAAK,EAAE,UAAU,GAAG,SAAS,GAC5B,MAAM,GAAG,SAAS,CAEpB"}

package/dist/snapshot-state.js

@@ -0,0 +1,80 @@
+import { isPlainObject } from "./fingerprint.js";
+// The previous snapshot and the keys the open scan's earlier parts listed,
+// as diff wrote them. null when there is none.
+export function readSnapshot(name, state) {
+    if (state === null)
+        return { snapshot: new Map(), listed: new Set() };
+    if (!isPlainObject(state))
+        throw invalid(name);
+    return {
+        snapshot: entries(name, state.snapshot),
+        listed: listedKeys(name, state.listed),
+    };
+}
+// The previous groups, unknown keys and the groups the open scan's earlier
+// parts listed, as diffGroups wrote them.
+export function readGroups(name, state) {
+    if (state === null)
+        return { groups: new Map(), unknown: new Map(), listed: new Set() };
+    if (!isPlainObject(state) || !isPlainObject(state.groups))
+        throw invalid(name);
+    const groups = new Map();
+    for (const [key, group] of Object.entries(state.groups)) {
+        if (!isPlainObject(group) ||
+            (group.fingerprint !== null && typeof group.fingerprint !== 'string'))
+            throw invalid(name);
+        groups.set(key, {
+            fingerprint: group.fingerprint,
+            snapshot: Object.fromEntries(entries(name, group.snapshot)),
+        });
+    }
+    return {
+        groups,
+        unknown: state.unknown === undefined ? new Map() : entries(name, state.unknown),
+        listed: listedKeys(name, state.listed),
+    };
+}
+// Sorted by key, so equal scans save byte-identical state.
+export function sorted(values) {
+    return Object.fromEntries([...values].sort(([a], [b]) => compareKeys(a, b)));
+}
+// By UTF-16 code unit, not by locale, so the order never varies by machine.
+function compareKeys(a, b) {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+export function fingerprintIn(entry) {
+    return typeof entry === 'string' ? entry : entry?.[0];
+}
+function entries(name, snapshot) {
+    if (!isPlainObject(snapshot))
+        throw invalid(name);
+    const saved = new Map();
+    for (const [key, entry] of Object.entries(snapshot)) {
+        if (!isSavedEntry(entry))
+            throw invalid(name);
+        saved.set(key, entry);
+    }
+    return saved;
+}
+function listedKeys(name, listed) {
+    if (listed === undefined)
+        return new Set();
+    if (!Array.isArray(listed) || !listed.every((key) => typeof key === 'string'))
+        throw invalid(name);
+    return new Set(listed);
+}
+function isSavedEntry(value) {
+    return (typeof value === 'string' ||
+        (Array.isArray(value) &&
+            value.length === 2 &&
+            typeof value[0] === 'string' &&
+            typeof value[1] === 'string'));
+}
+function invalid(name) {
+    return new TypeError(`Snapshot ${name} state is not a saved snapshot`);
+}
+//# sourceMappingURL=snapshot-state.js.map

package/dist/snapshot-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-state.js","sourceRoot":"","sources":["../src/snapshot-state.ts"],"names":[],"mappings":"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"}

package/dist/timestamp.d.ts

@@ -0,0 +1,2 @@
+export declare function isTimestamp(value: unknown): value is string;
+//# sourceMappingURL=timestamp.d.ts.map

package/dist/timestamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.d.ts","sourceRoot":"","sources":["../src/timestamp.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAM3D"}

package/dist/timestamp.js

@@ -0,0 +1,8 @@
+// A UTC timestamp exactly as Date#toISOString writes it, so timestamps order
+// as text.
+export function isTimestamp(value) {
+    return (typeof value === 'string' &&
+        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) &&
+        new Date(value).toISOString() === value);
+}
+//# sourceMappingURL=timestamp.js.map

package/dist/timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.js","sourceRoot":"","sources":["../src/timestamp.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,WAAW;AACX,MAAM,UAAU,WAAW,CAAC,KAAc;IACxC,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,+CAA+C,CAAC,IAAI,CAAC,KAAK,CAAC;QAC3D,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,KAAK,KAAK,CACxC,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@zukhruf/snapshot-differential",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.25",
+  "description": "Change data capture for an upstream with no change log: compare each scan with the last snapshot, get the new and changed records, and let a deletion policy judge each key that the scan no longer lists.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JanuaryLabs/zukhruf",
+    "directory": "packages/snapshot-differential"
+  },
+  "bugs": {
+    "url": "https://github.com/JanuaryLabs/zukhruf/issues"
+  },
+  "homepage": "https://github.com/JanuaryLabs/zukhruf/tree/main/packages/snapshot-differential#readme",
+  "keywords": [
+    "snapshot-differential",
+    "change-data-capture",
+    "cdc",
+    "diff",
+    "snapshot",
+    "incremental",
+    "etl",
+    "elt"
+  ],
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@zukhruf/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/spec/**",
+    "!**/*.tsbuildinfo",
+    "!**/*.test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}