@graffiti-garden/implementation-local 0.6.4 → 1.0.0

package/dist/cjs/identity.js

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var identity_exports = {};
+__export(identity_exports, {
+  GraffitiLocalIdentity: () => GraffitiLocalIdentity
+});
+module.exports = __toCommonJS(identity_exports);
+var import_utilities = require("./utilities");
+const DID_LOCAL_PREFIX = "did:local:";
+class GraffitiLocalIdentity {
+  sessionEvents = new EventTarget();
+  handleToActor = async (handle) => {
+    const bytes = new TextEncoder().encode(handle);
+    const base64 = (0, import_utilities.encodeBase64)(bytes);
+    return `${DID_LOCAL_PREFIX}${base64}`;
+  };
+  actorToHandle = async (actor) => {
+    if (!actor.startsWith(DID_LOCAL_PREFIX)) {
+      throw new Error(`actor must start with ${DID_LOCAL_PREFIX}`);
+    }
+    const base64 = actor.slice(DID_LOCAL_PREFIX.length);
+    const bytes = (0, import_utilities.decodeBase64)(base64);
+    return new TextDecoder().decode(bytes);
+  };
+  constructor() {
+    const sessionRestorer = async () => {
+      await Promise.resolve();
+      for (const handle of this.getLoggedInHandles()) {
+        const event2 = new CustomEvent("login", {
+          detail: { session: { actor: await this.handleToActor(handle) } }
+        });
+        this.sessionEvents.dispatchEvent(event2);
+      }
+      const event = new CustomEvent(
+        "initialized",
+        { detail: {} }
+      );
+      this.sessionEvents.dispatchEvent(event);
+    };
+    sessionRestorer();
+  }
+  loggedInHandles = [];
+  getLoggedInHandles() {
+    if (typeof window !== "undefined") {
+      const handlesString = window.localStorage.getItem("graffiti-handles");
+      return handlesString ? handlesString.split(",").map(decodeURIComponent) : [];
+    } else {
+      return this.loggedInHandles;
+    }
+  }
+  setLoggedInHandles(handles) {
+    if (typeof window !== "undefined") {
+      window.localStorage.setItem("graffiti-handles", handles.join(","));
+    } else {
+      this.loggedInHandles = handles;
+    }
+  }
+  login = async (actor) => {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    let handle = actor ? await this.actorToHandle(actor) : void 0;
+    if (typeof window !== "undefined") {
+      const response = window.prompt("Choose a username to log in.", handle);
+      handle = response ?? void 0;
+    }
+    if (!handle) {
+      const detail = {
+        error: new Error("No handle provided to login")
+      };
+      const event = new CustomEvent("login", { detail });
+      this.sessionEvents.dispatchEvent(event);
+    } else {
+      const existingHandles = this.getLoggedInHandles();
+      if (!existingHandles.includes(handle)) {
+        this.setLoggedInHandles([...existingHandles, handle]);
+      }
+      window.location.reload();
+    }
+  };
+  logout = async (session) => {
+    const handle = await this.actorToHandle(session.actor);
+    const existingHandles = this.getLoggedInHandles();
+    const exists = existingHandles.includes(handle);
+    if (exists) {
+      this.setLoggedInHandles(existingHandles.filter((h) => h !== handle));
+    }
+    const detail = exists ? {
+      actor: session.actor
+    } : {
+      actor: session.actor,
+      error: new Error("Not logged in with that actor")
+    };
+    const event = new CustomEvent("logout", { detail });
+    this.sessionEvents.dispatchEvent(event);
+  };
+}
+//# sourceMappingURL=identity.js.map

