@rocicorp/zero 0.25.0-canary.6 → 0.25.0-canary.8

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

@@ -0,0 +1,198 @@
+import { sleep } from "../../../shared/src/sleep.js";
+import { assertSnapshotCommitDD31, baseSnapshotFromHead, commitFromHash, baseSnapshotFromHash, commitFromHead, DEFAULT_HEAD_NAME, baseSnapshotFromCommit, localMutationsGreaterThan, compareCookiesForSnapshots } from "../db/commit.js";
+import { rebaseMutationAndPutCommit } from "../db/rebase.js";
+import { diffCommits } from "../sync/diff.js";
+import { withRead, withWrite } from "../with-transactions.js";
+import { getClientGroupForClient, ClientStateNotFoundError, mustGetClient, assertClientV6, setClient } from "./clients.js";
+import { GatherNotCachedVisitor } from "./gather-not-cached-visitor.js";
+const GATHER_SIZE_LIMIT = 5 * 2 ** 20;
+const DELAY_MS = 300;
+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"
+      };
+    }
+    await sleep(DELAY_MS);
+    if (closed()) {
+      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
+  };
+}
+function shouldAbortRefresh(memdagBaseSnapshot, perdagClientGroupBaseSnapshot, perdagClientGroupHeadHash) {
+  const baseSnapshotCookieCompareResult = compareCookiesForSnapshots(
+    memdagBaseSnapshot,
+    perdagClientGroupBaseSnapshot
+  );
+  return baseSnapshotCookieCompareResult > 0 || baseSnapshotCookieCompareResult === 0 && perdagClientGroupHeadHash === perdagClientGroupBaseSnapshot.chunk.hash;
+}
+export {
+  refresh
+};
+//# sourceMappingURL=refresh.js.map

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

@@ -0,0 +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 {sleep} from '../../../shared/src/sleep.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\nconst DELAY_MS = 300;\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      // pull/poke and refresh are racing to see who gets to update\n      // the memdag (the one with the newer base snapshot cookie wins)\n      // pull/poke updates are preferable so delay refresh slightly to\n      // make pull/poke the winner except when pull/pokes are slow.\n      // This is especially important for pokes, as refresh winning\n      // will result in the next poke's cookie not matching necessitating\n      // a disconnect/reconnect.\n      await sleep(DELAY_MS);\n      if (closed()) {\n        return {\n          type: 'aborted',\n        };\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":"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"}

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

