@powerhousedao/connect 6.0.0-dev.77 → 6.0.0-dev.78

package/dist/src/store/index.js

@@ -4499,7 +4499,7 @@ var init_package = __esm(() => {
   package_default = {
     name: "@powerhousedao/connect",
     productName: "Powerhouse-Connect",
-    version: "6.0.0-dev.76",
+    version: "6.0.0-dev.77",
     description: "Powerhouse Connect",
     main: "dist/index.html",
     type: "module",
@@ -13587,14 +13587,14 @@ class BaseReadModel {
   operationIndex;
   writeCache;
   consistencyTracker;
-  readModelId;
+  config;
   lastOrdinal = 0;
-  constructor(db, operationIndex, writeCache, consistencyTracker, readModelId) {
+  constructor(db, operationIndex, writeCache, consistencyTracker, config) {
     this.db = db;
     this.operationIndex = operationIndex;
     this.writeCache = writeCache;
     this.consistencyTracker = consistencyTracker;
-    this.readModelId = readModelId;
+    this.config = config;
   }
   async init() {
     const viewState = await this.loadState();
@@ -13602,21 +13602,22 @@ class BaseReadModel {
       this.lastOrdinal = viewState;
       const missedOperations = await this.operationIndex.getSinceOrdinal(this.lastOrdinal);
       if (missedOperations.results.length > 0) {
-        const opsWithState = await this.rebuildStateForOperations(missedOperations.results);
-        await this.indexOperations(opsWithState);
+        const ops = this.config.rebuildStateOnInit ? await this.rebuildStateForOperations(missedOperations.results) : missedOperations.results;
+        await this.indexOperations(ops);
       }
     } else {
       await this.initializeState();
       const allOperations = await this.operationIndex.getSinceOrdinal(0);
       if (allOperations.results.length > 0) {
-        const opsWithState = await this.rebuildStateForOperations(allOperations.results);
-        await this.indexOperations(opsWithState);
+        const ops = this.config.rebuildStateOnInit ? await this.rebuildStateForOperations(allOperations.results) : allOperations.results;
+        await this.indexOperations(ops);
       }
     }
   }
   async indexOperations(items) {
     if (items.length === 0)
       return;
+    await this.commitOperations(items);
     await this.db.transaction().execute(async (trx) => {
       await this.saveState(trx, items);
     });
@@ -13628,6 +13629,7 @@ class BaseReadModel {
     }
     await this.consistencyTracker.waitFor(token.coordinates, timeoutMs, signal);
   }
+  async commitOperations(items) {}
   async rebuildStateForOperations(operations) {
     const result = [];
     for (const op of operations) {
@@ -13646,13 +13648,13 @@ class BaseReadModel {
   }
   async loadState() {
     const viewStateDb = this.db;
-    const row = await viewStateDb.selectFrom("ViewState").select("lastOrdinal").where("readModelId", "=", this.readModelId).executeTakeFirst();
+    const row = await viewStateDb.selectFrom("ViewState").select("lastOrdinal").where("readModelId", "=", this.config.readModelId).executeTakeFirst();
     return row?.lastOrdinal;
   }
   async initializeState() {
     const viewStateDb = this.db;
     await viewStateDb.insertInto("ViewState").values({
-      readModelId: this.readModelId,
+      readModelId: this.config.readModelId,
       lastOrdinal: 0
     }).execute();
   }
@@ -13662,7 +13664,7 @@ class BaseReadModel {
     await trx.updateTable("ViewState").set({
       lastOrdinal: maxOrdinal,
       lastOperationTimestamp: new Date
-    }).where("readModelId", "=", this.readModelId).execute();
+    }).where("readModelId", "=", this.config.readModelId).execute();
   }
   updateConsistencyTracker(items) {
     const coordinates = [];
@@ -14387,6 +14389,661 @@ class ConsistencyTracker {
     }
   }
 }
+async function collectAllPages(firstPage, signal) {
+  const allResults = [...firstPage.results];
+  let currentPage = firstPage;
+  while (currentPage.next) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    currentPage = await currentPage.next();
+    allResults.push(...currentPage.results);
+  }
+  return allResults;
+}
+
+class KyselyKeyframeStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async putKeyframe(documentId, scope, branch, revision, document2, signal) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    await this.db.insertInto("Keyframe").values({
+      documentId,
+      documentType: document2.header.documentType,
+      scope,
+      branch,
+      revision,
+      document: document2
+    }).onConflict((oc) => oc.columns(["documentId", "scope", "branch", "revision"]).doUpdateSet({ document: document2 })).execute();
+  }
+  async findNearestKeyframe(documentId, scope, branch, targetRevision, signal) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    const row = await this.db.selectFrom("Keyframe").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("revision", "<=", targetRevision).orderBy("revision", "desc").limit(1).executeTakeFirst();
+    if (!row) {
+      return;
+    }
+    return {
+      revision: row.revision,
+      document: row.document
+    };
+  }
+  async deleteKeyframes(documentId, scope, branch, signal) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    let query = this.db.deleteFrom("Keyframe").where("documentId", "=", documentId);
+    if (scope !== undefined && branch !== undefined) {
+      query = query.where("scope", "=", scope).where("branch", "=", branch);
+    } else if (scope !== undefined) {
+      query = query.where("scope", "=", scope);
+    }
+    const result = await query.executeTakeFirst();
+    return Number(result.numDeletedRows || 0n);
+  }
+}
+
+class AtomicTransaction {
+  documentId;
+  documentType;
+  scope;
+  branch;
+  baseRevision;
+  operations = [];
+  constructor(documentId, documentType, scope, branch, baseRevision) {
+    this.documentId = documentId;
+    this.documentType = documentType;
+    this.scope = scope;
+    this.branch = branch;
+    this.baseRevision = baseRevision;
+  }
+  addOperations(...operations) {
+    for (const op of operations) {
+      this.operations.push({
+        jobId: v4_default(),
+        opId: op.id,
+        prevOpId: "",
+        documentId: this.documentId,
+        documentType: this.documentType,
+        scope: this.scope,
+        branch: this.branch,
+        timestampUtcMs: new Date(op.timestampUtcMs),
+        index: op.index,
+        action: JSON.stringify(op.action),
+        skip: op.skip,
+        error: op.error || null,
+        hash: op.hash
+      });
+    }
+  }
+  getOperations() {
+    return this.operations;
+  }
+}
+
+class KyselyOperationStore {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async apply(documentId, documentType, scope, branch, revision, fn, signal) {
+    await this.db.transaction().execute(async (trx) => {
+      if (signal?.aborted) {
+        throw new Error("Operation aborted");
+      }
+      const latestOp = await trx.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).orderBy("index", "desc").limit(1).executeTakeFirst();
+      const currentRevision = latestOp ? latestOp.index : -1;
+      if (currentRevision !== revision - 1) {
+        throw new RevisionMismatchError(currentRevision + 1, revision);
+      }
+      const atomicTxn = new AtomicTransaction(documentId, documentType, scope, branch, revision);
+      await fn(atomicTxn);
+      const operations = atomicTxn.getOperations();
+      if (operations.length > 0) {
+        let prevOpId = latestOp?.opId || "";
+        for (const op of operations) {
+          op.prevOpId = prevOpId;
+          prevOpId = op.opId;
+        }
+        try {
+          await trx.insertInto("Operation").values(operations).execute();
+        } catch (error) {
+          if (error instanceof Error) {
+            if (error.message.includes("unique constraint")) {
+              const op = operations[0];
+              throw new DuplicateOperationError(`${op.opId} at index ${op.index} with skip ${op.skip}`);
+            }
+            throw error;
+          }
+          throw error;
+        }
+      }
+    });
+  }
+  async getSince(documentId, scope, branch, revision, filter, paging, signal) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    let query = this.db.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("index", ">", revision).orderBy("index", "asc");
+    if (filter) {
+      if (filter.actionTypes && filter.actionTypes.length > 0) {
+        const actionTypesArray = filter.actionTypes.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
+        query = query.where(sql`action->>'type' = ANY(ARRAY[${sql.raw(actionTypesArray)}]::text[])`);
+      }
+      if (filter.timestampFrom) {
+        query = query.where("timestampUtcMs", ">=", new Date(filter.timestampFrom));
+      }
+      if (filter.timestampTo) {
+        query = query.where("timestampUtcMs", "<=", new Date(filter.timestampTo));
+      }
+      if (filter.sinceRevision !== undefined) {
+        query = query.where("index", ">=", filter.sinceRevision);
+      }
+    }
+    if (paging) {
+      const cursorValue = Number.parseInt(paging.cursor, 10);
+      if (cursorValue > 0) {
+        query = query.where("index", ">", cursorValue);
+      }
+      if (paging.limit) {
+        query = query.limit(paging.limit + 1);
+      }
+    }
+    const rows = await query.execute();
+    let hasMore = false;
+    let items = rows;
+    if (paging?.limit && rows.length > paging.limit) {
+      hasMore = true;
+      items = rows.slice(0, paging.limit);
+    }
+    const nextCursor = hasMore && items.length > 0 ? items[items.length - 1].index.toString() : undefined;
+    const cursor = paging?.cursor || "0";
+    const limit = paging?.limit || 100;
+    const operations = items.map((row) => this.rowToOperation(row));
+    return {
+      results: operations,
+      options: { cursor, limit },
+      nextCursor,
+      next: hasMore ? () => this.getSince(documentId, scope, branch, revision, filter, { cursor: nextCursor, limit }, signal) : undefined
+    };
+  }
+  async getSinceId(id, paging, signal) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    let query = this.db.selectFrom("Operation").selectAll().where("id", ">", id).orderBy("id", "asc");
+    if (paging) {
+      const cursorValue = Number.parseInt(paging.cursor, 10);
+      if (cursorValue > 0) {
+        query = query.where("id", ">", cursorValue);
+      }
+      if (paging.limit) {
+        query = query.limit(paging.limit + 1);
+      }
+    }
+    const rows = await query.execute();
+    let hasMore = false;
+    let items = rows;
+    if (paging?.limit && rows.length > paging.limit) {
+      hasMore = true;
+      items = rows.slice(0, paging.limit);
+    }
+    const nextCursor = hasMore && items.length > 0 ? items[items.length - 1].id.toString() : undefined;
+    const cursor = paging?.cursor || "0";
+    const limit = paging?.limit || 100;
+    const operations = items.map((row) => this.rowToOperationWithContext(row));
+    return {
+      results: operations,
+      options: { cursor, limit },
+      nextCursor,
+      next: hasMore ? () => this.getSinceId(id, { cursor: nextCursor, limit }, signal) : undefined
+    };
+  }
+  async getConflicting(documentId, scope, branch, minTimestamp, paging, signal) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    let query = this.db.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("timestampUtcMs", ">=", new Date(minTimestamp)).orderBy("index", "asc");
+    if (paging) {
+      const cursorValue = Number.parseInt(paging.cursor, 10);
+      if (cursorValue > 0) {
+        query = query.where("index", ">", cursorValue);
+      }
+      if (paging.limit) {
+        query = query.limit(paging.limit + 1);
+      }
+    }
+    const rows = await query.execute();
+    let hasMore = false;
+    let items = rows;
+    if (paging?.limit && rows.length > paging.limit) {
+      hasMore = true;
+      items = rows.slice(0, paging.limit);
+    }
+    const nextCursor = hasMore && items.length > 0 ? items[items.length - 1].index.toString() : undefined;
+    const cursor = paging?.cursor || "0";
+    const limit = paging?.limit || 100;
+    const operations = items.map((row) => this.rowToOperation(row));
+    return {
+      results: operations,
+      options: { cursor, limit },
+      nextCursor,
+      next: hasMore ? () => this.getConflicting(documentId, scope, branch, minTimestamp, { cursor: nextCursor, limit }, signal) : undefined
+    };
+  }
+  async getRevisions(documentId, branch, signal) {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+    const scopeRevisions = await this.db.selectFrom("Operation as o1").select(["o1.scope", "o1.index", "o1.timestampUtcMs"]).where("o1.documentId", "=", documentId).where("o1.branch", "=", branch).where((eb) => eb("o1.index", "=", eb.selectFrom("Operation as o2").select((eb2) => eb2.fn.max("o2.index").as("maxIndex")).where("o2.documentId", "=", eb.ref("o1.documentId")).where("o2.branch", "=", eb.ref("o1.branch")).where("o2.scope", "=", eb.ref("o1.scope")))).execute();
+    const revision = {};
+    let latestTimestamp = new Date(0).toISOString();
+    for (const row of scopeRevisions) {
+      revision[row.scope] = row.index + 1;
+      const timestamp = row.timestampUtcMs.toISOString();
+      if (timestamp > latestTimestamp) {
+        latestTimestamp = timestamp;
+      }
+    }
+    return {
+      revision,
+      latestTimestamp
+    };
+  }
+  rowToOperation(row) {
+    return {
+      index: row.index,
+      timestampUtcMs: row.timestampUtcMs.toISOString(),
+      hash: row.hash,
+      skip: row.skip,
+      error: row.error || undefined,
+      id: row.opId,
+      action: row.action
+    };
+  }
+  rowToOperationWithContext(row) {
+    return {
+      operation: this.rowToOperation(row),
+      context: {
+        documentId: row.documentId,
+        documentType: row.documentType,
+        scope: row.scope,
+        branch: row.branch,
+        ordinal: row.id
+      }
+    };
+  }
+}
+async function up(db) {
+  await db.schema.createTable("Operation").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("jobId", "text", (col) => col.notNull()).addColumn("opId", "text", (col) => col.notNull()).addColumn("prevOpId", "text", (col) => col.notNull()).addColumn("writeTimestampUtcMs", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("documentId", "text", (col) => col.notNull()).addColumn("documentType", "text", (col) => col.notNull()).addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("timestampUtcMs", "timestamptz", (col) => col.notNull()).addColumn("index", "integer", (col) => col.notNull()).addColumn("action", "jsonb", (col) => col.notNull()).addColumn("skip", "integer", (col) => col.notNull()).addColumn("error", "text").addColumn("hash", "text", (col) => col.notNull()).addUniqueConstraint("unique_revision", [
+    "documentId",
+    "scope",
+    "branch",
+    "index"
+  ]).addUniqueConstraint("unique_operation_instance", ["opId", "index", "skip"]).execute();
+  await db.schema.createIndex("streamOperations").on("Operation").columns(["documentId", "scope", "branch", "id"]).execute();
+  await db.schema.createIndex("branchlessStreamOperations").on("Operation").columns(["documentId", "scope", "id"]).execute();
+}
+async function up2(db) {
+  await db.schema.createTable("Keyframe").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("documentId", "text", (col) => col.notNull()).addColumn("documentType", "text", (col) => col.notNull()).addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("revision", "integer", (col) => col.notNull()).addColumn("document", "jsonb", (col) => col.notNull()).addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addUniqueConstraint("unique_keyframe", [
+    "documentId",
+    "scope",
+    "branch",
+    "revision"
+  ]).execute();
+  await db.schema.createIndex("keyframe_lookup").on("Keyframe").columns(["documentId", "scope", "branch", "revision"]).execute();
+}
+async function up3(db) {
+  await db.schema.createTable("Document").addColumn("id", "text", (col) => col.primaryKey()).addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+}
+async function up4(db) {
+  await db.schema.createTable("DocumentRelationship").addColumn("id", "text", (col) => col.primaryKey()).addColumn("sourceId", "text", (col) => col.notNull().references("Document.id").onDelete("cascade")).addColumn("targetId", "text", (col) => col.notNull().references("Document.id").onDelete("cascade")).addColumn("relationshipType", "text", (col) => col.notNull()).addColumn("metadata", "jsonb").addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addUniqueConstraint("unique_source_target_type", [
+    "sourceId",
+    "targetId",
+    "relationshipType"
+  ]).execute();
+  await db.schema.createIndex("idx_relationship_source").on("DocumentRelationship").column("sourceId").execute();
+  await db.schema.createIndex("idx_relationship_target").on("DocumentRelationship").column("targetId").execute();
+  await db.schema.createIndex("idx_relationship_type").on("DocumentRelationship").column("relationshipType").execute();
+}
+async function up5(db) {
+  await db.schema.createTable("IndexerState").addColumn("id", "integer", (col) => col.primaryKey().generatedAlwaysAsIdentity()).addColumn("lastOperationId", "integer", (col) => col.notNull()).addColumn("lastOperationTimestamp", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+}
+async function up6(db) {
+  await db.schema.createTable("DocumentSnapshot").addColumn("id", "text", (col) => col.primaryKey()).addColumn("documentId", "text", (col) => col.notNull()).addColumn("slug", "text").addColumn("name", "text").addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("content", "jsonb", (col) => col.notNull()).addColumn("documentType", "text", (col) => col.notNull()).addColumn("lastOperationIndex", "integer", (col) => col.notNull()).addColumn("lastOperationHash", "text", (col) => col.notNull()).addColumn("lastUpdatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("snapshotVersion", "integer", (col) => col.notNull().defaultTo(1)).addColumn("identifiers", "jsonb").addColumn("metadata", "jsonb").addColumn("isDeleted", "boolean", (col) => col.notNull().defaultTo(false)).addColumn("deletedAt", "timestamptz").addUniqueConstraint("unique_doc_scope_branch", [
+    "documentId",
+    "scope",
+    "branch"
+  ]).execute();
+  await db.schema.createIndex("idx_slug_scope_branch").on("DocumentSnapshot").columns(["slug", "scope", "branch"]).execute();
+  await db.schema.createIndex("idx_doctype_scope_branch").on("DocumentSnapshot").columns(["documentType", "scope", "branch"]).execute();
+  await db.schema.createIndex("idx_last_updated").on("DocumentSnapshot").column("lastUpdatedAt").execute();
+  await db.schema.createIndex("idx_is_deleted").on("DocumentSnapshot").column("isDeleted").execute();
+}
+async function up7(db) {
+  await db.schema.createTable("SlugMapping").addColumn("slug", "text", (col) => col.primaryKey()).addColumn("documentId", "text", (col) => col.notNull()).addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addUniqueConstraint("unique_docid_scope_branch", [
+    "documentId",
+    "scope",
+    "branch"
+  ]).execute();
+  await db.schema.createIndex("idx_slug_documentid").on("SlugMapping").column("documentId").execute();
+}
+async function up8(db) {
+  await db.schema.createTable("ViewState").addColumn("readModelId", "text", (col) => col.primaryKey()).addColumn("lastOrdinal", "integer", (col) => col.notNull().defaultTo(0)).addColumn("lastOperationTimestamp", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+}
+async function up9(db) {
+  await db.schema.createTable("document_collections").addColumn("documentId", "text", (col) => col.notNull()).addColumn("collectionId", "text", (col) => col.notNull()).addColumn("joinedOrdinal", "bigint", (col) => col.notNull().defaultTo(0)).addColumn("leftOrdinal", "bigint").addPrimaryKeyConstraint("document_collections_pkey", [
+    "documentId",
+    "collectionId"
+  ]).execute();
+  await db.schema.createIndex("idx_document_collections_collectionId").on("document_collections").column("collectionId").execute();
+  await db.schema.createIndex("idx_doc_collections_collection_range").on("document_collections").columns(["collectionId", "joinedOrdinal"]).execute();
+  await db.schema.createTable("operation_index_operations").addColumn("ordinal", "serial", (col) => col.primaryKey()).addColumn("opId", "text", (col) => col.notNull()).addColumn("documentId", "text", (col) => col.notNull()).addColumn("documentType", "text", (col) => col.notNull()).addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("timestampUtcMs", "text", (col) => col.notNull()).addColumn("writeTimestampUtcMs", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("index", "integer", (col) => col.notNull()).addColumn("skip", "integer", (col) => col.notNull()).addColumn("hash", "text", (col) => col.notNull()).addColumn("action", "jsonb", (col) => col.notNull()).execute();
+  await db.schema.createIndex("idx_operation_index_operations_document").on("operation_index_operations").columns(["documentId", "branch", "scope"]).execute();
+  await db.schema.createIndex("idx_operation_index_operations_ordinal").on("operation_index_operations").column("ordinal").execute();
+}
+async function up10(db) {
+  await db.schema.createTable("sync_remotes").addColumn("name", "text", (col) => col.primaryKey()).addColumn("collection_id", "text", (col) => col.notNull()).addColumn("channel_type", "text", (col) => col.notNull()).addColumn("channel_id", "text", (col) => col.notNull().defaultTo("")).addColumn("remote_name", "text", (col) => col.notNull().defaultTo("")).addColumn("channel_parameters", "jsonb", (col) => col.notNull().defaultTo(sql`'{}'::jsonb`)).addColumn("filter_document_ids", "jsonb").addColumn("filter_scopes", "jsonb").addColumn("filter_branch", "text", (col) => col.notNull().defaultTo("main")).addColumn("push_state", "text", (col) => col.notNull().defaultTo("idle")).addColumn("push_last_success_utc_ms", "text").addColumn("push_last_failure_utc_ms", "text").addColumn("push_failure_count", "integer", (col) => col.notNull().defaultTo(0)).addColumn("pull_state", "text", (col) => col.notNull().defaultTo("idle")).addColumn("pull_last_success_utc_ms", "text").addColumn("pull_last_failure_utc_ms", "text").addColumn("pull_failure_count", "integer", (col) => col.notNull().defaultTo(0)).addColumn("created_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updated_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+  await db.schema.createIndex("idx_sync_remotes_collection").on("sync_remotes").column("collection_id").execute();
+  await db.schema.createTable("sync_cursors").addColumn("remote_name", "text", (col) => col.primaryKey().references("sync_remotes.name").onDelete("cascade")).addColumn("cursor_ordinal", "bigint", (col) => col.notNull().defaultTo(0)).addColumn("last_synced_at_utc_ms", "text").addColumn("updated_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+  await db.schema.createIndex("idx_sync_cursors_ordinal").on("sync_cursors").column("cursor_ordinal").execute();
+}
+async function up11(db) {
+  await db.deleteFrom("sync_cursors").where("remote_name", "like", "outbox::%").execute();
+  await db.deleteFrom("sync_remotes").where("name", "like", "outbox::%").execute();
+  await db.schema.dropTable("sync_cursors").execute();
+  await db.schema.createTable("sync_cursors").addColumn("remote_name", "text", (col) => col.notNull()).addColumn("cursor_type", "text", (col) => col.notNull().defaultTo("inbox")).addColumn("cursor_ordinal", "bigint", (col) => col.notNull().defaultTo(0)).addColumn("last_synced_at_utc_ms", "text").addColumn("updated_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addPrimaryKeyConstraint("sync_cursors_pk", ["remote_name", "cursor_type"]).execute();
+  await db.schema.createIndex("idx_sync_cursors_ordinal").on("sync_cursors").column("cursor_ordinal").execute();
+}
+async function up12(db) {
+  await db.schema.alterTable("operation_index_operations").addColumn("sourceRemote", "text", (col) => col.notNull().defaultTo("")).execute();
+}
+async function up13(db) {
+  await db.schema.createTable("sync_dead_letters").addColumn("ordinal", "serial", (col) => col.primaryKey()).addColumn("id", "text", (col) => col.unique().notNull()).addColumn("job_id", "text", (col) => col.notNull()).addColumn("job_dependencies", "jsonb", (col) => col.notNull().defaultTo(sql`'[]'::jsonb`)).addColumn("remote_name", "text", (col) => col.notNull().references("sync_remotes.name").onDelete("cascade")).addColumn("document_id", "text", (col) => col.notNull()).addColumn("scopes", "jsonb", (col) => col.notNull().defaultTo(sql`'[]'::jsonb`)).addColumn("branch", "text", (col) => col.notNull()).addColumn("operations", "jsonb", (col) => col.notNull().defaultTo(sql`'[]'::jsonb`)).addColumn("error_source", "text", (col) => col.notNull()).addColumn("error_message", "text", (col) => col.notNull()).addColumn("created_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+  await db.schema.createIndex("idx_sync_dead_letters_remote").on("sync_dead_letters").column("remote_name").execute();
+}
+async function up14(db) {
+  await db.schema.createTable("ProcessorCursor").addColumn("processorId", "text", (col) => col.primaryKey()).addColumn("factoryId", "text", (col) => col.notNull()).addColumn("driveId", "text", (col) => col.notNull()).addColumn("processorIndex", "integer", (col) => col.notNull()).addColumn("lastOrdinal", "integer", (col) => col.notNull().defaultTo(sql`0`)).addColumn("status", "text", (col) => col.notNull().defaultTo(sql`'active'`)).addColumn("lastError", "text").addColumn("lastErrorTimestamp", "timestamptz").addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
+}
+
+class ProgrammaticMigrationProvider {
+  getMigrations() {
+    return Promise.resolve(migrations);
+  }
+}
+async function runMigrations(db, schema = REACTOR_SCHEMA) {
+  try {
+    await sql`CREATE SCHEMA IF NOT EXISTS ${sql.id(schema)}`.execute(db);
+  } catch (error2) {
+    return {
+      success: false,
+      migrationsExecuted: [],
+      error: error2 instanceof Error ? error2 : new Error("Failed to create schema")
+    };
+  }
+  const migrator = new Migrator({
+    db: db.withSchema(schema),
+    provider: new ProgrammaticMigrationProvider,
+    migrationTableSchema: schema
+  });
+  let error;
+  let results;
+  try {
+    const result = await migrator.migrateToLatest();
+    error = result.error;
+    results = result.results;
+  } catch (e) {
+    error = e;
+    results = [];
+  }
+  const migrationsExecuted = results?.map((result) => result.migrationName) ?? [];
+  if (error) {
+    return {
+      success: false,
+      migrationsExecuted,
+      error: error instanceof Error ? error : new Error("Unknown migration error")
+    };
+  }
+  return {
+    success: true,
+    migrationsExecuted
+  };
+}
+
+class DefaultSubscriptionErrorHandler {
+  handleError(error, context) {
+    const errorMessage = `Subscription error in ${context.eventType} (${context.subscriptionId})`;
+    if (error instanceof Error) {
+      const enhancedError = new Error(`${errorMessage}: ${error.message}`);
+      enhancedError.cause = error;
+      enhancedError.stack = error.stack;
+      throw enhancedError;
+    } else {
+      throw new Error(`${errorMessage}: ${String(error)}`);
+    }
+  }
+}
+
+class ReactorSubscriptionManager {
+  createdSubscriptions = new Map;
+  deletedSubscriptions = new Map;
+  updatedSubscriptions = new Map;
+  relationshipSubscriptions = new Map;
+  subscriptionCounter = 0;
+  errorHandler;
+  constructor(errorHandler) {
+    this.errorHandler = errorHandler;
+  }
+  onDocumentCreated(callback, search) {
+    const id = `created-${++this.subscriptionCounter}`;
+    this.createdSubscriptions.set(id, { id, callback, search });
+    return () => {
+      this.createdSubscriptions.delete(id);
+    };
+  }
+  onDocumentDeleted(callback, search) {
+    const id = `deleted-${++this.subscriptionCounter}`;
+    this.deletedSubscriptions.set(id, { id, callback, search });
+    return () => {
+      this.deletedSubscriptions.delete(id);
+    };
+  }
+  onDocumentStateUpdated(callback, search, view) {
+    const id = `updated-${++this.subscriptionCounter}`;
+    this.updatedSubscriptions.set(id, { id, callback, search, view });
+    return () => {
+      this.updatedSubscriptions.delete(id);
+    };
+  }
+  onRelationshipChanged(callback, search) {
+    const id = `relationship-${++this.subscriptionCounter}`;
+    this.relationshipSubscriptions.set(id, { id, callback, search });
+    return () => {
+      this.relationshipSubscriptions.delete(id);
+    };
+  }
+  notifyDocumentsCreated(documentIds, documentTypes, parentIds) {
+    const result = {
+      results: documentIds,
+      options: { cursor: "", limit: documentIds.length }
+    };
+    for (const subscription of this.createdSubscriptions.values()) {
+      const filteredIds = this.filterDocumentIds(documentIds, subscription.search, documentTypes, parentIds);
+      if (filteredIds.length > 0) {
+        try {
+          subscription.callback({
+            ...result,
+            results: filteredIds
+          });
+        } catch (error) {
+          this.errorHandler.handleError(error, {
+            eventType: "created",
+            subscriptionId: subscription.id,
+            eventData: filteredIds
+          });
+        }
+      }
+    }
+  }
+  notifyDocumentsDeleted(documentIds, documentTypes, parentIds) {
+    for (const subscription of this.deletedSubscriptions.values()) {
+      const filteredIds = this.filterDocumentIds(documentIds, subscription.search, documentTypes, parentIds);
+      if (filteredIds.length > 0) {
+        try {
+          subscription.callback(filteredIds);
+        } catch (error) {
+          this.errorHandler.handleError(error, {
+            eventType: "deleted",
+            subscriptionId: subscription.id,
+            eventData: filteredIds
+          });
+        }
+      }
+    }
+  }
+  notifyDocumentsUpdated(documents) {
+    const result = {
+      results: documents,
+      options: { cursor: "", limit: documents.length }
+    };
+    for (const subscription of this.updatedSubscriptions.values()) {
+      const filteredDocs = this.filterDocuments(documents, subscription.search);
+      if (filteredDocs.length > 0) {
+        try {
+          subscription.callback({
+            ...result,
+            results: filteredDocs
+          });
+        } catch (error) {
+          this.errorHandler.handleError(error, {
+            eventType: "updated",
+            subscriptionId: subscription.id,
+            eventData: filteredDocs
+          });
+        }
+      }
+    }
+  }
+  notifyRelationshipChanged(parentId, childId, changeType, childType) {
+    for (const subscription of this.relationshipSubscriptions.values()) {
+      if (this.matchesRelationshipFilter(parentId, childId, childType, subscription.search)) {
+        try {
+          subscription.callback(parentId, childId, changeType);
+        } catch (error) {
+          this.errorHandler.handleError(error, {
+            eventType: "relationshipChanged",
+            subscriptionId: subscription.id,
+            eventData: { parentId, childId, changeType }
+          });
+        }
+      }
+    }
+  }
+  clearAll() {
+    this.createdSubscriptions.clear();
+    this.deletedSubscriptions.clear();
+    this.updatedSubscriptions.clear();
+    this.relationshipSubscriptions.clear();
+  }
+  filterDocumentIds(documentIds, search, documentTypes, parentIds) {
+    if (!search)
+      return documentIds;
+    return documentIds.filter((id) => {
+      if (search.ids && !search.ids.includes(id))
+        return false;
+      if (search.type && documentTypes) {
+        const docType = documentTypes.get(id);
+        if (docType !== search.type)
+          return false;
+      }
+      if (search.parentId && parentIds) {
+        const parentId = parentIds.get(id);
+        if (parentId !== search.parentId)
+          return false;
+      }
+      return true;
+    });
+  }
+  filterDocuments(documents, search) {
+    if (!search)
+      return documents;
+    return documents.filter((doc) => {
+      if (search.ids && !search.ids.includes(doc.header.id))
+        return false;
+      if (search.type && doc.header.documentType !== search.type)
+        return false;
+      if (search.slugs && !search.slugs.includes(doc.header.slug))
+        return false;
+      return true;
+    });
+  }
+  matchesRelationshipFilter(parentId, childId, childType, search) {
+    if (!search)
+      return true;
+    if (search.parentId && parentId !== search.parentId)
+      return false;
+    if (search.ids && !search.ids.includes(childId))
+      return false;
+    if (search.type && childType && childType !== search.type)
+      return false;
+    return true;
+  }
+}
+
+class SubscriptionNotificationReadModel {
+  subscriptionManager;
+  documentView;
+  constructor(subscriptionManager, documentView) {
+    this.subscriptionManager = subscriptionManager;
+    this.documentView = documentView;
+  }
+  async indexOperations(operations) {
+    if (operations.length === 0)
+      return;
+    const created = [];
+    const deleted = [];
+    const updatedIds = new Set;
+    const documentTypes = new Map;
+    const parentIds = new Map;
+    for (const item of operations) {
+      const { operation, context } = item;
+      const actionType = operation.action.type;
+      documentTypes.set(context.documentId, context.documentType);
+      if (actionType === "CREATE_DOCUMENT") {
+        created.push(context.documentId);
+      } else if (actionType === "DELETE_DOCUMENT") {
+        const input = operation.action.input;
+        const deletedId = input.documentId ?? context.documentId;
+        deleted.push(deletedId);
+      } else if (actionType === "ADD_RELATIONSHIP") {
+        const input = operation.action.input;
+        this.subscriptionManager.notifyRelationshipChanged(input.sourceId, input.targetId, "added", input.childType);
+      } else if (actionType === "REMOVE_RELATIONSHIP") {
+        const input = operation.action.input;
+        this.subscriptionManager.notifyRelationshipChanged(input.sourceId, input.targetId, "removed", input.childType);
+      } else {
+        if (!created.includes(context.documentId)) {
+          updatedIds.add(context.documentId);
+        }
+      }
+    }
+    if (created.length > 0) {
+      this.subscriptionManager.notifyDocumentsCreated(created, documentTypes, parentIds);
+    }
+    if (deleted.length > 0) {
+      this.subscriptionManager.notifyDocumentsDeleted(deleted, documentTypes, parentIds);
+    }
+    if (updatedIds.size > 0 && this.documentView) {
+      const documents = await Promise.all(Array.from(updatedIds).map((id) => this.documentView.get(id)));
+      this.subscriptionManager.notifyDocumentsUpdated(documents);
+    }
+  }
+}
 
 class Mailbox {
   itemsMap = new Map;
@@ -15147,6 +15804,8 @@ class GqlRequestChannel {
   pushFailureCount = 0;
   pushRetryTimer = null;
   pushBlocked = false;
+  connectionState = "connecting";
+  connectionStateCallbacks = new Set;
   constructor(logger2, channelId, remoteName, cursorStorage, config, operationIndex, pollTimer) {
     this.logger = logger2;
     this.channelId = channelId;
@@ -15175,6 +15834,7 @@ class GqlRequestChannel {
         clearTimeout(this.pushRetryTimer);
         this.pushRetryTimer = null;
       }
+      this.transitionConnectionState("error");
     });
     this.outbox.onAdded((syncOps) => {
       if (this.isShutdown)
@@ -15222,8 +15882,25 @@ class GqlRequestChannel {
       clearTimeout(this.pushRetryTimer);
       this.pushRetryTimer = null;
     }
+    this.transitionConnectionState("disconnected");
     return Promise.resolve();
   }
+  getConnectionState() {
+    return {
+      state: this.connectionState,
+      failureCount: this.failureCount,
+      lastSuccessUtcMs: this.lastSuccessUtcMs ?? 0,
+      lastFailureUtcMs: this.lastFailureUtcMs ?? 0,
+      pushBlocked: this.pushBlocked,
+      pushFailureCount: this.pushFailureCount
+    };
+  }
+  onConnectionStateChange(callback) {
+    this.connectionStateCallbacks.add(callback);
+    return () => {
+      this.connectionStateCallbacks.delete(callback);
+    };
+  }
   async init() {
     await this.touchRemoteChannel();
     const cursors = await this.cursorStorage.list(this.remoteName);
@@ -15235,6 +15912,20 @@ class GqlRequestChannel {
     this.lastPersistedOutboxOrdinal = outboxOrdinal;
     this.pollTimer.setDelegate(() => this.poll());
     this.pollTimer.start();
+    this.transitionConnectionState("connected");
+  }
+  transitionConnectionState(next) {
+    if (this.connectionState === next)
+      return;
+    this.connectionState = next;
+    const snapshot = this.getConnectionState();
+    for (const callback of this.connectionStateCallbacks) {
+      try {
+        callback(snapshot);
+      } catch (error) {
+        this.logger.error("Connection state change callback error: @Error", error);
+      }
+    }
   }
   async poll() {
     if (this.isShutdown) {
@@ -15273,6 +15964,7 @@ class GqlRequestChannel {
     }
     this.lastSuccessUtcMs = Date.now();
     this.failureCount = 0;
+    this.transitionConnectionState("connected");
   }
   handleRemoteDeadLetters(deadLetters) {
     for (const dl of deadLetters) {
@@ -15289,11 +15981,13 @@ class GqlRequestChannel {
   handlePollError(error) {
     const err = error instanceof Error ? error : new Error(String(error));
     if (err.message.includes("Channel not found")) {
+      this.transitionConnectionState("reconnecting");
       this.recoverFromChannelNotFound();
       return true;
     }
     this.failureCount++;
     this.lastFailureUtcMs = Date.now();
+    this.transitionConnectionState("error");
     const channelError = new ChannelError("inbox", err);
     this.logger.error("GqlChannel poll error (@FailureCount): @Error", this.failureCount, channelError);
     return false;
@@ -15305,11 +15999,13 @@ class GqlRequestChannel {
       this.logger.info("GqlChannel @ChannelId re-registered successfully", this.channelId);
       this.failureCount = 0;
       this.pollTimer.start();
+      this.transitionConnectionState("connected");
     }).catch((recoveryError) => {
       this.logger.error("GqlChannel @ChannelId failed to re-register: @Error", this.channelId, recoveryError);
       this.failureCount++;
       this.lastFailureUtcMs = Date.now();
       this.pollTimer.start();
+      this.transitionConnectionState("error");
     });
   }
   async pollSyncEnvelopes(ackOrdinal, latestOrdinal) {
@@ -15430,12 +16126,16 @@ class GqlRequestChannel {
     this.pushSyncOperations(syncOps).then(() => {
       this.pushBlocked = false;
       this.pushFailureCount = 0;
+      if (this.connectionState === "reconnecting" || this.connectionState === "error") {
+        this.transitionConnectionState("connected");
+      }
     }).catch((error) => {
       const err = error instanceof Error ? error : new Error(String(error));
       if (this.isRecoverablePushError(err)) {
         this.pushFailureCount++;
         this.pushBlocked = true;
         this.logger.error("GqlChannel push failed (attempt @FailureCount), will retry: @Error", this.pushFailureCount, err);
+        this.transitionConnectionState("reconnecting");
         this.schedulePushRetry();
       } else {
         const channelError = new ChannelError("outbox", err);
@@ -15444,6 +16144,7 @@ class GqlRequestChannel {
         }
         this.deadLetter.add(...syncOps);
         this.outbox.remove(...syncOps);
+        this.transitionConnectionState("error");
       }
     });
   }
@@ -15569,14 +16270,6 @@ class GqlRequestChannel {
     }
     return result.data;
   }
-  getHealth() {
-    return {
-      state: this.failureCount > 0 ? "error" : "idle",
-      lastSuccessUtcMs: this.lastSuccessUtcMs,
-      lastFailureUtcMs: this.lastFailureUtcMs,
-      failureCount: this.failureCount
-    };
-  }
   get poller() {
     return this.pollTimer;
   }
@@ -15675,6 +16368,8 @@ class GqlResponseChannel {
   isShutdown;
   lastPersistedInboxOrdinal = 0;
   lastPersistedOutboxOrdinal = 0;
+  connectionState = "connecting";
+  connectionStateCallbacks = new Set;
   constructor(logger2, channelId, remoteName, cursorStorage) {
     this.logger = logger2;
     this.channelId = channelId;
@@ -15715,8 +16410,38 @@ class GqlResponseChannel {
   }
   shutdown() {
     this.isShutdown = true;
+    this.transitionConnectionState("disconnected");
     return Promise.resolve();
   }
+  getConnectionState() {
+    return {
+      state: this.connectionState,
+      failureCount: 0,
+      lastSuccessUtcMs: 0,
+      lastFailureUtcMs: 0,
+      pushBlocked: false,
+      pushFailureCount: 0
+    };
+  }
+  onConnectionStateChange(callback) {
+    this.connectionStateCallbacks.add(callback);
+    return () => {
+      this.connectionStateCallbacks.delete(callback);
+    };
+  }
+  transitionConnectionState(next) {
+    if (this.connectionState === next)
+      return;
+    this.connectionState = next;
+    const snapshot = this.getConnectionState();
+    for (const callback of this.connectionStateCallbacks) {
+      try {
+        callback(snapshot);
+      } catch (error) {
+        this.logger.error("Connection state change callback error: @Error", error);
+      }
+    }
+  }
   async init() {
     const cursors = await this.cursorStorage.list(this.remoteName);
     const inboxOrdinal = cursors.find((c) => c.cursorType === "inbox")?.cursorOrdinal ?? 0;
@@ -15725,6 +16450,7 @@ class GqlResponseChannel {
     this.outbox.init(outboxOrdinal);
     this.lastPersistedInboxOrdinal = inboxOrdinal;
     this.lastPersistedOutboxOrdinal = outboxOrdinal;
+    this.transitionConnectionState("connected");
   }
 }
 
@@ -15737,981 +16463,6 @@ class GqlResponseChannelFactory {
     return new GqlResponseChannel(this.logger, remoteId, remoteName, cursorStorage);
   }
 }
-async function collectAllPages(firstPage, signal) {
-  const allResults = [...firstPage.results];
-  let currentPage = firstPage;
-  while (currentPage.next) {
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    currentPage = await currentPage.next();
-    allResults.push(...currentPage.results);
-  }
-  return allResults;
-}
-
-class KyselyDocumentIndexer {
-  db;
-  operationStore;
-  consistencyTracker;
-  lastOperationId = 0;
-  constructor(db, operationStore, consistencyTracker) {
-    this.db = db;
-    this.operationStore = operationStore;
-    this.consistencyTracker = consistencyTracker;
-  }
-  async init() {
-    const indexerState = await this.db.selectFrom("IndexerState").selectAll().executeTakeFirst();
-    if (indexerState) {
-      this.lastOperationId = indexerState.lastOperationId;
-      const missedOperations = await this.operationStore.getSinceId(this.lastOperationId);
-      if (missedOperations.results.length > 0) {
-        await this.indexOperations(missedOperations.results);
-      }
-    } else {
-      await this.db.insertInto("IndexerState").values({
-        lastOperationId: 0
-      }).execute();
-      const allOperations = await this.operationStore.getSinceId(0);
-      if (allOperations.results.length > 0) {
-        await this.indexOperations(allOperations.results);
-      }
-    }
-  }
-  async indexOperations(items) {
-    if (items.length === 0)
-      return;
-    await this.db.transaction().execute(async (trx) => {
-      for (const item of items) {
-        const { operation } = item;
-        const actionType = operation.action.type;
-        if (actionType === "ADD_RELATIONSHIP") {
-          await this.handleAddRelationship(trx, operation);
-        } else if (actionType === "REMOVE_RELATIONSHIP") {
-          await this.handleRemoveRelationship(trx, operation);
-        }
-      }
-      const lastOpId = items[items.length - 1].operation.id;
-      if (lastOpId && typeof lastOpId === "number") {
-        this.lastOperationId = lastOpId;
-        await trx.updateTable("IndexerState").set({
-          lastOperationId: lastOpId,
-          lastOperationTimestamp: new Date
-        }).execute();
-      }
-    });
-    const coordinates = [];
-    for (let i = 0;i < items.length; i++) {
-      const item = items[i];
-      coordinates.push({
-        documentId: item.context.documentId,
-        scope: item.context.scope,
-        branch: item.context.branch,
-        operationIndex: item.operation.index
-      });
-    }
-    this.consistencyTracker.update(coordinates);
-  }
-  async waitForConsistency(token, timeoutMs, signal) {
-    if (token.coordinates.length === 0) {
-      return;
-    }
-    await this.consistencyTracker.waitFor(token.coordinates, timeoutMs, signal);
-  }
-  async getOutgoing(documentId, types2, paging, consistencyToken, signal) {
-    if (consistencyToken) {
-      await this.waitForConsistency(consistencyToken, undefined, signal);
-    }
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
-    const limit = paging?.limit || 100;
-    let query = this.db.selectFrom("DocumentRelationship").selectAll().where("sourceId", "=", documentId);
-    if (types2 && types2.length > 0) {
-      query = query.where("relationshipType", "in", types2);
-    }
-    const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").offset(startIndex).limit(limit + 1).execute();
-    const hasMore = rows.length > limit;
-    const results = hasMore ? rows.slice(0, limit) : rows;
-    const nextCursor = hasMore ? String(startIndex + limit) : undefined;
-    return {
-      results: results.map((row) => ({
-        sourceId: row.sourceId,
-        targetId: row.targetId,
-        relationshipType: row.relationshipType,
-        metadata: row.metadata ? row.metadata : undefined,
-        createdAt: row.createdAt,
-        updatedAt: row.updatedAt
-      })),
-      options: paging || { cursor: "0", limit: 100 },
-      nextCursor,
-      next: hasMore ? () => this.getOutgoing(documentId, types2, { cursor: nextCursor, limit }, consistencyToken, signal) : undefined
-    };
-  }
-  async getIncoming(documentId, types2, paging, consistencyToken, signal) {
-    if (consistencyToken) {
-      await this.waitForConsistency(consistencyToken, undefined, signal);
-    }
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
-    const limit = paging?.limit || 100;
-    let query = this.db.selectFrom("DocumentRelationship").selectAll().where("targetId", "=", documentId);
-    if (types2 && types2.length > 0) {
-      query = query.where("relationshipType", "in", types2);
-    }
-    const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").offset(startIndex).limit(limit + 1).execute();
-    const hasMore = rows.length > limit;
-    const results = hasMore ? rows.slice(0, limit) : rows;
-    const nextCursor = hasMore ? String(startIndex + limit) : undefined;
-    return {
-      results: results.map((row) => ({
-        sourceId: row.sourceId,
-        targetId: row.targetId,
-        relationshipType: row.relationshipType,
-        metadata: row.metadata ? row.metadata : undefined,
-        createdAt: row.createdAt,
-        updatedAt: row.updatedAt
-      })),
-      options: paging || { cursor: "0", limit: 100 },
-      nextCursor,
-      next: hasMore ? () => this.getIncoming(documentId, types2, { cursor: nextCursor, limit }, consistencyToken, signal) : undefined
-    };
-  }
-  async hasRelationship(sourceId, targetId, types2, consistencyToken, signal) {
-    if (consistencyToken) {
-      await this.waitForConsistency(consistencyToken, undefined, signal);
-    }
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    let query = this.db.selectFrom("DocumentRelationship").select("id").where("sourceId", "=", sourceId).where("targetId", "=", targetId);
-    if (types2 && types2.length > 0) {
-      query = query.where("relationshipType", "in", types2);
-    }
-    const result = await query.executeTakeFirst();
-    return result !== undefined;
-  }
-  async getUndirectedRelationships(a, b, types2, paging, consistencyToken, signal) {
-    if (consistencyToken) {
-      await this.waitForConsistency(consistencyToken, undefined, signal);
-    }
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
-    const limit = paging?.limit || 100;
-    let query = this.db.selectFrom("DocumentRelationship").selectAll().where((eb) => eb.or([
-      eb.and([eb("sourceId", "=", a), eb("targetId", "=", b)]),
-      eb.and([eb("sourceId", "=", b), eb("targetId", "=", a)])
-    ]));
-    if (types2 && types2.length > 0) {
-      query = query.where("relationshipType", "in", types2);
-    }
-    const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").offset(startIndex).limit(limit + 1).execute();
-    const hasMore = rows.length > limit;
-    const results = hasMore ? rows.slice(0, limit) : rows;
-    const nextCursor = hasMore ? String(startIndex + limit) : undefined;
-    return {
-      results: results.map((row) => ({
-        sourceId: row.sourceId,
-        targetId: row.targetId,
-        relationshipType: row.relationshipType,
-        metadata: row.metadata ? row.metadata : undefined,
-        createdAt: row.createdAt,
-        updatedAt: row.updatedAt
-      })),
-      options: paging || { cursor: "0", limit: 100 },
-      nextCursor,
-      next: hasMore ? () => this.getUndirectedRelationships(a, b, types2, { cursor: nextCursor, limit }, consistencyToken, signal) : undefined
-    };
-  }
-  async getDirectedRelationships(sourceId, targetId, types2, paging, consistencyToken, signal) {
-    if (consistencyToken) {
-      await this.waitForConsistency(consistencyToken, undefined, signal);
-    }
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
-    const limit = paging?.limit || 100;
-    let query = this.db.selectFrom("DocumentRelationship").selectAll().where("sourceId", "=", sourceId).where("targetId", "=", targetId);
-    if (types2 && types2.length > 0) {
-      query = query.where("relationshipType", "in", types2);
-    }
-    const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").offset(startIndex).limit(limit + 1).execute();
-    const hasMore = rows.length > limit;
-    const results = hasMore ? rows.slice(0, limit) : rows;
-    const nextCursor = hasMore ? String(startIndex + limit) : undefined;
-    return {
-      results: results.map((row) => ({
-        sourceId: row.sourceId,
-        targetId: row.targetId,
-        relationshipType: row.relationshipType,
-        metadata: row.metadata ? row.metadata : undefined,
-        createdAt: row.createdAt,
-        updatedAt: row.updatedAt
-      })),
-      options: paging || { cursor: "0", limit: 100 },
-      nextCursor,
-      next: hasMore ? () => this.getDirectedRelationships(sourceId, targetId, types2, { cursor: nextCursor, limit }, consistencyToken, signal) : undefined
-    };
-  }
-  async findPath(sourceId, targetId, types2, consistencyToken, signal) {
-    if (consistencyToken) {
-      await this.waitForConsistency(consistencyToken, undefined, signal);
-    }
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    if (sourceId === targetId) {
-      return [sourceId];
-    }
-    const visited = new Set;
-    const queue = [
-      { id: sourceId, path: [sourceId] }
-    ];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (current.id === targetId) {
-        return current.path;
-      }
-      if (visited.has(current.id)) {
-        continue;
-      }
-      visited.add(current.id);
-      const outgoingPage = await this.getOutgoing(current.id, types2, undefined, consistencyToken, signal);
-      const outgoingRelationships = await collectAllPages(outgoingPage, signal);
-      for (const rel of outgoingRelationships) {
-        if (!visited.has(rel.targetId)) {
-          queue.push({
-            id: rel.targetId,
-            path: [...current.path, rel.targetId]
-          });
-        }
-      }
-    }
-    return null;
-  }
-  async findAncestors(documentId, types2, consistencyToken, signal) {
-    if (consistencyToken) {
-      await this.waitForConsistency(consistencyToken, undefined, signal);
-    }
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    const nodes = new Set([documentId]);
-    const edges = [];
-    const queue = [documentId];
-    const visited = new Set;
-    while (queue.length > 0) {
-      const currentId = queue.shift();
-      if (visited.has(currentId)) {
-        continue;
-      }
-      visited.add(currentId);
-      const incomingPage = await this.getIncoming(currentId, types2, undefined, consistencyToken, signal);
-      const incomingRelationships = await collectAllPages(incomingPage, signal);
-      for (const rel of incomingRelationships) {
-        nodes.add(rel.sourceId);
-        edges.push({
-          from: rel.sourceId,
-          to: rel.targetId,
-          type: rel.relationshipType
-        });
-        if (!visited.has(rel.sourceId)) {
-          queue.push(rel.sourceId);
-        }
-      }
-    }
-    return {
-      nodes: Array.from(nodes),
-      edges
-    };
-  }
-  async getRelationshipTypes(consistencyToken, signal) {
-    if (consistencyToken) {
-      await this.waitForConsistency(consistencyToken, undefined, signal);
-    }
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    const rows = await this.db.selectFrom("DocumentRelationship").select("relationshipType").distinct().execute();
-    return rows.map((row) => row.relationshipType);
-  }
-  async handleAddRelationship(trx, operation) {
-    const input = operation.action.input;
-    const existingDoc = await trx.selectFrom("Document").select("id").where("id", "=", input.sourceId).executeTakeFirst();
-    if (!existingDoc) {
-      await trx.insertInto("Document").values({
-        id: input.sourceId
-      }).execute();
-    }
-    const existingTargetDoc = await trx.selectFrom("Document").select("id").where("id", "=", input.targetId).executeTakeFirst();
-    if (!existingTargetDoc) {
-      await trx.insertInto("Document").values({
-        id: input.targetId
-      }).execute();
-    }
-    const existingRel = await trx.selectFrom("DocumentRelationship").select("id").where("sourceId", "=", input.sourceId).where("targetId", "=", input.targetId).where("relationshipType", "=", input.relationshipType).executeTakeFirst();
-    if (!existingRel) {
-      const relationship = {
-        id: v4_default(),
-        sourceId: input.sourceId,
-        targetId: input.targetId,
-        relationshipType: input.relationshipType,
-        metadata: input.metadata || null
-      };
-      await trx.insertInto("DocumentRelationship").values(relationship).execute();
-    }
-  }
-  async handleRemoveRelationship(trx, operation) {
-    const input = operation.action.input;
-    await trx.deleteFrom("DocumentRelationship").where("sourceId", "=", input.sourceId).where("targetId", "=", input.targetId).where("relationshipType", "=", input.relationshipType).execute();
-  }
-}
-
-class KyselyKeyframeStore {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  async putKeyframe(documentId, scope, branch, revision, document2, signal) {
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    await this.db.insertInto("Keyframe").values({
-      documentId,
-      documentType: document2.header.documentType,
-      scope,
-      branch,
-      revision,
-      document: document2
-    }).onConflict((oc) => oc.columns(["documentId", "scope", "branch", "revision"]).doUpdateSet({ document: document2 })).execute();
-  }
-  async findNearestKeyframe(documentId, scope, branch, targetRevision, signal) {
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    const row = await this.db.selectFrom("Keyframe").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("revision", "<=", targetRevision).orderBy("revision", "desc").limit(1).executeTakeFirst();
-    if (!row) {
-      return;
-    }
-    return {
-      revision: row.revision,
-      document: row.document
-    };
-  }
-  async deleteKeyframes(documentId, scope, branch, signal) {
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    let query = this.db.deleteFrom("Keyframe").where("documentId", "=", documentId);
-    if (scope !== undefined && branch !== undefined) {
-      query = query.where("scope", "=", scope).where("branch", "=", branch);
-    } else if (scope !== undefined) {
-      query = query.where("scope", "=", scope);
-    }
-    const result = await query.executeTakeFirst();
-    return Number(result.numDeletedRows || 0n);
-  }
-}
-
-class AtomicTransaction {
-  documentId;
-  documentType;
-  scope;
-  branch;
-  baseRevision;
-  operations = [];
-  constructor(documentId, documentType, scope, branch, baseRevision) {
-    this.documentId = documentId;
-    this.documentType = documentType;
-    this.scope = scope;
-    this.branch = branch;
-    this.baseRevision = baseRevision;
-  }
-  addOperations(...operations) {
-    for (const op of operations) {
-      this.operations.push({
-        jobId: v4_default(),
-        opId: op.id,
-        prevOpId: "",
-        documentId: this.documentId,
-        documentType: this.documentType,
-        scope: this.scope,
-        branch: this.branch,
-        timestampUtcMs: new Date(op.timestampUtcMs),
-        index: op.index,
-        action: JSON.stringify(op.action),
-        skip: op.skip,
-        error: op.error || null,
-        hash: op.hash
-      });
-    }
-  }
-  getOperations() {
-    return this.operations;
-  }
-}
-
-class KyselyOperationStore {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-  async apply(documentId, documentType, scope, branch, revision, fn, signal) {
-    await this.db.transaction().execute(async (trx) => {
-      if (signal?.aborted) {
-        throw new Error("Operation aborted");
-      }
-      const latestOp = await trx.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).orderBy("index", "desc").limit(1).executeTakeFirst();
-      const currentRevision = latestOp ? latestOp.index : -1;
-      if (currentRevision !== revision - 1) {
-        throw new RevisionMismatchError(currentRevision + 1, revision);
-      }
-      const atomicTxn = new AtomicTransaction(documentId, documentType, scope, branch, revision);
-      await fn(atomicTxn);
-      const operations = atomicTxn.getOperations();
-      if (operations.length > 0) {
-        let prevOpId = latestOp?.opId || "";
-        for (const op of operations) {
-          op.prevOpId = prevOpId;
-          prevOpId = op.opId;
-        }
-        try {
-          await trx.insertInto("Operation").values(operations).execute();
-        } catch (error) {
-          if (error instanceof Error) {
-            if (error.message.includes("unique constraint")) {
-              const op = operations[0];
-              throw new DuplicateOperationError(`${op.opId} at index ${op.index} with skip ${op.skip}`);
-            }
-            throw error;
-          }
-          throw error;
-        }
-      }
-    });
-  }
-  async getSince(documentId, scope, branch, revision, filter, paging, signal) {
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    let query = this.db.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("index", ">", revision).orderBy("index", "asc");
-    if (filter) {
-      if (filter.actionTypes && filter.actionTypes.length > 0) {
-        const actionTypesArray = filter.actionTypes.map((t) => `'${t.replace(/'/g, "''")}'`).join(",");
-        query = query.where(sql`action->>'type' = ANY(ARRAY[${sql.raw(actionTypesArray)}]::text[])`);
-      }
-      if (filter.timestampFrom) {
-        query = query.where("timestampUtcMs", ">=", new Date(filter.timestampFrom));
-      }
-      if (filter.timestampTo) {
-        query = query.where("timestampUtcMs", "<=", new Date(filter.timestampTo));
-      }
-      if (filter.sinceRevision !== undefined) {
-        query = query.where("index", ">=", filter.sinceRevision);
-      }
-    }
-    if (paging) {
-      const cursorValue = Number.parseInt(paging.cursor, 10);
-      if (cursorValue > 0) {
-        query = query.where("index", ">", cursorValue);
-      }
-      if (paging.limit) {
-        query = query.limit(paging.limit + 1);
-      }
-    }
-    const rows = await query.execute();
-    let hasMore = false;
-    let items = rows;
-    if (paging?.limit && rows.length > paging.limit) {
-      hasMore = true;
-      items = rows.slice(0, paging.limit);
-    }
-    const nextCursor = hasMore && items.length > 0 ? items[items.length - 1].index.toString() : undefined;
-    const cursor = paging?.cursor || "0";
-    const limit = paging?.limit || 100;
-    const operations = items.map((row) => this.rowToOperation(row));
-    return {
-      results: operations,
-      options: { cursor, limit },
-      nextCursor,
-      next: hasMore ? () => this.getSince(documentId, scope, branch, revision, filter, { cursor: nextCursor, limit }, signal) : undefined
-    };
-  }
-  async getSinceId(id, paging, signal) {
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    let query = this.db.selectFrom("Operation").selectAll().where("id", ">", id).orderBy("id", "asc");
-    if (paging) {
-      const cursorValue = Number.parseInt(paging.cursor, 10);
-      if (cursorValue > 0) {
-        query = query.where("id", ">", cursorValue);
-      }
-      if (paging.limit) {
-        query = query.limit(paging.limit + 1);
-      }
-    }
-    const rows = await query.execute();
-    let hasMore = false;
-    let items = rows;
-    if (paging?.limit && rows.length > paging.limit) {
-      hasMore = true;
-      items = rows.slice(0, paging.limit);
-    }
-    const nextCursor = hasMore && items.length > 0 ? items[items.length - 1].id.toString() : undefined;
-    const cursor = paging?.cursor || "0";
-    const limit = paging?.limit || 100;
-    const operations = items.map((row) => this.rowToOperationWithContext(row));
-    return {
-      results: operations,
-      options: { cursor, limit },
-      nextCursor,
-      next: hasMore ? () => this.getSinceId(id, { cursor: nextCursor, limit }, signal) : undefined
-    };
-  }
-  async getConflicting(documentId, scope, branch, minTimestamp, paging, signal) {
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    let query = this.db.selectFrom("Operation").selectAll().where("documentId", "=", documentId).where("scope", "=", scope).where("branch", "=", branch).where("timestampUtcMs", ">=", new Date(minTimestamp)).orderBy("index", "asc");
-    if (paging) {
-      const cursorValue = Number.parseInt(paging.cursor, 10);
-      if (cursorValue > 0) {
-        query = query.where("index", ">", cursorValue);
-      }
-      if (paging.limit) {
-        query = query.limit(paging.limit + 1);
-      }
-    }
-    const rows = await query.execute();
-    let hasMore = false;
-    let items = rows;
-    if (paging?.limit && rows.length > paging.limit) {
-      hasMore = true;
-      items = rows.slice(0, paging.limit);
-    }
-    const nextCursor = hasMore && items.length > 0 ? items[items.length - 1].index.toString() : undefined;
-    const cursor = paging?.cursor || "0";
-    const limit = paging?.limit || 100;
-    const operations = items.map((row) => this.rowToOperation(row));
-    return {
-      results: operations,
-      options: { cursor, limit },
-      nextCursor,
-      next: hasMore ? () => this.getConflicting(documentId, scope, branch, minTimestamp, { cursor: nextCursor, limit }, signal) : undefined
-    };
-  }
-  async getRevisions(documentId, branch, signal) {
-    if (signal?.aborted) {
-      throw new Error("Operation aborted");
-    }
-    const scopeRevisions = await this.db.selectFrom("Operation as o1").select(["o1.scope", "o1.index", "o1.timestampUtcMs"]).where("o1.documentId", "=", documentId).where("o1.branch", "=", branch).where((eb) => eb("o1.index", "=", eb.selectFrom("Operation as o2").select((eb2) => eb2.fn.max("o2.index").as("maxIndex")).where("o2.documentId", "=", eb.ref("o1.documentId")).where("o2.branch", "=", eb.ref("o1.branch")).where("o2.scope", "=", eb.ref("o1.scope")))).execute();
-    const revision = {};
-    let latestTimestamp = new Date(0).toISOString();
-    for (const row of scopeRevisions) {
-      revision[row.scope] = row.index + 1;
-      const timestamp = row.timestampUtcMs.toISOString();
-      if (timestamp > latestTimestamp) {
-        latestTimestamp = timestamp;
-      }
-    }
-    return {
-      revision,
-      latestTimestamp
-    };
-  }
-  rowToOperation(row) {
-    return {
-      index: row.index,
-      timestampUtcMs: row.timestampUtcMs.toISOString(),
-      hash: row.hash,
-      skip: row.skip,
-      error: row.error || undefined,
-      id: row.opId,
-      action: row.action
-    };
-  }
-  rowToOperationWithContext(row) {
-    return {
-      operation: this.rowToOperation(row),
-      context: {
-        documentId: row.documentId,
-        documentType: row.documentType,
-        scope: row.scope,
-        branch: row.branch,
-        ordinal: row.id
-      }
-    };
-  }
-}
-async function up(db) {
-  await db.schema.createTable("Operation").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("jobId", "text", (col) => col.notNull()).addColumn("opId", "text", (col) => col.notNull()).addColumn("prevOpId", "text", (col) => col.notNull()).addColumn("writeTimestampUtcMs", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("documentId", "text", (col) => col.notNull()).addColumn("documentType", "text", (col) => col.notNull()).addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("timestampUtcMs", "timestamptz", (col) => col.notNull()).addColumn("index", "integer", (col) => col.notNull()).addColumn("action", "jsonb", (col) => col.notNull()).addColumn("skip", "integer", (col) => col.notNull()).addColumn("error", "text").addColumn("hash", "text", (col) => col.notNull()).addUniqueConstraint("unique_revision", [
-    "documentId",
-    "scope",
-    "branch",
-    "index"
-  ]).addUniqueConstraint("unique_operation_instance", ["opId", "index", "skip"]).execute();
-  await db.schema.createIndex("streamOperations").on("Operation").columns(["documentId", "scope", "branch", "id"]).execute();
-  await db.schema.createIndex("branchlessStreamOperations").on("Operation").columns(["documentId", "scope", "id"]).execute();
-}
-async function up2(db) {
-  await db.schema.createTable("Keyframe").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("documentId", "text", (col) => col.notNull()).addColumn("documentType", "text", (col) => col.notNull()).addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("revision", "integer", (col) => col.notNull()).addColumn("document", "jsonb", (col) => col.notNull()).addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addUniqueConstraint("unique_keyframe", [
-    "documentId",
-    "scope",
-    "branch",
-    "revision"
-  ]).execute();
-  await db.schema.createIndex("keyframe_lookup").on("Keyframe").columns(["documentId", "scope", "branch", "revision"]).execute();
-}
-async function up3(db) {
-  await db.schema.createTable("Document").addColumn("id", "text", (col) => col.primaryKey()).addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
-}
-async function up4(db) {
-  await db.schema.createTable("DocumentRelationship").addColumn("id", "text", (col) => col.primaryKey()).addColumn("sourceId", "text", (col) => col.notNull().references("Document.id").onDelete("cascade")).addColumn("targetId", "text", (col) => col.notNull().references("Document.id").onDelete("cascade")).addColumn("relationshipType", "text", (col) => col.notNull()).addColumn("metadata", "jsonb").addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addUniqueConstraint("unique_source_target_type", [
-    "sourceId",
-    "targetId",
-    "relationshipType"
-  ]).execute();
-  await db.schema.createIndex("idx_relationship_source").on("DocumentRelationship").column("sourceId").execute();
-  await db.schema.createIndex("idx_relationship_target").on("DocumentRelationship").column("targetId").execute();
-  await db.schema.createIndex("idx_relationship_type").on("DocumentRelationship").column("relationshipType").execute();
-}
-async function up5(db) {
-  await db.schema.createTable("IndexerState").addColumn("id", "integer", (col) => col.primaryKey().generatedAlwaysAsIdentity()).addColumn("lastOperationId", "integer", (col) => col.notNull()).addColumn("lastOperationTimestamp", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
-}
-async function up6(db) {
-  await db.schema.createTable("DocumentSnapshot").addColumn("id", "text", (col) => col.primaryKey()).addColumn("documentId", "text", (col) => col.notNull()).addColumn("slug", "text").addColumn("name", "text").addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("content", "jsonb", (col) => col.notNull()).addColumn("documentType", "text", (col) => col.notNull()).addColumn("lastOperationIndex", "integer", (col) => col.notNull()).addColumn("lastOperationHash", "text", (col) => col.notNull()).addColumn("lastUpdatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("snapshotVersion", "integer", (col) => col.notNull().defaultTo(1)).addColumn("identifiers", "jsonb").addColumn("metadata", "jsonb").addColumn("isDeleted", "boolean", (col) => col.notNull().defaultTo(false)).addColumn("deletedAt", "timestamptz").addUniqueConstraint("unique_doc_scope_branch", [
-    "documentId",
-    "scope",
-    "branch"
-  ]).execute();
-  await db.schema.createIndex("idx_slug_scope_branch").on("DocumentSnapshot").columns(["slug", "scope", "branch"]).execute();
-  await db.schema.createIndex("idx_doctype_scope_branch").on("DocumentSnapshot").columns(["documentType", "scope", "branch"]).execute();
-  await db.schema.createIndex("idx_last_updated").on("DocumentSnapshot").column("lastUpdatedAt").execute();
-  await db.schema.createIndex("idx_is_deleted").on("DocumentSnapshot").column("isDeleted").execute();
-}
-async function up7(db) {
-  await db.schema.createTable("SlugMapping").addColumn("slug", "text", (col) => col.primaryKey()).addColumn("documentId", "text", (col) => col.notNull()).addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("createdAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updatedAt", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addUniqueConstraint("unique_docid_scope_branch", [
-    "documentId",
-    "scope",
-    "branch"
-  ]).execute();
-  await db.schema.createIndex("idx_slug_documentid").on("SlugMapping").column("documentId").execute();
-}
-async function up8(db) {
-  await db.schema.createTable("ViewState").addColumn("readModelId", "text", (col) => col.primaryKey()).addColumn("lastOrdinal", "integer", (col) => col.notNull().defaultTo(0)).addColumn("lastOperationTimestamp", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
-}
-async function up9(db) {
-  await db.schema.createTable("document_collections").addColumn("documentId", "text", (col) => col.notNull()).addColumn("collectionId", "text", (col) => col.notNull()).addColumn("joinedOrdinal", "bigint", (col) => col.notNull().defaultTo(0)).addColumn("leftOrdinal", "bigint").addPrimaryKeyConstraint("document_collections_pkey", [
-    "documentId",
-    "collectionId"
-  ]).execute();
-  await db.schema.createIndex("idx_document_collections_collectionId").on("document_collections").column("collectionId").execute();
-  await db.schema.createIndex("idx_doc_collections_collection_range").on("document_collections").columns(["collectionId", "joinedOrdinal"]).execute();
-  await db.schema.createTable("operation_index_operations").addColumn("ordinal", "serial", (col) => col.primaryKey()).addColumn("opId", "text", (col) => col.notNull()).addColumn("documentId", "text", (col) => col.notNull()).addColumn("documentType", "text", (col) => col.notNull()).addColumn("scope", "text", (col) => col.notNull()).addColumn("branch", "text", (col) => col.notNull()).addColumn("timestampUtcMs", "text", (col) => col.notNull()).addColumn("writeTimestampUtcMs", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("index", "integer", (col) => col.notNull()).addColumn("skip", "integer", (col) => col.notNull()).addColumn("hash", "text", (col) => col.notNull()).addColumn("action", "jsonb", (col) => col.notNull()).execute();
-  await db.schema.createIndex("idx_operation_index_operations_document").on("operation_index_operations").columns(["documentId", "branch", "scope"]).execute();
-  await db.schema.createIndex("idx_operation_index_operations_ordinal").on("operation_index_operations").column("ordinal").execute();
-}
-async function up10(db) {
-  await db.schema.createTable("sync_remotes").addColumn("name", "text", (col) => col.primaryKey()).addColumn("collection_id", "text", (col) => col.notNull()).addColumn("channel_type", "text", (col) => col.notNull()).addColumn("channel_id", "text", (col) => col.notNull().defaultTo("")).addColumn("remote_name", "text", (col) => col.notNull().defaultTo("")).addColumn("channel_parameters", "jsonb", (col) => col.notNull().defaultTo(sql`'{}'::jsonb`)).addColumn("filter_document_ids", "jsonb").addColumn("filter_scopes", "jsonb").addColumn("filter_branch", "text", (col) => col.notNull().defaultTo("main")).addColumn("push_state", "text", (col) => col.notNull().defaultTo("idle")).addColumn("push_last_success_utc_ms", "text").addColumn("push_last_failure_utc_ms", "text").addColumn("push_failure_count", "integer", (col) => col.notNull().defaultTo(0)).addColumn("pull_state", "text", (col) => col.notNull().defaultTo("idle")).addColumn("pull_last_success_utc_ms", "text").addColumn("pull_last_failure_utc_ms", "text").addColumn("pull_failure_count", "integer", (col) => col.notNull().defaultTo(0)).addColumn("created_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addColumn("updated_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
-  await db.schema.createIndex("idx_sync_remotes_collection").on("sync_remotes").column("collection_id").execute();
-  await db.schema.createTable("sync_cursors").addColumn("remote_name", "text", (col) => col.primaryKey().references("sync_remotes.name").onDelete("cascade")).addColumn("cursor_ordinal", "bigint", (col) => col.notNull().defaultTo(0)).addColumn("last_synced_at_utc_ms", "text").addColumn("updated_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
-  await db.schema.createIndex("idx_sync_cursors_ordinal").on("sync_cursors").column("cursor_ordinal").execute();
-}
-async function up11(db) {
-  await db.deleteFrom("sync_cursors").where("remote_name", "like", "outbox::%").execute();
-  await db.deleteFrom("sync_remotes").where("name", "like", "outbox::%").execute();
-  await db.schema.dropTable("sync_cursors").execute();
-  await db.schema.createTable("sync_cursors").addColumn("remote_name", "text", (col) => col.notNull()).addColumn("cursor_type", "text", (col) => col.notNull().defaultTo("inbox")).addColumn("cursor_ordinal", "bigint", (col) => col.notNull().defaultTo(0)).addColumn("last_synced_at_utc_ms", "text").addColumn("updated_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).addPrimaryKeyConstraint("sync_cursors_pk", ["remote_name", "cursor_type"]).execute();
-  await db.schema.createIndex("idx_sync_cursors_ordinal").on("sync_cursors").column("cursor_ordinal").execute();
-}
-async function up12(db) {
-  await db.schema.alterTable("operation_index_operations").addColumn("sourceRemote", "text", (col) => col.notNull().defaultTo("")).execute();
-}
-async function up13(db) {
-  await db.schema.createTable("sync_dead_letters").addColumn("ordinal", "serial", (col) => col.primaryKey()).addColumn("id", "text", (col) => col.unique().notNull()).addColumn("job_id", "text", (col) => col.notNull()).addColumn("job_dependencies", "jsonb", (col) => col.notNull().defaultTo(sql`'[]'::jsonb`)).addColumn("remote_name", "text", (col) => col.notNull().references("sync_remotes.name").onDelete("cascade")).addColumn("document_id", "text", (col) => col.notNull()).addColumn("scopes", "jsonb", (col) => col.notNull().defaultTo(sql`'[]'::jsonb`)).addColumn("branch", "text", (col) => col.notNull()).addColumn("operations", "jsonb", (col) => col.notNull().defaultTo(sql`'[]'::jsonb`)).addColumn("error_source", "text", (col) => col.notNull()).addColumn("error_message", "text", (col) => col.notNull()).addColumn("created_at", "timestamptz", (col) => col.notNull().defaultTo(sql`NOW()`)).execute();
-  await db.schema.createIndex("idx_sync_dead_letters_remote").on("sync_dead_letters").column("remote_name").execute();
-}
-
-class ProgrammaticMigrationProvider {
-  getMigrations() {
-    return Promise.resolve(migrations);
-  }
-}
-async function runMigrations(db, schema = REACTOR_SCHEMA) {
-  try {
-    await sql`CREATE SCHEMA IF NOT EXISTS ${sql.id(schema)}`.execute(db);
-  } catch (error2) {
-    return {
-      success: false,
-      migrationsExecuted: [],
-      error: error2 instanceof Error ? error2 : new Error("Failed to create schema")
-    };
-  }
-  const migrator = new Migrator({
-    db: db.withSchema(schema),
-    provider: new ProgrammaticMigrationProvider,
-    migrationTableSchema: schema
-  });
-  let error;
-  let results;
-  try {
-    const result = await migrator.migrateToLatest();
-    error = result.error;
-    results = result.results;
-  } catch (e) {
-    error = e;
-    results = [];
-  }
-  const migrationsExecuted = results?.map((result) => result.migrationName) ?? [];
-  if (error) {
-    return {
-      success: false,
-      migrationsExecuted,
-      error: error instanceof Error ? error : new Error("Unknown migration error")
-    };
-  }
-  return {
-    success: true,
-    migrationsExecuted
-  };
-}
-
-class DefaultSubscriptionErrorHandler {
-  handleError(error, context) {
-    const errorMessage = `Subscription error in ${context.eventType} (${context.subscriptionId})`;
-    if (error instanceof Error) {
-      const enhancedError = new Error(`${errorMessage}: ${error.message}`);
-      enhancedError.cause = error;
-      enhancedError.stack = error.stack;
-      throw enhancedError;
-    } else {
-      throw new Error(`${errorMessage}: ${String(error)}`);
-    }
-  }
-}
-
-class ReactorSubscriptionManager {
-  createdSubscriptions = new Map;
-  deletedSubscriptions = new Map;
-  updatedSubscriptions = new Map;
-  relationshipSubscriptions = new Map;
-  subscriptionCounter = 0;
-  errorHandler;
-  constructor(errorHandler) {
-    this.errorHandler = errorHandler;
-  }
-  onDocumentCreated(callback, search) {
-    const id = `created-${++this.subscriptionCounter}`;
-    this.createdSubscriptions.set(id, { id, callback, search });
-    return () => {
-      this.createdSubscriptions.delete(id);
-    };
-  }
-  onDocumentDeleted(callback, search) {
-    const id = `deleted-${++this.subscriptionCounter}`;
-    this.deletedSubscriptions.set(id, { id, callback, search });
-    return () => {
-      this.deletedSubscriptions.delete(id);
-    };
-  }
-  onDocumentStateUpdated(callback, search, view) {
-    const id = `updated-${++this.subscriptionCounter}`;
-    this.updatedSubscriptions.set(id, { id, callback, search, view });
-    return () => {
-      this.updatedSubscriptions.delete(id);
-    };
-  }
-  onRelationshipChanged(callback, search) {
-    const id = `relationship-${++this.subscriptionCounter}`;
-    this.relationshipSubscriptions.set(id, { id, callback, search });
-    return () => {
-      this.relationshipSubscriptions.delete(id);
-    };
-  }
-  notifyDocumentsCreated(documentIds, documentTypes, parentIds) {
-    const result = {
-      results: documentIds,
-      options: { cursor: "", limit: documentIds.length }
-    };
-    for (const subscription of this.createdSubscriptions.values()) {
-      const filteredIds = this.filterDocumentIds(documentIds, subscription.search, documentTypes, parentIds);
-      if (filteredIds.length > 0) {
-        try {
-          subscription.callback({
-            ...result,
-            results: filteredIds
-          });
-        } catch (error) {
-          this.errorHandler.handleError(error, {
-            eventType: "created",
-            subscriptionId: subscription.id,
-            eventData: filteredIds
-          });
-        }
-      }
-    }
-  }
-  notifyDocumentsDeleted(documentIds, documentTypes, parentIds) {
-    for (const subscription of this.deletedSubscriptions.values()) {
-      const filteredIds = this.filterDocumentIds(documentIds, subscription.search, documentTypes, parentIds);
-      if (filteredIds.length > 0) {
-        try {
-          subscription.callback(filteredIds);
-        } catch (error) {
-          this.errorHandler.handleError(error, {
-            eventType: "deleted",
-            subscriptionId: subscription.id,
-            eventData: filteredIds
-          });
-        }
-      }
-    }
-  }
-  notifyDocumentsUpdated(documents) {
-    const result = {
-      results: documents,
-      options: { cursor: "", limit: documents.length }
-    };
-    for (const subscription of this.updatedSubscriptions.values()) {
-      const filteredDocs = this.filterDocuments(documents, subscription.search);
-      if (filteredDocs.length > 0) {
-        try {
-          subscription.callback({
-            ...result,
-            results: filteredDocs
-          });
-        } catch (error) {
-          this.errorHandler.handleError(error, {
-            eventType: "updated",
-            subscriptionId: subscription.id,
-            eventData: filteredDocs
-          });
-        }
-      }
-    }
-  }
-  notifyRelationshipChanged(parentId, childId, changeType, childType) {
-    for (const subscription of this.relationshipSubscriptions.values()) {
-      if (this.matchesRelationshipFilter(parentId, childId, childType, subscription.search)) {
-        try {
-          subscription.callback(parentId, childId, changeType);
-        } catch (error) {
-          this.errorHandler.handleError(error, {
-            eventType: "relationshipChanged",
-            subscriptionId: subscription.id,
-            eventData: { parentId, childId, changeType }
-          });
-        }
-      }
-    }
-  }
-  clearAll() {
-    this.createdSubscriptions.clear();
-    this.deletedSubscriptions.clear();
-    this.updatedSubscriptions.clear();
-    this.relationshipSubscriptions.clear();
-  }
-  filterDocumentIds(documentIds, search, documentTypes, parentIds) {
-    if (!search)
-      return documentIds;
-    return documentIds.filter((id) => {
-      if (search.ids && !search.ids.includes(id))
-        return false;
-      if (search.type && documentTypes) {
-        const docType = documentTypes.get(id);
-        if (docType !== search.type)
-          return false;
-      }
-      if (search.parentId && parentIds) {
-        const parentId = parentIds.get(id);
-        if (parentId !== search.parentId)
-          return false;
-      }
-      return true;
-    });
-  }
-  filterDocuments(documents, search) {
-    if (!search)
-      return documents;
-    return documents.filter((doc) => {
-      if (search.ids && !search.ids.includes(doc.header.id))
-        return false;
-      if (search.type && doc.header.documentType !== search.type)
-        return false;
-      if (search.slugs && !search.slugs.includes(doc.header.slug))
-        return false;
-      return true;
-    });
-  }
-  matchesRelationshipFilter(parentId, childId, childType, search) {
-    if (!search)
-      return true;
-    if (search.parentId && parentId !== search.parentId)
-      return false;
-    if (search.ids && !search.ids.includes(childId))
-      return false;
-    if (search.type && childType && childType !== search.type)
-      return false;
-    return true;
-  }
-}
-
-class SubscriptionNotificationReadModel {
-  subscriptionManager;
-  documentView;
-  constructor(subscriptionManager, documentView) {
-    this.subscriptionManager = subscriptionManager;
-    this.documentView = documentView;
-  }
-  async indexOperations(operations) {
-    if (operations.length === 0)
-      return;
-    const created = [];
-    const deleted = [];
-    const updatedIds = new Set;
-    const documentTypes = new Map;
-    const parentIds = new Map;
-    for (const item of operations) {
-      const { operation, context } = item;
-      const actionType = operation.action.type;
-      documentTypes.set(context.documentId, context.documentType);
-      if (actionType === "CREATE_DOCUMENT") {
-        created.push(context.documentId);
-      } else if (actionType === "DELETE_DOCUMENT") {
-        const input = operation.action.input;
-        const deletedId = input.documentId ?? context.documentId;
-        deleted.push(deletedId);
-      } else if (actionType === "ADD_RELATIONSHIP") {
-        const input = operation.action.input;
-        this.subscriptionManager.notifyRelationshipChanged(input.sourceId, input.targetId, "added", input.childType);
-      } else if (actionType === "REMOVE_RELATIONSHIP") {
-        const input = operation.action.input;
-        this.subscriptionManager.notifyRelationshipChanged(input.sourceId, input.targetId, "removed", input.childType);
-      } else {
-        if (!created.includes(context.documentId)) {
-          updatedIds.add(context.documentId);
-        }
-      }
-    }
-    if (created.length > 0) {
-      this.subscriptionManager.notifyDocumentsCreated(created, documentTypes, parentIds);
-    }
-    if (deleted.length > 0) {
-      this.subscriptionManager.notifyDocumentsDeleted(deleted, documentTypes, parentIds);
-    }
-    if (updatedIds.size > 0 && this.documentView) {
-      const documents = await Promise.all(Array.from(updatedIds).map((id) => this.documentView.get(id)));
-      this.subscriptionManager.notifyDocumentsUpdated(documents);
-    }
-  }
-}
 function rowToRemoteCursor(row) {
   return {
     remoteName: row.remote_name,
@@ -17441,6 +17192,7 @@ class SyncManager {
   batchAggregator;
   syncStatusTracker;
   maxDeadLettersPerRemote;
+  connectionStateUnsubscribes = new Map;
   loadJobs = new Map;
   constructor(logger2, remoteStorage, cursorStorage, deadLetterStorage, channelFactory, operationIndex, reactor, eventBus, maxDeadLettersPerRemote = 100) {
     this.logger = logger2;
@@ -17506,6 +17258,10 @@ class SyncManager {
     this.awaiter.shutdown();
     this.syncAwaiter.shutdown();
     this.syncStatusTracker.clear();
+    for (const unsub of this.connectionStateUnsubscribes.values()) {
+      unsub();
+    }
+    this.connectionStateUnsubscribes.clear();
     const promises = [];
     for (const remote of this.remotes.values()) {
       promises.push(remote.channel.shutdown());
@@ -17587,6 +17343,11 @@ class SyncManager {
     await this.remoteStorage.remove(name);
     await this.cursorStorage.remove(name);
     this.syncStatusTracker.untrackRemote(name);
+    const unsub = this.connectionStateUnsubscribes.get(name);
+    if (unsub) {
+      unsub();
+      this.connectionStateUnsubscribes.delete(name);
+    }
     this.remotes.delete(name);
   }
   list() {
@@ -17604,6 +17365,16 @@ class SyncManager {
   wireChannelCallbacks(remote) {
     remote.channel.inbox.onAdded((syncOps) => this.handleInboxAdded(remote, syncOps));
     this.syncStatusTracker.trackRemote(remote.name, remote.channel);
+    const unsubscribe = remote.channel.onConnectionStateChange((snapshot) => {
+      this.eventBus.emit(SyncEventTypes.CONNECTION_STATE_CHANGED, {
+        remoteName: remote.name,
+        remoteId: remote.id,
+        previous: snapshot.state,
+        current: snapshot.state,
+        snapshot
+      }).catch(() => {});
+    });
+    this.connectionStateUnsubscribes.set(remote.name, unsubscribe);
     remote.channel.deadLetter.onAdded((syncOps) => {
       for (const syncOp of syncOps) {
         this.logger.error("Dead letter (@remote, @documentId, @jobId, @error, @dependencies)", remote.name, syncOp.documentId, syncOp.jobId, syncOp.error?.message ?? "unknown", syncOp.jobDependencies);
@@ -18527,7 +18298,6 @@ class ReactorBuilder {
   logger;
   documentModels = [];
   upgradeManifests = [];
-  storage;
   features = { legacyStorageEnabled: false };
   readModels = [];
   executorManager;
@@ -18556,10 +18326,6 @@ class ReactorBuilder {
     this.upgradeManifests = manifests;
     return this;
   }
-  withLegacyStorage(storage) {
-    this.storage = storage;
-    return this;
-  }
   withFeatures(features) {
     this.features = { ...this.features, ...features };
     return this;
@@ -18683,7 +18449,7 @@ class ReactorBuilder {
     }
     readModelInstances.push(documentView);
     const documentIndexerConsistencyTracker = new ConsistencyTracker;
-    const documentIndexer = new KyselyDocumentIndexer(database, operationStore, documentIndexerConsistencyTracker);
+    const documentIndexer = new KyselyDocumentIndexer(database, operationIndex, writeCache, documentIndexerConsistencyTracker);
     try {
       await documentIndexer.init();
     } catch (error) {
@@ -18693,7 +18459,7 @@ class ReactorBuilder {
     const subscriptionManager = new ReactorSubscriptionManager(new DefaultSubscriptionErrorHandler);
     const subscriptionNotificationReadModel = new SubscriptionNotificationReadModel(subscriptionManager, documentView);
     const processorManagerConsistencyTracker = new ConsistencyTracker;
-    const processorManager = new ProcessorManager(database, operationIndex, writeCache, processorManagerConsistencyTracker);
+    const processorManager = new ProcessorManager(database, operationIndex, writeCache, processorManagerConsistencyTracker, this.logger);
     try {
       await processorManager.init();
     } catch (error) {
@@ -19037,7 +18803,7 @@ var __defProp2, __export2 = (target, all) => {
   }
 }, DocumentDeletedError, InvalidSignatureError, DowngradeNotSupportedError, DocumentNotFoundError, getNextIndexForScope = (document2, scope) => {
   return document2.header.revision[scope] || 0;
-}, EventBusAggregateError, ReactorEventTypes, QueueEventTypes, ModuleNotFoundError, DuplicateModuleError, DuplicateManifestError, ManifestNotFoundError, DowngradeNotSupportedError2, MissingUpgradeTransitionError, InvalidUpgradeStepError, STRICT_ORDER_ACTION_TYPES, MAX_SKIP_THRESHOLD = 1000, documentScopeActions, DRIVE_DOCUMENT_TYPE = "powerhouse/document-drive", ProcessorManager, KyselyDocumentView, ChannelScheme, SyncOperationStatus, ChannelErrorSource, SyncEventTypes, MailboxAggregateError, ChannelError, SyncOperationAggregateError, DEFAULT_CONFIG, syncOpCounter = 0, getLatestAppliedOrdinal = (syncOps) => {
+}, EventBusAggregateError, ReactorEventTypes, QueueEventTypes, ModuleNotFoundError, DuplicateModuleError, DuplicateManifestError, ManifestNotFoundError, DowngradeNotSupportedError2, MissingUpgradeTransitionError, InvalidUpgradeStepError, STRICT_ORDER_ACTION_TYPES, MAX_SKIP_THRESHOLD = 1000, documentScopeActions, DRIVE_DOCUMENT_TYPE = "powerhouse/document-drive", ProcessorManager, KyselyDocumentView, KyselyDocumentIndexer, DuplicateOperationError, RevisionMismatchError, exports_001_create_operation_table, exports_002_create_keyframe_table, exports_003_create_document_table, exports_004_create_document_relationship_table, exports_005_create_indexer_state_table, exports_006_create_document_snapshot_table, exports_007_create_slug_mapping_table, exports_008_create_view_state_table, exports_009_create_operation_index_tables, exports_010_create_sync_tables, exports_011_add_cursor_type_column, exports_012_add_source_remote_column, exports_013_create_sync_dead_letters_table, exports_014_create_processor_cursor_table, REACTOR_SCHEMA = "reactor", migrations, ChannelScheme, SyncOperationStatus, ChannelErrorSource, SyncEventTypes, MailboxAggregateError, ChannelError, SyncOperationAggregateError, DEFAULT_CONFIG, syncOpCounter = 0, getLatestAppliedOrdinal = (syncOps) => {
   let maxOrdinal = 0;
   for (const syncOp of syncOps) {
     if (syncOp.status === 2) {
@@ -19047,7 +18813,7 @@ var __defProp2, __export2 = (target, all) => {
     }
   }
   return maxOrdinal;
-}, DuplicateOperationError, RevisionMismatchError, exports_001_create_operation_table, exports_002_create_keyframe_table, exports_003_create_document_table, exports_004_create_document_relationship_table, exports_005_create_indexer_state_table, exports_006_create_document_snapshot_table, exports_007_create_slug_mapping_table, exports_008_create_view_state_table, exports_009_create_operation_index_tables, exports_010_create_sync_tables, exports_011_add_cursor_type_column, exports_012_add_source_remote_column, exports_013_create_sync_dead_letters_table, REACTOR_SCHEMA = "reactor", migrations, SyncStatus, cachedEncoder, LOG2_26, IS_RELATIONAL_DB_PROCESSOR, RelationalDbProcessor;
+}, SyncStatus, cachedEncoder, LOG2_26, IS_RELATIONAL_DB_PROCESSOR, RelationalDbProcessor;
 var init_src = __esm(() => {
   __defProp2 = Object.defineProperty;
   byteToHex = [];
@@ -23189,19 +22955,24 @@ var init_src = __esm(() => {
     processorsByDrive = new Map;
     factoryToProcessors = new Map;
     knownDriveIds = new Set;
-    constructor(db, operationIndex, writeCache, consistencyTracker) {
-      super(db, operationIndex, writeCache, consistencyTracker, "processor-manager");
+    cursorCache = new Map;
+    logger;
+    constructor(db, operationIndex, writeCache, consistencyTracker, logger2) {
+      super(db, operationIndex, writeCache, consistencyTracker, {
+        readModelId: "processor-manager",
+        rebuildStateOnInit: true
+      });
+      this.logger = logger2;
     }
-    async indexOperations(items) {
-      if (items.length === 0)
-        return;
+    async init() {
+      await super.init();
+      await this.loadAllCursors();
+      await this.discoverExistingDrives();
+    }
+    async commitOperations(items) {
       await this.detectAndRegisterNewDrives(items);
       await this.detectAndCleanupDeletedDrives(items);
       await this.routeOperationsToProcessors(items);
-      await this.db.transaction().execute(async (trx) => {
-        await this.saveState(trx, items);
-      });
-      this.updateConsistencyTracker(items);
     }
     async registerFactory(identifier, factory) {
       if (this.factoryRegistry.has(identifier)) {
@@ -23218,13 +22989,13 @@ var init_src = __esm(() => {
       const factoryProcessors = this.factoryToProcessors.get(identifier);
       if (!factoryProcessors)
         return;
-      for (const [driveId, records] of factoryProcessors) {
-        for (const record of records) {
-          await this.safeDisconnect(record.processor);
+      for (const [driveId, tracked] of factoryProcessors) {
+        for (const t of tracked) {
+          await this.safeDisconnect(t.record.processor);
         }
         const driveProcessors = this.processorsByDrive.get(driveId);
         if (driveProcessors) {
-          const remaining = driveProcessors.filter((p) => !records.includes(p));
+          const remaining = driveProcessors.filter((p) => !tracked.includes(p));
           if (remaining.length > 0) {
             this.processorsByDrive.set(driveId, remaining);
           } else {
@@ -23232,14 +23003,24 @@ var init_src = __esm(() => {
           }
         }
       }
+      await this.deleteProcessorCursors({ factoryId: identifier });
       this.factoryToProcessors.delete(identifier);
       this.factoryRegistry.delete(identifier);
     }
-    getFactoryIdentifiers() {
-      return Array.from(this.factoryRegistry.keys());
+    get(processorId) {
+      for (const tracked of this.allTrackedProcessors()) {
+        if (tracked.processorId === processorId)
+          return tracked;
+      }
+      return;
     }
-    getProcessorsForDrive(driveId) {
-      return this.processorsByDrive.get(driveId) ?? [];
+    getAll() {
+      return Array.from(this.allTrackedProcessors());
+    }
+    *allTrackedProcessors() {
+      for (const tracked of this.processorsByDrive.values()) {
+        yield* tracked;
+      }
     }
     async detectAndRegisterNewDrives(operations) {
       for (const op of operations) {
@@ -23270,6 +23051,12 @@ var init_src = __esm(() => {
         this.knownDriveIds.delete(driveId);
       }
     }
+    async discoverExistingDrives() {
+      const drives = await this.db.selectFrom("DocumentSnapshot").select("documentId").where("documentType", "=", DRIVE_DOCUMENT_TYPE).where("isDeleted", "=", false).execute();
+      for (const drive of drives) {
+        this.knownDriveIds.add(drive.documentId);
+      }
+    }
     isDeletedDocumentADrive(documentId) {
       return this.knownDriveIds.has(documentId);
     }
@@ -23278,71 +23065,214 @@ var init_src = __esm(() => {
       try {
         records = await factory(driveHeader);
       } catch (error) {
-        console.error(`ProcessorManager: Factory '${identifier}' failed for drive '${driveId}':`, error);
+        this.logger.error("Factory '@FactoryId' failed for drive '@DriveId': @Error", identifier, driveId, error);
         return;
       }
       if (records.length === 0)
         return;
+      const trackedList = [];
+      for (let i = 0;i < records.length; i++) {
+        const record = records[i];
+        const processorId = `${identifier}:${driveId}:${i}`;
+        const cached = this.cursorCache.get(processorId);
+        let lastOrdinal;
+        let status;
+        let lastError;
+        let lastErrorTimestamp;
+        if (cached) {
+          lastOrdinal = cached.lastOrdinal;
+          status = cached.status;
+          lastError = cached.lastError ?? undefined;
+          lastErrorTimestamp = cached.lastErrorTimestamp ?? undefined;
+        } else {
+          const startFrom = record.startFrom ?? "beginning";
+          lastOrdinal = startFrom === "current" ? this.lastOrdinal : 0;
+          status = "active";
+          lastError = undefined;
+          lastErrorTimestamp = undefined;
+        }
+        const tracked = {
+          processorId,
+          factoryId: identifier,
+          driveId,
+          processorIndex: i,
+          record,
+          lastOrdinal,
+          status,
+          lastError,
+          lastErrorTimestamp,
+          retry: () => this.retryProcessor(tracked)
+        };
+        trackedList.push(tracked);
+        await this.saveProcessorCursor(tracked);
+      }
+      await this.db.deleteFrom("ProcessorCursor").where("factoryId", "=", identifier).where("driveId", "=", driveId).where("processorIndex", ">=", records.length).execute();
+      for (const [id, row] of this.cursorCache) {
+        if (row.factoryId === identifier && row.driveId === driveId && row.processorIndex >= records.length) {
+          this.cursorCache.delete(id);
+        }
+      }
       const factoryProcessors = this.factoryToProcessors.get(identifier);
       if (factoryProcessors) {
-        factoryProcessors.set(driveId, records);
+        factoryProcessors.set(driveId, trackedList);
       }
       const existingDriveProcessors = this.processorsByDrive.get(driveId) ?? [];
       this.processorsByDrive.set(driveId, [
         ...existingDriveProcessors,
-        ...records
+        ...trackedList
       ]);
+      for (const tracked of trackedList) {
+        if (tracked.status === "active" && tracked.lastOrdinal < this.lastOrdinal) {
+          await this.backfillProcessor(tracked);
+        }
+      }
+    }
+    async backfillProcessor(tracked) {
+      let page = await this.operationIndex.getSinceOrdinal(tracked.lastOrdinal);
+      while (page.results.length > 0) {
+        const matching = page.results.filter((op) => matchesFilter(op, tracked.record.filter));
+        if (matching.length > 0) {
+          try {
+            await tracked.record.processor.onOperations(matching);
+          } catch (error) {
+            tracked.status = "errored";
+            tracked.lastError = error instanceof Error ? error.message : String(error);
+            tracked.lastErrorTimestamp = new Date;
+            await this.safeSaveProcessorCursor(tracked);
+            this.logger.error("Processor '@ProcessorId' failed during backfill at ordinal @Ordinal: @Error", tracked.processorId, tracked.lastOrdinal, error);
+            return;
+          }
+        }
+        const maxOrdinal = Math.max(...page.results.map((op) => op.context.ordinal));
+        tracked.lastOrdinal = maxOrdinal;
+        await this.safeSaveProcessorCursor(tracked);
+        if (!page.next)
+          break;
+        page = await page.next();
+      }
+    }
+    async retryProcessor(tracked) {
+      if (tracked.status !== "errored")
+        return;
+      tracked.status = "active";
+      tracked.lastError = undefined;
+      tracked.lastErrorTimestamp = undefined;
+      await this.saveProcessorCursor(tracked);
+      await this.backfillProcessor(tracked);
     }
     async cleanupDriveProcessors(driveId) {
       const processors = this.processorsByDrive.get(driveId);
       if (!processors)
         return;
-      for (const record of processors) {
-        await this.safeDisconnect(record.processor);
+      for (const tracked of processors) {
+        await this.safeDisconnect(tracked.record.processor);
       }
       this.processorsByDrive.delete(driveId);
       for (const factoryProcessors of this.factoryToProcessors.values()) {
         factoryProcessors.delete(driveId);
       }
+      await this.deleteProcessorCursors({ driveId });
     }
     async safeDisconnect(processor) {
       try {
         await processor.onDisconnect();
       } catch (error) {
-        console.error("ProcessorManager: Error disconnecting processor:", error);
+        this.logger.error("Error disconnecting processor: @Error", error);
       }
     }
     async routeOperationsToProcessors(operations) {
-      const processorOperations = new Map;
-      for (const [, records] of this.processorsByDrive) {
-        for (const { processor, filter } of records) {
-          const matching = operations.filter((op) => matchesFilter(op, filter));
-          if (matching.length === 0)
-            continue;
-          const existing = processorOperations.get(processor) ?? [];
-          processorOperations.set(processor, [...existing, ...matching]);
+      const maxOrdinal = Math.max(...operations.map((op) => op.context.ordinal));
+      const allTracked = Array.from(this.allTrackedProcessors());
+      await Promise.all(allTracked.map(async (tracked) => {
+        if (tracked.status !== "active")
+          return;
+        const unseen = operations.filter((op) => op.context.ordinal > tracked.lastOrdinal);
+        const matching = unseen.filter((op) => matchesFilter(op, tracked.record.filter));
+        if (matching.length > 0) {
+          try {
+            await tracked.record.processor.onOperations(matching);
+          } catch (error) {
+            tracked.status = "errored";
+            tracked.lastError = error instanceof Error ? error.message : String(error);
+            tracked.lastErrorTimestamp = new Date;
+            await this.safeSaveProcessorCursor(tracked);
+            this.logger.error("Processor '@ProcessorId' failed at ordinal @Ordinal: @Error", tracked.processorId, tracked.lastOrdinal, error);
+            return;
+          }
         }
+        tracked.lastOrdinal = maxOrdinal;
+        await this.safeSaveProcessorCursor(tracked);
+      }));
+    }
+    async loadAllCursors() {
+      const rows = await this.db.selectFrom("ProcessorCursor").selectAll().execute();
+      for (const row of rows) {
+        this.cursorCache.set(row.processorId, row);
       }
-      await Promise.all(Array.from(processorOperations.entries()).map(async ([processor, ops]) => {
-        try {
-          await processor.onOperations(ops);
-        } catch (error) {
-          console.error("ProcessorManager: Error in processor.onOperations:", error);
+    }
+    async safeSaveProcessorCursor(tracked) {
+      try {
+        await this.saveProcessorCursor(tracked);
+      } catch (error) {
+        this.logger.error("Failed to persist cursor for '@ProcessorId': @Error", tracked.processorId, error);
+      }
+    }
+    async saveProcessorCursor(tracked) {
+      await this.db.insertInto("ProcessorCursor").values({
+        processorId: tracked.processorId,
+        factoryId: tracked.factoryId,
+        driveId: tracked.driveId,
+        processorIndex: tracked.processorIndex,
+        lastOrdinal: tracked.lastOrdinal,
+        status: tracked.status,
+        lastError: tracked.lastError ?? null,
+        lastErrorTimestamp: tracked.lastErrorTimestamp ?? null,
+        updatedAt: new Date
+      }).onConflict((oc) => oc.column("processorId").doUpdateSet({
+        lastOrdinal: tracked.lastOrdinal,
+        status: tracked.status,
+        lastError: tracked.lastError ?? null,
+        lastErrorTimestamp: tracked.lastErrorTimestamp ?? null,
+        updatedAt: new Date
+      })).execute();
+      this.cursorCache.set(tracked.processorId, {
+        processorId: tracked.processorId,
+        factoryId: tracked.factoryId,
+        driveId: tracked.driveId,
+        processorIndex: tracked.processorIndex,
+        lastOrdinal: tracked.lastOrdinal,
+        status: tracked.status,
+        lastError: tracked.lastError ?? null,
+        lastErrorTimestamp: tracked.lastErrorTimestamp ?? null,
+        createdAt: new Date,
+        updatedAt: new Date
+      });
+    }
+    async deleteProcessorCursors(filter) {
+      if ("factoryId" in filter) {
+        await this.db.deleteFrom("ProcessorCursor").where("factoryId", "=", filter.factoryId).execute();
+        for (const [id, row] of this.cursorCache) {
+          if (row.factoryId === filter.factoryId)
+            this.cursorCache.delete(id);
         }
-      }));
+      } else {
+        await this.db.deleteFrom("ProcessorCursor").where("driveId", "=", filter.driveId).execute();
+        for (const [id, row] of this.cursorCache) {
+          if (row.driveId === filter.driveId)
+            this.cursorCache.delete(id);
+        }
+      }
     }
   };
   KyselyDocumentView = class KyselyDocumentView extends BaseReadModel {
     operationStore;
     _db;
     constructor(db, operationStore, operationIndex, writeCache, consistencyTracker) {
-      super(db, operationIndex, writeCache, consistencyTracker, "document-view");
+      super(db, operationIndex, writeCache, consistencyTracker, { readModelId: "document-view", rebuildStateOnInit: true });
       this.operationStore = operationStore;
       this._db = db;
     }
-    async indexOperations(items) {
-      if (items.length === 0)
-        return;
+    async commitOperations(items) {
       await this._db.transaction().execute(async (trx) => {
         for (const item of items) {
           const { operation, context } = item;
@@ -23446,9 +23376,7 @@ var init_src = __esm(() => {
             }
           }
         }
-        await this.saveState(trx, items);
       });
-      this.updateConsistencyTracker(items);
     }
     async exists(documentIds, consistencyToken, signal) {
       if (consistencyToken) {
@@ -23693,63 +23621,278 @@ var init_src = __esm(() => {
       return resolvedDocumentId;
     }
   };
-  ((ChannelScheme2) => {
-    ChannelScheme2["CONNECT"] = "connect";
-    ChannelScheme2["SWITCHBOARD"] = "switchboard";
-  })(ChannelScheme ||= {});
-  ((SyncOperationStatus2) => {
-    SyncOperationStatus2[SyncOperationStatus2["Unknown"] = -1] = "Unknown";
-    SyncOperationStatus2[SyncOperationStatus2["TransportPending"] = 0] = "TransportPending";
-    SyncOperationStatus2[SyncOperationStatus2["ExecutionPending"] = 1] = "ExecutionPending";
-    SyncOperationStatus2[SyncOperationStatus2["Applied"] = 2] = "Applied";
-    SyncOperationStatus2[SyncOperationStatus2["Error"] = 3] = "Error";
-  })(SyncOperationStatus ||= {});
-  ((ChannelErrorSource2) => {
-    ChannelErrorSource2["None"] = "none";
-    ChannelErrorSource2["Channel"] = "channel";
-    ChannelErrorSource2["Inbox"] = "inbox";
-    ChannelErrorSource2["Outbox"] = "outbox";
-  })(ChannelErrorSource ||= {});
-  SyncEventTypes = {
-    SYNC_PENDING: 20001,
-    SYNC_SUCCEEDED: 20002,
-    SYNC_FAILED: 20003,
-    DEAD_LETTER_ADDED: 20004
-  };
-  MailboxAggregateError = class MailboxAggregateError extends Error {
-    errors;
-    constructor(errors2) {
-      const messages = errors2.map((e) => e.message).join("; ");
-      super(`Mailbox callback failed with ${errors2.length} error(s): ${messages}`);
-      this.name = "MailboxAggregateError";
-      this.errors = errors2;
+  KyselyDocumentIndexer = class KyselyDocumentIndexer extends BaseReadModel {
+    _db;
+    constructor(db, operationIndex, writeCache, consistencyTracker) {
+      super(db, operationIndex, writeCache, consistencyTracker, { readModelId: "document-indexer", rebuildStateOnInit: false });
+      this._db = db;
     }
-  };
-  ChannelError = class ChannelError extends Error {
-    source;
-    error;
-    constructor(source, error) {
-      super(`ChannelError[${source}]: ${error.message}`);
-      this.name = "ChannelError";
-      this.source = source;
-      this.error = error;
+    async commitOperations(items) {
+      await this._db.transaction().execute(async (trx) => {
+        for (const item of items) {
+          const { operation } = item;
+          const actionType = operation.action.type;
+          if (actionType === "ADD_RELATIONSHIP") {
+            await this.handleAddRelationship(trx, operation);
+          } else if (actionType === "REMOVE_RELATIONSHIP") {
+            await this.handleRemoveRelationship(trx, operation);
+          }
+        }
+      });
     }
-  };
-  SyncOperationAggregateError = class SyncOperationAggregateError extends Error {
-    errors;
-    constructor(errors2) {
-      const messages = errors2.map((e) => e.message).join("; ");
-      super(`SyncOperation callback failed with ${errors2.length} error(s): ${messages}`);
-      this.name = "SyncOperationAggregateError";
-      this.errors = errors2;
+    async getOutgoing(documentId, types2, paging, consistencyToken, signal) {
+      if (consistencyToken) {
+        await this.waitForConsistency(consistencyToken, undefined, signal);
+      }
+      if (signal?.aborted) {
+        throw new Error("Operation aborted");
+      }
+      const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
+      const limit = paging?.limit || 100;
+      let query = this._db.selectFrom("DocumentRelationship").selectAll().where("sourceId", "=", documentId);
+      if (types2 && types2.length > 0) {
+        query = query.where("relationshipType", "in", types2);
+      }
+      const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").offset(startIndex).limit(limit + 1).execute();
+      const hasMore = rows.length > limit;
+      const results = hasMore ? rows.slice(0, limit) : rows;
+      const nextCursor = hasMore ? String(startIndex + limit) : undefined;
+      return {
+        results: results.map((row) => ({
+          sourceId: row.sourceId,
+          targetId: row.targetId,
+          relationshipType: row.relationshipType,
+          metadata: row.metadata ? row.metadata : undefined,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt
+        })),
+        options: paging || { cursor: "0", limit: 100 },
+        nextCursor,
+        next: hasMore ? () => this.getOutgoing(documentId, types2, { cursor: nextCursor, limit }, consistencyToken, signal) : undefined
+      };
+    }
+    async getIncoming(documentId, types2, paging, consistencyToken, signal) {
+      if (consistencyToken) {
+        await this.waitForConsistency(consistencyToken, undefined, signal);
+      }
+      if (signal?.aborted) {
+        throw new Error("Operation aborted");
+      }
+      const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
+      const limit = paging?.limit || 100;
+      let query = this._db.selectFrom("DocumentRelationship").selectAll().where("targetId", "=", documentId);
+      if (types2 && types2.length > 0) {
+        query = query.where("relationshipType", "in", types2);
+      }
+      const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").offset(startIndex).limit(limit + 1).execute();
+      const hasMore = rows.length > limit;
+      const results = hasMore ? rows.slice(0, limit) : rows;
+      const nextCursor = hasMore ? String(startIndex + limit) : undefined;
+      return {
+        results: results.map((row) => ({
+          sourceId: row.sourceId,
+          targetId: row.targetId,
+          relationshipType: row.relationshipType,
+          metadata: row.metadata ? row.metadata : undefined,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt
+        })),
+        options: paging || { cursor: "0", limit: 100 },
+        nextCursor,
+        next: hasMore ? () => this.getIncoming(documentId, types2, { cursor: nextCursor, limit }, consistencyToken, signal) : undefined
+      };
+    }
+    async hasRelationship(sourceId, targetId, types2, consistencyToken, signal) {
+      if (consistencyToken) {
+        await this.waitForConsistency(consistencyToken, undefined, signal);
+      }
+      if (signal?.aborted) {
+        throw new Error("Operation aborted");
+      }
+      let query = this._db.selectFrom("DocumentRelationship").select("id").where("sourceId", "=", sourceId).where("targetId", "=", targetId);
+      if (types2 && types2.length > 0) {
+        query = query.where("relationshipType", "in", types2);
+      }
+      const result = await query.executeTakeFirst();
+      return result !== undefined;
+    }
+    async getUndirectedRelationships(a, b, types2, paging, consistencyToken, signal) {
+      if (consistencyToken) {
+        await this.waitForConsistency(consistencyToken, undefined, signal);
+      }
+      if (signal?.aborted) {
+        throw new Error("Operation aborted");
+      }
+      const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
+      const limit = paging?.limit || 100;
+      let query = this._db.selectFrom("DocumentRelationship").selectAll().where((eb) => eb.or([
+        eb.and([eb("sourceId", "=", a), eb("targetId", "=", b)]),
+        eb.and([eb("sourceId", "=", b), eb("targetId", "=", a)])
+      ]));
+      if (types2 && types2.length > 0) {
+        query = query.where("relationshipType", "in", types2);
+      }
+      const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").offset(startIndex).limit(limit + 1).execute();
+      const hasMore = rows.length > limit;
+      const results = hasMore ? rows.slice(0, limit) : rows;
+      const nextCursor = hasMore ? String(startIndex + limit) : undefined;
+      return {
+        results: results.map((row) => ({
+          sourceId: row.sourceId,
+          targetId: row.targetId,
+          relationshipType: row.relationshipType,
+          metadata: row.metadata ? row.metadata : undefined,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt
+        })),
+        options: paging || { cursor: "0", limit: 100 },
+        nextCursor,
+        next: hasMore ? () => this.getUndirectedRelationships(a, b, types2, { cursor: nextCursor, limit }, consistencyToken, signal) : undefined
+      };
+    }
+    async getDirectedRelationships(sourceId, targetId, types2, paging, consistencyToken, signal) {
+      if (consistencyToken) {
+        await this.waitForConsistency(consistencyToken, undefined, signal);
+      }
+      if (signal?.aborted) {
+        throw new Error("Operation aborted");
+      }
+      const startIndex = paging?.cursor ? parseInt(paging.cursor) : 0;
+      const limit = paging?.limit || 100;
+      let query = this._db.selectFrom("DocumentRelationship").selectAll().where("sourceId", "=", sourceId).where("targetId", "=", targetId);
+      if (types2 && types2.length > 0) {
+        query = query.where("relationshipType", "in", types2);
+      }
+      const rows = await query.orderBy("createdAt", "asc").orderBy("id", "asc").offset(startIndex).limit(limit + 1).execute();
+      const hasMore = rows.length > limit;
+      const results = hasMore ? rows.slice(0, limit) : rows;
+      const nextCursor = hasMore ? String(startIndex + limit) : undefined;
+      return {
+        results: results.map((row) => ({
+          sourceId: row.sourceId,
+          targetId: row.targetId,
+          relationshipType: row.relationshipType,
+          metadata: row.metadata ? row.metadata : undefined,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt
+        })),
+        options: paging || { cursor: "0", limit: 100 },
+        nextCursor,
+        next: hasMore ? () => this.getDirectedRelationships(sourceId, targetId, types2, { cursor: nextCursor, limit }, consistencyToken, signal) : undefined
+      };
+    }
+    async findPath(sourceId, targetId, types2, consistencyToken, signal) {
+      if (consistencyToken) {
+        await this.waitForConsistency(consistencyToken, undefined, signal);
+      }
+      if (signal?.aborted) {
+        throw new Error("Operation aborted");
+      }
+      if (sourceId === targetId) {
+        return [sourceId];
+      }
+      const visited = new Set;
+      const queue = [
+        { id: sourceId, path: [sourceId] }
+      ];
+      while (queue.length > 0) {
+        const current = queue.shift();
+        if (current.id === targetId) {
+          return current.path;
+        }
+        if (visited.has(current.id)) {
+          continue;
+        }
+        visited.add(current.id);
+        const outgoingPage = await this.getOutgoing(current.id, types2, undefined, consistencyToken, signal);
+        const outgoingRelationships = await collectAllPages(outgoingPage, signal);
+        for (const rel of outgoingRelationships) {
+          if (!visited.has(rel.targetId)) {
+            queue.push({
+              id: rel.targetId,
+              path: [...current.path, rel.targetId]
+            });
+          }
+        }
+      }
+      return null;
+    }
+    async findAncestors(documentId, types2, consistencyToken, signal) {
+      if (consistencyToken) {
+        await this.waitForConsistency(consistencyToken, undefined, signal);
+      }
+      if (signal?.aborted) {
+        throw new Error("Operation aborted");
+      }
+      const nodes = new Set([documentId]);
+      const edges = [];
+      const queue = [documentId];
+      const visited = new Set;
+      while (queue.length > 0) {
+        const currentId = queue.shift();
+        if (visited.has(currentId)) {
+          continue;
+        }
+        visited.add(currentId);
+        const incomingPage = await this.getIncoming(currentId, types2, undefined, consistencyToken, signal);
+        const incomingRelationships = await collectAllPages(incomingPage, signal);
+        for (const rel of incomingRelationships) {
+          nodes.add(rel.sourceId);
+          edges.push({
+            from: rel.sourceId,
+            to: rel.targetId,
+            type: rel.relationshipType
+          });
+          if (!visited.has(rel.sourceId)) {
+            queue.push(rel.sourceId);
+          }
+        }
+      }
+      return {
+        nodes: Array.from(nodes),
+        edges
+      };
+    }
+    async getRelationshipTypes(consistencyToken, signal) {
+      if (consistencyToken) {
+        await this.waitForConsistency(consistencyToken, undefined, signal);
+      }
+      if (signal?.aborted) {
+        throw new Error("Operation aborted");
+      }
+      const rows = await this._db.selectFrom("DocumentRelationship").select("relationshipType").distinct().execute();
+      return rows.map((row) => row.relationshipType);
+    }
+    async handleAddRelationship(trx, operation) {
+      const input = operation.action.input;
+      const existingDoc = await trx.selectFrom("Document").select("id").where("id", "=", input.sourceId).executeTakeFirst();
+      if (!existingDoc) {
+        await trx.insertInto("Document").values({
+          id: input.sourceId
+        }).execute();
+      }
+      const existingTargetDoc = await trx.selectFrom("Document").select("id").where("id", "=", input.targetId).executeTakeFirst();
+      if (!existingTargetDoc) {
+        await trx.insertInto("Document").values({
+          id: input.targetId
+        }).execute();
+      }
+      const existingRel = await trx.selectFrom("DocumentRelationship").select("id").where("sourceId", "=", input.sourceId).where("targetId", "=", input.targetId).where("relationshipType", "=", input.relationshipType).executeTakeFirst();
+      if (!existingRel) {
+        const relationship = {
+          id: v4_default(),
+          sourceId: input.sourceId,
+          targetId: input.targetId,
+          relationshipType: input.relationshipType,
+          metadata: input.metadata || null
+        };
+        await trx.insertInto("DocumentRelationship").values(relationship).execute();
+      }
+    }
+    async handleRemoveRelationship(trx, operation) {
+      const input = operation.action.input;
+      await trx.deleteFrom("DocumentRelationship").where("sourceId", "=", input.sourceId).where("targetId", "=", input.targetId).where("relationshipType", "=", input.relationshipType).execute();
     }
-  };
-  DEFAULT_CONFIG = {
-    intervalMs: 2000,
-    maxQueueDepth: 100,
-    backpressureCheckIntervalMs: 500,
-    retryBaseDelayMs: 1000,
-    retryMaxDelayMs: 300000
   };
   DuplicateOperationError = class DuplicateOperationError extends Error {
     constructor(description) {
@@ -23815,6 +23958,10 @@ var init_src = __esm(() => {
   __export2(exports_013_create_sync_dead_letters_table, {
     up: () => up13
   });
+  exports_014_create_processor_cursor_table = {};
+  __export2(exports_014_create_processor_cursor_table, {
+    up: () => up14
+  });
   migrations = {
     "001_create_operation_table": exports_001_create_operation_table,
     "002_create_keyframe_table": exports_002_create_keyframe_table,
@@ -23828,7 +23975,67 @@ var init_src = __esm(() => {
     "010_create_sync_tables": exports_010_create_sync_tables,
     "011_add_cursor_type_column": exports_011_add_cursor_type_column,
     "012_add_source_remote_column": exports_012_add_source_remote_column,
-    "013_create_sync_dead_letters_table": exports_013_create_sync_dead_letters_table
+    "013_create_sync_dead_letters_table": exports_013_create_sync_dead_letters_table,
+    "014_create_processor_cursor_table": exports_014_create_processor_cursor_table
+  };
+  ((ChannelScheme2) => {
+    ChannelScheme2["CONNECT"] = "connect";
+    ChannelScheme2["SWITCHBOARD"] = "switchboard";
+  })(ChannelScheme ||= {});
+  ((SyncOperationStatus2) => {
+    SyncOperationStatus2[SyncOperationStatus2["Unknown"] = -1] = "Unknown";
+    SyncOperationStatus2[SyncOperationStatus2["TransportPending"] = 0] = "TransportPending";
+    SyncOperationStatus2[SyncOperationStatus2["ExecutionPending"] = 1] = "ExecutionPending";
+    SyncOperationStatus2[SyncOperationStatus2["Applied"] = 2] = "Applied";
+    SyncOperationStatus2[SyncOperationStatus2["Error"] = 3] = "Error";
+  })(SyncOperationStatus ||= {});
+  ((ChannelErrorSource2) => {
+    ChannelErrorSource2["None"] = "none";
+    ChannelErrorSource2["Channel"] = "channel";
+    ChannelErrorSource2["Inbox"] = "inbox";
+    ChannelErrorSource2["Outbox"] = "outbox";
+  })(ChannelErrorSource ||= {});
+  SyncEventTypes = {
+    SYNC_PENDING: 20001,
+    SYNC_SUCCEEDED: 20002,
+    SYNC_FAILED: 20003,
+    DEAD_LETTER_ADDED: 20004,
+    CONNECTION_STATE_CHANGED: 20005
+  };
+  MailboxAggregateError = class MailboxAggregateError extends Error {
+    errors;
+    constructor(errors2) {
+      const messages = errors2.map((e) => e.message).join("; ");
+      super(`Mailbox callback failed with ${errors2.length} error(s): ${messages}`);
+      this.name = "MailboxAggregateError";
+      this.errors = errors2;
+    }
+  };
+  ChannelError = class ChannelError extends Error {
+    source;
+    error;
+    constructor(source, error) {
+      super(`ChannelError[${source}]: ${error.message}`);
+      this.name = "ChannelError";
+      this.source = source;
+      this.error = error;
+    }
+  };
+  SyncOperationAggregateError = class SyncOperationAggregateError extends Error {
+    errors;
+    constructor(errors2) {
+      const messages = errors2.map((e) => e.message).join("; ");
+      super(`SyncOperation callback failed with ${errors2.length} error(s): ${messages}`);
+      this.name = "SyncOperationAggregateError";
+      this.errors = errors2;
+    }
+  };
+  DEFAULT_CONFIG = {
+    intervalMs: 2000,
+    maxQueueDepth: 100,
+    backpressureCheckIntervalMs: 500,
+    retryBaseDelayMs: 1000,
+    retryMaxDelayMs: 300000
   };
   ((SyncStatus2) => {
     SyncStatus2["Synced"] = "SYNCED";
@@ -23946,6 +24153,8 @@ __export(exports_src, {
   useDocumentById: () => useDocumentById,
   useDocument: () => useDocument,
   useDefaultDriveEditorModule: () => useDefaultDriveEditorModule,
+  useConnectionStates: () => useConnectionStates,
+  useConnectionState: () => useConnectionState,
   useAllowedDocumentTypes: () => useAllowedDocumentTypes,
   useAllowedDocumentModelModules: () => useAllowedDocumentModelModules,
   truncateAllTables: () => dropAllTables,
@@ -24052,6 +24261,7 @@ __export(exports_src, {
   RemoteDocumentController: () => RemoteDocumentController,
   RemoteClient: () => RemoteClient,
   RelationalDbProcessor: () => RelationalDbProcessor,
+  RegistryClient: () => RegistryClient,
   ReactorClientDocumentCache: () => ReactorClientDocumentCache,
   ReactorClientBuilder: () => ReactorClientBuilder,
   ReactorBuilder: () => ReactorBuilder,
@@ -24115,14 +24325,15 @@ import {
 import { documentModelDocumentModelModule } from "document-model";
 import { useSyncExternalStore } from "react";
 import { useSyncExternalStore as useSyncExternalStore2 } from "react";
+import { useEffect, useRef, useState } from "react";
 import { logger as logger5 } from "document-drive";
-import { use, useCallback, useSyncExternalStore as useSyncExternalStore3 } from "react";
-import { useEffect, useState } from "react";
+import { use, useCallback as useCallback2, useSyncExternalStore as useSyncExternalStore3 } from "react";
+import { useEffect as useEffect2, useState as useState2 } from "react";
 import {
   DocumentModelNotFoundError,
   DocumentNotFoundError as DocumentNotFoundError2
 } from "document-drive";
-import { useCallback as useCallback2, useEffect as useEffect2, useRef, useState as useState2 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
 import { isFileNode as isFileNode2 } from "document-drive";
 import { useMemo } from "react";
 import {
@@ -24133,19 +24344,19 @@ import {
 import { createState } from "document-model";
 import { defaultBaseState as defaultBaseState2, generateId as generateId22 } from "document-model/core";
 import { logger as logger6 } from "document-drive";
-import { useEffect as useEffect3, useState as useState3 } from "react";
 import { useEffect as useEffect4, useState as useState4 } from "react";
+import { useEffect as useEffect5, useState as useState5 } from "react";
 import { createRelationalDbLegacy } from "document-drive";
 import { useMemo as useMemo2 } from "react";
-import { useEffect as useEffect5, useRef as useRef2, useState as useState5 } from "react";
-import { useCallback as useCallback3, useMemo as useMemo3, useRef as useRef3 } from "react";
-import { useCallback as useCallback4, useEffect as useEffect6, useRef as useRef4, useState as useState6 } from "react";
+import { useEffect as useEffect6, useRef as useRef3, useState as useState6 } from "react";
+import { useCallback as useCallback4, useMemo as useMemo3, useRef as useRef4 } from "react";
+import { useCallback as useCallback5, useEffect as useEffect7, useRef as useRef5, useState as useState7 } from "react";
 import { jsxDEV } from "react/jsx-dev-runtime";
 import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
-import { useCallback as useCallback5, useEffect as useEffect7, useRef as useRef5, useState as useState7 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect8, useRef as useRef6, useState as useState8 } from "react";
 import { jsxDEV as jsxDEV3 } from "react/jsx-dev-runtime";
 import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
-import { useEffect as useEffect8, useRef as useRef6 } from "react";
+import { useEffect as useEffect9, useRef as useRef7 } from "react";
 function asUint8Array(buf) {
   if (globalThis.Buffer != null) {
     return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
@@ -27577,6 +27788,52 @@ function useAllowedDocumentModelModules() {
     return documentModelModules;
   return documentModelModules?.filter((module) => allowedDocumentTypes.includes(module.documentModel.global.id));
 }
+function useConnectionStates() {
+  const syncManager = useSync();
+  const [states, setStates] = useState(() => buildSnapshot(syncManager));
+  const unsubscribesRef = useRef([]);
+  useEffect(() => {
+    if (!syncManager)
+      return;
+    function subscribe() {
+      for (const unsub of unsubscribesRef.current) {
+        unsub();
+      }
+      unsubscribesRef.current = [];
+      const remotes = syncManager.list();
+      for (const remote of remotes) {
+        const unsub = remote.channel.onConnectionStateChange(() => {
+          setStates(buildSnapshot(syncManager));
+        });
+        unsubscribesRef.current.push(unsub);
+      }
+      setStates(buildSnapshot(syncManager));
+    }
+    subscribe();
+    const interval = setInterval(subscribe, 5000);
+    return () => {
+      clearInterval(interval);
+      for (const unsub of unsubscribesRef.current) {
+        unsub();
+      }
+      unsubscribesRef.current = [];
+    };
+  }, [syncManager]);
+  return states;
+}
+function useConnectionState(remoteName) {
+  const states = useConnectionStates();
+  return states.get(remoteName);
+}
+function buildSnapshot(syncManager) {
+  const map = new Map;
+  if (!syncManager)
+    return map;
+  for (const remote of syncManager.list()) {
+    map.set(remote.name, remote.channel.getConnectionState());
+  }
+  return map;
+}
 function sortNodesByName(nodes) {
   return nodes.toSorted((a, b) => a.name.localeCompare(b.name));
 }
@@ -27634,7 +27891,7 @@ function useDocuments(ids) {
 }
 function useGetDocument() {
   const documentCache = useDocumentCache();
-  return useCallback((id) => {
+  return useCallback2((id) => {
     if (!documentCache) {
       return Promise.reject(new Error("Document cache not initialized"));
     }
@@ -27643,7 +27900,7 @@ function useGetDocument() {
 }
 function useGetDocuments() {
   const documentCache = useDocumentCache();
-  return useCallback((ids) => {
+  return useCallback2((ids) => {
     if (!documentCache) {
       return Promise.reject(new Error("Document cache not initialized"));
     }
@@ -27945,8 +28202,8 @@ function setPHDocumentEditorConfig(config) {
   }
 }
 function useSetPHDriveEditorConfig(config) {
-  const [isInitialized, setIsInitialized] = useState(false);
-  useEffect(() => {
+  const [isInitialized, setIsInitialized] = useState2(false);
+  useEffect2(() => {
     if (isInitialized)
       return;
     setPHDriveEditorConfig(config);
@@ -27954,8 +28211,8 @@ function useSetPHDriveEditorConfig(config) {
   }, [config, isInitialized]);
 }
 function useSetPHDocumentEditorConfig(config) {
-  const [isInitialized, setIsInitialized] = useState(false);
-  useEffect(() => {
+  const [isInitialized, setIsInitialized] = useState2(false);
+  useEffect2(() => {
     if (isInitialized)
       return;
     setPHDocumentEditorConfig(config);
@@ -27988,14 +28245,14 @@ function useDocumentOfType(documentId, documentType) {
 }
 function useDocumentOperations(documentId) {
   const reactorClient = useReactorClient();
-  const hasFetchedRef = useRef(false);
-  const [state, setState] = useState2(() => ({
+  const hasFetchedRef = useRef2(false);
+  const [state, setState] = useState3(() => ({
     globalOperations: [],
     localOperations: [],
     isLoading: !!documentId,
     error: undefined
   }));
-  const fetchOperations = useCallback2(async (retryCount = 0) => {
+  const fetchOperations = useCallback3(async (retryCount = 0) => {
     const MAX_RETRIES = 5;
     const RETRY_DELAY_MS = 500;
     if (!documentId || !reactorClient) {
@@ -28041,7 +28298,7 @@ function useDocumentOperations(documentId) {
     });
     hasFetchedRef.current = true;
   }, [documentId, reactorClient]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (documentId && reactorClient) {
       fetchOperations();
     } else if (!documentId) {
@@ -28054,7 +28311,7 @@ function useDocumentOperations(documentId) {
       hasFetchedRef.current = false;
     }
   }, [documentId, reactorClient, fetchOperations]);
-  const refetch = useCallback2(() => {
+  const refetch = useCallback3(() => {
     fetchOperations(0);
   }, [fetchOperations]);
   return { ...state, refetch };
@@ -28556,8 +28813,8 @@ async function logout() {
 }
 function useUser() {
   const renown = useRenown();
-  const [user, setUser] = useState3(() => renown?.user);
-  useEffect3(() => {
+  const [user, setUser] = useState4(() => renown?.user);
+  useEffect4(() => {
     setUser(renown?.user);
     if (!renown)
       return;
@@ -28567,8 +28824,8 @@ function useUser() {
 }
 function useLoginStatus() {
   const renown = useRenown();
-  const [status, setStatus] = useState3(() => renown ? renown.status : "initializing");
-  useEffect3(() => {
+  const [status, setStatus] = useState4(() => renown ? renown.status : "initializing");
+  useEffect4(() => {
     setStatus(renown ? renown.status : "initializing");
     if (!renown)
       return;
@@ -28670,6 +28927,7 @@ async function loadExternalPackage(name4, registryUrl) {
 class BrowserPackageManager {
   #storage;
   #packages = new Map;
+  #localPackageIds = new Set;
   #subscribers = new Set;
   #packagesMemo = [];
   constructor(namespace) {
@@ -28690,6 +28948,9 @@ class BrowserPackageManager {
   get packages() {
     return this.#packagesMemo;
   }
+  get localPackageIds() {
+    return new Set(this.#localPackageIds);
+  }
   async addPackage(name4, registryUrl) {
     const module = await loadExternalPackage(name4, registryUrl);
     this.#packages.set(name4, module);
@@ -28706,6 +28967,7 @@ class BrowserPackageManager {
   }
   async addLocalPackage(name4, localPackage) {
     this.#packages.set(name4, localPackage);
+    this.#localPackageIds.add(localPackage.id);
     this.#notifyPackagesChanged();
   }
   async removePackage(name4) {
@@ -28754,6 +29016,40 @@ async function dropAllReactorStorage(pg) {
   await dropTablesInSchema(pg, REACTOR_SCHEMA);
   await dropTablesInSchema(pg, "public");
 }
+function cdnUrlToApiUrl(cdnUrl) {
+  return cdnUrl.replace(/\/-\/cdn\/?$/, "");
+}
+function mapPackageInfo(pkg) {
+  return {
+    name: pkg.name,
+    description: pkg.manifest?.description,
+    version: pkg.manifest?.version,
+    category: pkg.manifest?.category,
+    publisher: pkg.manifest?.publisher?.name,
+    publisherUrl: pkg.manifest?.publisher?.url
+  };
+}
+
+class RegistryClient {
+  apiUrl;
+  constructor(cdnUrl) {
+    this.apiUrl = cdnUrlToApiUrl(cdnUrl);
+  }
+  async getPackages() {
+    const res = await fetch(`${this.apiUrl}/packages`);
+    if (!res.ok)
+      throw new Error(`Registry error: HTTP ${res.status}`);
+    const data = await res.json();
+    return data.map(mapPackageInfo);
+  }
+  async searchPackages(query) {
+    const packages = await this.getPackages();
+    if (!query)
+      return packages;
+    const lowerQuery = query.toLowerCase();
+    return packages.filter((pkg) => pkg.name.toLowerCase().includes(lowerQuery) || pkg.description?.toLowerCase().includes(lowerQuery));
+  }
+}
 
 class ReactorClientDocumentCache {
   client;
@@ -40191,11 +40487,11 @@ function createRelationalDbWithLive(pgliteInstance) {
   return relationalDBWithLive;
 }
 function useRelationalQuery(ProcessorClass, driveId, queryCallback, parameters, options) {
-  const [result, setResult] = useState5(null);
-  const [queryLoading, setQueryLoading] = useState5(true);
-  const [error, setError] = useState5(undefined);
-  const retryCount = useRef2(0);
-  const retryTimeoutRef = useRef2(null);
+  const [result, setResult] = useState6(null);
+  const [queryLoading, setQueryLoading] = useState6(true);
+  const [error, setError] = useState6(undefined);
+  const retryCount = useRef3(0);
+  const retryTimeoutRef = useRef3(null);
   const relationalDb = useRelationalDb();
   const executeLiveQuery = async (sql22, queryParameters, retryAttempt = 0) => {
     if (!relationalDb.db) {
@@ -40221,7 +40517,7 @@ function useRelationalQuery(ProcessorClass, driveId, queryCallback, parameters,
       return null;
     }
   };
-  useEffect5(() => {
+  useEffect6(() => {
     setError(undefined);
     setQueryLoading(true);
     retryCount.current = 0;
@@ -40251,7 +40547,7 @@ function useRelationalQuery(ProcessorClass, driveId, queryCallback, parameters,
   };
 }
 function useStableParams(params) {
-  const prevParamsRef = useRef3(null);
+  const prevParamsRef = useRef4(null);
   return useMemo3(() => {
     if (!import_lodash.default(prevParamsRef.current, params)) {
       prevParamsRef.current = params;
@@ -40262,7 +40558,7 @@ function useStableParams(params) {
 function createProcessorQuery(ProcessorClass) {
   function useQuery(driveId, queryCallback, parameters, options) {
     const stableParams = useStableParams(parameters);
-    const memoizedCallback = useCallback3(queryCallback, [stableParams]);
+    const memoizedCallback = useCallback4(queryCallback, [stableParams]);
     return useRelationalQuery(ProcessorClass, driveId, memoizedCallback, stableParams, options);
   }
   return useQuery;
@@ -40966,20 +41262,20 @@ function RenownLoginButton({
   showPopover = false
 }) {
   const onLogin = onLoginProp ?? (() => openRenown());
-  const [isOpen, setIsOpen] = useState6(false);
-  const [isLoading, setIsLoading] = useState6(false);
-  const [isHovered, setIsHovered] = useState6(false);
-  const [showAbove, setShowAbove] = useState6(true);
-  const wrapperRef = useRef4(null);
-  const closeTimeoutRef = useRef4(null);
-  const calculatePosition = useCallback4(() => {
+  const [isOpen, setIsOpen] = useState7(false);
+  const [isLoading, setIsLoading] = useState7(false);
+  const [isHovered, setIsHovered] = useState7(false);
+  const [showAbove, setShowAbove] = useState7(true);
+  const wrapperRef = useRef5(null);
+  const closeTimeoutRef = useRef5(null);
+  const calculatePosition = useCallback5(() => {
     if (!wrapperRef.current)
       return;
     const rect = wrapperRef.current.getBoundingClientRect();
     const spaceAbove = rect.top;
     setShowAbove(spaceAbove >= POPOVER_HEIGHT + POPOVER_GAP);
   }, []);
-  const handleMouseEnter = useCallback4(() => {
+  const handleMouseEnter = useCallback5(() => {
     setIsHovered(true);
     if (!showPopover)
       return;
@@ -40990,13 +41286,13 @@ function RenownLoginButton({
     calculatePosition();
     setIsOpen(true);
   }, [calculatePosition, showPopover]);
-  const handleMouseLeave = useCallback4(() => {
+  const handleMouseLeave = useCallback5(() => {
     closeTimeoutRef.current = setTimeout(() => {
       setIsOpen(false);
       setIsHovered(false);
     }, 150);
   }, []);
-  useEffect6(() => {
+  useEffect7(() => {
     return () => {
       if (closeTimeoutRef.current) {
         clearTimeout(closeTimeoutRef.current);
@@ -41105,19 +41401,19 @@ function RenownUserButton({
   const avatarUrl = avatarUrlProp ?? user?.ens?.avatarUrl;
   const userId = userIdProp ?? user?.profile?.documentId;
   const onDisconnect = onDisconnectProp ?? (() => void logout());
-  const [isOpen, setIsOpen] = useState7(false);
-  const [isCopied, setIsCopied] = useState7(false);
-  const [showAbove, setShowAbove] = useState7(true);
-  const wrapperRef = useRef5(null);
-  const closeTimeoutRef = useRef5(null);
-  const calculatePosition = useCallback5(() => {
+  const [isOpen, setIsOpen] = useState8(false);
+  const [isCopied, setIsCopied] = useState8(false);
+  const [showAbove, setShowAbove] = useState8(true);
+  const wrapperRef = useRef6(null);
+  const closeTimeoutRef = useRef6(null);
+  const calculatePosition = useCallback6(() => {
     if (!wrapperRef.current)
       return;
     const rect = wrapperRef.current.getBoundingClientRect();
     const spaceAbove = rect.top;
     setShowAbove(spaceAbove >= POPOVER_HEIGHT2 + POPOVER_GAP2);
   }, []);
-  const handleMouseEnter = useCallback5(() => {
+  const handleMouseEnter = useCallback6(() => {
     if (closeTimeoutRef.current) {
       clearTimeout(closeTimeoutRef.current);
       closeTimeoutRef.current = null;
@@ -41125,19 +41421,19 @@ function RenownUserButton({
     calculatePosition();
     setIsOpen(true);
   }, [calculatePosition]);
-  const handleMouseLeave = useCallback5(() => {
+  const handleMouseLeave = useCallback6(() => {
     closeTimeoutRef.current = setTimeout(() => {
       setIsOpen(false);
     }, 150);
   }, []);
-  useEffect7(() => {
+  useEffect8(() => {
     return () => {
       if (closeTimeoutRef.current) {
         clearTimeout(closeTimeoutRef.current);
       }
     };
   }, []);
-  const copyToClipboard = useCallback5(async () => {
+  const copyToClipboard = useCallback6(async () => {
     try {
       await navigator.clipboard.writeText(address);
       setIsCopied(true);
@@ -41330,8 +41626,8 @@ function RenownProvider({
   baseUrl,
   children
 }) {
-  const initRef = useRef6(false);
-  const initialPropsRef = useRef6({ appName, basename, baseUrl });
+  const initRef = useRef7(false);
+  const initialPropsRef = useRef7({ appName, basename, baseUrl });
   if (initRef.current) {
     const initial = initialPropsRef.current;
     if (appName !== initial.appName) {
@@ -41344,7 +41640,7 @@ function RenownProvider({
       console.warn("RenownProvider: 'baseUrl' changed after mount. This prop is only read once during initialization.");
     }
   }
-  useEffect8(() => {
+  useEffect9(() => {
     if (initRef.current)
       return;
     initRef.current = true;
@@ -41929,10 +42225,10 @@ ${String(result)}`);
 }, docCache, fragmentSourceMap, printFragmentWarnings = true, experimentalFragmentVariables = false, extras, PropagationMode2, PhDocumentFieldsFragmentDoc, GetDocumentModelsDocument, GetDocumentDocument, GetDocumentChildrenDocument, GetDocumentParentsDocument, FindDocumentsDocument, GetDocumentOperationsDocument, GetJobStatusDocument, CreateDocumentDocument, CreateEmptyDocumentDocument, MutateDocumentDocument, MutateDocumentAsyncDocument, RenameDocumentDocument, AddChildrenDocument, RemoveChildrenDocument, MoveChildrenDocument, DeleteDocumentDocument, DeleteDocumentsDocument, DocumentChangesDocument, JobChangesDocument, PollSyncEnvelopesDocument, TouchChannelDocument, PushSyncEnvelopesDocument, defaultWrapper = (action, _operationName, _operationType, _variables) => action(), SPLIT_LOWER_UPPER_RE, SPLIT_UPPER_UPPER_RE, SPLIT_SEPARATE_NUMBER_RE, DEFAULT_STRIP_REGEXP, SPLIT_REPLACE_VALUE = "$1\x00$2", DEFAULT_PREFIX_SUFFIX_CHARACTERS = "", isExternalControlsEnabledEventFunctions, setIsExternalControlsEnabled, useIsExternalControlsEnabled, addIsExternalControlsEnabledEventHandler, isDragAndDropEnabledEventFunctions, setIsDragAndDropEnabled, useIsDragAndDropEnabled, addIsDragAndDropEnabledEventHandler, allowedDocumentTypesEventFunctions, setAllowedDocumentTypes, addAllowedDocumentTypesEventHandler, phDriveEditorConfigSetters, phDocumentEditorConfigSetters, phDriveEditorConfigHooks, phDocumentEditorConfigHooks, vetraPackageManagerFunctions, useVetraPackageManager, useVetraPackages = () => {
   const packageManager = useVetraPackageManager();
   return useSyncExternalStore2((cb) => packageManager ? packageManager.subscribe(cb) : () => {}, () => packageManager?.packages ?? []);
-}, addVetraPackageManagerEventHandler, documentEventFunctions, useDocumentCache, setDocumentCache, addDocumentCacheEventHandler, base64, locales, defaultLocale, initialMulticharmap, initialCharmap, slug_default, drivesEventFunctions, useDrives, setDrives, addDrivesEventHandler, selectedDriveIdEventFunctions, useSelectedDriveId, setSelectedDriveId, addSelectedDriveIdEventHandler, selectedNodeIdEventFunctions, useSelectedNodeId, setSelectedNodeId, addSelectedNodeIdEventHandler, useRouterBasename, setRouterBasename, addRouterBasenameEventHandler, useVersion, setVersion, addVersionEventHandler, useRequiresHardRefresh, setRequiresHardRefresh, addRequiresHardRefreshEventHandler, useWarnOutdatedApp, setWarnOutdatedApp, addWarnOutdatedAppEventHandler, useStudioMode, setStudioMode, addStudioModeEventHandler, useBasePath, setBasePath, addBasePathEventHandler, useVersionCheckInterval, setVersionCheckInterval, addVersionCheckIntervalEventHandler, useCliVersion, setCliVersion, addCliVersionEventHandler, useFileUploadOperationsChunkSize, setFileUploadOperationsChunkSize, addFileUploadOperationsChunkSizeEventHandler, useIsDocumentModelSelectionSettingsEnabled, setIsDocumentModelSelectionSettingsEnabled, addIsDocumentModelSelectionSettingsEnabledEventHandler, useGaTrackingId, setGaTrackingId, addGaTrackingIdEventHandler, useDefaultDrivesUrl, setDefaultDrivesUrl, addDefaultDrivesUrlEventHandler, useDrivesPreserveStrategy, setDrivesPreserveStrategy, addDrivesPreserveStrategyEventHandler, useIsLocalDrivesEnabled, setIsLocalDrivesEnabled, addIsLocalDrivesEnabledEventHandler, useIsAddDriveEnabled, setIsAddDriveEnabled, addIsAddDriveEnabledEventHandler, useIsPublicDrivesEnabled, setIsPublicDrivesEnabled, addIsPublicDrivesEnabledEventHandler, useIsAddPublicDrivesEnabled, setIsAddPublicDrivesEnabled, addIsAddPublicDrivesEnabledEventHandler, useIsDeletePublicDrivesEnabled, setIsDeletePublicDrivesEnabled, addIsDeletePublicDrivesEnabledEventHandler, useIsCloudDrivesEnabled, setIsCloudDrivesEnabled, addIsCloudDrivesEnabledEventHandler, useIsAddCloudDrivesEnabled, setIsAddCloudDrivesEnabled, addIsAddCloudDrivesEnabledEventHandler, useIsDeleteCloudDrivesEnabled, setIsDeleteCloudDrivesEnabled, addIsDeleteCloudDrivesEnabledEventHandler, useLocalDrivesEnabled, setLocalDrivesEnabled, addLocalDrivesEnabledEventHandler, useIsAddLocalDrivesEnabled, setIsAddLocalDrivesEnabled, addIsAddLocalDrivesEnabledEventHandler, useIsDeleteLocalDrivesEnabled, setIsDeleteLocalDrivesEnabled, addIsDeleteLocalDrivesEnabledEventHandler, useIsEditorDebugModeEnabled, setIsEditorDebugModeEnabled, addIsEditorDebugModeEnabledEventHandler, useIsEditorReadModeEnabled, setIsEditorReadModeEnabled, addIsEditorReadModeEnabledEventHandler, useIsAnalyticsDatabaseWorkerEnabled, setIsAnalyticsDatabaseWorkerEnabled, addIsAnalyticsDatabaseWorkerEnabledEventHandler, useIsDiffAnalyticsEnabled, setIsDiffAnalyticsEnabled, addIsDiffAnalyticsEnabledEventHandler, useIsDriveAnalyticsEnabled, setIsDriveAnalyticsEnabled, addIsDriveAnalyticsEnabledEventHandler, useRenownUrl, setRenownUrl, addRenownUrlEventHandler, useRenownNetworkId, setRenownNetworkId, addRenownNetworkIdEventHandler, useRenownChainId, setRenownChainId, addRenownChainIdEventHandler, useSentryRelease, setSentryRelease, addSentryReleaseEventHandler, useSentryDsn, setSentryDsn, addSentryDsnEventHandler, useSentryEnv, setSentryEnv, addSentryEnvEventHandler, useIsSentryTracingEnabled, setIsSentryTracingEnabled, addIsSentryTracingEnabledEventHandler, useIsExternalProcessorsEnabled, setIsExternalProcessorsEnabled, addIsExternalProcessorsEnabledEventHandler, useIsExternalPackagesEnabled, setIsExternalPackagesEnabled, addIsExternalPackagesEnabledEventHandler, enabledEditorsEventFunctions, setEnabledEditors, useEnabledEditors, addEnabledEditorsEventHandler, disabledEditorsEventFunctions, setDisabledEditors, useDisabledEditors, addDisabledEditorsEventHandler, isRelationalProcessorsEnabled, setIsRelationalProcessorsEnabled, useIsRelationalProcessorsEnabled, addIsRelationalProcessorsEnabledEventHandler, isExternalRelationalProcessorsEnabled, setIsExternalRelationalProcessorsEnabled, useIsExternalRelationalProcessorsEnabled, addIsExternalRelationalProcessorsEnabledEventHandler, isAnalyticsEnabledEventFunctions, setIsAnalyticsEnabled, useIsAnalyticsEnabled, addIsAnalyticsEnabledEventHandler, isAnalyticsExternalProcessorsEnabled, setIsAnalyticsExternalProcessorsEnabled, useIsAnalyticsExternalProcessorsEnabled, addIsAnalyticsExternalProcessorsEnabledEventHandler, analyticsDatabaseNameEventFunctions, setAnalyticsDatabaseName, useAnalyticsDatabaseName, addAnalyticsDatabaseNameEventHandler, logLevelEventFunctions, setLogLevel2, useLogLevel, addLogLevelEventHandler, allowListEventFunctions, setAllowList, useAllowList, addAllowListEventHandler, nonUserConfigSetters, phGlobalConfigSetters, nonUserConfigHooks, phGlobalConfigHooks, reactorClientModuleEventFunctions, reactorClientEventFunctions, useReactorClientModule, setReactorClientModule, addReactorClientModuleEventHandler, useReactorClient, setReactorClient, addReactorClientEventHandler, useSync = () => useReactorClientModule()?.reactorModule?.syncModule?.syncManager, useSyncList = () => {
+}, addVetraPackageManagerEventHandler, reactorClientModuleEventFunctions, reactorClientEventFunctions, useReactorClientModule, setReactorClientModule, addReactorClientModuleEventHandler, useReactorClient, setReactorClient, addReactorClientEventHandler, useSync = () => useReactorClientModule()?.reactorModule?.syncModule?.syncManager, useSyncList = () => {
   const sync = useSync();
   return sync?.list() ?? [];
-}, featuresEventFunctions, useFeatures, setFeatures, addFeaturesEventHandler, modalEventFunctions, usePHModal, setPHModal, addModalEventHandler, revisionHistoryEventFunctions, useRevisionHistoryVisible, setRevisionHistoryVisible, addRevisionHistoryVisibleEventHandler, selectedTimelineItemEventFunctions, useSelectedTimelineItem, setSelectedTimelineItem, addSelectedTimelineItemEventHandler, selectedTimelineRevisionEventFunctions, useSelectedTimelineRevision, setSelectedTimelineRevision, addSelectedTimelineRevisionEventHandler, toastEventFunctions, usePHToast, setPHToast, addToastEventHandler, FEATURE_INSPECTOR_ENABLED = "FEATURE_INSPECTOR_ENABLED", FEATURE_INSPECTOR_ENABLED_DEFAULT = false, syncStatusToUI, validateDocument = (document2) => {
+}, documentEventFunctions, useDocumentCache, setDocumentCache, addDocumentCacheEventHandler, base64, locales, defaultLocale, initialMulticharmap, initialCharmap, slug_default, drivesEventFunctions, useDrives, setDrives, addDrivesEventHandler, selectedDriveIdEventFunctions, useSelectedDriveId, setSelectedDriveId, addSelectedDriveIdEventHandler, selectedNodeIdEventFunctions, useSelectedNodeId, setSelectedNodeId, addSelectedNodeIdEventHandler, useRouterBasename, setRouterBasename, addRouterBasenameEventHandler, useVersion, setVersion, addVersionEventHandler, useRequiresHardRefresh, setRequiresHardRefresh, addRequiresHardRefreshEventHandler, useWarnOutdatedApp, setWarnOutdatedApp, addWarnOutdatedAppEventHandler, useStudioMode, setStudioMode, addStudioModeEventHandler, useBasePath, setBasePath, addBasePathEventHandler, useVersionCheckInterval, setVersionCheckInterval, addVersionCheckIntervalEventHandler, useCliVersion, setCliVersion, addCliVersionEventHandler, useFileUploadOperationsChunkSize, setFileUploadOperationsChunkSize, addFileUploadOperationsChunkSizeEventHandler, useIsDocumentModelSelectionSettingsEnabled, setIsDocumentModelSelectionSettingsEnabled, addIsDocumentModelSelectionSettingsEnabledEventHandler, useGaTrackingId, setGaTrackingId, addGaTrackingIdEventHandler, useDefaultDrivesUrl, setDefaultDrivesUrl, addDefaultDrivesUrlEventHandler, useDrivesPreserveStrategy, setDrivesPreserveStrategy, addDrivesPreserveStrategyEventHandler, useIsLocalDrivesEnabled, setIsLocalDrivesEnabled, addIsLocalDrivesEnabledEventHandler, useIsAddDriveEnabled, setIsAddDriveEnabled, addIsAddDriveEnabledEventHandler, useIsPublicDrivesEnabled, setIsPublicDrivesEnabled, addIsPublicDrivesEnabledEventHandler, useIsAddPublicDrivesEnabled, setIsAddPublicDrivesEnabled, addIsAddPublicDrivesEnabledEventHandler, useIsDeletePublicDrivesEnabled, setIsDeletePublicDrivesEnabled, addIsDeletePublicDrivesEnabledEventHandler, useIsCloudDrivesEnabled, setIsCloudDrivesEnabled, addIsCloudDrivesEnabledEventHandler, useIsAddCloudDrivesEnabled, setIsAddCloudDrivesEnabled, addIsAddCloudDrivesEnabledEventHandler, useIsDeleteCloudDrivesEnabled, setIsDeleteCloudDrivesEnabled, addIsDeleteCloudDrivesEnabledEventHandler, useLocalDrivesEnabled, setLocalDrivesEnabled, addLocalDrivesEnabledEventHandler, useIsAddLocalDrivesEnabled, setIsAddLocalDrivesEnabled, addIsAddLocalDrivesEnabledEventHandler, useIsDeleteLocalDrivesEnabled, setIsDeleteLocalDrivesEnabled, addIsDeleteLocalDrivesEnabledEventHandler, useIsEditorDebugModeEnabled, setIsEditorDebugModeEnabled, addIsEditorDebugModeEnabledEventHandler, useIsEditorReadModeEnabled, setIsEditorReadModeEnabled, addIsEditorReadModeEnabledEventHandler, useIsAnalyticsDatabaseWorkerEnabled, setIsAnalyticsDatabaseWorkerEnabled, addIsAnalyticsDatabaseWorkerEnabledEventHandler, useIsDiffAnalyticsEnabled, setIsDiffAnalyticsEnabled, addIsDiffAnalyticsEnabledEventHandler, useIsDriveAnalyticsEnabled, setIsDriveAnalyticsEnabled, addIsDriveAnalyticsEnabledEventHandler, useRenownUrl, setRenownUrl, addRenownUrlEventHandler, useRenownNetworkId, setRenownNetworkId, addRenownNetworkIdEventHandler, useRenownChainId, setRenownChainId, addRenownChainIdEventHandler, useSentryRelease, setSentryRelease, addSentryReleaseEventHandler, useSentryDsn, setSentryDsn, addSentryDsnEventHandler, useSentryEnv, setSentryEnv, addSentryEnvEventHandler, useIsSentryTracingEnabled, setIsSentryTracingEnabled, addIsSentryTracingEnabledEventHandler, useIsExternalProcessorsEnabled, setIsExternalProcessorsEnabled, addIsExternalProcessorsEnabledEventHandler, useIsExternalPackagesEnabled, setIsExternalPackagesEnabled, addIsExternalPackagesEnabledEventHandler, enabledEditorsEventFunctions, setEnabledEditors, useEnabledEditors, addEnabledEditorsEventHandler, disabledEditorsEventFunctions, setDisabledEditors, useDisabledEditors, addDisabledEditorsEventHandler, isRelationalProcessorsEnabled, setIsRelationalProcessorsEnabled, useIsRelationalProcessorsEnabled, addIsRelationalProcessorsEnabledEventHandler, isExternalRelationalProcessorsEnabled, setIsExternalRelationalProcessorsEnabled, useIsExternalRelationalProcessorsEnabled, addIsExternalRelationalProcessorsEnabledEventHandler, isAnalyticsEnabledEventFunctions, setIsAnalyticsEnabled, useIsAnalyticsEnabled, addIsAnalyticsEnabledEventHandler, isAnalyticsExternalProcessorsEnabled, setIsAnalyticsExternalProcessorsEnabled, useIsAnalyticsExternalProcessorsEnabled, addIsAnalyticsExternalProcessorsEnabledEventHandler, analyticsDatabaseNameEventFunctions, setAnalyticsDatabaseName, useAnalyticsDatabaseName, addAnalyticsDatabaseNameEventHandler, logLevelEventFunctions, setLogLevel2, useLogLevel, addLogLevelEventHandler, allowListEventFunctions, setAllowList, useAllowList, addAllowListEventHandler, nonUserConfigSetters, phGlobalConfigSetters, nonUserConfigHooks, phGlobalConfigHooks, featuresEventFunctions, useFeatures, setFeatures, addFeaturesEventHandler, modalEventFunctions, usePHModal, setPHModal, addModalEventHandler, revisionHistoryEventFunctions, useRevisionHistoryVisible, setRevisionHistoryVisible, addRevisionHistoryVisibleEventHandler, selectedTimelineItemEventFunctions, useSelectedTimelineItem, setSelectedTimelineItem, addSelectedTimelineItemEventHandler, selectedTimelineRevisionEventFunctions, useSelectedTimelineRevision, setSelectedTimelineRevision, addSelectedTimelineRevisionEventHandler, toastEventFunctions, usePHToast, setPHToast, addToastEventHandler, FEATURE_INSPECTOR_ENABLED = "FEATURE_INSPECTOR_ENABLED", FEATURE_INSPECTOR_ENABLED_DEFAULT = false, syncStatusToUI, validateDocument = (document2) => {
   const errors2 = [];
   if (document2.header.documentType !== "powerhouse/document-model") {
     return errors2;
@@ -41999,8 +42295,8 @@ ${String(result)}`);
   };
   return onDropFile;
 }, store, BrowserLocalStorage, PGLITE_UPDATE_EVENT = "ph:pglite-update", defaultPGliteState, usePGliteDB = () => {
-  const [state, setState] = useState4(() => window.powerhouse?.pglite ?? defaultPGliteState);
-  useEffect4(() => {
+  const [state, setState] = useState5(() => window.powerhouse?.pglite ?? defaultPGliteState);
+  useEffect5(() => {
     const handlePgliteUpdate = () => setState(window.powerhouse?.pglite ?? defaultPGliteState);
     window.addEventListener(PGLITE_UPDATE_EVENT, handlePgliteUpdate);
     return () => window.removeEventListener(PGLITE_UPDATE_EVENT, handlePgliteUpdate);
@@ -47184,6 +47480,14 @@ spurious results.`);
   vetraPackageManagerFunctions = makePHEventFunctions("vetraPackageManager");
   useVetraPackageManager = vetraPackageManagerFunctions.useValue;
   addVetraPackageManagerEventHandler = vetraPackageManagerFunctions.addEventHandler;
+  reactorClientModuleEventFunctions = makePHEventFunctions("reactorClientModule");
+  reactorClientEventFunctions = makePHEventFunctions("reactorClient");
+  useReactorClientModule = reactorClientModuleEventFunctions.useValue;
+  setReactorClientModule = reactorClientModuleEventFunctions.setValue;
+  addReactorClientModuleEventHandler = reactorClientModuleEventFunctions.addEventHandler;
+  useReactorClient = reactorClientEventFunctions.useValue;
+  setReactorClient = reactorClientEventFunctions.setValue;
+  addReactorClientEventHandler = reactorClientEventFunctions.addEventHandler;
   documentEventFunctions = makePHEventFunctions("documentCache");
   useDocumentCache = documentEventFunctions.useValue;
   setDocumentCache = documentEventFunctions.setValue;
@@ -48231,14 +48535,6 @@ spurious results.`);
     ...phDocumentEditorConfigHooks,
     ...nonUserConfigHooks
   };
-  reactorClientModuleEventFunctions = makePHEventFunctions("reactorClientModule");
-  reactorClientEventFunctions = makePHEventFunctions("reactorClient");
-  useReactorClientModule = reactorClientModuleEventFunctions.useValue;
-  setReactorClientModule = reactorClientModuleEventFunctions.setValue;
-  addReactorClientModuleEventHandler = reactorClientModuleEventFunctions.addEventHandler;
-  useReactorClient = reactorClientEventFunctions.useValue;
-  setReactorClient = reactorClientEventFunctions.setValue;
-  addReactorClientEventHandler = reactorClientEventFunctions.addEventHandler;
   featuresEventFunctions = makePHEventFunctions("features");
   useFeatures = featuresEventFunctions.useValue;
   setFeatures = featuresEventFunctions.setValue;
@@ -86276,21 +86572,21 @@ var init_extraerrordata = __esm(() => {
 
 // ../../node_modules/.pnpm/@sentry+core@10.40.0/node_modules/@sentry/core/build/esm/utils/path.js
 function normalizeArray(parts, allowAboveRoot) {
-  let up14 = 0;
+  let up15 = 0;
   for (let i = parts.length - 1;i >= 0; i--) {
     const last = parts[i];
     if (last === ".") {
       parts.splice(i, 1);
     } else if (last === "..") {
       parts.splice(i, 1);
-      up14++;
-    } else if (up14) {
+      up15++;
+    } else if (up15) {
       parts.splice(i, 1);
-      up14--;
+      up15--;
     }
   }
   if (allowAboveRoot) {
-    for (;up14--; up14) {
+    for (;up15--; up15) {
       parts.unshift("..");
     }
   }
@@ -108288,7 +108584,7 @@ function createV6CompatibleWrapCreateMemoryRouter(createRouterFunction, version5
 function createReactRouterV6CompatibleTracingIntegration(options, version5) {
   const integration = browserTracingIntegration({ ...options, instrumentPageLoad: false, instrumentNavigation: false });
   const {
-    useEffect: useEffect10,
+    useEffect: useEffect11,
     useLocation,
     useNavigationType,
     createRoutesFromChildren,
@@ -108319,7 +108615,7 @@ function createReactRouterV6CompatibleTracingIntegration(options, version5) {
       } else {
         _lazyRouteTimeout = configuredMaxWait;
       }
-      _useEffect = useEffect10;
+      _useEffect = useEffect11;
       _useLocation = useLocation;
       _useNavigationType = useNavigationType;
       _matchRoutes2 = matchRoutes2;
@@ -135962,7 +136258,7 @@ ${typeDefsDoc}`;
 
 // ../../packages/powerhouse-vetra-packages/dist/editors/document-model-editor/context/schema-context.js
 import { jsx as _jsx2 } from "react/jsx-runtime";
-import { createContext, useContext, useEffect as useEffect11, useState as useState10 } from "react";
+import { createContext, useContext, useEffect as useEffect12, useState as useState11 } from "react";
 function makeSharedSchemaSdl(existingSchemaSdl, globalStateSchemaSdl, localStateSchemaSdl, operationSchemasSdl) {
   const existingSchema = buildSchema(existingSchemaSdl);
   const sdls = [
@@ -136035,8 +136331,8 @@ function parseSharedSchemaSdl(initialSchema2, globalStateSchemaSdl, localStateSc
 }
 function SchemaContextProvider(props) {
   const { children, globalStateSchemaSdl, localStateSchemaSdl, operationSchemasSdl } = props;
-  const [sharedSchemaSdl, setSharedSchemaSdl] = useState10(() => parseSharedSchemaSdl(printSchema(initialSchema), globalStateSchemaSdl, localStateSchemaSdl, operationSchemasSdl));
-  useEffect11(() => {
+  const [sharedSchemaSdl, setSharedSchemaSdl] = useState11(() => parseSharedSchemaSdl(printSchema(initialSchema), globalStateSchemaSdl, localStateSchemaSdl, operationSchemasSdl));
+  useEffect12(() => {
     setSharedSchemaSdl((prev) => parseSharedSchemaSdl(prev.sharedSchema, globalStateSchemaSdl, localStateSchemaSdl, operationSchemasSdl));
   }, [globalStateSchemaSdl, localStateSchemaSdl, operationSchemasSdl]);
   return _jsx2(SchemaContext.Provider, { value: sharedSchemaSdl, children });
@@ -145611,18 +145907,18 @@ var init_form = __esm(() => {
 // ../../packages/powerhouse-vetra-packages/dist/editors/document-model-editor/components/text-area.js
 import { jsx as _jsx5 } from "react/jsx-runtime";
 import * as React14 from "react";
-import { forwardRef as forwardRef6, useImperativeHandle, useRef as useRef9, useCallback as useCallback8 } from "react";
+import { forwardRef as forwardRef6, useImperativeHandle, useRef as useRef10, useCallback as useCallback7 } from "react";
 var Textarea;
 var init_text_area = __esm(() => {
   init_style();
   Textarea = forwardRef6(({ className, ...props }, ref) => {
-    const textareaRef = useRef9(null);
-    const adjustHeight = useCallback8((textarea) => {
+    const textareaRef = useRef10(null);
+    const adjustHeight = useCallback7((textarea) => {
       textarea.style.height = "auto";
       const newHeight = Math.max(textarea.scrollHeight, textarea.offsetHeight);
       textarea.style.height = `${newHeight}px`;
     }, []);
-    const handleInput = useCallback8((e3) => {
+    const handleInput = useCallback7((e3) => {
       adjustHeight(e3.currentTarget);
     }, [adjustHeight]);
     React14.useEffect(() => {
@@ -145641,7 +145937,7 @@ var init_text_area = __esm(() => {
 
 // ../../packages/powerhouse-vetra-packages/dist/editors/document-model-editor/components/text-field.js
 import { jsx as _jsx6, jsxs as _jsxs } from "react/jsx-runtime";
-import { forwardRef as forwardRef7, useCallback as useCallback9, useEffect as useEffect13, useId as useId2, useImperativeHandle as useImperativeHandle2, useRef as useRef10 } from "react";
+import { forwardRef as forwardRef7, useCallback as useCallback9, useEffect as useEffect14, useId as useId2, useImperativeHandle as useImperativeHandle2, useRef as useRef11 } from "react";
 var TextField;
 var init_text_field = __esm(() => {
   init_zod2();
@@ -145652,9 +145948,9 @@ var init_text_field = __esm(() => {
   init_form();
   init_text_area();
   TextField = forwardRef7(({ name: name6, value, onSubmit, label, placeholder, unique, className = "", rows = 1, focusOnMount = false, required: required2 = false, allowEmpty = false, shouldReset = false, onChange }, ref) => {
-    const textareaRef = useRef10(null);
+    const textareaRef = useRef11(null);
     const id = useId2();
-    useEffect13(() => {
+    useEffect14(() => {
       if (focusOnMount && textareaRef.current) {
         textareaRef.current.focus();
       }
@@ -145704,7 +146000,7 @@ var init_text_field = __esm(() => {
     useImperativeHandle2(ref, () => ({
       focus: () => textareaRef.current?.focus()
     }));
-    useEffect13(() => {
+    useEffect14(() => {
       form.reset({ [name6]: value ?? "" });
     }, [form, name6, value]);
     return _jsx6(Form2, { ...form, children: _jsx6(FormField, { control: form.control, name: name6, render: ({ field }) => _jsxs(FormItem, { className: "grid h-full grid-rows-[auto,1fr] gap-2 overflow-visible", children: [!!label && _jsx6(FormLabel, { htmlFor: name6, className: "text-sm font-medium text-gray-700", children: label }), _jsx6(FormControl, { children: _jsx6(Textarea, { ...field, id, name: name6, ref: (node) => {
@@ -145911,10 +146207,10 @@ var init_linting = __esm(() => {
 
 // ../../packages/powerhouse-vetra-packages/dist/editors/document-model-editor/components/operation-description-form.js
 import { jsx as _jsx10 } from "react/jsx-runtime";
-import { useEffect as useEffect14, useRef as useRef11 } from "react";
+import { useEffect as useEffect15, useRef as useRef12 } from "react";
 function OperationDescriptionForm({ operation, focusOnMount, setOperationDescription }) {
-  const textFieldRef = useRef11(null);
-  useEffect14(() => {
+  const textFieldRef = useRef12(null);
+  useEffect15(() => {
     if (focusOnMount && textFieldRef.current) {
       textFieldRef.current.focus();
     }
@@ -145927,9 +146223,9 @@ var init_operation_description_form = __esm(() => {
 
 // ../../packages/powerhouse-vetra-packages/dist/editors/document-model-editor/components/operation-error-form.js
 import { jsx as _jsx11 } from "react/jsx-runtime";
-import { useCallback as useCallback12, useRef as useRef12 } from "react";
+import { useCallback as useCallback12, useRef as useRef13 } from "react";
 function OperationErrorForm({ operation, error: error50, focusOnMount, onSubmit, onAddOperationError, deleteOperationError, setOperationErrorName }) {
-  const textFieldRef = useRef12(null);
+  const textFieldRef = useRef13(null);
   const isEdit = !!error50;
   const allOperationErrorNames = operation.errors.map((o3) => o3.name).filter((n5) => n5 !== null);
   const handleSubmit = useCallback12((name6) => {
@@ -145967,10 +146263,10 @@ var init_operation_error_form = __esm(() => {
 
 // ../../packages/powerhouse-vetra-packages/dist/editors/document-model-editor/components/operation-errors.js
 import { jsx as _jsx12, jsxs as _jsxs3 } from "react/jsx-runtime";
-import { useCallback as useCallback13, useId as useId3, useState as useState11 } from "react";
+import { useCallback as useCallback13, useId as useId3, useState as useState12 } from "react";
 function OperationErrors({ operation, addOperationError, deleteOperationError, setOperationErrorName }) {
   const addErrorFormId = useId3();
-  const [shouldFocusAddForm, setShouldFocusAddForm] = useState11(false);
+  const [shouldFocusAddForm, setShouldFocusAddForm] = useState12(false);
   const onAddOperationError = useCallback13(async (operationId, error50) => {
     const errorId = await addOperationError(operationId, error50);
     if (errorId) {
@@ -149278,10 +149574,10 @@ function dispatchKey(elt, name6, code6, mods) {
   let down = new KeyboardEvent("keydown", options);
   down.synthetic = true;
   elt.dispatchEvent(down);
-  let up14 = new KeyboardEvent("keyup", options);
-  up14.synthetic = true;
-  elt.dispatchEvent(up14);
-  return down.defaultPrevented || up14.defaultPrevented;
+  let up15 = new KeyboardEvent("keyup", options);
+  up15.synthetic = true;
+  elt.dispatchEvent(up15);
+  return down.defaultPrevented || up15.defaultPrevented;
 }
 function getRoot(node) {
   while (node) {
@@ -171609,14 +171905,14 @@ var init_factories = __esm(() => {
 });
 
 // ../../packages/powerhouse-vetra-packages/dist/editors/document-model-editor/components/code-editors/hooks.js
-import { useEffect as useEffect15, useRef as useRef13 } from "react";
+import { useEffect as useEffect16, useRef as useRef14 } from "react";
 function useEditorRefs() {
-  const editorRef = useRef13(null);
-  const viewRef = useRef13(null);
-  const updateListenerCompartment = useRef13(new Compartment);
-  const focusHandlerCompartment = useRef13(new Compartment);
-  const pasteHandlerCompartment = useRef13(new Compartment);
-  const timeoutRef = useRef13(null);
+  const editorRef = useRef14(null);
+  const viewRef = useRef14(null);
+  const updateListenerCompartment = useRef14(new Compartment);
+  const focusHandlerCompartment = useRef14(new Compartment);
+  const pasteHandlerCompartment = useRef14(new Compartment);
+  const timeoutRef = useRef14(null);
   return {
     editorRef,
     viewRef,
@@ -171627,7 +171923,7 @@ function useEditorRefs() {
   };
 }
 function useEditorCleanup(viewRef) {
-  useEffect15(() => {
+  useEffect16(() => {
     return () => {
       if (viewRef.current) {
         viewRef.current.destroy();
@@ -171637,7 +171933,7 @@ function useEditorCleanup(viewRef) {
   }, []);
 }
 function useHandlerReconfiguration(view, readonly4, timeoutRef, updateDocumentInModel, compartments) {
-  useEffect15(() => {
+  useEffect16(() => {
     if (!view)
       return;
     view.dispatch({
@@ -171651,7 +171947,7 @@ function useHandlerReconfiguration(view, readonly4, timeoutRef, updateDocumentIn
   }, [readonly4, updateDocumentInModel]);
 }
 function useDocumentSync(view, doc3) {
-  useEffect15(() => {
+  useEffect16(() => {
     if (!view)
       return;
     const currentDoc = view.state.doc.toString();
@@ -178967,7 +179263,7 @@ __export(exports_graphql_editor, {
   default: () => graphql_editor_default
 });
 import { jsx as _jsx13 } from "react/jsx-runtime";
-import { memo as memo2, useEffect as useEffect16, useRef as useRef14 } from "react";
+import { memo as memo2, useEffect as useEffect17, useRef as useRef15 } from "react";
 var GraphqlEditor, graphql_editor_default;
 var init_graphql_editor = __esm(() => {
   init_dist11();
@@ -178984,10 +179280,10 @@ var init_graphql_editor = __esm(() => {
   GraphqlEditor = memo2(function GraphqlEditor2(props) {
     const { doc: doc3, readonly: readonly4 = false, updateDocumentInModel, customLinter } = props;
     const { editorRef, viewRef, updateListenerCompartment, focusHandlerCompartment, pasteHandlerCompartment, timeoutRef } = useEditorRefs();
-    const graphqlCompartment = useRef14(new Compartment);
-    const linterCompartment = useRef14(new Compartment);
+    const graphqlCompartment = useRef15(new Compartment);
+    const linterCompartment = useRef15(new Compartment);
     const { sharedSchema } = useSchemaContext();
-    useEffect16(() => {
+    useEffect17(() => {
       if (!viewRef.current) {
         const schema18 = buildSchema(sharedSchema);
         viewRef.current = new EditorView({
@@ -179011,7 +179307,7 @@ var init_graphql_editor = __esm(() => {
       }
     }, []);
     useEditorCleanup(viewRef);
-    useEffect16(() => {
+    useEffect17(() => {
       const view = viewRef.current;
       if (!view)
         return;
@@ -179068,9 +179364,9 @@ var init_operation = __esm(() => {
 
 // ../../packages/powerhouse-vetra-packages/dist/editors/document-model-editor/components/operations.js
 import { jsx as _jsx15, jsxs as _jsxs5 } from "react/jsx-runtime";
-import { useCallback as useCallback15, useId as useId4, useState as useState12 } from "react";
+import { useCallback as useCallback15, useId as useId4, useState as useState13 } from "react";
 function Operations({ module, allOperations, shouldFocusNewOperation, updateOperationName, deleteOperation, addOperationAndInitialSchema, addOperationError, deleteOperationError, setOperationErrorName, updateOperationSchema, setOperationDescription, toggleNoInputRequired }) {
-  const [lastCreatedOperationId, setLastCreatedOperationId] = useState12(null);
+  const [lastCreatedOperationId, setLastCreatedOperationId] = useState13(null);
   const addOperationFormId = useId4();
   const allOperationNames = allOperations.map((o3) => o3.name).filter((n5) => n5 !== null);
   const onAddOperationAndInitialSchema = useCallback15(async (moduleId, name6) => {
@@ -179102,10 +179398,10 @@ var init_module = __esm(() => {
 
 // ../../packages/powerhouse-vetra-packages/dist/editors/document-model-editor/components/modules.js
 import { jsx as _jsx17, jsxs as _jsxs7 } from "react/jsx-runtime";
-import { useCallback as useCallback16, useRef as useRef15, useState as useState13 } from "react";
+import { useCallback as useCallback16, useRef as useRef16, useState as useState14 } from "react";
 function Modules({ modules, allOperations, addModule, updateModuleName, deleteModule, updateOperationName, deleteOperation, addOperationAndInitialSchema, updateOperationSchema, setOperationDescription, addOperationError, deleteOperationError, setOperationErrorName, toggleNoInputRequired }) {
-  const [lastCreatedModuleId, setLastCreatedModuleId] = useState13(null);
-  const focusTrapRef = useRef15(null);
+  const [lastCreatedModuleId, setLastCreatedModuleId] = useState14(null);
+  const focusTrapRef = useRef16(null);
   const onAddModule = useCallback16(async (name6) => {
     const moduleId = await addModule(name6);
     if (moduleId) {
@@ -180464,7 +180760,7 @@ __export(exports_json_editor, {
   default: () => json_editor_default
 });
 import { jsx as _jsx21 } from "react/jsx-runtime";
-import { memo as memo3, useEffect as useEffect23 } from "react";
+import { memo as memo3, useEffect as useEffect24 } from "react";
 var JSONEditor, json_editor_default;
 var init_json_editor = __esm(() => {
   init_dist35();
@@ -180478,7 +180774,7 @@ var init_json_editor = __esm(() => {
   JSONEditor = memo3(function JSONEditor2(props) {
     const { doc: doc3, readonly: readonly4 = false, updateDocumentInModel } = props;
     const { editorRef, viewRef, updateListenerCompartment, focusHandlerCompartment, pasteHandlerCompartment, timeoutRef } = useEditorRefs();
-    useEffect23(() => {
+    useEffect24(() => {
       if (!viewRef.current) {
         viewRef.current = new EditorView({
           state: EditorState.create({
@@ -180521,11 +180817,11 @@ __export(exports_state_schemas, {
 import { jsxs as _jsxs9, jsx as _jsx22 } from "react/jsx-runtime";
 import { cn as cn3 } from "@powerhousedao/design-system";
 import { Checkbox } from "@powerhousedao/design-system/ui/components/checkbox/checkbox.js";
-import { lazy as lazy3, Suspense as Suspense2, useCallback as useCallback20, useEffect as useEffect24, useMemo as useMemo8, useRef as useRef22, useState as useState18 } from "react";
+import { lazy as lazy3, Suspense as Suspense2, useCallback as useCallback20, useEffect as useEffect25, useMemo as useMemo8, useRef as useRef23, useState as useState19 } from "react";
 function StateEditor({ modelName, stateSchema, initialValue, setStateSchema, setInitialState, scope }) {
   const { sharedSchema: sharedSchemaSdl, error: sharedSchemaError } = useSchemaContext();
-  const [showStandardLib, setShowStandardLib] = useState18(false);
-  const [syncWithSchema, setSyncWithSchema] = useState18(true);
+  const [showStandardLib, setShowStandardLib] = useState19(false);
+  const [syncWithSchema, setSyncWithSchema] = useState19(true);
   const customLinter = useCallback20((doc3) => ensureValidStateSchemaName(doc3, modelName, scope), [modelName, scope]);
   const schemaErrors = useMemo8(() => {
     const errors5 = ensureValidStateSchemaName(stateSchema, modelName, scope);
@@ -180539,7 +180835,7 @@ function StateEditor({ modelName, stateSchema, initialValue, setStateSchema, set
   }, []);
   const handleSchemaUpdate = useCallback20((newDoc) => setStateSchema(newDoc, scope), [setStateSchema, scope]);
   const handleInitialStateUpdate = useCallback20((newDoc) => setInitialState(newDoc, scope), [setInitialState, scope]);
-  const hasSyncedRef = useRef22(false);
+  const hasSyncedRef = useRef23(false);
   const { initialValueErrors, fixedState } = useMemo8(() => {
     const existingValue = initialValue || "{}";
     const sharedSchemaDocumentNode = safeParseSdl(sharedSchemaSdl);
@@ -180564,7 +180860,7 @@ function StateEditor({ modelName, stateSchema, initialValue, setStateSchema, set
     }
     return { initialValueErrors: errors5, fixedState: null };
   }, [sharedSchemaSdl, initialValue, syncWithSchema, scope, modelName]);
-  useEffect24(() => {
+  useEffect25(() => {
     if (fixedState && !hasSyncedRef.current) {
       hasSyncedRef.current = true;
       setInitialState(fixedState, scope);
@@ -180605,18 +180901,18 @@ import { jsx as _jsx23, jsxs as _jsxs10 } from "react/jsx-runtime";
 import { DocumentToolbar } from "@powerhousedao/design-system/connect";
 import { addModule, addOperation, addOperationError, deleteModule, deleteOperation, deleteOperationError, setAuthorName, setAuthorWebsite, setInitialState, setModelDescription, setModelExtension, setModelId, setModelName, setModuleName, setOperationDescription, setOperationErrorName, setOperationName, setOperationSchema, setStateSchema } from "document-model";
 import { generateId as generateId3 } from "document-model/core";
-import { lazy as lazy4, Suspense as Suspense3, useEffect as useEffect25, useRef as useRef23, useState as useState19 } from "react";
+import { lazy as lazy4, Suspense as Suspense3, useEffect as useEffect26, useRef as useRef24, useState as useState20 } from "react";
 function Editor() {
   useSetPHDocumentEditorConfig(editorConfig);
   const toast3 = usePHToast();
   const [document2, dispatch] = useSelectedDocumentModelDocument();
-  const [scope, setScope] = useState19("global");
+  const [scope, setScope] = useState20("global");
   const documentNodeName = document2.header.name;
   const { name: modelName, id: documentType, extension, description, author: { name: authorName, website: authorWebsite } } = document2.state.global;
   const { state: { global: { schema: globalStateSchema, initialValue: globalStateInitialValue }, local: { schema: localStateSchema, initialValue: localStateInitialValue } }, modules } = document2.state.global.specifications[0];
   const operations = modules.flatMap((module) => module.operations);
-  const shouldSetInitialName = useRef23(!modelName && !!documentNodeName && operations.length === 0);
-  useEffect25(() => {
+  const shouldSetInitialName = useRef24(!modelName && !!documentNodeName && operations.length === 0);
+  useEffect26(() => {
     if (!shouldSetInitialName.current || !documentNodeName)
       return;
     const initialSchemaDoc2 = initializeModelSchema(documentNodeName);
@@ -181713,9 +182009,9 @@ var init_esm12 = __esm(() => {
 import { jsx as _jsx25 } from "react/jsx-runtime";
 import { useWindowSize } from "@powerhousedao/design-system";
 import { FileItem } from "@powerhousedao/design-system/connect";
-import React33, { useRef as useRef24 } from "react";
+import React33, { useRef as useRef25 } from "react";
 function FileContentView() {
-  const parentRef = useRef24(null);
+  const parentRef = useRef25(null);
   const windowSize = useWindowSize();
   const availableWidth = windowSize.innerWidth - USED_SPACE;
   const nodes = useNodesInSelectedDriveOrFolder();
@@ -181889,14 +182185,15 @@ var init_editors = __esm(() => {
 import { logger as logger9 } from "document-drive";
 import { useSyncExternalStore as useSyncExternalStore4 } from "react";
 import { use as use3, useCallback as useCallback21, useSyncExternalStore as useSyncExternalStore22 } from "react";
-import { useEffect as useEffect27, useState as useState21 } from "react";
+import { useEffect as useEffect28, useState as useState22 } from "react";
 import { logger as logger52 } from "document-drive";
 import { logger as logger42 } from "document-drive";
 import { logger as logger23 } from "document-drive";
 import { logger as logger32 } from "document-drive";
 import { buildSignedAction as buildSignedAction2 } from "document-model/core";
 import { useSyncExternalStore as useSyncExternalStore32 } from "react";
-import { useEffect as useEffect28, useState as useState22 } from "react";
+import { useEffect as useEffect29, useState as useState23 } from "react";
+import { useEffect as useEffect32, useRef as useRef26, useState as useState32 } from "react";
 function consumeDidFromUrl2() {
   if (typeof window === "undefined")
     return;
@@ -182170,8 +182467,8 @@ class DocumentCache2 {
 }
 function useUser2() {
   const renown = useRenown2();
-  const [user, setUser2] = useState21(() => renown?.user);
-  useEffect27(() => {
+  const [user, setUser2] = useState22(() => renown?.user);
+  useEffect28(() => {
     setUser2(renown?.user);
     if (!renown)
       return;
@@ -182388,6 +182685,48 @@ function setDefaultPHGlobalConfig(config20) {
     callGlobalSetterForKey2(key, config20[key]);
   }
 }
+function useConnectionStates2() {
+  const syncManager = useSync2();
+  const [states, setStates] = useState32(() => buildSnapshot2(syncManager));
+  const unsubscribesRef = useRef26([]);
+  useEffect32(() => {
+    if (!syncManager)
+      return;
+    function subscribe2() {
+      for (const unsub of unsubscribesRef.current) {
+        unsub();
+      }
+      unsubscribesRef.current = [];
+      const remotes = syncManager.list();
+      for (const remote of remotes) {
+        const unsub = remote.channel.onConnectionStateChange(() => {
+          setStates(buildSnapshot2(syncManager));
+        });
+        unsubscribesRef.current.push(unsub);
+      }
+      setStates(buildSnapshot2(syncManager));
+    }
+    subscribe2();
+    const interval = setInterval(subscribe2, 5000);
+    return () => {
+      clearInterval(interval);
+      for (const unsub of unsubscribesRef.current) {
+        unsub();
+      }
+      unsubscribesRef.current = [];
+    };
+  }, [syncManager]);
+  return states;
+}
+function buildSnapshot2(syncManager) {
+  const map2 = new Map;
+  if (!syncManager)
+    return map2;
+  for (const remote of syncManager.list()) {
+    map2.set(remote.name, remote.channel.getConnectionState());
+  }
+  return map2;
+}
 var SPLIT_LOWER_UPPER_RE3, SPLIT_UPPER_UPPER_RE3, SPLIT_SEPARATE_NUMBER_RE3, DEFAULT_STRIP_REGEXP3, SPLIT_REPLACE_VALUE3 = "$1\x00$2", DEFAULT_PREFIX_SUFFIX_CHARACTERS3 = "", isExternalControlsEnabledEventFunctions2, setIsExternalControlsEnabled2, useIsExternalControlsEnabled2, addIsExternalControlsEnabledEventHandler2, isDragAndDropEnabledEventFunctions2, setIsDragAndDropEnabled2, useIsDragAndDropEnabled2, addIsDragAndDropEnabledEventHandler2, allowedDocumentTypesEventFunctions2, setAllowedDocumentTypes2, addAllowedDocumentTypesEventHandler2, phDriveEditorConfigSetters2, phDocumentEditorConfigSetters2, phDriveEditorConfigHooks2, phDocumentEditorConfigHooks2, useRouterBasename2, setRouterBasename2, addRouterBasenameEventHandler2, useVersion2, setVersion2, addVersionEventHandler2, useRequiresHardRefresh2, setRequiresHardRefresh2, addRequiresHardRefreshEventHandler2, useWarnOutdatedApp2, setWarnOutdatedApp2, addWarnOutdatedAppEventHandler2, useStudioMode2, setStudioMode2, addStudioModeEventHandler2, useBasePath2, setBasePath2, addBasePathEventHandler2, useVersionCheckInterval2, setVersionCheckInterval2, addVersionCheckIntervalEventHandler2, useCliVersion2, setCliVersion2, addCliVersionEventHandler2, useFileUploadOperationsChunkSize2, setFileUploadOperationsChunkSize2, addFileUploadOperationsChunkSizeEventHandler2, useIsDocumentModelSelectionSettingsEnabled2, setIsDocumentModelSelectionSettingsEnabled2, addIsDocumentModelSelectionSettingsEnabledEventHandler2, useGaTrackingId2, setGaTrackingId2, addGaTrackingIdEventHandler2, useDefaultDrivesUrl2, setDefaultDrivesUrl2, addDefaultDrivesUrlEventHandler2, useDrivesPreserveStrategy2, setDrivesPreserveStrategy2, addDrivesPreserveStrategyEventHandler2, useIsLocalDrivesEnabled2, setIsLocalDrivesEnabled2, addIsLocalDrivesEnabledEventHandler2, useIsAddDriveEnabled2, setIsAddDriveEnabled2, addIsAddDriveEnabledEventHandler2, useIsPublicDrivesEnabled2, setIsPublicDrivesEnabled2, addIsPublicDrivesEnabledEventHandler2, useIsAddPublicDrivesEnabled2, setIsAddPublicDrivesEnabled2, addIsAddPublicDrivesEnabledEventHandler2, useIsDeletePublicDrivesEnabled2, setIsDeletePublicDrivesEnabled2, addIsDeletePublicDrivesEnabledEventHandler2, useIsCloudDrivesEnabled2, setIsCloudDrivesEnabled2, addIsCloudDrivesEnabledEventHandler2, useIsAddCloudDrivesEnabled2, setIsAddCloudDrivesEnabled2, addIsAddCloudDrivesEnabledEventHandler2, useIsDeleteCloudDrivesEnabled2, setIsDeleteCloudDrivesEnabled2, addIsDeleteCloudDrivesEnabledEventHandler2, useLocalDrivesEnabled2, setLocalDrivesEnabled2, addLocalDrivesEnabledEventHandler2, useIsAddLocalDrivesEnabled2, setIsAddLocalDrivesEnabled2, addIsAddLocalDrivesEnabledEventHandler2, useIsDeleteLocalDrivesEnabled2, setIsDeleteLocalDrivesEnabled2, addIsDeleteLocalDrivesEnabledEventHandler2, useIsEditorDebugModeEnabled2, setIsEditorDebugModeEnabled2, addIsEditorDebugModeEnabledEventHandler2, useIsEditorReadModeEnabled2, setIsEditorReadModeEnabled2, addIsEditorReadModeEnabledEventHandler2, useIsAnalyticsDatabaseWorkerEnabled2, setIsAnalyticsDatabaseWorkerEnabled2, addIsAnalyticsDatabaseWorkerEnabledEventHandler2, useIsDiffAnalyticsEnabled2, setIsDiffAnalyticsEnabled2, addIsDiffAnalyticsEnabledEventHandler2, useIsDriveAnalyticsEnabled2, setIsDriveAnalyticsEnabled2, addIsDriveAnalyticsEnabledEventHandler2, useRenownUrl2, setRenownUrl2, addRenownUrlEventHandler2, useRenownNetworkId2, setRenownNetworkId2, addRenownNetworkIdEventHandler2, useRenownChainId2, setRenownChainId2, addRenownChainIdEventHandler2, useSentryRelease2, setSentryRelease2, addSentryReleaseEventHandler2, useSentryDsn2, setSentryDsn2, addSentryDsnEventHandler2, useSentryEnv2, setSentryEnv2, addSentryEnvEventHandler2, useIsSentryTracingEnabled2, setIsSentryTracingEnabled2, addIsSentryTracingEnabledEventHandler2, useIsExternalProcessorsEnabled2, setIsExternalProcessorsEnabled2, addIsExternalProcessorsEnabledEventHandler2, useIsExternalPackagesEnabled2, setIsExternalPackagesEnabled2, addIsExternalPackagesEnabledEventHandler2, enabledEditorsEventFunctions2, setEnabledEditors2, useEnabledEditors2, addEnabledEditorsEventHandler2, disabledEditorsEventFunctions2, setDisabledEditors2, useDisabledEditors2, addDisabledEditorsEventHandler2, isRelationalProcessorsEnabled2, setIsRelationalProcessorsEnabled2, useIsRelationalProcessorsEnabled2, addIsRelationalProcessorsEnabledEventHandler2, isExternalRelationalProcessorsEnabled2, setIsExternalRelationalProcessorsEnabled2, useIsExternalRelationalProcessorsEnabled2, addIsExternalRelationalProcessorsEnabledEventHandler2, isAnalyticsEnabledEventFunctions2, setIsAnalyticsEnabled2, useIsAnalyticsEnabled2, addIsAnalyticsEnabledEventHandler2, isAnalyticsExternalProcessorsEnabled2, setIsAnalyticsExternalProcessorsEnabled2, useIsAnalyticsExternalProcessorsEnabled2, addIsAnalyticsExternalProcessorsEnabledEventHandler2, analyticsDatabaseNameEventFunctions2, setAnalyticsDatabaseName2, useAnalyticsDatabaseName2, addAnalyticsDatabaseNameEventHandler2, logLevelEventFunctions2, setLogLevel3, useLogLevel2, addLogLevelEventHandler2, allowListEventFunctions2, setAllowList2, useAllowList2, addAllowListEventHandler2, nonUserConfigSetters2, phGlobalConfigSetters2, nonUserConfigHooks2, phGlobalConfigHooks2, featuresEventFunctions2, useFeatures2, setFeatures2, addFeaturesEventHandler2, documentEventFunctions2, useDocumentCache2, setDocumentCache2, addDocumentCacheEventHandler2, drivesEventFunctions2, useDrives2, setDrives2, addDrivesEventHandler2, useLoading2, setLoading2, addLoadingEventHandler2, modalEventFunctions2, usePHModal2, setPHModal2, addModalEventHandler2, reactorClientModuleEventFunctions2, reactorClientEventFunctions2, useReactorClientModule2, setReactorClientModule2, addReactorClientModuleEventHandler2, useReactorClient2, setReactorClient2, addReactorClientEventHandler2, useSync2 = () => useReactorClientModule2()?.reactorModule?.syncModule?.syncManager, useSyncList2 = () => {
   const sync = useSync2();
   return sync?.list() ?? [];
@@ -252224,10 +252563,10 @@ var init_reactor2 = __esm(() => {
 });
 
 // src/store/user.ts
-import { useEffect as useEffect34 } from "react";
+import { useEffect as useEffect37 } from "react";
 function useSetSentryUser() {
   const user = useUser2();
-  useEffect34(() => {
+  useEffect37(() => {
     let sentryUser = null;
     if (user) {
       const { credential, ...rest } = user;