package/dist/cjs/identity.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/identity.ts"],
+  "sourcesContent": ["import type {\n  Graffiti,\n  GraffitiLoginEvent,\n  GraffitiLogoutEvent,\n  GraffitiSessionInitializedEvent,\n} from \"@graffiti-garden/api\";\nimport { decodeBase64, encodeBase64 } from \"./utilities\";\n\nconst DID_LOCAL_PREFIX = \"did:local:\";\n\n/**\n * A class that implements the login methods\n * of the [Graffiti API]() for use in the browser.\n * It is completely insecure and should only be used\n * for testing and demonstrations.\n *\n * It uses `localStorage` to store login state and\n * window prompts rather than an oauth flow for log in.\n * It can be used in node.js but will not persist\n * login state and a proposed username must be provided.\n */\nexport class GraffitiLocalIdentity {\n  sessionEvents: Graffiti[\"sessionEvents\"] = new EventTarget();\n\n  handleToActor: Graffiti[\"handleToActor\"] = async (handle: string) => {\n    const bytes = new TextEncoder().encode(handle);\n    const base64 = encodeBase64(bytes);\n    return `${DID_LOCAL_PREFIX}${base64}`;\n  };\n\n  actorToHandle: Graffiti[\"actorToHandle\"] = async (actor: string) => {\n    if (!actor.startsWith(DID_LOCAL_PREFIX)) {\n      throw new Error(`actor must start with ${DID_LOCAL_PREFIX}`);\n    }\n    const base64 = actor.slice(DID_LOCAL_PREFIX.length);\n    const bytes = decodeBase64(base64);\n    return new TextDecoder().decode(bytes);\n  };\n\n  constructor() {\n    // Look for any existing sessions\n    const sessionRestorer = async () => {\n      // Allow listeners to be added first\n      await Promise.resolve();\n\n      // Restore previous sessions\n      for (const handle of this.getLoggedInHandles()) {\n        const event: GraffitiLoginEvent = new CustomEvent(\"login\", {\n          detail: { session: { actor: await this.handleToActor(handle) } },\n        });\n        this.sessionEvents.dispatchEvent(event);\n      }\n\n      const event: GraffitiSessionInitializedEvent = new CustomEvent(\n        \"initialized\",\n        { detail: {} },\n      );\n      this.sessionEvents.dispatchEvent(event);\n    };\n    sessionRestorer();\n  }\n\n  loggedInHandles: string[] = [];\n\n  protected getLoggedInHandles(): string[] {\n    if (typeof window !== \"undefined\") {\n      const handlesString = window.localStorage.getItem(\"graffiti-handles\");\n      return handlesString\n        ? handlesString.split(\",\").map(decodeURIComponent)\n        : [];\n    } else {\n      return this.loggedInHandles;\n    }\n  }\n\n  protected setLoggedInHandles(handles: string[]) {\n    if (typeof window !== \"undefined\") {\n      window.localStorage.setItem(\"graffiti-handles\", handles.join(\",\"));\n    } else {\n      this.loggedInHandles = handles;\n    }\n  }\n\n  login: Graffiti[\"login\"] = async (actor) => {\n    // Wait a tick for the browser to update the UI\n    await new Promise((resolve) => setTimeout(resolve, 0));\n\n    let handle = actor ? await this.actorToHandle(actor) : undefined;\n\n    if (typeof window !== \"undefined\") {\n      const response = window.prompt(\"Choose a username to log in.\", handle);\n      handle = response ?? undefined;\n    }\n\n    if (!handle) {\n      const detail: GraffitiLoginEvent[\"detail\"] = {\n        error: new Error(\"No handle provided to login\"),\n      };\n      const event: GraffitiLoginEvent = new CustomEvent(\"login\", { detail });\n      this.sessionEvents.dispatchEvent(event);\n    } else {\n      const existingHandles = this.getLoggedInHandles();\n      if (!existingHandles.includes(handle)) {\n        this.setLoggedInHandles([...existingHandles, handle]);\n      }\n      // Refresh the page to simulate oauth\n      window.location.reload();\n    }\n  };\n\n  logout: Graffiti[\"logout\"] = async (session) => {\n    const handle = await this.actorToHandle(session.actor);\n    const existingHandles = this.getLoggedInHandles();\n    const exists = existingHandles.includes(handle);\n    if (exists) {\n      this.setLoggedInHandles(existingHandles.filter((h) => h !== handle));\n    }\n\n    const detail: GraffitiLogoutEvent[\"detail\"] = exists\n      ? {\n          actor: session.actor,\n        }\n      : {\n          actor: session.actor,\n          error: new Error(\"Not logged in with that actor\"),\n        };\n\n    const event: GraffitiLogoutEvent = new CustomEvent(\"logout\", { detail });\n    this.sessionEvents.dispatchEvent(event);\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,uBAA2C;AAE3C,MAAM,mBAAmB;AAalB,MAAM,sBAAsB;AAAA,EACjC,gBAA2C,IAAI,YAAY;AAAA,EAE3D,gBAA2C,OAAO,WAAmB;AACnE,UAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,MAAM;AAC7C,UAAM,aAAS,+BAAa,KAAK;AACjC,WAAO,GAAG,gBAAgB,GAAG,MAAM;AAAA,EACrC;AAAA,EAEA,gBAA2C,OAAO,UAAkB;AAClE,QAAI,CAAC,MAAM,WAAW,gBAAgB,GAAG;AACvC,YAAM,IAAI,MAAM,yBAAyB,gBAAgB,EAAE;AAAA,IAC7D;AACA,UAAM,SAAS,MAAM,MAAM,iBAAiB,MAAM;AAClD,UAAM,YAAQ,+BAAa,MAAM;AACjC,WAAO,IAAI,YAAY,EAAE,OAAO,KAAK;AAAA,EACvC;AAAA,EAEA,cAAc;AAEZ,UAAM,kBAAkB,YAAY;AAElC,YAAM,QAAQ,QAAQ;AAGtB,iBAAW,UAAU,KAAK,mBAAmB,GAAG;AAC9C,cAAMA,SAA4B,IAAI,YAAY,SAAS;AAAA,UACzD,QAAQ,EAAE,SAAS,EAAE,OAAO,MAAM,KAAK,cAAc,MAAM,EAAE,EAAE;AAAA,QACjE,CAAC;AACD,aAAK,cAAc,cAAcA,MAAK;AAAA,MACxC;AAEA,YAAM,QAAyC,IAAI;AAAA,QACjD;AAAA,QACA,EAAE,QAAQ,CAAC,EAAE;AAAA,MACf;AACA,WAAK,cAAc,cAAc,KAAK;AAAA,IACxC;AACA,oBAAgB;AAAA,EAClB;AAAA,EAEA,kBAA4B,CAAC;AAAA,EAEnB,qBAA+B;AACvC,QAAI,OAAO,WAAW,aAAa;AACjC,YAAM,gBAAgB,OAAO,aAAa,QAAQ,kBAAkB;AACpE,aAAO,gBACH,cAAc,MAAM,GAAG,EAAE,IAAI,kBAAkB,IAC/C,CAAC;AAAA,IACP,OAAO;AACL,aAAO,KAAK;AAAA,IACd;AAAA,EACF;AAAA,EAEU,mBAAmB,SAAmB;AAC9C,QAAI,OAAO,WAAW,aAAa;AACjC,aAAO,aAAa,QAAQ,oBAAoB,QAAQ,KAAK,GAAG,CAAC;AAAA,IACnE,OAAO;AACL,WAAK,kBAAkB;AAAA,IACzB;AAAA,EACF;AAAA,EAEA,QAA2B,OAAO,UAAU;AAE1C,UAAM,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,CAAC,CAAC;AAErD,QAAI,SAAS,QAAQ,MAAM,KAAK,cAAc,KAAK,IAAI;AAEvD,QAAI,OAAO,WAAW,aAAa;AACjC,YAAM,WAAW,OAAO,OAAO,gCAAgC,MAAM;AACrE,eAAS,YAAY;AAAA,IACvB;AAEA,QAAI,CAAC,QAAQ;AACX,YAAM,SAAuC;AAAA,QAC3C,OAAO,IAAI,MAAM,6BAA6B;AAAA,MAChD;AACA,YAAM,QAA4B,IAAI,YAAY,SAAS,EAAE,OAAO,CAAC;AACrE,WAAK,cAAc,cAAc,KAAK;AAAA,IACxC,OAAO;AACL,YAAM,kBAAkB,KAAK,mBAAmB;AAChD,UAAI,CAAC,gBAAgB,SAAS,MAAM,GAAG;AACrC,aAAK,mBAAmB,CAAC,GAAG,iBAAiB,MAAM,CAAC;AAAA,MACtD;AAEA,aAAO,SAAS,OAAO;AAAA,IACzB;AAAA,EACF;AAAA,EAEA,SAA6B,OAAO,YAAY;AAC9C,UAAM,SAAS,MAAM,KAAK,cAAc,QAAQ,KAAK;AACrD,UAAM,kBAAkB,KAAK,mBAAmB;AAChD,UAAM,SAAS,gBAAgB,SAAS,MAAM;AAC9C,QAAI,QAAQ;AACV,WAAK,mBAAmB,gBAAgB,OAAO,CAAC,MAAM,MAAM,MAAM,CAAC;AAAA,IACrE;AAEA,UAAM,SAAwC,SAC1C;AAAA,MACE,OAAO,QAAQ;AAAA,IACjB,IACA;AAAA,MACE,OAAO,QAAQ;AAAA,MACf,OAAO,IAAI,MAAM,+BAA+B;AAAA,IAClD;AAEJ,UAAM,QAA6B,IAAI,YAAY,UAAU,EAAE,OAAO,CAAC;AACvE,SAAK,cAAc,cAAc,KAAK;AAAA,EACxC;AACF;",
+  "names": ["event"]
+}

