@atproto/repo 0.2.0 → 0.3.0

package/dist/index.js

@@ -13141,8 +13141,8 @@ var require_varint = __commonJS({
 });
 
 // src/index.ts
-var src_exports6 = {};
-__export(src_exports6, {
+var src_exports4 = {};
+__export(src_exports4, {
   BlobNotFoundError: () => BlobNotFoundError,
   BlockMap: () => BlockMap,
   CidSet: () => CidSet,
@@ -13153,7 +13153,6 @@ __export(src_exports6, {
   MstWalker: () => MstWalker,
   ReadableBlockstore: () => ReadableBlockstore,
   Repo: () => Repo,
-  RepoStorage: () => RepoStorage,
   RepoVerificationError: () => RepoVerificationError,
   SyncStorage: () => SyncStorage,
   WriteOpAction: () => WriteOpAction,
@@ -13162,44 +13161,35 @@ __export(src_exports6, {
   cborToLex: () => cborToLex,
   cborToLexRecord: () => cborToLexRecord,
   cidForRecord: () => cidForRecord,
-  collapseDiffs: () => collapseDiffs,
-  collapseWriteLog: () => collapseWriteLog,
   def: () => def2,
   diffToWriteDescripts: () => diffToWriteDescripts,
+  ensureCreates: () => ensureCreates,
+  ensureV3Commit: () => ensureV3Commit,
   formatDataKey: () => formatDataKey,
-  getCheckout: () => getCheckout,
-  getCommits: () => getCommits,
   getFullRepo: () => getFullRepo,
   getRecords: () => getRecords,
-  getWriteLog: () => getWriteLog,
-  loadCheckout: () => loadCheckout,
-  loadDiff: () => loadDiff,
-  loadFullRepo: () => loadFullRepo,
   metaEqual: () => metaEqual,
   mstDiff: () => mstDiff,
   mstUtil: () => util_exports2,
   nodeDataDef: () => nodeDataDef,
   nullDiff: () => nullDiff,
   parseDataKey: () => parseDataKey,
-  persistUpdates: () => persistUpdates,
   readCar: () => readCar,
   readCarWithRoot: () => readCarWithRoot,
   schema: () => schema2,
   signCommit: () => signCommit,
-  verifyCheckout: () => verifyCheckout,
-  verifyCheckoutWithCids: () => verifyCheckoutWithCids,
-  verifyCommitPath: () => verifyCommitPath,
   verifyCommitSig: () => verifyCommitSig,
-  verifyFullHistory: () => verifyFullHistory,
+  verifyDiff: () => verifyDiff,
+  verifyDiffCar: () => verifyDiffCar,
   verifyIncomingCarBlocks: () => verifyIncomingCarBlocks,
   verifyProofs: () => verifyProofs,
   verifyRecords: () => verifyRecords,
-  verifyUpdates: () => verifyUpdates,
+  verifyRepo: () => verifyRepo,
+  verifyRepoCar: () => verifyRepoCar,
   writeCar: () => writeCar,
-  writeCarStream: () => writeCarStream,
-  writeCommitsToCarStream: () => writeCommitsToCarStream
+  writeCarStream: () => writeCarStream
 });
-module.exports = __toCommonJS(src_exports6);
+module.exports = __toCommonJS(src_exports4);
 
 // ../../node_modules/zod/lib/index.mjs
 var util;
@@ -16790,7 +16780,7 @@ var z = /* @__PURE__ */ Object.freeze({
   ZodError
 });
 
-// ../nsid/src/index.ts
+// ../syntax/src/nsid.ts
 var NSID = class {
   constructor(nsid2) {
     this.segments = [];
@@ -16895,6 +16885,108 @@ var streamToBuffer = async (stream) => {
   }
   return flattenUint8Arrays(arrays);
 };
+var S32_CHAR = "234567abcdefghijklmnopqrstuvwxyz";
+var s32encode = (i) => {
+  let s = "";
+  while (i) {
+    const c = i % 32;
+    i = Math.floor(i / 32);
+    s = S32_CHAR.charAt(c) + s;
+  }
+  return s;
+};
+var s32decode = (s) => {
+  let i = 0;
+  for (const c of s) {
+    i = i * 32 + S32_CHAR.indexOf(c);
+  }
+  return i;
+};
+
+// ../common-web/src/tid.ts
+var TID_LEN = 13;
+var lastTimestamp = 0;
+var timestampCount = 0;
+var clockid = null;
+function dedash(str) {
+  return str.replaceAll("-", "");
+}
+var TID = class {
+  constructor(str) {
+    const noDashes = dedash(str);
+    if (noDashes.length !== TID_LEN) {
+      throw new Error(`Poorly formatted TID: ${noDashes.length} length`);
+    }
+    this.str = noDashes;
+  }
+  static next(prev) {
+    const time = Math.max(Date.now(), lastTimestamp);
+    if (time === lastTimestamp) {
+      timestampCount++;
+    }
+    lastTimestamp = time;
+    const timestamp = time * 1e3 + timestampCount;
+    if (clockid === null) {
+      clockid = Math.floor(Math.random() * 32);
+    }
+    const tid = TID.fromTime(timestamp, clockid);
+    if (!prev || tid.newerThan(prev)) {
+      return tid;
+    }
+    return TID.fromTime(prev.timestamp() + 1, clockid);
+  }
+  static nextStr(prev) {
+    return TID.next(prev ? new TID(prev) : void 0).toString();
+  }
+  static fromTime(timestamp, clockid2) {
+    const str = `${s32encode(timestamp)}${s32encode(clockid2).padStart(2, "2")}`;
+    return new TID(str);
+  }
+  static fromStr(str) {
+    return new TID(str);
+  }
+  static oldestFirst(a, b) {
+    return a.compareTo(b);
+  }
+  static newestFirst(a, b) {
+    return b.compareTo(a);
+  }
+  static is(str) {
+    return dedash(str).length === TID_LEN;
+  }
+  timestamp() {
+    return s32decode(this.str.slice(0, 11));
+  }
+  clockid() {
+    return s32decode(this.str.slice(11, 13));
+  }
+  formatted() {
+    const str = this.toString();
+    return `${str.slice(0, 4)}-${str.slice(4, 7)}-${str.slice(
+      7,
+      11
+    )}-${str.slice(11, 13)}`;
+  }
+  toString() {
+    return this.str;
+  }
+  compareTo(other) {
+    if (this.str > other.str)
+      return 1;
+    if (this.str < other.str)
+      return -1;
+    return 0;
+  }
+  equals(other) {
+    return this.str === other.str;
+  }
+  newerThan(other) {
+    return this.compareTo(other) > 0;
+  }
+  olderThan(other) {
+    return this.compareTo(other) < 0;
+  }
+};
 
 // ../../node_modules/multiformats/esm/vendor/varint.js
 var encode_1 = encode;
@@ -18095,1054 +18187,6 @@ var DAY = HOUR * 24;
 // ../common-web/src/strings.ts
 var import_graphemer = __toESM(require_lib());
 
-// ../identifier/src/reserved.ts
-var atpSpecific = [
-  "at",
-  "atp",
-  "plc",
-  "pds",
-  "did",
-  "repo",
-  "tid",
-  "nsid",
-  "xrpc",
-  "lex",
-  "lexicon",
-  "bsky",
-  "bluesky",
-  "handle"
-];
-var commonlyReserved = [
-  "about",
-  "abuse",
-  "access",
-  "account",
-  "accounts",
-  "acme",
-  "activate",
-  "activities",
-  "activity",
-  "ad",
-  "add",
-  "address",
-  "adm",
-  "admanager",
-  "admin",
-  "administration",
-  "administrator",
-  "administrators",
-  "admins",
-  "ads",
-  "adsense",
-  "adult",
-  "advertising",
-  "adwords",
-  "affiliate",
-  "affiliatepage",
-  "affiliates",
-  "afp",
-  "ajax",
-  "all",
-  "alpha",
-  "analysis",
-  "analytics",
-  "android",
-  "anon",
-  "anonymous",
-  "answer",
-  "answers",
-  "ap",
-  "api",
-  "apis",
-  "app",
-  "appengine",
-  "appnews",
-  "apps",
-  "archive",
-  "archives",
-  "article",
-  "asdf",
-  "asset",
-  "assets",
-  "auth",
-  "authentication",
-  "avatar",
-  "backup",
-  "bank",
-  "banner",
-  "banners",
-  "base",
-  "beginners",
-  "beta",
-  "billing",
-  "bin",
-  "binaries",
-  "binary",
-  "blackberry",
-  "blog",
-  "blogs",
-  "blogsearch",
-  "board",
-  "book",
-  "bookmark",
-  "bookmarks",
-  "books",
-  "bot",
-  "bots",
-  "bug",
-  "bugs",
-  "business",
-  "buy",
-  "buzz",
-  "cache",
-  "calendar",
-  "call",
-  "campaign",
-  "cancel",
-  "captcha",
-  "career",
-  "careers",
-  "cart",
-  "catalog",
-  "catalogs",
-  "categories",
-  "category",
-  "cdn",
-  "cgi",
-  "cgi-bin",
-  "changelog",
-  "chart",
-  "charts",
-  "chat",
-  "check",
-  "checked",
-  "checking",
-  "checkout",
-  "client",
-  "cliente",
-  "clients",
-  "clients1",
-  "cnarne",
-  "code",
-  "comercial",
-  "comment",
-  "comments",
-  "communities",
-  "community",
-  "company",
-  "compare",
-  "compras",
-  "config",
-  "configuration",
-  "confirm",
-  "confirmation",
-  "connect",
-  "contact",
-  "contacts",
-  "contactus",
-  "contact-us",
-  "contact_us",
-  "content",
-  "contest",
-  "contribute",
-  "contributor",
-  "contributors",
-  "coppa",
-  "copyright",
-  "copyrights",
-  "core",
-  "corp",
-  "countries",
-  "country",
-  "cpanel",
-  "create",
-  "css",
-  "cssproxy",
-  "customise",
-  "customize",
-  "dashboard",
-  "data",
-  "db",
-  "default",
-  "delete",
-  "demo",
-  "design",
-  "designer",
-  "desktop",
-  "destroy",
-  "dev",
-  "devel",
-  "developer",
-  "developers",
-  "devs",
-  "diagram",
-  "diary",
-  "dict",
-  "dictionary",
-  "die",
-  "dir",
-  "directory",
-  "direct_messages",
-  "direct-messages",
-  "dist",
-  "diversity",
-  "dl",
-  "dmca",
-  "doc",
-  "docs",
-  "documentation",
-  "documentations",
-  "documents",
-  "domain",
-  "domains",
-  "donate",
-  "download",
-  "downloads",
-  "e",
-  "e-mail",
-  "earth",
-  "ecommerce",
-  "edit",
-  "edits",
-  "editor",
-  "edu",
-  "education",
-  "email",
-  "embed",
-  "embedded",
-  "employment",
-  "employments",
-  "empty",
-  "enable",
-  "encrypted",
-  "end",
-  "engine",
-  "enterprise",
-  "enterprises",
-  "entries",
-  "entry",
-  "error",
-  "errorlog",
-  "errors",
-  "eval",
-  "event",
-  "example",
-  "examplecommunity",
-  "exampleopenid",
-  "examplesyn",
-  "examplesyndicated",
-  "exampleusername",
-  "exchange",
-  "exit",
-  "explore",
-  "faq",
-  "faqs",
-  "favorite",
-  "favorites",
-  "favourite",
-  "favourites",
-  "feature",
-  "features",
-  "feed",
-  "feedback",
-  "feedburner",
-  "feedproxy",
-  "feeds",
-  "file",
-  "files",
-  "finance",
-  "folder",
-  "folders",
-  "first",
-  "following",
-  "forgot",
-  "form",
-  "forms",
-  "forum",
-  "forums",
-  "founder",
-  "free",
-  "friend",
-  "friends",
-  "ftp",
-  "fuck",
-  "fun",
-  "fusion",
-  "gadget",
-  "gadgets",
-  "game",
-  "games",
-  "gears",
-  "general",
-  "geographic",
-  "get",
-  "gettingstarted",
-  "gift",
-  "gifts",
-  "gist",
-  "git",
-  "github",
-  "gmail",
-  "go",
-  "golang",
-  "goto",
-  "gov",
-  "graph",
-  "graphs",
-  "group",
-  "groups",
-  "guest",
-  "guests",
-  "guide",
-  "guides",
-  "hack",
-  "hacks",
-  "head",
-  "help",
-  "home",
-  "homepage",
-  "host",
-  "hosting",
-  "hostmaster",
-  "hostname",
-  "howto",
-  "how-to",
-  "how_to",
-  "html",
-  "htrnl",
-  "http",
-  "httpd",
-  "https",
-  "i",
-  "iamges",
-  "icon",
-  "icons",
-  "id",
-  "idea",
-  "ideas",
-  "im",
-  "image",
-  "images",
-  "img",
-  "imap",
-  "inbox",
-  "inboxes",
-  "index",
-  "indexes",
-  "info",
-  "information",
-  "inquiry",
-  "intranet",
-  "investor",
-  "investors",
-  "invitation",
-  "invitations",
-  "invite",
-  "invoice",
-  "invoices",
-  "imac",
-  "ios",
-  "ipad",
-  "iphone",
-  "irc",
-  "irnages",
-  "irng",
-  "is",
-  "issue",
-  "issues",
-  "it",
-  "item",
-  "items",
-  "java",
-  "javascript",
-  "job",
-  "jobs",
-  "join",
-  "js",
-  "json",
-  "jump",
-  "kb",
-  "knowledge-base",
-  "knowledgebase",
-  "lab",
-  "labs",
-  "language",
-  "languages",
-  "last",
-  "ldap_status",
-  "ldap-status",
-  "ldapstatus",
-  "legal",
-  "license",
-  "licenses",
-  "link",
-  "links",
-  "linux",
-  "list",
-  "lists",
-  "livejournal",
-  "lj",
-  "local",
-  "locale",
-  "location",
-  "log",
-  "log-in",
-  "log-out",
-  "login",
-  "logout",
-  "logs",
-  "log_in",
-  "log_out",
-  "m",
-  "mac",
-  "macos",
-  "macosx",
-  "mac-os",
-  "mac-os-x",
-  "mac_os_x",
-  "mail",
-  "mailer",
-  "mailing",
-  "main",
-  "maintenance",
-  "manage",
-  "manager",
-  "manual",
-  "map",
-  "maps",
-  "marketing",
-  "master",
-  "me",
-  "media",
-  "member",
-  "members",
-  "memories",
-  "memory",
-  "merchandise",
-  "message",
-  "messages",
-  "messenger",
-  "mg",
-  "microblog",
-  "microblogs",
-  "mine",
-  "mis",
-  "misc",
-  "mms",
-  "mob",
-  "mobile",
-  "model",
-  "models",
-  "money",
-  "movie",
-  "movies",
-  "mp3",
-  "mp4",
-  "msg",
-  "msn",
-  "music",
-  "mx",
-  "my",
-  "mymme",
-  "mysql",
-  "name",
-  "named",
-  "nan",
-  "navi",
-  "navigation",
-  "net",
-  "network",
-  "networks",
-  "new",
-  "news",
-  "newsletter",
-  "nick",
-  "nickname",
-  "nil",
-  "none",
-  "notes",
-  "noticias",
-  "notification",
-  "notifications",
-  "notify",
-  "ns",
-  "ns1",
-  "ns2",
-  "ns3",
-  "ns4",
-  "ns5",
-  "null",
-  "oauth",
-  "oauth-clients",
-  "oauth_clients",
-  "ocsp",
-  "offer",
-  "offers",
-  "official",
-  "old",
-  "online",
-  "openid",
-  "operator",
-  "option",
-  "options",
-  "order",
-  "orders",
-  "org",
-  "organization",
-  "organizations",
-  "other",
-  "overview",
-  "owner",
-  "owners",
-  "p0rn",
-  "pack",
-  "page",
-  "pager",
-  "pages",
-  "paid",
-  "panel",
-  "partner",
-  "partnerpage",
-  "partners",
-  "password",
-  "patch",
-  "pay",
-  "payment",
-  "people",
-  "perl",
-  "person",
-  "phone",
-  "photo",
-  "photoalbum",
-  "photos",
-  "php",
-  "phpmyadmin",
-  "phppgadmin",
-  "phpredisadmin",
-  "pic",
-  "pics",
-  "picture",
-  "pictures",
-  "ping",
-  "pixel",
-  "places",
-  "plan",
-  "plans",
-  "plugin",
-  "plugins",
-  "podcasts",
-  "policies",
-  "policy",
-  "pop",
-  "pop3",
-  "popular",
-  "porn",
-  "portal",
-  "portals",
-  "post",
-  "postfix",
-  "postmaster",
-  "posts",
-  "pr",
-  "pr0n",
-  "premium",
-  "press",
-  "price",
-  "pricing",
-  "principles",
-  "print",
-  "privacy",
-  "privacy-policy",
-  "privacypolicy",
-  "privacy_policy",
-  "private",
-  "prod",
-  "product",
-  "production",
-  "products",
-  "profile",
-  "profiles",
-  "project",
-  "projects",
-  "promo",
-  "promotions",
-  "proxies",
-  "proxy",
-  "pub",
-  "public",
-  "purchase",
-  "purpose",
-  "put",
-  "python",
-  "queries",
-  "query",
-  "radio",
-  "random",
-  "ranking",
-  "read",
-  "reader",
-  "readme",
-  "recent",
-  "recruit",
-  "recruitment",
-  "redirect",
-  "register",
-  "registration",
-  "release",
-  "remove",
-  "replies",
-  "report",
-  "reports",
-  "repositories",
-  "repository",
-  "req",
-  "request",
-  "requests",
-  "research",
-  "reset",
-  "resolve",
-  "resolver",
-  "review",
-  "rnail",
-  "rnicrosoft",
-  "roc",
-  "root",
-  "rss",
-  "ruby",
-  "rule",
-  "sag",
-  "sale",
-  "sales",
-  "sample",
-  "samples",
-  "sandbox",
-  "save",
-  "scholar",
-  "school",
-  "schools",
-  "script",
-  "scripts",
-  "search",
-  "secure",
-  "security",
-  "self",
-  "seminars",
-  "send",
-  "server",
-  "server-info",
-  "server_info",
-  "server-status",
-  "server_status",
-  "servers",
-  "service",
-  "services",
-  "session",
-  "sessions",
-  "setting",
-  "settings",
-  "setup",
-  "share",
-  "shop",
-  "shopping",
-  "shortcut",
-  "shortcuts",
-  "show",
-  "sign-in",
-  "sign-up",
-  "signin",
-  "signout",
-  "signup",
-  "sign_in",
-  "sign_up",
-  "site",
-  "sitemap",
-  "sitemaps",
-  "sitenews",
-  "sites",
-  "sketchup",
-  "sky",
-  "slash",
-  "slashinvoice",
-  "slut",
-  "smartphone",
-  "sms",
-  "smtp",
-  "soap",
-  "software",
-  "sorry",
-  "source",
-  "spec",
-  "special",
-  "spreadsheet",
-  "spreadsheets",
-  "sql",
-  "src",
-  "srntp",
-  "ssh",
-  "ssl",
-  "ssladmin",
-  "ssladministrator",
-  "sslwebmaster",
-  "ssytem",
-  "staff",
-  "stage",
-  "staging",
-  "start",
-  "stat",
-  "state",
-  "static",
-  "statistics",
-  "stats",
-  "status",
-  "store",
-  "stores",
-  "stories",
-  "style",
-  "styleguide",
-  "styles",
-  "stylesheet",
-  "stylesheets",
-  "subdomain",
-  "subscribe",
-  "subscription",
-  "subscriptions",
-  "suggest",
-  "suggestqueries",
-  "support",
-  "survey",
-  "surveys",
-  "surveytool",
-  "svn",
-  "swf",
-  "syn",
-  "sync",
-  "syndicated",
-  "sys",
-  "sysadmin",
-  "sysadministrator",
-  "sysadmins",
-  "system",
-  "tablet",
-  "tablets",
-  "tag",
-  "tags",
-  "talk",
-  "talkgadget",
-  "task",
-  "tasks",
-  "team",
-  "teams",
-  "tech",
-  "telnet",
-  "term",
-  "terms",
-  "terms-of-service",
-  "termsofservice",
-  "terms_of_service",
-  "test",
-  "testing",
-  "tests",
-  "text",
-  "theme",
-  "themes",
-  "thread",
-  "threads",
-  "ticket",
-  "tickets",
-  "tmp",
-  "todo",
-  "to-do",
-  "to_do",
-  "toml",
-  "tool",
-  "toolbar",
-  "toolbars",
-  "tools",
-  "top",
-  "topic",
-  "topics",
-  "tos",
-  "tour",
-  "trac",
-  "translate",
-  "trace",
-  "translation",
-  "translations",
-  "translator",
-  "trends",
-  "tutorial",
-  "tux",
-  "tv",
-  "twitter",
-  "txt",
-  "ul",
-  "undef",
-  "unfollow",
-  "unsubscribe",
-  "update",
-  "updates",
-  "upgrade",
-  "upgrades",
-  "upi",
-  "upload",
-  "uploads",
-  "url",
-  "usage",
-  "user",
-  "username",
-  "usernames",
-  "users",
-  "uuid",
-  "validation",
-  "validations",
-  "ver",
-  "version",
-  "video",
-  "videos",
-  "video-stats",
-  "visitor",
-  "visitors",
-  "voice",
-  "volunteer",
-  "volunteers",
-  "w",
-  "watch",
-  "wave",
-  "weather",
-  "web",
-  "webdisk",
-  "webhook",
-  "webhooks",
-  "webmail",
-  "webmaster",
-  "webmasters",
-  "webrnail",
-  "website",
-  "websites",
-  "welcome",
-  "whm",
-  "whois",
-  "widget",
-  "widgets",
-  "wifi",
-  "wiki",
-  "wikis",
-  "win",
-  "windows",
-  "word",
-  "work",
-  "works",
-  "workshop",
-  "wpad",
-  "ww",
-  "wws",
-  "www",
-  "wwws",
-  "wwww",
-  "xfn",
-  "xhtml",
-  "xhtrnl",
-  "xml",
-  "xmpp",
-  "xpg",
-  "xxx",
-  "yaml",
-  "year",
-  "yml",
-  "you",
-  "yourdomain",
-  "yourname",
-  "yoursite",
-  "yourusername"
-];
-var famousAccounts = [
-  "10ronaldinho",
-  "3gerardpique",
-  "aclu",
-  "adele",
-  "akshaykumar",
-  "aliaa08",
-  "aliciakeys",
-  "amitshah",
-  "andresiniesta8",
-  "anushkasharma",
-  "arianagrande",
-  "arrahman",
-  "arvindkejriwal",
-  "avrillavigne",
-  "barackobama",
-  "bbcbreaking",
-  "bbcworld",
-  "beingsalmankhan",
-  "billgates",
-  "britneyspears",
-  "brunomars",
-  "bts_bighit",
-  "bts_twt",
-  "championsleague",
-  "chrisbrown",
-  "cnnbrk",
-  "coldplay",
-  "conanobrien",
-  "cristiano",
-  "danieltosh",
-  "davidguetta",
-  "ddlovato",
-  "deepikapadukone",
-  "drake",
-  "elisapie",
-  "ellendegeneres",
-  "elonmusk",
-  "eminem",
-  "emmawatson",
-  "fcbarcelona",
-  "foxnews",
-  "harry_styles",
-  "hillaryclinton",
-  "iamsrk",
-  "ihrithik",
-  "imvkohli",
-  "instagram",
-  "jimmyfallon",
-  "jlo",
-  "joebiden",
-  "jtimberlake",
-  "justinbieber",
-  "kaka",
-  "kanyewest",
-  "katyperry",
-  "kendalljenner",
-  "kevinhart4real",
-  "khloekardashian",
-  "kimkardashian",
-  "kingjames",
-  "kourtneykardash",
-  "kyliejenner",
-  "ladygaga",
-  "liampayne",
-  "liltunechi",
-  "manutd",
-  "mariahcarey",
-  "mileycyrus",
-  "mohamadalarefe",
-  "narendramodi",
-  "nasa",
-  "nba",
-  "neymarjr",
-  "nfl",
-  "niallofficial",
-  "nickiminaj",
-  "npr",
-  "nytimes",
-  "onedirection",
-  "oprah",
-  "pink",
-  "pitbull",
-  "playstation",
-  "pmoindia",
-  "premierleague",
-  "priyankachopra",
-  "realdonaldtrump",
-  "ricky_martin",
-  "rihanna",
-  "sachin_rt",
-  "selenagomez",
-  "shakira",
-  "shawnmendes",
-  "sportscenter",
-  "srbachchan",
-  "subhisharma100",
-  "taylorswift13",
-  "theeconomist",
-  "twitter",
-  "virendersehwag",
-  "whitehouse45",
-  "wizkhalifa",
-  "youtube",
-  "zaynmalik",
-  "beyonce",
-  "billieeilish",
-  "leomessi",
-  "natgeo",
-  "nike",
-  "snoopdogg",
-  "taylorswift",
-  "therock",
-  "10downingstreet",
-  "aoc",
-  "carterjwm",
-  "dril",
-  "gretathunberg",
-  "kamalaharris",
-  "kremlinrussia_e",
-  "potus",
-  "rondesantisfl",
-  "ukraine",
-  "washingtonpost",
-  "yousuck2020",
-  "zelenskyyua",
-  "akiko_lawson",
-  "ariyoshihiroiki",
-  "asahi",
-  "dozle_official",
-  "famima_now",
-  "ff_xiv_jp",
-  "fujitv",
-  "gigazine",
-  "hajimesyacho",
-  "hikakin",
-  "jocx",
-  "jotx",
-  "kiyo_saiore",
-  "mainichi",
-  "matsu_bouzu",
-  "naomiosaka",
-  "nhk",
-  "nikkei",
-  "nintendo",
-  "ntv",
-  "oowareware1945",
-  "pamyurin",
-  "poke_times",
-  "rolaworld",
-  "seikintv",
-  "starbucksjapan",
-  "tbs",
-  "tbs_pr",
-  "tvasahi",
-  "tvtokyo",
-  "yokoono",
-  "yomiuri_online",
-  "brasildefato",
-  "claudialeitte",
-  "correio",
-  "em_com",
-  "estadao",
-  "folha",
-  "gazetadopovo",
-  "ivetesangalo",
-  "jairbolsonaro",
-  "jornaldobrasil",
-  "jornaloglobo",
-  "lucianohuck",
-  "lulaoficial",
-  "marcosmion",
-  "paulocoelho",
-  "portalr7",
-  "rede_globo",
-  "zerohora"
-];
-var reservedSubdomains = [
-  ...atpSpecific,
-  ...commonlyReserved,
-  ...famousAccounts
-].reduce((acc, cur) => {
-  return {
-    ...acc,
-    [cur]: true
-  };
-}, {});
-
 // ../lexicon/src/validators/formats.ts
 var import_iso_datestring_validator = __toESM(require_dist());
 
@@ -23596,26 +22640,46 @@ var cid_set_default = CidSet;
 // src/types.ts
 var unsignedCommit = z.object({
   did: z.string(),
-  version: z.number(),
-  prev: schema.cid.nullable(),
-  data: schema.cid
+  version: z.literal(3),
+  data: schema.cid,
+  rev: z.string(),
+  prev: schema.cid.nullable().optional()
 });
 var commit = z.object({
   did: z.string(),
-  version: z.number(),
-  prev: schema.cid.nullable(),
+  version: z.literal(3),
   data: schema.cid,
+  rev: z.string(),
+  prev: schema.cid.nullable().optional(),
   sig: schema.bytes
 });
+var legacyV2Commit = z.object({
+  did: z.string(),
+  version: z.literal(2),
+  data: schema.cid,
+  rev: z.string().optional(),
+  prev: schema.cid.nullable(),
+  sig: schema.bytes
+});
+var versionedCommit = z.discriminatedUnion("version", [
+  commit,
+  legacyV2Commit
+]);
 var schema2 = {
   ...schema,
-  commit
+  commit,
+  legacyV2Commit,
+  versionedCommit
 };
 var def2 = {
   ...def,
   commit: {
     name: "commit",
     schema: schema2.commit
+  },
+  versionedCommit: {
+    name: "versioned_commit",
+    schema: schema2.versionedCommit
   }
 };
 var WriteOpAction = /* @__PURE__ */ ((WriteOpAction2) => {
@@ -23644,7 +22708,8 @@ __export(util_exports2, {
 // ../crypto/src/const.ts
 var P256_DID_PREFIX = new Uint8Array([128, 36]);
 var SECP256K1_DID_PREFIX = new Uint8Array([231, 1]);
-var BASE58_DID_PREFIX = "did:key:z";
+var BASE58_MULTIBASE_PREFIX = "z";
+var DID_KEY_PREFIX = "did:key:";
 var P256_JWT_ALG = "ES256";
 var SECP256K1_JWT_ALG = "ES256K";
 
@@ -25526,12 +24591,12 @@ var plugins = [plugin_default, plugin_default2];
 var plugins_default = plugins;
 
 // ../crypto/src/did.ts
-var parseDidKey = (did2) => {
-  if (!did2.startsWith(BASE58_DID_PREFIX)) {
-    throw new Error(`Incorrect prefix for did:key: ${did2}`);
+var parseMultikey = (multikey) => {
+  if (!multikey.startsWith(BASE58_MULTIBASE_PREFIX)) {
+    throw new Error(`Incorrect prefix for multikey: ${multikey}`);
   }
   const prefixedBytes = fromString2(
-    did2.slice(BASE58_DID_PREFIX.length),
+    multikey.slice(BASE58_MULTIBASE_PREFIX.length),
     "base58btc"
   );
   const plugin = plugins_default.find((p) => hasPrefix(prefixedBytes, p.prefix));
@@ -25549,6 +24614,12 @@ var parseDidKey = (did2) => {
     keyBytes
   };
 };
+var parseDidKey = (did2) => {
+  if (!did2.startsWith(DID_KEY_PREFIX)) {
+    throw new Error(`Incorrect prefix for did:key: ${did2}`);
+  }
+  return parseMultikey(did2.slice(DID_KEY_PREFIX.length));
+};
 var hasPrefix = (bytes3, prefix) => {
   return equals3(prefix, bytes3.subarray(0, prefix.byteLength));
 };
@@ -25709,14 +24780,6 @@ var MissingBlocksError = class extends Error {
     this.cids = cids;
   }
 };
-var MissingCommitBlocksError = class extends Error {
-  constructor(commit2, cids) {
-    const cidStr = cids.map((c) => c.toString());
-    super(`missing blocks for commit ${commit2.toString()}: ${cidStr}`);
-    this.commit = commit2;
-    this.cids = cids;
-  }
-};
 var UnexpectedObjectError = class extends Error {
   constructor(cid2, def3) {
     super(`unexpected object at ${cid2.toString()}, expected: ${def3}`);
@@ -26266,93 +25329,6 @@ var CarWriter2 = class extends CarWriter {
   }
 };
 
-// src/data-diff.ts
-var DataDiff = class {
-  constructor() {
-    this.adds = {};
-    this.updates = {};
-    this.deletes = {};
-    this.newCids = new cid_set_default();
-    this.removedCids = new cid_set_default();
-  }
-  static async of(curr, prev) {
-    return mstDiff(curr, prev);
-  }
-  recordAdd(key, cid2) {
-    this.adds[key] = { key, cid: cid2 };
-    this.newCids.add(cid2);
-  }
-  recordUpdate(key, prev, cid2) {
-    this.updates[key] = { key, prev, cid: cid2 };
-    this.newCids.add(cid2);
-  }
-  recordDelete(key, cid2) {
-    this.deletes[key] = { key, cid: cid2 };
-  }
-  recordNewCid(cid2) {
-    if (this.removedCids.has(cid2)) {
-      this.removedCids.delete(cid2);
-    } else {
-      this.newCids.add(cid2);
-    }
-  }
-  recordRemovedCid(cid2) {
-    if (this.newCids.has(cid2)) {
-      this.newCids.delete(cid2);
-    } else {
-      this.removedCids.add(cid2);
-    }
-  }
-  addDiff(diff) {
-    for (const add of diff.addList()) {
-      if (this.deletes[add.key]) {
-        const del = this.deletes[add.key];
-        if (del.cid !== add.cid) {
-          this.recordUpdate(add.key, del.cid, add.cid);
-        }
-        delete this.deletes[add.key];
-      } else {
-        this.recordAdd(add.key, add.cid);
-      }
-    }
-    for (const update of diff.updateList()) {
-      this.recordUpdate(update.key, update.prev, update.cid);
-      delete this.adds[update.key];
-      delete this.deletes[update.key];
-    }
-    for (const del of diff.deleteList()) {
-      if (this.adds[del.key]) {
-        delete this.adds[del.key];
-      } else {
-        delete this.updates[del.key];
-        this.recordDelete(del.key, del.cid);
-      }
-    }
-    this.newCids.addSet(diff.newCids);
-  }
-  addList() {
-    return Object.values(this.adds);
-  }
-  updateList() {
-    return Object.values(this.updates);
-  }
-  deleteList() {
-    return Object.values(this.deletes);
-  }
-  newCidList() {
-    return this.newCids.toList();
-  }
-  updatedKeys() {
-    const keys = [
-      ...Object.keys(this.adds),
-      ...Object.keys(this.updates),
-      ...Object.keys(this.deletes)
-    ];
-    return [...new Set(keys)];
-  }
-};
-var data_diff_default = DataDiff;
-
 // src/util.ts
 async function* verifyIncomingCarBlocks(car) {
   for await (const block of car) {
@@ -26408,27 +25384,6 @@ var readCarWithRoot = async (bytes3) => {
     blocks
   };
 };
-var getWriteLog = async (storage, latest, earliest) => {
-  const commits = await storage.getCommitPath(latest, earliest);
-  if (!commits)
-    throw new Error("Could not find shared history");
-  const heads = await Promise.all(commits.map((c) => repo_default.load(storage, c)));
-  let prev = await MST.create(storage);
-  const msts = heads.map((h) => h.data);
-  const diffs = [];
-  for (const mst of msts) {
-    diffs.push(await data_diff_default.of(mst, prev));
-    prev = mst;
-  }
-  const fullDiff = collapseDiffs(diffs);
-  const diffBlocks = await storage.getBlocks(fullDiff.newCidList());
-  if (diffBlocks.missing.length > 0) {
-    throw new MissingBlocksError("write op log", diffBlocks.missing);
-  }
-  return Promise.all(
-    diffs.map((diff) => diffToWriteDescripts(diff, diffBlocks.blocks))
-  );
-};
 var diffToWriteDescripts = (diff, blocks) => {
   return Promise.all([
     ...diff.addList().map(async (add) => {
@@ -26465,54 +25420,16 @@ var diffToWriteDescripts = (diff, blocks) => {
     })
   ]);
 };
-var collapseWriteLog = (log) => {
-  const creates = {};
-  const updates = {};
-  const deletes = {};
-  for (const commit2 of log) {
-    for (const op of commit2) {
-      const key = op.collection + "/" + op.rkey;
-      if (op.action === "create" /* Create */) {
-        const del = deletes[key];
-        if (del) {
-          if (del.cid !== op.cid) {
-            updates[key] = {
-              ...op,
-              action: "update" /* Update */,
-              prev: del.cid
-            };
-          }
-          delete deletes[key];
-        } else {
-          creates[key] = op;
-        }
-      } else if (op.action === "update" /* Update */) {
-        updates[key] = op;
-        delete creates[key];
-        delete deletes[key];
-      } else if (op.action === "delete" /* Delete */) {
-        if (creates[key]) {
-          delete creates[key];
-        } else {
-          delete updates[key];
-          deletes[key] = op;
-        }
-      } else {
-        throw new Error(`unknown action: ${op}`);
-      }
+var ensureCreates = (descripts) => {
+  const creates = [];
+  for (const descript of descripts) {
+    if (descript.action !== "create" /* Create */) {
+      throw new Error(`Unexpected action: ${descript.action}`);
+    } else {
+      creates.push(descript);
     }
   }
-  return [
-    ...Object.values(creates),
-    ...Object.values(updates),
-    ...Object.values(deletes)
-  ];
-};
-var collapseDiffs = (diffs) => {
-  return diffs.reduce((acc, cur) => {
-    acc.addDiff(cur);
-    return acc;
-  }, new data_diff_default());
+  return creates;
 };
 var parseDataKey = (key) => {
   const parts = key.split("/");
@@ -26552,6 +25469,17 @@ var cborToLexRecord = (val) => {
 var cidForRecord = async (val) => {
   return cidForCbor(lexToIpld(val));
 };
+var ensureV3Commit = (commit2) => {
+  if (commit2.version === 3) {
+    return commit2;
+  } else {
+    return {
+      ...commit2,
+      version: 3,
+      rev: commit2.rev ?? TID.nextStr()
+    };
+  }
+};
 
 // src/parse.ts
 var getAndParseRecord = async (blocks, cid2) => {
@@ -26640,6 +25568,12 @@ var MST = class {
   async getPointer() {
     if (!this.outdatedPointer)
       return this.pointer;
+    const { cid: cid2 } = await this.serialize();
+    this.pointer = cid2;
+    this.outdatedPointer = false;
+    return this.pointer;
+  }
+  async serialize() {
     let entries = await this.getEntries();
     const outdated = entries.filter(
       (e) => e.isTree() && e.outdatedPointer
@@ -26648,9 +25582,12 @@ var MST = class {
       await Promise.all(outdated.map((e) => e.getPointer()));
       entries = await this.getEntries();
     }
-    this.pointer = await cidForEntries(entries);
-    this.outdatedPointer = false;
-    return this.pointer;
+    const data = serializeNodeData(entries);
+    const block = await dataToCborBlock(data);
+    return {
+      cid: block.cid,
+      bytes: block.bytes
+    };
   }
   async getLayer() {
     this.layer = await this.attemptGetLayer();
@@ -27151,6 +26088,95 @@ var Leaf = class {
   }
 };
 
+// src/data-diff.ts
+var DataDiff = class {
+  constructor() {
+    this.adds = {};
+    this.updates = {};
+    this.deletes = {};
+    this.newMstBlocks = new block_map_default();
+    this.newLeafCids = new cid_set_default();
+    this.removedCids = new cid_set_default();
+  }
+  static async of(curr, prev) {
+    return mstDiff(curr, prev);
+  }
+  async nodeAdd(node) {
+    if (node.isLeaf()) {
+      this.leafAdd(node.key, node.value);
+    } else {
+      const data = await node.serialize();
+      this.treeAdd(data.cid, data.bytes);
+    }
+  }
+  async nodeDelete(node) {
+    if (node.isLeaf()) {
+      const key = node.key;
+      const cid2 = node.value;
+      this.deletes[key] = { key, cid: cid2 };
+      this.removedCids.add(cid2);
+    } else {
+      const cid2 = await node.getPointer();
+      this.treeDelete(cid2);
+    }
+  }
+  leafAdd(key, cid2) {
+    this.adds[key] = { key, cid: cid2 };
+    if (this.removedCids.has(cid2)) {
+      this.removedCids.delete(cid2);
+    } else {
+      this.newLeafCids.add(cid2);
+    }
+  }
+  leafUpdate(key, prev, cid2) {
+    if (prev.equals(cid2))
+      return;
+    this.updates[key] = { key, prev, cid: cid2 };
+    this.removedCids.add(prev);
+    this.newLeafCids.add(cid2);
+  }
+  leafDelete(key, cid2) {
+    this.deletes[key] = { key, cid: cid2 };
+    if (this.newLeafCids.has(cid2)) {
+      this.newLeafCids.delete(cid2);
+    } else {
+      this.removedCids.add(cid2);
+    }
+  }
+  treeAdd(cid2, bytes3) {
+    if (this.removedCids.has(cid2)) {
+      this.removedCids.delete(cid2);
+    } else {
+      this.newMstBlocks.set(cid2, bytes3);
+    }
+  }
+  treeDelete(cid2) {
+    if (this.newMstBlocks.has(cid2)) {
+      this.newMstBlocks.delete(cid2);
+    } else {
+      this.removedCids.add(cid2);
+    }
+  }
+  addList() {
+    return Object.values(this.adds);
+  }
+  updateList() {
+    return Object.values(this.updates);
+  }
+  deleteList() {
+    return Object.values(this.deletes);
+  }
+  updatedKeys() {
+    const keys = [
+      ...Object.keys(this.adds),
+      ...Object.keys(this.updates),
+      ...Object.keys(this.deletes)
+    ];
+    return [...new Set(keys)];
+  }
+};
+var data_diff_default = DataDiff;
+
 // src/mst/walker.ts
 var MstWalker = class {
   constructor(root) {
@@ -27249,11 +26275,7 @@ var walker_default = MstWalker;
 var nullDiff = async (tree2) => {
   const diff = new DataDiff();
   for await (const entry of tree2.walk()) {
-    if (entry.isLeaf()) {
-      diff.recordAdd(entry.key, entry.value);
-    } else {
-      diff.recordNewCid(entry.pointer);
-    }
+    await diff.nodeAdd(entry);
   }
   return diff;
 };
@@ -27268,21 +26290,11 @@ var mstDiff = async (curr, prev) => {
   const rightWalker = new walker_default(curr);
   while (!leftWalker.status.done || !rightWalker.status.done) {
     if (leftWalker.status.done && !rightWalker.status.done) {
-      const node = rightWalker.status.curr;
-      if (node.isLeaf()) {
-        diff.recordAdd(node.key, node.value);
-      } else {
-        diff.recordNewCid(node.pointer);
-      }
+      await diff.nodeAdd(rightWalker.status.curr);
       await rightWalker.advance();
       continue;
     } else if (!leftWalker.status.done && rightWalker.status.done) {
-      const node = leftWalker.status.curr;
-      if (node.isLeaf()) {
-        diff.recordDelete(node.key, node.value);
-      } else {
-        diff.recordRemovedCid(node.pointer);
-      }
+      await diff.nodeDelete(leftWalker.status.curr);
       await leftWalker.advance();
       continue;
     }
@@ -27295,42 +26307,34 @@ var mstDiff = async (curr, prev) => {
     if (left.isLeaf() && right.isLeaf()) {
       if (left.key === right.key) {
         if (!left.value.equals(right.value)) {
-          diff.recordUpdate(left.key, left.value, right.value);
+          diff.leafUpdate(left.key, left.value, right.value);
         }
         await leftWalker.advance();
         await rightWalker.advance();
       } else if (left.key < right.key) {
-        diff.recordDelete(left.key, left.value);
+        diff.leafDelete(left.key, left.value);
         await leftWalker.advance();
       } else {
-        diff.recordAdd(right.key, right.value);
+        diff.leafAdd(right.key, right.value);
         await rightWalker.advance();
       }
       continue;
     }
     if (leftWalker.layer() > rightWalker.layer()) {
       if (left.isLeaf()) {
-        if (right.isLeaf()) {
-          diff.recordAdd(right.key, right.value);
-        } else {
-          diff.recordNewCid(right.pointer);
-        }
+        await diff.nodeAdd(right);
         await rightWalker.advance();
       } else {
-        diff.recordRemovedCid(left.pointer);
+        await diff.nodeDelete(left);
         await leftWalker.stepInto();
       }
       continue;
     } else if (leftWalker.layer() < rightWalker.layer()) {
       if (right.isLeaf()) {
-        if (left.isLeaf()) {
-          diff.recordDelete(left.key, left.value);
-        } else {
-          diff.recordRemovedCid(left.pointer);
-        }
+        await diff.nodeDelete(left);
         await leftWalker.advance();
       } else {
-        diff.recordNewCid(right.pointer);
+        await diff.nodeAdd(right);
         await rightWalker.stepInto();
       }
       continue;
@@ -27340,19 +26344,19 @@ var mstDiff = async (curr, prev) => {
         await leftWalker.stepOver();
         await rightWalker.stepOver();
       } else {
-        diff.recordNewCid(right.pointer);
-        diff.recordRemovedCid(left.pointer);
+        await diff.nodeAdd(right);
+        await diff.nodeDelete(left);
         await leftWalker.stepInto();
         await rightWalker.stepInto();
       }
       continue;
     }
     if (left.isLeaf() && right.isTree()) {
-      diff.recordNewCid(right.pointer);
+      await diff.nodeAdd(right);
       await rightWalker.stepInto();
       continue;
     } else if (left.isTree() && right.isLeaf()) {
-      diff.recordRemovedCid(left.pointer);
+      await diff.nodeDelete(left);
       await leftWalker.stepInto();
       continue;
     }
@@ -27374,13 +26378,13 @@ var ReadableRepo = class {
     this.cid = params2.cid;
   }
   static async load(storage, commitCid) {
-    const commit2 = await storage.readObj(commitCid, def2.commit);
+    const commit2 = await storage.readObj(commitCid, def2.versionedCommit);
     const data = await MST.load(storage, commit2.data);
     logger_default.info({ did: commit2.did }, "loaded repo for");
     return new ReadableRepo({
       storage,
       data,
-      commit: commit2,
+      commit: ensureV3Commit(commit2),
       cid: commitCid
     });
   }
@@ -27430,27 +26434,33 @@ var Repo = class extends ReadableRepo {
       const dataKey = formatDataKey(record.collection, record.rkey);
       data = await data.add(dataKey, cid2);
     }
-    const unstoredData = await data.getUnstoredBlocks();
-    newBlocks.addMap(unstoredData.blocks);
+    const dataCid = await data.getPointer();
+    const diff = await data_diff_default.of(data, null);
+    newBlocks.addMap(diff.newMstBlocks);
+    const rev = TID.nextStr();
     const commit2 = await signCommit(
       {
         did: did2,
-        version: 2,
+        version: 3,
+        rev,
         prev: null,
-        data: unstoredData.root
+        data: dataCid
       },
       keypair
     );
     const commitCid = await newBlocks.add(commit2);
     return {
-      commit: commitCid,
+      cid: commitCid,
+      rev,
+      since: null,
       prev: null,
-      blocks: newBlocks
+      newBlocks,
+      removedCids: diff.removedCids
     };
   }
   static async createFromCommit(storage, commit2) {
     await storage.applyCommit(commit2);
-    return Repo.load(storage, commit2.commit);
+    return Repo.load(storage, commit2.cid);
   }
   static async create(storage, did2, keypair, initialWrites = []) {
     const commit2 = await Repo.formatInitCommit(
@@ -27462,31 +26472,31 @@ var Repo = class extends ReadableRepo {
     return Repo.createFromCommit(storage, commit2);
   }
   static async load(storage, cid2) {
-    const commitCid = cid2 || await storage.getHead();
+    const commitCid = cid2 || await storage.getRoot();
     if (!commitCid) {
       throw new Error("No cid provided and none in storage");
     }
-    const commit2 = await storage.readObj(commitCid, def2.commit);
+    const commit2 = await storage.readObj(commitCid, def2.versionedCommit);
     const data = await MST.load(storage, commit2.data);
     logger_default.info({ did: commit2.did }, "loaded repo for");
     return new Repo({
       storage,
       data,
-      commit: commit2,
+      commit: ensureV3Commit(commit2),
       cid: commitCid
     });
   }
   async formatCommit(toWrite, keypair) {
     const writes = Array.isArray(toWrite) ? toWrite : [toWrite];
-    const commitBlocks = new block_map_default();
+    const leaves = new block_map_default();
     let data = this.data;
     for (const write of writes) {
       if (write.action === "create" /* Create */) {
-        const cid2 = await commitBlocks.add(write.record);
+        const cid2 = await leaves.add(write.record);
         const dataKey = write.collection + "/" + write.rkey;
         data = await data.add(dataKey, cid2);
       } else if (write.action === "update" /* Update */) {
-        const cid2 = await commitBlocks.add(write.record);
+        const cid2 = await leaves.add(write.record);
         const dataKey = write.collection + "/" + write.rkey;
         data = await data.update(dataKey, cid2);
       } else if (write.action === "delete" /* Delete */) {
@@ -27494,73 +26504,50 @@ var Repo = class extends ReadableRepo {
         data = await data.delete(dataKey);
       }
     }
-    const unstoredData = await data.getUnstoredBlocks();
-    commitBlocks.addMap(unstoredData.blocks);
+    const dataCid = await data.getPointer();
     const diff = await data_diff_default.of(data, this.data);
-    const found = commitBlocks.getMany(diff.newCidList());
-    if (found.missing.length > 0) {
-      const fromStorage = await this.storage.getBlocks(found.missing);
-      if (fromStorage.missing.length > 0) {
-        throw new Error(
-          "Could not find block for commit in Datastore or storage"
-        );
-      }
-      commitBlocks.addMap(fromStorage.blocks);
-    }
+    const newBlocks = diff.newMstBlocks;
+    const removedCids = diff.removedCids;
+    const addedLeaves = leaves.getMany(diff.newLeafCids.toList());
+    if (addedLeaves.missing.length > 0) {
+      throw new Error(`Missing leaf blocks: ${addedLeaves.missing}`);
+    }
+    newBlocks.addMap(addedLeaves.blocks);
+    const rev = TID.nextStr(this.commit.rev);
     const commit2 = await signCommit(
       {
         did: this.did,
-        version: 2,
-        prev: this.cid,
-        data: unstoredData.root
+        version: 3,
+        rev,
+        prev: null,
+        data: dataCid
       },
       keypair
     );
-    const commitCid = await commitBlocks.add(commit2);
+    const commitCid = await newBlocks.add(commit2);
+    if (commitCid.equals(this.cid)) {
+      newBlocks.delete(commitCid);
+    } else {
+      removedCids.add(this.cid);
+    }
     return {
-      commit: commitCid,
+      cid: commitCid,
+      rev,
+      since: this.commit.rev,
       prev: this.cid,
-      blocks: commitBlocks
+      newBlocks,
+      removedCids
     };
   }
   async applyCommit(commitData) {
     await this.storage.applyCommit(commitData);
-    return Repo.load(this.storage, commitData.commit);
+    return Repo.load(this.storage, commitData.cid);
   }
   async applyWrites(toWrite, keypair) {
     const commit2 = await this.formatCommit(toWrite, keypair);
     return this.applyCommit(commit2);
   }
-  async formatRebase(keypair) {
-    const preservedCids = await this.data.allCids();
-    const blocks = new block_map_default();
-    const commit2 = await signCommit(
-      {
-        did: this.did,
-        version: 2,
-        prev: null,
-        data: this.commit.data
-      },
-      keypair
-    );
-    const commitCid = await blocks.add(commit2);
-    return {
-      commit: commitCid,
-      rebased: this.cid,
-      blocks,
-      preservedCids: preservedCids.toList()
-    };
-  }
-  async applyRebase(rebase) {
-    await this.storage.applyRebase(rebase);
-    return Repo.load(this.storage, rebase.commit);
-  }
-  async rebase(keypair) {
-    const rebaseData = await this.formatRebase(keypair);
-    return this.applyRebase(rebaseData);
-  }
 };
-var repo_default = Repo;
 
 // src/storage/readable-blockstore.ts
 var ReadableBlockstore = class {
@@ -27598,39 +26585,18 @@ var ReadableBlockstore = class {
 };
 var readable_blockstore_default = ReadableBlockstore;
 
-// src/storage/repo-storage.ts
-var RepoStorage = class extends readable_blockstore_default {
-  async applyCommit(commit2) {
-    await Promise.all([
-      this.indexCommits([commit2]),
-      this.updateHead(commit2.commit, commit2.prev)
-    ]);
-  }
-  async getCommits(latest, earliest) {
-    const commitPath = await this.getCommitPath(latest, earliest);
-    if (!commitPath)
-      return null;
-    const blocksByCommit = await this.getBlocksForCommits(commitPath);
-    return commitPath.map((commit2) => ({
-      commit: commit2,
-      blocks: blocksByCommit[commit2.toString()] || new block_map_default()
-    }));
-  }
-};
-var repo_storage_default = RepoStorage;
-
 // src/storage/memory-blockstore.ts
-var MemoryBlockstore = class extends repo_storage_default {
+var MemoryBlockstore = class extends readable_blockstore_default {
   constructor(blocks) {
     super();
-    this.head = null;
+    this.root = null;
     this.blocks = new block_map_default();
     if (blocks) {
       this.blocks.addMap(blocks);
     }
   }
-  async getHead() {
-    return this.head;
+  async getRoot() {
+    return this.root;
   }
   async getBytes(cid2) {
     return this.blocks.get(cid2) || null;
@@ -27647,68 +26613,18 @@ var MemoryBlockstore = class extends repo_storage_default {
   async putMany(blocks) {
     this.blocks.addMap(blocks);
   }
-  async indexCommits(commits) {
-    commits.forEach((commit2) => {
-      this.blocks.addMap(commit2.blocks);
-    });
-  }
-  async updateHead(cid2, _prev) {
-    this.head = cid2;
+  async updateRoot(cid2) {
+    this.root = cid2;
   }
   async applyCommit(commit2) {
-    this.blocks.addMap(commit2.blocks);
-    this.head = commit2.commit;
-  }
-  async getCommitPath(latest, earliest) {
-    let curr = latest;
-    const path = [];
-    while (curr !== null) {
-      path.push(curr);
-      const commit2 = await this.readObj(curr, def2.commit);
-      if (!earliest && commit2.prev === null) {
-        return path.reverse();
-      } else if (earliest && commit2.prev.equals(earliest)) {
-        return path.reverse();
-      }
-      curr = commit2.prev;
-    }
-    return null;
-  }
-  async getBlocksForCommits(commits) {
-    const commitData = {};
-    let prevData = null;
-    for (const commitCid of commits) {
-      const commit2 = await this.readObj(commitCid, def2.commit);
-      const data = await MST.load(this, commit2.data);
-      const diff = await data_diff_default.of(data, prevData);
-      const { blocks, missing } = await this.getBlocks([
-        commitCid,
-        ...diff.newCidList()
-      ]);
-      if (missing.length > 0) {
-        throw new MissingCommitBlocksError(commitCid, missing);
-      }
-      commitData[commitCid.toString()] = blocks;
-      prevData = data;
-    }
-    return commitData;
-  }
-  async applyRebase(rebase) {
-    this.putMany(rebase.blocks);
-    const allCids = new cid_set_default([
-      ...rebase.preservedCids,
-      ...rebase.blocks.cids()
-    ]);
-    const toDelete = [];
-    this.blocks.forEach((_bytes, cid2) => {
-      if (!allCids.has(cid2)) {
-        toDelete.push(cid2);
-      }
-    });
-    for (const cid2 of toDelete) {
+    this.root = commit2.cid;
+    const rmCids = commit2.removedCids.toList();
+    for (const cid2 of rmCids) {
       this.blocks.delete(cid2);
     }
-    await this.updateHead(rebase.commit, null);
+    commit2.newBlocks.forEach((bytes3, cid2) => {
+      this.blocks.set(cid2, bytes3);
+    });
   }
   async sizeInBytes() {
     let total = 0;
@@ -27749,124 +26665,80 @@ var SyncStorage = class extends readable_blockstore_default {
     return await this.staged.has(cid2) || await this.saved.has(cid2);
   }
 };
-var sync_storage_default = SyncStorage;
 
 // src/storage/types.ts
 var BlobNotFoundError = class extends Error {
 };
 
-// src/verify.ts
-var verifyCheckout = async (storage, head, did2, signingKey) => {
-  const repo = await verifyRepoRoot(storage, head, did2, signingKey);
-  const diff = await data_diff_default.of(repo.data, null);
-  const newCids = new cid_set_default([repo.cid]).addSet(diff.newCids);
-  const contents = {};
-  for (const add of diff.addList()) {
-    const { collection, rkey } = parseDataKey(add.key);
-    if (!contents[collection]) {
-      contents[collection] = {};
-    }
-    const record = await storage.readRecord(add.cid);
-    contents[collection][rkey] = record;
-  }
+// src/sync/consumer.ts
+var verifyRepoCar = async (carBytes, did2, signingKey) => {
+  const car = await readCarWithRoot(carBytes);
+  return verifyRepo(car.blocks, car.root, did2, signingKey);
+};
+var verifyRepo = async (blocks, head, did2, signingKey) => {
+  const diff = await verifyDiff(null, blocks, head, did2, signingKey);
+  const creates = ensureCreates(diff.writes);
   return {
-    contents,
-    newCids
+    creates,
+    commit: diff.commit
   };
 };
-var verifyCheckoutWithCids = async (storage, head, did2, signingKey) => {
-  const repo = await verifyRepoRoot(storage, head, did2, signingKey);
-  const diff = await data_diff_default.of(repo.data, null);
-  const contents = {};
-  for (const add of diff.addList()) {
-    const { collection, rkey } = parseDataKey(add.key);
-    contents[collection] ?? (contents[collection] = {});
-    contents[collection][rkey] = {
-      cid: add.cid,
-      value: await storage.readRecord(add.cid)
-    };
+var verifyDiffCar = async (repo, carBytes, did2, signingKey) => {
+  const car = await readCarWithRoot(carBytes);
+  return verifyDiff(repo, car.blocks, car.root, did2, signingKey);
+};
+var verifyDiff = async (repo, updateBlocks, updateRoot, did2, signingKey) => {
+  const stagedStorage = new MemoryBlockstore(updateBlocks);
+  const updateStorage = repo ? new SyncStorage(stagedStorage, repo.storage) : stagedStorage;
+  const updated = await verifyRepoRoot(
+    updateStorage,
+    updateRoot,
+    did2,
+    signingKey
+  );
+  const diff = await data_diff_default.of(updated.data, repo?.data ?? null);
+  const writes = await diffToWriteDescripts(diff, updateBlocks);
+  const newBlocks = diff.newMstBlocks;
+  const leaves = updateBlocks.getMany(diff.newLeafCids.toList());
+  if (leaves.missing.length > 0) {
+    throw new Error(`missing leaf blocks: ${leaves.missing}`);
+  }
+  newBlocks.addMap(leaves.blocks);
+  const removedCids = diff.removedCids;
+  const commitCid = await newBlocks.add(updated.commit);
+  if (repo) {
+    if (commitCid.equals(repo.cid)) {
+      newBlocks.delete(commitCid);
+    } else {
+      removedCids.add(repo.cid);
+    }
   }
   return {
-    commit: repo.cid,
-    contents
+    writes,
+    commit: {
+      cid: updated.cid,
+      rev: updated.commit.rev,
+      prev: repo?.cid ?? null,
+      since: repo?.commit.rev ?? null,
+      newBlocks,
+      removedCids
+    }
   };
 };
 var verifyRepoRoot = async (storage, head, did2, signingKey) => {
   const repo = await readable_repo_default.load(storage, head);
-  if (repo.did !== did2) {
+  if (did2 !== void 0 && repo.did !== did2) {
     throw new RepoVerificationError(`Invalid repo did: ${repo.did}`);
   }
-  const validSig = await verifyCommitSig(repo.commit, signingKey);
-  if (!validSig) {
-    throw new RepoVerificationError(
-      `Invalid signature on commit: ${repo.cid.toString()}`
-    );
-  }
-  return repo;
-};
-var verifyFullHistory = async (storage, head, did2, signingKey) => {
-  const commitPath = await storage.getCommitPath(head, null);
-  if (commitPath === null) {
-    throw new RepoVerificationError("Could not find shared history");
-  } else if (commitPath.length < 1) {
-    throw new RepoVerificationError("Expected at least one commit");
-  }
-  const baseRepo = await repo_default.load(storage, commitPath[0]);
-  const baseDiff = await data_diff_default.of(baseRepo.data, null);
-  const baseRepoCids = new cid_set_default([baseRepo.cid]).addSet(baseDiff.newCids);
-  const init = {
-    commit: baseRepo.cid,
-    prev: null,
-    diff: baseDiff,
-    newCids: baseRepoCids
-  };
-  const updates = await verifyCommitPath(
-    baseRepo,
-    storage,
-    commitPath.slice(1),
-    did2,
-    signingKey
-  );
-  return [init, ...updates];
-};
-var verifyUpdates = async (repo, updateStorage, updateRoot, did2, signingKey) => {
-  const commitPath = await updateStorage.getCommitPath(updateRoot, repo.cid);
-  if (commitPath === null) {
-    throw new RepoVerificationError("Could not find shared history");
-  }
-  const syncStorage = new sync_storage_default(updateStorage, repo.storage);
-  return verifyCommitPath(repo, syncStorage, commitPath, did2, signingKey);
-};
-var verifyCommitPath = async (baseRepo, storage, commitPath, did2, signingKey) => {
-  const updates = [];
-  if (commitPath.length === 0)
-    return updates;
-  let prevRepo = baseRepo;
-  for (const commit2 of commitPath) {
-    const nextRepo = await readable_repo_default.load(storage, commit2);
-    const diff = await data_diff_default.of(nextRepo.data, prevRepo.data);
-    if (nextRepo.did !== did2) {
-      throw new RepoVerificationError(`Invalid repo did: ${nextRepo.did}`);
-    }
-    if (!metaEqual(nextRepo.commit, prevRepo.commit)) {
-      throw new RepoVerificationError("Not supported: repo metadata updated");
-    }
-    const validSig = await verifyCommitSig(nextRepo.commit, signingKey);
+  if (signingKey !== void 0) {
+    const validSig = await verifyCommitSig(repo.commit, signingKey);
     if (!validSig) {
       throw new RepoVerificationError(
-        `Invalid signature on commit: ${nextRepo.cid.toString()}`
+        `Invalid signature on commit: ${repo.cid.toString()}`
       );
     }
-    const newCids = new cid_set_default([nextRepo.cid]).addSet(diff.newCids);
-    updates.push({
-      commit: nextRepo.cid,
-      prev: prevRepo.cid,
-      diff,
-      newCids
-    });
-    prevRepo = nextRepo;
   }
-  return updates;
+  return repo;
 };
 var verifyProofs = async (proofs, claims, did2, didKey) => {
   const car = await readCarWithRoot(proofs);
@@ -27938,100 +26810,8 @@ var verifyRecords = async (proofs, did2, signingKey) => {
 var RepoVerificationError = class extends Error {
 };
 
-// src/sync/consumer.ts
-var loadCheckout = async (storage, repoCar, did2, signingKey) => {
-  const { root, blocks } = await readCarWithRoot(repoCar);
-  const updateStorage = new MemoryBlockstore(blocks);
-  const checkout = await verifyCheckout(
-    updateStorage,
-    root,
-    did2,
-    signingKey
-  );
-  const checkoutBlocks = await updateStorage.getBlocks(
-    checkout.newCids.toList()
-  );
-  if (checkoutBlocks.missing.length > 0) {
-    throw new MissingBlocksError("sync", checkoutBlocks.missing);
-  }
-  await Promise.all([
-    storage.putMany(checkoutBlocks.blocks),
-    storage.updateHead(root, null)
-  ]);
-  return {
-    root,
-    contents: checkout.contents
-  };
-};
-var loadFullRepo = async (storage, repoCar, did2, signingKey) => {
-  const { root, blocks } = await readCarWithRoot(repoCar);
-  const updateStorage = new MemoryBlockstore(blocks);
-  const updates = await verifyFullHistory(
-    updateStorage,
-    root,
-    did2,
-    signingKey
-  );
-  const [writeLog] = await Promise.all([
-    persistUpdates(storage, updateStorage, updates),
-    storage.updateHead(root, null)
-  ]);
-  const repo = await repo_default.load(storage, root);
-  return {
-    root,
-    writeLog,
-    repo
-  };
-};
-var loadDiff = async (repo, diffCar, did2, signingKey) => {
-  const { root, blocks } = await readCarWithRoot(diffCar);
-  const updateStorage = new MemoryBlockstore(blocks);
-  const updates = await verifyUpdates(
-    repo,
-    updateStorage,
-    root,
-    did2,
-    signingKey
-  );
-  const [writeLog] = await Promise.all([
-    persistUpdates(repo.storage, updateStorage, updates),
-    repo.storage.updateHead(root, repo.cid)
-  ]);
-  return {
-    root,
-    writeLog
-  };
-};
-var persistUpdates = async (storage, updateStorage, updates) => {
-  const newCids = new cid_set_default();
-  for (const update of updates) {
-    newCids.addSet(update.newCids);
-  }
-  const diffBlocks = await updateStorage.getBlocks(newCids.toList());
-  if (diffBlocks.missing.length > 0) {
-    throw new MissingBlocksError("sync", diffBlocks.missing);
-  }
-  const commits = updates.map((update) => {
-    const forCommit = diffBlocks.blocks.getMany(update.newCids.toList());
-    if (forCommit.missing.length > 0) {
-      throw new MissingBlocksError("sync", forCommit.missing);
-    }
-    return {
-      commit: update.commit,
-      prev: update.prev,
-      blocks: forCommit.blocks
-    };
-  });
-  await storage.indexCommits(commits);
-  return Promise.all(
-    updates.map(
-      (upd) => diffToWriteDescripts(upd.diff, diffBlocks.blocks)
-    )
-  );
-};
-
 // src/sync/provider.ts
-var getCheckout = (storage, commitCid) => {
+var getFullRepo = (storage, commitCid) => {
   return writeCar(commitCid, async (car) => {
     const commit2 = await storage.readObjAndBytes(commitCid, def2.commit);
     await car.put({ cid: commitCid, bytes: commit2.bytes });
@@ -28039,27 +26819,6 @@ var getCheckout = (storage, commitCid) => {
     await mst.writeToCarStream(car);
   });
 };
-var getCommits = (storage, latest, earliest) => {
-  return writeCar(latest, (car) => {
-    return writeCommitsToCarStream(storage, car, latest, earliest);
-  });
-};
-var getFullRepo = (storage, cid2) => {
-  return getCommits(storage, cid2, null);
-};
-var writeCommitsToCarStream = async (storage, car, latest, earliest) => {
-  const commits = await storage.getCommits(latest, earliest);
-  if (commits === null) {
-    throw new Error("Could not find shared history");
-  }
-  if (commits.length === 0)
-    return;
-  for (const commit2 of commits) {
-    for (const entry of commit2.blocks.entries()) {
-      await car.put(entry);
-    }
-  }
-};
 var getRecords = (storage, commitCid, paths) => {
   return writeCar(commitCid, async (car) => {
     const commit2 = await storage.readObjAndBytes(commitCid, def2.commit);
@@ -28094,7 +26853,6 @@ var getRecords = (storage, commitCid, paths) => {
   MstWalker,
   ReadableBlockstore,
   Repo,
-  RepoStorage,
   RepoVerificationError,
   SyncStorage,
   WriteOpAction,
@@ -28103,42 +26861,33 @@ var getRecords = (storage, commitCid, paths) => {
   cborToLex,
   cborToLexRecord,
   cidForRecord,
-  collapseDiffs,
-  collapseWriteLog,
   def,
   diffToWriteDescripts,
+  ensureCreates,
+  ensureV3Commit,
   formatDataKey,
-  getCheckout,
-  getCommits,
   getFullRepo,
   getRecords,
-  getWriteLog,
-  loadCheckout,
-  loadDiff,
-  loadFullRepo,
   metaEqual,
   mstDiff,
   mstUtil,
   nodeDataDef,
   nullDiff,
   parseDataKey,
-  persistUpdates,
   readCar,
   readCarWithRoot,
   schema,
   signCommit,
-  verifyCheckout,
-  verifyCheckoutWithCids,
-  verifyCommitPath,
   verifyCommitSig,
-  verifyFullHistory,
+  verifyDiff,
+  verifyDiffCar,
   verifyIncomingCarBlocks,
   verifyProofs,
   verifyRecords,
-  verifyUpdates,
+  verifyRepo,
+  verifyRepoCar,
   writeCar,
-  writeCarStream,
-  writeCommitsToCarStream
+  writeCarStream
 });
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */