@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

package/out/replicache/src/persist/refresh.js

@@ -1,190 +1,101 @@
-import { assertSnapshotCommitDD31, baseSnapshotFromHead, commitFromHash, baseSnapshotFromHash, commitFromHead, DEFAULT_HEAD_NAME, baseSnapshotFromCommit, localMutationsGreaterThan, compareCookiesForSnapshots } from "../db/commit.js";
-import { rebaseMutationAndPutCommit } from "../db/rebase.js";
+import { DEFAULT_HEAD_NAME, assertSnapshotCommitDD31, baseSnapshotFromCommit, baseSnapshotFromHash, baseSnapshotFromHead, commitFromHash, commitFromHead, compareCookiesForSnapshots, localMutationsGreaterThan } from "../db/commit.js";
 import { diffCommits } from "../sync/diff.js";
 import { withRead, withWrite } from "../with-transactions.js";
-import { getClientGroupForClient, ClientStateNotFoundError, mustGetClient, assertClientV6, setClient } from "./clients.js";
+import { ClientStateNotFoundError, assertClientV6, getClientGroupForClient, mustGetClient, setClient } from "./clients.js";
+import { rebaseMutationAndPutCommit } from "../db/rebase.js";
 import { GatherNotCachedVisitor } from "./gather-not-cached-visitor.js";
