jazz-tools 0.19.22 → 0.20.0

package/src/tools/ssr/ssr.ts

@@ -1,10 +1,10 @@
 import { WebSocketPeerWithReconnection } from "cojson-transport-ws";
-import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 import { createAnonymousJazzContext } from "jazz-tools";
 
 export function createSSRJazzAgent(opts: { peer: string }) {
   const ssrNode = createAnonymousJazzContext({
-    crypto: new PureJSCrypto(),
+    crypto: WasmCrypto.createSync(),
     peers: [],
   });
 

package/src/tools/subscribe/CoValueCoreSubscription.ts

@@ -223,6 +223,7 @@ export class CoValueCoreSubscription {
  */
 function isCompletelyDownloaded(value: RawCoValue) {
   return (
+    value.core.isDeleted ||
     value.core.verified?.header.meta?.type === "binary" ||
     value.core.isCompletelyDownloaded()
   );

package/src/tools/subscribe/JazzError.ts

@@ -6,6 +6,7 @@ export class JazzError {
     public id: ID<CoValue> | undefined,
     public type:
       | typeof CoValueLoadingState.UNAVAILABLE
+      | typeof CoValueLoadingState.DELETED
       | typeof CoValueLoadingState.UNAUTHORIZED,
     public issues: JazzErrorIssue[],
   ) {}
@@ -49,8 +50,10 @@ export class JazzError {
 export type JazzErrorIssue = {
   code:
     | typeof CoValueLoadingState.UNAVAILABLE
+    | typeof CoValueLoadingState.DELETED
     | typeof CoValueLoadingState.UNAUTHORIZED
-    | "validationError";
+    | "validationError"
+    | "deleteError";
   message: string;
   params: Record<string, any>;
   path: string[];

package/src/tools/subscribe/SubscriptionScope.ts

@@ -171,6 +171,25 @@ export class SubscriptionScope<D extends CoValue> {
       return;
     }
 
+    if (update.core.isDeleted) {
+      if (this.value.type !== CoValueLoadingState.DELETED) {
+        const error = new JazzError(this.id, CoValueLoadingState.DELETED, [
+          {
+            code: CoValueLoadingState.DELETED,
+            message: `Jazz Deleted Error: ${this.id} has been deleted`,
+            params: {
+              id: this.id,
+            },
+            path: [],
+          },
+        ]);
+
+        this.updateValue(error);
+        this.triggerUpdate();
+      }
+      return;
+    }
+
     if (!hasAccessToCoValue(update)) {
       if (this.value.type !== CoValueLoadingState.UNAUTHORIZED) {
         const message = `Jazz Authorization Error: The current user (${this.node.getCurrentAgent().id}) is not authorized to access ${this.id}`;
@@ -279,6 +298,7 @@ export class SubscriptionScope<D extends CoValue> {
 
     if (
       value.type === CoValueLoadingState.UNAVAILABLE ||
+      value.type === CoValueLoadingState.DELETED ||
       value.type === CoValueLoadingState.UNAUTHORIZED
     ) {
       this.childErrors.set(id, value.prependPath(key ?? id));
@@ -414,6 +434,7 @@ export class SubscriptionScope<D extends CoValue> {
 
     if (
       rawValue === CoValueLoadingState.UNAUTHORIZED ||
+      rawValue === CoValueLoadingState.DELETED ||
       rawValue === CoValueLoadingState.UNAVAILABLE ||
       rawValue === CoValueLoadingState.LOADING
     ) {
@@ -427,6 +448,7 @@ export class SubscriptionScope<D extends CoValue> {
   private getCurrentRawValue(): D | NotLoadedCoValueState {
     if (
       this.value.type === CoValueLoadingState.UNAUTHORIZED ||
+      this.value.type === CoValueLoadingState.DELETED ||
       this.value.type === CoValueLoadingState.UNAVAILABLE
     ) {
       return this.value.type;
@@ -481,6 +503,7 @@ export class SubscriptionScope<D extends CoValue> {
   private getError() {
     if (
       this.value.type === CoValueLoadingState.UNAUTHORIZED ||
+      this.value.type === CoValueLoadingState.DELETED ||
       this.value.type === CoValueLoadingState.UNAVAILABLE
     ) {
       return this.value;

package/src/tools/subscribe/types.ts

@@ -16,6 +16,10 @@ export const CoValueLoadingState = {
    * The coValue is being loaded.
    */
   LOADING: "loading",
+  /**
+   * The coValue existed but has been deleted (tombstoned).
+   */
+  DELETED: "deleted",
   /**
    * The coValue was loaded but the account is not authorized to access it.
    */
@@ -31,6 +35,7 @@ export type CoValueLoadingState =
 
 export type CoValueErrorState =
   | typeof CoValueLoadingState.UNAVAILABLE
+  | typeof CoValueLoadingState.DELETED
   | typeof CoValueLoadingState.UNAUTHORIZED;
 
 export type NotLoadedCoValueState =

package/src/tools/testing.ts

@@ -1,6 +1,5 @@
 import { LocalNode } from "cojson";
 import { cojsonInternals } from "cojson";
-import { PureJSCrypto } from "cojson/dist/crypto/PureJSCrypto";
 import {
   Account,
   AccountClass,
@@ -18,6 +17,7 @@ import {
   createJazzContext,
   MockSessionProvider,
 } from "./internal.js";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 
 const randomSessionProvider = new MockSessionProvider();
 
@@ -28,11 +28,11 @@ const syncServer: { current: LocalNode | null; asyncPeers: boolean } = {
   asyncPeers: false,
 };
 
-export class TestJSCrypto extends PureJSCrypto {
+export class TestJSCrypto extends WasmCrypto {
   static async create() {
     if ("navigator" in globalThis && navigator.userAgent?.includes("jsdom")) {
       // Mocking crypto seal & encrypt to make it work with JSDom. Getting "Error: Uint8Array expected" there
-      const crypto = new PureJSCrypto();
+      const crypto = await WasmCrypto.create();
 
       crypto.seal = (options) =>
         `sealed_U${cojsonInternals.stableStringify(options.message)}` as any;
@@ -47,7 +47,7 @@ export class TestJSCrypto extends PureJSCrypto {
     }
 
     // For non-jsdom environments, we use the real crypto
-    return new PureJSCrypto();
+    return await WasmCrypto.create();
   }
 }
 
@@ -188,7 +188,7 @@ export function runWithoutActiveAccount<Result>(
 
 export async function createJazzTestGuest() {
   const ctx = await createAnonymousJazzContext({
-    crypto: await PureJSCrypto.create(),
+    crypto: await WasmCrypto.create(),
     peers: [],
   });
 

package/src/tools/tests/PassphraseAuth.test.ts

@@ -1,7 +1,6 @@
 // @vitest-environment happy-dom
 
 import { AgentSecret } from "cojson";
-import { PureJSCrypto } from "cojson/crypto/PureJSCrypto";
 import { assert, beforeEach, describe, expect, it, vi } from "vitest";
 import { PassphraseAuth } from "../auth/PassphraseAuth";
 import {
@@ -17,6 +16,7 @@ import {
   setupJazzTestSync,
 } from "../testing";
 import { testWordlist } from "./fixtures";
+import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 
 // Initialize KV store for tests
 KvStoreContext.getInstance().initialize(new InMemoryKVStore());
@@ -26,7 +26,7 @@ beforeEach(async () => {
 });
 
 describe("PassphraseAuth", () => {
-  let crypto: PureJSCrypto;
+  let crypto: WasmCrypto;
   let mockAuthenticate: any;
   let mockRegister: any;
   let authSecretStorage: AuthSecretStorage;
@@ -38,7 +38,7 @@ describe("PassphraseAuth", () => {
     KvStoreContext.getInstance().getStorage().clearAll();
 
     // Set up crypto and mocks
-    crypto = await PureJSCrypto.create();
+    crypto = await WasmCrypto.create();
     mockAuthenticate = vi.fn();
     mockRegister = vi.fn();
     authSecretStorage = new AuthSecretStorage();
@@ -201,7 +201,7 @@ describe("PassphraseAuth", () => {
 KvStoreContext.getInstance().initialize(new InMemoryKVStore());
 
 describe("PassphraseAuth with TestJazzContextManager", () => {
-  let crypto: PureJSCrypto;
+  let crypto: WasmCrypto;
   let contextManager: TestJazzContextManager<any>;
   let authSecretStorage: AuthSecretStorage;
   let passphraseAuth: PassphraseAuth;
@@ -215,7 +215,7 @@ describe("PassphraseAuth with TestJazzContextManager", () => {
     });
 
     // Set up crypto and context manager
-    crypto = await PureJSCrypto.create();
+    crypto = await WasmCrypto.create();
     contextManager = TestJazzContextManager.fromAccountOrGuest(account);
     authSecretStorage = contextManager.getAuthSecretStorage();
 

package/src/tools/tests/deleteCoValues.test.ts

@@ -0,0 +1,231 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import {
+  Account,
+  CoValueLoadingState,
+  Group,
+  co,
+  deleteCoValues,
+  z,
+} from "../exports.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+import { assertLoaded, waitFor } from "./utils.js";
+
+beforeEach(async () => {
+  await setupJazzTestSync();
+  await createJazzTestAccount({
+    isCurrentActiveAccount: true,
+  });
+});
+
+describe("deleteCoValues", () => {
+  test("deletes a resolved graph (tombstones) and loads as DELETED", async () => {
+    const Meta = co.map({
+      tag: z.string(),
+    });
+
+    const Note = co.map({
+      text: co.plainText(),
+      meta: Meta,
+    });
+
+    const owner = Account.getMe();
+    const group = Group.create(owner).makePublic("reader");
+
+    const note = Note.create(
+      {
+        text: "hello",
+        meta: { tag: "t1" },
+      },
+      group,
+    );
+
+    const text = note.text;
+    const meta = note.meta;
+
+    await note.$jazz.raw.core.waitForSync();
+
+    await deleteCoValues(Note, note.$jazz.id, {
+      loadAs: owner,
+      resolve: { text: true, meta: true },
+    });
+
+    expect(note.$jazz.raw.core.isDeleted).toBe(true);
+    expect(text.$jazz.raw.core.isDeleted).toBe(true);
+    expect(meta.$jazz.raw.core.isDeleted).toBe(true);
+
+    const viewer = await createJazzTestAccount();
+    const loaded = await Note.load(note.$jazz.id, {
+      loadAs: viewer,
+      skipRetry: true,
+    });
+
+    expect(loaded.$isLoaded).toBe(false);
+    expect(loaded.$jazz.loadingState).toBe(CoValueLoadingState.DELETED);
+  });
+
+  test("rejects deletion for non-admin on a group-owned value", async () => {
+    const Meta = co.map({
+      tag: z.string(),
+    });
+
+    const Note = co.map({
+      meta: Meta,
+    });
+
+    const owner = Account.getMe();
+    const writer = await createJazzTestAccount();
+
+    const group = Group.create(owner);
+    group.addMember(writer, "writer");
+
+    const note = Note.create({ meta: { tag: "t1" } }, group);
+    await note.$jazz.raw.core.waitForSync();
+
+    await expect(
+      deleteCoValues(Note, note.$jazz.id, {
+        loadAs: writer,
+        resolve: { meta: true },
+      }),
+    ).rejects.toThrow(/admin permissions/i);
+
+    expect(note.$jazz.raw.core.isDeleted).toBe(false);
+  });
+
+  test("rejects deletion when a resolved child is not deletable (error includes path)", async () => {
+    const Child = co.map({
+      value: z.string(),
+    });
+
+    const Root = co.map({
+      child: Child,
+    });
+
+    const owner = Account.getMe();
+    const otherOwner = await createJazzTestAccount();
+
+    const groupA = Group.create(owner).makePublic("reader");
+    const groupB = Group.create({ owner: otherOwner }).makePublic("reader");
+
+    const child = Child.create({ value: "child" }, groupB);
+    await child.$jazz.raw.core.waitForSync();
+
+    const root = Root.create({ child }, groupA);
+    await root.$jazz.raw.core.waitForSync();
+
+    await expect(
+      deleteCoValues(Root, root.$jazz.id, {
+        loadAs: owner,
+        resolve: { child: true },
+      }),
+    ).rejects.toThrow(
+      new RegExp(
+        `Subscription starts from ${root.$jazz.id}.*path ${child.$jazz.id}`,
+      ),
+    );
+
+    expect(root.$jazz.raw.core.isDeleted).toBe(false);
+    expect(child.$jazz.raw.core.isDeleted).toBe(false);
+  });
+
+  test("rejects deletion when the value cannot be loaded", async () => {
+    const Root = co.map({
+      value: z.string(),
+    });
+
+    const owner = Account.getMe();
+    const otherOwner = await createJazzTestAccount();
+    const root = Root.create(
+      { value: "root" },
+      Group.create({ owner: otherOwner }),
+    );
+    await root.$jazz.raw.core.waitForSync();
+
+    await expect(
+      deleteCoValues(Root, root.$jazz.id, {
+        loadAs: owner,
+      }),
+    ).rejects.toThrow(new RegExp(`Jazz Authorization Error`));
+
+    expect(root.$jazz.raw.core.isDeleted).toBe(false);
+  });
+
+  test("rejects deletion when a child could not be loaded", async () => {
+    const Child = co.map({
+      value: z.string(),
+    });
+
+    const Root = co.map({
+      child: Child,
+    });
+
+    const owner = Account.getMe();
+    const otherOwner = await createJazzTestAccount();
+
+    const groupA = Group.create(owner).makePublic("reader");
+    const groupB = Group.create({ owner: otherOwner });
+
+    const child = Child.create({ value: "child" }, groupB);
+    await child.$jazz.raw.core.waitForSync();
+
+    const root = Root.create({ child }, groupA);
+    await root.$jazz.raw.core.waitForSync();
+
+    await expect(
+      deleteCoValues(Root, root.$jazz.id, {
+        loadAs: owner,
+        resolve: { child: true },
+      }),
+    ).rejects.toThrow(new RegExp(`Jazz Authorization Error`));
+
+    expect(root.$jazz.raw.core.isDeleted).toBe(false);
+    expect(child.$jazz.raw.core.isDeleted).toBe(false);
+  });
+
+  test("delete the CoValue when the child cannot be loaded but is marked with $onError", async () => {
+    const Child = co.map({
+      value: z.string(),
+    });
+
+    const Root = co.map({
+      child: Child,
+    });
+
+    const owner = Account.getMe();
+    const otherOwner = await createJazzTestAccount();
+
+    const groupA = Group.create(owner).makePublic("reader");
+    const groupB = Group.create({ owner: otherOwner });
+
+    const child = Child.create({ value: "child" }, groupB);
+    await child.$jazz.raw.core.waitForSync();
+
+    const root = Root.create({ child }, groupA);
+    await root.$jazz.raw.core.waitForSync();
+
+    await deleteCoValues(Root, root.$jazz.id, {
+      loadAs: owner,
+      resolve: { child: { $onError: "catch" } },
+    });
+
+    expect(root.$jazz.raw.core.isDeleted).toBe(true);
+    expect(child.$jazz.raw.core.isDeleted).toBe(false);
+  });
+
+  test("skips Account and Group CoValues", async () => {
+    const me = Account.getMe();
+
+    await deleteCoValues(Account, me.$jazz.id, {
+      loadAs: me,
+    });
+
+    expect(me.$jazz.raw.core.isDeleted).toBe(false);
+
+    const group = Group.create(me).makePublic("reader");
+
+    await deleteCoValues(Group, group.$jazz.id, {
+      loadAs: me,
+    });
+
+    expect(group.$jazz.raw.core.isDeleted).toBe(false);
+  });
+});

package/src/tools/tests/deletedState.test.ts

@@ -0,0 +1,110 @@
+import { beforeEach, describe, expect, it, onTestFinished, vi } from "vitest";
+import { cojsonInternals } from "cojson";
+
+import { Account, Group, z } from "../index.js";
+import {
+  CoValueLoadingState,
+  co,
+  coValueClassFromCoValueClassOrSchema,
+  subscribeToCoValue,
+} from "../internal.js";
+import { loadCoValue } from "../exports.js";
+import { createJazzTestAccount, setupJazzTestSync } from "../testing.js";
+import { setupAccount, waitFor } from "./utils.js";
+
+cojsonInternals.setCoValueLoadingRetryDelay(50);
+
+describe("deleted loading state", () => {
+  beforeEach(() => {
+    // Keep these tests snappy and deterministic.
+    cojsonInternals.CO_VALUE_LOADING_CONFIG.MAX_RETRIES = 1;
+    cojsonInternals.CO_VALUE_LOADING_CONFIG.TIMEOUT = 50;
+  });
+
+  it("subscribeToCoValue calls onError and stops emitting loaded updates", async () => {
+    const TestMap = co.map({
+      value: z.string(),
+    });
+
+    const { me, meOnSecondPeer } = await setupAccount();
+
+    const map = TestMap.create({ value: "hello" }, me);
+
+    const onLoaded = vi.fn();
+    const onError = vi.fn();
+    const onUnavailable = vi.fn();
+    const onUnauthorized = vi.fn();
+
+    const unsubscribe = subscribeToCoValue(
+      coValueClassFromCoValueClassOrSchema(TestMap),
+      map.$jazz.id,
+      {
+        loadAs: meOnSecondPeer,
+        onError,
+        onUnavailable,
+        onUnauthorized,
+      },
+      onLoaded,
+    );
+
+    onTestFinished(unsubscribe);
+
+    await waitFor(() => {
+      expect(onLoaded).toHaveBeenCalled();
+    });
+
+    const loadedCallCountBeforeDelete = onLoaded.mock.calls.length;
+
+    map.$jazz.raw.core.deleteCoValue();
+    await map.$jazz.raw.core.waitForSync();
+
+    await waitFor(() => {
+      expect(onError).toHaveBeenCalled();
+    });
+
+    const deletedValue = onError.mock.calls[0]?.[0];
+    expect(deletedValue?.$isLoaded).toBe(false);
+    expect(deletedValue?.$jazz.loadingState).toBe(CoValueLoadingState.DELETED);
+
+    // Give the system a moment; we should not emit additional loaded updates after deletion.
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(onLoaded).toHaveBeenCalledTimes(loadedCallCountBeforeDelete);
+    expect(onUnavailable).not.toHaveBeenCalled();
+    expect(onUnauthorized).not.toHaveBeenCalled();
+  });
+
+  it("loadCoValue resolves a NotLoaded(DELETED) value for deleted coValues", async () => {
+    await setupJazzTestSync();
+
+    const TestMap = co.map({
+      value: z.string(),
+    });
+
+    const owner = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    const group = Group.create(owner).makePublic("reader");
+    const map = TestMap.create({ value: "hello" }, group);
+
+    // Ensure the value exists on storage/peers before deleting.
+    await map.$jazz.raw.core.waitForSync();
+
+    map.$jazz.raw.core.deleteCoValue();
+    await map.$jazz.raw.core.waitForSync();
+
+    const viewer = await createJazzTestAccount();
+
+    const loaded = await loadCoValue(
+      coValueClassFromCoValueClassOrSchema(TestMap),
+      map.$jazz.id,
+      {
+        loadAs: viewer,
+        skipRetry: true,
+      },
+    );
+
+    expect(loaded.$isLoaded).toBe(false);
+    expect(loaded.$jazz.loadingState).toBe(CoValueLoadingState.DELETED);
+  });
+});

package/src/tools/tests/request.test.ts

@@ -20,7 +20,18 @@ import { createJazzTestAccount, linkAccounts } from "../testing.js";
 
 const server = setupServer();
 
-beforeAll(() => server.listen());
+const ignoreWasmRequests = (request: Request, print: any) => {
+  if (request.url.includes("application/wasm")) {
+    return;
+  }
+  print.warning();
+};
+
+beforeAll(() =>
+  server.listen({
+    onUnhandledRequest: ignoreWasmRequests,
+  }),
+);
 afterEach(() => server.resetHandlers());
 afterEach(() => vi.restoreAllMocks());
 afterAll(() => server.close());
@@ -877,7 +888,9 @@ describe("JazzRequestError handling", () => {
         ),
       ).rejects.toThrow("fetch failed");
 
-      server.listen();
+      server.listen({
+        onUnhandledRequest: ignoreWasmRequests,
+      });
     });
   });
 

package/src/worker/edge-wasm.ts

@@ -1,5 +1,6 @@
 // InitWasm allow to load the wasm code in edge runtimes (ex. cloudflare worker and vercel edge functions)
-import { init as InitWasm } from "cojson/crypto/WasmCrypto/edge";
+import { init as InitWasm, initSync } from "cojson/crypto/WasmCrypto/edge";
 import { WasmCrypto } from "cojson/crypto/WasmCrypto";
 
 WasmCrypto.setInit(InitWasm);
+WasmCrypto.setInitSync(initSync);

package/src/worker/wasm.ts

@@ -0,0 +1 @@
+export { initWasmCrypto as initWasm } from "cojson/crypto/WasmCrypto";

package/tsup.config.ts

@@ -42,7 +42,6 @@ export default defineConfig([
     entry: {
       index: "src/expo/index.ts",
       testing: "src/expo/testing.ts",
-      crypto: "src/expo/crypto.ts",
       polyfills: "src/react-native-core/polyfills/index.js",
     },
     outDir: "dist/expo",
@@ -115,7 +114,6 @@ export default defineConfig([
     entry: {
       index: "src/react-native/index.ts",
       testing: "src/react-native/testing.ts",
-      crypto: "src/react-native/crypto.ts",
       polyfills: "src/react-native-core/polyfills/index.js",
     },
     outDir: "dist/react-native",
@@ -132,8 +130,6 @@ export default defineConfig([
     entry: {
       index: "src/react-native-core/index.ts",
       testing: "src/react-native-core/testing.tsx",
-      crypto: "src/react-native-core/crypto/index.ts",
-      "crypto/RNCrypto": "src/react-native-core/crypto/RNCrypto.ts",
     },
     outDir: "dist/react-native-core",
   },

package/dist/browser/storageOptions.d.ts

@@ -1,8 +0,0 @@
-type StorageOption = "indexedDB";
-type CombinedStorageOption = ["indexedDB"];
-export type StorageConfig = StorageOption | CombinedStorageOption | [StorageOption];
-export declare function getStorageOptions(storage?: StorageConfig): {
-    useIndexedDB: boolean;
-};
-export {};
-//# sourceMappingURL=storageOptions.d.ts.map

package/dist/browser/storageOptions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"storageOptions.d.ts","sourceRoot":"","sources":["../../src/browser/storageOptions.ts"],"names":[],"mappings":"AAAA,KAAK,aAAa,GAAG,WAAW,CAAC;AACjC,KAAK,qBAAqB,GAAG,CAAC,WAAW,CAAC,CAAC;AAC3C,MAAM,MAAM,aAAa,GACrB,aAAa,GACb,qBAAqB,GACrB,CAAC,aAAa,CAAC,CAAC;AAEpB,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG;IAC1D,YAAY,EAAE,OAAO,CAAC;CACvB,CAOA"}

package/dist/browser/tests/storageOptions.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=storageOptions.test.d.ts.map

package/dist/browser/tests/storageOptions.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"storageOptions.test.d.ts","sourceRoot":"","sources":["../../../src/browser/tests/storageOptions.test.ts"],"names":[],"mappings":""}

package/dist/chunk-M2HGBOXS.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/tools/ssr/ssr.ts"],"sourcesContent":["import { WebSocketPeerWithReconnection } from \"cojson-transport-ws\";\nimport { PureJSCrypto } from \"cojson/dist/crypto/PureJSCrypto\";\nimport { createAnonymousJazzContext } from \"jazz-tools\";\n\nexport function createSSRJazzAgent(opts: { peer: string }) {\n  const ssrNode = createAnonymousJazzContext({\n    crypto: new PureJSCrypto(),\n    peers: [],\n  });\n\n  const wsPeer = new WebSocketPeerWithReconnection({\n    peer: opts.peer,\n    reconnectionTimeout: 100,\n    addPeer: (peer) => {\n      ssrNode.agent.node.syncManager.addPeer(peer);\n    },\n    removePeer: () => {},\n  });\n\n  wsPeer.enable();\n\n  return ssrNode.agent;\n}\n"],"mappings":";AAAA,SAAS,qCAAqC;AAC9C,SAAS,oBAAoB;AAC7B,SAAS,kCAAkC;AAEpC,SAAS,mBAAmB,MAAwB;AACzD,QAAM,UAAU,2BAA2B;AAAA,IACzC,QAAQ,IAAI,aAAa;AAAA,IACzB,OAAO,CAAC;AAAA,EACV,CAAC;AAED,QAAM,SAAS,IAAI,8BAA8B;AAAA,IAC/C,MAAM,KAAK;AAAA,IACX,qBAAqB;AAAA,IACrB,SAAS,CAAC,SAAS;AACjB,cAAQ,MAAM,KAAK,YAAY,QAAQ,IAAI;AAAA,IAC7C;AAAA,IACA,YAAY,MAAM;AAAA,IAAC;AAAA,EACrB,CAAC;AAED,SAAO,OAAO;AAEd,SAAO,QAAQ;AACjB;","names":[]}