@@ -0,0 +1,96 @@
+import { resolver } from "@rocicorp/resolver";
+import { AbortError } from "../../shared/src/abort-error.js";
+import { assert } from "../../shared/src/asserts.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;
+  // oxlint-disable-next-line no-unused-private-class-members -- False positive, this is used in #run
+  #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 }
+    );
+  }
+  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;
+  }
+  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);
+  }
+}
+export {
+  ProcessScheduler
+};
+//# sourceMappingURL=process-scheduler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"process-scheduler.js","sources":["../../../../replicache/src/process-scheduler.ts"],"sourcesContent":["import {type Resolver, resolver} from '@rocicorp/resolver';\nimport {AbortError} from '../../shared/src/abort-error.ts';\nimport {assert} from '../../shared/src/asserts.ts';\nimport {sleep} from '../../shared/src/sleep.ts';\nimport {requestIdle as defaultRequestIdle} from './request-idle.ts';\n\nexport class ProcessScheduler {\n  readonly #process: () => Promise<void>;\n  readonly #idleTimeoutMs: number;\n  readonly #throttleMs: number;\n  readonly #abortSignal: AbortSignal;\n  readonly #requestIdle: typeof defaultRequestIdle;\n  #scheduledResolver: Resolver<void> | undefined = undefined;\n  #runResolver: Resolver<void> | undefined = undefined;\n  // oxlint-disable-next-line no-unused-private-class-members -- False positive, this is used in #run\n  #runPromise = Promise.resolve();\n  // oxlint-disable-next-line no-unused-private-class-members -- False positive, this is used in #run\n  #throttlePromise = Promise.resolve();\n\n  /**\n   * Supports scheduling a `process` to be run with certain constraints.\n   *  - Process runs are never concurrent.\n   *  - Multiple calls to schedule will be fulfilled by a single process\n   *    run started after the call to schedule.  A call is never fulfilled by an\n   *    already running process run.  This can be thought of as debouncing.\n   *  - Process runs are throttled so that the process runs at most once every\n   *    `throttleMs`.\n   *  - Process runs try to run during an idle period, but will delay at most\n   *    `idleTimeoutMs`.\n   *  - Scheduled runs which have not completed when `abortSignal` is aborted\n   *    will reject with an `AbortError`.\n   */\n  constructor(\n    process: () => Promise<void>,\n    idleTimeoutMs: number,\n    throttleMs: number,\n    abortSignal: AbortSignal,\n    requestIdle = defaultRequestIdle,\n  ) {\n    this.#process = process;\n    this.#idleTimeoutMs = idleTimeoutMs;\n    this.#throttleMs = throttleMs;\n    this.#abortSignal = abortSignal;\n    this.#requestIdle = requestIdle;\n    this.#abortSignal.addEventListener(\n      'abort',\n      () => {\n        const abortError = new AbortError('Aborted');\n        this.#runResolver?.reject(abortError);\n        this.#scheduledResolver?.reject(abortError);\n        this.#runResolver = undefined;\n        this.#scheduledResolver = undefined;\n      },\n      {once: true},\n    );\n  }\n\n  schedule(): Promise<void> {\n    if (this.#abortSignal.aborted) {\n      return Promise.reject(new AbortError('Aborted'));\n    }\n    if (this.#scheduledResolver) {\n      return this.#scheduledResolver.promise;\n    }\n    this.#scheduledResolver = resolver();\n    void this.#scheduleInternal();\n    return this.#scheduledResolver.promise;\n  }\n\n  async #scheduleInternal(): Promise<void> {\n    try {\n      await this.#runPromise;\n      // Prevent errors thrown by process from cancelling scheduled runs.\n      // this._runPromise is also awaited below and errors are explicitly\n      // propagated to promises returned from schedule.\n    } catch {}\n    await this.#throttlePromise;\n    if (!this.#scheduledResolver) {\n      return;\n    }\n    await this.#requestIdle(this.#idleTimeoutMs);\n    if (!this.#scheduledResolver) {\n      return;\n    }\n    this.#throttlePromise = throttle(this.#throttleMs, this.#abortSignal);\n    this.#runResolver = this.#scheduledResolver;\n    this.#scheduledResolver = undefined;\n    try {\n      this.#runPromise = this.#process();\n      await this.#runPromise;\n      this.#runResolver?.resolve();\n    } catch (e) {\n      this.#runResolver?.reject(e);\n    }\n    this.#runResolver = undefined;\n  }\n}\n\nasync function throttle(\n  timeMs: number,\n  abortSignal: AbortSignal,\n): Promise<void> {\n  try {\n    await sleep(timeMs, abortSignal);\n  } catch (e) {\n    assert(e instanceof AbortError);\n  }\n}\n"],"names":["requestIdle","defaultRequestIdle"],"mappings":";;;;;AAMO,MAAM,iBAAiB;AAAA,EACnB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACT,qBAAiD;AAAA,EACjD,eAA2C;AAAA;AAAA,EAE3C,cAAc,QAAQ,QAAA;AAAA;AAAA,EAEtB,mBAAmB,QAAQ,QAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAe3B,YACE,SACA,eACA,YACA,aACAA,gBAAcC,aACd;AACA,SAAK,WAAW;AAChB,SAAK,iBAAiB;AACtB,SAAK,cAAc;AACnB,SAAK,eAAe;AACpB,SAAK,eAAeD;AACpB,SAAK,aAAa;AAAA,MAChB;AAAA,MACA,MAAM;AACJ,cAAM,aAAa,IAAI,WAAW,SAAS;AAC3C,aAAK,cAAc,OAAO,UAAU;AACpC,aAAK,oBAAoB,OAAO,UAAU;AAC1C,aAAK,eAAe;AACpB,aAAK,qBAAqB;AAAA,MAC5B;AAAA,MACA,EAAC,MAAM,KAAA;AAAA,IAAI;AAAA,EAEf;AAAA,EAEA,WAA0B;AACxB,QAAI,KAAK,aAAa,SAAS;AAC7B,aAAO,QAAQ,OAAO,IAAI,WAAW,SAAS,CAAC;AAAA,IACjD;AACA,QAAI,KAAK,oBAAoB;AAC3B,aAAO,KAAK,mBAAmB;AAAA,IACjC;AACA,SAAK,qBAAqB,SAAA;AAC1B,SAAK,KAAK,kBAAA;AACV,WAAO,KAAK,mBAAmB;AAAA,EACjC;AAAA,EAEA,MAAM,oBAAmC;AACvC,QAAI;AACF,YAAM,KAAK;AAAA,IAIb,QAAQ;AAAA,IAAC;AACT,UAAM,KAAK;AACX,QAAI,CAAC,KAAK,oBAAoB;AAC5B;AAAA,IACF;AACA,UAAM,KAAK,aAAa,KAAK,cAAc;AAC3C,QAAI,CAAC,KAAK,oBAAoB;AAC5B;AAAA,IACF;AACA,SAAK,mBAAmB,SAAS,KAAK,aAAa,KAAK,YAAY;AACpE,SAAK,eAAe,KAAK;AACzB,SAAK,qBAAqB;AAC1B,QAAI;AACF,WAAK,cAAc,KAAK,SAAA;AACxB,YAAM,KAAK;AACX,WAAK,cAAc,QAAA;AAAA,IACrB,SAAS,GAAG;AACV,WAAK,cAAc,OAAO,CAAC;AAAA,IAC7B;AACA,SAAK,eAAe;AAAA,EACtB;AACF;AAEA,eAAe,SACb,QACA,aACe;AACf,MAAI;AACF,UAAM,MAAM,QAAQ,WAAW;AAAA,EACjC,SAAS,GAAG;AACV,WAAO,aAAa,UAAU;AAAA,EAChC;AACF;"}

