@atproto/repo 0.0.1

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("pino").default.Logger<import("pino").default.LoggerOptions>;
+export default logger;

package/dist/mst/diff.d.ts

@@ -0,0 +1,33 @@
+import * as auth from '@atproto/auth';
+import { CID } from 'multiformats';
+import CidSet from '../cid-set';
+export declare class DataDiff {
+    adds: Record<string, DataAdd>;
+    updates: Record<string, DataUpdate>;
+    deletes: Record<string, DataDelete>;
+    newCids: CidSet;
+    recordAdd(key: string, cid: CID): void;
+    recordUpdate(key: string, prev: CID, cid: CID): void;
+    recordDelete(key: string, cid: CID): void;
+    recordNewCid(cid: CID): void;
+    addDiff(diff: DataDiff): void;
+    addList(): DataAdd[];
+    updateList(): DataUpdate[];
+    deleteList(): DataDelete[];
+    newCidList(): CID[];
+    updatedKeys(): string[];
+    neededCapabilities(rootDid: string): auth.ucans.Capability[];
+}
+export declare type DataAdd = {
+    key: string;
+    cid: CID;
+};
+export declare type DataUpdate = {
+    key: string;
+    prev: CID;
+    cid: CID;
+};
+export declare type DataDelete = {
+    key: string;
+    cid: CID;
+};

package/dist/mst/index.d.ts

@@ -0,0 +1,4 @@
+export * from './mst';
+export * from './diff';
+export * from './walker';
+export * as mstUtil from './util';

package/dist/mst/mst.d.ts

