@atproto/repo 0.2.0 → 0.3.0

package/dist/mst/mst.d.ts

@@ -12,10 +12,10 @@ 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;
     }, {
         p: number;
         k: Uint8Array;
@@ -23,13 +23,13 @@ declare const nodeData: z.ZodObject<{
         t?: any;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
+    l: CID | null;
     e: {
+        t: CID | null;
         p: number;
         k: Uint8Array;
         v: CID;
-        t: CID | null;
     }[];
-    l: CID | null;
 }, {
     e: {
         p: number;
@@ -50,10 +50,10 @@ 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;
         }, {
             p: number;
             k: Uint8Array;
@@ -61,13 +61,13 @@ export declare const nodeDataDef: {
             t?: any;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
+        l: CID | null;
         e: {
+            t: CID | null;
             p: number;
             k: Uint8Array;
             v: CID;
-            t: CID | null;
         }[];
-        l: CID | null;
     }, {
         e: {
             p: number;
@@ -95,6 +95,10 @@ export declare class MST {
     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,5 +1,5 @@
 import { CID } from 'multiformats/cid';
-import { Commit, RepoContents } from './types';
+import { RepoContents, Commit } from './types';
 import { ReadableBlockstore } from './storage';
 import { MST } from './mst';
 declare type Params = {

package/dist/repo.d.ts

@@ -1,6 +1,6 @@
 import { CID } from 'multiformats/cid';
 import * as crypto from '@atproto/crypto';
-import { Commit, RecordCreateOp, RecordWriteOp, CommitData, RebaseData } from './types';
+import { Commit, CommitData, RecordCreateOp, RecordWriteOp } from './types';
 import { RepoStorage } from './storage';
 import { MST } from './mst';
 import { ReadableRepo } from './readable-repo';
@@ -20,8 +20,5 @@ export declare class Repo extends ReadableRepo {
     formatCommit(toWrite: RecordWriteOp | RecordWriteOp[], keypair: crypto.Keypair): Promise<CommitData>;
     applyCommit(commitData: CommitData): Promise<Repo>;
     applyWrites(toWrite: RecordWriteOp | RecordWriteOp[], keypair: crypto.Keypair): Promise<Repo>;
-    formatRebase(keypair: crypto.Keypair): Promise<RebaseData>;
-    applyRebase(rebase: RebaseData): Promise<Repo>;
-    rebase(keypair: crypto.Keypair): Promise<Repo>;
 }
 export default Repo;

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, RebaseData } from '../types';
+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,14 +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;
-    }>;
-    applyRebase(rebase: RebaseData): Promise<void>;
     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>;

package/dist/sync/consumer.d.ts

@@ -1,19 +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;
-    repo: Repo;
-}>;
-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) => AsyncIterable<Uint8Array>;
-export declare const getCommits: (storage: RepoStorage, latest: CID, earliest: CID | null) => AsyncIterable<Uint8Array>;
-export declare const getFullRepo: (storage: RepoStorage, cid: CID) => AsyncIterable<Uint8Array>;
-export declare const writeCommitsToCarStream: (storage: RepoStorage, car: BlockWriter, latest: CID, earliest: CID | null) => Promise<void>;
+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

@@ -2,65 +2,207 @@ import { z } from 'zod';
 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, {
     did: string;
     data: CID;
-    version: number;
-    prev: CID | null;
+    version: 3;
+    rev: string;
+    prev?: CID | null | undefined;
 }, {
     did: string;
-    version: number;
-    prev?: any;
+    version: 3;
+    rev: string;
     data?: any;
+    prev?: any;
 }>;
 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: number;
-    prev: CID | null;
+    version: 3;
+    rev: string;
     sig: Uint8Array;
+    prev?: CID | null | undefined;
 }, {
     did: string;
-    version: number;
+    version: 3;
+    rev: string;
     sig: Uint8Array;
-    prev?: any;
     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;
+    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;
+    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;
+    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: number;
-        prev: CID | null;
+        version: 3;
+        rev: string;
         sig: Uint8Array;
+        prev?: CID | null | undefined;
     }, {
         did: string;
-        version: number;
+        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;
+        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;
+        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;
@@ -73,24 +215,73 @@ 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: number;
-            prev: CID | null;
+            version: 3;
+            rev: string;
             sig: Uint8Array;
+            prev?: CID | null | undefined;
         }, {
             did: string;
-            version: number;
+            version: 3;
+            rev: string;
             sig: Uint8Array;
-            prev?: any;
             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;
+            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>;
     string: import("@atproto/common-web/src/check").Def<string>;
@@ -132,23 +323,13 @@ 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 & {
-    prev: CID | null;
-};
-export declare type RebaseData = {
-    commit: CID;
-    rebased: CID;
-    blocks: BlockMap;
-    preservedCids: CID[];
-};
-export declare type CommitCidData = {
-    commit: CID;
+export declare type CommitData = {
+    cid: CID;
+    rev: string;
+    since: string | null;
     prev: CID | null;
-    cids: CID[];
+    newBlocks: BlockMap;
+    removedCids: CidSet;
 };
 export declare type RepoUpdate = CommitData & {
     ops: RecordWriteOp[];
@@ -171,4 +352,12 @@ export declare type RecordClaim = {
     rkey: string;
     record: RepoRecord | null;
 };
+export declare type VerifiedDiff = {
+    writes: RecordWriteDescript[];
+    commit: CommitData;
+};
+export declare type VerifiedRepo = {
+    creates: RecordCreateDescript[];
+    commit: CommitData;
+};
 export {};

package/dist/util.d.ts

@@ -4,8 +4,7 @@ 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';
@@ -22,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;
@@ -34,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/repo",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "main": "dist/index.js",
   "license": "MIT",
   "repository": {
@@ -31,7 +31,7 @@
     "@atproto/crypto": "*",
     "@atproto/identity": "*",
     "@atproto/lexicon": "*",
-    "@atproto/nsid": "*",
+    "@atproto/syntax": "*",
     "@ipld/car": "^3.2.3",
     "@ipld/dag-cbor": "^7.0.0",
     "multiformats": "^9.6.4",