@graffiti-garden/implementation-decentralized 0.0.1

package/dist/cjs/3-protocol/4-graffiti.js

@@ -0,0 +1,937 @@
+"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 graffiti_exports = {};
+__export(graffiti_exports, {
+  GraffitiDecentralized: () => GraffitiDecentralized
+});
+module.exports = __toCommonJS(graffiti_exports);
+var import_api = require("@graffiti-garden/api");
+var import_utils = require("@noble/hashes/utils.js");
+var import_dag_cbor = require("@ipld/dag-cbor");
+var import_dids = require("../1-services/2-dids");
+var import_authorization = require("../1-services/1-authorization");
+var import_storage_buckets = require("../1-services/3-storage-buckets");
+var import_inboxes = require("../1-services/4-inboxes");
+var import_string_encoding = require("../2-primitives/1-string-encoding");
+var import_content_addresses = require("../2-primitives/2-content-addresses");
+var import_channel_attestations = require("../2-primitives/3-channel-attestations");
+var import_allowed_attestations = require("../2-primitives/4-allowed-attestations");
+var import_handles = require("./2-handles");
+var import_sessions = require("./1-sessions");
+var import_object_encoding = require("./3-object-encoding");
+var import_modal = require("@graffiti-garden/modal");
+var import_mini = require("zod/mini");
+const Uint8ArraySchema = (0, import_mini.custom)(
+  (v) => v instanceof Uint8Array
+);
+const MESSAGE_DATA_STORAGE_BUCKET_KEY = "k";
+const MESSAGE_DATA_TOMBSTONED_MESSAGE_ID_KEY = "t";
+const MessageMetadataBaseSchema = (0, import_mini.strictObject)({
+  [MESSAGE_DATA_STORAGE_BUCKET_KEY]: (0, import_mini.string)(),
+  [MESSAGE_DATA_TOMBSTONED_MESSAGE_ID_KEY]: (0, import_mini.optional)((0, import_mini.string)())
+});
+const MESSAGE_DATA_ANNOUNCEMENT_MESSAGE_ID_KEY = "id";
+const MESSAGE_DATA_ANNOUNCEMENT_ENDPOINT_KEY = "e";
+const MESSAGE_DATA_ANNOUNCEMENT_ACTOR_KEY = "a";
+const MessageMetadataAnnouncementsSchema = (0, import_mini.array)(
+  (0, import_mini.strictObject)({
+    [MESSAGE_DATA_ANNOUNCEMENT_MESSAGE_ID_KEY]: (0, import_mini.string)(),
+    [MESSAGE_DATA_ANNOUNCEMENT_ENDPOINT_KEY]: (0, import_mini.optional)((0, import_mini.url)()),
+    [MESSAGE_DATA_ANNOUNCEMENT_ACTOR_KEY]: (0, import_mini.optional)((0, import_mini.url)())
+  })
+);
+const MESSAGE_DATA_ALLOWED_TICKETS_KEY = "s";
+const MESSAGE_DATA_ANNOUNCEMENTS_KEY = "n";
+const MessageMetaDataSelfSchema = (0, import_mini.extend)(MessageMetadataBaseSchema, {
+  [MESSAGE_DATA_ALLOWED_TICKETS_KEY]: (0, import_mini.optional)((0, import_mini.array)(Uint8ArraySchema)),
+  [MESSAGE_DATA_ANNOUNCEMENTS_KEY]: MessageMetadataAnnouncementsSchema
+});
+const MESSAGE_DATA_ALLOWED_TICKET_KEY = "a";
+const MESSAGE_DATA_ALLOWED_TICKET_INDEX_KEY = "i";
+const MessageMetadataPrivateSchema = (0, import_mini.extend)(MessageMetadataBaseSchema, {
+  [MESSAGE_DATA_ALLOWED_TICKET_KEY]: Uint8ArraySchema,
+  [MESSAGE_DATA_ALLOWED_TICKET_INDEX_KEY]: (0, import_mini.int)().check((0, import_mini.nonnegative)())
+});
+const MessageMetadataSchema = (0, import_mini.union)([
+  MessageMetadataBaseSchema,
+  MessageMetaDataSelfSchema,
+  MessageMetadataPrivateSchema
+]);
+const MESSAGE_LABEL_UNLABELED = 0;
+const MESSAGE_LABEL_VALID = 1;
+const MESSAGE_LABEL_TRASH = 2;
+const MESSAGE_LABEL_INVALID = 3;
+class GraffitiDecentralized {
+  dids = new import_dids.DecentralizedIdentifiers();
+  authorization = new import_authorization.Authorization();
+  storageBuckets = new import_storage_buckets.StorageBuckets();
+  inboxes = new import_inboxes.Inboxes();
+  stringEncoder = new import_string_encoding.StringEncoder();
+  contentAddresses = new import_content_addresses.ContentAddresses();
+  channelAttestations = new import_channel_attestations.ChannelAttestations();
+  allowedAttestations = new import_allowed_attestations.AllowedAttestations();
+  sessions = new import_sessions.Sessions({
+    dids: this.dids,
+    authorization: this.authorization,
+    storageBuckets: this.storageBuckets,
+    inboxes: this.inboxes
+  });
+  handles = new import_handles.Handles({ dids: this.dids });
+  objectEncoding = new import_object_encoding.ObjectEncoding({
+    stringEncoder: this.stringEncoder,
+    contentAddresses: this.contentAddresses,
+    channelAttestations: this.channelAttestations,
+    allowedAttestations: this.allowedAttestations
+  });
+  modal = typeof window === "undefined" ? void 0 : new import_modal.GraffitiModal({
+    useTemplateHTML: () => import("./login-dialog.html").then(({ template }) => template),
+    onManualClose: () => {
+      const event = new CustomEvent("login", {
+        detail: {
+          error: new Error("User cancelled login"),
+          manual: true
+        }
+      });
+      this.sessionEvents.dispatchEvent(event);
+    }
+  });
+  defaultInboxEndpoints;
+  identityCreatorEndpoint;
+  constructor(options) {
+    this.defaultInboxEndpoints = options?.defaultInboxEndpoints ?? [
+      "https://graffiti.actor/i/shared"
+    ];
+    this.identityCreatorEndpoint = options?.identityCreatorEndpoint ?? "https://graffiti.actor/create";
+    this.sessionEvents.addEventListener("login", async (event) => {
+      if (!(event instanceof CustomEvent)) return;
+      const detail = event.detail;
+      if (detail.error !== void 0 && !("manual" in detail && detail.manual)) {
+        alert("Login failed: " + detail.error.message);
+        const actor = detail.session?.actor;
+        let handle;
+        if (actor) {
+          try {
+            handle = await this.actorToHandle(actor);
+          } catch (error) {
+            console.error("Failed to handle actor:", error);
+          }
+        }
+        this.login_(handle);
+      }
+    });
+  }
+  actorToHandle = this.handles.actorToHandle.bind(this.handles);
+  handleToActor = this.handles.handleToActor.bind(this.handles);
+  sessionEvents = this.sessions.sessionEvents;
+  login = async (actor) => {
+    try {
+      let proposedHandle;
+      try {
+        proposedHandle = actor ? await this.actorToHandle(actor) : void 0;
+      } catch (error) {
+        console.error("Error fetching handle for actor:", error);
+      }
+      await this.login_(proposedHandle);
+    } catch (e) {
+      const loginError = new CustomEvent("login", {
+        detail: {
+          error: e instanceof Error ? e : new Error(String(e))
+        }
+      });
+      this.sessionEvents.dispatchEvent(loginError);
+    }
+  };
+  async login_(proposedHandle) {
+    if (typeof window !== "undefined") {
+      let template;
+      if (proposedHandle !== void 0) {
+        template = await this.modal?.displayTemplate("graffiti-login-handle");
+        const input = template?.querySelector(
+          "#username"
+        );
+        input?.setAttribute("value", proposedHandle);
+        input?.addEventListener("focus", () => input?.select());
+        new Promise((r) => {
+          setTimeout(() => r(), 0);
+        }).then(() => {
+          input?.focus();
+        });
+        template?.querySelector("#graffiti-login-handle-form")?.addEventListener("submit", async (e) => {
+          e.preventDefault();
+          input?.setAttribute("disabled", "true");
+          const submitButton = template?.querySelector(
+            "#graffiti-login-handle-submit"
+          );
+          submitButton?.setAttribute("disabled", "true");
+          submitButton && (submitButton.innerHTML = "Logging in...");
+          if (!input?.value) {
+            alert("No handle provided");
+            this.login_("");
+            return;
+          }
+          let handle = input.value;
+          if (!handle.includes(".") && !handle.startsWith("localhost")) {
+            const defaultHost = new URL(this.identityCreatorEndpoint).host;
+            handle = `${handle}.${defaultHost}`;
+          }
+          let actor;
+          try {
+            actor = await this.handleToActor(handle);
+          } catch (e2) {
+            alert("Could not find an identity associated with that handle.");
+            this.login_(handle);
+            return;
+          }
+          try {
+            await this.sessions.login(actor);
+          } catch (e2) {
+            alert("Error logging in.");
+            console.error(e2);
+            this.login_(handle);
+          }
+        });
+      } else {
+        template = await this.modal?.displayTemplate("graffiti-login-welcome");
+        template?.querySelector("#graffiti-login-existing")?.addEventListener("click", (e) => {
+          e.preventDefault();
+          this.login_("");
+        });
+        new Promise((r) => {
+          setTimeout(() => r(), 0);
+        }).then(() => {
+          template?.querySelector("#graffiti-login-new")?.focus();
+        });
+      }
+      const createUrl = new URL(this.identityCreatorEndpoint);
+      createUrl.searchParams.set(
+        "redirect_uri",
+        encodeURIComponent(window.location.toString())
+      );
+      template?.querySelector("#graffiti-login-new")?.setAttribute("href", createUrl.toString());
+      await this.modal?.open();
+    } else {
+      const readline = await import("readline").catch((e) => {
+        throw new Error(
+          "Unrecognized environment: neither window nor readline"
+        );
+      });
+      console.log(
+        "If you do not already have a Graffiti handle, you can create one here:"
+      );
+      console.log(this.identityCreatorEndpoint);
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const handle = await new Promise((resolve) => {
+        rl.question(
+          `Please enter your handle${proposedHandle ? ` (default: ${proposedHandle})` : ""}: `,
+          (input) => {
+            rl.close();
+            resolve(input || proposedHandle);
+          }
+        );
+      });
+      if (!handle) {
+        throw new Error("No handle provided");
+      }
+      const actor = await this.handleToActor(handle);
+      await this.sessions.login(actor);
+    }
+  }
+  logout = async (session) => {
+    await this.sessions.logout(session.actor);
+  };
+  // @ts-ignore
+  post = async (...args) => {
+    const [partialObject, session] = args;
+    const resolvedSession = this.sessions.resolveSession(session);
+    const { object, tags, objectBytes, allowedTickets } = await this.objectEncoding.encode(partialObject, session.actor);
+    const storageBucketKeyBytes = (0, import_utils.randomBytes)();
+    const storageBucketKey = await this.stringEncoder.encode(
+      import_string_encoding.STRING_ENCODER_METHOD_BASE64URL,
+      storageBucketKeyBytes
+    );
+    await this.storageBuckets.put(
+      resolvedSession.storageBucket.serviceEndpoint,
+      storageBucketKey,
+      objectBytes,
+      resolvedSession.storageBucket.token
+    );
+    await this.announceObject(
+      object,
+      tags,
+      allowedTickets,
+      storageBucketKey,
+      session
+    );
+    return object;
+  };
+  get = async (...args) => {
+    const [url2, schema, session] = args;
+    let services;
+    const validator = await (0, import_api.compileGraffitiObjectSchema)(schema);
+    if (session) {
+      const resolvedSession = this.sessions.resolveSession(session);
+      services = [
+        resolvedSession.personalInbox,
+        ...resolvedSession.sharedInboxes
+      ];
+    } else {
+      services = this.defaultInboxEndpoints.map((s) => ({
+        serviceEndpoint: s
+      }));
+    }
+    const objectUrl = (0, import_api.unpackObjectUrl)(url2);
+    const tags = [new TextEncoder().encode(objectUrl)];
+    for (const service of services) {
+      let object = void 0;
+      const iterator = this.querySingleEndpoint(
+        service.serviceEndpoint,
+        {
+          tags,
+          objectSchema: {}
+        },
+        service.token,
+        session?.actor
+      );
+      for await (const result of iterator) {
+        if (result.object.url !== objectUrl) continue;
+        if (result.tombstone) {
+          object = void 0;
+        } else {
+          object = result.object;
+        }
+      }
+      if (object) {
+        if (!validator(object)) {
+          throw new import_api.GraffitiErrorSchemaMismatch(
+            "Object exists but does not match the supplied schema"
+          );
+        }
+        return object;
+      }
+    }
+    throw new import_api.GraffitiErrorNotFound("Object not found");
+  };
+  delete = async (url2, session) => {
+    const resolvedSession = this.sessions.resolveSession(session);
+    const objectUrl = (0, import_api.unpackObjectUrl)(url2);
+    const { actor } = (0, import_object_encoding.decodeObjectUrl)(objectUrl);
+    if (actor !== session.actor) {
+      throw new import_api.GraffitiErrorForbidden("Cannot delete someone else's actor");
+    }
+    const iterator = this.querySingleEndpoint(
+      resolvedSession.personalInbox.serviceEndpoint,
+      {
+        tags: [new TextEncoder().encode(objectUrl)],
+        objectSchema: {}
+      },
+      resolvedSession.personalInbox.token
+    );
+    let existing;
+    for await (const result of iterator) {
+      if (result.object.url !== objectUrl) continue;
+      if (result.tombstone) {
+        existing = void 0;
+      } else {
+        existing = result;
+      }
+    }
+    if (!existing) {
+      throw new import_api.GraffitiErrorNotFound(`Object ${objectUrl} not found`);
+    }
+    const {
+      object,
+      storageBucketKey,
+      tags,
+      allowedTickets,
+      announcements,
+      messageId
+    } = existing;
+    await this.storageBuckets.delete(
+      resolvedSession.storageBucket.serviceEndpoint,
+      storageBucketKey,
+      resolvedSession.storageBucket.token
+    );
+    await this.announceObject(
+      object,
+      tags,
+      allowedTickets,
+      storageBucketKey,
+      session,
+      [
+        ...announcements ?? [],
+        // Make sure we delete from our own inbox too
+        {
+          [MESSAGE_DATA_ANNOUNCEMENT_ACTOR_KEY]: session.actor,
+          [MESSAGE_DATA_ANNOUNCEMENT_MESSAGE_ID_KEY]: messageId
+        }
+      ]
+    );
+    return object;
+  };
+  postMedia = async (...args) => {
+    const [media, session] = args;
+    const type = media.data.type;
+    const resolvedSession = this.sessions.resolveSession(session);
+    const keyBytes = (0, import_utils.randomBytes)();
+    const key = await this.stringEncoder.encode(
+      import_string_encoding.STRING_ENCODER_METHOD_BASE64URL,
+      keyBytes
+    );
+    await this.storageBuckets.put(
+      resolvedSession.storageBucket.serviceEndpoint,
+      key,
+      new Uint8Array(await media.data.arrayBuffer()),
+      resolvedSession.storageBucket.token
+    );
+    const { url: url2 } = await this.post(
+      {
+        value: {
+          key,
+          type,
+          size: media.data.size
+        },
+        channels: [],
+        allowed: media.allowed
+      },
+      session
+    );
+    return url2;
+  };
+  getMedia = async (...args) => {
+    const [mediaUrl, accept, session] = args;
+    const object = await this.get(
+      mediaUrl,
+      MEDIA_OBJECT_SCHEMA,
+      session
+    );
+    const { key, type, size } = object.value;
+    if (accept?.maxBytes && size > accept.maxBytes) {
+      throw new import_api.GraffitiErrorTooLarge("File size exceeds limit");
+    }
+    if (accept?.types) {
+      if (!(0, import_api.isMediaAcceptable)(type, accept.types)) {
+        throw new import_api.GraffitiErrorNotAcceptable(
+          `Unacceptable media type, ${type}`
+        );
+      }
+    }
+    const actorDocument = await this.dids.resolve(object.actor);
+    const storageBucketService = actorDocument?.service?.find(
+      (service) => service.id === import_sessions.DID_SERVICE_ID_GRAFFITI_STORAGE_BUCKET && service.type === import_sessions.DID_SERVICE_TYPE_GRAFFITI_STORAGE_BUCKET
+    );
+    if (!storageBucketService) {
+      throw new import_api.GraffitiErrorNotFound(
+        `Actor ${object.actor} has no storage bucket service`
+      );
+    }
+    if (typeof storageBucketService.serviceEndpoint !== "string") {
+      throw new import_api.GraffitiErrorNotFound(
+        `Actor ${object.actor} does not have a valid storage bucket endpoint`
+      );
+    }
+    const storageBucketEndpoint = storageBucketService.serviceEndpoint;
+    const data = await this.storageBuckets.get(
+      storageBucketEndpoint,
+      key,
+      size
+    );
+    const blob = new Blob([data.slice()], { type });
+    return {
+      data: blob,
+      actor: object.actor,
+      allowed: object.allowed
+    };
+  };
+  deleteMedia = async (...args) => {
+    const [mediaUrl, session] = args;
+    const resolvedSession = this.sessions.resolveSession(session);
+    const result = await this.delete(mediaUrl, session);
+    if (!("key" in result.value && typeof result.value.key === "string"))
+      throw new Error(
+        "Deleted object was not media: " + JSON.stringify(result, null, 2)
+      );
+    await this.storageBuckets.delete(
+      resolvedSession.storageBucket.serviceEndpoint,
+      result.value.key,
+      resolvedSession.storageBucket.token
+    );
+  };
+  async *discoverMeta(channels, schema, cursors, session) {
+    const tombstones = /* @__PURE__ */ new Map();
+    let allInboxes;
+    if (session) {
+      const resolvedSession = this.sessions.resolveSession(session);
+      allInboxes = [
+        resolvedSession.personalInbox,
+        ...resolvedSession.sharedInboxes
+      ];
+    } else {
+      allInboxes = this.defaultInboxEndpoints.map((e) => ({
+        serviceEndpoint: e
+      }));
+    }
+    for (const endpoint in cursors) {
+      if (!allInboxes.some((i) => i.serviceEndpoint === endpoint)) {
+        throw new import_api.GraffitiErrorForbidden(
+          "Cursor does not match actor's inboxes"
+        );
+      }
+    }
+    const tags = await Promise.all(
+      channels.map(
+        (c) => this.channelAttestations.register(
+          import_channel_attestations.CHANNEL_ATTESTATION_METHOD_SHA256_ED25519,
+          c
+        )
+      )
+    );
+    const iterators = allInboxes.map(
+      (i) => {
+        const cursor = cursors[i.serviceEndpoint];
+        return this.querySingleEndpoint(
+          i.serviceEndpoint,
+          cursor ? {
+            cursor
+          } : {
+            tags,
+            objectSchema: schema
+          },
+          i.token,
+          session?.actor
+        );
+      }
+    );
+    let indexedIteratorNexts = iterators.map(async (it, index) => indexedSingleEndpointQueryNext(it, index));
+    let active = indexedIteratorNexts.length;
+    while (active > 0) {
+      const next = await Promise.race(indexedIteratorNexts);
+      if (next.error !== void 0) {
+        indexedIteratorNexts[next.index] = new Promise(() => {
+        });
+        active--;
+        yield {
+          error: next.error,
+          origin: allInboxes[next.index].serviceEndpoint
+        };
+      } else if (next.result.done) {
+        const inbox = allInboxes[next.index];
+        cursors[inbox.serviceEndpoint] = next.result.value;
+        indexedIteratorNexts[next.index] = new Promise(() => {
+        });
+        active--;
+      } else {
+        indexedIteratorNexts[next.index] = indexedSingleEndpointQueryNext(
+          iterators[next.index],
+          next.index
+        );
+        const { object, tombstone, tags: receivedTags } = next.result.value;
+        if (tombstone) {
+          if (tombstones.get(object.url) === true) continue;
+          tombstones.set(object.url, true);
+          yield {
+            tombstone,
+            object: { url: object.url }
+          };
+        } else {
+          if (tombstones.get(object.url) === false) continue;
+          const matchedTagIndices = tags.reduce(
+            (acc, tag, tagIndex) => {
+              for (const receivedTag of receivedTags) {
+                if (tag.length === receivedTag.length && tag.every((b, i) => receivedTag[i] === b)) {
+                  acc.push(tagIndex);
+                  break;
+                }
+              }
+              return acc;
+            },
+            []
+          );
+          const matchedChannels = matchedTagIndices.map(
+            (index) => channels[index]
+          );
+          if (matchedChannels.length === 0) {
+            yield {
+              error: new Error(
+                "Inbox returned object without matching channels"
+              ),
+              origin: allInboxes[next.index].serviceEndpoint
+            };
+          }
+          tombstones.set(object.url, false);
+          yield {
+            object: {
+              ...object,
+              channels: matchedChannels
+            }
+          };
+        }
+      }
+    }
+    return {
+      cursor: JSON.stringify({
+        channels,
+        cursors
+      }),
+      continue: (session2) => this.discoverMeta(channels, schema, cursors, session2)
+    };
+  }
+  discover = (...args) => {
+    const [channels, schema, session] = args;
+    return this.discoverMeta(channels, schema, {}, session);
+  };
+  continueDiscover = (...args) => {
+    const [cursor, session] = args;
+    let channels;
+    let cursors;
+    try {
+      const json = JSON.parse(cursor);
+      const parsed = CursorSchema.parse(json);
+      channels = parsed.channels;
+      cursors = parsed.cursors;
+    } catch (error) {
+      return (async function* () {
+        throw new import_api.GraffitiErrorCursorExpired("Invalid cursor");
+      })();
+    }
+    return this.discoverMeta(channels, {}, cursors, session);
+  };
+  async announceObject(object, tags, allowedTickets, storageBucketKey, session, priorAnnouncements) {
+    const resolvedSession = this.sessions.resolveSession(session);
+    const metadataBase = {
+      [MESSAGE_DATA_STORAGE_BUCKET_KEY]: storageBucketKey
+    };
+    const announcements = [];
+    const allowed = object.allowed;
+    if (Array.isArray(allowed)) {
+      if (!allowedTickets || allowedTickets.length !== allowed.length) {
+        throw new Error(
+          "If allowed actors are specified, there must be a corresponding ticket for each allowed actor"
+        );
+      }
+      const results = await Promise.allSettled(
+        allowed.map(async (recipient, recipientIndex) => {
+          const copy = JSON.parse(JSON.stringify(object));
+          const masked = (0, import_api.maskGraffitiObject)(copy, [], recipient);
+          const actorDocument = await this.dids.resolve(recipient);
+          const personalInbox = actorDocument.service?.find(
+            (service) => service.type === import_sessions.DID_SERVICE_TYPE_GRAFFITI_INBOX && service.id === import_sessions.DID_SERVICE_ID_GRAFFITI_PERSONAL_INBOX
+          );
+          if (!personalInbox) {
+            throw new Error(
+              `Recipient ${recipient} does not have a personal inbox`
+            );
+          }
+          if (typeof personalInbox.serviceEndpoint !== "string") {
+            throw new Error(
+              `Recipient ${recipient} does not have a valid personal inbox endpoint`
+            );
+          }
+          const tombstonedMessageId2 = priorAnnouncements ? priorAnnouncements.find(
+            (a) => a[MESSAGE_DATA_ANNOUNCEMENT_ACTOR_KEY] === recipient
+          )?.[MESSAGE_DATA_ANNOUNCEMENT_MESSAGE_ID_KEY] : void 0;
+          const privateMetadata = {
+            ...metadataBase,
+            ...tombstonedMessageId2 ? {
+              [MESSAGE_DATA_TOMBSTONED_MESSAGE_ID_KEY]: tombstonedMessageId2
+            } : {},
+            [MESSAGE_DATA_ALLOWED_TICKET_KEY]: allowedTickets[recipientIndex],
+            [MESSAGE_DATA_ALLOWED_TICKET_INDEX_KEY]: recipientIndex
+          };
+          const messageId = await this.inboxes.send(
+            personalInbox.serviceEndpoint,
+            {
+              [import_inboxes.MESSAGE_TAGS_KEY]: tags,
+              [import_inboxes.MESSAGE_OBJECT_KEY]: masked,
+              [import_inboxes.MESSAGE_METADATA_KEY]: (0, import_dag_cbor.encode)(privateMetadata)
+            }
+          );
+          announcements.push({
+            [MESSAGE_DATA_ANNOUNCEMENT_MESSAGE_ID_KEY]: messageId,
+            [MESSAGE_DATA_ANNOUNCEMENT_ACTOR_KEY]: recipient
+          });
+        })
+      );
+      for (const [index, result] of results.entries()) {
+        if (result.status === "rejected") {
+          const recipient = allowed[index];
+          console.error("Error sending to recipient:", recipient);
+          console.error(result.reason);
+        }
+      }
+    } else {
+      const copy = JSON.parse(JSON.stringify(object));
+      const masked = (0, import_api.maskGraffitiObject)(copy, []);
+      const sharedInboxes = resolvedSession.sharedInboxes;
+      const results = await Promise.allSettled(
+        sharedInboxes.map(async (inbox) => {
+          const tombstonedMessageId2 = priorAnnouncements ? priorAnnouncements.find(
+            (a) => a[MESSAGE_DATA_ANNOUNCEMENT_ENDPOINT_KEY] === inbox.serviceEndpoint
+          )?.[MESSAGE_DATA_ANNOUNCEMENT_MESSAGE_ID_KEY] : void 0;
+          const metadata = {
+            ...metadataBase,
+            ...tombstonedMessageId2 ? {
+              [MESSAGE_DATA_TOMBSTONED_MESSAGE_ID_KEY]: tombstonedMessageId2
+            } : {}
+          };
+          const messageId = await this.inboxes.send(inbox.serviceEndpoint, {
+            ...tombstonedMessageId2 ? {
+              [MESSAGE_DATA_TOMBSTONED_MESSAGE_ID_KEY]: tombstonedMessageId2
+            } : {},
+            [import_inboxes.MESSAGE_TAGS_KEY]: tags,
+            [import_inboxes.MESSAGE_OBJECT_KEY]: masked,
+            [import_inboxes.MESSAGE_METADATA_KEY]: (0, import_dag_cbor.encode)(metadata)
+          });
+          announcements.push({
+            [MESSAGE_DATA_ANNOUNCEMENT_MESSAGE_ID_KEY]: messageId,
+            [MESSAGE_DATA_ANNOUNCEMENT_ENDPOINT_KEY]: inbox.serviceEndpoint
+          });
+        })
+      );
+      for (const [index, result] of results.entries()) {
+        if (result.status === "rejected") {
+          const inbox = sharedInboxes[index];
+          console.error("Error sending to inbox:", inbox);
+          console.error(result.reason);
+        }
+      }
+    }
+    const tombstonedMessageId = priorAnnouncements ? priorAnnouncements.find(
+      (a) => a[MESSAGE_DATA_ANNOUNCEMENT_ACTOR_KEY] === session.actor
+    )?.[MESSAGE_DATA_ANNOUNCEMENT_MESSAGE_ID_KEY] : void 0;
+    const selfMetadata = {
+      ...metadataBase,
+      ...allowedTickets ? {
+        [MESSAGE_DATA_ALLOWED_TICKETS_KEY]: allowedTickets
+      } : {},
+      ...tombstonedMessageId ? {
+        [MESSAGE_DATA_TOMBSTONED_MESSAGE_ID_KEY]: tombstonedMessageId
+      } : {},
+      [MESSAGE_DATA_ANNOUNCEMENTS_KEY]: announcements
+    };
+    await this.inboxes.send(resolvedSession.personalInbox.serviceEndpoint, {
+      [import_inboxes.MESSAGE_TAGS_KEY]: tags,
+      [import_inboxes.MESSAGE_OBJECT_KEY]: object,
+      [import_inboxes.MESSAGE_METADATA_KEY]: (0, import_dag_cbor.encode)(selfMetadata)
+    });
+  }
+  async *querySingleEndpoint(inboxEndpoint, queryArguments, inboxToken, recipient) {
+    const iterator = "tags" in queryArguments ? this.inboxes.query(
+      inboxEndpoint,
+      queryArguments.tags,
+      queryArguments.objectSchema,
+      inboxToken
+    ) : this.inboxes.continueQuery(
+      inboxEndpoint,
+      queryArguments.cursor,
+      inboxToken
+    );
+    while (true) {
+      const itResult = await iterator.next();
+      if (itResult.done) return itResult.value;
+      const result = itResult.value;
+      const label = result.l;
+      if (label !== MESSAGE_LABEL_VALID && label !== MESSAGE_LABEL_UNLABELED)
+        continue;
+      const messageId = result.id;
+      const { o: object, m: metadataBytes, t: receivedTags } = result.m;
+      let metadata;
+      try {
+        const metadataRaw = (0, import_dag_cbor.decode)(metadataBytes);
+        metadata = MessageMetadataSchema.parse(metadataRaw);
+      } catch (e) {
+        this.inboxes.label(
+          inboxEndpoint,
+          messageId,
+          MESSAGE_LABEL_INVALID,
+          inboxToken
+        );
+        continue;
+      }
+      const {
+        [MESSAGE_DATA_STORAGE_BUCKET_KEY]: storageBucketKey,
+        [MESSAGE_DATA_TOMBSTONED_MESSAGE_ID_KEY]: tombstonedMessageId
+      } = metadata;
+      const allowedTickets = MESSAGE_DATA_ALLOWED_TICKETS_KEY in metadata ? metadata[MESSAGE_DATA_ALLOWED_TICKETS_KEY] : void 0;
+      const announcements = MESSAGE_DATA_ANNOUNCEMENTS_KEY in metadata ? metadata[MESSAGE_DATA_ANNOUNCEMENTS_KEY] : void 0;
+      if (label === MESSAGE_LABEL_VALID) {
+        yield {
+          messageId,
+          object,
+          storageBucketKey,
+          allowedTickets,
+          tags: receivedTags,
+          announcements
+        };
+        continue;
+      }
+      let validationError = void 0;
+      try {
+        const actor = object.actor;
+        const actorDocument = await this.dids.resolve(actor);
+        const storageBucketService = actorDocument?.service?.find(
+          (service) => service.id === import_sessions.DID_SERVICE_ID_GRAFFITI_STORAGE_BUCKET && service.type === import_sessions.DID_SERVICE_TYPE_GRAFFITI_STORAGE_BUCKET
+        );
+        if (!storageBucketService) {
+          throw new import_api.GraffitiErrorNotFound(
+            `Actor ${actor} has no storage bucket service`
+          );
+        }
+        if (typeof storageBucketService.serviceEndpoint !== "string") {
+          throw new import_api.GraffitiErrorNotFound(
+            `Actor ${actor} does not have a valid storage bucket endpoint`
+          );
+        }
+        const storageBucketEndpoint = storageBucketService.serviceEndpoint;
+        const objectBytes = await this.storageBuckets.get(
+          storageBucketEndpoint,
+          storageBucketKey,
+          import_object_encoding.MAX_OBJECT_SIZE_BYTES
+        );
+        if (MESSAGE_DATA_ALLOWED_TICKET_KEY in metadata && !recipient) {
+          throw new import_api.GraffitiErrorForbidden(
+            `Recipient is required when allowed ticket is present`
+          );
+        }
+        const privateObjectInfo = allowedTickets ? { allowedTickets } : MESSAGE_DATA_ALLOWED_TICKET_KEY in metadata ? {
+          recipient: recipient ?? "null",
+          allowedTicket: metadata[MESSAGE_DATA_ALLOWED_TICKET_KEY],
+          allowedIndex: metadata[MESSAGE_DATA_ALLOWED_TICKET_INDEX_KEY]
+        } : void 0;
+        await this.objectEncoding.validate(
+          object,
+          receivedTags,
+          objectBytes,
+          privateObjectInfo
+        );
+      } catch (e) {
+        validationError = e;
+      }
+      if (tombstonedMessageId) {
+        if (validationError instanceof import_api.GraffitiErrorNotFound) {
+          this.inboxes.get(inboxEndpoint, tombstonedMessageId, inboxToken).then((result2) => {
+            if (result2 && result2[import_inboxes.LABELED_MESSAGE_MESSAGE_KEY][import_inboxes.MESSAGE_OBJECT_KEY].url === object.url) {
+              this.inboxes.label(
+                inboxEndpoint,
+                tombstonedMessageId,
+                MESSAGE_LABEL_TRASH,
+                inboxToken
+              );
+            }
+            this.inboxes.label(
+              inboxEndpoint,
+              messageId,
+              MESSAGE_LABEL_TRASH,
+              inboxToken
+            );
+          });
+          yield {
+            messageId,
+            tombstone: true,
+            object,
+            storageBucketKey,
+            allowedTickets,
+            tags: receivedTags,
+            announcements
+          };
+        } else {
+          console.error("Recieved an incorrect object");
+          console.error(validationError);
+          this.inboxes.label(
+            inboxEndpoint,
+            messageId,
+            MESSAGE_LABEL_INVALID,
+            inboxToken
+          );
+        }
+      } else {
+        if (validationError === void 0) {
+          this.inboxes.label(
+            inboxEndpoint,
+            messageId,
+            MESSAGE_LABEL_VALID,
+            inboxToken
+          );
+          yield {
+            messageId,
+            object,
+            storageBucketKey,
+            tags: receivedTags,
+            allowedTickets,
+            announcements
+          };
+        } else {
+          console.error("Recieved an incorrect object");
+          console.error(validationError);
+          this.inboxes.label(
+            inboxEndpoint,
+            messageId,
+            MESSAGE_LABEL_INVALID,
+            inboxToken
+          );
+        }
+      }
+    }
+  }
+}
+const MEDIA_OBJECT_SCHEMA = {
+  properties: {
+    value: {
+      properties: {
+        type: { type: "string" },
+        size: { type: "number" },
+        key: { type: "string" }
+      },
+      required: ["type", "size", "key"]
+    }
+  }
+};
+const CursorSchema = (0, import_mini.strictObject)({
+  cursors: (0, import_mini.record)((0, import_mini.url)(), (0, import_mini.string)()),
+  channels: (0, import_mini.array)((0, import_mini.string)())
+});
+async function indexedSingleEndpointQueryNext(it, index) {
+  try {
+    return {
+      index,
+      result: await it.next()
+    };
+  } catch (e) {
+    if (e instanceof import_api.GraffitiErrorCursorExpired || e instanceof import_api.GraffitiErrorInvalidSchema) {
+      throw e;
+    }
+    return {
+      index,
+      error: e instanceof Error ? e : new Error(String(e))
+    };
+  }
+}
+//# sourceMappingURL=4-graffiti.js.map