@@ -0,0 +1,106 @@
+import z from 'zod';
+import { CID } from 'multiformats';
+import IpldStore from '../blockstore/ipld-store';
+import { DataDiff } from './diff';
+import { DataStore } from '../types';
+import { BlockWriter } from '@ipld/car/api';
+export declare const nodeDataDef: z.ZodObject<{
+    l: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+    e: z.ZodArray<z.ZodObject<{
+        p: z.ZodNumber;
+        k: z.ZodString;
+        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: string;
+        v: CID;
+    }, {
+        t?: any;
+        v?: any;
+        p: number;
+        k: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    l: CID | null;
+    e: {
+        t: CID | null;
+        p: number;
+        k: string;
+        v: CID;
+    }[];
+}, {
+    l?: any;
+    e: {
+        t?: any;
+        v?: any;
+        p: number;
+        k: string;
+    }[];
+}>;
+export declare type NodeData = z.infer<typeof nodeDataDef>;
+export declare type NodeEntry = MST | Leaf;
+export declare type Fanout = 2 | 8 | 16 | 32 | 64;
+export declare type MstOpts = {
+    layer: number;
+    fanout: Fanout;
+};
+export declare class MST implements DataStore {
+    blockstore: IpldStore;
+    fanout: Fanout;
+    entries: NodeEntry[] | null;
+    layer: number | null;
+    pointer: CID;
+    outdatedPointer: boolean;
+    constructor(blockstore: IpldStore, fanout: Fanout, pointer: CID, entries: NodeEntry[] | null, layer: number | null);
+    static create(blockstore: IpldStore, entries?: NodeEntry[], opts?: Partial<MstOpts>): Promise<MST>;
+    static fromData(blockstore: IpldStore, data: NodeData, opts?: Partial<MstOpts>): Promise<MST>;
+    static load(blockstore: IpldStore, cid: CID, opts?: Partial<MstOpts>): MST;
+    newTree(entries: NodeEntry[]): Promise<MST>;
+    getEntries(): Promise<NodeEntry[]>;
+    getPointer(): Promise<CID>;
+    getLayer(): Promise<number>;
+    attemptGetLayer(): Promise<number | null>;
+    stage(): Promise<CID>;
+    stageRecurse(trimTop?: boolean): Promise<CID>;
+    add(key: string, value: CID, knownZeros?: number): Promise<MST>;
+    get(key: string): Promise<CID | null>;
+    update(key: string, value: CID): Promise<MST>;
+    delete(key: string): Promise<MST>;
+    diff(other: MST): Promise<DataDiff>;
+    updateEntry(index: number, entry: NodeEntry): Promise<MST>;
+    removeEntry(index: number): Promise<MST>;
+    append(entry: NodeEntry): Promise<MST>;
+    prepend(entry: NodeEntry): Promise<MST>;
+    atIndex(index: number): Promise<NodeEntry | null>;
+    slice(start?: number | undefined, end?: number | undefined): Promise<NodeEntry[]>;
+    spliceIn(entry: NodeEntry, index: number): Promise<MST>;
+    replaceWithSplit(index: number, left: MST | null, leaf: Leaf, right: MST | null): Promise<MST>;
+    splitAround(key: string): Promise<[MST | null, MST | null]>;
+    appendMerge(toMerge: MST): Promise<MST>;
+    createChild(): Promise<MST>;
+    createParent(): Promise<MST>;
+    findGtOrEqualLeafIndex(key: string): Promise<number>;
+    walkLeavesFrom(key: string): AsyncIterable<Leaf>;
+    list(count: number, after?: string, before?: string): Promise<Leaf[]>;
+    listWithPrefix(prefix: string, count?: number): Promise<Leaf[]>;
+    walk(): AsyncIterable<NodeEntry>;
+    paths(): Promise<NodeEntry[][]>;
+    allNodes(): Promise<NodeEntry[]>;
+    leaves(): Promise<Leaf[]>;
+    leafCount(): Promise<number>;
+    writeToCarStream(car: BlockWriter): Promise<void>;
+    isTree(): this is MST;
+    isLeaf(): this is Leaf;
+    equals(other: NodeEntry): Promise<boolean>;
+}
+export declare class Leaf {
+    key: string;
+    value: CID;
+    constructor(key: string, value: CID);
+    isTree(): this is MST;
+    isLeaf(): this is Leaf;
+    equals(entry: NodeEntry): boolean;
+}
+export default MST;

package/dist/mst/util.d.ts

@@ -0,0 +1,9 @@
+import { CID } from 'multiformats';
+import IpldStore from '../blockstore/ipld-store';
+import { NodeEntry, NodeData, MstOpts, Fanout } from './mst';
+export declare const leadingZerosOnHash: (key: string, fanout: Fanout) => Promise<number>;
+export declare const layerForEntries: (entries: NodeEntry[], fanout: Fanout) => Promise<number | null>;
+export declare const deserializeNodeData: (blockstore: IpldStore, data: NodeData, opts?: Partial<MstOpts>) => Promise<NodeEntry[]>;
+export declare const serializeNodeData: (entries: NodeEntry[]) => NodeData;
+export declare const countPrefixLen: (a: string, b: string) => number;
+export declare const cidForEntries: (entries: NodeEntry[]) => Promise<CID>;

package/dist/mst/walker.d.ts

@@ -0,0 +1,22 @@
+import { MST, NodeEntry } from './mst';
+declare type WalkerStatusDone = {
+    done: true;
+};
+declare type WalkerStatusProgress = {
+    done: false;
+    curr: NodeEntry;
+    walking: MST | null;
+    index: number;
+};
+declare type WalkerStatus = WalkerStatusDone | WalkerStatusProgress;
+export declare class MstWalker {
+    root: MST;
+    stack: WalkerStatus[];
+    status: WalkerStatus;
+    constructor(root: MST);
+    layer(): number;
+    stepOver(): Promise<void>;
+    stepInto(): Promise<void>;
+    advance(): Promise<void>;
+}
+export default MstWalker;

package/dist/repo.d.ts

@@ -0,0 +1,39 @@
+import { CID } from 'multiformats/cid';
+import { BlockWriter } from '@ipld/car/writer';
+import { RepoRoot, Commit, DataStore, RepoMeta, RecordCreateOp, RecordWriteOp } from './types';
+import IpldStore from './blockstore/ipld-store';
+import * as auth from '@atproto/auth';
+declare type Params = {
+    blockstore: IpldStore;
+    data: DataStore;
+    commit: Commit;
+    root: RepoRoot;
+    meta: RepoMeta;
+    cid: CID;
+    stagedWrites: RecordWriteOp[];
+};
+export declare class Repo {
+    blockstore: IpldStore;
+    data: DataStore;
+    commit: Commit;
+    root: RepoRoot;
+    meta: RepoMeta;
+    cid: CID;
+    stagedWrites: RecordWriteOp[];
+    constructor(params: Params);
+    static create(blockstore: IpldStore, did: string, authStore: auth.AuthStore, initialRecords?: RecordCreateOp[]): Promise<Repo>;
+    static load(blockstore: IpldStore, cid: CID): Promise<Repo>;
+    private updateRepo;
+    get did(): string;
+    getRecord(collection: string, rkey: string): Promise<unknown | null>;
+    stageUpdate(write: RecordWriteOp | RecordWriteOp[]): Repo;
+    createCommit(authStore: auth.AuthStore, performUpdate?: (prev: CID, curr: CID) => Promise<CID | null>): Promise<Repo>;
+    revert(count: number): Promise<Repo>;
+    getCarNoHistory(): Promise<Uint8Array>;
+    getDiffCar(to: CID | null): Promise<Uint8Array>;
+    getFullHistory(): Promise<Uint8Array>;
+    private openCar;
+    writeCheckoutToCarStream(car: BlockWriter): Promise<void>;
+    writeCommitsToCarStream(car: BlockWriter, oldestCommit: CID | null, recentCommit: CID): Promise<void>;
+}
+export default Repo;

package/dist/storage/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/storage/types.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import stream from 'stream';
+import { CID } from 'multiformats/cid';
+export interface BlobStore {
+    putTemp(bytes: Uint8Array | stream.Readable): Promise<string>;
+    makePermanent(key: string, cid: CID): Promise<void>;
+    putPermanent(cid: CID, bytes: Uint8Array | stream.Readable): Promise<void>;
+    getBytes(cid: CID): Promise<Uint8Array>;
+    getStream(cid: CID): Promise<stream.Readable>;
+}
+export declare class BlobNotFoundError extends Error {
+}

package/dist/sync.d.ts

@@ -0,0 +1,9 @@
+import * as auth from '@atproto/auth';
+import { IpldStore } from './blockstore';
+import { DataDiff } from './mst';
+import Repo from './repo';
+export declare const loadRepoFromCar: (carBytes: Uint8Array, blockstore: IpldStore, verifier: auth.Verifier) => Promise<Repo>;
+export declare const loadDiff: (repo: Repo, diffCar: Uint8Array, verifier: auth.Verifier) => Promise<{
+    repo: Repo;
+    diff: DataDiff;
+}>;

package/dist/types.d.ts

@@ -0,0 +1,368 @@
+import { z } from 'zod';
+import { BlockWriter } from '@ipld/car/writer';
+import { CID } from 'multiformats';
+import { DataDiff } from './mst';
+declare const repoMeta: z.ZodObject<{
+    did: z.ZodString;
+    version: z.ZodNumber;
+    datastore: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version: number;
+    did: string;
+    datastore: string;
+}, {
+    version: number;
+    did: string;
+    datastore: string;
+}>;
+export declare type RepoMeta = z.infer<typeof repoMeta>;
+declare const repoRoot: z.ZodObject<{
+    meta: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+    auth_token: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+    data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+}, "strip", z.ZodTypeAny, {
+    data: CID;
+    meta: CID;
+    prev: CID | null;
+    auth_token: CID | null;
+}, {
+    data?: any;
+    meta?: any;
+    prev?: any;
+    auth_token?: any;
+}>;
+export declare type RepoRoot = z.infer<typeof repoRoot>;
+declare const commit: z.ZodObject<{
+    root: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+}, "strip", z.ZodTypeAny, {
+    root: CID;
+    sig: Uint8Array;
+}, {
+    root?: any;
+    sig: Uint8Array;
+}>;
+export declare type Commit = z.infer<typeof commit>;
+export declare const cidCreateOp: z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "create";
+    rkey: string;
+    cid: CID;
+}, {
+    cid?: any;
+    collection: string;
+    action: "create";
+    rkey: string;
+}>;
+export declare type CidCreateOp = z.infer<typeof cidCreateOp>;
+export declare const cidUpdateOp: z.ZodObject<{
+    action: z.ZodLiteral<"update">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "update";
+    rkey: string;
+    cid: CID;
+}, {
+    cid?: any;
+    collection: string;
+    action: "update";
+    rkey: string;
+}>;
+export declare type CidUpdateOp = z.infer<typeof cidUpdateOp>;
+export declare const deleteOp: z.ZodObject<{
+    action: z.ZodLiteral<"delete">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "delete";
+    rkey: string;
+}, {
+    collection: string;
+    action: "delete";
+    rkey: string;
+}>;
+export declare type DeleteOp = z.infer<typeof deleteOp>;
+export declare const cidWriteOp: z.ZodUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "create";
+    rkey: string;
+    cid: CID;
+}, {
+    cid?: any;
+    collection: string;
+    action: "create";
+    rkey: string;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"update">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "update";
+    rkey: string;
+    cid: CID;
+}, {
+    cid?: any;
+    collection: string;
+    action: "update";
+    rkey: string;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"delete">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "delete";
+    rkey: string;
+}, {
+    collection: string;
+    action: "delete";
+    rkey: string;
+}>]>;
+export declare type CidWriteOp = z.infer<typeof cidWriteOp>;
+export declare const recordCreateOp: z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    value?: any;
+    collection: string;
+    action: "create";
+    rkey: string;
+}, {
+    value?: any;
+    collection: string;
+    action: "create";
+    rkey: string;
+}>;
+export declare type RecordCreateOp = z.infer<typeof recordCreateOp>;
+export declare const recordUpdateOp: z.ZodObject<{
+    action: z.ZodLiteral<"update">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    value?: any;
+    collection: string;
+    action: "update";
+    rkey: string;
+}, {
+    value?: any;
+    collection: string;
+    action: "update";
+    rkey: string;
+}>;
+export declare type RecordUpdateOp = z.infer<typeof recordUpdateOp>;
+export declare const recordWriteOp: z.ZodUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    value?: any;
+    collection: string;
+    action: "create";
+    rkey: string;
+}, {
+    value?: any;
+    collection: string;
+    action: "create";
+    rkey: string;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"update">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    value?: any;
+    collection: string;
+    action: "update";
+    rkey: string;
+}, {
+    value?: any;
+    collection: string;
+    action: "update";
+    rkey: string;
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"delete">;
+    collection: z.ZodString;
+    rkey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    action: "delete";
+    rkey: string;
+}, {
+    collection: string;
+    action: "delete";
+    rkey: string;
+}>]>;
+export declare type RecordWriteOp = z.infer<typeof recordWriteOp>;
+export declare const def: {
+    repoMeta: z.ZodObject<{
+        did: z.ZodString;
+        version: z.ZodNumber;
+        datastore: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        version: number;
+        did: string;
+        datastore: string;
+    }, {
+        version: number;
+        did: string;
+        datastore: string;
+    }>;
+    repoRoot: z.ZodObject<{
+        meta: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+        prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+        auth_token: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+        data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    }, "strip", z.ZodTypeAny, {
+        data: CID;
+        meta: CID;
+        prev: CID | null;
+        auth_token: CID | null;
+    }, {
+        data?: any;
+        meta?: any;
+        prev?: any;
+        auth_token?: any;
+    }>;
+    commit: z.ZodObject<{
+        root: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+        sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+    }, "strip", z.ZodTypeAny, {
+        root: CID;
+        sig: Uint8Array;
+    }, {
+        root?: any;
+        sig: Uint8Array;
+    }>;
+    cidWriteOp: z.ZodUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"create">;
+        collection: z.ZodString;
+        rkey: z.ZodString;
+        cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    }, "strip", z.ZodTypeAny, {
+        collection: string;
+        action: "create";
+        rkey: string;
+        cid: CID;
+    }, {
+        cid?: any;
+        collection: string;
+        action: "create";
+        rkey: string;
+    }>, z.ZodObject<{
+        action: z.ZodLiteral<"update">;
+        collection: z.ZodString;
+        rkey: z.ZodString;
+        cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    }, "strip", z.ZodTypeAny, {
+        collection: string;
+        action: "update";
+        rkey: string;
+        cid: CID;
+    }, {
+        cid?: any;
+        collection: string;
+        action: "update";
+        rkey: string;
+    }>, z.ZodObject<{
+        action: z.ZodLiteral<"delete">;
+        collection: z.ZodString;
+        rkey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        collection: string;
+        action: "delete";
+        rkey: string;
+    }, {
+        collection: string;
+        action: "delete";
+        rkey: string;
+    }>]>;
+    recordWriteOp: z.ZodUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"create">;
+        collection: z.ZodString;
+        rkey: z.ZodString;
+        value: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        value?: any;
+        collection: string;
+        action: "create";
+        rkey: string;
+    }, {
+        value?: any;
+        collection: string;
+        action: "create";
+        rkey: string;
+    }>, z.ZodObject<{
+        action: z.ZodLiteral<"update">;
+        collection: z.ZodString;
+        rkey: z.ZodString;
+        value: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        value?: any;
+        collection: string;
+        action: "update";
+        rkey: string;
+    }, {
+        value?: any;
+        collection: string;
+        action: "update";
+        rkey: string;
+    }>, z.ZodObject<{
+        action: z.ZodLiteral<"delete">;
+        collection: z.ZodString;
+        rkey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        collection: string;
+        action: "delete";
+        rkey: string;
+    }, {
+        collection: string;
+        action: "delete";
+        rkey: string;
+    }>]>;
+    string: z.ZodString;
+    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    strToCid: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, CID, string>;
+    bytes: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+    strToInt: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, number, string>;
+    strToBool: z.ZodEffects<z.ZodString, boolean, string>;
+};
+export interface CarStreamable {
+    writeToCarStream(car: BlockWriter): Promise<void>;
+}
+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[]>;
+    diff(other: DataStore): Promise<DataDiff>;
+    stage(): Promise<CID>;
+    writeToCarStream(car: BlockWriter): Promise<void>;
+}
+export {};

