@rocicorp/zero 0.25.0 → 0.26.0-canary.0

package/out/replicache/src/connection-loop-delegates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-loop-delegates.js","sources":["../../../../replicache/src/connection-loop-delegates.ts"],"sourcesContent":["import type {ConnectionLoopDelegate} from './connection-loop.ts';\nimport type {ReplicacheImpl} from './replicache-impl.ts';\n\nclass ConnectionLoopDelegateImpl {\n  readonly rep: ReplicacheImpl;\n  readonly invokeSend: () => Promise<boolean>;\n\n  // TODO: Remove the ability to have more than one concurrent connection and update tests.\n  // Bug: https://github.com/rocicorp/replicache-internal/issues/303\n  readonly maxConnections = 1;\n\n  constructor(rep: ReplicacheImpl, invokeSend: () => Promise<boolean>) {\n    this.rep = rep;\n    this.invokeSend = invokeSend;\n  }\n\n  get maxDelayMs(): number {\n    return this.rep.requestOptions.maxDelayMs;\n  }\n\n  get minDelayMs(): number {\n    return this.rep.requestOptions.minDelayMs;\n  }\n}\n\nexport class PullDelegate\n  extends ConnectionLoopDelegateImpl\n  implements ConnectionLoopDelegate\n{\n  readonly debounceDelay = 0;\n\n  get watchdogTimer(): number | null {\n    return this.rep.pullInterval;\n  }\n}\n\nexport class PushDelegate\n  extends ConnectionLoopDelegateImpl\n  implements ConnectionLoopDelegate\n{\n  get debounceDelay(): number {\n    return this.rep.pushDelay;\n  }\n\n  watchdogTimer = null;\n}\n"],"names":[],"mappings":"AAGA,MAAM,2BAA2B;AAAA,EACtB;AAAA,EACA;AAAA;AAAA;AAAA,EAIA,iBAAiB;AAAA,EAE1B,YAAY,KAAqB,YAAoC;AACnE,SAAK,MAAM;AACX,SAAK,aAAa;AAAA,EACpB;AAAA,EAEA,IAAI,aAAqB;AACvB,WAAO,KAAK,IAAI,eAAe;AAAA,EACjC;AAAA,EAEA,IAAI,aAAqB;AACvB,WAAO,KAAK,IAAI,eAAe;AAAA,EACjC;AACF;AAEO,MAAM,qBACH,2BAEV;AAAA,EACW,gBAAgB;AAAA,EAEzB,IAAI,gBAA+B;AACjC,WAAO,KAAK,IAAI;AAAA,EAClB;AACF;AAEO,MAAM,qBACH,2BAEV;AAAA,EACE,IAAI,gBAAwB;AAC1B,WAAO,KAAK,IAAI;AAAA,EAClB;AAAA,EAEA,gBAAgB;AAClB;"}

package/out/replicache/src/connection-loop.js

@@ -0,0 +1,251 @@
+import { resolver } from "@rocicorp/resolver";
+import { sleep } from "../../shared/src/sleep.js";
+const MIN_DELAY_MS = 30;
+const MAX_DELAY_MS = 6e4;
+class ConnectionLoop {
+  // ConnectionLoop runs a loop sending network requests (either pushes or
+  // pulls) to the server. Our goal, generally, is to send requests as fast as
+  // we can, but to adjust in case of slowness, network errors, etc. We will
+  // send requests in parallel if the server supports it. We also debounce
+  // pushes since they frequently happen in series very near to one another
+  // (e.g., during drag'n drops).
+  //
+  // The loop flows through the following states forever, until it is closed:
+  //
+  // Pending: Wait for event or watchdog
+  //          |
+  //          v
+  // Debounce: Wait for more events (we debounce pushes)
+  //          |
+  //          v
+  // Wait for available connection (we limit number of parallel requests
+  // allowed)
+  //          |
+  //          v
+  // Wait to send (if requests are taking too long, we will slow down)
+  //          |
+  //          v
+  // Send (asynchronously, wrt the loop)
+  //          |
+  //          v
+  // Back to the pending!
+  // Controls whether the next iteration of the loop will wait at the pending
+  // state.
+  #pendingResolver = resolver();
+  /**
+   * This resolver is used to allow us to skip sleeps when we do send(true)
+   */
+  #skipSleepsResolver = resolver();
+  /**
+   * Resolver for the next send. Never rejects. Returns an error instead since
+   * this resolver is used in cases where they might not be someone waiting,
+   * and we don't want an unhandled promise rejection in that case.
+   */
+  #sendResolver = resolver();
+  #delegate;
+  #closed = false;
+  #abortSignal = new AbortController();
+  /**
+   * Number of pending send calls.
+   *
+   * We keep track of this because if close happens while we are waiting for the
+   * send to resolve we should reject the send promise.
+   */
+  #sendCounter = 0;
+  #lc;
+  #visibilityWatcher;
+  constructor(lc, delegate, visibilityWatcher) {
+    this.#lc = lc;
+    this.#delegate = delegate;
+    this.#visibilityWatcher = visibilityWatcher;
+    void this.run();
+  }
+  close() {
+    this.#closed = true;
+    this.#abortSignal.abort();
+    if (this.#sendCounter > 0) {
+      this.#sendResolver.resolve({ error: closeError() });
+    }
+  }
+  /**
+   *
+   * @returns Returns undefined if ok, otherwise it return the error that caused
+   * the send to fail.
+   */
+  async send(now) {
+    if (this.#closed) {
+      return { error: closeError() };
+    }
+    this.#sendCounter++;
+    this.#lc.debug?.("send", now);
+    if (now) {
+      this.#skipSleepsResolver.resolve();
+    } else {
+      await this.#visibilityWatcher?.waitForVisible();
+    }
+    this.#pendingResolver.resolve();
+    const result = await this.#sendResolver.promise;
+    this.#sendCounter--;
+    return result;
+  }
+  async run() {
+    const sendRecords = [];
+    let recoverResolver = resolver();
+    let lastSendTime;
+    let counter = 0;
+    const delegate = this.#delegate;
+    const { debug } = this.#lc;
+    let delay = 0;
+    debug?.("Starting connection loop");
+    const sleepMaybeSkip = (ms) => Promise.race([this.#skipSleepsResolver.promise, sleep(ms)]);
+    while (!this.#closed) {
+      debug?.(
+        didLastSendRequestFail(sendRecords) ? "Last request failed. Trying again" : "Waiting for a send"
+      );
+      const races = [this.#pendingResolver.promise];
+      const t = delegate.watchdogTimer;
+      if (t !== null) {
+        races.push(sleep(t, this.#abortSignal.signal).catch(() => {
+        }));
+      }
+      await Promise.race(races);
+      if (this.#closed) break;
+      debug?.("Waiting for debounce");
+      await sleepMaybeSkip(delegate.debounceDelay);
+      if (this.#closed) break;
+      debug?.("debounced");
+      this.#pendingResolver = resolver();
+      if (counter >= delegate.maxConnections) {
+        debug?.("Too many request in flight. Waiting until one finishes...");
+        await this.#waitUntilAvailableConnection();
+        if (this.#closed) break;
+        debug?.("...finished");
+      }
+      if (counter > 0 || didLastSendRequestFail(sendRecords)) {
+        delay = computeDelayAndUpdateDurations(delay, delegate, sendRecords);
+        debug?.(
+          didLastSendRequestFail(sendRecords) ? "Last connection errored. Sleeping for" : "More than one outstanding connection (" + counter + "). Sleeping for",
+          delay,
+          "ms"
+        );
+      } else {
+        delay = 0;
+      }
+      const clampedDelay = Math.min(
+        delegate.maxDelayMs,
+        Math.max(delegate.minDelayMs, delay)
+      );
+      if (lastSendTime !== void 0) {
+        const timeSinceLastSend = Date.now() - lastSendTime;
+        if (clampedDelay > timeSinceLastSend) {
+          await Promise.race([
+            sleepMaybeSkip(clampedDelay - timeSinceLastSend),
+            recoverResolver.promise
+          ]);
+          if (this.#closed) break;
+        }
+      }
+      counter++;
+      void (async () => {
+        const start = Date.now();
+        let ok;
+        let error;
+        try {
+          lastSendTime = start;
+          debug?.("Sending request");
+          this.#skipSleepsResolver = resolver();
+          ok = await delegate.invokeSend();
+          debug?.("Send returned", ok);
+        } catch (e) {
+          debug?.("Send failed", e);
+          error = e;
+          ok = false;
+        }
+        if (this.#closed) {
+          debug?.("Closed after invokeSend");
+          return;
+        }
+        debug?.("Request done", { duration: Date.now() - start, ok });
+        sendRecords.push({ duration: Date.now() - start, ok });
+        if (recovered(sendRecords)) {
+          recoverResolver.resolve();
+          recoverResolver = resolver();
+        }
+        counter--;
+        this.#connectionAvailable();
+        const sendResolver = this.#sendResolver;
+        this.#sendResolver = resolver();
+        if (error) {
+          sendResolver.resolve({ error });
+        } else {
+          sendResolver.resolve(void 0);
+        }
+        if (!ok) {
+          this.#pendingResolver.resolve();
+        }
+      })();
+    }
+  }
+  #waitingConnectionResolve = void 0;
+  #connectionAvailable() {
+    if (this.#waitingConnectionResolve) {
+      const resolve = this.#waitingConnectionResolve;
+      this.#waitingConnectionResolve = void 0;
+      resolve();
+    }
+  }
+  #waitUntilAvailableConnection() {
+    const { promise, resolve } = resolver();
+    this.#waitingConnectionResolve = resolve;
+    return promise;
+  }
+}
+const CONNECTION_MEMORY_COUNT = 9;
+function closeError() {
+  return new Error("Closed");
+}
+function computeDelayAndUpdateDurations(delay, delegate, sendRecords) {
+  const { length } = sendRecords;
+  if (length === 0) {
+    return delay;
+  }
+  const { ok } = sendRecords[sendRecords.length - 1];
+  const { maxConnections, minDelayMs } = delegate;
+  if (!ok) {
+    return delay === 0 ? minDelayMs : delay * 2;
+  }
+  if (length > 1) {
+    const previous = sendRecords[sendRecords.length - 2];
+    while (sendRecords.length > CONNECTION_MEMORY_COUNT) {
+      sendRecords.shift();
+    }
+    if (ok && !previous.ok) {
+      return minDelayMs;
+    }
+  }
+  const med = median(
+    sendRecords.filter(({ ok: ok2 }) => ok2).map(({ duration }) => duration)
+  );
+  return med / maxConnections | 0;
+}
+function median(values) {
+  values.sort();
+  const { length } = values;
+  const half = length >> 1;
+  if (length % 2 === 1) {
+    return values[half];
+  }
+  return (values[half - 1] + values[half]) / 2;
+}
+function didLastSendRequestFail(sendRecords) {
+  return sendRecords.length > 0 && !sendRecords[sendRecords.length - 1].ok;
+}
+function recovered(sendRecords) {
+  return sendRecords.length > 1 && !sendRecords[sendRecords.length - 2].ok && sendRecords[sendRecords.length - 1].ok;
+}
+export {
+  ConnectionLoop,
+  MAX_DELAY_MS,
+  MIN_DELAY_MS
+};
+//# sourceMappingURL=connection-loop.js.map

package/out/replicache/src/connection-loop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-loop.js","sources":["../../../../replicache/src/connection-loop.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {resolver} from '@rocicorp/resolver';\nimport type {DocumentVisibilityWatcher} from '../../shared/src/document-visible.ts';\nimport {sleep} from '../../shared/src/sleep.ts';\n\nexport const DEBOUNCE_DELAY_MS = 10;\n\nexport const MIN_DELAY_MS = 30;\nexport const MAX_DELAY_MS = 60_000;\n\ntype SendRecord = {duration: number; ok: boolean};\n\nexport interface ConnectionLoopDelegate {\n  invokeSend(): Promise<boolean>;\n  debounceDelay: number;\n  // If null, no watchdog timer is used.\n  watchdogTimer: number | null;\n  maxConnections: number;\n  maxDelayMs: number;\n  minDelayMs: number;\n}\n\nexport class ConnectionLoop {\n  // ConnectionLoop runs a loop sending network requests (either pushes or\n  // pulls) to the server. Our goal, generally, is to send requests as fast as\n  // we can, but to adjust in case of slowness, network errors, etc. We will\n  // send requests in parallel if the server supports it. We also debounce\n  // pushes since they frequently happen in series very near to one another\n  // (e.g., during drag'n drops).\n  //\n  // The loop flows through the following states forever, until it is closed:\n  //\n  // Pending: Wait for event or watchdog\n  //          |\n  //          v\n  // Debounce: Wait for more events (we debounce pushes)\n  //          |\n  //          v\n  // Wait for available connection (we limit number of parallel requests\n  // allowed)\n  //          |\n  //          v\n  // Wait to send (if requests are taking too long, we will slow down)\n  //          |\n  //          v\n  // Send (asynchronously, wrt the loop)\n  //          |\n  //          v\n  // Back to the pending!\n\n  // Controls whether the next iteration of the loop will wait at the pending\n  // state.\n  #pendingResolver = resolver<void>();\n\n  /**\n   * This resolver is used to allow us to skip sleeps when we do send(true)\n   */\n  #skipSleepsResolver = resolver<void>();\n\n  /**\n   * Resolver for the next send. Never rejects. Returns an error instead since\n   * this resolver is used in cases where they might not be someone waiting,\n   * and we don't want an unhandled promise rejection in that case.\n   */\n  #sendResolver = resolver<undefined | {error: unknown}>();\n\n  readonly #delegate: ConnectionLoopDelegate;\n  #closed = false;\n  #abortSignal = new AbortController();\n\n  /**\n   * Number of pending send calls.\n   *\n   * We keep track of this because if close happens while we are waiting for the\n   * send to resolve we should reject the send promise.\n   */\n  #sendCounter = 0;\n  readonly #lc: LogContext;\n  readonly #visibilityWatcher: DocumentVisibilityWatcher | undefined;\n\n  constructor(\n    lc: LogContext,\n    delegate: ConnectionLoopDelegate,\n    visibilityWatcher?: DocumentVisibilityWatcher,\n  ) {\n    this.#lc = lc;\n    this.#delegate = delegate;\n    this.#visibilityWatcher = visibilityWatcher;\n    void this.run();\n  }\n\n  close(): void {\n    this.#closed = true;\n    this.#abortSignal.abort();\n    if (this.#sendCounter > 0) {\n      this.#sendResolver.resolve({error: closeError()});\n    }\n  }\n\n  /**\n   *\n   * @returns Returns undefined if ok, otherwise it return the error that caused\n   * the send to fail.\n   */\n  async send(now: boolean): Promise<undefined | {error: unknown}> {\n    if (this.#closed) {\n      return {error: closeError()};\n    }\n    this.#sendCounter++;\n    this.#lc.debug?.('send', now);\n    if (now) {\n      this.#skipSleepsResolver.resolve();\n    } else {\n      await this.#visibilityWatcher?.waitForVisible();\n    }\n\n    this.#pendingResolver.resolve();\n\n    const result = await this.#sendResolver.promise;\n    this.#sendCounter--;\n    return result;\n  }\n\n  async run(): Promise<void> {\n    const sendRecords: SendRecord[] = [];\n\n    let recoverResolver = resolver();\n    let lastSendTime;\n\n    // The number of active connections.\n    let counter = 0;\n    const delegate = this.#delegate;\n    const {debug} = this.#lc;\n    let delay = 0;\n\n    debug?.('Starting connection loop');\n\n    const sleepMaybeSkip: typeof sleep = ms =>\n      Promise.race([this.#skipSleepsResolver.promise, sleep(ms)]);\n\n    while (!this.#closed) {\n      debug?.(\n        didLastSendRequestFail(sendRecords)\n          ? 'Last request failed. Trying again'\n          : 'Waiting for a send',\n      );\n\n      // Wait until send is called or until the watchdog timer fires.\n      const races = [this.#pendingResolver.promise];\n      const t = delegate.watchdogTimer;\n      if (t !== null) {\n        // Wait for the watchdog timer to fire or the abort signal to be triggered.\n        races.push(sleep(t, this.#abortSignal.signal).catch(() => {}));\n      }\n      await Promise.race(races);\n      if (this.#closed) break;\n\n      debug?.('Waiting for debounce');\n      await sleepMaybeSkip(delegate.debounceDelay);\n      if (this.#closed) break;\n      debug?.('debounced');\n\n      // This resolver is used to wait for incoming push calls.\n      this.#pendingResolver = resolver();\n\n      if (counter >= delegate.maxConnections) {\n        debug?.('Too many request in flight. Waiting until one finishes...');\n        await this.#waitUntilAvailableConnection();\n        if (this.#closed) break;\n        debug?.('...finished');\n      }\n\n      // We need to delay the next request even if there are no active requests\n      // in case of error.\n      if (counter > 0 || didLastSendRequestFail(sendRecords)) {\n        delay = computeDelayAndUpdateDurations(delay, delegate, sendRecords);\n        debug?.(\n          didLastSendRequestFail(sendRecords)\n            ? 'Last connection errored. Sleeping for'\n            : 'More than one outstanding connection (' +\n                counter +\n                '). Sleeping for',\n          delay,\n          'ms',\n        );\n      } else {\n        // We set this to 0 here in case minDelayMs is mutated to a lower value\n        // than the old delay so that we still get minDelayMs. This can happen\n        // if we get an error during a run where minDelayMs is larger than the\n        // current value of minDelayMs.\n        delay = 0;\n      }\n\n      const clampedDelay = Math.min(\n        delegate.maxDelayMs,\n        Math.max(delegate.minDelayMs, delay),\n      );\n      if (lastSendTime !== undefined) {\n        const timeSinceLastSend = Date.now() - lastSendTime;\n        if (clampedDelay > timeSinceLastSend) {\n          await Promise.race([\n            sleepMaybeSkip(clampedDelay - timeSinceLastSend),\n            recoverResolver.promise,\n          ]);\n          if (this.#closed) break;\n        }\n      }\n\n      counter++;\n      void (async () => {\n        const start = Date.now();\n        let ok: boolean;\n        let error: unknown;\n        try {\n          lastSendTime = start;\n          debug?.('Sending request');\n          this.#skipSleepsResolver = resolver();\n          ok = await delegate.invokeSend();\n          debug?.('Send returned', ok);\n        } catch (e) {\n          debug?.('Send failed', e);\n          error = e;\n          ok = false;\n        }\n        if (this.#closed) {\n          debug?.('Closed after invokeSend');\n          return;\n        }\n        debug?.('Request done', {duration: Date.now() - start, ok});\n        sendRecords.push({duration: Date.now() - start, ok});\n        if (recovered(sendRecords)) {\n          recoverResolver.resolve();\n          recoverResolver = resolver();\n        }\n        counter--;\n        this.#connectionAvailable();\n        const sendResolver = this.#sendResolver;\n        this.#sendResolver = resolver();\n        if (error) {\n          sendResolver.resolve({error});\n        } else {\n          sendResolver.resolve(undefined);\n        }\n        if (!ok) {\n          // Keep trying\n          this.#pendingResolver.resolve();\n        }\n      })();\n    }\n  }\n\n  #waitingConnectionResolve: (() => void) | undefined = undefined;\n\n  #connectionAvailable() {\n    if (this.#waitingConnectionResolve) {\n      const resolve = this.#waitingConnectionResolve;\n      this.#waitingConnectionResolve = undefined;\n      resolve();\n    }\n  }\n\n  #waitUntilAvailableConnection() {\n    const {promise, resolve} = resolver();\n    this.#waitingConnectionResolve = resolve;\n    return promise;\n  }\n}\n\n// Number of connections to remember when computing the new delay.\nconst CONNECTION_MEMORY_COUNT = 9;\n\nfunction closeError() {\n  return new Error('Closed');\n}\n\n// Computes a new delay based on the previous requests. We use the median of the\n// previous successful request divided by `maxConnections`. When we get errors\n// we do exponential backoff. As soon as we recover from an error we reset back\n// to delegate.minDelayMs.\nfunction computeDelayAndUpdateDurations(\n  delay: number,\n  delegate: ConnectionLoopDelegate,\n  sendRecords: SendRecord[],\n): number {\n  const {length} = sendRecords;\n  if (length === 0) {\n    return delay;\n  }\n\n  const {ok} = sendRecords[sendRecords.length - 1];\n  const {maxConnections, minDelayMs} = delegate;\n\n  if (!ok) {\n    return delay === 0 ? minDelayMs : delay * 2;\n  }\n\n  if (length > 1) {\n    // length > 1\n    const previous: SendRecord = sendRecords[sendRecords.length - 2];\n\n    // Prune\n    while (sendRecords.length > CONNECTION_MEMORY_COUNT) {\n      sendRecords.shift();\n    }\n\n    if (ok && !previous.ok) {\n      // Recovered\n      return minDelayMs;\n    }\n  }\n\n  const med = median(\n    sendRecords.filter(({ok}) => ok).map(({duration}) => duration),\n  );\n\n  return (med / maxConnections) | 0;\n}\n\nfunction median(values: number[]) {\n  values.sort();\n  const {length} = values;\n  const half = length >> 1;\n  if (length % 2 === 1) {\n    return values[half];\n  }\n  return (values[half - 1] + values[half]) / 2;\n}\n\nfunction didLastSendRequestFail(sendRecords: SendRecord[]) {\n  return sendRecords.length > 0 && !sendRecords[sendRecords.length - 1].ok;\n}\n\nfunction recovered(sendRecords: SendRecord[]) {\n  return (\n    sendRecords.length > 1 &&\n    !sendRecords[sendRecords.length - 2].ok &&\n    sendRecords[sendRecords.length - 1].ok\n  );\n}\n"],"names":["ok"],"mappings":"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"}

package/out/replicache/src/cookies.js

@@ -0,0 +1,40 @@
+import { assertJSONObject } from "../../shared/src/json.js";
+import { stringCompare } from "../../shared/src/string-compare.js";
+function compareCookies(a, b) {
+  if (a === b) {
+    return 0;
+  }
+  if (a === null) {
+    return -1;
+  }
+  if (b === null) {
+    return 1;
+  }
+  const cva = getCompareValue(a);
+  const cvb = getCompareValue(b);
+  if (typeof cva === "string" || typeof cvb === "string") {
+    return stringCompare(String(cva), String(cvb));
+  }
+  return cva - cvb;
+}
+function getCompareValue(cookie) {
+  if (typeof cookie === "string" || typeof cookie === "number") {
+    return cookie;
+  }
+  return cookie.order;
+}
+function assertCookie(v) {
+  if (v === null || typeof v === "string" || typeof v === "number") {
+    return;
+  }
+  assertJSONObject(v);
+  if (typeof v.order === "string" || typeof v.order === "number") {
+    return;
+  }
+  throw new Error("Invalid cookie");
+}
+export {
+  assertCookie,
+  compareCookies
+};
+//# sourceMappingURL=cookies.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cookies.js","sources":["../../../../replicache/src/cookies.ts"],"sourcesContent":["import {\n  assertJSONObject,\n  type ReadonlyJSONValue,\n} from '../../shared/src/json.ts';\nimport {stringCompare} from '../../shared/src/string-compare.ts';\nimport type {FrozenJSONValue} from './frozen-json.ts';\n\n/**\n * A cookie is a value that is used to determine the order of snapshots. It\n * needs to be comparable. This can be a `string`, `number` or if you want to\n * use a more complex value, you can use an object with an `order` property. The\n * value `null` is considered to be less than any other cookie and it is used\n * for the first pull when no cookie has been set.\n *\n * The order is the natural order of numbers and strings. If one of the cookies\n * is an object then the value of the `order` property is treated as the cookie\n * when doing comparison.\n *\n * If one of the cookies is a string and the other is a number, the number is\n * fist converted to a string (using `toString()`).\n */\nexport type Cookie =\n  | null\n  | string\n  | number\n  | (ReadonlyJSONValue & {readonly order: number | string});\n\nexport type FrozenCookie =\n  | null\n  | string\n  | number\n  | (FrozenJSONValue & {readonly order: number | string});\n\n/**\n * Compare two cookies.\n * `null` is considered to be less than any other cookie.\n */\nexport function compareCookies(a: Cookie, b: Cookie): number {\n  if (a === b) {\n    return 0;\n  }\n  if (a === null) {\n    return -1;\n  }\n  if (b === null) {\n    return 1;\n  }\n\n  const cva = getCompareValue(a);\n  const cvb = getCompareValue(b);\n\n  // If either a or b is a string. Compare by string.\n  if (typeof cva === 'string' || typeof cvb === 'string') {\n    return stringCompare(String(cva), String(cvb));\n  }\n\n  return cva - cvb;\n}\n\ntype NonNull<T> = T extends null ? never : T;\n\nfunction getCompareValue(cookie: NonNull<Cookie>): string | number {\n  if (typeof cookie === 'string' || typeof cookie === 'number') {\n    return cookie;\n  }\n  return cookie.order;\n}\n\nexport function assertCookie(v: unknown): asserts v is Cookie {\n  if (v === null || typeof v === 'string' || typeof v === 'number') {\n    return;\n  }\n\n  assertJSONObject(v);\n  if (typeof v.order === 'string' || typeof v.order === 'number') {\n    return;\n  }\n\n  throw new Error('Invalid cookie');\n}\n"],"names":[],"mappings":";;AAqCO,SAAS,eAAe,GAAW,GAAmB;AAC3D,MAAI,MAAM,GAAG;AACX,WAAO;AAAA,EACT;AACA,MAAI,MAAM,MAAM;AACd,WAAO;AAAA,EACT;AACA,MAAI,MAAM,MAAM;AACd,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,gBAAgB,CAAC;AAC7B,QAAM,MAAM,gBAAgB,CAAC;AAG7B,MAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ,UAAU;AACtD,WAAO,cAAc,OAAO,GAAG,GAAG,OAAO,GAAG,CAAC;AAAA,EAC/C;AAEA,SAAO,MAAM;AACf;AAIA,SAAS,gBAAgB,QAA0C;AACjE,MAAI,OAAO,WAAW,YAAY,OAAO,WAAW,UAAU;AAC5D,WAAO;AAAA,EACT;AACA,SAAO,OAAO;AAChB;AAEO,SAAS,aAAa,GAAiC;AAC5D,MAAI,MAAM,QAAQ,OAAO,MAAM,YAAY,OAAO,MAAM,UAAU;AAChE;AAAA,EACF;AAEA,mBAAiB,CAAC;AAClB,MAAI,OAAO,EAAE,UAAU,YAAY,OAAO,EAAE,UAAU,UAAU;AAC9D;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,gBAAgB;AAClC;"}

package/out/replicache/src/dag/chunk.js

@@ -0,0 +1,59 @@
+import { assertString, assert } from "../../../shared/src/asserts.js";
+import { assertDeepFrozen } from "../frozen-json.js";
+function asRefs(sortedRefs) {
+  return sortedRefs;
+}
+function toRefs(refs) {
+  if (Array.isArray(refs)) {
+    refs.sort();
+    for (let i = 1; i < refs.length; i++) {
+      assert(refs[i - 1] !== refs[i], "Refs must not have duplicates");
+    }
+    return asRefs(refs);
+  }
+  const refsArray = [...refs];
+  refsArray.sort();
+  return asRefs(refsArray);
+}
+class Chunk {
+  hash;
+  data;
+  /**
+   * Meta is an array of refs. If there are no refs we do not write a meta
+   * chunk.
+   */
+  meta;
+  constructor(hash, data, refs) {
+    assert(
+      !refs.includes(hash),
+      "Chunk cannot reference itself"
+    );
+    assertDeepFrozen(data);
+    this.hash = hash;
+    this.data = data;
+    this.meta = refs;
+  }
+}
+function assertRefs(v) {
+  if (!Array.isArray(v)) {
+    throw new Error("Refs must be an array");
+  }
+  if (v.length > 0) {
+    assertString(v[0]);
+    for (let i = 1; i < v.length; i++) {
+      assertString(v[i]);
+    }
+  }
+}
+function createChunk(data, refs, chunkHasher) {
+  const hash = chunkHasher();
+  return new Chunk(hash, data, refs);
+}
+export {
+  Chunk,
+  asRefs,
+  assertRefs,
+  createChunk,
+  toRefs
+};
+//# sourceMappingURL=chunk.js.map

package/out/replicache/src/dag/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.js","sources":["../../../../../replicache/src/dag/chunk.ts"],"sourcesContent":["import {assert, assertString} from '../../../shared/src/asserts.ts';\nimport {assertDeepFrozen} from '../frozen-json.ts';\nimport type {Hash} from '../hash.ts';\n\n// By using declare we tell the type system that there is a unique symbol.\n// However, there is no such symbol but the type system does not care.\ndeclare const refsTag: unique symbol;\n\n/**\n * Opaque type representing a Refs. The reason to use an opaque type here is to\n * make sure that Refs are always sorted and have no duplicates.\n */\nexport type Refs = [] | readonly [Hash] | (readonly Hash[] & {[refsTag]: true});\n\n/**\n * Convert to a Refs when we already know it is sorted and has no duplicates.\n */\nexport function asRefs(sortedRefs: Hash[]): Refs {\n  return sortedRefs as unknown as Refs;\n}\n\n/**\n * Sorts and tags as Refs. If an Array is passed in the array is sorted in\n * place, otherwise a copy of the iterable is created. This checks for duplicates.\n */\nexport function toRefs(refs: Hash[] | Set<Hash>): Refs {\n  if (Array.isArray(refs)) {\n    refs.sort();\n    for (let i = 1; i < refs.length; i++) {\n      assert(refs[i - 1] !== refs[i], 'Refs must not have duplicates');\n    }\n    return asRefs(refs);\n  }\n\n  const refsArray = [...refs];\n  refsArray.sort();\n  // no need to check for duplicates as Set cannot have duplicates.\n  return asRefs(refsArray);\n}\n\nexport class Chunk<V = unknown> {\n  readonly hash: Hash;\n  readonly data: V;\n\n  /**\n   * Meta is an array of refs. If there are no refs we do not write a meta\n   * chunk.\n   */\n  readonly meta: Refs;\n\n  constructor(hash: Hash, data: V, refs: Refs) {\n    assert(\n      !(refs as unknown[]).includes(hash),\n      'Chunk cannot reference itself',\n    );\n    assertDeepFrozen(data);\n    this.hash = hash;\n    this.data = data;\n    this.meta = refs;\n  }\n}\n\nexport function assertRefs(v: unknown): asserts v is Refs {\n  if (!Array.isArray(v)) {\n    throw new Error('Refs must be an array');\n  }\n  if (v.length > 0) {\n    assertString(v[0]);\n    for (let i = 1; i < v.length; i++) {\n      assertString(v[i]);\n    }\n  }\n}\n\nexport function createChunk<V>(\n  data: V,\n  refs: Refs,\n  chunkHasher: ChunkHasher,\n): Chunk<V> {\n  const hash = chunkHasher();\n  return new Chunk(hash, data, refs);\n}\n\nexport type CreateChunk = <V>(data: V, refs: Refs) => Chunk<V>;\n\nexport type ChunkHasher = () => Hash;\n\nexport function throwChunkHasher(): Hash {\n  throw new Error('unexpected call to compute chunk hash');\n}\n"],"names":[],"mappings":";;AAiBO,SAAS,OAAO,YAA0B;AAC/C,SAAO;AACT;AAMO,SAAS,OAAO,MAAgC;AACrD,MAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,SAAK,KAAA;AACL,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,aAAO,KAAK,IAAI,CAAC,MAAM,KAAK,CAAC,GAAG,+BAA+B;AAAA,IACjE;AACA,WAAO,OAAO,IAAI;AAAA,EACpB;AAEA,QAAM,YAAY,CAAC,GAAG,IAAI;AAC1B,YAAU,KAAA;AAEV,SAAO,OAAO,SAAS;AACzB;AAEO,MAAM,MAAmB;AAAA,EACrB;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA;AAAA,EAET,YAAY,MAAY,MAAS,MAAY;AAC3C;AAAA,MACE,CAAE,KAAmB,SAAS,IAAI;AAAA,MAClC;AAAA,IAAA;AAEF,qBAAiB,IAAI;AACrB,SAAK,OAAO;AACZ,SAAK,OAAO;AACZ,SAAK,OAAO;AAAA,EACd;AACF;AAEO,SAAS,WAAW,GAA+B;AACxD,MAAI,CAAC,MAAM,QAAQ,CAAC,GAAG;AACrB,UAAM,IAAI,MAAM,uBAAuB;AAAA,EACzC;AACA,MAAI,EAAE,SAAS,GAAG;AAChB,iBAAa,EAAE,CAAC,CAAC;AACjB,aAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,mBAAa,EAAE,CAAC,CAAC;AAAA,IACnB;AAAA,EACF;AACF;AAEO,SAAS,YACd,MACA,MACA,aACU;AACV,QAAM,OAAO,YAAA;AACb,SAAO,IAAI,MAAM,MAAM,MAAM,IAAI;AACnC;"}

package/out/replicache/src/dag/gc.js

@@ -0,0 +1,117 @@
+import { assert, assertNumber } from "../../../shared/src/asserts.js";
+import { isProd } from "../../../shared/src/config.js";
+import { emptyHash } from "../hash.js";
+function computeRefCountUpdates(headChanges, putChunks, delegate) {
+  return new RefCountUpdates(headChanges, putChunks, delegate).compute();
+}
+class RefCountUpdates {
+  #newHeads;
+  #oldHeads;
+  #putChunks;
+  #delegate;
+  #refsCounted;
+  #refCountUpdates;
+  #loadedRefCountPromises;
+  #isLazyDelegate;
+  constructor(headChanges, putChunks, delegate) {
+    const newHeads = [];
+    const oldHeads = [];
+    for (const changedHead of headChanges) {
+      if (changedHead.old !== changedHead.new) {
+        changedHead.old && oldHeads.push(changedHead.old);
+        changedHead.new && newHeads.push(changedHead.new);
+      }
+    }
+    this.#newHeads = newHeads;
+    this.#oldHeads = oldHeads;
+    this.#putChunks = putChunks;
+    this.#delegate = delegate;
+    this.#refCountUpdates = /* @__PURE__ */ new Map();
+    this.#loadedRefCountPromises = /* @__PURE__ */ new Map();
+    this.#isLazyDelegate = delegate.areRefsCounted !== void 0;
+    this.#refsCounted = this.#isLazyDelegate ? /* @__PURE__ */ new Set() : null;
+  }
+  async compute() {
+    for (const n of this.#newHeads) {
+      await this.#changeRefCount(n, 1);
+    }
+    await Promise.all(
+      Array.from(
+        this.#putChunks.values(),
+        (hash) => this.#ensureRefCountLoaded(hash)
+      )
+    );
+    if (this.#isLazyDelegate) {
+      assert(this.#delegate.areRefsCounted);
+      assert(this.#refsCounted);
+      let refCountsUpdated;
+      do {
+        refCountsUpdated = false;
+        for (const hash of this.#putChunks.values()) {
+          if (!this.#delegate.areRefsCounted(hash) && !this.#refsCounted.has(hash) && this.#refCountUpdates.get(hash) !== 0) {
+            await this.#updateRefsCounts(hash, 1);
+            refCountsUpdated = true;
+            break;
+          }
+        }
+      } while (refCountsUpdated);
+    }
+    for (const o of this.#oldHeads) {
+      await this.#changeRefCount(o, -1);
+    }
+    if (!isProd) {
+      for (const [hash, update] of this.#refCountUpdates) {
+        assert(
+          update >= 0,
+          `ref count update must be non-negative. ${hash}:${update}`
+        );
+      }
+    }
+    return this.#refCountUpdates;
+  }
+  async #changeRefCount(hash, delta) {
+    await this.#ensureRefCountLoaded(hash);
+    if (this.#updateRefCount(hash, delta)) {
+      await this.#updateRefsCounts(hash, delta);
+    }
+  }
+  async #updateRefsCounts(hash, delta) {
+    if (hash === emptyHash) {
+      return;
+    }
+    const refs = await this.#delegate.getRefs(hash);
+    if (!isProd) {
+      assert(
+        refs || this.#isLazyDelegate && !this.#putChunks.has(hash),
+        "refs must be defined"
+      );
+    }
+    if (refs !== void 0) {
+      this.#refsCounted?.add(hash);
+      const ps = refs.map((ref) => this.#changeRefCount(ref, delta));
+      await Promise.all(ps);
+    }
+  }
+  #ensureRefCountLoaded(hash) {
+    let p = this.#loadedRefCountPromises.get(hash);
+    if (p === void 0) {
+      p = (async () => {
+        const value = await this.#delegate.getRefCount(hash) || 0;
+        this.#refCountUpdates.set(hash, value);
+        return value;
+      })();
+      this.#loadedRefCountPromises.set(hash, p);
+    }
+    return p;
+  }
+  #updateRefCount(hash, delta) {
+    const oldCount = this.#refCountUpdates.get(hash);
+    assertNumber(oldCount);
+    this.#refCountUpdates.set(hash, oldCount + delta);
+    return oldCount === 0 && delta === 1 || oldCount === 1 && delta === -1;
+  }
+}
+export {
+  computeRefCountUpdates
+};
+//# sourceMappingURL=gc.js.map

package/out/replicache/src/dag/gc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gc.js","sources":["../../../../../replicache/src/dag/gc.ts"],"sourcesContent":["import {assert, assertNumber} from '../../../shared/src/asserts.ts';\nimport type {MaybePromise} from '../../../shared/src/types.ts';\nimport {skipGCAsserts} from '../config.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\n\nexport type HeadChange = {\n  new: Hash | undefined;\n  old: Hash | undefined;\n};\n\ntype LoadedRefCountPromises = Map<Hash, Promise<number>>;\n\nexport interface RefCountUpdatesDelegate {\n  getRefCount: (hash: Hash) => MaybePromise<number | undefined>;\n  getRefs: (hash: Hash) => MaybePromise<readonly Hash[] | undefined>;\n  /**\n   * Should be implemented if the store lazily loads refs, returning whether\n   * or not the chunks refs have already been counted (i.e. are reflected\n   * in `getRefCount`).\n   *\n   * If defined then:\n   *  - `getRefs` should return undefined for refs that have not been loaded,\n   *    but should never return undefined for hashes in `putChunks`.\n   *  - it is assumed that chunks in `putChunks` may have been reachable before\n   *    the write, but may not have been counted.  This method is used to\n   *    determine if they have been counted or not.  If they have not been\n   *    counted, and are reachable with the write applied, the returned\n   *    ref count updates will include updates for counting them.\n   *\n   * If undefined then:\n   *  - `getRefs` should never return undefined\n   *  - it is assumed that the refs of any chunks which were reachable before\n   *    the write are already counted\n   */\n  areRefsCounted?: (hash: Hash) => boolean;\n}\n\n/**\n * Computes how ref counts should be updated when a dag write is committed.\n * Does not modify the dag store.\n * @param headChanges Heads that were changed by the dag write.\n * @param putChunks Chunks that were put by the dag write.\n * @param delegate Delegate used for getting ref information from the dag store.\n * @returns Map from chunk Hash to changed ref counts.  Chunks with a new ref\n * count of 0 should be deleted.  All hashes in `putChunks` will have an entry\n * (which will be zero if the newly put chunk is not reachable from any head).\n */\nexport function computeRefCountUpdates(\n  headChanges: Iterable<HeadChange>,\n  putChunks: ReadonlySet<Hash>,\n  delegate: RefCountUpdatesDelegate,\n): Promise<Map<Hash, number>> {\n  return new RefCountUpdates(headChanges, putChunks, delegate).compute();\n}\n\nclass RefCountUpdates {\n  readonly #newHeads: Hash[];\n  readonly #oldHeads: Hash[];\n  readonly #putChunks: ReadonlySet<Hash>;\n  readonly #delegate: RefCountUpdatesDelegate;\n  readonly #refsCounted: Set<Hash> | null;\n  readonly #refCountUpdates: Map<Hash, number>;\n  readonly #loadedRefCountPromises: LoadedRefCountPromises;\n  readonly #isLazyDelegate: boolean;\n\n  constructor(\n    headChanges: Iterable<HeadChange>,\n    putChunks: ReadonlySet<Hash>,\n    delegate: RefCountUpdatesDelegate,\n  ) {\n    const newHeads: Hash[] = [];\n    const oldHeads: Hash[] = [];\n    for (const changedHead of headChanges) {\n      if (changedHead.old !== changedHead.new) {\n        changedHead.old && oldHeads.push(changedHead.old);\n        changedHead.new && newHeads.push(changedHead.new);\n      }\n    }\n    this.#newHeads = newHeads;\n    this.#oldHeads = oldHeads;\n    this.#putChunks = putChunks;\n    this.#delegate = delegate;\n    this.#refCountUpdates = new Map();\n    // This map is used to ensure we do not load the ref count key more than once.\n    // Once it is loaded we only operate on a cache of the ref counts.\n    this.#loadedRefCountPromises = new Map();\n    this.#isLazyDelegate = delegate.areRefsCounted !== undefined;\n    this.#refsCounted = this.#isLazyDelegate ? new Set() : null;\n  }\n\n  async compute(): Promise<Map<Hash, number>> {\n    for (const n of this.#newHeads) {\n      await this.#changeRefCount(n, 1);\n    }\n\n    // Now go through the put chunks to ensure each has an entry in\n    // refCountUpdates (zero for new chunks which are not reachable from\n    // newHeads).\n    await Promise.all(\n      Array.from(this.#putChunks.values(), hash =>\n        this.#ensureRefCountLoaded(hash),\n      ),\n    );\n\n    if (this.#isLazyDelegate) {\n      assert(this.#delegate.areRefsCounted);\n      assert(this.#refsCounted);\n      let refCountsUpdated;\n      do {\n        refCountsUpdated = false;\n        for (const hash of this.#putChunks.values()) {\n          if (\n            !this.#delegate.areRefsCounted(hash) &&\n            !this.#refsCounted.has(hash) &&\n            this.#refCountUpdates.get(hash) !== 0\n          ) {\n            await this.#updateRefsCounts(hash, 1);\n            refCountsUpdated = true;\n            break;\n          }\n        }\n      } while (refCountsUpdated);\n    }\n\n    for (const o of this.#oldHeads) {\n      await this.#changeRefCount(o, -1);\n    }\n\n    if (!skipGCAsserts) {\n      for (const [hash, update] of this.#refCountUpdates) {\n        assert(\n          update >= 0,\n          `ref count update must be non-negative. ${hash}:${update}`,\n        );\n      }\n    }\n\n    return this.#refCountUpdates;\n  }\n\n  async #changeRefCount(hash: Hash, delta: number): Promise<void> {\n    // First make sure that we have the ref count in the cache. This is async\n    // because it might need to load the ref count from the store (via the delegate).\n    //\n    // Once we have loaded the ref count all the updates to it are sync to\n    // prevent race conditions.\n    await this.#ensureRefCountLoaded(hash);\n    if (this.#updateRefCount(hash, delta)) {\n      await this.#updateRefsCounts(hash, delta);\n    }\n  }\n\n  async #updateRefsCounts(hash: Hash, delta: number) {\n    if (hash === emptyHash) {\n      return;\n    }\n    const refs = await this.#delegate.getRefs(hash);\n    if (!skipGCAsserts) {\n      assert(\n        refs || (this.#isLazyDelegate && !this.#putChunks.has(hash)),\n        'refs must be defined',\n      );\n    }\n\n    if (refs !== undefined) {\n      this.#refsCounted?.add(hash);\n      const ps = refs.map(ref => this.#changeRefCount(ref, delta));\n      await Promise.all(ps);\n    }\n  }\n\n  #ensureRefCountLoaded(hash: Hash): Promise<number> {\n    // Only get the ref count once.\n    let p = this.#loadedRefCountPromises.get(hash);\n    if (p === undefined) {\n      p = (async () => {\n        const value = (await this.#delegate.getRefCount(hash)) || 0;\n        this.#refCountUpdates.set(hash, value);\n        return value;\n      })();\n      this.#loadedRefCountPromises.set(hash, p);\n    }\n    return p;\n  }\n\n  #updateRefCount(hash: Hash, delta: number): boolean {\n    const oldCount = this.#refCountUpdates.get(hash);\n    assertNumber(oldCount);\n    this.#refCountUpdates.set(hash, oldCount + delta);\n    return (oldCount === 0 && delta === 1) || (oldCount === 1 && delta === -1);\n  }\n}\n"],"names":["skipGCAsserts"],"mappings":"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"}

package/out/replicache/src/dag/key.js

@@ -0,0 +1,20 @@
+import "../hash.js";
+function chunkDataKey(hash) {
+  return `c/${hash}/d`;
+}
+function chunkMetaKey(hash) {
+  return `c/${hash}/m`;
+}
+function chunkRefCountKey(hash) {
+  return `c/${hash}/r`;
+}
+function headKey(name) {
+  return `h/${name}`;
+}
+export {
+  chunkDataKey,
+  chunkMetaKey,
+  chunkRefCountKey,
+  headKey
+};
+//# sourceMappingURL=key.js.map

package/out/replicache/src/dag/key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.js","sources":["../../../../../replicache/src/dag/key.ts"],"sourcesContent":["import {type Hash, parse as parseHash} from '../hash.ts';\nimport * as KeyType from './key-type-enum.ts';\n\nexport function chunkDataKey(hash: Hash): string {\n  return `c/${hash}/d`;\n}\n\nexport function chunkMetaKey(hash: Hash): string {\n  return `c/${hash}/m`;\n}\n\nexport function chunkRefCountKey(hash: Hash): string {\n  return `c/${hash}/r`;\n}\n\nexport function headKey(name: string): string {\n  return `h/${name}`;\n}\n\nexport type Key =\n  | {\n      type: KeyType.ChunkData;\n      hash: Hash;\n    }\n  | {\n      type: KeyType.ChunkMeta;\n      hash: Hash;\n    }\n  | {\n      type: KeyType.ChunkRefCount;\n      hash: Hash;\n    }\n  | {\n      type: KeyType.Head;\n      name: string;\n    };\n\nexport function parse(key: string): Key {\n  const invalidKey = () => new Error(`Invalid key. Got \"${key}\"`);\n  const hash = () => parseHash(key.substring(2, key.length - 2));\n\n  // '/'\n  if (key.charCodeAt(1) === 47) {\n    switch (key.charCodeAt(0)) {\n      // c\n      case 99: {\n        if (key.length < 4 || key.charCodeAt(key.length - 2) !== 47) {\n          throw invalidKey();\n        }\n        switch (key.charCodeAt(key.length - 1)) {\n          case 100: // d\n            return {\n              type: KeyType.ChunkData,\n              hash: hash(),\n            };\n          case 109: // m\n            return {\n              type: KeyType.ChunkMeta,\n              hash: hash(),\n            };\n          case 114: // r\n            return {\n              type: KeyType.ChunkRefCount,\n              hash: hash(),\n            };\n        }\n        break;\n      }\n      case 104: // h\n        return {\n          type: KeyType.Head,\n          name: key.substring(2),\n        };\n    }\n  }\n  throw invalidKey();\n}\n"],"names":[],"mappings":";AAGO,SAAS,aAAa,MAAoB;AAC/C,SAAO,KAAK,IAAI;AAClB;AAEO,SAAS,aAAa,MAAoB;AAC/C,SAAO,KAAK,IAAI;AAClB;AAEO,SAAS,iBAAiB,MAAoB;AACnD,SAAO,KAAK,IAAI;AAClB;AAEO,SAAS,QAAQ,MAAsB;AAC5C,SAAO,KAAK,IAAI;AAClB;"}

package/out/replicache/src/dag/lazy-store.d.ts

@@ -1,6 +1,7 @@
 import type { MaybePromise } from '../../../shared/src/types.ts';
 import type { Hash } from '../hash.ts';
-import { Chunk, type ChunkHasher, type Refs } from './chunk.ts';
+import type { Chunk } from './chunk.ts';
+import { type ChunkHasher, type Refs } from './chunk.ts';
 import { type HeadChange, type RefCountUpdatesDelegate } from './gc.ts';
 import { type Read, type Store, type Write } from './store.ts';
 /**

package/out/replicache/src/dag/lazy-store.d.ts.map

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