@atproto/repo 0.1.0 → 0.3.0

package/dist/mst/mst.d.ts

@@ -1,7 +1,6 @@
 import z from 'zod';
 import { CID } from 'multiformats';
 import { ReadableBlockstore } from '../storage';
-import { DataStore } from '../types';
 import { BlockWriter } from '@ipld/car/api';
 import BlockMap from '../block-map';
 import CidSet from '../cid-set';
@@ -13,32 +12,32 @@ declare const nodeData: z.ZodObject<{
         v: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
         t: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
     }, "strip", z.ZodTypeAny, {
+        t: CID | null;
         p: number;
         k: Uint8Array;
         v: CID;
-        t: CID | null;
     }, {
-        v?: any;
-        t?: any;
         p: number;
         k: Uint8Array;
+        v?: any;
+        t?: any;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     l: CID | null;
     e: {
+        t: CID | null;
         p: number;
         k: Uint8Array;
         v: CID;
-        t: CID | null;
     }[];
 }, {
-    l?: any;
     e: {
-        v?: any;
-        t?: any;
         p: number;
         k: Uint8Array;
+        v?: any;
+        t?: any;
     }[];
+    l?: any;
 }>;
 export declare type NodeData = z.infer<typeof nodeData>;
 export declare const nodeDataDef: {
@@ -51,39 +50,39 @@ export declare const nodeDataDef: {
             v: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
             t: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
         }, "strip", z.ZodTypeAny, {
+            t: CID | null;
             p: number;
             k: Uint8Array;
             v: CID;
-            t: CID | null;
         }, {
-            v?: any;
-            t?: any;
             p: number;
             k: Uint8Array;
+            v?: any;
+            t?: any;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
         l: CID | null;
         e: {
+            t: CID | null;
             p: number;
             k: Uint8Array;
             v: CID;
-            t: CID | null;
         }[];
     }, {
-        l?: any;
         e: {
-            v?: any;
-            t?: any;
             p: number;
             k: Uint8Array;
+            v?: any;
+            t?: any;
         }[];
+        l?: any;
     }>;
 };
 export declare type NodeEntry = MST | Leaf;
 export declare type MstOpts = {
     layer: number;
 };