package/dist/util.d.ts

@@ -0,0 +1,13 @@
+import { CID } from 'multiformats/cid';
+import * as auth from '@atproto/auth';
+import { DataDiff } from './mst';
+import { IpldStore } from './blockstore';
+import { DataStore, RecordWriteOp } from './types';
+export declare const ucanForOperation: (prevData: DataStore, newData: DataStore, rootDid: string, authStore: auth.AuthStore) => Promise<string>;
+export declare const getCommitPath: (blockstore: IpldStore, earliest: CID | null, latest: CID) => Promise<CID[] | null>;
+export declare const getWriteOpLog: (blockstore: IpldStore, earliest: CID | null, latest: CID) => Promise<RecordWriteOp[][]>;
+export declare const diffToWriteOps: (blockstore: IpldStore, diff: DataDiff) => Promise<RecordWriteOp[]>;
+export declare const parseRecordKey: (key: string) => {
+    collection: string;
+    rkey: string;
+};

package/dist/verify.d.ts

@@ -0,0 +1,5 @@
+import { CID } from 'multiformats/cid';
+import * as auth from '@atproto/auth';
+import { IpldStore } from './blockstore';
+import { DataDiff } from './mst';
+export declare const verifyUpdates: (blockstore: IpldStore, earliest: CID | null, latest: CID, verifier: auth.Verifier) => Promise<DataDiff>;