-const GATHER_SIZE_LIMIT = 5 * 2 ** 20;
+//#region ../replicache/src/persist/refresh.ts
+var GATHER_SIZE_LIMIT = 5 * 2 ** 20;
+/**
+* This returns the diff between the state of the btree before and after
+* refresh. It returns `undefined` if the refresh was aborted.
+*/
 async function refresh(lc, memdag, perdag, clientID, mutators, diffConfig, closed, formatVersion, zero) {
-  if (closed()) {
-    return;
-  }
-  const memdagBaseSnapshot = await withRead(
-    memdag,
-    (memdagRead) => baseSnapshotFromHead(DEFAULT_HEAD_NAME, memdagRead)
-  );
-  assertSnapshotCommitDD31(memdagBaseSnapshot);
-  const result = await memdag.withSuspendedSourceCacheEvictsAndDeletes(async () => {
-    const perdagWriteResult = await withWrite(
-      perdag,
-      async (perdagWrite) => {
-        const clientGroup = await getClientGroupForClient(
-          clientID,
-          perdagWrite
-        );
-        if (!clientGroup) {
-          throw new ClientStateNotFoundError(clientID);
-        }
-        const perdagClientGroupHeadHash2 = clientGroup.headHash;
-        const perdagClientGroupHeadCommit = await commitFromHash(
-          perdagClientGroupHeadHash2,
-          perdagWrite
-        );
-        const perdagLmid2 = await perdagClientGroupHeadCommit.getMutationID(
-          clientID,
-          perdagWrite
-        );
-        const client = await mustGetClient(clientID, perdagWrite);
-        assertClientV6(client);
-        const perdagClientGroupBaseSnapshot2 = await baseSnapshotFromHash(
-          perdagClientGroupHeadHash2,
-          perdagWrite
-        );
-        assertSnapshotCommitDD31(perdagClientGroupBaseSnapshot2);
-        if (shouldAbortRefresh(
-          memdagBaseSnapshot,
-          perdagClientGroupBaseSnapshot2,
-          perdagClientGroupHeadHash2
-        )) {
-          return void 0;
-        }
-        const visitor = new GatherNotCachedVisitor(
-          perdagWrite,
-          memdag,
-          GATHER_SIZE_LIMIT
-        );
-        await visitor.visit(perdagClientGroupHeadHash2);
-        const { gatheredChunks: gatheredChunks2 } = visitor;
-        const refreshHashesSet = new Set(client.refreshHashes);
-        refreshHashesSet.add(perdagClientGroupHeadHash2);
-        const newClient = {
-          ...client,
-          refreshHashes: [...refreshHashesSet]
-        };
-        await setClient(clientID, newClient, perdagWrite);
-        return [
-          perdagClientGroupHeadHash2,
-          perdagClientGroupBaseSnapshot2,
-          perdagLmid2,
-          gatheredChunks2,
-          client.refreshHashes
-        ];
-      }
-    );
-    if (closed() || !perdagWriteResult) {
-      return {
-        type: "aborted"
-      };
-    }
-    const [
-      perdagClientGroupHeadHash,
-      perdagClientGroupBaseSnapshot,
-      perdagLmid,
-      gatheredChunks,
-      refreshHashesForRevert
-    ] = perdagWriteResult;
-    return withWrite(memdag, async (memdagWrite) => {
-      const memdagHeadCommit = await commitFromHead(
-        DEFAULT_HEAD_NAME,
-        memdagWrite
-      );
-      const memdagBaseSnapshot2 = await baseSnapshotFromCommit(
-        memdagHeadCommit,
-        memdagWrite
-      );
-      assertSnapshotCommitDD31(memdagBaseSnapshot2);
-      if (shouldAbortRefresh(
-        memdagBaseSnapshot2,
-        perdagClientGroupBaseSnapshot,
-        perdagClientGroupHeadHash
-      )) {
-        return {
-          type: "aborted",
-          refreshHashesForRevert
-        };
-      }
-      const newMemdagMutations = await localMutationsGreaterThan(
-        memdagHeadCommit,
-        { [clientID]: perdagLmid },
-        memdagWrite
-      );
-      const ps = [];
-      for (const { chunk, size } of gatheredChunks.values()) {
-        ps.push(memdagWrite.putChunk(chunk, size));
-      }
-      await Promise.all(ps);
-      let newMemdagHeadHash = perdagClientGroupHeadHash;
-      if (newMemdagMutations.length > 0) {
-        const zeroData = await zero?.getTxData?.(newMemdagHeadHash, {
-          openLazyRead: memdagWrite
-        });
-        for (let i = newMemdagMutations.length - 1; i >= 0; i--) {
-          newMemdagHeadHash = (await rebaseMutationAndPutCommit(
-            newMemdagMutations[i],
-            memdagWrite,
-            newMemdagHeadHash,
-            mutators,
-            lc,
-            newMemdagMutations[i].meta.clientID,
-            formatVersion,
-            zeroData
-          )).chunk.hash;
-        }
-      }
-      const newMemdagHeadCommit = await commitFromHash(
-        newMemdagHeadHash,
-        memdagWrite
-      );
-      const diffs = await diffCommits(
-        memdagHeadCommit,
-        newMemdagHeadCommit,
-        memdagWrite,
-        diffConfig,
-        formatVersion
-      );
-      await memdagWrite.setHead(DEFAULT_HEAD_NAME, newMemdagHeadHash);
-      return {
-        type: "complete",
-        diffs,
-        oldHead: memdagHeadCommit.chunk.hash,
-        newHead: newMemdagHeadHash,
-        newPerdagClientHeadHash: perdagClientGroupHeadHash
-      };
-    });
-  });
-  if (closed()) {
-    return;
-  }
-  const setRefreshHashes = (refreshHashes) => withWrite(perdag, async (perdagWrite) => {
-    const client = await mustGetClient(clientID, perdagWrite);
-    const newClient = {
-      ...client,
-      refreshHashes
-    };
-    await setClient(clientID, newClient, perdagWrite);
-  });
-  if (result.type === "aborted") {
-    if (result.refreshHashesForRevert) {
-      await setRefreshHashes(result.refreshHashesForRevert);
-    }
-    return void 0;
-  }
-  zero?.advance(result.oldHead, result.newHead, result.diffs.get("") ?? []);
-  await setRefreshHashes([result.newPerdagClientHeadHash]);
-  return {
-    oldHead: result.oldHead,
-    newHead: result.newHead,
-    diffs: result.diffs
-  };
+	if (closed()) return;
+	const memdagBaseSnapshot = await withRead(memdag, (memdagRead) => baseSnapshotFromHead(DEFAULT_HEAD_NAME, memdagRead));
+	assertSnapshotCommitDD31(memdagBaseSnapshot);
+	const result = await memdag.withSuspendedSourceCacheEvictsAndDeletes(async () => {
+		const perdagWriteResult = await withWrite(perdag, async (perdagWrite) => {
+			const clientGroup = await getClientGroupForClient(clientID, perdagWrite);
+			if (!clientGroup) throw new ClientStateNotFoundError(clientID);
+			const perdagClientGroupHeadHash = clientGroup.headHash;
+			const perdagLmid = await (await commitFromHash(perdagClientGroupHeadHash, perdagWrite)).getMutationID(clientID, perdagWrite);
+			const client = await mustGetClient(clientID, perdagWrite);
+			assertClientV6(client);
+			const perdagClientGroupBaseSnapshot = await baseSnapshotFromHash(perdagClientGroupHeadHash, perdagWrite);
+			assertSnapshotCommitDD31(perdagClientGroupBaseSnapshot);
+			if (shouldAbortRefresh(memdagBaseSnapshot, perdagClientGroupBaseSnapshot, perdagClientGroupHeadHash)) return;
+			const visitor = new GatherNotCachedVisitor(perdagWrite, memdag, GATHER_SIZE_LIMIT);
+			await visitor.visit(perdagClientGroupHeadHash);
+			const { gatheredChunks } = visitor;
+			const refreshHashesSet = new Set(client.refreshHashes);
+			refreshHashesSet.add(perdagClientGroupHeadHash);
+			await setClient(clientID, {
+				...client,
+				refreshHashes: [...refreshHashesSet]
+			}, perdagWrite);
+			return [
+				perdagClientGroupHeadHash,
+				perdagClientGroupBaseSnapshot,
+				perdagLmid,
+				gatheredChunks,
+				client.refreshHashes
+			];
+		});
+		if (closed() || !perdagWriteResult) return { type: "aborted" };
+		const [perdagClientGroupHeadHash, perdagClientGroupBaseSnapshot, perdagLmid, gatheredChunks, refreshHashesForRevert] = perdagWriteResult;
+		return withWrite(memdag, async (memdagWrite) => {
+			const memdagHeadCommit = await commitFromHead(DEFAULT_HEAD_NAME, memdagWrite);
+			const memdagBaseSnapshot = await baseSnapshotFromCommit(memdagHeadCommit, memdagWrite);
+			assertSnapshotCommitDD31(memdagBaseSnapshot);
+			if (shouldAbortRefresh(memdagBaseSnapshot, perdagClientGroupBaseSnapshot, perdagClientGroupHeadHash)) return {
+				type: "aborted",
+				refreshHashesForRevert
+			};
+			const newMemdagMutations = await localMutationsGreaterThan(memdagHeadCommit, { [clientID]: perdagLmid }, memdagWrite);
+			const ps = [];
+			for (const { chunk, size } of gatheredChunks.values()) ps.push(memdagWrite.putChunk(chunk, size));
+			await Promise.all(ps);
+			let newMemdagHeadHash = perdagClientGroupHeadHash;
+			if (newMemdagMutations.length > 0) {
+				const zeroData = await zero?.getTxData?.(newMemdagHeadHash, { openLazyRead: memdagWrite });
+				for (let i = newMemdagMutations.length - 1; i >= 0; i--) newMemdagHeadHash = (await rebaseMutationAndPutCommit(newMemdagMutations[i], memdagWrite, newMemdagHeadHash, mutators, lc, newMemdagMutations[i].meta.clientID, formatVersion, zeroData)).chunk.hash;
+			}
+			const diffs = await diffCommits(memdagHeadCommit, await commitFromHash(newMemdagHeadHash, memdagWrite), memdagWrite, diffConfig, formatVersion);
+			await memdagWrite.setHead(DEFAULT_HEAD_NAME, newMemdagHeadHash);
+			return {
+				type: "complete",
+				diffs,
+				oldHead: memdagHeadCommit.chunk.hash,
+				newHead: newMemdagHeadHash,
+				newPerdagClientHeadHash: perdagClientGroupHeadHash
+			};
+		});
+	});
+	if (closed()) return;
+	const setRefreshHashes = (refreshHashes) => withWrite(perdag, async (perdagWrite) => {
+		await setClient(clientID, {
+			...await mustGetClient(clientID, perdagWrite),
+			refreshHashes
+		}, perdagWrite);
+	});
+	if (result.type === "aborted") {
+		if (result.refreshHashesForRevert) await setRefreshHashes(result.refreshHashesForRevert);
+		return;
+	}
+	zero?.advance(result.oldHead, result.newHead, result.diffs.get("") ?? []);
+	await setRefreshHashes([result.newPerdagClientHeadHash]);
+	return {
+		oldHead: result.oldHead,
+		newHead: result.newHead,
+		diffs: result.diffs
+	};
 }
 function shouldAbortRefresh(memdagBaseSnapshot, perdagClientGroupBaseSnapshot, perdagClientGroupHeadHash) {
-  const baseSnapshotCookieCompareResult = compareCookiesForSnapshots(
-    memdagBaseSnapshot,
-    perdagClientGroupBaseSnapshot
-  );
-  return baseSnapshotCookieCompareResult > 0 || baseSnapshotCookieCompareResult === 0 && perdagClientGroupHeadHash === perdagClientGroupBaseSnapshot.chunk.hash;
+	const baseSnapshotCookieCompareResult = compareCookiesForSnapshots(memdagBaseSnapshot, perdagClientGroupBaseSnapshot);
+	return baseSnapshotCookieCompareResult > 0 || baseSnapshotCookieCompareResult === 0 && perdagClientGroupHeadHash === perdagClientGroupBaseSnapshot.chunk.hash;
 }
