@powerhousedao/reactor-local 1.2.0

package/dist/chunk-VFTWNJCU.js

@@ -0,0 +1,3935 @@
+import { fileURLToPath } from 'url';
+import path2 from 'path';
+import { startAPI, setAdditionalContextFields, registerInternalListener, addSubgraph, createSchema } from '@powerhousedao/reactor-api';
+import * as DocumentDrive from 'document-model-libs/document-drive';
+import { isFileNode, utils as utils$1, actions, documentModel } from 'document-model-libs/document-drive';
+import { utils } from 'document-model/document';
+import { ClientError, gql, GraphQLClient } from 'graphql-request';
+import { createNanoEvents } from 'nanoevents';
+import { v4 } from 'uuid';
+import { pascalCase } from 'change-case';
+import { GraphQLError, buildSchema, GraphQLObjectType, GraphQLNonNull, GraphQLUnionType, GraphQLList, GraphQLScalarType } from 'graphql';
+import stringify from 'json-stringify-deterministic';
+import { readdirSync, existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import fs from 'fs/promises';
+import sanitize from 'sanitize-filename';
+import * as DocumentModelsLibs from 'document-model-libs/document-models';
+import { module } from 'document-model/document-model';
+import dotenv from 'dotenv';
+import { drizzle } from 'drizzle-orm/connect';
+import * as searchListener from '@powerhousedao/general-document-indexer';
+
+// ../../node_modules/.pnpm/tsup@8.3.0_@swc+core@1.5.29_postcss@8.4.47_typescript@5.6.3/node_modules/tsup/assets/esm_shims.js
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path2.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+// ../document-drive/src/cache/memory.ts
+var InMemoryCache = class {
+  cache = /* @__PURE__ */ new Map();
+  async setDocument(drive, id, document) {
+    const global2 = document.operations.global.map((e) => {
+      delete e.resultingState;
+      return e;
+    });
+    const local = document.operations.local.map((e) => {
+      delete e.resultingState;
+      return e;
+    });
+    const doc = { ...document, operations: { global: global2, local } };
+    if (!this.cache.has(drive)) {
+      this.cache.set(drive, /* @__PURE__ */ new Map());
+    }
+    this.cache.get(drive)?.set(id, doc);
+    return true;
+  }
+  async deleteDocument(drive, id) {
+    return this.cache.get(drive)?.delete(id) ?? false;
+  }
+  async getDocument(drive, id) {
+    return this.cache.get(drive)?.get(id);
+  }
+};
+var memory_default = InMemoryCache;
+
+// ../document-drive/src/server/error.ts
+var DocumentModelNotFoundError = class extends Error {
+  constructor(id, cause) {
+    super(`Document model "${id}" not found`, { cause });
+    this.id = id;
+  }
+};
+var OperationError = class extends Error {
+  status;
+  operation;
+  constructor(status, operation, message, cause) {
+    super(message, { cause: cause ?? operation });
+    this.status = status;
+    this.operation = operation;
+  }
+};
+var ConflictOperationError = class extends OperationError {
+  constructor(existingOperation, newOperation) {
+    super(
+      "CONFLICT",
+      newOperation,
+      `Conflicting operation on index ${newOperation.index}`,
+      { existingOperation, newOperation }
+    );
+  }
+};
+var DriveAlreadyExistsError = class extends Error {
+  driveId;
+  constructor(driveId) {
+    super(`Drive already exists. ID: ${driveId}`);
+    this.driveId = driveId;
+  }
+};
+var DriveNotFoundError = class extends Error {
+  driveId;
+  constructor(driveId) {
+    super(`Drive with id ${driveId} not found`);
+    this.driveId = driveId;
+  }
+};
+var SynchronizationUnitNotFoundError = class extends Error {
+  syncUnitId;
+  constructor(message, syncUnitId) {
+    super(message);
+    this.syncUnitId = syncUnitId;
+  }
+};
+
+// ../document-drive/src/utils/run-asap.ts
+var RunAsap;
+((RunAsap2) => {
+  RunAsap2.useMessageChannel = (() => {
+    if (typeof MessageChannel === "undefined") {
+      return new Error("MessageChannel is not supported");
+    }
+    return (task) => {
+      const controller = new AbortController();
+      const signal = controller.signal;
+      const mc = new MessageChannel();
+      mc.port1.postMessage(null);
+      mc.port2.addEventListener(
+        "message",
+        () => {
+          task();
+          mc.port1.close();
+          mc.port2.close();
+        },
+        { once: true, signal }
+      );
+      mc.port2.start();
+      return () => controller.abort();
+    };
+  })();
+  RunAsap2.usePostMessage = (() => {
+    const _main = (
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      typeof window === "object" && window || // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      typeof global === "object" && global || typeof self === "object" && self
+    );
+    if (!_main) {
+      return new Error("No global object found");
+    }
+    const main = _main;
+    if (
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      !main.postMessage || // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      !main.addEventListener || main.importScripts
+    ) {
+      return new Error("postMessage is not supported");
+    }
+    let index = 0;
+    const tasks = /* @__PURE__ */ new Map();
+    function getNewIndex() {
+      if (index === 9007199254740991) {
+        return 0;
+      }
+      return ++index;
+    }
+    const MESSAGE_PREFIX = "com.usePostMessage" + Math.random();
+    main.addEventListener(
+      "message",
+      (e) => {
+        const event = e;
+        if (typeof event.data !== "string") {
+          return;
+        }
+        if (event.source !== main || !event.data.startsWith(MESSAGE_PREFIX)) {
+          return;
+        }
+        const index2 = event.data.split(":").at(1);
+        if (index2 === void 0) {
+          return;
+        }
+        const i = +index2;
+        const task = tasks.get(i);
+        if (task) {
+          task();
+          tasks.delete(i);
+        }
+      },
+      false
+    );
+    return (task) => {
+      const i = getNewIndex();
+      tasks.set(i, task);
+      main.postMessage(MESSAGE_PREFIX + ":" + i, { targetOrigin: "*" });
+      return () => {
+        tasks.delete(i);
+      };
+    };
+  })();
+  RunAsap2.useSetImmediate = (() => {
+    if (typeof window !== "undefined") {
+      return new Error("setImmediate is not supported on the browser");
+    }
+    if (typeof setImmediate === "undefined") {
+      return new Error("setImmediate is not supported");
+    }
+    return (task) => {
+      const id = setImmediate(task);
+      return () => clearImmediate(id);
+    };
+  })();
+  RunAsap2.useSetTimeout = /* @__PURE__ */ (() => {
+    return (task) => {
+      const id = setTimeout(task, 0);
+      return () => clearTimeout(id);
+    };
+  })();
+  function runAsap2(task) {
+    if (!(RunAsap2.useSetImmediate instanceof Error)) {
+      return (0, RunAsap2.useSetImmediate)(task);
+    } else if (!(RunAsap2.useMessageChannel instanceof Error)) {
+      return (0, RunAsap2.useMessageChannel)(task);
+    } else if (!(RunAsap2.usePostMessage instanceof Error)) {
+      return (0, RunAsap2.usePostMessage)(task);
+    } else {
+      return (0, RunAsap2.useSetTimeout)(task);
+    }
+  }
+  RunAsap2.runAsap = runAsap2;
+  function runAsapAsync2(task, queueMethod = runAsap2) {
+    if (queueMethod instanceof Error) {
+      throw new Error("queueMethod is not supported", {
+        cause: queueMethod
+      });
+    }
+    return new Promise((resolve, reject) => {
+      queueMethod(() => {
+        task().then(resolve).catch(reject);
+      });
+    });
+  }
+  RunAsap2.runAsapAsync = runAsapAsync2;
+})(RunAsap || (RunAsap = {}));
+
+// ../document-drive/src/utils/index.ts
+var runAsap = RunAsap.runAsap;
+var runAsapAsync = RunAsap.runAsapAsync;
+function isDocumentDrive(document) {
+  return document.documentType === documentModel.id;
+}
+function mergeOperations(currentOperations, newOperations) {
+  const minIndexByScope = Object.keys(currentOperations).reduce((acc, curr) => {
+    const scope = curr;
+    acc[scope] = currentOperations[scope].at(-1)?.index ?? 0;
+    return acc;
+  }, {});
+  const conflictOp = newOperations.find(
+    (op) => op.index < (minIndexByScope[op.scope] ?? 0)
+  );
+  if (conflictOp) {
+    throw new OperationError(
+      "ERROR",
+      conflictOp,
+      `Tried to add operation with index ${conflictOp.index} and document is at index ${minIndexByScope[conflictOp.scope]}`
+    );
+  }
+  return newOperations.sort((a, b) => a.index - b.index).reduce((acc, curr) => {
+    const existingOperations = acc[curr.scope] || [];
+    return { ...acc, [curr.scope]: [...existingOperations, curr] };
+  }, currentOperations);
+}
+function generateUUID() {
+  return v4();
+}
+function isBefore(dateA, dateB) {
+  return new Date(dateA) < new Date(dateB);
+}
+
+// ../document-drive/src/utils/logger.ts
+var Logger = class {
+  #logger = console;
+  set logger(logger2) {
+    this.#logger = logger2;
+  }
+  log(...data) {
+    return this.#logger.log(...data);
+  }
+  info(...data) {
+    return this.#logger.info(...data);
+  }
+  warn(...data) {
+    return this.#logger.warn(...data);
+  }
+  error(...data) {
+    return this.#logger.error(...data);
+  }
+  debug(...data) {
+    return this.#logger.debug(...data);
+  }
+  trace(...data) {
+    return this.#logger.trace(...data);
+  }
+};
+var loggerInstance = new Logger();
+var logger = loggerInstance;
+
+// ../document-drive/src/queue/types.ts
+function isOperationJob(job) {
+  return "operations" in job;
+}
+function isActionJob(job) {
+  return "actions" in job;
+}
+
+// ../document-drive/src/queue/base.ts
+var MemoryQueue = class {
+  id;
+  blocked = false;
+  deleted = false;
+  items = [];
+  dependencies = new Array();
+  constructor(id) {
+    this.id = id;
+  }
+  async setDeleted(deleted) {
+    this.deleted = deleted;
+  }
+  async isDeleted() {
+    return this.deleted;
+  }
+  async addJob(data) {
+    this.items.push(data);
+    return Promise.resolve();
+  }
+  async getNextJob() {
+    const job = this.items.shift();
+    return Promise.resolve(job);
+  }
+  async amountOfJobs() {
+    return Promise.resolve(this.items.length);
+  }
+  getId() {
+    return this.id;
+  }
+  async setBlocked(blocked) {
+    this.blocked = blocked;
+  }
+  async isBlocked() {
+    return this.blocked;
+  }
+  async getJobs() {
+    return this.items;
+  }
+  async addDependencies(job) {
+    if (!this.dependencies.find((j) => j.jobId === job.jobId)) {
+      this.dependencies.push(job);
+    }
+    if (!this.isBlocked()) {
+      this.setBlocked(true);
+    }
+  }
+  async removeDependencies(job) {
+    this.dependencies = this.dependencies.filter(
+      (j) => j.jobId !== job.jobId && j.driveId !== job.driveId
+    );
+    if (this.dependencies.length === 0) {
+      await this.setBlocked(false);
+    }
+  }
+};
+var BaseQueueManager = class {
+  emitter = createNanoEvents();
+  ticker = 0;
+  queues = [];
+  workers;
+  timeout;
+  delegate;
+  constructor(workers = 3, timeout = 0) {
+    this.workers = workers;
+    this.timeout = timeout;
+  }
+  async init(delegate, onError) {
+    this.delegate = delegate;
+    for (let i = 0; i < this.workers; i++) {
+      setTimeout(
+        () => this.processNextJob.bind(this)().catch(onError),
+        100 * i
+      );
+    }
+    return Promise.resolve();
+  }
+  async addJob(job) {
+    if (!this.delegate) {
+      throw new Error("No server delegate defined");
+    }
+    const jobId = generateUUID();
+    const queue = this.getQueue(job.driveId, job.documentId);
+    if (await queue.isDeleted()) {
+      throw new Error("Queue is deleted");
+    }
+    const newDocument = job.documentId && !await this.delegate.checkDocumentExists(job.driveId, job.documentId);
+    if (newDocument && !await queue.isBlocked()) {
+      await queue.setBlocked(true);
+      const driveQueue = this.getQueue(job.driveId);
+      const jobs = await driveQueue.getJobs();
+      for (const driveJob of jobs) {
+        const actions3 = isOperationJob(driveJob) ? driveJob.operations : driveJob.actions;
+        const op = actions3.find((j) => {
+          const input = j.input;
+          return j.type === "ADD_FILE" && input.id === job.documentId;
+        });
+        if (op) {
+          await queue.addDependencies(driveJob);
+        }
+      }
+    }
+    const actions2 = isOperationJob(job) ? job.operations : job.actions;
+    const addFileOps = actions2.filter((j) => j.type === "ADD_FILE");
+    for (const addFileOp of addFileOps) {
+      const input = addFileOp.input;
+      const q = this.getQueue(job.driveId, input.id);
+      await q.addDependencies({ jobId, ...job });
+    }
+    const removeFileOps = actions2.filter(
+      (j) => j.type === "DELETE_NODE"
+    );
+    for (const removeFileOp of removeFileOps) {
+      const input = removeFileOp.input;
+      const queue2 = this.getQueue(job.driveId, input.id);
+      await queue2.setDeleted(true);
+    }
+    await queue.addJob({ jobId, ...job });
+    return jobId;
+  }
+  getQueue(driveId, documentId) {
+    const queueId = this.getQueueId(driveId, documentId);
+    let queue = this.queues.find((q) => q.getId() === queueId);
+    if (!queue) {
+      queue = new MemoryQueue(queueId);
+      this.queues.push(queue);
+    }
+    return queue;
+  }
+  removeQueue(driveId, documentId) {
+    const queueId = this.getQueueId(driveId, documentId);
+    this.queues = this.queues.filter((q) => q.getId() !== queueId);
+    this.emit("queueRemoved", queueId);
+  }
+  getQueueByIndex(index) {
+    const queue = this.queues[index];
+    if (queue) {
+      return queue;
+    }
+    return null;
+  }
+  getQueues() {
+    return this.queues.map((q) => q.getId());
+  }
+  retryNextJob(timeout) {
+    const _timeout = timeout !== void 0 ? timeout : this.timeout;
+    const retry = _timeout > 0 ? (fn) => setTimeout(fn, _timeout) : runAsap;
+    retry(() => this.processNextJob());
+  }
+  async findFirstNonEmptyQueue(ticker) {
+    const numQueues = this.queues.length;
+    for (let i = 0; i < numQueues; i++) {
+      const index = (ticker + i) % numQueues;
+      const queue = this.queues[index];
+      if (queue && await queue.amountOfJobs() > 0) {
+        return index;
+      }
+    }
+    return null;
+  }
+  async processNextJob() {
+    if (!this.delegate) {
+      throw new Error("No server delegate defined");
+    }
+    if (this.queues.length === 0) {
+      this.retryNextJob();
+      return;
+    }
+    const queue = this.queues[this.ticker];
+    if (!queue) {
+      this.ticker = 0;
+      this.retryNextJob();
+      return;
+    }
+    const amountOfJobs = await queue.amountOfJobs();
+    if (amountOfJobs === 0) {
+      const nextTicker = await this.findFirstNonEmptyQueue(this.ticker);
+      if (nextTicker !== null) {
+        this.ticker = nextTicker;
+        this.retryNextJob(0);
+      } else {
+        this.retryNextJob();
+      }
+      return;
+    }
+    this.ticker = this.ticker === this.queues.length - 1 ? 0 : this.ticker + 1;
+    const isBlocked = await queue.isBlocked();
+    if (isBlocked) {
+      this.retryNextJob();
+      return;
+    }
+    await queue.setBlocked(true);
+    const nextJob = await queue.getNextJob();
+    if (!nextJob) {
+      this.retryNextJob();
+      return;
+    }
+    try {
+      const result = await this.delegate.processJob(nextJob);
+      const actions2 = isOperationJob(nextJob) ? nextJob.operations : nextJob.actions;
+      const addFileActions = actions2.filter((op) => op.type === "ADD_FILE");
+      if (addFileActions.length > 0) {
+        for (const addFile of addFileActions) {
+          const documentQueue = this.getQueue(
+            nextJob.driveId,
+            addFile.input.id
+          );
+          await documentQueue.removeDependencies(nextJob);
+        }
+      }
+      this.emit("jobCompleted", nextJob, result);
+    } catch (e) {
+      logger.error(`job failed`, e);
+      this.emit("jobFailed", nextJob, e);
+    } finally {
+      await queue.setBlocked(false);
+      this.retryNextJob(0);
+    }
+  }
+  emit(event, ...args) {
+    this.emitter.emit(event, ...args);
+  }
+  on(event, cb) {
+    return this.emitter.on(event, cb);
+  }
+  getQueueId(driveId, documentId) {
+    return `queue:${driveId}${documentId ? `:${documentId}` : ""}`;
+  }
+};
+async function requestGraphql(...args) {
+  const [url, ...requestArgs] = args;
+  const client = new GraphQLClient(url, { fetch });
+  const { errors, ...response } = await client.request(...requestArgs);
+  const result = { ...response };
+  if (errors?.length) {
+    result.errors = errors.map(
+      ({ message, ...options2 }) => new GraphQLError(message, options2)
+    );
+  }
+  return result;
+}
+function getFields(type) {
+  if (type instanceof GraphQLObjectType) {
+    return Object.entries(type.getFields()).map(([fieldName, field]) => {
+      const fieldType = field.type instanceof GraphQLNonNull ? field.type.ofType : field.type;
+      if (fieldType instanceof GraphQLObjectType || fieldType instanceof GraphQLUnionType) {
+        return `${fieldName} { ${getFields(fieldType)} }`;
+      }
+      if (fieldType instanceof GraphQLList) {
+        const listItemType = fieldType.ofType instanceof GraphQLNonNull ? fieldType.ofType.ofType : fieldType.ofType;
+        if (listItemType instanceof GraphQLScalarType) {
+          return fieldName;
+        } else if (listItemType instanceof GraphQLObjectType || listItemType instanceof GraphQLUnionType) {
+          return `${fieldName} { ${getFields(listItemType)} }`;
+        } else {
+          throw new Error(
+            `List item type ${listItemType.toString()} is not handled`
+          );
+        }
+      }
+      return fieldName;
+    }).join(" ");
+  } else if (type instanceof GraphQLUnionType) {
+    return type.getTypes().map((unionType) => {
+      return `... on ${unionType.name} { ${getFields(unionType)} }`;
+    }).join(" ");
+  }
+  return "";
+}
+function generateDocumentStateQueryFields(documentModel2, options2) {
+  const name = pascalCase(documentModel2.name);
+  const spec = documentModel2.specifications.at(-1);
+  if (!spec) {
+    throw new Error("No document model specification found");
+  }
+  const source = `${spec.state.global.schema} type Query { ${name}: ${name}State }`;
+  const schema = buildSchema(source, options2);
+  const queryType = schema.getQueryType();
+  if (!queryType) {
+    throw new Error("No query type found");
+  }
+  const fields = queryType.getFields();
+  const stateQuery = fields[name];
+  if (!stateQuery) {
+    throw new Error("No state query found");
+  }
+  const queryFields = getFields(stateQuery.type);
+  return queryFields;
+}
+async function requestPublicDrive(url) {
+  let drive;
+  try {
+    const result = await requestGraphql(
+      url,
+      gql`
+        query getDrive {
+          drive {
+            id
+            name
+            icon
+            slug
+          }
+        }
+      `
+    );
+    if (result.errors?.length || !result.drive) {
+      throw result.errors?.at(0) ?? new Error("Drive not found");
+    }
+    drive = result.drive;
+  } catch (e) {
+    logger.error(e);
+    throw new Error("Couldn't find drive info");
+  }
+  return drive;
+}
+async function fetchDocument(url, documentId, documentModelLib) {
+  const { documentModel: documentModel2, utils: utils3 } = documentModelLib;
+  const stateFields = generateDocumentStateQueryFields(documentModel2);
+  const name = pascalCase(documentModel2.name);
+  const result = await requestGraphql(
+    url,
+    gql`
+            query ($id: String!) {
+                document(id: $id) {
+                    id
+                    name
+                    created
+                    documentType
+                    lastModified
+                    revision
+                    operations {
+                        id
+                        error
+                        hash
+                        index
+                        skip
+                        timestamp
+                        type
+                        inputText
+                        context {
+                            signer {
+                                user {
+                                    address
+                                    networkId
+                                    chainId
+                                }
+                                app {
+                                    name
+                                    key
+                                }
+                                signatures
+                            }
+                        }
+                    }
+                    ... on ${name} {
+                        state {
+                            ${stateFields}
+                        }
+                        initialState {
+                            ${stateFields}
+                        }
+                    }
+                }
+            }
+        `,
+    { id: documentId }
+  );
+  const document = result.document ? {
+    ...result.document,
+    revision: {
+      global: result.document.revision,
+      local: 0
+    },
+    state: utils3.createState({ global: result.document.state }),
+    operations: {
+      global: result.document.operations.map(({ inputText, ...o }) => ({
+        ...o,
+        error: o.error ?? void 0,
+        scope: "global",
+        input: JSON.parse(inputText)
+      })),
+      local: []
+    },
+    attachments: {},
+    initialState: utils3.createExtendedState({
+      // TODO: getDocument should return all the initial state fields
+      created: result.document.created,
+      lastModified: result.document.created,
+      state: utils3.createState({
+        global: result.document.initialState
+      })
+    }),
+    clipboard: []
+  } : null;
+  return {
+    ...result,
+    document
+  };
+}
+
+// ../document-drive/src/read-mode/errors.ts
+var ReadDriveError = class extends Error {
+};
+var ReadDriveNotFoundError = class extends ReadDriveError {
+  constructor(driveId) {
+    super(`Read drive ${driveId} not found.`);
+  }
+};
+var ReadDriveSlugNotFoundError = class extends ReadDriveError {
+  constructor(slug) {
+    super(`Read drive with slug ${slug} not found.`);
+  }
+};
+var ReadDocumentNotFoundError = class extends ReadDriveError {
+  constructor(drive, id) {
+    super(`Document with id ${id} not found on read drive ${drive}.`);
+  }
+};
+
+// ../document-drive/src/read-mode/service.ts
+var ReadModeService = class {
+  #getDocumentModel;
+  #drives = /* @__PURE__ */ new Map();
+  constructor(getDocumentModel) {
+    this.#getDocumentModel = getDocumentModel;
+  }
+  #parseGraphQLErrors(errors, driveId, documentId) {
+    for (const error of errors) {
+      if (error.message === `Drive with id ${driveId} not found`) {
+        return new ReadDriveNotFoundError(driveId);
+      } else if (documentId && error.message === `Document with id ${documentId} not found`) {
+        return new ReadDocumentNotFoundError(driveId, documentId);
+      }
+    }
+    const firstError = errors.at(0);
+    if (firstError) {
+      return firstError;
+    }
+  }
+  async #fetchDrive(id, url) {
+    const { errors, document } = await fetchDocument(
+      url,
+      id,
+      DocumentDrive
+    );
+    const error = errors ? this.#parseGraphQLErrors(errors, id) : void 0;
+    return error || document;
+  }
+  async fetchDrive(id) {
+    const drive = this.#drives.get(id);
+    if (!drive) {
+      return new ReadDriveNotFoundError(id);
+    }
+    const document = await this.fetchDocument(
+      id,
+      id,
+      DocumentDrive.documentModel.id
+    );
+    if (document instanceof Error) {
+      return document;
+    }
+    const result = { ...document, readContext: drive.context };
+    drive.drive = result;
+    return result;
+  }
+  async fetchDocument(driveId, documentId, documentType) {
+    const drive = this.#drives.get(driveId);
+    if (!drive) {
+      return new ReadDriveNotFoundError(driveId);
+    }
+    let documentModel2 = void 0;
+    try {
+      documentModel2 = this.#getDocumentModel(
+        documentType
+      );
+    } catch (error) {
+      return new DocumentModelNotFoundError(documentType, error);
+    }
+    const { url } = drive.context;
+    const { errors, document } = await fetchDocument(
+      url,
+      documentId,
+      documentModel2
+    );
+    if (errors) {
+      const error = this.#parseGraphQLErrors(errors, driveId, documentId);
+      if (error instanceof ReadDriveError) {
+        return error;
+      } else if (error) {
+        throw error;
+      }
+    }
+    if (!document) {
+      return new ReadDocumentNotFoundError(driveId, documentId);
+    }
+    return document;
+  }
+  async addReadDrive(url, options2) {
+    const { id } = options2?.expectedDriveInfo ?? await requestPublicDrive(url);
+    const result = await this.#fetchDrive(id, url);
+    if (result instanceof Error) {
+      throw result;
+    } else if (!result) {
+      throw new Error(`Drive "${id}" not found at ${url}`);
+    }
+    this.#drives.set(id, {
+      drive: result,
+      context: {
+        ...options2,
+        url
+      }
+    });
+  }
+  async getReadDrives() {
+    return Promise.resolve([...this.#drives.keys()]);
+  }
+  async getReadDrive(id) {
+    const result = this.#drives.get(id);
+    return Promise.resolve(
+      result ? { ...result.drive, readContext: result.context } : new ReadDriveNotFoundError(id)
+    );
+  }
+  async getReadDriveBySlug(slug) {
+    const readDrive = [...this.#drives.values()].find(
+      ({ drive }) => drive.state.global.slug === slug
+    );
+    return Promise.resolve(
+      readDrive ? { ...readDrive.drive, readContext: readDrive.context } : new ReadDriveSlugNotFoundError(slug)
+    );
+  }
+  getReadDriveContext(id) {
+    return Promise.resolve(
+      this.#drives.get(id)?.context ?? new ReadDriveNotFoundError(id)
+    );
+  }
+  deleteReadDrive(id) {
+    const deleted = this.#drives.delete(id);
+    return Promise.resolve(
+      deleted ? void 0 : new ReadDriveNotFoundError(id)
+    );
+  }
+};
+
+// ../document-drive/src/read-mode/index.ts
+function ReadModeServer(Base) {
+  return class ReadMode extends Base {
+    #readModeStorage;
+    #listeners = /* @__PURE__ */ new Set();
+    constructor(...args) {
+      super(...args);
+      this.#readModeStorage = new ReadModeService(
+        this.getDocumentModel.bind(this)
+      );
+      this.#buildDrives().then((drives) => {
+        if (drives.length) {
+          this.#notifyListeners(drives, "add");
+        }
+      }).catch(logger.error);
+    }
+    async #buildDrives() {
+      const driveIds = await this.getReadDrives();
+      const drives = (await Promise.all(driveIds.map((driveId) => this.getReadDrive(driveId)))).filter((drive) => !(drive instanceof Error));
+      return drives;
+    }
+    #notifyListeners(drives, operation) {
+      this.#listeners.forEach((listener) => listener(drives, operation));
+    }
+    getReadDrives() {
+      return this.#readModeStorage.getReadDrives();
+    }
+    getReadDrive(id) {
+      return this.#readModeStorage.getReadDrive(id);
+    }
+    getReadDriveBySlug(slug) {
+      return this.#readModeStorage.getReadDriveBySlug(slug);
+    }
+    getReadDriveContext(id) {
+      return this.#readModeStorage.getReadDriveContext(id);
+    }
+    async addReadDrive(url, options2) {
+      await this.#readModeStorage.addReadDrive(url, options2);
+      this.#notifyListeners(await this.#buildDrives(), "add");
+    }
+    fetchDrive(id) {
+      return this.#readModeStorage.fetchDrive(id);
+    }
+    fetchDocument(driveId, documentId, documentType) {
+      return this.#readModeStorage.fetchDocument(
+        driveId,
+        documentId,
+        documentType
+      );
+    }
+    async deleteReadDrive(id) {
+      const error = await this.#readModeStorage.deleteReadDrive(id);
+      if (error) {
+        return error;
+      }
+      this.#notifyListeners(await this.#buildDrives(), "delete");
+    }
+    async migrateReadDrive(id, options2) {
+      const result = await this.getReadDriveContext(id);
+      if (result instanceof Error) {
+        return result;
+      }
+      const { url, ...readOptions } = result;
+      try {
+        const newDrive = await this.addRemoteDrive(url, options2);
+        return newDrive;
+      } catch (error) {
+        logger.error(error);
+        await this.addReadDrive(result.url, readOptions);
+        throw error;
+      }
+    }
+    onReadDrivesUpdate(listener) {
+      this.#listeners.add(listener);
+      return Promise.resolve(() => this.#listeners.delete(listener));
+    }
+  };
+}
+
+// ../document-drive/src/storage/memory.ts
+var MemoryStorage = class {
+  documents;
+  drives;
+  slugToDriveId = {};
+  constructor() {
+    this.documents = {};
+    this.drives = {};
+  }
+  checkDocumentExists(drive, id) {
+    return Promise.resolve(this.documents[drive]?.[id] !== void 0);
+  }
+  async getDocuments(drive) {
+    return Object.keys(this.documents[drive] ?? {});
+  }
+  async getDocument(driveId, id) {
+    const drive = this.documents[driveId];
+    if (!drive) {
+      throw new DriveNotFoundError(driveId);
+    }
+    const document = drive[id];
+    if (!document) {
+      throw new Error(`Document with id ${id} not found`);
+    }
+    return document;
+  }
+  async saveDocument(drive, id, document) {
+    this.documents[drive] = this.documents[drive] ?? {};
+    this.documents[drive][id] = document;
+  }
+  async clearStorage() {
+    this.documents = {};
+    this.drives = {};
+  }
+  async createDocument(drive, id, document) {
+    this.documents[drive] = this.documents[drive] ?? {};
+    const {
+      operations,
+      initialState,
+      name,
+      revision,
+      documentType,
+      created,
+      lastModified,
+      clipboard,
+      state
+    } = document;
+    this.documents[drive][id] = {
+      operations,
+      initialState,
+      name,
+      revision,
+      documentType,
+      created,
+      lastModified,
+      clipboard,
+      state
+    };
+  }
+  async addDocumentOperations(drive, id, operations, header) {
+    const document = await this.getDocument(drive, id);
+    if (!document) {
+      throw new Error(`Document with id ${id} not found`);
+    }
+    const mergedOperations = mergeOperations(document.operations, operations);
+    this.documents[drive][id] = {
+      ...document,
+      ...header,
+      operations: mergedOperations
+    };
+  }
+  async deleteDocument(drive, id) {
+    if (!this.documents[drive]) {
+      throw new DriveNotFoundError(drive);
+    }
+    delete this.documents[drive][id];
+  }
+  async getDrives() {
+    return Object.keys(this.drives);
+  }
+  async getDrive(id) {
+    const drive = this.drives[id];
+    if (!drive) {
+      throw new DriveNotFoundError(id);
+    }
+    return drive;
+  }
+  async getDriveBySlug(slug) {
+    const driveId = this.slugToDriveId[slug];
+    if (!driveId) {
+      throw new Error(`Drive with slug ${slug} not found`);
+    }
+    return this.getDrive(driveId);
+  }
+  async createDrive(id, drive) {
+    this.drives[id] = drive;
+    this.documents[id] = {};
+    const { slug } = drive.initialState.state.global;
+    if (slug) {
+      this.slugToDriveId[slug] = id;
+    }
+  }
+  async addDriveOperations(id, operations, header) {
+    const drive = await this.getDrive(id);
+    const mergedOperations = mergeOperations(drive.operations, operations);
+    this.drives[id] = {
+      ...drive,
+      ...header,
+      operations: mergedOperations
+    };
+  }
+  async deleteDrive(id) {
+    delete this.documents[id];
+    delete this.drives[id];
+  }
+  async getSynchronizationUnitsRevision(units) {
+    const results = await Promise.allSettled(
+      units.map(async (unit) => {
+        try {
+          const document = await (unit.documentId ? this.getDocument(unit.driveId, unit.documentId) : this.getDrive(unit.driveId));
+          if (!document) {
+            return void 0;
+          }
+          const operation = document.operations[unit.scope].at(-1);
+          if (operation) {
+            return {
+              driveId: unit.driveId,
+              documentId: unit.documentId,
+              scope: unit.scope,
+              branch: unit.branch,
+              lastUpdated: operation.timestamp,
+              revision: operation.index
+            };
+          }
+        } catch {
+          return void 0;
+        }
+      })
+    );
+    return results.reduce((acc, curr) => {
+      if (curr.status === "fulfilled" && curr.value !== void 0) {
+        acc.push(curr.value);
+      }
+      return acc;
+    }, []);
+  }
+};
+
+// ../document-drive/src/utils/default-drives-manager.ts
+function isReadModeDriveServer(obj) {
+  return typeof obj.getReadDrives === "function";
+}
+var DefaultDrivesManager = class {
+  constructor(server, delegate, options2) {
+    this.server = server;
+    this.delegate = delegate;
+    if (options2?.defaultDrives.remoteDrives) {
+      for (const defaultDrive of options2.defaultDrives.remoteDrives) {
+        this.defaultRemoteDrives.set(defaultDrive.url, {
+          ...defaultDrive,
+          status: "PENDING"
+        });
+      }
+    }
+    this.removeOldRemoteDrivesConfig = options2?.defaultDrives.removeOldRemoteDrives || {
+      strategy: "preserve-all"
+    };
+  }
+  defaultRemoteDrives = /* @__PURE__ */ new Map();
+  removeOldRemoteDrivesConfig;
+  getDefaultRemoteDrives() {
+    return new Map(
+      JSON.parse(
+        JSON.stringify(Array.from(this.defaultRemoteDrives))
+      )
+    );
+  }
+  async deleteDriveById(driveId) {
+    try {
+      await this.server.deleteDrive(driveId);
+    } catch (error) {
+      if (!(error instanceof DriveNotFoundError)) {
+        logger.error(error);
+      }
+    }
+  }
+  async preserveDrivesById(driveIdsToPreserve, drives, removeStrategy = "detach") {
+    const getAllDrives = drives.map((driveId) => this.server.getDrive(driveId));
+    const drivesToRemove = (await Promise.all(getAllDrives)).filter(
+      (drive) => drive.state.local.listeners.length > 0 || drive.state.local.triggers.length > 0
+    ).filter((drive) => !driveIdsToPreserve.includes(drive.state.global.id));
+    const driveIds = drivesToRemove.map((drive) => drive.state.global.id);
+    if (removeStrategy === "detach") {
+      await this.detachDrivesById(driveIds);
+    } else {
+      await this.removeDrivesById(driveIds);
+    }
+  }
+  async removeDrivesById(driveIds) {
+    for (const driveId of driveIds) {
+      await this.deleteDriveById(driveId);
+    }
+  }
+  async detachDrivesById(driveIds) {
+    const detachDrivesPromises = driveIds.map(
+      (driveId) => this.delegate.detachDrive(driveId)
+    );
+    await Promise.all(detachDrivesPromises);
+  }
+  async removeOldremoteDrives() {
+    const driveids = await this.server.getDrives();
+    switch (this.removeOldRemoteDrivesConfig.strategy) {
+      case "preserve-by-id-and-detach":
+      case "preserve-by-id": {
+        const detach = this.removeOldRemoteDrivesConfig.strategy === "preserve-by-id-and-detach" ? "detach" : "remove";
+        await this.preserveDrivesById(
+          this.removeOldRemoteDrivesConfig.ids,
+          driveids,
+          detach
+        );
+        break;
+      }
+      case "preserve-by-url-and-detach":
+      case "preserve-by-url": {
+        const detach = this.removeOldRemoteDrivesConfig.strategy === "preserve-by-url-and-detach" ? "detach" : "remove";
+        const getDrivesInfo = this.removeOldRemoteDrivesConfig.urls.map(
+          (url) => requestPublicDrive(url)
+        );
+        const drivesIdsToPreserve = (await Promise.all(getDrivesInfo)).map(
+          (driveInfo) => driveInfo.id
+        );
+        await this.preserveDrivesById(drivesIdsToPreserve, driveids, detach);
+        break;
+      }
+      case "remove-by-id": {
+        const drivesIdsToRemove = this.removeOldRemoteDrivesConfig.ids.filter(
+          (driveId) => driveids.includes(driveId)
+        );
+        await this.removeDrivesById(drivesIdsToRemove);
+        break;
+      }
+      case "remove-by-url": {
+        const getDrivesInfo = this.removeOldRemoteDrivesConfig.urls.map(
+          (driveUrl) => requestPublicDrive(driveUrl)
+        );
+        const drivesInfo = await Promise.all(getDrivesInfo);
+        const drivesIdsToRemove = drivesInfo.map((driveInfo) => driveInfo.id).filter((driveId) => driveids.includes(driveId));
+        await this.removeDrivesById(drivesIdsToRemove);
+        break;
+      }
+      case "remove-all": {
+        const getDrives = driveids.map(
+          (driveId) => this.server.getDrive(driveId)
+        );
+        const drives = await Promise.all(getDrives);
+        const drivesToRemove = drives.filter(
+          (drive) => drive.state.local.listeners.length > 0 || drive.state.local.triggers.length > 0
+        ).map((drive) => drive.state.global.id);
+        await this.removeDrivesById(drivesToRemove);
+        break;
+      }
+      case "detach-by-id": {
+        const drivesIdsToRemove = this.removeOldRemoteDrivesConfig.ids.filter(
+          (driveId) => driveids.includes(driveId)
+        );
+        const detachDrivesPromises = drivesIdsToRemove.map(
+          (driveId) => this.delegate.detachDrive(driveId)
+        );
+        await Promise.all(detachDrivesPromises);
+        break;
+      }
+      case "detach-by-url": {
+        const getDrivesInfo = this.removeOldRemoteDrivesConfig.urls.map(
+          (driveUrl) => requestPublicDrive(driveUrl)
+        );
+        const drivesInfo = await Promise.all(getDrivesInfo);
+        const drivesIdsToRemove = drivesInfo.map((driveInfo) => driveInfo.id).filter((driveId) => driveids.includes(driveId));
+        const detachDrivesPromises = drivesIdsToRemove.map(
+          (driveId) => this.delegate.detachDrive(driveId)
+        );
+        await Promise.all(detachDrivesPromises);
+        break;
+      }
+    }
+  }
+  async setAllDefaultDrivesAccessLevel(level) {
+    const drives = this.defaultRemoteDrives.values();
+    for (const drive of drives) {
+      await this.setDefaultDriveAccessLevel(drive.url, level);
+    }
+  }
+  async setDefaultDriveAccessLevel(url, level) {
+    const drive = this.defaultRemoteDrives.get(url);
+    if (drive && drive.options.accessLevel !== level) {
+      const newDriveValue = {
+        ...drive,
+        options: { ...drive.options, accessLevel: level }
+      };
+      this.defaultRemoteDrives.set(url, newDriveValue);
+      await this.initializeDefaultRemoteDrives([newDriveValue]);
+    }
+  }
+  async initializeDefaultRemoteDrives(defaultDrives = Array.from(
+    this.defaultRemoteDrives.values()
+  )) {
+    const drives = await this.server.getDrives();
+    const readServer = isReadModeDriveServer(this.server) ? this.server : void 0;
+    const readDrives = await readServer?.getReadDrives();
+    for (const remoteDrive of defaultDrives) {
+      let remoteDriveInfo = { ...remoteDrive };
+      try {
+        const driveInfo = remoteDrive.metadata ?? await requestPublicDrive(remoteDrive.url);
+        remoteDriveInfo = { ...remoteDrive, metadata: driveInfo };
+        this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
+        const driveIsAdded = drives.includes(driveInfo.id);
+        const readDriveIsAdded = readDrives?.includes(driveInfo.id);
+        const hasAccessLevel = remoteDrive.options.accessLevel !== void 0;
+        const readMode = readServer && remoteDrive.options.accessLevel === "READ";
+        const isAdded = readMode ? readDriveIsAdded : driveIsAdded;
+        const driveToDelete = hasAccessLevel && (readMode ? driveIsAdded : readDriveIsAdded);
+        if (driveToDelete) {
+          try {
+            await (readMode ? this.server.deleteDrive(driveInfo.id) : readServer?.deleteReadDrive(driveInfo.id));
+          } catch (e) {
+            logger.error(e);
+          }
+        }
+        if (isAdded) {
+          remoteDriveInfo.status = "ALREADY_ADDED";
+          this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
+          this.delegate.emit(
+            "ALREADY_ADDED",
+            this.defaultRemoteDrives,
+            remoteDriveInfo,
+            driveInfo.id,
+            driveInfo.name
+          );
+          continue;
+        }
+        remoteDriveInfo.status = "ADDING";
+        this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
+        this.delegate.emit("ADDING", this.defaultRemoteDrives, remoteDriveInfo);
+        if (!hasAccessLevel && readServer || readMode) {
+          await readServer.addReadDrive(remoteDrive.url, {
+            ...remoteDrive.options,
+            expectedDriveInfo: driveInfo
+          });
+        } else {
+          await this.server.addRemoteDrive(remoteDrive.url, {
+            ...remoteDrive.options,
+            expectedDriveInfo: driveInfo
+          });
+        }
+        remoteDriveInfo.status = "SUCCESS";
+        this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
+        this.delegate.emit(
+          "SUCCESS",
+          this.defaultRemoteDrives,
+          remoteDriveInfo,
+          driveInfo.id,
+          driveInfo.name
+        );
+      } catch (error) {
+        remoteDriveInfo.status = "ERROR";
+        this.defaultRemoteDrives.set(remoteDrive.url, remoteDriveInfo);
+        this.delegate.emit(
+          "ERROR",
+          this.defaultRemoteDrives,
+          remoteDriveInfo,
+          void 0,
+          void 0,
+          error
+        );
+      }
+    }
+  }
+};
+var {
+  attachBranch,
+  garbageCollect,
+  groupOperationsByScope,
+  merge,
+  split,
+  precedes,
+  removeExistingOperations,
+  reshuffleByTimestamp,
+  sortOperations,
+  addUndo,
+  checkOperationsIntegrity,
+  checkCleanedOperationsIntegrity,
+  reshuffleByTimestampAndIndex,
+  nextSkipNumber,
+  prepareOperations,
+  IntegrityIssueSubType,
+  IntegrityIssueType
+} = utils.documentHelpers;
+
+// ../document-drive/src/server/types.ts
+var AbstractDocumentDriveServer = class {
+};
+var DefaultListenerManagerOptions = {
+  sequentialUpdates: true
+};
+var BaseListenerManager = class {
+  drive;
+  listenerState = /* @__PURE__ */ new Map();
+  options;
+  transmitters = {};
+  constructor(drive, listenerState = /* @__PURE__ */ new Map(), options2 = DefaultListenerManagerOptions) {
+    this.drive = drive;
+    this.listenerState = listenerState;
+    this.options = { ...DefaultListenerManagerOptions, ...options2 };
+  }
+};
+
+// ../document-drive/src/server/utils.ts
+function buildRevisionsFilter(strands, driveId, documentId) {
+  return strands.reduce((acc, s) => {
+    if (!(s.driveId === driveId && s.documentId === documentId)) {
+      return acc;
+    }
+    acc[s.scope] = s.operations[s.operations.length - 1]?.index ?? -1;
+    return acc;
+  }, {});
+}
+function filterOperationsByRevision(operations, revisions) {
+  if (!revisions) {
+    return operations;
+  }
+  return Object.keys(operations).reduce((acc, scope) => {
+    const revision = revisions[scope];
+    if (revision !== void 0) {
+      acc[scope] = operations[scope].filter((op) => op.index <= revision);
+    }
+    return acc;
+  }, operations);
+}
+
+// ../document-drive/src/server/listener/transmitter/internal.ts
+var InternalTransmitter = class {
+  drive;
+  listener;
+  receiver;
+  constructor(listener, drive) {
+    this.listener = listener;
+    this.drive = drive;
+  }
+  async transmit(strands) {
+    if (!this.receiver) {
+      return [];
+    }
+    const retrievedDocuments = /* @__PURE__ */ new Map();
+    const updates = [];
+    for (const strand of strands) {
+      let document = retrievedDocuments.get(
+        `${strand.driveId}:${strand.documentId}`
+      );
+      if (!document) {
+        const revisions = buildRevisionsFilter(
+          strands,
+          strand.driveId,
+          strand.documentId
+        );
+        document = await (strand.documentId ? this.drive.getDocument(strand.driveId, strand.documentId, {
+          revisions
+        }) : this.drive.getDrive(strand.driveId, { revisions }));
+        retrievedDocuments.set(
+          `${strand.driveId}:${strand.documentId}`,
+          document
+        );
+      }
+      updates.push({ ...strand, state: document.state[strand.scope] });
+    }
+    try {
+      await this.receiver.transmit(updates);
+      return strands.map(({ operations, ...s }) => ({
+        ...s,
+        status: "SUCCESS",
+        revision: operations[operations.length - 1]?.index ?? -1
+      }));
+    } catch (error) {
+      logger.error(error);
+      return strands.map(({ operations, ...s }) => ({
+        ...s,
+        status: "ERROR",
+        revision: (operations[0]?.index ?? 0) - 1
+      }));
+    }
+  }
+  setReceiver(receiver) {
+    this.receiver = receiver;
+  }
+  async disconnect() {
+    await this.receiver?.disconnect();
+  }
+};
+
+// ../document-drive/src/server/listener/transmitter/pull-responder.ts
+var PullResponderTransmitter = class _PullResponderTransmitter {
+  drive;
+  listener;
+  manager;
+  constructor(listener, drive, manager) {
+    this.listener = listener;
+    this.drive = drive;
+    this.manager = manager;
+  }
+  getStrands(options2) {
+    return this.manager.getStrands(
+      this.listener.driveId,
+      this.listener.listenerId,
+      options2
+    );
+  }
+  disconnect() {
+    return Promise.resolve();
+  }
+  async processAcknowledge(driveId, listenerId, revisions) {
+    const syncUnits = await this.manager.getListenerSyncUnitIds(
+      driveId,
+      listenerId
+    );
+    let success = true;
+    for (const revision of revisions) {
+      const syncUnit = syncUnits.find(
+        (s) => s.scope === revision.scope && s.branch === revision.branch && s.driveId === revision.driveId && s.documentId == revision.documentId
+      );
+      if (!syncUnit) {
+        logger.warn("Unknown sync unit was acknowledged", revision);
+        success = false;
+        continue;
+      }
+      await this.manager.updateListenerRevision(
+        listenerId,
+        driveId,
+        syncUnit.syncId,
+        revision.revision
+      );
+    }
+    return success;
+  }
+  static async registerPullResponder(driveId, url, filter) {
+    const result = await requestGraphql(
+      url,
+      gql`
+        mutation registerPullResponderListener($filter: InputListenerFilter!) {
+          registerPullResponderListener(filter: $filter) {
+            listenerId
+          }
+        }
+      `,
+      { filter }
+    );
+    const error = result.errors?.at(0);
+    if (error) {
+      throw error;
+    }
+    if (!result.registerPullResponderListener) {
+      throw new Error("Error registering listener");
+    }
+    return result.registerPullResponderListener.listenerId;
+  }
+  static async pullStrands(driveId, url, listenerId, options2) {
+    const result = await requestGraphql(
+      url,
+      gql`
+        query strands($listenerId: ID!) {
+          system {
+            sync {
+              strands(listenerId: $listenerId) {
+                driveId
+                documentId
+                scope
+                branch
+                operations {
+                  id
+                  timestamp
+                  skip
+                  type
+                  input
+                  hash
+                  index
+                  context {
+                    signer {
+                      user {
+                        address
+                        networkId
+                        chainId
+                      }
+                      app {
+                        name
+                        key
+                      }
+                      signatures
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      `,
+      { listenerId }
+    );
+    const error = result.errors?.at(0);
+    if (error) {
+      throw error;
+    }
+    if (!result.system) {
+      return [];
+    }
+    return result.system.sync.strands.map((s) => ({
+      ...s,
+      operations: s.operations.map((o) => ({
+        ...o,
+        input: JSON.parse(o.input)
+      }))
+    }));
+  }
+  static async acknowledgeStrands(driveId, url, listenerId, revisions) {
+    const result = await requestGraphql(
+      url,
+      gql`
+        mutation acknowledge(
+          $listenerId: String!
+          $revisions: [ListenerRevisionInput]
+        ) {
+          acknowledge(listenerId: $listenerId, revisions: $revisions)
+        }
+      `,
+      { listenerId, revisions }
+    );
+    const error = result.errors?.at(0);
+    if (error) {
+      throw error;
+    }
+    if (result.acknowledge === null) {
+      throw new Error("Error acknowledging strands");
+    }
+    return result.acknowledge;
+  }
+  static async executePull(driveId, trigger, onStrandUpdate, onError, onRevisions, onAcknowledge) {
+    try {
+      const { url, listenerId } = trigger.data;
+      const strands = await _PullResponderTransmitter.pullStrands(
+        driveId,
+        url,
+        listenerId
+        // since ?
+      );
+      if (!strands.length) {
+        onRevisions?.([]);
+        return;
+      }
+      const listenerRevisions = [];
+      for (const strand of strands) {
+        const operations = strand.operations.map((op) => ({
+          ...op,
+          scope: strand.scope,
+          branch: strand.branch
+        }));
+        let error = void 0;
+        try {
+          const result = await onStrandUpdate(strand, {
+            type: "trigger",
+            trigger
+          });
+          if (result.error) {
+            throw result.error;
+          }
+        } catch (e) {
+          error = e;
+          onError(error);
+        }
+        listenerRevisions.push({
+          branch: strand.branch,
+          documentId: strand.documentId || "",
+          driveId: strand.driveId,
+          revision: operations.pop()?.index ?? -1,
+          scope: strand.scope,
+          status: error ? error instanceof OperationError ? error.status : "ERROR" : "SUCCESS",
+          error
+        });
+      }
+      onRevisions?.(listenerRevisions);
+      await _PullResponderTransmitter.acknowledgeStrands(
+        driveId,
+        url,
+        listenerId,
+        listenerRevisions.map((revision) => {
+          const { error, ...rest } = revision;
+          return rest;
+        })
+      ).then((result) => onAcknowledge?.(result)).catch((error) => logger.error("ACK error", error));
+    } catch (error) {
+      onError(error);
+    }
+  }
+  static setupPull(driveId, trigger, onStrandUpdate, onError, onRevisions, onAcknowledge) {
+    const { interval } = trigger.data;
+    let loopInterval = PULL_DRIVE_INTERVAL;
+    if (interval) {
+      try {
+        const intervalNumber = parseInt(interval);
+        if (intervalNumber) {
+          loopInterval = intervalNumber;
+        }
+      } catch {
+      }
+    }
+    let isCancelled = false;
+    let timeout;
+    const executeLoop = async () => {
+      while (!isCancelled) {
+        await this.executePull(
+          driveId,
+          trigger,
+          onStrandUpdate,
+          onError,
+          onRevisions,
+          onAcknowledge
+        );
+        await new Promise((resolve) => {
+          timeout = setTimeout(resolve, loopInterval);
+        });
+      }
+    };
+    executeLoop().catch(logger.error);
+    return () => {
+      isCancelled = true;
+      if (timeout !== void 0) {
+        clearTimeout(timeout);
+      }
+    };
+  }
+  static async createPullResponderTrigger(driveId, url, options2) {
+    const { pullFilter, pullInterval } = options2;
+    const listenerId = await _PullResponderTransmitter.registerPullResponder(
+      driveId,
+      url,
+      pullFilter ?? {
+        documentId: ["*"],
+        documentType: ["*"],
+        branch: ["*"],
+        scope: ["*"]
+      }
+    );
+    const pullTrigger = {
+      id: generateUUID(),
+      type: "PullResponder",
+      data: {
+        url,
+        listenerId,
+        interval: pullInterval?.toString() ?? ""
+      }
+    };
+    return pullTrigger;
+  }
+  static isPullResponderTrigger(trigger) {
+    return trigger.type === "PullResponder";
+  }
+};
+var SwitchboardPushTransmitter = class {
+  drive;
+  listener;
+  targetURL;
+  constructor(listener, drive) {
+    this.listener = listener;
+    this.drive = drive;
+    this.targetURL = listener.callInfo.data;
+  }
+  async transmit(strands, source) {
+    if (source.type === "trigger" && source.trigger.data?.url === this.targetURL) {
+      return strands.map((strand) => ({
+        driveId: strand.driveId,
+        documentId: strand.documentId,
+        scope: strand.scope,
+        branch: strand.branch,
+        status: "SUCCESS",
+        revision: strand.operations.at(-1)?.index ?? -1
+      }));
+    }
+    try {
+      const { pushUpdates } = await requestGraphql(
+        this.targetURL,
+        gql`
+          mutation pushUpdates($strands: [InputStrandUpdate!]) {
+            pushUpdates(strands: $strands) {
+              driveId
+              documentId
+              scope
+              branch
+              status
+              revision
+              error
+            }
+          }
+        `,
+        {
+          strands: strands.map((strand) => ({
+            ...strand,
+            operations: strand.operations.map((op) => ({
+              ...op,
+              input: stringify(op.input)
+            }))
+          }))
+        }
+      );
+      if (!pushUpdates) {
+        throw new Error("Couldn't update listener revision");
+      }
+      return pushUpdates;
+    } catch (e) {
+      logger.error(e);
+      throw e;
+    }
+    return [];
+  }
+};
+
+// ../document-drive/src/server/listener/manager.ts
+function debounce(func, delay = 250) {
+  let timer;
+  return (immediate, ...args) => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    return new Promise((resolve, reject) => {
+      if (immediate) {
+        func(...args).then(resolve).catch(reject);
+      } else {
+        timer = setTimeout(() => {
+          func(...args).then(resolve).catch(reject);
+        }, delay);
+      }
+    });
+  };
+}
+var ListenerManager = class _ListenerManager extends BaseListenerManager {
+  static LISTENER_UPDATE_DELAY = 250;
+  async getTransmitter(driveId, listenerId) {
+    return Promise.resolve(this.transmitters[driveId]?.[listenerId]);
+  }
+  driveHasListeners(driveId) {
+    return this.listenerState.has(driveId);
+  }
+  async addListener(listener) {
+    const drive = listener.driveId;
+    if (!this.listenerState.has(drive)) {
+      this.listenerState.set(drive, /* @__PURE__ */ new Map());
+    }
+    const driveMap = this.listenerState.get(drive);
+    driveMap.set(listener.listenerId, {
+      block: listener.block,
+      driveId: listener.driveId,
+      pendingTimeout: "0",
+      listener,
+      listenerStatus: "CREATED",
+      syncUnits: /* @__PURE__ */ new Map()
+    });
+    let transmitter;
+    switch (listener.callInfo?.transmitterType) {
+      case "SwitchboardPush": {
+        transmitter = new SwitchboardPushTransmitter(listener, this.drive);
+        break;
+      }
+      case "PullResponder": {
+        transmitter = new PullResponderTransmitter(listener, this.drive, this);
+        break;
+      }
+      case "Internal": {
+        transmitter = new InternalTransmitter(listener, this.drive);
+        break;
+      }
+    }
+    if (!transmitter) {
+      throw new Error("Transmitter not found");
+    }
+    const driveTransmitters = this.transmitters[drive] || {};
+    driveTransmitters[listener.listenerId] = transmitter;
+    this.transmitters[drive] = driveTransmitters;
+    return Promise.resolve(transmitter);
+  }
+  async removeListener(driveId, listenerId) {
+    const driveMap = this.listenerState.get(driveId);
+    if (!driveMap) {
+      return false;
+    }
+    return Promise.resolve(driveMap.delete(listenerId));
+  }
+  async removeSyncUnits(driveId, syncUnits) {
+    const listeners = this.listenerState.get(driveId);
+    if (!listeners) {
+      return;
+    }
+    for (const [, listener] of listeners) {
+      for (const syncUnit of syncUnits) {
+        listener.syncUnits.delete(syncUnit.syncId);
+      }
+    }
+    return Promise.resolve();
+  }
+  async updateSynchronizationRevisions(driveId, syncUnits, source, willUpdate, onError, forceSync = false) {
+    const drive = this.listenerState.get(driveId);
+    if (!drive) {
+      return [];
+    }
+    const outdatedListeners = [];
+    for (const [, listener] of drive) {
+      if (outdatedListeners.find(
+        (l) => l.listenerId === listener.listener.listenerId
+      )) {
+        continue;
+      }
+      const transmitter = await this.getTransmitter(
+        driveId,
+        listener.listener.listenerId
+      );
+      if (!transmitter?.transmit) {
+        continue;
+      }
+      for (const syncUnit of syncUnits) {
+        if (!this._checkFilter(listener.listener.filter, syncUnit)) {
+          continue;
+        }
+        const listenerRev = listener.syncUnits.get(syncUnit.syncId);
+        if (!listenerRev || listenerRev.listenerRev < syncUnit.revision) {
+          outdatedListeners.push(listener.listener);
+          break;
+        }
+      }
+    }
+    if (outdatedListeners.length) {
+      willUpdate?.(outdatedListeners);
+      return this.triggerUpdate(forceSync, source, onError);
+    }
+    return [];
+  }
+  async updateListenerRevision(listenerId, driveId, syncId, listenerRev) {
+    const drive = this.listenerState.get(driveId);
+    if (!drive) {
+      return;
+    }
+    const listener = drive.get(listenerId);
+    if (!listener) {
+      return;
+    }
+    const lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = listener.syncUnits.get(syncId);
+    if (entry) {
+      entry.listenerRev = listenerRev;
+      entry.lastUpdated = lastUpdated;
+    } else {
+      listener.syncUnits.set(syncId, { listenerRev, lastUpdated });
+    }
+    return Promise.resolve();
+  }
+  triggerUpdate = debounce(
+    this._triggerUpdate.bind(this),
+    _ListenerManager.LISTENER_UPDATE_DELAY
+  );
+  async _triggerUpdate(source, onError) {
+    const listenerUpdates = [];
+    for (const [driveId, drive] of this.listenerState) {
+      for (const [id, listener] of drive) {
+        const transmitter = await this.getTransmitter(driveId, id);
+        if (!transmitter?.transmit) {
+          continue;
+        }
+        const syncUnits = await this.getListenerSyncUnits(
+          driveId,
+          listener.listener.listenerId
+        );
+        const strandUpdates = [];
+        const tasks = syncUnits.map((syncUnit) => async () => {
+          const unitState = listener.syncUnits.get(syncUnit.syncId);
+          if (unitState && unitState.listenerRev >= syncUnit.revision) {
+            return;
+          }
+          const opData = [];
+          try {
+            const data = await this.drive.getOperationData(
+              // TODO - join queries, DEAL WITH INVALID SYNC ID ERROR
+              driveId,
+              syncUnit.syncId,
+              {
+                fromRevision: unitState?.listenerRev
+              }
+            );
+            opData.push(...data);
+          } catch (e) {
+            logger.error(e);
+          }
+          if (!opData.length) {
+            return;
+          }
+          strandUpdates.push({
+            driveId,
+            documentId: syncUnit.documentId,
+            branch: syncUnit.branch,
+            operations: opData,
+            scope: syncUnit.scope
+          });
+        });
+        if (this.options.sequentialUpdates) {
+          for (const task of tasks) {
+            await task();
+          }
+        } else {
+          await Promise.all(tasks.map((task) => task()));
+        }
+        if (strandUpdates.length == 0) {
+          continue;
+        }
+        listener.pendingTimeout = new Date(
+          (/* @__PURE__ */ new Date()).getTime() / 1e3 + 300
+        ).toISOString();
+        listener.listenerStatus = "PENDING";
+        try {
+          const listenerRevisions = await transmitter.transmit(
+            strandUpdates,
+            source
+          );
+          listener.pendingTimeout = "0";
+          listener.listenerStatus = "PENDING";
+          const lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+          for (const revision of listenerRevisions) {
+            const syncUnit = syncUnits.find(
+              (unit) => revision.documentId === unit.documentId && revision.scope === unit.scope && revision.branch === unit.branch
+            );
+            if (syncUnit) {
+              listener.syncUnits.set(syncUnit.syncId, {
+                lastUpdated,
+                listenerRev: revision.revision
+              });
+            } else {
+              logger.warn(
+                `Received revision for untracked unit for listener ${listener.listener.listenerId}`,
+                revision
+              );
+            }
+          }
+          for (const revision of listenerRevisions) {
+            const error = revision.status === "ERROR";
+            if (revision.error?.includes("Missing operations")) {
+              const updates = await this._triggerUpdate(source, onError);
+              listenerUpdates.push(...updates);
+            } else {
+              listenerUpdates.push({
+                listenerId: listener.listener.listenerId,
+                listenerRevisions
+              });
+              if (error) {
+                throw new OperationError(
+                  revision.status,
+                  void 0,
+                  revision.error,
+                  revision.error
+                );
+              }
+            }
+          }
+          listener.listenerStatus = "SUCCESS";
+        } catch (e) {
+          onError?.(e, driveId, listener);
+          listener.listenerStatus = e instanceof OperationError ? e.status : "ERROR";
+        }
+      }
+    }
+    return listenerUpdates;
+  }
+  _checkFilter(filter, syncUnit) {
+    const { branch, documentId, scope, documentType } = syncUnit;
+    if ((!filter.branch || filter.branch.includes(branch) || filter.branch.includes("*")) && (!filter.documentId || filter.documentId.includes(documentId) || filter.documentId.includes("*")) && (!filter.scope || filter.scope.includes(scope) || filter.scope.includes("*")) && (!filter.documentType || filter.documentType.includes(documentType) || filter.documentType.includes("*"))) {
+      return true;
+    }
+    return false;
+  }
+  getListenerSyncUnits(driveId, listenerId, loadedDrive) {
+    const listener = this.listenerState.get(driveId)?.get(listenerId);
+    if (!listener) {
+      return [];
+    }
+    const filter = listener.listener.filter;
+    return this.drive.getSynchronizationUnits(
+      driveId,
+      filter.documentId ?? ["*"],
+      filter.scope ?? ["*"],
+      filter.branch ?? ["*"],
+      filter.documentType ?? ["*"],
+      loadedDrive
+    );
+  }
+  getListenerSyncUnitIds(driveId, listenerId) {
+    const listener = this.listenerState.get(driveId)?.get(listenerId);
+    if (!listener) {
+      return [];
+    }
+    const filter = listener.listener.filter;
+    return this.drive.getSynchronizationUnitsIds(
+      driveId,
+      filter.documentId ?? ["*"],
+      filter.scope ?? ["*"],
+      filter.branch ?? ["*"],
+      filter.documentType ?? ["*"]
+    );
+  }
+  async initDrive(drive) {
+    const {
+      state: {
+        local: { listeners }
+      }
+    } = drive;
+    for (const listener of listeners) {
+      await this.addListener({
+        block: listener.block,
+        driveId: drive.state.global.id,
+        filter: {
+          branch: listener.filter.branch ?? [],
+          documentId: listener.filter.documentId ?? [],
+          documentType: listener.filter.documentType,
+          scope: listener.filter.scope ?? []
+        },
+        listenerId: listener.listenerId,
+        system: listener.system,
+        callInfo: listener.callInfo ?? void 0,
+        label: listener.label ?? ""
+      });
+    }
+  }
+  async removeDrive(driveId) {
+    this.listenerState.delete(driveId);
+    const transmitters = this.transmitters[driveId];
+    if (transmitters) {
+      await Promise.all(
+        Object.values(transmitters).map((t) => t.disconnect?.())
+      );
+    }
+  }
+  getListener(driveId, listenerId) {
+    const drive = this.listenerState.get(driveId);
+    if (!drive) throw new Error("Drive not found");
+    const listener = drive.get(listenerId);
+    if (!listener) throw new Error("Listener not found");
+    return Promise.resolve(listener);
+  }
+  async getStrands(driveId, listenerId, options2) {
+    const listener = await this.getListener(driveId, listenerId);
+    const strands = [];
+    const drive = await this.drive.getDrive(driveId);
+    const syncUnits = await this.getListenerSyncUnits(
+      driveId,
+      listenerId,
+      drive
+    );
+    const limit = options2?.limit;
+    let operationsCount = 0;
+    const tasks = syncUnits.map((syncUnit) => async () => {
+      if (limit && operationsCount >= limit) {
+        return;
+      }
+      if (syncUnit.revision < 0) {
+        return;
+      }
+      const entry = listener.syncUnits.get(syncUnit.syncId);
+      if (entry && entry.listenerRev >= syncUnit.revision) {
+        return;
+      }
+      const { documentId, driveId: driveId2, scope, branch } = syncUnit;
+      try {
+        const operations = await this.drive.getOperationData(
+          // DEAL WITH INVALID SYNC ID ERROR
+          driveId2,
+          syncUnit.syncId,
+          {
+            since: options2?.since,
+            fromRevision: options2?.fromRevision ?? entry?.listenerRev,
+            limit: limit ? limit - operationsCount : void 0
+          },
+          drive
+        );
+        if (!operations.length) {
+          return;
+        }
+        operationsCount += operations.length;
+        strands.push({
+          driveId: driveId2,
+          documentId,
+          scope,
+          branch,
+          operations
+        });
+      } catch (error) {
+        logger.error(error);
+        return;
+      }
+    });
+    if (this.options.sequentialUpdates) {
+      for (const task of tasks) {
+        await task();
+      }
+    } else {
+      await Promise.all(tasks.map((task) => task()));
+    }
+    return strands;
+  }
+};
+
+// ../document-drive/src/server/index.ts
+var PULL_DRIVE_INTERVAL = 5e3;
+var BaseDocumentDriveServer = class extends AbstractDocumentDriveServer {
+  emitter = createNanoEvents();
+  cache;
+  documentModels;
+  storage;
+  listenerStateManager;
+  triggerMap = /* @__PURE__ */ new Map();
+  syncStatus = /* @__PURE__ */ new Map();
+  queueManager;
+  initializePromise;
+  defaultDrivesManager;
+  options;
+  constructor(documentModels, storage = new MemoryStorage(), cache = new memory_default(), queueManager = new BaseQueueManager(), options2) {
+    super();
+    this.options = {
+      ...options2,
+      defaultDrives: {
+        ...options2?.defaultDrives
+      },
+      listenerManager: {
+        ...DefaultListenerManagerOptions,
+        ...options2?.listenerManager
+      },
+      taskQueueMethod: options2?.taskQueueMethod === void 0 ? RunAsap.runAsap : options2.taskQueueMethod
+    };
+    this.listenerStateManager = new ListenerManager(
+      this,
+      void 0,
+      options2?.listenerManager
+    );
+    this.documentModels = documentModels;
+    this.storage = storage;
+    this.cache = cache;
+    this.queueManager = queueManager;
+    this.defaultDrivesManager = new DefaultDrivesManager(
+      this,
+      this.defaultDrivesManagerDelegate,
+      options2
+    );
+    this.storage.setStorageDelegate?.({
+      getCachedOperations: async (drive, id) => {
+        try {
+          const document = await this.cache.getDocument(drive, id);
+          return document?.operations;
+        } catch (error) {
+          logger.error(error);
+          return void 0;
+        }
+      }
+    });
+    this.initializePromise = this._initialize();
+  }
+  setDocumentModels(models) {
+    this.documentModels = [...models];
+    this.emit("documentModels", [...models]);
+  }
+  initializeDefaultRemoteDrives() {
+    return this.defaultDrivesManager.initializeDefaultRemoteDrives();
+  }
+  getDefaultRemoteDrives() {
+    return this.defaultDrivesManager.getDefaultRemoteDrives();
+  }
+  setDefaultDriveAccessLevel(url, level) {
+    return this.defaultDrivesManager.setDefaultDriveAccessLevel(url, level);
+  }
+  setAllDefaultDrivesAccessLevel(level) {
+    return this.defaultDrivesManager.setAllDefaultDrivesAccessLevel(level);
+  }
+  getOperationSource(source) {
+    return source.type === "local" ? "push" : "pull";
+  }
+  getCombinedSyncUnitStatus(syncUnitStatus) {
+    if (!syncUnitStatus.pull && !syncUnitStatus.push) return "INITIAL_SYNC";
+    if (syncUnitStatus.pull === "INITIAL_SYNC") return "INITIAL_SYNC";
+    if (syncUnitStatus.push === "INITIAL_SYNC")
+      return syncUnitStatus.pull || "INITIAL_SYNC";
+    const order = [
+      "ERROR",
+      "MISSING",
+      "CONFLICT",
+      "SYNCING",
+      "SUCCESS"
+    ];
+    const sortedStatus = Object.values(syncUnitStatus).sort(
+      (a, b) => order.indexOf(a) - order.indexOf(b)
+    );
+    return sortedStatus[0];
+  }
+  initSyncStatus(syncUnitId, status) {
+    const defaultSyncUnitStatus = Object.entries(
+      status
+    ).reduce((acc, [key, _status]) => {
+      return {
+        ...acc,
+        [key]: _status !== "SYNCING" ? _status : "INITIAL_SYNC"
+      };
+    }, {});
+    this.syncStatus.set(syncUnitId, defaultSyncUnitStatus);
+    this.emit(
+      "syncStatus",
+      syncUnitId,
+      this.getCombinedSyncUnitStatus(defaultSyncUnitStatus),
+      void 0,
+      defaultSyncUnitStatus
+    );
+  }
+  async initializeDriveSyncStatus(driveId, drive) {
+    const syncUnits = await this.getSynchronizationUnitsIds(driveId);
+    const syncStatus = {
+      pull: drive.state.local.triggers.length > 0 ? "INITIAL_SYNC" : void 0,
+      push: drive.state.local.listeners.length > 0 ? "SUCCESS" : void 0
+    };
+    if (!syncStatus.pull && !syncStatus.push) return;
+    const syncUnitsIds = [driveId, ...syncUnits.map((s) => s.syncId)];
+    for (const syncUnitId of syncUnitsIds) {
+      this.initSyncStatus(syncUnitId, syncStatus);
+    }
+  }
+  updateSyncUnitStatus(syncUnitId, status, error) {
+    if (status === null) {
+      this.syncStatus.delete(syncUnitId);
+      return;
+    }
+    const syncUnitStatus = this.syncStatus.get(syncUnitId);
+    if (!syncUnitStatus) {
+      this.initSyncStatus(syncUnitId, status);
+      return;
+    }
+    const shouldUpdateStatus = Object.entries(status).some(
+      ([key, _status]) => syncUnitStatus[key] !== _status
+    );
+    if (shouldUpdateStatus) {
+      const newstatus = Object.entries(status).reduce((acc, [key, _status]) => {
+        return {
+          ...acc,
+          // do not replace initial_syncing if it has not finished yet
+          [key]: acc[key] === "INITIAL_SYNC" && _status === "SYNCING" ? "INITIAL_SYNC" : _status
+        };
+      }, syncUnitStatus);
+      const previousCombinedStatus = this.getCombinedSyncUnitStatus(syncUnitStatus);
+      const newCombinedStatus = this.getCombinedSyncUnitStatus(newstatus);
+      this.syncStatus.set(syncUnitId, newstatus);
+      if (previousCombinedStatus !== newCombinedStatus) {
+        this.emit(
+          "syncStatus",
+          syncUnitId,
+          this.getCombinedSyncUnitStatus(newstatus),
+          error,
+          newstatus
+        );
+      }
+    }
+  }
+  async saveStrand(strand, source) {
+    const operations = strand.operations.map((op) => ({
+      ...op,
+      scope: strand.scope,
+      branch: strand.branch
+    }));
+    const result = await (!strand.documentId ? this.queueDriveOperations(
+      strand.driveId,
+      operations,
+      { source }
+    ) : this.queueOperations(strand.driveId, strand.documentId, operations, {
+      source
+    }));
+    if (result.status === "ERROR") {
+      const syncUnits = strand.documentId !== "" ? (await this.getSynchronizationUnitsIds(
+        strand.driveId,
+        [strand.documentId],
+        [strand.scope],
+        [strand.branch]
+      )).map((s) => s.syncId) : [strand.driveId];
+      const operationSource = this.getOperationSource(source);
+      for (const syncUnit of syncUnits) {
+        this.updateSyncUnitStatus(
+          syncUnit,
+          { [operationSource]: result.status },
+          result.error
+        );
+      }
+    }
+    this.emit("strandUpdate", strand);
+    return result;
+  }
+  handleListenerError(error, driveId, listener) {
+    logger.error(
+      `Listener ${listener.listener.label ?? listener.listener.listenerId} error:`,
+      error
+    );
+    const status = error instanceof OperationError ? error.status : "ERROR";
+    this.updateSyncUnitStatus(driveId, { push: status }, error);
+  }
+  shouldSyncRemoteDrive(drive) {
+    return drive.state.local.availableOffline && drive.state.local.triggers.length > 0;
+  }
+  async startSyncRemoteDrive(driveId) {
+    const drive = await this.getDrive(driveId);
+    let driveTriggers = this.triggerMap.get(driveId);
+    const syncUnits = await this.getSynchronizationUnitsIds(
+      driveId,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      drive
+    );
+    for (const trigger of drive.state.local.triggers) {
+      if (driveTriggers?.get(trigger.id)) {
+        continue;
+      }
+      if (!driveTriggers) {
+        driveTriggers = /* @__PURE__ */ new Map();
+      }
+      this.updateSyncUnitStatus(driveId, { pull: "SYNCING" });
+      for (const syncUnit of syncUnits) {
+        this.updateSyncUnitStatus(syncUnit.syncId, { pull: "SYNCING" });
+      }
+      if (PullResponderTransmitter.isPullResponderTrigger(trigger)) {
+        let firstPull = true;
+        const cancelPullLoop = PullResponderTransmitter.setupPull(
+          driveId,
+          trigger,
+          this.saveStrand.bind(this),
+          (error) => {
+            const statusError = error instanceof OperationError ? error.status : "ERROR";
+            this.updateSyncUnitStatus(driveId, { pull: statusError }, error);
+            if (error instanceof ClientError) {
+              this.emit(
+                "clientStrandsError",
+                driveId,
+                trigger,
+                error.response.status,
+                error.message
+              );
+            }
+          },
+          (revisions) => {
+            const errorRevision = revisions.filter(
+              (r) => r.status !== "SUCCESS"
+            );
+            if (errorRevision.length < 1) {
+              this.updateSyncUnitStatus(driveId, {
+                pull: "SUCCESS"
+              });
+            }
+            const documentIdsFromRevision = revisions.filter((rev) => rev.documentId !== "").map((rev) => rev.documentId);
+            this.getSynchronizationUnitsIds(driveId, documentIdsFromRevision).then((revSyncUnits) => {
+              for (const syncUnit of revSyncUnits) {
+                const fileErrorRevision = errorRevision.find(
+                  (r) => r.documentId === syncUnit.documentId
+                );
+                if (fileErrorRevision) {
+                  this.updateSyncUnitStatus(
+                    syncUnit.syncId,
+                    { pull: fileErrorRevision.status },
+                    fileErrorRevision.error
+                  );
+                } else {
+                  this.updateSyncUnitStatus(syncUnit.syncId, {
+                    pull: "SUCCESS"
+                  });
+                }
+              }
+            }).catch(console.error);
+            if (firstPull) {
+              firstPull = false;
+              const pushListener = drive.state.local.listeners.find(
+                (listener) => trigger.data.url === listener.callInfo?.data
+              );
+              if (pushListener) {
+                this.getSynchronizationUnitsRevision(driveId, syncUnits).then((syncUnitRevisions) => {
+                  for (const revision of syncUnitRevisions) {
+                    this.listenerStateManager.updateListenerRevision(
+                      pushListener.listenerId,
+                      driveId,
+                      revision.syncId,
+                      revision.revision
+                    ).catch(logger.error);
+                  }
+                }).catch(logger.error);
+              }
+            }
+          }
+        );
+        driveTriggers.set(trigger.id, cancelPullLoop);
+        this.triggerMap.set(driveId, driveTriggers);
+      }
+    }
+  }
+  async stopSyncRemoteDrive(driveId) {
+    const syncUnits = await this.getSynchronizationUnitsIds(driveId);
+    const filesNodeSyncId = syncUnits.filter((syncUnit) => syncUnit.documentId !== "").map((syncUnit) => syncUnit.syncId);
+    const triggers = this.triggerMap.get(driveId);
+    triggers?.forEach((cancel) => cancel());
+    this.updateSyncUnitStatus(driveId, null);
+    for (const fileNodeSyncId of filesNodeSyncId) {
+      this.updateSyncUnitStatus(fileNodeSyncId, null);
+    }
+    return this.triggerMap.delete(driveId);
+  }
+  defaultDrivesManagerDelegate = {
+    detachDrive: this.detachDrive.bind(this),
+    emit: (...args) => this.emit("defaultRemoteDrive", ...args)
+  };
+  queueDelegate = {
+    checkDocumentExists: (driveId, documentId) => this.storage.checkDocumentExists(driveId, documentId),
+    processOperationJob: async ({
+      driveId,
+      documentId,
+      operations,
+      options: options2
+    }) => {
+      return documentId ? this.addOperations(driveId, documentId, operations, options2) : this.addDriveOperations(
+        driveId,
+        operations,
+        options2
+      );
+    },
+    processActionJob: async ({
+      driveId,
+      documentId,
+      actions: actions2,
+      options: options2
+    }) => {
+      return documentId ? this.addActions(driveId, documentId, actions2, options2) : this.addDriveActions(
+        driveId,
+        actions2,
+        options2
+      );
+    },
+    processJob: async (job) => {
+      if (isOperationJob(job)) {
+        return this.queueDelegate.processOperationJob(job);
+      } else if (isActionJob(job)) {
+        return this.queueDelegate.processActionJob(job);
+      } else {
+        throw new Error("Unknown job type", job);
+      }
+    }
+  };
+  initialize() {
+    return this.initializePromise;
+  }
+  async _initialize() {
+    await this.queueManager.init(this.queueDelegate, (error) => {
+      logger.error(`Error initializing queue manager`, error);
+      errors.push(error);
+    });
+    try {
+      await this.defaultDrivesManager.removeOldremoteDrives();
+    } catch (error) {
+      logger.error(error);
+    }
+    const errors = [];
+    const drives = await this.getDrives();
+    for (const drive of drives) {
+      await this._initializeDrive(drive).catch((error) => {
+        logger.error(`Error initializing drive ${drive}`, error);
+        errors.push(error);
+      });
+    }
+    if (this.options.defaultDrives.loadOnInit !== false) {
+      await this.defaultDrivesManager.initializeDefaultRemoteDrives();
+    }
+    if (typeof window !== "undefined") {
+      window.addEventListener("online", () => {
+        this.listenerStateManager.triggerUpdate(
+          false,
+          { type: "local" },
+          this.handleListenerError.bind(this)
+        ).catch((error) => {
+          logger.error("Non handled error updating listeners", error);
+        });
+      });
+    }
+    return errors.length === 0 ? null : errors;
+  }
+  async _initializeDrive(driveId) {
+    const drive = await this.getDrive(driveId);
+    await this.initializeDriveSyncStatus(driveId, drive);
+    if (this.shouldSyncRemoteDrive(drive)) {
+      await this.startSyncRemoteDrive(driveId);
+    }
+    await this.listenerStateManager.initDrive(drive);
+  }
+  async getSynchronizationUnits(driveId, documentId, scope, branch, documentType, loadedDrive) {
+    const drive = loadedDrive || await this.getDrive(driveId);
+    const synchronizationUnitsQuery = await this.getSynchronizationUnitsIds(
+      driveId,
+      documentId,
+      scope,
+      branch,
+      documentType,
+      drive
+    );
+    return this.getSynchronizationUnitsRevision(
+      driveId,
+      synchronizationUnitsQuery,
+      drive
+    );
+  }
+  async getSynchronizationUnitsRevision(driveId, syncUnitsQuery, loadedDrive) {
+    const drive = loadedDrive || await this.getDrive(driveId);
+    const revisions = await this.storage.getSynchronizationUnitsRevision(syncUnitsQuery);
+    const synchronizationUnits = syncUnitsQuery.map(
+      (s) => ({
+        ...s,
+        lastUpdated: drive.created,
+        revision: -1
+      })
+    );
+    for (const revision of revisions) {
+      const syncUnit = synchronizationUnits.find(
+        (s) => revision.driveId === s.driveId && revision.documentId === s.documentId && revision.scope === s.scope && revision.branch === s.branch
+      );
+      if (syncUnit) {
+        syncUnit.revision = revision.revision;
+        syncUnit.lastUpdated = revision.lastUpdated;
+      }
+    }
+    return synchronizationUnits;
+  }
+  async getSynchronizationUnitsIds(driveId, documentId, scope, branch, documentType, loadedDrive) {
+    const drive = loadedDrive ?? await this.getDrive(driveId);
+    const nodes = drive.state.global.nodes.filter(
+      (node) => isFileNode(node) && (!documentId?.length || documentId.includes(node.id) || documentId.includes("*")) && (!documentType?.length || documentType.includes(node.documentType) || documentType.includes("*"))
+    );
+    if ((!documentId || documentId.includes("*") || documentId.includes("")) && (!documentType?.length || documentType.includes("powerhouse/document-drive") || documentType.includes("*"))) {
+      nodes.unshift({
+        id: "",
+        documentType: "powerhouse/document-drive",
+        synchronizationUnits: [
+          {
+            syncId: "0",
+            scope: "global",
+            branch: "main"
+          }
+        ]
+      });
+    }
+    const synchronizationUnitsQuery = [];
+    for (const node of nodes) {
+      const nodeUnits = scope?.length || branch?.length ? node.synchronizationUnits.filter(
+        (unit) => (!scope?.length || scope.includes(unit.scope) || scope.includes("*")) && (!branch?.length || branch.includes(unit.branch) || branch.includes("*"))
+      ) : node.synchronizationUnits;
+      if (!nodeUnits.length) {
+        continue;
+      }
+      synchronizationUnitsQuery.push(
+        ...nodeUnits.map((n) => ({
+          driveId,
+          documentId: node.id,
+          syncId: n.syncId,
+          documentType: node.documentType,
+          scope: n.scope,
+          branch: n.branch
+        }))
+      );
+    }
+    return synchronizationUnitsQuery;
+  }
+  async getSynchronizationUnitIdInfo(driveId, syncId, loadedDrive) {
+    const drive = loadedDrive || await this.getDrive(driveId);
+    const node = drive.state.global.nodes.find(
+      (node2) => isFileNode(node2) && node2.synchronizationUnits.find((unit) => unit.syncId === syncId)
+    );
+    if (!node || !isFileNode(node)) {
+      return void 0;
+    }
+    const syncUnit = node.synchronizationUnits.find(
+      (unit) => unit.syncId === syncId
+    );
+    if (!syncUnit) {
+      return void 0;
+    }
+    return {
+      syncId,
+      scope: syncUnit.scope,
+      branch: syncUnit.branch,
+      driveId,
+      documentId: node.id,
+      documentType: node.documentType
+    };
+  }
+  async getSynchronizationUnit(driveId, syncId, loadedDrive) {
+    const syncUnit = await this.getSynchronizationUnitIdInfo(
+      driveId,
+      syncId,
+      loadedDrive
+    );
+    if (!syncUnit) {
+      return void 0;
+    }
+    const { scope, branch, documentId, documentType } = syncUnit;
+    const document = await this.getDocument(driveId, documentId);
+    const operations = document.operations[scope] ?? [];
+    const lastOperation = operations[operations.length - 1];
+    return {
+      syncId,
+      scope,
+      branch,
+      driveId,
+      documentId,
+      documentType,
+      lastUpdated: lastOperation?.timestamp ?? document.lastModified,
+      revision: lastOperation?.index ?? 0
+    };
+  }
+  async getOperationData(driveId, syncId, filter, loadedDrive) {
+    const syncUnit = syncId === "0" ? { documentId: "", scope: "global" } : await this.getSynchronizationUnitIdInfo(driveId, syncId, loadedDrive);
+    if (!syncUnit) {
+      throw new Error(`Invalid Sync Id ${syncId} in drive ${driveId}`);
+    }
+    const document = syncId === "0" ? loadedDrive || await this.getDrive(driveId) : await this.getDocument(driveId, syncUnit.documentId);
+    const operations = document.operations[syncUnit.scope] ?? [];
+    const filteredOperations = operations.filter(
+      (operation) => Object.keys(filter).length === 0 || (filter.since === void 0 || isBefore(filter.since, operation.timestamp)) && (filter.fromRevision === void 0 || operation.index > filter.fromRevision)
+    );
+    const limitedOperations = filter.limit ? filteredOperations.slice(0, filter.limit) : filteredOperations;
+    return limitedOperations.map((operation) => ({
+      hash: operation.hash,
+      index: operation.index,
+      timestamp: operation.timestamp,
+      type: operation.type,
+      input: operation.input,
+      skip: operation.skip,
+      context: operation.context,
+      id: operation.id
+    }));
+  }
+  getDocumentModel(documentType) {
+    const documentModel2 = this.documentModels.find(
+      (model) => model.documentModel.id === documentType
+    );
+    if (!documentModel2) {
+      throw new Error(`Document type ${documentType} not supported`);
+    }
+    return documentModel2;
+  }
+  getDocumentModels() {
+    return [...this.documentModels];
+  }
+  async addDrive(drive) {
+    const id = drive.global.id || generateUUID();
+    if (!id) {
+      throw new Error("Invalid Drive Id");
+    }
+    const drives = await this.storage.getDrives();
+    if (drives.includes(id)) {
+      throw new DriveAlreadyExistsError(id);
+    }
+    const document = utils$1.createDocument({
+      state: drive
+    });
+    await this.storage.createDrive(id, document);
+    if (drive.global.slug) {
+      await this.cache.deleteDocument("drives-slug", drive.global.slug);
+    }
+    await this._initializeDrive(id);
+    this.emit("driveAdded", document);
+    return document;
+  }
+  async addRemoteDrive(url, options2) {
+    const { id, name, slug, icon } = options2.expectedDriveInfo || await requestPublicDrive(url);
+    const {
+      pullFilter,
+      pullInterval,
+      availableOffline,
+      sharingType,
+      listeners,
+      triggers
+    } = options2;
+    const pullTrigger = await PullResponderTransmitter.createPullResponderTrigger(id, url, {
+      pullFilter,
+      pullInterval
+    });
+    return await this.addDrive({
+      global: {
+        id,
+        name,
+        slug,
+        icon: icon ?? null
+      },
+      local: {
+        triggers: [...triggers, pullTrigger],
+        listeners,
+        availableOffline,
+        sharingType
+      }
+    });
+  }
+  async registerPullResponderTrigger(id, url, options2) {
+    const pullTrigger = await PullResponderTransmitter.createPullResponderTrigger(
+      id,
+      url,
+      options2
+    );
+    return pullTrigger;
+  }
+  async deleteDrive(id) {
+    const result = await Promise.allSettled([
+      this.stopSyncRemoteDrive(id),
+      this.listenerStateManager.removeDrive(id),
+      this.cache.deleteDocument("drives", id),
+      this.storage.deleteDrive(id)
+    ]);
+    result.forEach((r) => {
+      if (r.status === "rejected") {
+        throw r.reason;
+      }
+    });
+  }
+  getDrives() {
+    return this.storage.getDrives();
+  }
+  async getDrive(drive, options2) {
+    try {
+      const document2 = await this.cache.getDocument("drives", drive);
+      if (document2 && isDocumentDrive(document2)) {
+        return document2;
+      }
+    } catch (e) {
+      logger.error("Error getting drive from cache", e);
+    }
+    const driveStorage = await this.storage.getDrive(drive);
+    const document = this._buildDocument(driveStorage, options2);
+    if (!isDocumentDrive(document)) {
+      throw new Error(`Document with id ${drive} is not a Document Drive`);
+    } else {
+      this.cache.setDocument("drives", drive, document).catch(logger.error);
+      return document;
+    }
+  }
+  async getDriveBySlug(slug, options2) {
+    try {
+      const document2 = await this.cache.getDocument("drives-slug", slug);
+      if (document2 && isDocumentDrive(document2)) {
+        return document2;
+      }
+    } catch (e) {
+      logger.error("Error getting drive from cache", e);
+    }
+    const driveStorage = await this.storage.getDriveBySlug(slug);
+    const document = this._buildDocument(driveStorage, options2);
+    if (!isDocumentDrive(document)) {
+      throw new Error(`Document with slug ${slug} is not a Document Drive`);
+    } else {
+      this.cache.setDocument("drives-slug", slug, document).catch(logger.error);
+      return document;
+    }
+  }
+  async getDocument(drive, id, options2) {
+    try {
+      const document2 = await this.cache.getDocument(drive, id);
+      if (document2) {
+        return document2;
+      }
+    } catch (e) {
+      logger.error("Error getting document from cache", e);
+    }
+    const documentStorage = await this.storage.getDocument(drive, id);
+    const document = this._buildDocument(documentStorage, options2);
+    this.cache.setDocument(drive, id, document).catch(logger.error);
+    return document;
+  }
+  getDocuments(drive) {
+    return this.storage.getDocuments(drive);
+  }
+  async createDocument(driveId, input) {
+    let state = void 0;
+    if (input.document) {
+      if (input.documentType !== input.document.documentType) {
+        throw new Error(`Provided document is not ${input.documentType}`);
+      }
+      const doc = this._buildDocument(input.document);
+      state = doc.state;
+    }
+    const document = input.document ?? this.getDocumentModel(input.documentType).utils.createDocument();
+    const documentStorage = {
+      name: document.name,
+      revision: document.revision,
+      documentType: document.documentType,
+      created: document.created,
+      lastModified: document.lastModified,
+      operations: { global: [], local: [] },
+      initialState: document.initialState,
+      clipboard: [],
+      state: state ?? document.state
+    };
+    await this.storage.createDocument(driveId, input.id, documentStorage);
+    for (const syncUnit of input.synchronizationUnits) {
+      this.initSyncStatus(syncUnit.syncId, {
+        pull: this.triggerMap.get(driveId) ? "INITIAL_SYNC" : void 0,
+        push: this.listenerStateManager.driveHasListeners(driveId) ? "SUCCESS" : void 0
+      });
+    }
+    const operations = Object.values(document.operations).flat();
+    if (operations.length) {
+      if (isDocumentDrive(document)) {
+        await this.storage.addDriveOperations(
+          driveId,
+          operations,
+          document
+        );
+      } else {
+        await this.storage.addDocumentOperations(
+          driveId,
+          input.id,
+          operations,
+          document
+        );
+      }
+    }
+    return document;
+  }
+  async deleteDocument(driveId, id) {
+    try {
+      const syncUnits = await this.getSynchronizationUnitsIds(driveId, [id]);
+      for (const syncUnit of syncUnits) {
+        this.updateSyncUnitStatus(syncUnit.syncId, null);
+      }
+      await this.listenerStateManager.removeSyncUnits(driveId, syncUnits);
+    } catch (error) {
+      logger.warn("Error deleting document", error);
+    }
+    await this.cache.deleteDocument(driveId, id);
+    return this.storage.deleteDocument(driveId, id);
+  }
+  async _processOperations(drive, documentId, documentStorage, operations) {
+    const operationsApplied = [];
+    const signals = [];
+    const documentStorageWithState = await this._addDocumentResultingStage(
+      documentStorage,
+      drive,
+      documentId
+    );
+    let document = this._buildDocument(documentStorageWithState);
+    let error;
+    const operationsByScope = groupOperationsByScope(operations);
+    for (const scope of Object.keys(operationsByScope)) {
+      const storageDocumentOperations = documentStorage.operations[scope];
+      const branch = removeExistingOperations(
+        operationsByScope[scope] || [],
+        storageDocumentOperations
+      );
+      if (branch.length < 1) {
+        continue;
+      }
+      const trunk = garbageCollect(sortOperations(storageDocumentOperations));
+      const [invertedTrunk, tail] = attachBranch(trunk, branch);
+      const newHistory = tail.length < 1 ? invertedTrunk : merge(trunk, invertedTrunk, reshuffleByTimestamp);
+      const newOperations = newHistory.filter(
+        (op) => trunk.length < 1 || precedes(trunk[trunk.length - 1], op)
+      );
+      for (const nextOperation of newOperations) {
+        let skipHashValidation = false;
+        if (tail.length > 0) {
+          const sourceOperation = operations.find(
+            (op) => op.hash === nextOperation.hash
+          );
+          skipHashValidation = !sourceOperation || sourceOperation.index !== nextOperation.index || sourceOperation.skip !== nextOperation.skip;
+        }
+        try {
+          const taskQueueMethod = this.options.taskQueueMethod;
+          const task = () => this._performOperation(
+            drive,
+            documentId,
+            document,
+            nextOperation,
+            skipHashValidation
+          );
+          const appliedResult = await (taskQueueMethod ? runAsapAsync(task, taskQueueMethod) : task());
+          document = appliedResult.document;
+          signals.push(...appliedResult.signals);
+          operationsApplied.push(appliedResult.operation);
+        } catch (e) {
+          error = e instanceof OperationError ? e : new OperationError(
+            "ERROR",
+            nextOperation,
+            e.message,
+            e.cause
+          );
+          break;
+        }
+      }
+    }
+    return {
+      document,
+      operationsApplied,
+      signals,
+      error
+    };
+  }
+  async _addDocumentResultingStage(document, drive, documentId, options2) {
+    const operations = options2?.revisions !== void 0 ? filterOperationsByRevision(document.operations, options2.revisions) : document.operations;
+    const documentOperations = utils.documentHelpers.garbageCollectDocumentOperations(
+      operations
+    );
+    for (const scope of Object.keys(documentOperations)) {
+      const lastRemainingOperation = documentOperations[scope].at(-1);
+      if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
+        lastRemainingOperation.resultingState = await (documentId ? this.storage.getOperationResultingState?.(
+          drive,
+          documentId,
+          lastRemainingOperation.index,
+          lastRemainingOperation.scope,
+          "main"
+        ) : this.storage.getDriveOperationResultingState?.(
+          drive,
+          lastRemainingOperation.index,
+          lastRemainingOperation.scope,
+          "main"
+        ));
+      }
+    }
+    return {
+      ...document,
+      operations: documentOperations
+    };
+  }
+  _buildDocument(documentStorage, options2) {
+    if (documentStorage.state && (!options2 || options2.checkHashes === false)) {
+      return documentStorage;
+    }
+    const documentModel2 = this.getDocumentModel(documentStorage.documentType);
+    const revisionOperations = options2?.revisions !== void 0 ? filterOperationsByRevision(
+      documentStorage.operations,
+      options2.revisions
+    ) : documentStorage.operations;
+    const operations = utils.documentHelpers.garbageCollectDocumentOperations(
+      revisionOperations
+    );
+    return utils.replayDocument(
+      documentStorage.initialState,
+      operations,
+      documentModel2.reducer,
+      void 0,
+      documentStorage,
+      void 0,
+      {
+        ...options2,
+        checkHashes: options2?.checkHashes ?? true,
+        reuseOperationResultingState: options2?.checkHashes ?? true
+      }
+    );
+  }
+  async _performOperation(drive, id, document, operation, skipHashValidation = false) {
+    const documentModel2 = this.getDocumentModel(document.documentType);
+    const signalResults = [];
+    let newDocument = document;
+    const scope = operation.scope;
+    const documentOperations = utils.documentHelpers.garbageCollectDocumentOperations({
+      ...document.operations,
+      [scope]: utils.documentHelpers.skipHeaderOperations(
+        document.operations[scope],
+        operation
+      )
+    });
+    const lastRemainingOperation = documentOperations[scope].at(-1);
+    if (lastRemainingOperation && !lastRemainingOperation.resultingState) {
+      lastRemainingOperation.resultingState = await (id ? this.storage.getOperationResultingState?.(
+        drive,
+        id,
+        lastRemainingOperation.index,
+        lastRemainingOperation.scope,
+        "main"
+      ) : this.storage.getDriveOperationResultingState?.(
+        drive,
+        lastRemainingOperation.index,
+        lastRemainingOperation.scope,
+        "main"
+      ));
+    }
+    const operationSignals = [];
+    newDocument = documentModel2.reducer(
+      newDocument,
+      operation,
+      (signal) => {
+        let handler = void 0;
+        switch (signal.type) {
+          case "CREATE_CHILD_DOCUMENT":
+            handler = () => this.createDocument(drive, signal.input);
+            break;
+          case "DELETE_CHILD_DOCUMENT":
+            handler = () => this.deleteDocument(drive, signal.input.id);
+            break;
+          case "COPY_CHILD_DOCUMENT":
+            handler = () => this.getDocument(drive, signal.input.id).then(
+              (documentToCopy) => this.createDocument(drive, {
+                id: signal.input.newId,
+                documentType: documentToCopy.documentType,
+                document: documentToCopy,
+                synchronizationUnits: signal.input.synchronizationUnits
+              })
+            );
+            break;
+        }
+        if (handler) {
+          operationSignals.push(
+            () => handler().then((result) => ({ signal, result }))
+          );
+        }
+      },
+      { skip: operation.skip, reuseOperationResultingState: true }
+    );
+    const appliedOperations = newDocument.operations[operation.scope].filter(
+      (op) => op.index == operation.index && op.skip == operation.skip
+    );
+    const appliedOperation = appliedOperations.at(0);
+    if (!appliedOperation) {
+      throw new OperationError(
+        "ERROR",
+        operation,
+        `Operation with index ${operation.index}:${operation.skip} was not applied.`
+      );
+    }
+    if (!appliedOperation.error && appliedOperation.hash !== operation.hash && !skipHashValidation) {
+      throw new ConflictOperationError(operation, appliedOperation);
+    }
+    for (const signalHandler of operationSignals) {
+      const result = await signalHandler();
+      signalResults.push(result);
+    }
+    return {
+      document: newDocument,
+      signals: signalResults,
+      operation: appliedOperation
+    };
+  }
+  addOperation(drive, id, operation, options2) {
+    return this.addOperations(drive, id, [operation], options2);
+  }
+  async _addOperations(drive, id, callback) {
+    if (!this.storage.addDocumentOperationsWithTransaction) {
+      const documentStorage = await this.storage.getDocument(drive, id);
+      const result = await callback(documentStorage);
+      if (result.operations.length > 0) {
+        await this.storage.addDocumentOperations(
+          drive,
+          id,
+          result.operations,
+          result.header
+        );
+      }
+    } else {
+      await this.storage.addDocumentOperationsWithTransaction(
+        drive,
+        id,
+        callback
+      );
+    }
+  }
+  queueOperation(drive, id, operation, options2) {
+    return this.queueOperations(drive, id, [operation], options2);
+  }
+  async resultIfExistingOperations(drive, id, operations) {
+    try {
+      const document = await this.getDocument(drive, id);
+      const newOperation = operations.find(
+        (op) => !op.id || !document.operations[op.scope].find(
+          (existingOp) => existingOp.id === op.id && existingOp.index === op.index && existingOp.type === op.type && existingOp.hash === op.hash
+        )
+      );
+      if (!newOperation) {
+        return {
+          status: "SUCCESS",
+          document,
+          operations,
+          signals: []
+        };
+      } else {
+        return void 0;
+      }
+    } catch (error) {
+      if (!error.message.includes(`Document with id ${id} not found`)) {
+        console.error(error);
+      }
+      return void 0;
+    }
+  }
+  async queueOperations(drive, id, operations, options2) {
+    const result = await this.resultIfExistingOperations(drive, id, operations);
+    if (result) {
+      return result;
+    }
+    try {
+      const jobId = await this.queueManager.addJob({
+        driveId: drive,
+        documentId: id,
+        operations,
+        options: options2
+      });
+      return new Promise((resolve, reject) => {
+        const unsubscribe = this.queueManager.on(
+          "jobCompleted",
+          (job, result2) => {
+            if (job.jobId === jobId) {
+              unsubscribe();
+              unsubscribeError();
+              resolve(result2);
+            }
+          }
+        );
+        const unsubscribeError = this.queueManager.on(
+          "jobFailed",
+          (job, error) => {
+            if (job.jobId === jobId) {
+              unsubscribe();
+              unsubscribeError();
+              reject(error);
+            }
+          }
+        );
+      });
+    } catch (error) {
+      logger.error("Error adding job", error);
+      throw error;
+    }
+  }
+  async queueAction(drive, id, action, options2) {
+    return this.queueActions(drive, id, [action], options2);
+  }
+  async queueActions(drive, id, actions2, options2) {
+    try {
+      const jobId = await this.queueManager.addJob({
+        driveId: drive,
+        documentId: id,
+        actions: actions2,
+        options: options2
+      });
+      return new Promise((resolve, reject) => {
+        const unsubscribe = this.queueManager.on(
+          "jobCompleted",
+          (job, result) => {
+            if (job.jobId === jobId) {
+              unsubscribe();
+              unsubscribeError();
+              resolve(result);
+            }
+          }
+        );
+        const unsubscribeError = this.queueManager.on(
+          "jobFailed",
+          (job, error) => {
+            if (job.jobId === jobId) {
+              unsubscribe();
+              unsubscribeError();
+              reject(error);
+            }
+          }
+        );
+      });
+    } catch (error) {
+      logger.error("Error adding job", error);
+      throw error;
+    }
+  }
+  async queueDriveAction(drive, action, options2) {
+    return this.queueDriveActions(drive, [action], options2);
+  }
+  async queueDriveActions(drive, actions2, options2) {
+    try {
+      const jobId = await this.queueManager.addJob({
+        driveId: drive,
+        actions: actions2,
+        options: options2
+      });
+      return new Promise(
+        (resolve, reject) => {
+          const unsubscribe = this.queueManager.on(
+            "jobCompleted",
+            (job, result) => {
+              if (job.jobId === jobId) {
+                unsubscribe();
+                unsubscribeError();
+                resolve(result);
+              }
+            }
+          );
+          const unsubscribeError = this.queueManager.on(
+            "jobFailed",
+            (job, error) => {
+              if (job.jobId === jobId) {
+                unsubscribe();
+                unsubscribeError();
+                reject(error);
+              }
+            }
+          );
+        }
+      );
+    } catch (error) {
+      logger.error("Error adding drive job", error);
+      throw error;
+    }
+  }
+  async addOperations(drive, id, operations, options2) {
+    const result = await this.resultIfExistingOperations(drive, id, operations);
+    if (result) {
+      return result;
+    }
+    let document;
+    const operationsApplied = [];
+    const signals = [];
+    let error;
+    try {
+      await this._addOperations(drive, id, async (documentStorage) => {
+        const result2 = await this._processOperations(
+          drive,
+          id,
+          documentStorage,
+          operations
+        );
+        if (!result2.document) {
+          logger.error("Invalid document");
+          throw result2.error ?? new Error("Invalid document");
+        }
+        document = result2.document;
+        error = result2.error;
+        signals.push(...result2.signals);
+        operationsApplied.push(...result2.operationsApplied);
+        return {
+          operations: result2.operationsApplied,
+          header: result2.document,
+          newState: document.state
+        };
+      });
+      if (document) {
+        this.cache.setDocument(drive, id, document).catch(logger.error);
+      }
+      const { scopes, branches } = operationsApplied.reduce(
+        (acc, operation) => {
+          if (!acc.scopes.includes(operation.scope)) {
+            acc.scopes.push(operation.scope);
+          }
+          return acc;
+        },
+        { scopes: [], branches: ["main"] }
+      );
+      const syncUnits = await this.getSynchronizationUnits(
+        drive,
+        [id],
+        scopes,
+        branches
+      );
+      const newOp = operationsApplied.find(
+        (appliedOp) => !operations.find(
+          (o) => o.id === appliedOp.id && o.index === appliedOp.index && o.skip === appliedOp.skip && o.hash === appliedOp.hash
+        )
+      );
+      const source = newOp ? { type: "local" } : options2?.source ?? { type: "local" };
+      const operationSource = this.getOperationSource(source);
+      this.listenerStateManager.updateSynchronizationRevisions(
+        drive,
+        syncUnits,
+        source,
+        () => {
+          this.updateSyncUnitStatus(drive, {
+            [operationSource]: "SYNCING"
+          });
+          for (const syncUnit of syncUnits) {
+            this.updateSyncUnitStatus(syncUnit.syncId, {
+              [operationSource]: "SYNCING"
+            });
+          }
+        },
+        this.handleListenerError.bind(this),
+        options2?.forceSync ?? source.type === "local"
+      ).then((updates) => {
+        if (updates.length) {
+          this.updateSyncUnitStatus(drive, {
+            [operationSource]: "SUCCESS"
+          });
+        }
+        for (const syncUnit of syncUnits) {
+          this.updateSyncUnitStatus(syncUnit.syncId, {
+            [operationSource]: "SUCCESS"
+          });
+        }
+      }).catch((error2) => {
+        logger.error("Non handled error updating sync revision", error2);
+        this.updateSyncUnitStatus(
+          drive,
+          {
+            [operationSource]: "ERROR"
+          },
+          error2
+        );
+        for (const syncUnit of syncUnits) {
+          this.updateSyncUnitStatus(
+            syncUnit.syncId,
+            {
+              [operationSource]: "ERROR"
+            },
+            error2
+          );
+        }
+      });
+      if (error) {
+        throw error;
+      }
+      return {
+        status: "SUCCESS",
+        document,
+        operations: operationsApplied,
+        signals
+      };
+    } catch (error2) {
+      const operationError = error2 instanceof OperationError ? error2 : new OperationError(
+        "ERROR",
+        void 0,
+        error2.message,
+        error2.cause
+      );
+      return {
+        status: operationError.status,
+        error: operationError,
+        document,
+        operations: operationsApplied,
+        signals
+      };
+    }
+  }
+  addDriveOperation(drive, operation, options2) {
+    return this.addDriveOperations(drive, [operation], options2);
+  }
+  async clearStorage() {
+    for (const drive of await this.getDrives()) {
+      await this.deleteDrive(drive);
+    }
+    await this.storage.clearStorage?.();
+  }
+  async _addDriveOperations(drive, callback) {
+    if (!this.storage.addDriveOperationsWithTransaction) {
+      const documentStorage = await this.storage.getDrive(drive);
+      const result = await callback(documentStorage);
+      if (result.operations.length > 0) {
+        await this.storage.addDriveOperations(
+          drive,
+          result.operations,
+          result.header
+        );
+      }
+      return result;
+    } else {
+      return this.storage.addDriveOperationsWithTransaction(drive, callback);
+    }
+  }
+  queueDriveOperation(drive, operation, options2) {
+    return this.queueDriveOperations(drive, [operation], options2);
+  }
+  async resultIfExistingDriveOperations(driveId, operations) {
+    try {
+      const drive = await this.getDrive(driveId);
+      const newOperation = operations.find(
+        (op) => !op.id || !drive.operations[op.scope].find(
+          (existingOp) => existingOp.id === op.id && existingOp.index === op.index && existingOp.type === op.type && existingOp.hash === op.hash
+        )
+      );
+      if (!newOperation) {
+        return {
+          status: "SUCCESS",
+          document: drive,
+          operations,
+          signals: []
+        };
+      } else {
+        return void 0;
+      }
+    } catch (error) {
+      console.error(error);
+      return void 0;
+    }
+  }
+  async queueDriveOperations(drive, operations, options2) {
+    const result = await this.resultIfExistingDriveOperations(
+      drive,
+      operations
+    );
+    if (result) {
+      return result;
+    }
+    try {
+      const jobId = await this.queueManager.addJob({
+        driveId: drive,
+        operations,
+        options: options2
+      });
+      return new Promise(
+        (resolve, reject) => {
+          const unsubscribe = this.queueManager.on(
+            "jobCompleted",
+            (job, result2) => {
+              if (job.jobId === jobId) {
+                unsubscribe();
+                unsubscribeError();
+                resolve(result2);
+              }
+            }
+          );
+          const unsubscribeError = this.queueManager.on(
+            "jobFailed",
+            (job, error) => {
+              if (job.jobId === jobId) {
+                unsubscribe();
+                unsubscribeError();
+                reject(error);
+              }
+            }
+          );
+        }
+      );
+    } catch (error) {
+      logger.error("Error adding drive job", error);
+      throw error;
+    }
+  }
+  async addDriveOperations(drive, operations, options2) {
+    let document;
+    const operationsApplied = [];
+    const signals = [];
+    let error;
+    const result = await this.resultIfExistingDriveOperations(
+      drive,
+      operations
+    );
+    if (result) {
+      return result;
+    }
+    try {
+      await this._addDriveOperations(drive, async (documentStorage) => {
+        const result2 = await this._processOperations(drive, void 0, documentStorage, operations.slice());
+        document = result2.document;
+        operationsApplied.push(...result2.operationsApplied);
+        signals.push(...result2.signals);
+        error = result2.error;
+        return {
+          operations: result2.operationsApplied,
+          header: result2.document
+        };
+      });
+      if (!document || !isDocumentDrive(document)) {
+        throw error ?? new Error("Invalid Document Drive document");
+      }
+      this.cache.setDocument("drives", drive, document).catch(logger.error);
+      for (const operation of operationsApplied) {
+        switch (operation.type) {
+          case "ADD_LISTENER": {
+            await this.addListener(drive, operation);
+            break;
+          }
+          case "REMOVE_LISTENER": {
+            await this.removeListener(drive, operation);
+            break;
+          }
+        }
+      }
+      const lastOperation = operationsApplied.filter((op) => op.scope === "global").slice().pop();
+      if (lastOperation) {
+        const newOp = operationsApplied.find(
+          (appliedOp) => !operations.find(
+            (o) => o.id === appliedOp.id && o.index === appliedOp.index && o.skip === appliedOp.skip && o.hash === appliedOp.hash
+          )
+        );
+        const source = newOp ? { type: "local" } : options2?.source ?? { type: "local" };
+        const operationSource = this.getOperationSource(source);
+        this.listenerStateManager.updateSynchronizationRevisions(
+          drive,
+          [
+            {
+              syncId: "0",
+              driveId: drive,
+              documentId: "",
+              scope: "global",
+              branch: "main",
+              documentType: "powerhouse/document-drive",
+              lastUpdated: lastOperation.timestamp,
+              revision: lastOperation.index
+            }
+          ],
+          source,
+          () => {
+            this.updateSyncUnitStatus(drive, {
+              [operationSource]: "SYNCING"
+            });
+          },
+          this.handleListenerError.bind(this),
+          options2?.forceSync ?? source.type === "local"
+        ).then((updates) => {
+          if (updates.length) {
+            this.updateSyncUnitStatus(drive, {
+              [operationSource]: "SUCCESS"
+            });
+          }
+        }).catch((error2) => {
+          logger.error("Non handled error updating sync revision", error2);
+          this.updateSyncUnitStatus(
+            drive,
+            { [operationSource]: "ERROR" },
+            error2
+          );
+        });
+      }
+      if (this.shouldSyncRemoteDrive(document)) {
+        this.startSyncRemoteDrive(document.state.global.id);
+      } else {
+        this.stopSyncRemoteDrive(document.state.global.id);
+      }
+      if (error) {
+        throw error;
+      }
+      return {
+        status: "SUCCESS",
+        document,
+        operations: operationsApplied,
+        signals
+      };
+    } catch (error2) {
+      const operationError = error2 instanceof OperationError ? error2 : new OperationError(
+        "ERROR",
+        void 0,
+        error2.message,
+        error2.cause
+      );
+      return {
+        status: operationError.status,
+        error: operationError,
+        document,
+        operations: operationsApplied,
+        signals
+      };
+    }
+  }
+  _buildOperations(document, actions2) {
+    const operations = [];
+    const { reducer } = this.getDocumentModel(document.documentType);
+    for (const action of actions2) {
+      document = reducer(document, action);
+      const operation = document.operations[action.scope].slice().pop();
+      if (!operation) {
+        throw new Error("Error creating operations");
+      }
+      operations.push(operation);
+    }
+    return operations;
+  }
+  async addAction(drive, id, action, options2) {
+    return this.addActions(drive, id, [action], options2);
+  }
+  async addActions(drive, id, actions2, options2) {
+    const document = await this.getDocument(drive, id);
+    const operations = this._buildOperations(document, actions2);
+    return this.addOperations(drive, id, operations, options2);
+  }
+  async addDriveAction(drive, action, options2) {
+    return this.addDriveActions(drive, [action], options2);
+  }
+  async addDriveActions(drive, actions2, options2) {
+    const document = await this.getDrive(drive);
+    const operations = this._buildOperations(document, actions2);
+    const result = await this.addDriveOperations(drive, operations, options2);
+    return result;
+  }
+  async addInternalListener(driveId, receiver, options2) {
+    const listener = {
+      callInfo: {
+        data: "",
+        name: "Interal",
+        transmitterType: "Internal"
+      },
+      system: true,
+      ...options2
+    };
+    await this.addDriveAction(driveId, actions.addListener({ listener }));
+    const transmitter = await this.getTransmitter(driveId, options2.listenerId);
+    if (!transmitter) {
+      logger.error("Internal listener not found");
+      throw new Error("Internal listener not found");
+    }
+    if (!(transmitter instanceof InternalTransmitter)) {
+      logger.error("Listener is not an internal transmitter");
+      throw new Error("Listener is not an internal transmitter");
+    }
+    transmitter.setReceiver(receiver);
+    return transmitter;
+  }
+  async detachDrive(driveId) {
+    const documentDrive = await this.getDrive(driveId);
+    const listeners = documentDrive.state.local.listeners || [];
+    const triggers = documentDrive.state.local.triggers || [];
+    for (const listener of listeners) {
+      await this.addDriveAction(
+        driveId,
+        actions.removeListener({ listenerId: listener.listenerId })
+      );
+    }
+    for (const trigger of triggers) {
+      await this.addDriveAction(
+        driveId,
+        actions.removeTrigger({ triggerId: trigger.id })
+      );
+    }
+    await this.addDriveAction(
+      driveId,
+      actions.setSharingType({ type: "LOCAL" })
+    );
+  }
+  async addListener(driveId, operation) {
+    const { listener } = operation.input;
+    await this.listenerStateManager.addListener({
+      ...listener,
+      driveId,
+      label: listener.label ?? "",
+      system: listener.system ?? false,
+      filter: {
+        branch: listener.filter.branch ?? [],
+        documentId: listener.filter.documentId ?? [],
+        documentType: listener.filter.documentType ?? [],
+        scope: listener.filter.scope ?? []
+      },
+      callInfo: {
+        data: listener.callInfo?.data ?? "",
+        name: listener.callInfo?.name ?? "PullResponder",
+        transmitterType: listener.callInfo?.transmitterType ?? "PullResponder"
+      }
+    });
+  }
+  async removeListener(driveId, operation) {
+    const { listenerId } = operation.input;
+    await this.listenerStateManager.removeListener(driveId, listenerId);
+  }
+  getTransmitter(driveId, listenerId) {
+    return this.listenerStateManager.getTransmitter(driveId, listenerId);
+  }
+  getListener(driveId, listenerId) {
+    return this.listenerStateManager.getListener(driveId, listenerId);
+  }
+  getSyncStatus(syncUnitId) {
+    const status = this.syncStatus.get(syncUnitId);
+    if (!status) {
+      return new SynchronizationUnitNotFoundError(
+        `Sync status not found for syncUnitId: ${syncUnitId}`,
+        syncUnitId
+      );
+    }
+    return this.getCombinedSyncUnitStatus(status);
+  }
+  on(event, cb) {
+    return this.emitter.on(event, cb);
+  }
+  emit(event, ...args) {
+    return this.emitter.emit(event, ...args);
+  }
+};
+var DocumentDriveServer = ReadModeServer(BaseDocumentDriveServer);
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+var FilesystemStorage = class _FilesystemStorage {
+  basePath;
+  drivesPath;
+  static DRIVES_DIR = "drives";
+  constructor(basePath) {
+    this.basePath = basePath;
+    ensureDir(this.basePath);
+    this.drivesPath = path2.join(this.basePath, _FilesystemStorage.DRIVES_DIR);
+    ensureDir(this.drivesPath);
+  }
+  _buildDocumentPath(...args) {
+    return `${path2.join(
+      this.basePath,
+      ...args.map((arg) => sanitize(arg))
+    )}.json`;
+  }
+  async getDocuments(drive) {
+    let files = [];
+    try {
+      files = readdirSync(path2.join(this.basePath, drive), {
+        withFileTypes: true
+      });
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const documents = [];
+    for (const file of files.filter((file2) => file2.isFile())) {
+      try {
+        const documentId = path2.parse(file.name).name;
+        await this.getDocument(drive, documentId);
+        documents.push(documentId);
+      } catch {
+      }
+    }
+    return documents;
+  }
+  checkDocumentExists(drive, id) {
+    const documentExists = existsSync(this._buildDocumentPath(drive, id));
+    return Promise.resolve(documentExists);
+  }
+  async getDocument(drive, id) {
+    try {
+      const content = readFileSync(this._buildDocumentPath(drive, id), {
+        encoding: "utf-8"
+      });
+      return JSON.parse(content);
+    } catch (error) {
+      throw new Error(`Document with id ${id} not found`);
+    }
+  }
+  async createDocument(drive, id, document) {
+    const documentPath = this._buildDocumentPath(drive, id);
+    ensureDir(path2.dirname(documentPath));
+    writeFileSync(documentPath, stringify(document), {
+      encoding: "utf-8"
+    });
+    return Promise.resolve();
+  }
+  async clearStorage() {
+    const drivesPath = path2.join(this.basePath, _FilesystemStorage.DRIVES_DIR);
+    const drives = (await fs.readdir(drivesPath, {
+      withFileTypes: true,
+      recursive: true
+    })).filter((dirent) => !!dirent.name);
+    await Promise.all(
+      drives.map(async (dirent) => {
+        await fs.rm(path2.join(drivesPath, dirent.name), {
+          recursive: true
+        });
+      })
+    );
+    const files = (await fs.readdir(this.basePath, { withFileTypes: true })).filter(
+      (file) => file.name !== _FilesystemStorage.DRIVES_DIR && !!file.name
+    );
+    await Promise.all(
+      files.map(async (dirent) => {
+        await fs.rm(path2.join(this.basePath, dirent.name), {
+          recursive: true
+        });
+      })
+    );
+  }
+  async deleteDocument(drive, id) {
+    return fs.rm(this._buildDocumentPath(drive, id));
+  }
+  async addDocumentOperations(drive, id, operations, header) {
+    const document = await this.getDocument(drive, id);
+    if (!document) {
+      throw new Error(`Document with id ${id} not found`);
+    }
+    const mergedOperations = mergeOperations(document.operations, operations);
+    await this.createDocument(drive, id, {
+      ...document,
+      ...header,
+      operations: mergedOperations
+    });
+  }
+  async getDrives() {
+    const files = readdirSync(this.drivesPath, {
+      withFileTypes: true
+    });
+    const drives = [];
+    for (const file of files.filter((file2) => file2.isFile())) {
+      try {
+        const driveId = path2.parse(file.name).name;
+        await this.getDrive(driveId);
+        drives.push(driveId);
+      } catch {
+      }
+    }
+    return drives;
+  }
+  async getDrive(id) {
+    try {
+      return await this.getDocument(
+        _FilesystemStorage.DRIVES_DIR,
+        id
+      );
+    } catch {
+      throw new DriveNotFoundError(id);
+    }
+  }
+  async getDriveBySlug(slug) {
+    const drives = (await this.getDrives()).reverse();
+    for (const drive of drives) {
+      const {
+        initialState: {
+          state: {
+            global: { slug: driveSlug }
+          }
+        }
+      } = await this.getDrive(drive);
+      if (driveSlug === slug) {
+        return this.getDrive(drive);
+      }
+    }
+    throw new Error(`Drive with slug ${slug} not found`);
+  }
+  createDrive(id, drive) {
+    return this.createDocument(_FilesystemStorage.DRIVES_DIR, id, drive);
+  }
+  async deleteDrive(id) {
+    const documents = await this.getDocuments(id);
+    await this.deleteDocument(_FilesystemStorage.DRIVES_DIR, id);
+    await Promise.all(
+      documents.map((document) => this.deleteDocument(id, document))
+    );
+  }
+  async addDriveOperations(id, operations, header) {
+    const drive = await this.getDrive(id);
+    const mergedOperations = mergeOperations(drive.operations, operations);
+    await this.createDrive(id, {
+      ...drive,
+      ...header,
+      operations: mergedOperations
+    });
+  }
+  async getSynchronizationUnitsRevision(units) {
+    const results = await Promise.allSettled(
+      units.map(async (unit) => {
+        try {
+          const document = await (unit.documentId ? this.getDocument(unit.driveId, unit.documentId) : this.getDrive(unit.driveId));
+          if (!document) {
+            return void 0;
+          }
+          const operation = document.operations[unit.scope].at(-1);
+          if (operation) {
+            return {
+              driveId: unit.driveId,
+              documentId: unit.documentId,
+              scope: unit.scope,
+              branch: unit.branch,
+              lastUpdated: operation.timestamp,
+              revision: operation.index
+            };
+          }
+        } catch {
+          return void 0;
+        }
+      })
+    );
+    return results.reduce((acc, curr) => {
+      if (curr.status === "fulfilled" && curr.value !== void 0) {
+        acc.push(curr.value);
+      }
+      return acc;
+    }, []);
+  }
+};
+dotenv.config();
+var driveServer = new DocumentDriveServer(
+  [module, ...Object.values(DocumentModelsLibs)],
+  new FilesystemStorage(path2.join(__dirname, "../file-storage"))
+);
+var serverPort = process.env.PORT ? Number(process.env.PORT) : 4001;
+var startServer = async () => {
+  const db = await drizzle("pglite", "./dev.db");
+  await driveServer.initialize();
+  try {
+    await driveServer.addDrive({
+      global: {
+        id: "powerhouse",
+        name: "Powerhouse",
+        icon: "powerhouse",
+        slug: "powerhouse"
+      },
+      local: {
+        availableOffline: true,
+        listeners: [],
+        sharingType: "public",
+        triggers: []
+      }
+    });
+  } catch (e) {
+    console.info("Default drive already exists. Skipping...");
+  }
+  try {
+    await startAPI(driveServer, {
+      port: serverPort
+    });
+    setAdditionalContextFields({ db });
+    await registerInternalListener({
+      name: "search",
+      options: searchListener.options,
+      transmit: (strands) => searchListener.transmit(strands, db)
+    });
+    await addSubgraph({
+      getSchema: () => createSchema(
+        driveServer,
+        searchListener.resolvers,
+        searchListener.typeDefs
+      ),
+      name: "search/:drive"
+    });
+  } catch (e) {
+    console.error("App crashed", e);
+  }
+};
+
+export { startServer };