package/out/replicache/src/pusher.js

@@ -0,0 +1,33 @@
+import { assertObject } from "../../shared/src/asserts.js";
+import { isClientStateNotFoundResponse, assertVersionNotSupportedResponse } from "./error-responses.js";
+import { assertHTTPRequestInfo } from "./http-request-info.js";
+function assertPusherResult(v) {
+  assertObject(v);
+  assertHTTPRequestInfo(v.httpRequestInfo);
+  if (v.response !== void 0) {
+    assertPushResponse(v.response);
+  }
+}
+function assertPushResponse(v) {
+  if (isClientStateNotFoundResponse(v)) {
+    return;
+  }
+  assertVersionNotSupportedResponse(v);
+}
+class PushError extends Error {
+  name = "PushError";
+  // causedBy is used instead of cause, because while cause has been proposed as a
+  // JavaScript language standard for this purpose (see
+  // https://github.com/tc39/proposal-error-cause) current browser behavior is
+  // inconsistent.
+  causedBy;
+  constructor(causedBy) {
+    super("Failed to push");
+    this.causedBy = causedBy;
+  }
+}
+export {
+  PushError,
+  assertPusherResult
+};
+//# sourceMappingURL=pusher.js.map

package/out/replicache/src/pusher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pusher.js","sources":["../../../../replicache/src/pusher.ts"],"sourcesContent":["import {assertObject} from '../../shared/src/asserts.ts';\nimport {\n  assertVersionNotSupportedResponse,\n  type ClientStateNotFoundResponse,\n  isClientStateNotFoundResponse,\n  type VersionNotSupportedResponse,\n} from './error-responses.ts';\nimport {\n  assertHTTPRequestInfo,\n  type HTTPRequestInfo,\n} from './http-request-info.ts';\nimport type {PushRequest} from './sync/push.ts';\n\nexport type PusherResult = {\n  response?: PushResponse | undefined;\n  httpRequestInfo: HTTPRequestInfo;\n};\n\n/**\n * The response from a push can contain information about error conditions.\n */\nexport type PushResponse =\n  | ClientStateNotFoundResponse\n  | VersionNotSupportedResponse;\n\nexport function assertPusherResult(v: unknown): asserts v is PusherResult {\n  assertObject(v);\n  assertHTTPRequestInfo(v.httpRequestInfo);\n  if (v.response !== undefined) {\n    assertPushResponse(v.response);\n  }\n}\n\nfunction assertPushResponse(v: unknown): asserts v is PushResponse {\n  if (isClientStateNotFoundResponse(v)) {\n    return;\n  }\n  assertVersionNotSupportedResponse(v);\n}\n\n/**\n * Pusher is the function type used to do the fetch part of a push. The request\n * is a POST request where the body is JSON with the type {@link PushRequest}.\n *\n * The return value should either be a {@link HTTPRequestInfo} or a\n * {@link PusherResult}. The reason for the two different return types is that\n * we didn't use to care about the response body of the push request. The\n * default pusher implementation checks if the response body is JSON and if it\n * matches the type {@link PusherResponse}. If it does, it is included in the\n * return value.\n */\nexport type Pusher = (\n  requestBody: PushRequest,\n  requestID: string,\n) => Promise<PusherResult>;\n\n/**\n * This error is thrown when the pusher fails for any reason.\n */\nexport class PushError extends Error {\n  name = 'PushError';\n  // causedBy is used instead of cause, because while cause has been proposed as a\n  // JavaScript language standard for this purpose (see\n  // https://github.com/tc39/proposal-error-cause) current browser behavior is\n  // inconsistent.\n  causedBy?: Error | undefined;\n  constructor(causedBy?: Error) {\n    super('Failed to push');\n    this.causedBy = causedBy;\n  }\n}\n"],"names":[],"mappings":";;;AAyBO,SAAS,mBAAmB,GAAuC;AACxE,eAAa,CAAC;AACd,wBAAsB,EAAE,eAAe;AACvC,MAAI,EAAE,aAAa,QAAW;AAC5B,uBAAmB,EAAE,QAAQ;AAAA,EAC/B;AACF;AAEA,SAAS,mBAAmB,GAAuC;AACjE,MAAI,8BAA8B,CAAC,GAAG;AACpC;AAAA,EACF;AACA,oCAAkC,CAAC;AACrC;AAqBO,MAAM,kBAAkB,MAAM;AAAA,EACnC,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,EAKP;AAAA,EACA,YAAY,UAAkB;AAC5B,UAAM,gBAAgB;AACtB,SAAK,WAAW;AAAA,EAClB;AACF;"}

package/out/replicache/src/replicache-impl.d.ts

@@ -1,4 +1,4 @@
-import { LogContext } from '@rocicorp/logger';
+import type { LogContext } from '@rocicorp/logger';
 import type { MaybePromise } from '../../shared/src/types.ts';
 import { type Cookie } from './cookies.ts';
 import { LazyStore } from './dag/lazy-store.ts';

package/out/replicache/src/replicache-impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replicache-impl.d.ts","sourceRoot":"","sources":["../../../../replicache/src/replicache-impl.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"replicache-impl.d.ts","sourceRoot":"","sources":["../../../../replicache/src/replicache-impl.ts"],"names":[],"mappings":"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"}