-export {
-  refresh
-};
-//# sourceMappingURL=refresh.js.map
+//#endregion
+export { refresh };
+
+//# sourceMappingURL=refresh.js.map

package/out/replicache/src/persist/refresh.js.map

@@ -1 +1 @@
-{"version":3,"file":"refresh.js","sources":["../../../../../replicache/src/persist/refresh.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {LazyStore} from '../dag/lazy-store.ts';\nimport type {Store} from '../dag/store.ts';\nimport type {Commit} from '../db/commit.ts';\nimport {\n  DEFAULT_HEAD_NAME,\n  type SnapshotMetaDD31,\n  assertSnapshotCommitDD31,\n  baseSnapshotFromCommit,\n  baseSnapshotFromHash,\n  baseSnapshotFromHead,\n  commitFromHash,\n  commitFromHead,\n  compareCookiesForSnapshots,\n  localMutationsGreaterThan,\n} from '../db/commit.ts';\nimport {rebaseMutationAndPutCommit} from '../db/rebase.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {Hash} from '../hash.ts';\nimport type {ZeroOption} from '../replicache-options.ts';\nimport type {DiffsMap} from '../sync/diff.ts';\nimport {type DiffComputationConfig, diffCommits} from '../sync/diff.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport type {MutatorDefs} from '../types.ts';\nimport {withRead, withWrite} from '../with-transactions.ts';\nimport {\n  ClientStateNotFoundError,\n  type ClientV6,\n  assertClientV6,\n  getClientGroupForClient,\n  mustGetClient,\n  setClient,\n} from './clients.ts';\nimport {\n  type ChunkWithSize,\n  GatherNotCachedVisitor,\n} from './gather-not-cached-visitor.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nconst GATHER_SIZE_LIMIT = 5 * 2 ** 20; // 5 MB\n\ntype RefreshResult =\n  | {\n      type: 'aborted';\n      refreshHashesForRevert?: readonly Hash[] | undefined;\n    }\n  | {\n      type: 'complete';\n      diffs: DiffsMap;\n      newPerdagClientHeadHash: Hash;\n      oldHead: Hash;\n      newHead: Hash;\n    };\n\n/**\n * This returns the diff between the state of the btree before and after\n * refresh. It returns `undefined` if the refresh was aborted.\n */\nexport async function refresh(\n  lc: LogContext,\n  memdag: LazyStore,\n  perdag: Store,\n  clientID: ClientID,\n  mutators: MutatorDefs,\n  diffConfig: DiffComputationConfig,\n  closed: () => boolean,\n  formatVersion: FormatVersion,\n  zero: ZeroOption | undefined,\n): Promise<{oldHead: Hash; newHead: Hash; diffs: DiffsMap} | undefined> {\n  if (closed()) {\n    return;\n  }\n  const memdagBaseSnapshot = await withRead(memdag, memdagRead =>\n    baseSnapshotFromHead(DEFAULT_HEAD_NAME, memdagRead),\n  );\n  assertSnapshotCommitDD31(memdagBaseSnapshot);\n\n  type PerdagWriteResult = [\n    perdagClientGroupHeadHash: Hash,\n    perdagClientGroupBaseSnapshot: Commit<SnapshotMetaDD31>,\n    perdagLmid: number,\n    gatheredChunks: ReadonlyMap<Hash, ChunkWithSize>,\n    refreshHashesForRevert: readonly Hash[],\n  ];\n\n  // Suspend eviction and deletion of chunks cached by the lazy store\n  // to prevent cache misses.  If eviction and deletion are not suspended\n  // some chunks that are not gathered due to already being cached, may be\n  // evicted or deleted by the time the write lock is acquired on the memdag,\n  // which can lead to cache misses when performing the rebase and diff.\n  // It is important to avoid these cache misses because they often create jank\n  // because they block local mutations, pulls and queries on reading from idb.\n  // Cache misses can still happen during the rebase and diff, but only\n  // if the gather step hits its size limit.\n  const result: RefreshResult =\n    await memdag.withSuspendedSourceCacheEvictsAndDeletes(async () => {\n      const perdagWriteResult: PerdagWriteResult | undefined = await withWrite(\n        perdag,\n        async perdagWrite => {\n          const clientGroup = await getClientGroupForClient(\n            clientID,\n            perdagWrite,\n          );\n          if (!clientGroup) {\n            throw new ClientStateNotFoundError(clientID);\n          }\n\n          const perdagClientGroupHeadHash = clientGroup.headHash;\n          const perdagClientGroupHeadCommit = await commitFromHash(\n            perdagClientGroupHeadHash,\n            perdagWrite,\n          );\n          const perdagLmid = await perdagClientGroupHeadCommit.getMutationID(\n            clientID,\n            perdagWrite,\n          );\n\n          // Need to pull this head into memdag, but can't have it disappear if\n          // perdag moves forward while we're rebasing in memdag. Can't change\n          // client headHash until our rebase in memdag is complete, because if\n          // rebase fails, then nothing is keeping client's chunks alive in\n          // perdag.\n          const client = await mustGetClient(clientID, perdagWrite);\n          assertClientV6(client);\n          const perdagClientGroupBaseSnapshot = await baseSnapshotFromHash(\n            perdagClientGroupHeadHash,\n            perdagWrite,\n          );\n          assertSnapshotCommitDD31(perdagClientGroupBaseSnapshot);\n          if (\n            shouldAbortRefresh(\n              memdagBaseSnapshot,\n              perdagClientGroupBaseSnapshot,\n              perdagClientGroupHeadHash,\n            )\n          ) {\n            return undefined;\n          }\n\n          // To avoid pulling the entire perdag graph into the memdag\n          // the amount of chunk data gathered is limited by size.\n          const visitor = new GatherNotCachedVisitor(\n            perdagWrite,\n            memdag,\n            GATHER_SIZE_LIMIT,\n          );\n          await visitor.visit(perdagClientGroupHeadHash);\n          const {gatheredChunks} = visitor;\n\n          const refreshHashesSet = new Set(client.refreshHashes);\n          refreshHashesSet.add(perdagClientGroupHeadHash);\n\n          const newClient: ClientV6 = {\n            ...client,\n            refreshHashes: [...refreshHashesSet],\n          };\n\n          await setClient(clientID, newClient, perdagWrite);\n          return [\n            perdagClientGroupHeadHash,\n            perdagClientGroupBaseSnapshot,\n            perdagLmid,\n            gatheredChunks,\n            client.refreshHashes,\n          ];\n        },\n      );\n\n      if (closed() || !perdagWriteResult) {\n        return {\n          type: 'aborted',\n        } as const;\n      }\n\n      const [\n        perdagClientGroupHeadHash,\n        perdagClientGroupBaseSnapshot,\n        perdagLmid,\n        gatheredChunks,\n        refreshHashesForRevert,\n      ] = perdagWriteResult;\n      return withWrite(memdag, async memdagWrite => {\n        const memdagHeadCommit = await commitFromHead(\n          DEFAULT_HEAD_NAME,\n          memdagWrite,\n        );\n        const memdagBaseSnapshot = await baseSnapshotFromCommit(\n          memdagHeadCommit,\n          memdagWrite,\n        );\n        assertSnapshotCommitDD31(memdagBaseSnapshot);\n        if (\n          shouldAbortRefresh(\n            memdagBaseSnapshot,\n            perdagClientGroupBaseSnapshot,\n            perdagClientGroupHeadHash,\n          )\n        ) {\n          return {\n            type: 'aborted',\n            refreshHashesForRevert,\n          };\n        }\n\n        const newMemdagMutations = await localMutationsGreaterThan(\n          memdagHeadCommit,\n          {[clientID]: perdagLmid},\n          memdagWrite,\n        );\n        const ps = [];\n        for (const {chunk, size} of gatheredChunks.values()) {\n          ps.push(memdagWrite.putChunk(chunk, size));\n        }\n        await Promise.all(ps);\n\n        let newMemdagHeadHash = perdagClientGroupHeadHash;\n        if (newMemdagMutations.length > 0) {\n          const zeroData = await zero?.getTxData?.(newMemdagHeadHash, {\n            openLazyRead: memdagWrite,\n          });\n          for (let i = newMemdagMutations.length - 1; i >= 0; i--) {\n            newMemdagHeadHash = (\n              await rebaseMutationAndPutCommit(\n                newMemdagMutations[i],\n                memdagWrite,\n                newMemdagHeadHash,\n                mutators,\n                lc,\n                newMemdagMutations[i].meta.clientID,\n                formatVersion,\n                zeroData,\n              )\n            ).chunk.hash;\n          }\n        }\n\n        const newMemdagHeadCommit = await commitFromHash(\n          newMemdagHeadHash,\n          memdagWrite,\n        );\n        const diffs = await diffCommits(\n          memdagHeadCommit,\n          newMemdagHeadCommit,\n          memdagWrite,\n          diffConfig,\n          formatVersion,\n        );\n\n        await memdagWrite.setHead(DEFAULT_HEAD_NAME, newMemdagHeadHash);\n        return {\n          type: 'complete',\n          diffs,\n          oldHead: memdagHeadCommit.chunk.hash,\n          newHead: newMemdagHeadHash,\n          newPerdagClientHeadHash: perdagClientGroupHeadHash,\n        } as const;\n      });\n    });\n\n  if (closed()) {\n    return;\n  }\n\n  const setRefreshHashes = (refreshHashes: readonly Hash[]) =>\n    withWrite(perdag, async perdagWrite => {\n      const client = await mustGetClient(clientID, perdagWrite);\n      const newClient = {\n        ...client,\n        refreshHashes,\n      };\n\n      // If this cleanup never happens, it's no big deal, some data will stay\n      // alive longer but next refresh will fix it.\n      await setClient(clientID, newClient, perdagWrite);\n    });\n\n  if (result.type === 'aborted') {\n    if (result.refreshHashesForRevert) {\n      await setRefreshHashes(result.refreshHashesForRevert);\n    }\n    return undefined;\n  }\n\n  // Advance zero here before setting refresh hashes\n  // since we must advance before delegating control of the microtask\n  // loop.\n  zero?.advance(result.oldHead, result.newHead, result.diffs.get('') ?? []);\n  await setRefreshHashes([result.newPerdagClientHeadHash]);\n  return {\n    oldHead: result.oldHead,\n    newHead: result.newHead,\n    diffs: result.diffs,\n  };\n}\n\nfunction shouldAbortRefresh(\n  memdagBaseSnapshot: Commit<SnapshotMetaDD31>,\n  perdagClientGroupBaseSnapshot: Commit<SnapshotMetaDD31>,\n  perdagClientGroupHeadHash: Hash,\n): boolean {\n  const baseSnapshotCookieCompareResult = compareCookiesForSnapshots(\n    memdagBaseSnapshot,\n    perdagClientGroupBaseSnapshot,\n  );\n  return (\n    baseSnapshotCookieCompareResult > 0 ||\n    (baseSnapshotCookieCompareResult === 0 &&\n      perdagClientGroupHeadHash === perdagClientGroupBaseSnapshot.chunk.hash)\n  );\n}\n"],"names":["perdagClientGroupHeadHash","perdagLmid","perdagClientGroupBaseSnapshot","gatheredChunks","memdagBaseSnapshot"],"mappings":";;;;;;AAyCA,MAAM,oBAAoB,IAAI,KAAK;AAmBnC,eAAsB,QACpB,IACA,QACA,QACA,UACA,UACA,YACA,QACA,eACA,MACsE;AACtE,MAAI,UAAU;AACZ;AAAA,EACF;AACA,QAAM,qBAAqB,MAAM;AAAA,IAAS;AAAA,IAAQ,CAAA,eAChD,qBAAqB,mBAAmB,UAAU;AAAA,EAAA;AAEpD,2BAAyB,kBAAkB;AAmB3C,QAAM,SACJ,MAAM,OAAO,yCAAyC,YAAY;AAChE,UAAM,oBAAmD,MAAM;AAAA,MAC7D;AAAA,MACA,OAAM,gBAAe;AACnB,cAAM,cAAc,MAAM;AAAA,UACxB;AAAA,UACA;AAAA,QAAA;AAEF,YAAI,CAAC,aAAa;AAChB,gBAAM,IAAI,yBAAyB,QAAQ;AAAA,QAC7C;AAEA,cAAMA,6BAA4B,YAAY;AAC9C,cAAM,8BAA8B,MAAM;AAAA,UACxCA;AAAAA,UACA;AAAA,QAAA;AAEF,cAAMC,cAAa,MAAM,4BAA4B;AAAA,UACnD;AAAA,UACA;AAAA,QAAA;AAQF,cAAM,SAAS,MAAM,cAAc,UAAU,WAAW;AACxD,uBAAe,MAAM;AACrB,cAAMC,iCAAgC,MAAM;AAAA,UAC1CF;AAAAA,UACA;AAAA,QAAA;AAEF,iCAAyBE,8BAA6B;AACtD,YACE;AAAA,UACE;AAAA,UACAA;AAAAA,UACAF;AAAAA,QAAA,GAEF;AACA,iBAAO;AAAA,QACT;AAIA,cAAM,UAAU,IAAI;AAAA,UAClB;AAAA,UACA;AAAA,UACA;AAAA,QAAA;AAEF,cAAM,QAAQ,MAAMA,0BAAyB;AAC7C,cAAM,EAAC,gBAAAG,gBAAAA,IAAkB;AAEzB,cAAM,mBAAmB,IAAI,IAAI,OAAO,aAAa;AACrD,yBAAiB,IAAIH,0BAAyB;AAE9C,cAAM,YAAsB;AAAA,UAC1B,GAAG;AAAA,UACH,eAAe,CAAC,GAAG,gBAAgB;AAAA,QAAA;AAGrC,cAAM,UAAU,UAAU,WAAW,WAAW;AAChD,eAAO;AAAA,UACLA;AAAAA,UACAE;AAAAA,UACAD;AAAAA,UACAE;AAAAA,UACA,OAAO;AAAA,QAAA;AAAA,MAEX;AAAA,IAAA;AAGF,QAAI,OAAA,KAAY,CAAC,mBAAmB;AAClC,aAAO;AAAA,QACL,MAAM;AAAA,MAAA;AAAA,IAEV;AAEA,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IAAA,IACE;AACJ,WAAO,UAAU,QAAQ,OAAM,gBAAe;AAC5C,YAAM,mBAAmB,MAAM;AAAA,QAC7B;AAAA,QACA;AAAA,MAAA;AAEF,YAAMC,sBAAqB,MAAM;AAAA,QAC/B;AAAA,QACA;AAAA,MAAA;AAEF,+BAAyBA,mBAAkB;AAC3C,UACE;AAAA,QACEA;AAAAA,QACA;AAAA,QACA;AAAA,MAAA,GAEF;AACA,eAAO;AAAA,UACL,MAAM;AAAA,UACN;AAAA,QAAA;AAAA,MAEJ;AAEA,YAAM,qBAAqB,MAAM;AAAA,QAC/B;AAAA,QACA,EAAC,CAAC,QAAQ,GAAG,WAAA;AAAA,QACb;AAAA,MAAA;AAEF,YAAM,KAAK,CAAA;AACX,iBAAW,EAAC,OAAO,KAAA,KAAS,eAAe,UAAU;AACnD,WAAG,KAAK,YAAY,SAAS,OAAO,IAAI,CAAC;AAAA,MAC3C;AACA,YAAM,QAAQ,IAAI,EAAE;AAEpB,UAAI,oBAAoB;AACxB,UAAI,mBAAmB,SAAS,GAAG;AACjC,cAAM,WAAW,MAAM,MAAM,YAAY,mBAAmB;AAAA,UAC1D,cAAc;AAAA,QAAA,CACf;AACD,iBAAS,IAAI,mBAAmB,SAAS,GAAG,KAAK,GAAG,KAAK;AACvD,+BACE,MAAM;AAAA,YACJ,mBAAmB,CAAC;AAAA,YACpB;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA,YACA,mBAAmB,CAAC,EAAE,KAAK;AAAA,YAC3B;AAAA,YACA;AAAA,UAAA,GAEF,MAAM;AAAA,QACV;AAAA,MACF;AAEA,YAAM,sBAAsB,MAAM;AAAA,QAChC;AAAA,QACA;AAAA,MAAA;AAEF,YAAM,QAAQ,MAAM;AAAA,QAClB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MAAA;AAGF,YAAM,YAAY,QAAQ,mBAAmB,iBAAiB;AAC9D,aAAO;AAAA,QACL,MAAM;AAAA,QACN;AAAA,QACA,SAAS,iBAAiB,MAAM;AAAA,QAChC,SAAS;AAAA,QACT,yBAAyB;AAAA,MAAA;AAAA,IAE7B,CAAC;AAAA,EACH,CAAC;AAEH,MAAI,UAAU;AACZ;AAAA,EACF;AAEA,QAAM,mBAAmB,CAAC,kBACxB,UAAU,QAAQ,OAAM,gBAAe;AACrC,UAAM,SAAS,MAAM,cAAc,UAAU,WAAW;AACxD,UAAM,YAAY;AAAA,MAChB,GAAG;AAAA,MACH;AAAA,IAAA;AAKF,UAAM,UAAU,UAAU,WAAW,WAAW;AAAA,EAClD,CAAC;AAEH,MAAI,OAAO,SAAS,WAAW;AAC7B,QAAI,OAAO,wBAAwB;AACjC,YAAM,iBAAiB,OAAO,sBAAsB;AAAA,IACtD;AACA,WAAO;AAAA,EACT;AAKA,QAAM,QAAQ,OAAO,SAAS,OAAO,SAAS,OAAO,MAAM,IAAI,EAAE,KAAK,CAAA,CAAE;AACxE,QAAM,iBAAiB,CAAC,OAAO,uBAAuB,CAAC;AACvD,SAAO;AAAA,IACL,SAAS,OAAO;AAAA,IAChB,SAAS,OAAO;AAAA,IAChB,OAAO,OAAO;AAAA,EAAA;AAElB;AAEA,SAAS,mBACP,oBACA,+BACA,2BACS;AACT,QAAM,kCAAkC;AAAA,IACtC;AAAA,IACA;AAAA,EAAA;AAEF,SACE,kCAAkC,KACjC,oCAAoC,KACnC,8BAA8B,8BAA8B,MAAM;AAExE;"}
+{"version":3,"file":"refresh.js","names":[],"sources":["../../../../../replicache/src/persist/refresh.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport type {LazyStore} from '../dag/lazy-store.ts';\nimport type {Store} from '../dag/store.ts';\nimport type {Commit} from '../db/commit.ts';\nimport {\n  DEFAULT_HEAD_NAME,\n  type SnapshotMetaDD31,\n  assertSnapshotCommitDD31,\n  baseSnapshotFromCommit,\n  baseSnapshotFromHash,\n  baseSnapshotFromHead,\n  commitFromHash,\n  commitFromHead,\n  compareCookiesForSnapshots,\n  localMutationsGreaterThan,\n} from '../db/commit.ts';\nimport {rebaseMutationAndPutCommit} from '../db/rebase.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {Hash} from '../hash.ts';\nimport type {ZeroOption} from '../replicache-options.ts';\nimport type {DiffsMap} from '../sync/diff.ts';\nimport {type DiffComputationConfig, diffCommits} from '../sync/diff.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport type {MutatorDefs} from '../types.ts';\nimport {withRead, withWrite} from '../with-transactions.ts';\nimport {\n  ClientStateNotFoundError,\n  type ClientV6,\n  assertClientV6,\n  getClientGroupForClient,\n  mustGetClient,\n  setClient,\n} from './clients.ts';\nimport {\n  type ChunkWithSize,\n  GatherNotCachedVisitor,\n} from './gather-not-cached-visitor.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nconst GATHER_SIZE_LIMIT = 5 * 2 ** 20; // 5 MB\n\ntype RefreshResult =\n  | {\n      type: 'aborted';\n      refreshHashesForRevert?: readonly Hash[] | undefined;\n    }\n  | {\n      type: 'complete';\n      diffs: DiffsMap;\n      newPerdagClientHeadHash: Hash;\n      oldHead: Hash;\n      newHead: Hash;\n    };\n\n/**\n * This returns the diff between the state of the btree before and after\n * refresh. It returns `undefined` if the refresh was aborted.\n */\nexport async function refresh(\n  lc: LogContext,\n  memdag: LazyStore,\n  perdag: Store,\n  clientID: ClientID,\n  mutators: MutatorDefs,\n  diffConfig: DiffComputationConfig,\n  closed: () => boolean,\n  formatVersion: FormatVersion,\n  zero: ZeroOption | undefined,\n): Promise<{oldHead: Hash; newHead: Hash; diffs: DiffsMap} | undefined> {\n  if (closed()) {\n    return;\n  }\n  const memdagBaseSnapshot = await withRead(memdag, memdagRead =>\n    baseSnapshotFromHead(DEFAULT_HEAD_NAME, memdagRead),\n  );\n  assertSnapshotCommitDD31(memdagBaseSnapshot);\n\n  type PerdagWriteResult = [\n    perdagClientGroupHeadHash: Hash,\n    perdagClientGroupBaseSnapshot: Commit<SnapshotMetaDD31>,\n    perdagLmid: number,\n    gatheredChunks: ReadonlyMap<Hash, ChunkWithSize>,\n    refreshHashesForRevert: readonly Hash[],\n  ];\n\n  // Suspend eviction and deletion of chunks cached by the lazy store\n  // to prevent cache misses.  If eviction and deletion are not suspended\n  // some chunks that are not gathered due to already being cached, may be\n  // evicted or deleted by the time the write lock is acquired on the memdag,\n  // which can lead to cache misses when performing the rebase and diff.\n  // It is important to avoid these cache misses because they often create jank\n  // because they block local mutations, pulls and queries on reading from idb.\n  // Cache misses can still happen during the rebase and diff, but only\n  // if the gather step hits its size limit.\n  const result: RefreshResult =\n    await memdag.withSuspendedSourceCacheEvictsAndDeletes(async () => {\n      const perdagWriteResult: PerdagWriteResult | undefined = await withWrite(\n        perdag,\n        async perdagWrite => {\n          const clientGroup = await getClientGroupForClient(\n            clientID,\n            perdagWrite,\n          );\n          if (!clientGroup) {\n            throw new ClientStateNotFoundError(clientID);\n          }\n\n          const perdagClientGroupHeadHash = clientGroup.headHash;\n          const perdagClientGroupHeadCommit = await commitFromHash(\n            perdagClientGroupHeadHash,\n            perdagWrite,\n          );\n          const perdagLmid = await perdagClientGroupHeadCommit.getMutationID(\n            clientID,\n            perdagWrite,\n          );\n\n          // Need to pull this head into memdag, but can't have it disappear if\n          // perdag moves forward while we're rebasing in memdag. Can't change\n          // client headHash until our rebase in memdag is complete, because if\n          // rebase fails, then nothing is keeping client's chunks alive in\n          // perdag.\n          const client = await mustGetClient(clientID, perdagWrite);\n          assertClientV6(client);\n          const perdagClientGroupBaseSnapshot = await baseSnapshotFromHash(\n            perdagClientGroupHeadHash,\n            perdagWrite,\n          );\n          assertSnapshotCommitDD31(perdagClientGroupBaseSnapshot);\n          if (\n            shouldAbortRefresh(\n              memdagBaseSnapshot,\n              perdagClientGroupBaseSnapshot,\n              perdagClientGroupHeadHash,\n            )\n          ) {\n            return undefined;\n          }\n\n          // To avoid pulling the entire perdag graph into the memdag\n          // the amount of chunk data gathered is limited by size.\n          const visitor = new GatherNotCachedVisitor(\n            perdagWrite,\n            memdag,\n            GATHER_SIZE_LIMIT,\n          );\n          await visitor.visit(perdagClientGroupHeadHash);\n          const {gatheredChunks} = visitor;\n\n          const refreshHashesSet = new Set(client.refreshHashes);\n          refreshHashesSet.add(perdagClientGroupHeadHash);\n\n          const newClient: ClientV6 = {\n            ...client,\n            refreshHashes: [...refreshHashesSet],\n          };\n\n          await setClient(clientID, newClient, perdagWrite);\n          return [\n            perdagClientGroupHeadHash,\n            perdagClientGroupBaseSnapshot,\n            perdagLmid,\n            gatheredChunks,\n            client.refreshHashes,\n          ];\n        },\n      );\n\n      if (closed() || !perdagWriteResult) {\n        return {\n          type: 'aborted',\n        } as const;\n      }\n\n      const [\n        perdagClientGroupHeadHash,\n        perdagClientGroupBaseSnapshot,\n        perdagLmid,\n        gatheredChunks,\n        refreshHashesForRevert,\n      ] = perdagWriteResult;\n      return withWrite(memdag, async memdagWrite => {\n        const memdagHeadCommit = await commitFromHead(\n          DEFAULT_HEAD_NAME,\n          memdagWrite,\n        );\n        const memdagBaseSnapshot = await baseSnapshotFromCommit(\n          memdagHeadCommit,\n          memdagWrite,\n        );\n        assertSnapshotCommitDD31(memdagBaseSnapshot);\n        if (\n          shouldAbortRefresh(\n            memdagBaseSnapshot,\n            perdagClientGroupBaseSnapshot,\n            perdagClientGroupHeadHash,\n          )\n        ) {\n          return {\n            type: 'aborted',\n            refreshHashesForRevert,\n          };\n        }\n\n        const newMemdagMutations = await localMutationsGreaterThan(\n          memdagHeadCommit,\n          {[clientID]: perdagLmid},\n          memdagWrite,\n        );\n        const ps = [];\n        for (const {chunk, size} of gatheredChunks.values()) {\n          ps.push(memdagWrite.putChunk(chunk, size));\n        }\n        await Promise.all(ps);\n\n        let newMemdagHeadHash = perdagClientGroupHeadHash;\n        if (newMemdagMutations.length > 0) {\n          const zeroData = await zero?.getTxData?.(newMemdagHeadHash, {\n            openLazyRead: memdagWrite,\n          });\n          for (let i = newMemdagMutations.length - 1; i >= 0; i--) {\n            newMemdagHeadHash = (\n              await rebaseMutationAndPutCommit(\n                newMemdagMutations[i],\n                memdagWrite,\n                newMemdagHeadHash,\n                mutators,\n                lc,\n                newMemdagMutations[i].meta.clientID,\n                formatVersion,\n                zeroData,\n              )\n            ).chunk.hash;\n          }\n        }\n\n        const newMemdagHeadCommit = await commitFromHash(\n          newMemdagHeadHash,\n          memdagWrite,\n        );\n        const diffs = await diffCommits(\n          memdagHeadCommit,\n          newMemdagHeadCommit,\n          memdagWrite,\n          diffConfig,\n          formatVersion,\n        );\n\n        await memdagWrite.setHead(DEFAULT_HEAD_NAME, newMemdagHeadHash);\n        return {\n          type: 'complete',\n          diffs,\n          oldHead: memdagHeadCommit.chunk.hash,\n          newHead: newMemdagHeadHash,\n          newPerdagClientHeadHash: perdagClientGroupHeadHash,\n        } as const;\n      });\n    });\n\n  if (closed()) {\n    return;\n  }\n\n  const setRefreshHashes = (refreshHashes: readonly Hash[]) =>\n    withWrite(perdag, async perdagWrite => {\n      const client = await mustGetClient(clientID, perdagWrite);\n      const newClient = {\n        ...client,\n        refreshHashes,\n      };\n\n      // If this cleanup never happens, it's no big deal, some data will stay\n      // alive longer but next refresh will fix it.\n      await setClient(clientID, newClient, perdagWrite);\n    });\n\n  if (result.type === 'aborted') {\n    if (result.refreshHashesForRevert) {\n      await setRefreshHashes(result.refreshHashesForRevert);\n    }\n    return undefined;\n  }\n\n  // Advance zero here before setting refresh hashes\n  // since we must advance before delegating control of the microtask\n  // loop.\n  zero?.advance(result.oldHead, result.newHead, result.diffs.get('') ?? []);\n  await setRefreshHashes([result.newPerdagClientHeadHash]);\n  return {\n    oldHead: result.oldHead,\n    newHead: result.newHead,\n    diffs: result.diffs,\n  };\n}\n\nfunction shouldAbortRefresh(\n  memdagBaseSnapshot: Commit<SnapshotMetaDD31>,\n  perdagClientGroupBaseSnapshot: Commit<SnapshotMetaDD31>,\n  perdagClientGroupHeadHash: Hash,\n): boolean {\n  const baseSnapshotCookieCompareResult = compareCookiesForSnapshots(\n    memdagBaseSnapshot,\n    perdagClientGroupBaseSnapshot,\n  );\n  return (\n    baseSnapshotCookieCompareResult > 0 ||\n    (baseSnapshotCookieCompareResult === 0 &&\n      perdagClientGroupHeadHash === perdagClientGroupBaseSnapshot.chunk.hash)\n  );\n}\n"],"mappings":"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"}

