@graffiti-garden/wrapper-synchronize 0.2.4 → 1.0.2

package/dist/esm/index.js

@@ -1,22 +1,24 @@
-import { Graffiti } from "@graffiti-garden/api";
-import { Repeater } from "@repeaterjs/repeater";
 import {
-  applyGraffitiPatch,
+  GraffitiErrorNotFound,
   compileGraffitiObjectSchema,
   isActorAllowedGraffitiObject,
   maskGraffitiObject,
   unpackObjectUrl
-} from "@graffiti-garden/implementation-local/utilities";
-class GraffitiSynchronize extends Graffiti {
+} from "@graffiti-garden/api";
+import { Repeater } from "@repeaterjs/repeater";
+class GraffitiSynchronize {
   ajv_;
-  applyPatch_;
   graffiti;
   callbacks = /* @__PURE__ */ new Set();
   options;
-  channelStats;
   login;
   logout;
   sessionEvents;
+  postMedia;
+  getMedia;
+  deleteMedia;
+  actorToHandle;
+  handleToActor;
   get ajv() {
     if (!this.ajv_) {
       this.ajv_ = (async () => {
@@ -26,52 +28,42 @@ class GraffitiSynchronize extends Graffiti {
     }
     return this.ajv_;
   }
-  get applyPatch() {
-    if (!this.applyPatch_) {
-      this.applyPatch_ = (async () => {
-        const { applyPatch } = await import("fast-json-patch");
-        return applyPatch;
-      })();
-    }
-    return this.applyPatch_;
-  }
   /**
    * Wraps a Graffiti API instance to provide the synchronize methods.
    * The GraffitiSyncrhonize class rather than the Graffiti class
    * must be used for all functions for the synchronize methods to work.
    */
   constructor(graffiti, options) {
-    super();
     this.options = options ?? {};
     this.graffiti = graffiti;
-    this.channelStats = graffiti.channelStats.bind(graffiti);
     this.login = graffiti.login.bind(graffiti);
     this.logout = graffiti.logout.bind(graffiti);
     this.sessionEvents = graffiti.sessionEvents;
+    this.postMedia = graffiti.postMedia.bind(graffiti);
+    this.getMedia = graffiti.getMedia.bind(graffiti);
+    this.deleteMedia = graffiti.deleteMedia.bind(graffiti);
+    this.actorToHandle = graffiti.actorToHandle.bind(graffiti);
+    this.handleToActor = graffiti.handleToActor.bind(graffiti);
   }
-  synchronize(matchObject, channels, schema, session) {
-    const seenUrls = /* @__PURE__ */ new Set();
+  synchronize(matchObject, channels, schema, session, seenUrls = /* @__PURE__ */ new Set()) {
     const repeater = new Repeater(
       async (push, stop) => {
         const validate = compileGraffitiObjectSchema(await this.ajv, schema);
-        const callback = (oldObjectRaw, newObjectRaw) => {
-          for (const objectRaw of [newObjectRaw, oldObjectRaw]) {
-            if (objectRaw?.tombstone) {
-              if (seenUrls.has(objectRaw.object.url)) {
-                push(objectRaw);
-              }
-            } else if (objectRaw && matchObject(objectRaw.object) && (this.options.omniscient || isActorAllowedGraffitiObject(objectRaw.object, session))) {
-              const object = JSON.parse(
-                JSON.stringify(objectRaw.object)
-              );
-              if (!this.options.omniscient) {
-                maskGraffitiObject(object, channels, session);
-              }
-              if (validate(object)) {
-                push({ object });
-                seenUrls.add(object.url);
-                break;
-              }
+        const callback = (objectUpdate) => {
+          if (objectUpdate?.tombstone) {
+            if (seenUrls.has(objectUpdate.object.url)) {
+              push(objectUpdate);
+            }
+          } else if (objectUpdate && matchObject(objectUpdate.object) && (this.options.omniscient || isActorAllowedGraffitiObject(objectUpdate.object, session))) {
+            const object = JSON.parse(
+              JSON.stringify(objectUpdate.object)
+            );
+            if (!this.options.omniscient) {
+              maskGraffitiObject(object, channels, session);
+            }
+            if (validate(object)) {
+              push({ object });
+              seenUrls.add(object.url);
             }
           }
         };
@@ -86,8 +78,8 @@ class GraffitiSynchronize extends Graffiti {
   }
   /**
    * This method has the same signature as {@link discover} but listens for
-   * changes made via {@link put}, {@link patch}, and {@link delete} or
-   * fetched from {@link get}, {@link discover}, and {@link recoverOrphans}
+   * changes made via {@link post} and {@link delete} or
+   * fetched from {@link get}, {@link discover}, and {@link continueDiscover}
    * and then streams appropriate changes to provide a responsive and
    * consistent user experience.
    *
@@ -95,10 +87,9 @@ class GraffitiSynchronize extends Graffiti {
    * and will not terminate unless the user calls the `return` method on the iterator
    * or `break`s out of the loop.
    *
-   * @group Synchronize Methods
+   * @group 0 - Synchronize Methods
    */
-  synchronizeDiscover(...args) {
-    const [channels, schema, session] = args;
+  synchronizeDiscover(channels, schema, session) {
     function matchObject(object) {
       return object.channels.some((channel) => channels.includes(channel));
     }
@@ -106,43 +97,28 @@ class GraffitiSynchronize extends Graffiti {
   }
   /**
    * This method has the same signature as {@link get} but
-   * listens for changes made via {@link put}, {@link patch}, and {@link delete} or
-   * fetched from {@link get}, {@link discover}, and {@link recoverOrphans} and then
+   * listens for changes made via {@link post}, and {@link delete} or
+   * fetched from {@link get}, {@link discover}, and {@link continueDiscover} and then
    * streams appropriate changes to provide a responsive and consistent user experience.
    *
    * Unlike {@link get}, which returns a single result, this method continuously
    * listens for changes which are output as an asynchronous stream, similar
    * to {@link discover}.
    *
-   * @group Synchronize Methods
+   * @group 0 - Synchronize Methods
    */
-  synchronizeGet(...args) {
-    const [objectUrl, schema, session] = args;
+  synchronizeGet(objectUrl, schema, session) {
     const url = unpackObjectUrl(objectUrl);
     function matchObject(object) {
       return object.url === url;
     }
-    return this.synchronize(matchObject, [], schema, session);
-  }
-  /**
-   * This method has the same signature as {@link recoverOrphans} but
-   * listens for changes made via
-   * {@link put}, {@link patch}, and {@link delete} or fetched from
-   * {@link get}, {@link discover}, and {@link recoverOrphans} and then
-   * streams appropriate changes to provide a responsive and consistent user experience.
-   *
-   * Unlike {@link recoverOrphans}, this method continuously listens for changes
-   * and will not terminate unless the user calls the `return` method on the iterator
-   * or `break`s out of the loop.
-   *
-   * @group Synchronize Methods
-   */
-  synchronizeRecoverOrphans(...args) {
-    const [schema, session] = args;
-    function matchObject(object) {
-      return object.actor === session.actor && object.channels.length === 0;
-    }
-    return this.synchronize(matchObject, [], schema, session);
+    return this.synchronize(
+      matchObject,
+      [],
+      schema,
+      session,
+      /* @__PURE__ */ new Set([url])
+    );
   }
   /**
    * Streams changes made to *any* object in *any* channel
@@ -154,74 +130,54 @@ class GraffitiSynchronize extends Graffiti {
    * Be careful using this method. Without additional filters it can
    * expose the user to content out of context.
    *
-   * @group Synchronize Methods
+   * @group 0 - Synchronize Methods
    */
   synchronizeAll(schema, session) {
     return this.synchronize(() => true, [], schema, session);
   }
-  async synchronizeDispatch(oldObject, newObject, waitForListeners = false) {
+  async synchronizeDispatch(objectUpdate, waitForListeners = false) {
     for (const callback of this.callbacks) {
-      callback(oldObject, newObject);
+      callback(objectUpdate);
     }
     if (waitForListeners) {
       await new Promise((resolve) => setTimeout(resolve, 0));
     }
   }
   get = async (...args) => {
-    const object = await this.graffiti.get(...args);
-    this.synchronizeDispatch({ object });
+    try {
+      const object = await this.graffiti.get(...args);
+      this.synchronizeDispatch({ object });
+      return object;
+    } catch (error) {
+      if (error instanceof GraffitiErrorNotFound) {
+        this.synchronizeDispatch({
+          tombstone: true,
+          object: { url: unpackObjectUrl(args[0]) }
+        });
+      }
+      throw error;
+    }
+  };
+  post = async (...args) => {
+    const object = await this.graffiti.post(...args);
+    await this.synchronizeDispatch({ object }, true);
     return object;
   };
-  put = async (...args) => {
-    const oldObject = await this.graffiti.put(...args);
-    const partialObject = args[0];
-    const newObject = {
-      ...oldObject,
-      value: partialObject.value,
-      channels: partialObject.channels,
-      allowed: partialObject.allowed
+  delete = async (...args) => {
+    const update = {
+      tombstone: true,
+      object: { url: unpackObjectUrl(args[0]) }
     };
-    await this.synchronizeDispatch(
-      {
-        tombstone: true,
-        object: oldObject
-      },
-      {
-        object: newObject
-      },
-      true
-    );
-    return oldObject;
-  };
-  patch = async (...args) => {
-    const oldObject = await this.graffiti.patch(...args);
-    const newObject = { ...oldObject };
-    for (const prop of ["value", "channels", "allowed"]) {
-      applyGraffitiPatch(await this.applyPatch, prop, args[0], newObject);
+    try {
+      const oldObject = await this.graffiti.delete(...args);
+      await this.synchronizeDispatch(update, true);
+      return oldObject;
+    } catch (error) {
+      if (error instanceof GraffitiErrorNotFound) {
+        await this.synchronizeDispatch(update, true);
+      }
+      throw error;
     }
-    await this.synchronizeDispatch(
-      {
-        tombstone: true,
-        object: oldObject
-      },
-      {
-        object: newObject
-      },
-      true
-    );
-    return oldObject;
-  };
-  delete = async (...args) => {
-    const oldObject = await this.graffiti.delete(...args);
-    await this.synchronizeDispatch(
-      {
-        tombstone: true,
-        object: oldObject
-      },
-      void 0,
-      true
-    );
-    return oldObject;
   };
   objectStreamContinue(iterator) {
     const this_ = this;
@@ -231,14 +187,12 @@ class GraffitiSynchronize extends Graffiti {
         if (result.done) {
           const { continue: continue_, cursor } = result.value;
           return {
-            continue: () => this_.objectStreamContinue(continue_()),
+            continue: (session) => this_.objectStreamContinue(continue_(session)),
             cursor
           };
         }
         if (!result.value.error) {
-          this_.synchronizeDispatch(
-            result.value
-          );
+          this_.synchronizeDispatch(result.value);
         }
         yield result.value;
       }
@@ -258,12 +212,8 @@ class GraffitiSynchronize extends Graffiti {
     const iterator = this.graffiti.discover(...args);
     return this.objectStream(iterator);
   };
-  recoverOrphans = (...args) => {
-    const iterator = this.graffiti.recoverOrphans(...args);
-    return this.objectStream(iterator);
-  };
-  continueObjectStream = (...args) => {
-    const iterator = this.graffiti.continueObjectStream(...args);
+  continueDiscover = (...args) => {
+    const iterator = this.graffiti.continueDiscover(...args);
     return this.objectStreamContinue(iterator);
   };
 }

package/dist/esm/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.ts"],
-  "sourcesContent": ["import type Ajv from \"ajv\";\nimport { Graffiti } from \"@graffiti-garden/api\";\nimport type {\n  GraffitiSession,\n  JSONSchema,\n  GraffitiObjectStream,\n  GraffitiObjectStreamContinueEntry,\n  GraffitiObjectStreamContinue,\n  GraffitiObject,\n} from \"@graffiti-garden/api\";\nimport type { GraffitiObjectBase } from \"@graffiti-garden/api\";\nimport { Repeater } from \"@repeaterjs/repeater\";\nimport type { applyPatch } from \"fast-json-patch\";\nimport {\n  applyGraffitiPatch,\n  compileGraffitiObjectSchema,\n  isActorAllowedGraffitiObject,\n  maskGraffitiObject,\n  unpackObjectUrl,\n} from \"@graffiti-garden/implementation-local/utilities\";\nexport type * from \"@graffiti-garden/api\";\n\nexport type GraffitiSynchronizeCallback = (\n  oldObject: GraffitiObjectStreamContinueEntry<{}>,\n  newObject?: GraffitiObjectStreamContinueEntry<{}>,\n) => void;\n\nexport interface GraffitiSynchronizeOptions {\n  /**\n   * Allows synchronize to listen to all objects, not just those\n   * that the session is allowed to see. This is useful to get a\n   * global view of all Graffiti objects passsing through the system,\n   * for example to build a client-side cache. Additional mechanisms\n   * should be in place to ensure that users do not see objects or\n   * properties they are not allowed to see.\n   *\n   * Default: `false`\n   */\n  omniscient?: boolean;\n}\n\n/**\n * Wraps the [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)\n * so that changes made or received in one part of an application\n * are automatically routed to other parts of the application.\n * This is an important tool for building responsive\n * and consistent user interfaces, and is built upon to make\n * the [Graffiti Vue Plugin](https://vue.graffiti.garden/variables/GraffitiPlugin.html)\n * and possibly other front-end libraries in the future.\n *\n * [See a live example](/example).\n *\n * Specifically, this library provides the following *synchronize*\n * methods to correspond with each of the following Graffiti API methods:\n *\n * | API Method | Synchronize Method |\n * |------------|--------------------|\n * | {@link get} | {@link synchronizeGet} |\n * | {@link discover} | {@link synchronizeDiscover} |\n * | {@link recoverOrphans} | {@link synchronizeRecoverOrphans} |\n *\n * Whenever a change is made via {@link put}, {@link patch}, and {@link delete} or\n * received from {@link get}, {@link discover}, and {@link recoverOrphans},\n * those changes are forwarded to the appropriate synchronize method.\n * Each synchronize method returns an iterator that streams these changes\n * continually until the user calls `return` on the iterator or `break`s out of the loop,\n * allowing for live updates without additional polling.\n *\n * Example 1: Suppose a user publishes a post using {@link put}. If the feed\n * displaying that user's posts is using {@link synchronizeDiscover} to listen for changes,\n * then the user's new post will instantly appear in their feed, giving the UI a\n * responsive feel.\n *\n * Example 2: Suppose one of a user's friends changes their name. As soon as the\n * user's application receives one notice of that change (using {@link get}\n * or {@link discover}), then {@link synchronizeDiscover} listeners can be used to update\n * all instance's of that friend's name in the user's application instantly,\n * providing a consistent user experience.\n *\n * The source code for this library is [available on GitHub](https://github.com/graffiti-garden/wrapper-synchronize/).\n *\n * @groupDescription Synchronize Methods\n * This group contains methods that listen for changes made via\n * {@link put}, {@link patch}, and {@link delete} or fetched from\n * {@link get}, {@link discover}, and {@link recoverOrphans} and then\n * streams appropriate changes to provide a responsive and consistent user experience.\n */\nexport class GraffitiSynchronize extends Graffiti {\n  protected ajv_: Promise<Ajv> | undefined;\n  protected applyPatch_: Promise<typeof applyPatch> | undefined;\n  protected readonly graffiti: Graffiti;\n  protected readonly callbacks = new Set<GraffitiSynchronizeCallback>();\n  protected readonly options: GraffitiSynchronizeOptions;\n\n  channelStats: Graffiti[\"channelStats\"];\n  login: Graffiti[\"login\"];\n  logout: Graffiti[\"logout\"];\n  sessionEvents: Graffiti[\"sessionEvents\"];\n\n  protected get ajv() {\n    if (!this.ajv_) {\n      this.ajv_ = (async () => {\n        const { default: Ajv } = await import(\"ajv\");\n        return new Ajv({ strict: false });\n      })();\n    }\n    return this.ajv_;\n  }\n\n  protected get applyPatch() {\n    if (!this.applyPatch_) {\n      this.applyPatch_ = (async () => {\n        const { applyPatch } = await import(\"fast-json-patch\");\n        return applyPatch;\n      })();\n    }\n    return this.applyPatch_;\n  }\n\n  /**\n   * Wraps a Graffiti API instance to provide the synchronize methods.\n   * The GraffitiSyncrhonize class rather than the Graffiti class\n   * must be used for all functions for the synchronize methods to work.\n   */\n  constructor(\n    /**\n     * The [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)\n     * instance to wrap.\n     */\n    graffiti: Graffiti,\n    options?: GraffitiSynchronizeOptions,\n  ) {\n    super();\n    this.options = options ?? {};\n    this.graffiti = graffiti;\n    this.channelStats = graffiti.channelStats.bind(graffiti);\n    this.login = graffiti.login.bind(graffiti);\n    this.logout = graffiti.logout.bind(graffiti);\n    this.sessionEvents = graffiti.sessionEvents;\n  }\n\n  protected synchronize<Schema extends JSONSchema>(\n    matchObject: (object: GraffitiObjectBase) => boolean,\n    channels: string[],\n    schema: Schema,\n    session?: GraffitiSession | null,\n  ): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>> {\n    const seenUrls = new Set<string>();\n\n    const repeater = new Repeater<GraffitiObjectStreamContinueEntry<Schema>>(\n      async (push, stop) => {\n        const validate = compileGraffitiObjectSchema(await this.ajv, schema);\n        const callback: GraffitiSynchronizeCallback = (\n          oldObjectRaw,\n          newObjectRaw,\n        ) => {\n          for (const objectRaw of [newObjectRaw, oldObjectRaw]) {\n            if (objectRaw?.tombstone) {\n              if (seenUrls.has(objectRaw.object.url)) {\n                push(objectRaw);\n              }\n            } else if (\n              objectRaw &&\n              matchObject(objectRaw.object) &&\n              (this.options.omniscient ||\n                isActorAllowedGraffitiObject(objectRaw.object, session))\n            ) {\n              // Deep clone the object to prevent mutation\n              const object = JSON.parse(\n                JSON.stringify(objectRaw.object),\n              ) as GraffitiObject<{}>;\n              if (!this.options.omniscient) {\n                maskGraffitiObject(object, channels, session);\n              }\n              if (validate(object)) {\n                push({ object });\n                seenUrls.add(object.url);\n                break;\n              }\n            }\n          }\n        };\n\n        this.callbacks.add(callback);\n        await stop;\n        this.callbacks.delete(callback);\n      },\n    );\n\n    return (async function* () {\n      for await (const i of repeater) yield i;\n    })();\n  }\n\n  /**\n   * This method has the same signature as {@link discover} but listens for\n   * changes made via {@link put}, {@link patch}, and {@link delete} or\n   * fetched from {@link get}, {@link discover}, and {@link recoverOrphans}\n   * and then streams appropriate changes to provide a responsive and\n   * consistent user experience.\n   *\n   * Unlike {@link discover}, this method continuously listens for changes\n   * and will not terminate unless the user calls the `return` method on the iterator\n   * or `break`s out of the loop.\n   *\n   * @group Synchronize Methods\n   */\n  synchronizeDiscover<Schema extends JSONSchema>(\n    ...args: Parameters<typeof Graffiti.prototype.discover<Schema>>\n  ): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>> {\n    const [channels, schema, session] = args;\n    function matchObject(object: GraffitiObjectBase) {\n      return object.channels.some((channel) => channels.includes(channel));\n    }\n    return this.synchronize<Schema>(matchObject, channels, schema, session);\n  }\n\n  /**\n   * This method has the same signature as {@link get} but\n   * listens for changes made via {@link put}, {@link patch}, and {@link delete} or\n   * fetched from {@link get}, {@link discover}, and {@link recoverOrphans} and then\n   * streams appropriate changes to provide a responsive and consistent user experience.\n   *\n   * Unlike {@link get}, which returns a single result, this method continuously\n   * listens for changes which are output as an asynchronous stream, similar\n   * to {@link discover}.\n   *\n   * @group Synchronize Methods\n   */\n  synchronizeGet<Schema extends JSONSchema>(\n    ...args: Parameters<typeof Graffiti.prototype.get<Schema>>\n  ): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>> {\n    const [objectUrl, schema, session] = args;\n    const url = unpackObjectUrl(objectUrl);\n    function matchObject(object: GraffitiObjectBase) {\n      return object.url === url;\n    }\n    return this.synchronize<Schema>(matchObject, [], schema, session);\n  }\n\n  /**\n   * This method has the same signature as {@link recoverOrphans} but\n   * listens for changes made via\n   * {@link put}, {@link patch}, and {@link delete} or fetched from\n   * {@link get}, {@link discover}, and {@link recoverOrphans} and then\n   * streams appropriate changes to provide a responsive and consistent user experience.\n   *\n   * Unlike {@link recoverOrphans}, this method continuously listens for changes\n   * and will not terminate unless the user calls the `return` method on the iterator\n   * or `break`s out of the loop.\n   *\n   * @group Synchronize Methods\n   */\n  synchronizeRecoverOrphans<Schema extends JSONSchema>(\n    ...args: Parameters<typeof Graffiti.prototype.recoverOrphans<Schema>>\n  ): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>> {\n    const [schema, session] = args;\n    function matchObject(object: GraffitiObjectBase) {\n      return object.actor === session.actor && object.channels.length === 0;\n    }\n    return this.synchronize<Schema>(matchObject, [], schema, session);\n  }\n\n  /**\n   * Streams changes made to *any* object in *any* channel\n   * and made by *any* user. You may want to use it in conjuction with\n   * {@link GraffitiSynchronizeOptions.omniscient} to get a global view\n   * of all Graffiti objects passing through the system. This is useful\n   * for building a client-side cache, for example.\n   *\n   * Be careful using this method. Without additional filters it can\n   * expose the user to content out of context.\n   *\n   * @group Synchronize Methods\n   */\n  synchronizeAll<Schema extends JSONSchema>(\n    schema: Schema,\n    session?: GraffitiSession | null,\n  ): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>> {\n    return this.synchronize<Schema>(() => true, [], schema, session);\n  }\n\n  protected async synchronizeDispatch(\n    oldObject: GraffitiObjectStreamContinueEntry<{}>,\n    newObject?: GraffitiObjectStreamContinueEntry<{}>,\n    waitForListeners = false,\n  ) {\n    for (const callback of this.callbacks) {\n      callback(oldObject, newObject);\n    }\n    if (waitForListeners) {\n      // Wait for the listeners to receive\n      // their objects, before returning the operation\n      // that triggered them.\n      //\n      // This is important for mutators (put, patch, delete)\n      // to ensure the application state has been updated\n      // everywhere before returning, giving consistent\n      // feedback to the user that the operation has completed.\n      //\n      // The opposite is true for accessors (get, discover, recoverOrphans),\n      // where it is a weird user experience to call `get`\n      // in one place and have the application update\n      // somewhere else first. It is also less efficient.\n      //\n      // The hack is simply to await one \"macro task cycle\".\n      // We need to wait for this cycle rather than using\n      // `await push` in the callback, because it turns out\n      // that `await push` won't resolve until the following\n      // .next() call of the iterator, so if only\n      // one .next() is called, this dispatch will hang.\n      await new Promise((resolve) => setTimeout(resolve, 0));\n    }\n  }\n\n  get: Graffiti[\"get\"] = async (...args) => {\n    const object = await this.graffiti.get(...args);\n    this.synchronizeDispatch({ object });\n    return object;\n  };\n\n  put: Graffiti[\"put\"] = async (...args) => {\n    const oldObject = await this.graffiti.put<{}>(...args);\n    const partialObject = args[0];\n    const newObject: GraffitiObjectBase = {\n      ...oldObject,\n      value: partialObject.value,\n      channels: partialObject.channels,\n      allowed: partialObject.allowed,\n    };\n    await this.synchronizeDispatch(\n      {\n        tombstone: true,\n        object: oldObject,\n      },\n      {\n        object: newObject,\n      },\n      true,\n    );\n    return oldObject;\n  };\n\n  patch: Graffiti[\"patch\"] = async (...args) => {\n    const oldObject = await this.graffiti.patch(...args);\n    const newObject: GraffitiObjectBase = { ...oldObject };\n    for (const prop of [\"value\", \"channels\", \"allowed\"] as const) {\n      applyGraffitiPatch(await this.applyPatch, prop, args[0], newObject);\n    }\n    await this.synchronizeDispatch(\n      {\n        tombstone: true,\n        object: oldObject,\n      },\n      {\n        object: newObject,\n      },\n      true,\n    );\n    return oldObject;\n  };\n\n  delete: Graffiti[\"delete\"] = async (...args) => {\n    const oldObject = await this.graffiti.delete(...args);\n    await this.synchronizeDispatch(\n      {\n        tombstone: true,\n        object: oldObject,\n      },\n      undefined,\n      true,\n    );\n    return oldObject;\n  };\n\n  protected objectStreamContinue<Schema extends JSONSchema>(\n    iterator: GraffitiObjectStreamContinue<Schema>,\n  ): GraffitiObjectStreamContinue<Schema> {\n    const this_ = this;\n    return (async function* () {\n      while (true) {\n        const result = await iterator.next();\n        if (result.done) {\n          const { continue: continue_, cursor } = result.value;\n          return {\n            continue: () => this_.objectStreamContinue<Schema>(continue_()),\n            cursor,\n          };\n        }\n        if (!result.value.error) {\n          this_.synchronizeDispatch(\n            result.value as GraffitiObjectStreamContinueEntry<{}>,\n          );\n        }\n        yield result.value;\n      }\n    })();\n  }\n\n  protected objectStream<Schema extends JSONSchema>(\n    iterator: GraffitiObjectStream<Schema>,\n  ): GraffitiObjectStream<Schema> {\n    const wrapped = this.objectStreamContinue<Schema>(iterator);\n    return (async function* () {\n      // Filter out the tombstones for type safety\n      while (true) {\n        const result = await wrapped.next();\n        if (result.done) return result.value;\n        if (result.value.error || !result.value.tombstone) yield result.value;\n      }\n    })();\n  }\n\n  discover: Graffiti[\"discover\"] = (...args) => {\n    const iterator = this.graffiti.discover(...args);\n    return this.objectStream<(typeof args)[1]>(iterator);\n  };\n\n  recoverOrphans: Graffiti[\"recoverOrphans\"] = (...args) => {\n    const iterator = this.graffiti.recoverOrphans(...args);\n    return this.objectStream<(typeof args)[0]>(iterator);\n  };\n\n  continueObjectStream: Graffiti[\"continueObjectStream\"] = (...args) => {\n    const iterator = this.graffiti.continueObjectStream(...args);\n    return this.objectStreamContinue<{}>(iterator);\n  };\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import type Ajv from \"ajv\";\nimport type {\n  Graffiti,\n  GraffitiSession,\n  JSONSchema,\n  GraffitiObjectBase,\n  GraffitiObjectStream,\n  GraffitiObjectStreamContinueEntry,\n  GraffitiObjectStreamContinue,\n  GraffitiObjectUrl,\n} from \"@graffiti-garden/api\";\nimport {\n  GraffitiErrorNotFound,\n  compileGraffitiObjectSchema,\n  isActorAllowedGraffitiObject,\n  maskGraffitiObject,\n  unpackObjectUrl,\n} from \"@graffiti-garden/api\";\nimport { Repeater } from \"@repeaterjs/repeater\";\nexport type * from \"@graffiti-garden/api\";\n\nexport type GraffitiSynchronizeCallback = (\n  object: GraffitiObjectStreamContinueEntry<{}>,\n) => void;\n\nexport interface GraffitiSynchronizeOptions {\n  /**\n   * Allows synchronize to listen to all objects, not just those\n   * that the session is allowed to see. This is useful to get a\n   * global view of all Graffiti objects passsing through the system,\n   * for example to build a client-side cache. Additional mechanisms\n   * should be in place to ensure that users do not see objects or\n   * properties they are not allowed to see.\n   *\n   * Default: `false`\n   */\n  omniscient?: boolean;\n}\n\n/**\n * Wraps the [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)\n * so that changes made or received in one part of an application\n * are automatically routed to other parts of the application.\n * This is an important tool for building responsive\n * and consistent user interfaces, and is built upon to make\n * the [Graffiti Vue Plugin](https://vue.graffiti.garden/variables/GraffitiPlugin.html)\n * and possibly other front-end libraries in the future.\n *\n * [See a live example](/example).\n *\n * Specifically, this library provides the following *synchronize*\n * methods to correspond with each of the following Graffiti API methods:\n *\n * | API Method | Synchronize Method |\n * |------------|--------------------|\n * | {@link get} | {@link synchronizeGet} |\n * | {@link discover} | {@link synchronizeDiscover} |\n *\n * Whenever a change is made via {@link post} and {@link delete} or\n * received from {@link get}, {@link discover}, and {@link continueDiscover},\n * those changes are forwarded to the appropriate synchronize method.\n * Each synchronize method returns an iterator that streams these changes\n * continually until the user calls `return` on the iterator or `break`s out of the loop,\n * allowing for live updates without additional polling.\n *\n * Example 1: Suppose a user publishes a post using {@link post}. If the feed\n * displaying that user's posts is using {@link synchronizeDiscover} to listen for changes,\n * then the user's new post will instantly appear in their feed, giving the UI a\n * responsive feel.\n *\n * Example 2: Suppose one of a user's friends changes their name. As soon as the\n * user's application receives one notice of that change (using {@link get}\n * or {@link discover}), then {@link synchronizeDiscover} listeners can be used to update\n * all instance's of that friend's name in the user's application instantly,\n * providing a consistent user experience.\n *\n * Additionally, the library supplies a {@link synchronizeAll} method that can be used\n * to stream all the Graffiti changes that an application is aware of, which can be used\n * for caching or history building.\n *\n * The source code for this library is [available on GitHub](https://github.com/graffiti-garden/wrapper-synchronize/).\n *\n * @groupDescription 0 - Synchronize Methods\n * This group contains methods that listen for changes made via\n * {@link post}, and {@link delete} or fetched from\n * {@link get}, {@link discover}, or {@link continueDiscover} and then\n * streams appropriate changes to provide a responsive and consistent user experience.\n */\nexport class GraffitiSynchronize implements Graffiti {\n  protected ajv_: Promise<Ajv> | undefined;\n  protected readonly graffiti: Graffiti;\n  protected readonly callbacks = new Set<GraffitiSynchronizeCallback>();\n  protected readonly options: GraffitiSynchronizeOptions;\n\n  login: Graffiti[\"login\"];\n  logout: Graffiti[\"logout\"];\n  sessionEvents: Graffiti[\"sessionEvents\"];\n  postMedia: Graffiti[\"postMedia\"];\n  getMedia: Graffiti[\"getMedia\"];\n  deleteMedia: Graffiti[\"deleteMedia\"];\n  actorToHandle: Graffiti[\"actorToHandle\"];\n  handleToActor: Graffiti[\"handleToActor\"];\n\n  protected get ajv() {\n    if (!this.ajv_) {\n      this.ajv_ = (async () => {\n        const { default: Ajv } = await import(\"ajv\");\n        return new Ajv({ strict: false });\n      })();\n    }\n    return this.ajv_;\n  }\n\n  /**\n   * Wraps a Graffiti API instance to provide the synchronize methods.\n   * The GraffitiSyncrhonize class rather than the Graffiti class\n   * must be used for all functions for the synchronize methods to work.\n   */\n  constructor(\n    /**\n     * The [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)\n     * instance to wrap.\n     */\n    graffiti: Graffiti,\n    options?: GraffitiSynchronizeOptions,\n  ) {\n    this.options = options ?? {};\n    this.graffiti = graffiti;\n    this.login = graffiti.login.bind(graffiti);\n    this.logout = graffiti.logout.bind(graffiti);\n    this.sessionEvents = graffiti.sessionEvents;\n    this.postMedia = graffiti.postMedia.bind(graffiti);\n    this.getMedia = graffiti.getMedia.bind(graffiti);\n    this.deleteMedia = graffiti.deleteMedia.bind(graffiti);\n    this.actorToHandle = graffiti.actorToHandle.bind(graffiti);\n    this.handleToActor = graffiti.handleToActor.bind(graffiti);\n  }\n\n  protected synchronize<Schema extends JSONSchema>(\n    matchObject: (object: GraffitiObjectBase) => boolean,\n    channels: string[],\n    schema: Schema,\n    session?: GraffitiSession | null,\n    seenUrls: Set<string> = new Set<string>(),\n  ): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>> {\n    const repeater = new Repeater<GraffitiObjectStreamContinueEntry<Schema>>(\n      async (push, stop) => {\n        const validate = compileGraffitiObjectSchema(await this.ajv, schema);\n        const callback: GraffitiSynchronizeCallback = (objectUpdate) => {\n          if (objectUpdate?.tombstone) {\n            if (seenUrls.has(objectUpdate.object.url)) {\n              push(objectUpdate);\n            }\n          } else if (\n            objectUpdate &&\n            matchObject(objectUpdate.object) &&\n            (this.options.omniscient ||\n              isActorAllowedGraffitiObject(objectUpdate.object, session))\n          ) {\n            // Deep clone the object to prevent mutation\n            const object = JSON.parse(\n              JSON.stringify(objectUpdate.object),\n            ) as GraffitiObjectBase;\n            if (!this.options.omniscient) {\n              maskGraffitiObject(object, channels, session);\n            }\n            if (validate(object)) {\n              push({ object });\n              seenUrls.add(object.url);\n            }\n          }\n        };\n\n        this.callbacks.add(callback);\n        await stop;\n        this.callbacks.delete(callback);\n      },\n    );\n\n    return (async function* () {\n      for await (const i of repeater) yield i;\n    })();\n  }\n\n  /**\n   * This method has the same signature as {@link discover} but listens for\n   * changes made via {@link post} and {@link delete} or\n   * fetched from {@link get}, {@link discover}, and {@link continueDiscover}\n   * and then streams appropriate changes to provide a responsive and\n   * consistent user experience.\n   *\n   * Unlike {@link discover}, this method continuously listens for changes\n   * and will not terminate unless the user calls the `return` method on the iterator\n   * or `break`s out of the loop.\n   *\n   * @group 0 - Synchronize Methods\n   */\n  synchronizeDiscover<Schema extends JSONSchema>(\n    channels: string[],\n    schema: Schema,\n    session?: GraffitiSession | null,\n  ): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>> {\n    function matchObject(object: GraffitiObjectBase) {\n      return object.channels.some((channel) => channels.includes(channel));\n    }\n    return this.synchronize<Schema>(matchObject, channels, schema, session);\n  }\n\n  /**\n   * This method has the same signature as {@link get} but\n   * listens for changes made via {@link post}, and {@link delete} or\n   * fetched from {@link get}, {@link discover}, and {@link continueDiscover} and then\n   * streams appropriate changes to provide a responsive and consistent user experience.\n   *\n   * Unlike {@link get}, which returns a single result, this method continuously\n   * listens for changes which are output as an asynchronous stream, similar\n   * to {@link discover}.\n   *\n   * @group 0 - Synchronize Methods\n   */\n  synchronizeGet<Schema extends JSONSchema>(\n    objectUrl: string | GraffitiObjectUrl,\n    schema: Schema,\n    session?: GraffitiSession | null | undefined,\n  ): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>> {\n    const url = unpackObjectUrl(objectUrl);\n    function matchObject(object: GraffitiObjectBase) {\n      return object.url === url;\n    }\n    return this.synchronize<Schema>(\n      matchObject,\n      [],\n      schema,\n      session,\n      new Set<string>([url]),\n    );\n  }\n\n  /**\n   * Streams changes made to *any* object in *any* channel\n   * and made by *any* user. You may want to use it in conjuction with\n   * {@link GraffitiSynchronizeOptions.omniscient} to get a global view\n   * of all Graffiti objects passing through the system. This is useful\n   * for building a client-side cache, for example.\n   *\n   * Be careful using this method. Without additional filters it can\n   * expose the user to content out of context.\n   *\n   * @group 0 - Synchronize Methods\n   */\n  synchronizeAll<Schema extends JSONSchema>(\n    schema: Schema,\n    session?: GraffitiSession | null,\n  ): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>> {\n    return this.synchronize<Schema>(() => true, [], schema, session);\n  }\n\n  protected async synchronizeDispatch(\n    objectUpdate: GraffitiObjectStreamContinueEntry<{}>,\n    waitForListeners = false,\n  ) {\n    for (const callback of this.callbacks) {\n      callback(objectUpdate);\n    }\n    if (waitForListeners) {\n      // Wait for the listeners to receive\n      // their objects, before returning the operation\n      // that triggered them.\n      //\n      // This is important for mutators (put, patch, delete)\n      // to ensure the application state has been updated\n      // everywhere before returning, giving consistent\n      // feedback to the user that the operation has completed.\n      //\n      // The opposite is true for accessors (get, discover, recoverOrphans),\n      // where it is a weird user experience to call `get`\n      // in one place and have the application update\n      // somewhere else first. It is also less efficient.\n      //\n      // The hack is simply to await one \"macro task cycle\".\n      // We need to wait for this cycle rather than using\n      // `await push` in the callback, because it turns out\n      // that `await push` won't resolve until the following\n      // .next() call of the iterator, so if only\n      // one .next() is called, this dispatch will hang.\n      await new Promise((resolve) => setTimeout(resolve, 0));\n    }\n  }\n\n  get: Graffiti[\"get\"] = async (...args) => {\n    try {\n      const object = await this.graffiti.get(...args);\n      this.synchronizeDispatch({ object });\n      return object;\n    } catch (error) {\n      if (error instanceof GraffitiErrorNotFound) {\n        this.synchronizeDispatch({\n          tombstone: true,\n          object: { url: unpackObjectUrl(args[0]) },\n        });\n      }\n      throw error;\n    }\n  };\n\n  post: Graffiti[\"post\"] = async (...args) => {\n    // @ts-ignore\n    const object = await this.graffiti.post(...args);\n    await this.synchronizeDispatch({ object }, true);\n    return object;\n  };\n\n  delete: Graffiti[\"delete\"] = async (...args) => {\n    const update = {\n      tombstone: true,\n      object: { url: unpackObjectUrl(args[0]) },\n    } as const;\n    try {\n      const oldObject = await this.graffiti.delete(...args);\n      await this.synchronizeDispatch(update, true);\n      return oldObject;\n    } catch (error) {\n      if (error instanceof GraffitiErrorNotFound) {\n        await this.synchronizeDispatch(update, true);\n      }\n      throw error;\n    }\n  };\n\n  protected objectStreamContinue<Schema extends JSONSchema>(\n    iterator: GraffitiObjectStreamContinue<Schema>,\n  ): GraffitiObjectStreamContinue<Schema> {\n    const this_ = this;\n    return (async function* () {\n      while (true) {\n        const result = await iterator.next();\n        if (result.done) {\n          const { continue: continue_, cursor } = result.value;\n          return {\n            continue: (session?: GraffitiSession | null) =>\n              this_.objectStreamContinue<Schema>(continue_(session)),\n            cursor,\n          };\n        }\n        if (!result.value.error) {\n          this_.synchronizeDispatch(result.value);\n        }\n        yield result.value;\n      }\n    })();\n  }\n\n  protected objectStream<Schema extends JSONSchema>(\n    iterator: GraffitiObjectStream<Schema>,\n  ): GraffitiObjectStream<Schema> {\n    const wrapped = this.objectStreamContinue<Schema>(iterator);\n    return (async function* () {\n      // Filter out the tombstones for type safety\n      while (true) {\n        const result = await wrapped.next();\n        if (result.done) return result.value;\n        if (result.value.error || !result.value.tombstone) yield result.value;\n      }\n    })();\n  }\n\n  discover: Graffiti[\"discover\"] = (...args) => {\n    const iterator = this.graffiti.discover(...args);\n    return this.objectStream<(typeof args)[1]>(iterator);\n  };\n\n  continueDiscover: Graffiti[\"continueDiscover\"] = (...args) => {\n    const iterator = this.graffiti.continueDiscover(...args);\n    return this.objectStreamContinue<{}>(iterator);\n  };\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/index.d.ts

@@ -1,10 +1,7 @@
 import type Ajv from "ajv";
-import { Graffiti } from "@graffiti-garden/api";
-import type { GraffitiSession, JSONSchema, GraffitiObjectStream, GraffitiObjectStreamContinueEntry, GraffitiObjectStreamContinue } from "@graffiti-garden/api";
-import type { GraffitiObjectBase } from "@graffiti-garden/api";
-import type { applyPatch } from "fast-json-patch";
+import type { Graffiti, GraffitiSession, JSONSchema, GraffitiObjectBase, GraffitiObjectStream, GraffitiObjectStreamContinueEntry, GraffitiObjectStreamContinue, GraffitiObjectUrl } from "@graffiti-garden/api";
 export type * from "@graffiti-garden/api";
-export type GraffitiSynchronizeCallback = (oldObject: GraffitiObjectStreamContinueEntry<{}>, newObject?: GraffitiObjectStreamContinueEntry<{}>) => void;
+export type GraffitiSynchronizeCallback = (object: GraffitiObjectStreamContinueEntry<{}>) => void;
 export interface GraffitiSynchronizeOptions {
     /**
      * Allows synchronize to listen to all objects, not just those
@@ -36,16 +33,15 @@ export interface GraffitiSynchronizeOptions {
  * |------------|--------------------|
  * | {@link get} | {@link synchronizeGet} |
  * | {@link discover} | {@link synchronizeDiscover} |
- * | {@link recoverOrphans} | {@link synchronizeRecoverOrphans} |
  *
- * Whenever a change is made via {@link put}, {@link patch}, and {@link delete} or
- * received from {@link get}, {@link discover}, and {@link recoverOrphans},
+ * Whenever a change is made via {@link post} and {@link delete} or
+ * received from {@link get}, {@link discover}, and {@link continueDiscover},
  * those changes are forwarded to the appropriate synchronize method.
  * Each synchronize method returns an iterator that streams these changes
  * continually until the user calls `return` on the iterator or `break`s out of the loop,
  * allowing for live updates without additional polling.
  *
- * Example 1: Suppose a user publishes a post using {@link put}. If the feed
+ * Example 1: Suppose a user publishes a post using {@link post}. If the feed
  * displaying that user's posts is using {@link synchronizeDiscover} to listen for changes,
  * then the user's new post will instantly appear in their feed, giving the UI a
  * responsive feel.
@@ -56,26 +52,32 @@ export interface GraffitiSynchronizeOptions {
  * all instance's of that friend's name in the user's application instantly,
  * providing a consistent user experience.
  *
+ * Additionally, the library supplies a {@link synchronizeAll} method that can be used
+ * to stream all the Graffiti changes that an application is aware of, which can be used
+ * for caching or history building.
+ *
  * The source code for this library is [available on GitHub](https://github.com/graffiti-garden/wrapper-synchronize/).
  *
- * @groupDescription Synchronize Methods
+ * @groupDescription 0 - Synchronize Methods
  * This group contains methods that listen for changes made via
- * {@link put}, {@link patch}, and {@link delete} or fetched from
- * {@link get}, {@link discover}, and {@link recoverOrphans} and then
+ * {@link post}, and {@link delete} or fetched from
+ * {@link get}, {@link discover}, or {@link continueDiscover} and then
  * streams appropriate changes to provide a responsive and consistent user experience.
  */
-export declare class GraffitiSynchronize extends Graffiti {
+export declare class GraffitiSynchronize implements Graffiti {
     protected ajv_: Promise<Ajv> | undefined;
-    protected applyPatch_: Promise<typeof applyPatch> | undefined;
     protected readonly graffiti: Graffiti;
     protected readonly callbacks: Set<GraffitiSynchronizeCallback>;
     protected readonly options: GraffitiSynchronizeOptions;
-    channelStats: Graffiti["channelStats"];
     login: Graffiti["login"];
     logout: Graffiti["logout"];
     sessionEvents: Graffiti["sessionEvents"];
+    postMedia: Graffiti["postMedia"];
+    getMedia: Graffiti["getMedia"];
+    deleteMedia: Graffiti["deleteMedia"];
+    actorToHandle: Graffiti["actorToHandle"];
+    handleToActor: Graffiti["handleToActor"];
     protected get ajv(): Promise<Ajv>;
-    protected get applyPatch(): Promise<typeof applyPatch>;
     /**
      * Wraps a Graffiti API instance to provide the synchronize methods.
      * The GraffitiSyncrhonize class rather than the Graffiti class
@@ -87,11 +89,11 @@ export declare class GraffitiSynchronize extends Graffiti {
      * instance to wrap.
      */
     graffiti: Graffiti, options?: GraffitiSynchronizeOptions);
-    protected synchronize<Schema extends JSONSchema>(matchObject: (object: GraffitiObjectBase) => boolean, channels: string[], schema: Schema, session?: GraffitiSession | null): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>>;
+    protected synchronize<Schema extends JSONSchema>(matchObject: (object: GraffitiObjectBase) => boolean, channels: string[], schema: Schema, session?: GraffitiSession | null, seenUrls?: Set<string>): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>>;
     /**
      * This method has the same signature as {@link discover} but listens for
-     * changes made via {@link put}, {@link patch}, and {@link delete} or
-     * fetched from {@link get}, {@link discover}, and {@link recoverOrphans}
+     * changes made via {@link post} and {@link delete} or
+     * fetched from {@link get}, {@link discover}, and {@link continueDiscover}
      * and then streams appropriate changes to provide a responsive and
      * consistent user experience.
      *
@@ -99,36 +101,22 @@ export declare class GraffitiSynchronize extends Graffiti {
      * and will not terminate unless the user calls the `return` method on the iterator
      * or `break`s out of the loop.
      *
-     * @group Synchronize Methods
+     * @group 0 - Synchronize Methods
      */
-    synchronizeDiscover<Schema extends JSONSchema>(...args: Parameters<typeof Graffiti.prototype.discover<Schema>>): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>>;
+    synchronizeDiscover<Schema extends JSONSchema>(channels: string[], schema: Schema, session?: GraffitiSession | null): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>>;
     /**
      * This method has the same signature as {@link get} but
-     * listens for changes made via {@link put}, {@link patch}, and {@link delete} or
-     * fetched from {@link get}, {@link discover}, and {@link recoverOrphans} and then
+     * listens for changes made via {@link post}, and {@link delete} or
+     * fetched from {@link get}, {@link discover}, and {@link continueDiscover} and then
      * streams appropriate changes to provide a responsive and consistent user experience.
      *
      * Unlike {@link get}, which returns a single result, this method continuously
      * listens for changes which are output as an asynchronous stream, similar
      * to {@link discover}.
      *
-     * @group Synchronize Methods
-     */
-    synchronizeGet<Schema extends JSONSchema>(...args: Parameters<typeof Graffiti.prototype.get<Schema>>): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>>;
-    /**
-     * This method has the same signature as {@link recoverOrphans} but
-     * listens for changes made via
-     * {@link put}, {@link patch}, and {@link delete} or fetched from
-     * {@link get}, {@link discover}, and {@link recoverOrphans} and then
-     * streams appropriate changes to provide a responsive and consistent user experience.
-     *
-     * Unlike {@link recoverOrphans}, this method continuously listens for changes
-     * and will not terminate unless the user calls the `return` method on the iterator
-     * or `break`s out of the loop.
-     *
-     * @group Synchronize Methods
+     * @group 0 - Synchronize Methods
      */
-    synchronizeRecoverOrphans<Schema extends JSONSchema>(...args: Parameters<typeof Graffiti.prototype.recoverOrphans<Schema>>): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>>;
+    synchronizeGet<Schema extends JSONSchema>(objectUrl: string | GraffitiObjectUrl, schema: Schema, session?: GraffitiSession | null | undefined): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>>;
     /**
      * Streams changes made to *any* object in *any* channel
      * and made by *any* user. You may want to use it in conjuction with
@@ -139,18 +127,16 @@ export declare class GraffitiSynchronize extends Graffiti {
      * Be careful using this method. Without additional filters it can
      * expose the user to content out of context.
      *
-     * @group Synchronize Methods
+     * @group 0 - Synchronize Methods
      */
     synchronizeAll<Schema extends JSONSchema>(schema: Schema, session?: GraffitiSession | null): AsyncGenerator<GraffitiObjectStreamContinueEntry<Schema>>;
-    protected synchronizeDispatch(oldObject: GraffitiObjectStreamContinueEntry<{}>, newObject?: GraffitiObjectStreamContinueEntry<{}>, waitForListeners?: boolean): Promise<void>;
+    protected synchronizeDispatch(objectUpdate: GraffitiObjectStreamContinueEntry<{}>, waitForListeners?: boolean): Promise<void>;
     get: Graffiti["get"];
-    put: Graffiti["put"];
-    patch: Graffiti["patch"];
+    post: Graffiti["post"];
     delete: Graffiti["delete"];
     protected objectStreamContinue<Schema extends JSONSchema>(iterator: GraffitiObjectStreamContinue<Schema>): GraffitiObjectStreamContinue<Schema>;
     protected objectStream<Schema extends JSONSchema>(iterator: GraffitiObjectStream<Schema>): GraffitiObjectStream<Schema>;
     discover: Graffiti["discover"];
-    recoverOrphans: Graffiti["recoverOrphans"];
-    continueObjectStream: Graffiti["continueObjectStream"];
+    continueDiscover: Graffiti["continueDiscover"];
 }
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiti-garden/wrapper-synchronize",
-  "version": "0.2.4",
+  "version": "1.0.2",
   "description": "Internal synchronization for the Graffiti API",
   "types": "./dist/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -45,19 +45,18 @@
   },
   "homepage": "https://sync.graffiti.garden/classes/GraffitiSynchronize.html",
   "devDependencies": {
-    "@types/node": "^24.7.2",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@graffiti-garden/implementation-local": "^1.0.2",
+    "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.0.16",
     "esbuild-plugin-polyfill-node": "^0.3.0",
     "tsx": "^4.20.6",
     "typedoc": "^0.28.14",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.16"
   },
   "dependencies": {
-    "@graffiti-garden/api": "^0.6.4",
-    "@graffiti-garden/implementation-local": "^0.6.4",
+    "@graffiti-garden/api": "^1.0.2",
     "@repeaterjs/repeater": "^3.0.6",
-    "ajv": "^8.17.1",
-    "fast-json-patch": "^3.1.1"
+    "ajv": "^8.17.1"
   }
 }