-export declare class MST implements DataStore {
+export declare class MST {
     storage: ReadableBlockstore;
     entries: NodeEntry[] | null;
     layer: number | null;
@@ -96,6 +95,10 @@ export declare class MST implements DataStore {
     newTree(entries: NodeEntry[]): Promise<MST>;
     getEntries(): Promise<NodeEntry[]>;
     getPointer(): Promise<CID>;
+    serialize(): Promise<{
+        cid: CID;
+        bytes: Uint8Array;
+    }>;
     getLayer(): Promise<number>;
     attemptGetLayer(): Promise<number | null>;
     getUnstoredBlocks(): Promise<{

package/dist/readable-repo.d.ts

@@ -1,15 +1,16 @@
 import { CID } from 'multiformats/cid';
-import { Commit, DataStore, RepoContents } from './types';
+import { RepoContents, Commit } from './types';
 import { ReadableBlockstore } from './storage';
+import { MST } from './mst';
 declare type Params = {
     storage: ReadableBlockstore;
-    data: DataStore;
+    data: MST;
     commit: Commit;
     cid: CID;
 };
 export declare class ReadableRepo {
     storage: ReadableBlockstore;
-    data: DataStore;
+    data: MST;
     commit: Commit;
     cid: CID;
     constructor(params: Params);

package/dist/repo.d.ts

@@ -1,11 +1,12 @@
 import { CID } from 'multiformats/cid';
 import * as crypto from '@atproto/crypto';
-import { Commit, DataStore, RecordCreateOp, RecordWriteOp, CommitData } from './types';
+import { Commit, CommitData, RecordCreateOp, RecordWriteOp } from './types';
 import { RepoStorage } from './storage';
+import { MST } from './mst';
 import { ReadableRepo } from './readable-repo';
 declare type Params = {
     storage: RepoStorage;
-    data: DataStore;
+    data: MST;
     commit: Commit;
     cid: CID;
 };

package/dist/storage/index.d.ts

@@ -1,5 +1,4 @@
 export * from './readable-blockstore';
-export * from './repo-storage';
 export * from './memory-blockstore';
 export * from './sync-storage';
 export * from './types';

package/dist/storage/memory-blockstore.d.ts

@@ -1,12 +1,13 @@
 import { CID } from 'multiformats/cid';
 import { CommitData } from '../types';
 import BlockMap from '../block-map';
-import RepoStorage from './repo-storage';
-export declare class MemoryBlockstore extends RepoStorage {
+import ReadableBlockstore from './readable-blockstore';
+import { RepoStorage } from './types';
+export declare class MemoryBlockstore extends ReadableBlockstore implements RepoStorage {
     blocks: BlockMap;
-    head: CID | null;
+    root: CID | null;
     constructor(blocks?: BlockMap);
-    getHead(): Promise<CID | null>;
+    getRoot(): Promise<CID | null>;
     getBytes(cid: CID): Promise<Uint8Array | null>;
     has(cid: CID): Promise<boolean>;
     getBlocks(cids: CID[]): Promise<{
@@ -15,13 +16,8 @@ export declare class MemoryBlockstore extends RepoStorage {
     }>;
     putBlock(cid: CID, block: Uint8Array): Promise<void>;
     putMany(blocks: BlockMap): Promise<void>;
-    indexCommits(commits: CommitData[]): Promise<void>;
-    updateHead(cid: CID, _prev: CID | null): Promise<void>;
+    updateRoot(cid: CID): Promise<void>;
     applyCommit(commit: CommitData): Promise<void>;
-    getCommitPath(latest: CID, earliest: CID | null): Promise<CID[] | null>;
-    getBlocksForCommits(commits: CID[]): Promise<{
-        [commit: string]: BlockMap;
-    }>;
     sizeInBytes(): Promise<number>;
     destroy(): Promise<void>;
 }

package/dist/storage/types.d.ts

@@ -1,6 +1,34 @@
 /// <reference types="node" />
 import stream from 'stream';
 import { CID } from 'multiformats/cid';
+import { RepoRecord } from '@atproto/lexicon';
+import { check } from '@atproto/common';
+import BlockMap from '../block-map';
+import { CommitData } from '../types';
+export interface RepoStorage {
+    getRoot(): Promise<CID | null>;
+    putBlock(cid: CID, block: Uint8Array, rev: string): Promise<void>;
+    putMany(blocks: BlockMap, rev: string): Promise<void>;
+    updateRoot(cid: CID): Promise<void>;
+    applyCommit(commit: CommitData): any;
+    getBytes(cid: CID): Promise<Uint8Array | null>;
+    has(cid: CID): Promise<boolean>;
+    getBlocks(cids: CID[]): Promise<{
+        blocks: BlockMap;
+        missing: CID[];
+    }>;
+    attemptRead<T>(cid: CID, def: check.Def<T>): Promise<{
+        obj: T;
+        bytes: Uint8Array;
+    } | null>;
+    readObjAndBytes<T>(cid: CID, def: check.Def<T>): Promise<{
+        obj: T;
+        bytes: Uint8Array;
+    }>;
+    readObj<T>(cid: CID, def: check.Def<T>): Promise<T>;
+    attemptReadRecord(cid: CID): Promise<RepoRecord | null>;
+    readRecord(cid: CID): Promise<RepoRecord>;
+}
 export interface BlobStore {
     putTemp(bytes: Uint8Array | stream.Readable): Promise<string>;
     makePermanent(key: string, cid: CID): Promise<void>;
@@ -9,6 +37,7 @@ export interface BlobStore {
     unquarantine(cid: CID): Promise<void>;
     getBytes(cid: CID): Promise<Uint8Array>;
     getStream(cid: CID): Promise<stream.Readable>;
+    hasStored(cid: CID): Promise<boolean>;
     delete(cid: CID): Promise<void>;
 }
 export declare class BlobNotFoundError extends Error {

package/dist/sync/consumer.d.ts

@@ -1,18 +1,15 @@
 import { CID } from 'multiformats/cid';
-import { RepoStorage } from '../storage';
-import Repo from '../repo';
-import * as verify from '../verify';
-import { RepoContents, WriteLog } from '../types';
-export declare const loadCheckout: (storage: RepoStorage, repoCar: Uint8Array, did: string, signingKey: string) => Promise<{
-    root: CID;
-    contents: RepoContents;
+import ReadableRepo from '../readable-repo';
+import { RecordClaim, VerifiedDiff, VerifiedRepo } from '../types';
+import BlockMap from '../block-map';
+export declare const verifyRepoCar: (carBytes: Uint8Array, did?: string, signingKey?: string) => Promise<VerifiedRepo>;
+export declare const verifyRepo: (blocks: BlockMap, head: CID, did?: string, signingKey?: string) => Promise<VerifiedRepo>;
+export declare const verifyDiffCar: (repo: ReadableRepo | null, carBytes: Uint8Array, did?: string, signingKey?: string) => Promise<VerifiedDiff>;
+export declare const verifyDiff: (repo: ReadableRepo | null, updateBlocks: BlockMap, updateRoot: CID, did?: string, signingKey?: string) => Promise<VerifiedDiff>;
+export declare const verifyProofs: (proofs: Uint8Array, claims: RecordClaim[], did: string, didKey: string) => Promise<{
+    verified: RecordClaim[];
+    unverified: RecordClaim[];
 }>;
-export declare const loadFullRepo: (storage: RepoStorage, repoCar: Uint8Array, did: string, signingKey: string) => Promise<{
-    root: CID;
-    writeLog: WriteLog;
-}>;
-export declare const loadDiff: (repo: Repo, diffCar: Uint8Array, did: string, signingKey: string) => Promise<{
-    root: CID;
-    writeLog: WriteLog;
-}>;
-export declare const persistUpdates: (storage: RepoStorage, updateStorage: RepoStorage, updates: verify.VerifiedUpdate[]) => Promise<WriteLog>;
+export declare const verifyRecords: (proofs: Uint8Array, did: string, signingKey: string) => Promise<RecordClaim[]>;
+export declare class RepoVerificationError extends Error {
+}

package/dist/sync/provider.d.ts

@@ -1,9 +1,5 @@
 import { RecordPath } from '../types';
-import { BlockWriter } from '@ipld/car/writer';
 import { CID } from 'multiformats/cid';
 import { RepoStorage } from '../storage';
-export declare const getCheckout: (storage: RepoStorage, commitCid: CID) => Promise<Uint8Array>;
-export declare const getDiff: (storage: RepoStorage, latest: CID, earliest: CID | null) => Promise<Uint8Array>;
-export declare const getFullRepo: (storage: RepoStorage, cid: CID) => Promise<Uint8Array>;
-export declare const writeCommitsToCarStream: (storage: RepoStorage, car: BlockWriter, latest: CID, earliest: CID | null) => Promise<void>;
-export declare const getRecords: (storage: RepoStorage, commitCid: CID, paths: RecordPath[]) => Promise<Uint8Array>;
+export declare const getFullRepo: (storage: RepoStorage, commitCid: CID) => AsyncIterable<Uint8Array>;
+export declare const getRecords: (storage: RepoStorage, commitCid: CID, paths: RecordPath[]) => AsyncIterable<Uint8Array>;

package/dist/types.d.ts

@@ -1,67 +1,208 @@
 import { z } from 'zod';
-import { BlockWriter } from '@ipld/car/writer';
 import { CID } from 'multiformats';
 import BlockMap from './block-map';
 import { RepoRecord } from '@atproto/lexicon';
+import CidSet from './cid-set';
 declare const unsignedCommit: z.ZodObject<{
     did: z.ZodString;
-    version: z.ZodNumber;
-    prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+    version: z.ZodLiteral<3>;
     data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    rev: z.ZodString;
+    prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
 }, "strip", z.ZodTypeAny, {
-    data: CID;
     did: string;
-    version: number;
-    prev: CID | null;
+    data: CID;
+    version: 3;
+    rev: string;
+    prev?: CID | null | undefined;
 }, {
+    did: string;
+    version: 3;
+    rev: string;
     data?: any;
     prev?: any;
-    did: string;
-    version: number;
 }>;
 export declare type UnsignedCommit = z.infer<typeof unsignedCommit> & {
     sig?: never;
 };
 declare const commit: z.ZodObject<{
     did: z.ZodString;
-    version: z.ZodNumber;
-    prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+    version: z.ZodLiteral<3>;
     data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    rev: z.ZodString;
+    prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
     sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
 }, "strip", z.ZodTypeAny, {
+    did: string;
     data: CID;
+    version: 3;
+    rev: string;
+    sig: Uint8Array;
+    prev?: CID | null | undefined;
+}, {
+    did: string;
+    version: 3;
+    rev: string;
+    sig: Uint8Array;
+    data?: any;
+    prev?: any;
+}>;
+export declare type Commit = z.infer<typeof commit>;
+declare const legacyV2Commit: z.ZodObject<{
+    did: z.ZodString;
+    version: z.ZodLiteral<2>;
+    data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    rev: z.ZodOptional<z.ZodString>;
+    prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+    sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+}, "strip", z.ZodTypeAny, {
     did: string;
-    version: number;
+    data: CID;
+    version: 2;
     prev: CID | null;
     sig: Uint8Array;
+    rev?: string | undefined;
 }, {
+    did: string;
+    version: 2;
+    sig: Uint8Array;
     data?: any;
+    rev?: string | undefined;
     prev?: any;
+}>;
+export declare type LegacyV2Commit = z.infer<typeof legacyV2Commit>;
+declare const versionedCommit: z.ZodDiscriminatedUnion<"version", [z.ZodObject<{
+    did: z.ZodString;
+    version: z.ZodLiteral<3>;
+    data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    rev: z.ZodString;
+    prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
+    sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+}, "strip", z.ZodTypeAny, {
     did: string;
-    version: number;
+    data: CID;
+    version: 3;
+    rev: string;
     sig: Uint8Array;
-}>;
-export declare type Commit = z.infer<typeof commit>;
+    prev?: CID | null | undefined;
+}, {
+    did: string;
+    version: 3;
+    rev: string;
+    sig: Uint8Array;
+    data?: any;
+    prev?: any;
+}>, z.ZodObject<{
+    did: z.ZodString;
+    version: z.ZodLiteral<2>;
+    data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    rev: z.ZodOptional<z.ZodString>;
+    prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+    sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+}, "strip", z.ZodTypeAny, {
+    did: string;
+    data: CID;
+    version: 2;
+    prev: CID | null;
+    sig: Uint8Array;
+    rev?: string | undefined;
+}, {
+    did: string;
+    version: 2;
+    sig: Uint8Array;
+    data?: any;
+    rev?: string | undefined;
+    prev?: any;
+}>]>;
+export declare type VersionedCommit = z.infer<typeof versionedCommit>;
 export declare const schema: {
     commit: z.ZodObject<{
         did: z.ZodString;
-        version: z.ZodNumber;
-        prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+        version: z.ZodLiteral<3>;
         data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+        rev: z.ZodString;
+        prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
         sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
     }, "strip", z.ZodTypeAny, {
+        did: string;
         data: CID;
+        version: 3;
+        rev: string;
+        sig: Uint8Array;
+        prev?: CID | null | undefined;
+    }, {
+        did: string;
+        version: 3;
+        rev: string;
+        sig: Uint8Array;
+        data?: any;
+        prev?: any;
+    }>;
+    legacyV2Commit: z.ZodObject<{
+        did: z.ZodString;
+        version: z.ZodLiteral<2>;
+        data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+        rev: z.ZodOptional<z.ZodString>;
+        prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+        sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+    }, "strip", z.ZodTypeAny, {
         did: string;
-        version: number;
+        data: CID;
+        version: 2;
         prev: CID | null;
         sig: Uint8Array;
+        rev?: string | undefined;
+    }, {
+        did: string;
+        version: 2;
+        sig: Uint8Array;
+        data?: any;
+        rev?: string | undefined;
+        prev?: any;
+    }>;
+    versionedCommit: z.ZodDiscriminatedUnion<"version", [z.ZodObject<{
+        did: z.ZodString;
+        version: z.ZodLiteral<3>;
+        data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+        rev: z.ZodString;
+        prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
+        sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+    }, "strip", z.ZodTypeAny, {
+        did: string;
+        data: CID;
+        version: 3;
+        rev: string;
+        sig: Uint8Array;
+        prev?: CID | null | undefined;
     }, {
+        did: string;
+        version: 3;
+        rev: string;
+        sig: Uint8Array;
         data?: any;
         prev?: any;
+    }>, z.ZodObject<{
+        did: z.ZodString;
+        version: z.ZodLiteral<2>;
+        data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+        rev: z.ZodOptional<z.ZodString>;
+        prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+        sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+    }, "strip", z.ZodTypeAny, {
         did: string;
-        version: number;
+        data: CID;
+        version: 2;
+        prev: CID | null;
         sig: Uint8Array;
-    }>;
+        rev?: string | undefined;
+    }, {
+        did: string;
+        version: 2;
+        sig: Uint8Array;
+        data?: any;
+        rev?: string | undefined;
+        prev?: any;
+    }>]>;
     cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
     bytes: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
     string: z.ZodString;
@@ -74,23 +215,72 @@ export declare const def: {
         name: string;
         schema: z.ZodObject<{
             did: z.ZodString;
-            version: z.ZodNumber;
-            prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+            version: z.ZodLiteral<3>;
             data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+            rev: z.ZodString;
+            prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
             sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
         }, "strip", z.ZodTypeAny, {
+            did: string;
             data: CID;
+            version: 3;
+            rev: string;
+            sig: Uint8Array;
+            prev?: CID | null | undefined;
+        }, {
             did: string;
-            version: number;
-            prev: CID | null;
+            version: 3;
+            rev: string;
             sig: Uint8Array;
+            data?: any;
+            prev?: any;
+        }>;
+    };
+    versionedCommit: {
+        name: string;
+        schema: z.ZodDiscriminatedUnion<"version", [z.ZodObject<{
+            did: z.ZodString;
+            version: z.ZodLiteral<3>;
+            data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+            rev: z.ZodString;
+            prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
+            sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+        }, "strip", z.ZodTypeAny, {
+            did: string;
+            data: CID;
+            version: 3;
+            rev: string;
+            sig: Uint8Array;
+            prev?: CID | null | undefined;
         }, {
+            did: string;
+            version: 3;
+            rev: string;
+            sig: Uint8Array;
             data?: any;
             prev?: any;
+        }>, z.ZodObject<{
+            did: z.ZodString;
+            version: z.ZodLiteral<2>;
+            data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+            rev: z.ZodOptional<z.ZodString>;
+            prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+            sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+        }, "strip", z.ZodTypeAny, {
             did: string;
-            version: number;
+            data: CID;
+            version: 2;
+            prev: CID | null;
             sig: Uint8Array;
-        }>;
+            rev?: string | undefined;
+        }, {
+            did: string;
+            version: 2;
+            sig: Uint8Array;
+            data?: any;
+            rev?: string | undefined;
+            prev?: any;
+        }>]>;
     };
     cid: import("@atproto/common-web/src/check").Def<CID>;
     bytes: import("@atproto/common-web/src/check").Def<Uint8Array>;
@@ -133,18 +323,26 @@ export declare type RecordDeleteDescript = RecordDeleteOp & {
 };
 export declare type RecordWriteDescript = RecordCreateDescript | RecordUpdateDescript | RecordDeleteDescript;
 export declare type WriteLog = RecordWriteDescript[][];
-export declare type CommitBlockData = {
-    commit: CID;
-    blocks: BlockMap;
-};
-export declare type CommitData = CommitBlockData & {
+export declare type CommitData = {
+    cid: CID;
+    rev: string;
+    since: string | null;
     prev: CID | null;
+    newBlocks: BlockMap;
+    removedCids: CidSet;
 };
 export declare type RepoUpdate = CommitData & {
     ops: RecordWriteOp[];
 };
 export declare type CollectionContents = Record<string, RepoRecord>;
 export declare type RepoContents = Record<string, CollectionContents>;
+export declare type RepoRecordWithCid = {
+    cid: CID;
+    value: RepoRecord;
+};
+export declare type CollectionContentsWithCids = Record<string, RepoRecordWithCid>;
+export declare type RepoContentsWithCids = Record<string, CollectionContentsWithCids>;
+export declare type DatastoreContents = Record<string, CID>;
 export declare type RecordPath = {
     collection: string;
     rkey: string;
@@ -154,22 +352,12 @@ export declare type RecordClaim = {
     rkey: string;
     record: RepoRecord | null;
 };
-export declare type DataValue = {
-    key: string;
-    value: CID;
-};
-export interface DataStore {
-    add(key: string, value: CID): Promise<DataStore>;
-    update(key: string, value: CID): Promise<DataStore>;
-    delete(key: string): Promise<DataStore>;
-    get(key: string): Promise<CID | null>;
-    list(count?: number, after?: string, before?: string): Promise<DataValue[]>;
-    listWithPrefix(prefix: string, count?: number): Promise<DataValue[]>;
-    getUnstoredBlocks(): Promise<{
-        root: CID;
-        blocks: BlockMap;
-    }>;
-    writeToCarStream(car: BlockWriter): Promise<void>;
-    cidsForPath(key: string): Promise<CID[]>;
-}
+export declare type VerifiedDiff = {
+    writes: RecordWriteDescript[];
+    commit: CommitData;
+};
+export declare type VerifiedRepo = {
+    creates: RecordCreateDescript[];
+    commit: CommitData;
+};
 export {};

package/dist/util.d.ts

@@ -1,15 +1,18 @@
+/// <reference types="node" />
 import { CID } from 'multiformats/cid';
 import { BlockWriter } from '@ipld/car/writer';
 import { Block as CarBlock } from '@ipld/car/api';
 import { LexValue, RepoRecord } from '@atproto/lexicon';
 import DataDiff from './data-diff';
-import { RepoStorage } from './storage';
-import { Commit, RecordPath, RecordWriteDescript, UnsignedCommit, WriteLog } from './types';
+import { Commit, LegacyV2Commit, RecordCreateDescript, RecordPath, RecordWriteDescript, UnsignedCommit } from './types';
 import BlockMap from './block-map';
 import { Keypair } from '@atproto/crypto';
+import { Readable } from 'stream';
 export declare function verifyIncomingCarBlocks(car: AsyncIterable<CarBlock>): AsyncIterable<CarBlock>;
-export declare const writeCar: (root: CID | null, fn: (car: BlockWriter) => Promise<void>) => Promise<Uint8Array>;
-export declare const blocksToCar: (root: CID | null, blocks: BlockMap) => Promise<Uint8Array>;
+export declare function writeCarStream(root: CID | null, fn: (car: BlockWriter) => Promise<void>): Readable;
+export declare function writeCar(root: CID | null, fn: (car: BlockWriter) => Promise<void>): AsyncIterable<Uint8Array>;
+export declare const blocksToCarStream: (root: CID | null, blocks: BlockMap) => AsyncIterable<Uint8Array>;
+export declare const blocksToCarFile: (root: CID | null, blocks: BlockMap) => Promise<Uint8Array>;
 export declare const readCar: (bytes: Uint8Array) => Promise<{
     roots: CID[];
     blocks: BlockMap;
@@ -18,10 +21,8 @@ export declare const readCarWithRoot: (bytes: Uint8Array) => Promise<{
     root: CID;
     blocks: BlockMap;
 }>;
-export declare const getWriteLog: (storage: RepoStorage, latest: CID, earliest: CID | null) => Promise<WriteLog>;
 export declare const diffToWriteDescripts: (diff: DataDiff, blocks: BlockMap) => Promise<RecordWriteDescript[]>;
-export declare const collapseWriteLog: (log: WriteLog) => RecordWriteDescript[];
-export declare const collapseDiffs: (diffs: DataDiff[]) => DataDiff;
+export declare const ensureCreates: (descripts: RecordWriteDescript[]) => RecordCreateDescript[];
 export declare const parseDataKey: (key: string) => RecordPath;
 export declare const formatDataKey: (collection: string, rkey: string) => string;
 export declare const metaEqual: (a: Commit, b: Commit) => boolean;
@@ -30,3 +31,4 @@ export declare const verifyCommitSig: (commit: Commit, didKey: string) => Promis
 export declare const cborToLex: (val: Uint8Array) => LexValue;
 export declare const cborToLexRecord: (val: Uint8Array) => RepoRecord;
 export declare const cidForRecord: (val: LexValue) => Promise<CID>;
+export declare const ensureV3Commit: (commit: LegacyV2Commit | Commit) => Commit;