package/dist/cjs/index.js

@@ -22,32 +22,53 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_api = require("@graffiti-garden/api");
-var import_session_manager = require("./session-manager.js");
-var import_database = require("./database.js");
-class GraffitiLocal extends import_api.Graffiti {
-  sessionManagerLocal = new import_session_manager.GraffitiLocalSessionManager();
-  login = this.sessionManagerLocal.login.bind(this.sessionManagerLocal);
-  logout = this.sessionManagerLocal.logout.bind(this.sessionManagerLocal);
-  sessionEvents = this.sessionManagerLocal.sessionEvents;
-  put;
+var import_identity = require("./identity");
+var import_objects = require("./objects");
+var import_media = require("./media");
+class GraffitiLocal {
+  graffitiLocalIdentity = new import_identity.GraffitiLocalIdentity();
+  login = this.graffitiLocalIdentity.login.bind(this.graffitiLocalIdentity);
+  logout = this.graffitiLocalIdentity.logout.bind(this.graffitiLocalIdentity);
+  handleToActor = this.graffitiLocalIdentity.handleToActor.bind(
+    this.graffitiLocalIdentity
+  );
+  actorToHandle = this.graffitiLocalIdentity.actorToHandle.bind(
+    this.graffitiLocalIdentity
+  );
+  sessionEvents = this.graffitiLocalIdentity.sessionEvents;
+  graffitiLocalObjects;
+  post;
   get;
-  patch;
   delete;
   discover;
-  recoverOrphans;
-  channelStats;
-  continueObjectStream;
+  continueDiscover;
+  graffitiLocalMedia;
+  postMedia;
+  getMedia;
+  deleteMedia;
   constructor(options) {
-    super();
-    const graffitiPouchDbBase = new import_database.GraffitiLocalDatabase(options);
-    this.put = graffitiPouchDbBase.put.bind(graffitiPouchDbBase);
-    this.get = graffitiPouchDbBase.get.bind(graffitiPouchDbBase);
-    this.patch = graffitiPouchDbBase.patch.bind(graffitiPouchDbBase);
-    this.delete = graffitiPouchDbBase.delete.bind(graffitiPouchDbBase);
-    this.discover = graffitiPouchDbBase.discover.bind(graffitiPouchDbBase);
-    this.recoverOrphans = graffitiPouchDbBase.recoverOrphans.bind(graffitiPouchDbBase);
-    this.channelStats = graffitiPouchDbBase.channelStats.bind(graffitiPouchDbBase);
-    this.continueObjectStream = graffitiPouchDbBase.continueObjectStream.bind(graffitiPouchDbBase);
+    this.graffitiLocalObjects = new import_objects.GraffitiLocalObjects(options);
+    this.post = this.graffitiLocalObjects.post.bind(this.graffitiLocalObjects);
+    this.get = this.graffitiLocalObjects.get.bind(this.graffitiLocalObjects);
+    this.delete = this.graffitiLocalObjects.delete.bind(
+      this.graffitiLocalObjects
+    );
+    this.discover = this.graffitiLocalObjects.discover.bind(
+      this.graffitiLocalObjects
+    );
+    this.continueDiscover = this.graffitiLocalObjects.continueDiscover.bind(
+      this.graffitiLocalObjects
+    );
+    this.graffitiLocalMedia = new import_media.GraffitiLocalMedia(this.graffitiLocalObjects);
+    this.postMedia = this.graffitiLocalMedia.postMedia.bind(
+      this.graffitiLocalMedia
+    );
+    this.getMedia = this.graffitiLocalMedia.getMedia.bind(
+      this.graffitiLocalMedia
+    );
+    this.deleteMedia = this.graffitiLocalMedia.deleteMedia.bind(
+      this.graffitiLocalMedia
+    );
   }
 }
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/index.ts"],
-  "sourcesContent": ["import { Graffiti, type GraffitiSession } from \"@graffiti-garden/api\";\nimport { GraffitiLocalSessionManager } from \"./session-manager.js\";\nimport {\n  GraffitiLocalDatabase,\n  type GraffitiLocalOptions,\n} from \"./database.js\";\n\nexport type { GraffitiLocalOptions };\n\n/**\n * A local implementation of the [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)\n * based on [PouchDB](https://pouchdb.com/). PouchDb will automatically persist data in a local\n * database, either in the browser or in Node.js.\n * It can also be configured to work with an external [CouchDB](https://couchdb.apache.org/) server,\n * although using it with a remote server will not be secure.\n */\nexport class GraffitiLocal extends Graffiti {\n  protected sessionManagerLocal = new GraffitiLocalSessionManager();\n  login = this.sessionManagerLocal.login.bind(this.sessionManagerLocal);\n  logout = this.sessionManagerLocal.logout.bind(this.sessionManagerLocal);\n  sessionEvents = this.sessionManagerLocal.sessionEvents;\n\n  put: Graffiti[\"put\"];\n  get: Graffiti[\"get\"];\n  patch: Graffiti[\"patch\"];\n  delete: Graffiti[\"delete\"];\n  discover: Graffiti[\"discover\"];\n  recoverOrphans: Graffiti[\"recoverOrphans\"];\n  channelStats: Graffiti[\"channelStats\"];\n  continueObjectStream: Graffiti[\"continueObjectStream\"];\n\n  constructor(options?: GraffitiLocalOptions) {\n    super();\n\n    const graffitiPouchDbBase = new GraffitiLocalDatabase(options);\n\n    this.put = graffitiPouchDbBase.put.bind(graffitiPouchDbBase);\n    this.get = graffitiPouchDbBase.get.bind(graffitiPouchDbBase);\n    this.patch = graffitiPouchDbBase.patch.bind(graffitiPouchDbBase);\n    this.delete = graffitiPouchDbBase.delete.bind(graffitiPouchDbBase);\n    this.discover = graffitiPouchDbBase.discover.bind(graffitiPouchDbBase);\n    this.recoverOrphans =\n      graffitiPouchDbBase.recoverOrphans.bind(graffitiPouchDbBase);\n    this.channelStats =\n      graffitiPouchDbBase.channelStats.bind(graffitiPouchDbBase);\n    this.continueObjectStream =\n      graffitiPouchDbBase.continueObjectStream.bind(graffitiPouchDbBase);\n  }\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAA+C;AAC/C,6BAA4C;AAC5C,sBAGO;AAWA,MAAM,sBAAsB,oBAAS;AAAA,EAChC,sBAAsB,IAAI,mDAA4B;AAAA,EAChE,QAAQ,KAAK,oBAAoB,MAAM,KAAK,KAAK,mBAAmB;AAAA,EACpE,SAAS,KAAK,oBAAoB,OAAO,KAAK,KAAK,mBAAmB;AAAA,EACtE,gBAAgB,KAAK,oBAAoB;AAAA,EAEzC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,SAAgC;AAC1C,UAAM;AAEN,UAAM,sBAAsB,IAAI,sCAAsB,OAAO;AAE7D,SAAK,MAAM,oBAAoB,IAAI,KAAK,mBAAmB;AAC3D,SAAK,MAAM,oBAAoB,IAAI,KAAK,mBAAmB;AAC3D,SAAK,QAAQ,oBAAoB,MAAM,KAAK,mBAAmB;AAC/D,SAAK,SAAS,oBAAoB,OAAO,KAAK,mBAAmB;AACjE,SAAK,WAAW,oBAAoB,SAAS,KAAK,mBAAmB;AACrE,SAAK,iBACH,oBAAoB,eAAe,KAAK,mBAAmB;AAC7D,SAAK,eACH,oBAAoB,aAAa,KAAK,mBAAmB;AAC3D,SAAK,uBACH,oBAAoB,qBAAqB,KAAK,mBAAmB;AAAA,EACrE;AACF;",
+  "sourcesContent": ["import { Graffiti, type GraffitiSession } from \"@graffiti-garden/api\";\nimport { GraffitiLocalIdentity } from \"./identity\";\nimport { GraffitiLocalObjects, type GraffitiLocalOptions } from \"./objects\";\nimport { GraffitiLocalMedia } from \"./media\";\n\nexport type { GraffitiLocalOptions };\n\n/**\n * A local implementation of the [Graffiti API](https://api.graffiti.garden/classes/Graffiti.html)\n * based on [PouchDB](https://pouchdb.com/). PouchDb will automatically persist data in a local\n * database, either in the browser or in Node.js.\n * It can also be configured to work with an external [CouchDB](https://couchdb.apache.org/) server,\n * although using it with a remote server will not be secure.\n */\nexport class GraffitiLocal implements Graffiti {\n  protected graffitiLocalIdentity = new GraffitiLocalIdentity();\n  login = this.graffitiLocalIdentity.login.bind(this.graffitiLocalIdentity);\n  logout = this.graffitiLocalIdentity.logout.bind(this.graffitiLocalIdentity);\n  handleToActor = this.graffitiLocalIdentity.handleToActor.bind(\n    this.graffitiLocalIdentity,\n  );\n  actorToHandle = this.graffitiLocalIdentity.actorToHandle.bind(\n    this.graffitiLocalIdentity,\n  );\n  sessionEvents = this.graffitiLocalIdentity.sessionEvents;\n\n  protected graffitiLocalObjects: GraffitiLocalObjects;\n  post: Graffiti[\"post\"];\n  get: Graffiti[\"get\"];\n  delete: Graffiti[\"delete\"];\n  discover: Graffiti[\"discover\"];\n  continueDiscover: Graffiti[\"continueDiscover\"];\n\n  protected graffitiLocalMedia: GraffitiLocalMedia;\n  postMedia: Graffiti[\"postMedia\"];\n  getMedia: Graffiti[\"getMedia\"];\n  deleteMedia: Graffiti[\"deleteMedia\"];\n\n  constructor(options?: GraffitiLocalOptions) {\n    this.graffitiLocalObjects = new GraffitiLocalObjects(options);\n    this.post = this.graffitiLocalObjects.post.bind(this.graffitiLocalObjects);\n    this.get = this.graffitiLocalObjects.get.bind(this.graffitiLocalObjects);\n    this.delete = this.graffitiLocalObjects.delete.bind(\n      this.graffitiLocalObjects,\n    );\n    this.discover = this.graffitiLocalObjects.discover.bind(\n      this.graffitiLocalObjects,\n    );\n    this.continueDiscover = this.graffitiLocalObjects.continueDiscover.bind(\n      this.graffitiLocalObjects,\n    );\n\n    this.graffitiLocalMedia = new GraffitiLocalMedia(this.graffitiLocalObjects);\n    this.postMedia = this.graffitiLocalMedia.postMedia.bind(\n      this.graffitiLocalMedia,\n    );\n    this.getMedia = this.graffitiLocalMedia.getMedia.bind(\n      this.graffitiLocalMedia,\n    );\n    this.deleteMedia = this.graffitiLocalMedia.deleteMedia.bind(\n      this.graffitiLocalMedia,\n    );\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAA+C;AAC/C,sBAAsC;AACtC,qBAAgE;AAChE,mBAAmC;AAW5B,MAAM,cAAkC;AAAA,EACnC,wBAAwB,IAAI,sCAAsB;AAAA,EAC5D,QAAQ,KAAK,sBAAsB,MAAM,KAAK,KAAK,qBAAqB;AAAA,EACxE,SAAS,KAAK,sBAAsB,OAAO,KAAK,KAAK,qBAAqB;AAAA,EAC1E,gBAAgB,KAAK,sBAAsB,cAAc;AAAA,IACvD,KAAK;AAAA,EACP;AAAA,EACA,gBAAgB,KAAK,sBAAsB,cAAc;AAAA,IACvD,KAAK;AAAA,EACP;AAAA,EACA,gBAAgB,KAAK,sBAAsB;AAAA,EAEjC;AAAA,EACV;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEU;AAAA,EACV;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,SAAgC;AAC1C,SAAK,uBAAuB,IAAI,oCAAqB,OAAO;AAC5D,SAAK,OAAO,KAAK,qBAAqB,KAAK,KAAK,KAAK,oBAAoB;AACzE,SAAK,MAAM,KAAK,qBAAqB,IAAI,KAAK,KAAK,oBAAoB;AACvE,SAAK,SAAS,KAAK,qBAAqB,OAAO;AAAA,MAC7C,KAAK;AAAA,IACP;AACA,SAAK,WAAW,KAAK,qBAAqB,SAAS;AAAA,MACjD,KAAK;AAAA,IACP;AACA,SAAK,mBAAmB,KAAK,qBAAqB,iBAAiB;AAAA,MACjE,KAAK;AAAA,IACP;AAEA,SAAK,qBAAqB,IAAI,gCAAmB,KAAK,oBAAoB;AAC1E,SAAK,YAAY,KAAK,mBAAmB,UAAU;AAAA,MACjD,KAAK;AAAA,IACP;AACA,SAAK,WAAW,KAAK,mBAAmB,SAAS;AAAA,MAC/C,KAAK;AAAA,IACP;AACA,SAAK,cAAc,KAAK,mBAAmB,YAAY;AAAA,MACrD,KAAK;AAAA,IACP;AAAA,EACF;AACF;",
   "names": []
 }

package/dist/cjs/media.js

@@ -0,0 +1,111 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var media_exports = {};
+__export(media_exports, {
+  GraffitiLocalMedia: () => GraffitiLocalMedia
+});
+module.exports = __toCommonJS(media_exports);
+var import_api = require("@graffiti-garden/api");
+var import_utilities = require("./utilities");
+var import_negotiator = __toESM(require("negotiator"));
+const MEDIA_OBJECT_SCHEMA = {
+  properties: {
+    value: {
+      properties: {
+        dataBase64: { type: "string" },
+        type: { type: "string" },
+        size: { type: "number" }
+      },
+      required: ["dataBase64", "type", "size"]
+    }
+  }
+};
+class GraffitiLocalMedia {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  postMedia = async (...args) => {
+    const [media, session] = args;
+    const dataBase64 = await (0, import_utilities.blobToBase64)(media.data);
+    const type = media.data.type;
+    const { url } = await this.db.post(
+      {
+        value: {
+          dataBase64,
+          type,
+          size: media.data.size
+        },
+        channels: [],
+        allowed: media.allowed
+      },
+      session
+    );
+    const { actor, id } = (0, import_utilities.decodeObjectUrl)(url);
+    return (0, import_utilities.encodeMediaUrl)(actor, id);
+  };
+  getMedia = async (...args) => {
+    const [mediaUrl, requirements, session] = args;
+    const { actor, id } = (0, import_utilities.decodeMediaUrl)(mediaUrl);
+    const objectUrl = (0, import_utilities.encodeObjectUrl)(actor, id);
+    const object = await this.db.get(
+      objectUrl,
+      MEDIA_OBJECT_SCHEMA,
+      session
+    );
+    const { dataBase64, type, size } = object.value;
+    if (requirements?.maxBytes && size > requirements.maxBytes) {
+      throw new import_api.GraffitiErrorTooLarge("File size exceeds limit");
+    }
+    if (requirements?.accept) {
+      const negotiator = new import_negotiator.default({
+        headers: { accept: requirements.accept }
+      });
+      if (negotiator.mediaType([type]) !== type) {
+        throw new import_api.GraffitiErrorNotAcceptable(`Unsupported media type, ${type}`);
+      }
+    }
+    const data = await (0, import_utilities.base64ToBlob)(dataBase64);
+    if (data.size !== size || data.type !== type) {
+      throw new Error("Invalid data");
+    }
+    return {
+      data,
+      actor: object.actor,
+      allowed: object.allowed
+    };
+  };
+  deleteMedia = async (...args) => {
+    const [mediaUrl, session] = args;
+    const { actor, id } = (0, import_utilities.decodeMediaUrl)(mediaUrl);
+    const objectUrl = (0, import_utilities.encodeObjectUrl)(actor, id);
+    await this.db.delete(objectUrl, session);
+  };
+}
+//# sourceMappingURL=media.js.map

package/dist/cjs/media.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/media.ts"],
+  "sourcesContent": ["import {\n  GraffitiErrorNotAcceptable,\n  GraffitiErrorTooLarge,\n  type Graffiti,\n  type JSONSchema,\n} from \"@graffiti-garden/api\";\nimport {\n  decodeObjectUrl,\n  encodeObjectUrl,\n  decodeMediaUrl,\n  encodeMediaUrl,\n  blobToBase64,\n  base64ToBlob,\n} from \"./utilities\";\nimport Negotiator from \"negotiator\";\n\nconst MEDIA_OBJECT_SCHEMA = {\n  properties: {\n    value: {\n      properties: {\n        dataBase64: { type: \"string\" },\n        type: { type: \"string\" },\n        size: { type: \"number\" },\n      },\n      required: [\"dataBase64\", \"type\", \"size\"],\n    },\n  },\n} as const satisfies JSONSchema;\n\nexport class GraffitiLocalMedia {\n  protected db: Pick<Graffiti, \"post\" | \"get\" | \"delete\">;\n\n  constructor(db: Pick<Graffiti, \"post\" | \"get\" | \"delete\">) {\n    this.db = db;\n  }\n\n  postMedia: Graffiti[\"postMedia\"] = async (...args) => {\n    const [media, session] = args;\n\n    const dataBase64 = await blobToBase64(media.data);\n    const type = media.data.type;\n\n    const { url } = await this.db.post<typeof MEDIA_OBJECT_SCHEMA>(\n      {\n        value: {\n          dataBase64,\n          type,\n          size: media.data.size,\n        },\n        channels: [],\n        allowed: media.allowed,\n      },\n      session,\n    );\n\n    const { actor, id } = decodeObjectUrl(url);\n    return encodeMediaUrl(actor, id);\n  };\n\n  getMedia: Graffiti[\"getMedia\"] = async (...args) => {\n    const [mediaUrl, requirements, session] = args;\n    const { actor, id } = decodeMediaUrl(mediaUrl);\n    const objectUrl = encodeObjectUrl(actor, id);\n\n    const object = await this.db.get<typeof MEDIA_OBJECT_SCHEMA>(\n      objectUrl,\n      MEDIA_OBJECT_SCHEMA,\n      session,\n    );\n\n    const { dataBase64, type, size } = object.value;\n\n    if (requirements?.maxBytes && size > requirements.maxBytes) {\n      throw new GraffitiErrorTooLarge(\"File size exceeds limit\");\n    }\n\n    // Make sure it adheres to requirements.accept\n    if (requirements?.accept) {\n      const negotiator = new Negotiator({\n        headers: { accept: requirements.accept },\n      });\n      if (negotiator.mediaType([type]) !== type) {\n        throw new GraffitiErrorNotAcceptable(`Unsupported media type, ${type}`);\n      }\n    }\n\n    const data = await base64ToBlob(dataBase64);\n    if (data.size !== size || data.type !== type) {\n      throw new Error(\"Invalid data\");\n    }\n\n    return {\n      data,\n      actor: object.actor,\n      allowed: object.allowed,\n    };\n  };\n\n  deleteMedia: Graffiti[\"deleteMedia\"] = async (...args) => {\n    const [mediaUrl, session] = args;\n    const { actor, id } = decodeMediaUrl(mediaUrl);\n    const objectUrl = encodeObjectUrl(actor, id);\n\n    await this.db.delete(objectUrl, session);\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAKO;AACP,uBAOO;AACP,wBAAuB;AAEvB,MAAM,sBAAsB;AAAA,EAC1B,YAAY;AAAA,IACV,OAAO;AAAA,MACL,YAAY;AAAA,QACV,YAAY,EAAE,MAAM,SAAS;AAAA,QAC7B,MAAM,EAAE,MAAM,SAAS;AAAA,QACvB,MAAM,EAAE,MAAM,SAAS;AAAA,MACzB;AAAA,MACA,UAAU,CAAC,cAAc,QAAQ,MAAM;AAAA,IACzC;AAAA,EACF;AACF;AAEO,MAAM,mBAAmB;AAAA,EACpB;AAAA,EAEV,YAAY,IAA+C;AACzD,SAAK,KAAK;AAAA,EACZ;AAAA,EAEA,YAAmC,UAAU,SAAS;AACpD,UAAM,CAAC,OAAO,OAAO,IAAI;AAEzB,UAAM,aAAa,UAAM,+BAAa,MAAM,IAAI;AAChD,UAAM,OAAO,MAAM,KAAK;AAExB,UAAM,EAAE,IAAI,IAAI,MAAM,KAAK,GAAG;AAAA,MAC5B;AAAA,QACE,OAAO;AAAA,UACL;AAAA,UACA;AAAA,UACA,MAAM,MAAM,KAAK;AAAA,QACnB;AAAA,QACA,UAAU,CAAC;AAAA,QACX,SAAS,MAAM;AAAA,MACjB;AAAA,MACA;AAAA,IACF;AAEA,UAAM,EAAE,OAAO,GAAG,QAAI,kCAAgB,GAAG;AACzC,eAAO,iCAAe,OAAO,EAAE;AAAA,EACjC;AAAA,EAEA,WAAiC,UAAU,SAAS;AAClD,UAAM,CAAC,UAAU,cAAc,OAAO,IAAI;AAC1C,UAAM,EAAE,OAAO,GAAG,QAAI,iCAAe,QAAQ;AAC7C,UAAM,gBAAY,kCAAgB,OAAO,EAAE;AAE3C,UAAM,SAAS,MAAM,KAAK,GAAG;AAAA,MAC3B;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAEA,UAAM,EAAE,YAAY,MAAM,KAAK,IAAI,OAAO;AAE1C,QAAI,cAAc,YAAY,OAAO,aAAa,UAAU;AAC1D,YAAM,IAAI,iCAAsB,yBAAyB;AAAA,IAC3D;AAGA,QAAI,cAAc,QAAQ;AACxB,YAAM,aAAa,IAAI,kBAAAA,QAAW;AAAA,QAChC,SAAS,EAAE,QAAQ,aAAa,OAAO;AAAA,MACzC,CAAC;AACD,UAAI,WAAW,UAAU,CAAC,IAAI,CAAC,MAAM,MAAM;AACzC,cAAM,IAAI,sCAA2B,2BAA2B,IAAI,EAAE;AAAA,MACxE;AAAA,IACF;AAEA,UAAM,OAAO,UAAM,+BAAa,UAAU;AAC1C,QAAI,KAAK,SAAS,QAAQ,KAAK,SAAS,MAAM;AAC5C,YAAM,IAAI,MAAM,cAAc;AAAA,IAChC;AAEA,WAAO;AAAA,MACL;AAAA,MACA,OAAO,OAAO;AAAA,MACd,SAAS,OAAO;AAAA,IAClB;AAAA,EACF;AAAA,EAEA,cAAuC,UAAU,SAAS;AACxD,UAAM,CAAC,UAAU,OAAO,IAAI;AAC5B,UAAM,EAAE,OAAO,GAAG,QAAI,iCAAe,QAAQ;AAC7C,UAAM,gBAAY,kCAAgB,OAAO,EAAE;AAE3C,UAAM,KAAK,GAAG,OAAO,WAAW,OAAO;AAAA,EACzC;AACF;",
+  "names": ["Negotiator"]
+}

package/dist/cjs/objects.js

@@ -0,0 +1,307 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var objects_exports = {};
+__export(objects_exports, {
+  GraffitiLocalObjects: () => GraffitiLocalObjects
+});
+module.exports = __toCommonJS(objects_exports);
+var import_api = require("@graffiti-garden/api");
+var import_utilities = require("./utilities.js");
+class GraffitiLocalObjects {
+  db_;
+  ajv_;
+  options;
+  operationClock = 0;
+  get db() {
+    if (!this.db_) {
+      this.db_ = (async () => {
+        const { default: PouchDB } = await import("pouchdb");
+        const pouchDbOptions = {
+          name: "graffitiDb",
+          ...this.options.pouchDBOptions
+        };
+        const db = new PouchDB(
+          pouchDbOptions.name,
+          pouchDbOptions
+        );
+        await db.put({
+          _id: "_design/indexes",
+          views: {
+            objectsPerChannelAndLastModified: {
+              map: function(object) {
+                const paddedLastModified = object.lastModified.toString().padStart(15, "0");
+                object.channels.forEach(function(channel) {
+                  const id = encodeURIComponent(channel) + "/" + paddedLastModified;
+                  emit(id);
+                });
+              }.toString()
+            }
+          }
+        }).catch((error) => {
+          if (error && typeof error === "object" && "name" in error && error.name === "conflict") {
+            return;
+          } else {
+            throw error;
+          }
+        });
+        return db;
+      })();
+    }
+    return this.db_;
+  }
+  get ajv() {
+    if (!this.ajv_) {
+      this.ajv_ = (async () => {
+        const { default: Ajv } = await import("ajv");
+        return new Ajv({ strict: false });
+      })();
+    }
+    return this.ajv_;
+  }
+  constructor(options) {
+    this.options = options ?? {};
+  }
+  get = async (...args) => {
+    const [urlObject, schema, session] = args;
+    const url = (0, import_api.unpackObjectUrl)(urlObject);
+    let doc;
+    try {
+      doc = await (await this.db).get(url);
+    } catch (error) {
+      throw new import_api.GraffitiErrorNotFound(
+        "The object you are trying to get either does not exist or you are not allowed to see it"
+      );
+    }
+    if (doc.tombstone) {
+      throw new import_api.GraffitiErrorNotFound(
+        "The object you are trying to get either does not exist or you are not allowed to see it"
+      );
+    }
+    const { actor } = (0, import_utilities.decodeObjectUrl)(url);
+    const { value, channels, allowed } = doc;
+    const object = {
+      value,
+      channels,
+      allowed,
+      url,
+      actor
+    };
+    if (!(0, import_api.isActorAllowedGraffitiObject)(object, session)) {
+      throw new import_api.GraffitiErrorNotFound(
+        "The object you are trying to get either does not exist or you are not allowed to see it"
+      );
+    }
+    (0, import_api.maskGraffitiObject)(object, [], session);
+    const validate = (0, import_api.compileGraffitiObjectSchema)(await this.ajv, schema);
+    if (!validate(object)) {
+      throw new import_api.GraffitiErrorSchemaMismatch();
+    }
+    return object;
+  };
+  delete = async (...args) => {
+    const [urlObject, session] = args;
+    const url = (0, import_api.unpackObjectUrl)(urlObject);
+    const { actor } = (0, import_utilities.decodeObjectUrl)(url);
+    if (actor !== session.actor) {
+      throw new import_api.GraffitiErrorForbidden(
+        "You cannot delete an object that you did not create."
+      );
+    }
+    let doc;
+    try {
+      doc = await (await this.db).get(url);
+    } catch {
+      throw new import_api.GraffitiErrorNotFound("Object not found.");
+    }
+    if (doc.tombstone) {
+      throw new import_api.GraffitiErrorNotFound("Object not found.");
+    }
+    doc.tombstone = true;
+    doc.lastModified = this.operationClock;
+    try {
+      await (await this.db).put(doc);
+    } catch {
+      throw new import_api.GraffitiErrorNotFound("Object not found.");
+    }
+    this.operationClock++;
+    return;
+  };
+  post = async (...args) => {
+    const [objectPartial, session] = args;
+    const actor = session.actor;
+    const id = (0, import_utilities.randomBase64)();
+    const url = (0, import_utilities.encodeObjectUrl)(actor, id);
+    const { value, channels, allowed } = objectPartial;
+    const object = {
+      value,
+      channels,
+      allowed,
+      lastModified: this.operationClock,
+      tombstone: false
+    };
+    await (await this.db).put({
+      _id: url,
+      ...object
+    });
+    this.operationClock++;
+    return {
+      ...objectPartial,
+      actor,
+      url
+    };
+  };
+  async *discoverMeta(args, continueParams) {
+    if (continueParams) {
+      const continueBuffer = this.options.continueBuffer ?? 2e3;
+      const timeElapsedSinceLastDiscover = Date.now() - continueParams.lastDiscovered;
+      if (timeElapsedSinceLastDiscover < continueBuffer) {
+        await new Promise(
+          (resolve) => setTimeout(resolve, continueBuffer - timeElapsedSinceLastDiscover)
+        );
+      }
+    }
+    const [discoverChannels, schema, session] = args;
+    const validate = (0, import_api.compileGraffitiObjectSchema)(await this.ajv, schema);
+    const startKeySuffix = continueParams ? continueParams.ifModifiedSince.toString().padStart(15, "0") : "";
+    const endKeySuffix = "\uFFFF";
+    const processedUrls = /* @__PURE__ */ new Set();
+    const startTime = this.operationClock;
+    for (const channel of discoverChannels) {
+      const keyPrefix = encodeURIComponent(channel) + "/";
+      const startkey = keyPrefix + startKeySuffix;
+      const endkey = keyPrefix + endKeySuffix;
+      const result = await (await this.db).query("indexes/objectsPerChannelAndLastModified", {
+        startkey,
+        endkey,
+        include_docs: true
+      });
+      for (const row of result.rows) {
+        const doc = row.doc;
+        if (!doc) continue;
+        const url = doc._id;
+        if (processedUrls.has(url)) continue;
+        processedUrls.add(url);
+        if (!continueParams && doc.tombstone) continue;
+        const { tombstone, value, channels, allowed } = doc;
+        const { actor } = (0, import_utilities.decodeObjectUrl)(url);
+        const object = {
+          url,
+          value,
+          allowed,
+          channels,
+          actor
+        };
+        if (!(0, import_api.isActorAllowedGraffitiObject)(object, session)) continue;
+        (0, import_api.maskGraffitiObject)(object, discoverChannels, session);
+        if (!validate(object)) continue;
+        yield tombstone ? {
+          tombstone: true,
+          object: { url }
+        } : { object };
+      }
+    }
+    return {
+      lastDiscovered: Date.now(),
+      ifModifiedSince: startTime
+    };
+  }
+  discoverCursor(args, continueParams) {
+    const [channels, schema, session] = args;
+    return "discover:" + JSON.stringify({
+      channels,
+      schema,
+      continueParams,
+      actor: session?.actor
+    });
+  }
+  async *discoverContinue(args, continueParams, session) {
+    if (session?.actor !== args[2]?.actor) {
+      throw new import_api.GraffitiErrorForbidden(
+        "Cannot continue a cursor started by another actor"
+      );
+    }
+    const iterator = this.discoverMeta(args, continueParams);
+    while (true) {
+      const result = await iterator.next();
+      if (result.done) {
+        return {
+          continue: (session2) => this.discoverContinue(args, result.value, session2),
+          cursor: this.discoverCursor(args, result.value)
+        };
+      }
+      yield result.value;
+    }
+  }
+  discover = (...args) => {
+    const [channels, schema, session] = args;
+    const iterator = this.discoverMeta([
+      channels,
+      schema,
+      session
+    ]);
+    const this_ = this;
+    return (async function* () {
+      while (true) {
+        const result = await iterator.next();
+        if (result.done) {
+          return {
+            continue: (session2) => this_.discoverContinue(
+              args,
+              result.value,
+              session2
+            ),
+            cursor: this_.discoverCursor(args, result.value)
+          };
+        }
+        if (result.value.tombstone) continue;
+        yield result.value;
+      }
+    })();
+  };
+  continueDiscover = (...args) => {
+    const [cursor, session] = args;
+    if (cursor.startsWith("discover:")) {
+      const { channels, schema, actor, continueParams } = JSON.parse(
+        cursor.slice("discover:".length)
+      );
+      if (actor && actor !== session?.actor) {
+        throw new import_api.GraffitiErrorForbidden(
+          "Cannot continue a cursor started by another actor"
+        );
+      }
+      return this.discoverContinue(
+        [channels, schema, session],
+        continueParams
+      );
+    } else {
+      throw new import_api.GraffitiErrorNotFound("Cursor not found");
+    }
+  };
+}
+//# sourceMappingURL=objects.js.map