package/jest.bench.config.js

@@ -0,0 +1,7 @@
+const base = require('./jest.config')
+
+module.exports = {
+  ...base,
+  testRegex: '(/bench/.*.bench)',
+  testTimeout: 3000000,
+}

package/jest.config.js

@@ -0,0 +1,6 @@
+const base = require('../../jest.config.base.js')
+
+module.exports = {
+  ...base,
+  displayName: 'Repo',
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@atproto/repo",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "license": "MIT",
+  "scripts": {
+    "test": "jest",
+    "test:profile": "node --inspect ../../node_modules/.bin/jest",
+    "bench": "jest --config jest.bench.config.js",
+    "bench:profile": "node --inspect ../../node_modules/.bin/jest --config jest.bench.config.js",
+    "prettier": "prettier --check src/",
+    "prettier:fix": "prettier --write src/",
+    "lint": "eslint . --ext .ts,.tsx",
+    "lint:fix": "yarn lint --fix",
+    "verify": "run-p prettier lint",
+    "verify:fix": "yarn prettier:fix && yarn lint:fix",
+    "build": "node ./build.js",
+    "postbuild": "tsc --build tsconfig.build.json",
+    "update-main-to-dist": "node ./update-pkg.js --update-main-to-dist",
+    "update-main-to-src": "node ./update-pkg.js --update-main-to-src",
+    "prepublish": "npm run update-main-to-dist",
+    "postpublish": "npm run update-main-to-src"
+  },
+  "dependencies": {
+    "@atproto/auth": "*",
+    "@atproto/common": "*",
+    "@atproto/nsid": "*",
+    "@ipld/car": "^3.2.3",
+    "@ipld/dag-cbor": "^7.0.0",
+    "multiformats": "^9.6.4",
+    "uint8arrays": "3.0.0",
+    "zod": "^3.14.2"
+  }
+}