package/out/replicache/src/process-scheduler.js

@@ -1,148 +1,127 @@
-import { resolver } from "@rocicorp/resolver";
-import { AbortError } from "../../shared/src/abort-error.js";
 import { assert } from "../../shared/src/asserts.js";
+import { AbortError } from "../../shared/src/abort-error.js";
 import { sleep } from "../../shared/src/sleep.js";
 import { requestIdle } from "./request-idle.js";
-class ProcessScheduler {
-  #process;
-  #idleTimeoutMs;
-  #throttleMs;
-  #abortSignal;
-  #requestIdle;
-  #scheduledResolver = void 0;
-  #runResolver = void 0;
-  #runPromise = Promise.resolve();
-  // oxlint-disable-next-line no-unused-private-class-members -- False positive, this is used in #run
-  #throttlePromise = Promise.resolve();
-  /**
-   * Supports scheduling a `process` to be run with certain constraints.
-   *  - Process runs are never concurrent.
-   *  - Multiple calls to schedule will be fulfilled by a single process
-   *    run started after the call to schedule.  A call is never fulfilled by an
-   *    already running process run.  This can be thought of as debouncing.
-   *  - Process runs are throttled so that the process runs at most once every
-   *    `throttleMs`.
-   *  - Process runs try to run during an idle period, but will delay at most
-   *    `idleTimeoutMs`.
-   *  - Scheduled runs which have not completed when `abortSignal` is aborted
-   *    will reject with an `AbortError`.
-   */
-  constructor(process, idleTimeoutMs, throttleMs, abortSignal, requestIdle$1 = requestIdle) {
-    this.#process = process;
-    this.#idleTimeoutMs = idleTimeoutMs;
-    this.#throttleMs = throttleMs;
-    this.#abortSignal = abortSignal;
-    this.#requestIdle = requestIdle$1;
-    this.#abortSignal.addEventListener(
-      "abort",
-      () => {
-        const abortError = new AbortError("Aborted");
-        this.#runResolver?.reject(abortError);
-        this.#scheduledResolver?.reject(abortError);
-        this.#runResolver = void 0;
-        this.#scheduledResolver = void 0;
-      },
-      { once: true }
-    );
-  }
-  /**
-   * Schedules the process to run.
-   *
-   * The returned promise resolves when the process has completed running.
-   * If the process throws an error, the returned promise rejects with that error.
-   *
-   * If `schedule()` is called multiple times while a process is running/scheduled,
-   * they will be debounced into a single run.
-   */
-  schedule() {
-    if (this.#abortSignal.aborted) {
-      return Promise.reject(new AbortError("Aborted"));
-    }
-    if (this.#scheduledResolver) {
-      return this.#scheduledResolver.promise;
-    }
-    this.#scheduledResolver = resolver();
-    void this.#scheduleInternal();
-    return this.#scheduledResolver.promise;
-  }
-  /**
-   * Runs the process immediately, skipping throttle and idle checks.
-   *
-   * The returned promise resolves when the process has completed running.
-   * If the process throws an error, the returned promise rejects with that error.
-   *
-   * If there is a scheduled run pending (waiting for idle or throttle), this run
-   * will effectively "take over" that scheduled run, and the promise returned
-   * by `schedule()` will resolve when this run completes.
-   *
-   * If there is a process currently running, this run will wait for it to finish
-   * before starting, satisfying the non-concurrency constraint.
-   */
-  async run() {
-    if (this.#abortSignal.aborted) {
-      return Promise.reject(new AbortError("Aborted"));
-    }
-    const resolverToResolve = this.#scheduledResolver;
-    this.#scheduledResolver = void 0;
-    const prevRunPromise = this.#runPromise;
-    const runTask = async () => {
-      try {
-        await prevRunPromise;
-      } catch {
-      }
-      if (this.#abortSignal.aborted) {
-        throw new AbortError("Aborted");
-      }
-      return this.#process();
-    };
-    const executionPromise = runTask();
-    this.#runPromise = executionPromise;
-    this.#throttlePromise = throttle(this.#throttleMs, this.#abortSignal);
-    try {
-      await executionPromise;
-      resolverToResolve?.resolve();
-    } catch (e) {
-      resolverToResolve?.reject(e);
-      throw e;
-    }
-  }
-  async #scheduleInternal() {
-    try {
-      await this.#runPromise;
-    } catch {
-    }
-    await this.#throttlePromise;
-    if (!this.#scheduledResolver) {
-      return;
-    }
-    await this.#requestIdle(this.#idleTimeoutMs);
-    if (!this.#scheduledResolver) {
-      return;
-    }
-    this.#throttlePromise = throttle(this.#throttleMs, this.#abortSignal);
-    this.#runResolver = this.#scheduledResolver;
-    this.#scheduledResolver = void 0;
-    try {
-      this.#runPromise = this.#process();
-      await this.#runPromise;
-      this.#runResolver?.resolve();
-    } catch (e) {
-      this.#runResolver?.reject(e);
-    }
-    this.#runResolver = void 0;
-  }
-}
+import { resolver } from "@rocicorp/resolver";
+//#region ../replicache/src/process-scheduler.ts
+var ProcessScheduler = class {
+	#process;
+	#idleTimeoutMs;
+	#throttleMs;
+	#abortSignal;
+	#requestIdle;
+	#scheduledResolver = void 0;
+	#runResolver = void 0;
+	#runPromise = Promise.resolve();
+	#throttlePromise = Promise.resolve();
+	/**
+	* Supports scheduling a `process` to be run with certain constraints.
+	*  - Process runs are never concurrent.
+	*  - Multiple calls to schedule will be fulfilled by a single process
+	*    run started after the call to schedule.  A call is never fulfilled by an
+	*    already running process run.  This can be thought of as debouncing.
+	*  - Process runs are throttled so that the process runs at most once every
+	*    `throttleMs`.
+	*  - Process runs try to run during an idle period, but will delay at most
+	*    `idleTimeoutMs`.
+	*  - Scheduled runs which have not completed when `abortSignal` is aborted
+	*    will reject with an `AbortError`.
+	*/
+	constructor(process, idleTimeoutMs, throttleMs, abortSignal, requestIdle$1 = requestIdle) {
+		this.#process = process;
+		this.#idleTimeoutMs = idleTimeoutMs;
+		this.#throttleMs = throttleMs;
+		this.#abortSignal = abortSignal;
+		this.#requestIdle = requestIdle$1;
+		this.#abortSignal.addEventListener("abort", () => {
+			const abortError = new AbortError("Aborted");
+			this.#runResolver?.reject(abortError);
+			this.#scheduledResolver?.reject(abortError);
+			this.#runResolver = void 0;
+			this.#scheduledResolver = void 0;
+		}, { once: true });
+	}
+	/**
+	* Schedules the process to run.
+	*
+	* The returned promise resolves when the process has completed running.
+	* If the process throws an error, the returned promise rejects with that error.
+	*
+	* If `schedule()` is called multiple times while a process is running/scheduled,
+	* they will be debounced into a single run.
+	*/
+	schedule() {
+		if (this.#abortSignal.aborted) return Promise.reject(new AbortError("Aborted"));
+		if (this.#scheduledResolver) return this.#scheduledResolver.promise;
+		this.#scheduledResolver = resolver();
+		this.#scheduleInternal();
+		return this.#scheduledResolver.promise;
+	}
+	/**
+	* Runs the process immediately, skipping throttle and idle checks.
+	*
+	* The returned promise resolves when the process has completed running.
+	* If the process throws an error, the returned promise rejects with that error.
+	*
+	* If there is a scheduled run pending (waiting for idle or throttle), this run
+	* will effectively "take over" that scheduled run, and the promise returned
+	* by `schedule()` will resolve when this run completes.
+	*
+	* If there is a process currently running, this run will wait for it to finish
+	* before starting, satisfying the non-concurrency constraint.
+	*/
+	async run() {
+		if (this.#abortSignal.aborted) return Promise.reject(new AbortError("Aborted"));
+		const resolverToResolve = this.#scheduledResolver;
+		this.#scheduledResolver = void 0;
+		const prevRunPromise = this.#runPromise;
+		const runTask = async () => {
+			try {
+				await prevRunPromise;
+			} catch {}
+			if (this.#abortSignal.aborted) throw new AbortError("Aborted");
+			return this.#process();
+		};
+		const executionPromise = runTask();
+		this.#runPromise = executionPromise;
+		this.#throttlePromise = throttle(this.#throttleMs, this.#abortSignal);
+		try {
+			await executionPromise;
+			resolverToResolve?.resolve();
+		} catch (e) {
+			resolverToResolve?.reject(e);
+			throw e;
+		}
+	}
+	async #scheduleInternal() {
+		try {
+			await this.#runPromise;
+		} catch {}
+		await this.#throttlePromise;
+		if (!this.#scheduledResolver) return;
+		await this.#requestIdle(this.#idleTimeoutMs);
+		if (!this.#scheduledResolver) return;
+		this.#throttlePromise = throttle(this.#throttleMs, this.#abortSignal);
+		this.#runResolver = this.#scheduledResolver;
+		this.#scheduledResolver = void 0;
+		try {
+			this.#runPromise = this.#process();
+			await this.#runPromise;
+			this.#runResolver?.resolve();
+		} catch (e) {
+			this.#runResolver?.reject(e);
+		}
+		this.#runResolver = void 0;
+	}
+};
 async function throttle(timeMs, abortSignal) {
-  try {
-    await sleep(timeMs, abortSignal);
-  } catch (e) {
-    assert(
-      e instanceof AbortError,
-      "Expected caught error to be an AbortError"
-    );
-  }
+	try {
+		await sleep(timeMs, abortSignal);
+	} catch (e) {
+		assert(e instanceof AbortError, "Expected caught error to be an AbortError");
+	}
 }
-export {
-  ProcessScheduler
-};
-//# sourceMappingURL=process-scheduler.js.map
+//#endregion
+export { ProcessScheduler };
+
+//# sourceMappingURL=process-scheduler.js.map