@topgunbuild/server 0.10.1 → 0.11.0

package/dist/start-server.js

@@ -462,7 +462,7 @@ var require_serialize = __commonJS({
   "../../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/serialize.js"(exports2, module2) {
     "use strict";
     var { cppdb } = require_util();
-    module2.exports = function serialize7(options) {
+    module2.exports = function serialize8(options) {
       if (options == null) options = {};
       if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
       const attachedName = "attached" in options ? options.attached : "main";
@@ -805,7 +805,7 @@ var require_lib = __commonJS({
 
 // src/ServerFactory.ts
 var import_http = require("http");
-var import_core41 = require("@topgunbuild/core");
+var import_core42 = require("@topgunbuild/core");
 
 // src/ServerCoordinator.ts
 var import_core = require("@topgunbuild/core");
@@ -8938,17 +8938,18 @@ function buildTLSOptions(config2) {
   return options;
 }
 function createNetworkModule(config2, _deps) {
+  let currentRequestHandler = (_req, res) => {
+    res.writeHead(200);
+    res.end(config2.tls?.enabled ? "TopGun Server Running (Secure)" : "TopGun Server Running");
+  };
+  const requestDispatcher = (req, res) => {
+    currentRequestHandler(req, res);
+  };
   let httpServer;
   if (config2.tls?.enabled) {
-    httpServer = (0, import_node_https.createServer)(buildTLSOptions(config2.tls), (_req, res) => {
-      res.writeHead(200);
-      res.end("TopGun Server Running (Secure)");
-    });
+    httpServer = (0, import_node_https.createServer)(buildTLSOptions(config2.tls), requestDispatcher);
   } else {
-    httpServer = (0, import_node_http.createServer)((_req, res) => {
-      res.writeHead(200);
-      res.end("TopGun Server Running");
-    });
+    httpServer = (0, import_node_http.createServer)(requestDispatcher);
   }
   httpServer.maxConnections = config2.maxConnections ?? 1e4;
   httpServer.timeout = config2.serverTimeout ?? 12e4;
@@ -8986,13 +8987,18 @@ function createNetworkModule(config2, _deps) {
       httpServer.listen(config2.port, () => {
         logger.info({ port: config2.port }, "Server Coordinator listening");
       });
+    },
+    // Deferred wiring: allows ServerFactory to inject the /sync handler
+    // after HttpSyncHandler is assembled
+    setHttpRequestHandler: (handler) => {
+      currentRequestHandler = handler;
     }
   };
 }
 
 // src/modules/handlers-module.ts
 var import_ws9 = require("ws");
-var import_core37 = require("@topgunbuild/core");
+var import_core38 = require("@topgunbuild/core");
 
 // src/coordinator/auth-handler.ts
 var jwt = __toESM(require("jsonwebtoken"));
@@ -12048,13 +12054,260 @@ var QueryHandler = class {
   }
 };
 
+// src/coordinator/http-sync-handler.ts
+var import_core25 = require("@topgunbuild/core");
+var HttpSyncHandler = class {
+  constructor(config2) {
+    this.config = config2;
+  }
+  /**
+   * Process a complete HTTP sync request and return a response.
+   *
+   * @param request - Parsed and validated HttpSyncRequest body
+   * @param authToken - JWT token from Authorization header
+   * @returns HttpSyncResponse with acks, deltas, query/search results
+   * @throws Error with message starting with '401:' for auth failures
+   * @throws Error with message starting with '403:' for permission failures
+   */
+  async handleSyncRequest(request, authToken) {
+    let principal;
+    try {
+      principal = this.config.authHandler.verifyToken(authToken);
+    } catch (err) {
+      throw new Error(`401: Authentication failed: ${err.message}`);
+    }
+    this.config.hlc.update({
+      millis: request.clientHlc.millis,
+      counter: request.clientHlc.counter,
+      nodeId: request.clientHlc.nodeId
+    });
+    const response = {
+      serverHlc: this.config.hlc.now()
+    };
+    const errors = [];
+    if (request.operations && request.operations.length > 0) {
+      const ackResults = await this.processOperations(request.operations, principal, errors);
+      if (ackResults.processedCount > 0) {
+        response.ack = {
+          lastId: ackResults.lastId,
+          results: ackResults.results.length > 0 ? ackResults.results : void 0
+        };
+      }
+    }
+    if (request.syncMaps && request.syncMaps.length > 0) {
+      response.deltas = await this.computeDeltas(request.syncMaps, principal, errors);
+    }
+    if (request.queries && request.queries.length > 0) {
+      response.queryResults = await this.executeQueries(request.queries, principal, errors);
+    }
+    if (request.searches && request.searches.length > 0) {
+      response.searchResults = await this.executeSearches(request.searches, principal, errors);
+    }
+    if (errors.length > 0) {
+      response.errors = errors;
+    }
+    response.serverHlc = this.config.hlc.now();
+    return response;
+  }
+  /**
+   * Process a batch of client operations.
+   */
+  async processOperations(operations, principal, errors) {
+    let lastId = "";
+    let processedCount = 0;
+    const results = [];
+    for (const op of operations) {
+      const opId = op.id || `http-op-${processedCount}`;
+      const isRemove = op.opType === "REMOVE" || op.record && op.record.value === null;
+      const action = isRemove ? "REMOVE" : "PUT";
+      if (!this.config.securityManager.checkPermission(principal, op.mapName, action)) {
+        errors.push({
+          code: 403,
+          message: "Access denied",
+          context: `Operation on ${op.mapName}/${op.key}`
+        });
+        results.push({
+          opId,
+          success: false,
+          achievedLevel: "FIRE_AND_FORGET",
+          error: "Access denied"
+        });
+        continue;
+      }
+      try {
+        const result = await this.config.operationHandler.applyOpToMap(op);
+        if (result.rejected) {
+          results.push({
+            opId,
+            success: false,
+            achievedLevel: "FIRE_AND_FORGET",
+            error: "Operation rejected by conflict resolver"
+          });
+        } else {
+          results.push({
+            opId,
+            success: true,
+            achievedLevel: "MEMORY"
+          });
+        }
+        processedCount++;
+        lastId = opId;
+      } catch (err) {
+        logger.error({ err, opId }, "HTTP sync operation failed");
+        errors.push({
+          code: 500,
+          message: err.message || "Operation failed",
+          context: `Operation ${opId} on ${op.mapName}/${op.key}`
+        });
+        results.push({
+          opId,
+          success: false,
+          achievedLevel: "FIRE_AND_FORGET",
+          error: err.message || "Operation failed"
+        });
+      }
+    }
+    return { processedCount, lastId, results };
+  }
+  /**
+   * Compute deltas by iterating the in-memory LWWMap and filtering records
+   * newer than the client's lastSyncTimestamp using HLC.compare().
+   */
+  async computeDeltas(syncMaps, principal, errors) {
+    const deltas = [];
+    for (const { mapName, lastSyncTimestamp } of syncMaps) {
+      if (!this.config.securityManager.checkPermission(principal, mapName, "READ")) {
+        errors.push({
+          code: 403,
+          message: "Access denied",
+          context: `Read deltas for ${mapName}`
+        });
+        continue;
+      }
+      try {
+        const map2 = await this.config.storageManager.getMapAsync(mapName);
+        if (!(map2 instanceof import_core25.LWWMap)) {
+          errors.push({
+            code: 400,
+            message: "HTTP sync only supports LWWMap deltas",
+            context: `Map ${mapName} is not an LWWMap`
+          });
+          continue;
+        }
+        const records = [];
+        for (const key of map2.allKeys()) {
+          const record2 = map2.getRecord(key);
+          if (!record2) continue;
+          if (import_core25.HLC.compare(record2.timestamp, lastSyncTimestamp) > 0) {
+            records.push({
+              key,
+              record: record2,
+              eventType: record2.value === null ? "REMOVE" : "PUT"
+            });
+          }
+        }
+        const serverSyncTimestamp = this.config.hlc.now();
+        deltas.push({
+          mapName,
+          records,
+          serverSyncTimestamp
+        });
+      } catch (err) {
+        logger.error({ err, mapName }, "HTTP sync delta computation failed");
+        errors.push({
+          code: 500,
+          message: err.message || "Delta computation failed",
+          context: `Map ${mapName}`
+        });
+      }
+    }
+    return deltas.length > 0 ? deltas : void 0;
+  }
+  /**
+   * Execute one-shot queries.
+   */
+  async executeQueries(queries, principal, errors) {
+    const results = [];
+    for (const query of queries) {
+      if (!this.config.securityManager.checkPermission(principal, query.mapName, "READ")) {
+        errors.push({
+          code: 403,
+          message: "Access denied",
+          context: `Query ${query.queryId} on ${query.mapName}`
+        });
+        continue;
+      }
+      try {
+        const coreQuery = {
+          where: query.filter,
+          limit: query.limit
+        };
+        const queryResults = await this.config.queryConversionHandler.executeLocalQuery(
+          query.mapName,
+          coreQuery
+        );
+        const hasMore = query.limit ? queryResults.length >= query.limit : false;
+        results.push({
+          queryId: query.queryId,
+          results: queryResults,
+          hasMore
+        });
+      } catch (err) {
+        logger.error({ err, queryId: query.queryId }, "HTTP sync query failed");
+        errors.push({
+          code: 500,
+          message: err.message || "Query failed",
+          context: `Query ${query.queryId} on ${query.mapName}`
+        });
+      }
+    }
+    return results.length > 0 ? results : void 0;
+  }
+  /**
+   * Execute one-shot searches.
+   */
+  async executeSearches(searches, principal, errors) {
+    const results = [];
+    for (const search of searches) {
+      if (!this.config.securityManager.checkPermission(principal, search.mapName, "READ")) {
+        errors.push({
+          code: 403,
+          message: "Access denied",
+          context: `Search ${search.searchId} on ${search.mapName}`
+        });
+        continue;
+      }
+      try {
+        const searchResult = this.config.searchCoordinator.search(
+          search.mapName,
+          search.query,
+          search.options
+        );
+        results.push({
+          searchId: search.searchId,
+          results: searchResult.results || [],
+          totalCount: searchResult.totalCount
+        });
+      } catch (err) {
+        logger.error({ err, searchId: search.searchId }, "HTTP sync search failed");
+        errors.push({
+          code: 500,
+          message: err.message || "Search failed",
+          context: `Search ${search.searchId} on ${search.mapName}`
+        });
+      }
+    }
+    return results.length > 0 ? results : void 0;
+  }
+};
+
 // src/coordinator/websocket-handler.ts
 var crypto2 = __toESM(require("crypto"));
-var import_core26 = require("@topgunbuild/core");
+var import_core27 = require("@topgunbuild/core");
 
 // src/utils/CoalescingWriter.ts
 var import_ws7 = require("ws");
-var import_core25 = require("@topgunbuild/core");
+var import_core26 = require("@topgunbuild/core");
 var DEFAULT_OPTIONS = {
   maxBatchSize: 100,
   maxDelayMs: 5,
@@ -12095,7 +12348,7 @@ var CoalescingWriter = class {
     if (this.closed) {
       return;
     }
-    const data = (0, import_core25.serialize)(message);
+    const data = (0, import_core26.serialize)(message);
     this.writeRaw(data, urgent);
   }
   /**
@@ -12279,7 +12532,7 @@ var CoalescingWriter = class {
       offset += msg.data.length;
     }
     const usedBatch = batch.subarray(0, totalSize);
-    const batchEnvelope = (0, import_core25.serialize)({
+    const batchEnvelope = (0, import_core26.serialize)({
       type: "BATCH",
       count: messages.length,
       data: usedBatch
@@ -12362,7 +12615,7 @@ var WebSocketHandler = class {
           buf = Buffer.from(message);
         }
         try {
-          data = (0, import_core26.deserialize)(buf);
+          data = (0, import_core27.deserialize)(buf);
         } catch (e) {
           try {
             const text = Buffer.isBuffer(buf) ? buf.toString() : new TextDecoder().decode(buf);
@@ -12380,14 +12633,14 @@ var WebSocketHandler = class {
     ws.on("close", () => {
       this.handleDisconnect(connection);
     });
-    ws.send((0, import_core26.serialize)({ type: "AUTH_REQUIRED" }));
+    ws.send((0, import_core27.serialize)({ type: "AUTH_REQUIRED" }));
   }
   /**
    * Handle incoming message from client.
    * Validates message, handles auth, and routes to appropriate handler.
    */
   async handleMessage(client, rawMessage) {
-    const parseResult = import_core26.MessageSchema.safeParse(rawMessage);
+    const parseResult = import_core27.MessageSchema.safeParse(rawMessage);
     if (!parseResult.success) {
       this.config.rateLimitedLogger.error(
         `invalid-message:${client.id}`,
@@ -12481,7 +12734,7 @@ var WebSocketHandler = class {
 };
 
 // src/coordinator/lifecycle-manager.ts
-var import_core27 = require("@topgunbuild/core");
+var import_core28 = require("@topgunbuild/core");
 var LifecycleManager = class {
   constructor(config2) {
     this.config = config2;
@@ -12527,7 +12780,7 @@ var LifecycleManager = class {
     this.config.metricsService.destroy();
     this.config.wss.close();
     logger.info(`Closing ${this.config.connectionManager.getClientCount()} client connections...`);
-    const shutdownMsg = (0, import_core27.serialize)({ type: "SHUTDOWN_PENDING", retryAfter: 5e3 });
+    const shutdownMsg = (0, import_core28.serialize)({ type: "SHUTDOWN_PENDING", retryAfter: 5e3 });
     for (const client of this.config.connectionManager.getClients().values()) {
       try {
         if (client.socket.readyState === 1) {
@@ -12679,7 +12932,7 @@ var LifecycleManager = class {
 };
 
 // src/handlers/CounterHandler.ts
-var import_core28 = require("@topgunbuild/core");
+var import_core29 = require("@topgunbuild/core");
 var CounterHandler = class {
   // counterName -> Set<clientId>
   constructor(nodeId = "server") {
@@ -12693,7 +12946,7 @@ var CounterHandler = class {
   getOrCreateCounter(name) {
     let counter = this.counters.get(name);
     if (!counter) {
-      counter = new import_core28.PNCounterImpl({ nodeId: this.nodeId });
+      counter = new import_core29.PNCounterImpl({ nodeId: this.nodeId });
       this.counters.set(name, counter);
       logger.debug({ name }, "Created new counter");
     }
@@ -12827,10 +13080,10 @@ var CounterHandler = class {
 };
 
 // src/handlers/EntryProcessorHandler.ts
-var import_core30 = require("@topgunbuild/core");
+var import_core31 = require("@topgunbuild/core");
 
 // src/ProcessorSandbox.ts
-var import_core29 = require("@topgunbuild/core");
+var import_core30 = require("@topgunbuild/core");
 var ivm = null;
 try {
   ivm = require("isolated-vm");
@@ -12874,7 +13127,7 @@ var ProcessorSandbox = class {
       };
     }
     if (this.config.strictValidation) {
-      const validation = (0, import_core29.validateProcessorCode)(processor.code);
+      const validation = (0, import_core30.validateProcessorCode)(processor.code);
       if (!validation.valid) {
         return {
           success: false,
@@ -13089,7 +13342,7 @@ var EntryProcessorHandler = class {
    * @returns Result with success status, processor result, and new value
    */
   async executeOnKey(map2, key, processorDef) {
-    const parseResult = import_core30.EntryProcessorDefSchema.safeParse(processorDef);
+    const parseResult = import_core31.EntryProcessorDefSchema.safeParse(processorDef);
     if (!parseResult.success) {
       logger.warn(
         { key, error: parseResult.error.message },
@@ -13155,7 +13408,7 @@ var EntryProcessorHandler = class {
   async executeOnKeys(map2, keys, processorDef) {
     const results = /* @__PURE__ */ new Map();
     const timestamps = /* @__PURE__ */ new Map();
-    const parseResult = import_core30.EntryProcessorDefSchema.safeParse(processorDef);
+    const parseResult = import_core31.EntryProcessorDefSchema.safeParse(processorDef);
     if (!parseResult.success) {
       const errorResult = {
         success: false,
@@ -13192,7 +13445,7 @@ var EntryProcessorHandler = class {
   async executeOnEntries(map2, processorDef, predicateCode) {
     const results = /* @__PURE__ */ new Map();
     const timestamps = /* @__PURE__ */ new Map();
-    const parseResult = import_core30.EntryProcessorDefSchema.safeParse(processorDef);
+    const parseResult = import_core31.EntryProcessorDefSchema.safeParse(processorDef);
     if (!parseResult.success) {
       return { results, timestamps };
     }
@@ -13251,7 +13504,7 @@ var EntryProcessorHandler = class {
 };
 
 // src/ConflictResolverService.ts
-var import_core31 = require("@topgunbuild/core");
+var import_core32 = require("@topgunbuild/core");
 var DEFAULT_CONFLICT_RESOLVER_CONFIG = {
   maxResolversPerMap: 100,
   enableSandboxedResolvers: true,
@@ -13282,7 +13535,7 @@ var ConflictResolverService = class {
       throw new Error("ConflictResolverService has been disposed");
     }
     if (resolver.code) {
-      const parsed = import_core31.ConflictResolverDefSchema.safeParse({
+      const parsed = import_core32.ConflictResolverDefSchema.safeParse({
         name: resolver.name,
         code: resolver.code,
         priority: resolver.priority,
@@ -13291,7 +13544,7 @@ var ConflictResolverService = class {
       if (!parsed.success) {
         throw new Error(`Invalid resolver definition: ${parsed.error.message}`);
       }
-      const validation = (0, import_core31.validateResolverCode)(resolver.code);
+      const validation = (0, import_core32.validateResolverCode)(resolver.code);
       if (!validation.valid) {
         throw new Error(`Invalid resolver code: ${validation.error}`);
       }
@@ -13353,7 +13606,7 @@ var ConflictResolverService = class {
     const entries = this.resolvers.get(context.mapName) ?? [];
     const allEntries = [
       ...entries,
-      { resolver: import_core31.BuiltInResolvers.LWW() }
+      { resolver: import_core32.BuiltInResolvers.LWW() }
     ];
     for (const entry of allEntries) {
       const { resolver } = entry;
@@ -13809,7 +14062,7 @@ var TopicManager = class {
 
 // src/search/SearchCoordinator.ts
 var import_events13 = require("events");
-var import_core32 = require("@topgunbuild/core");
+var import_core33 = require("@topgunbuild/core");
 var SearchCoordinator = class extends import_events13.EventEmitter {
   constructor() {
     super();
@@ -13879,7 +14132,7 @@ var SearchCoordinator = class extends import_events13.EventEmitter {
       logger.warn({ mapName }, "FTS already enabled for map, replacing index");
       this.indexes.delete(mapName);
     }
-    const index = new import_core32.FullTextIndex(config2);
+    const index = new import_core33.FullTextIndex(config2);
     this.indexes.set(mapName, index);
     this.configs.set(mapName, config2);
     logger.info({ mapName, fields: config2.fields }, "FTS enabled for map");
@@ -14511,7 +14764,7 @@ var SearchCoordinator = class extends import_events13.EventEmitter {
 
 // src/search/ClusterSearchCoordinator.ts
 var import_events14 = require("events");
-var import_core33 = require("@topgunbuild/core");
+var import_core34 = require("@topgunbuild/core");
 var DEFAULT_CONFIG6 = {
   rrfK: 60,
   defaultTimeoutMs: 5e3,
@@ -14526,7 +14779,7 @@ var ClusterSearchCoordinator = class extends import_events14.EventEmitter {
     this.partitionService = partitionService;
     this.localSearchCoordinator = localSearchCoordinator;
     this.config = { ...DEFAULT_CONFIG6, ...config2 };
-    this.rrf = new import_core33.ReciprocalRankFusion({ k: this.config.rrfK });
+    this.rrf = new import_core34.ReciprocalRankFusion({ k: this.config.rrfK });
     this.metricsService = metricsService;
     this.clusterManager.on("message", this.handleClusterMessage.bind(this));
   }
@@ -14550,8 +14803,8 @@ var ClusterSearchCoordinator = class extends import_events14.EventEmitter {
     const perNodeLimit = this.calculatePerNodeLimit(options.limit, options.cursor);
     let cursorData = null;
     if (options.cursor) {
-      cursorData = import_core33.SearchCursor.decode(options.cursor);
-      if (cursorData && !import_core33.SearchCursor.isValid(cursorData, query)) {
+      cursorData = import_core34.SearchCursor.decode(options.cursor);
+      if (cursorData && !import_core34.SearchCursor.isValid(cursorData, query)) {
         cursorData = null;
         logger.warn({ requestId }, "Invalid or expired cursor, ignoring");
       }
@@ -14617,7 +14870,7 @@ var ClusterSearchCoordinator = class extends import_events14.EventEmitter {
   async handleSearchRequest(senderId, rawPayload) {
     const startTime = performance.now();
     const myNodeId = this.clusterManager.config.nodeId;
-    const parsed = import_core33.ClusterSearchReqPayloadSchema.safeParse(rawPayload);
+    const parsed = import_core34.ClusterSearchReqPayloadSchema.safeParse(rawPayload);
     if (!parsed.success) {
       logger.warn(
         { senderId, error: parsed.error.message },
@@ -14684,7 +14937,7 @@ var ClusterSearchCoordinator = class extends import_events14.EventEmitter {
    * Handle search response from a node.
    */
   handleSearchResponse(_senderId, rawPayload) {
-    const parsed = import_core33.ClusterSearchRespPayloadSchema.safeParse(rawPayload);
+    const parsed = import_core34.ClusterSearchRespPayloadSchema.safeParse(rawPayload);
     if (!parsed.success) {
       logger.warn(
         { error: parsed.error.message },
@@ -14770,7 +15023,7 @@ var ClusterSearchCoordinator = class extends import_events14.EventEmitter {
     }
     let nextCursor;
     if (merged.length > limit && cursorResults.length > 0) {
-      nextCursor = import_core33.SearchCursor.fromResults(cursorResults, pending.query);
+      nextCursor = import_core34.SearchCursor.fromResults(cursorResults, pending.query);
     }
     const executionTimeMs = performance.now() - pending.startTime;
     if (this.metricsService) {
@@ -14836,7 +15089,7 @@ var ClusterSearchCoordinator = class extends import_events14.EventEmitter {
       });
       let results = localResult.results;
       if (cursorData) {
-        const position = import_core33.SearchCursor.getNodePosition(cursorData, myNodeId);
+        const position = import_core34.SearchCursor.getNodePosition(cursorData, myNodeId);
         if (position) {
           results = results.filter((r) => {
             if (r.score < position.afterScore) {
@@ -14885,9 +15138,9 @@ var ClusterSearchCoordinator = class extends import_events14.EventEmitter {
     });
     let results = localResult.results;
     if (options.cursor) {
-      const cursorData = import_core33.SearchCursor.decode(options.cursor);
-      if (cursorData && import_core33.SearchCursor.isValid(cursorData, query)) {
-        const position = import_core33.SearchCursor.getNodePosition(cursorData, myNodeId);
+      const cursorData = import_core34.SearchCursor.decode(options.cursor);
+      if (cursorData && import_core34.SearchCursor.isValid(cursorData, query)) {
+        const position = import_core34.SearchCursor.getNodePosition(cursorData, myNodeId);
         if (position) {
           results = results.filter((r) => {
             if (r.score < position.afterScore) {
@@ -14906,7 +15159,7 @@ var ClusterSearchCoordinator = class extends import_events14.EventEmitter {
     let nextCursor;
     if (totalCount > options.limit && results.length > 0) {
       const lastResult = results[results.length - 1];
-      nextCursor = import_core33.SearchCursor.fromResults(
+      nextCursor = import_core34.SearchCursor.fromResults(
         [{ key: lastResult.key, score: lastResult.score, nodeId: myNodeId }],
         query
       );
@@ -14964,10 +15217,10 @@ var ClusterSearchCoordinator = class extends import_events14.EventEmitter {
 
 // src/subscriptions/DistributedSubscriptionCoordinator.ts
 var import_events16 = require("events");
-var import_core35 = require("@topgunbuild/core");
+var import_core36 = require("@topgunbuild/core");
 
 // src/subscriptions/DistributedSearchCoordinator.ts
-var import_core34 = require("@topgunbuild/core");
+var import_core35 = require("@topgunbuild/core");
 
 // src/subscriptions/DistributedSubscriptionBase.ts
 var import_events15 = require("events");
@@ -15291,7 +15544,7 @@ var DistributedSearchCoordinator = class extends DistributedSubscriptionBase {
   constructor(clusterManager, searchCoordinator, config2, metricsService, options) {
     super(clusterManager, config2, metricsService, options);
     this.localSearchCoordinator = searchCoordinator;
-    this.rrf = new import_core34.ReciprocalRankFusion({ k: this.config.rrfK });
+    this.rrf = new import_core35.ReciprocalRankFusion({ k: this.config.rrfK });
     this.localSearchCoordinator.on("distributedUpdate", this.handleLocalSearchUpdate.bind(this));
     logger.debug("DistributedSearchCoordinator initialized");
   }
@@ -15823,7 +16076,7 @@ var DistributedSubscriptionCoordinator = class extends import_events16.EventEmit
   handleClusterMessage(msg) {
     switch (msg.type) {
       case "CLUSTER_SUB_REGISTER": {
-        const parsed = import_core35.ClusterSubRegisterPayloadSchema.safeParse(msg.payload);
+        const parsed = import_core36.ClusterSubRegisterPayloadSchema.safeParse(msg.payload);
         if (!parsed.success) {
           logger.warn(
             { senderId: msg.senderId, error: parsed.error.message },
@@ -15835,7 +16088,7 @@ var DistributedSubscriptionCoordinator = class extends import_events16.EventEmit
         break;
       }
       case "CLUSTER_SUB_ACK": {
-        const parsed = import_core35.ClusterSubAckPayloadSchema.safeParse(msg.payload);
+        const parsed = import_core36.ClusterSubAckPayloadSchema.safeParse(msg.payload);
         if (!parsed.success) {
           logger.warn(
             { senderId: msg.senderId, error: parsed.error.message },
@@ -15847,7 +16100,7 @@ var DistributedSubscriptionCoordinator = class extends import_events16.EventEmit
         break;
       }
       case "CLUSTER_SUB_UPDATE": {
-        const parsed = import_core35.ClusterSubUpdatePayloadSchema.safeParse(msg.payload);
+        const parsed = import_core36.ClusterSubUpdatePayloadSchema.safeParse(msg.payload);
         if (!parsed.success) {
           logger.warn(
             { senderId: msg.senderId, error: parsed.error.message },
@@ -15859,7 +16112,7 @@ var DistributedSubscriptionCoordinator = class extends import_events16.EventEmit
         break;
       }
       case "CLUSTER_SUB_UNREGISTER": {
-        const parsed = import_core35.ClusterSubUnregisterPayloadSchema.safeParse(msg.payload);
+        const parsed = import_core36.ClusterSubUnregisterPayloadSchema.safeParse(msg.payload);
         if (!parsed.success) {
           logger.warn(
             { senderId: msg.senderId, error: parsed.error.message },
@@ -15969,9 +16222,9 @@ var DistributedSubscriptionCoordinator = class extends import_events16.EventEmit
 };
 
 // src/EventJournalService.ts
-var import_core36 = require("@topgunbuild/core");
+var import_core37 = require("@topgunbuild/core");
 var DEFAULT_JOURNAL_SERVICE_CONFIG = {
-  ...import_core36.DEFAULT_EVENT_JOURNAL_CONFIG,
+  ...import_core37.DEFAULT_EVENT_JOURNAL_CONFIG,
   tableName: "event_journal",
   persistBatchSize: 100,
   persistIntervalMs: 1e3
@@ -15984,7 +16237,7 @@ function validateTableName(name) {
     );
   }
 }
-var EventJournalService = class extends import_core36.EventJournalImpl {
+var EventJournalService = class extends import_core37.EventJournalImpl {
   constructor(config2) {
     super(config2);
     this.pendingPersist = [];
@@ -16631,7 +16884,7 @@ function createQueryHandlers(config2, deps, internal) {
     finalizeClusterQuery: (reqId, timeout) => queryConversionHandler.finalizeClusterQuery(reqId, timeout),
     pendingClusterQueries: internal.pendingClusterQueries,
     readReplicaHandler: deps.cluster.readReplicaHandler,
-    ConsistencyLevel: { EVENTUAL: import_core37.ConsistencyLevel.EVENTUAL }
+    ConsistencyLevel: { EVENTUAL: import_core38.ConsistencyLevel.EVENTUAL }
   });
   return { queryHandler, queryConversionHandler };
 }
@@ -17028,7 +17281,7 @@ function createLifecycleModule(config2, deps) {
 }
 
 // src/debug/DebugEndpoints.ts
-var import_core38 = require("@topgunbuild/core");
+var import_core39 = require("@topgunbuild/core");
 var DebugEndpoints = class {
   constructor(config2) {
     this.config = config2;
@@ -17116,7 +17369,7 @@ var DebugEndpoints = class {
   async handleCrdtExport(req, res) {
     try {
       const body = await this.parseBody(req);
-      const debugger_ = (0, import_core38.getCRDTDebugger)();
+      const debugger_ = (0, import_core39.getCRDTDebugger)();
       const format = body.format || "json";
       const data = debugger_.exportHistory(format);
       const contentType = format === "csv" ? "text/csv" : format === "ndjson" ? "application/x-ndjson" : "application/json";
@@ -17130,7 +17383,7 @@ var DebugEndpoints = class {
   async handleCrdtStats(req, res) {
     try {
       const body = await this.parseBody(req);
-      const debugger_ = (0, import_core38.getCRDTDebugger)();
+      const debugger_ = (0, import_core39.getCRDTDebugger)();
       const stats = debugger_.getStatistics(body.mapId);
       res.setHeader("Content-Type", "application/json");
       res.end(JSON.stringify(stats, null, 2));
@@ -17142,7 +17395,7 @@ var DebugEndpoints = class {
   async handleCrdtConflicts(req, res) {
     try {
       const body = await this.parseBody(req);
-      const debugger_ = (0, import_core38.getCRDTDebugger)();
+      const debugger_ = (0, import_core39.getCRDTDebugger)();
       const conflicts = debugger_.getConflicts(body.mapId);
       res.setHeader("Content-Type", "application/json");
       res.end(JSON.stringify(conflicts, null, 2));
@@ -17154,7 +17407,7 @@ var DebugEndpoints = class {
   async handleCrdtOperations(req, res) {
     try {
       const body = await this.parseBody(req);
-      const debugger_ = (0, import_core38.getCRDTDebugger)();
+      const debugger_ = (0, import_core39.getCRDTDebugger)();
       const operations = debugger_.getOperations({
         mapId: body.mapId,
         nodeId: body.nodeId,
@@ -17171,7 +17424,7 @@ var DebugEndpoints = class {
   async handleCrdtTimeline(req, res) {
     try {
       const body = await this.parseBody(req);
-      const debugger_ = (0, import_core38.getCRDTDebugger)();
+      const debugger_ = (0, import_core39.getCRDTDebugger)();
       const intervalMs = body.intervalMs || 1e3;
       const timeline = debugger_.getTimeline(
         intervalMs,
@@ -17190,7 +17443,7 @@ var DebugEndpoints = class {
   async handleSearchExplain(req, res) {
     try {
       const body = await this.parseBody(req);
-      const debugger_ = (0, import_core38.getSearchDebugger)();
+      const debugger_ = (0, import_core39.getSearchDebugger)();
       if (body.query) {
         const lastQuery2 = debugger_.getLastQuery();
         if (lastQuery2 && lastQuery2.query === body.query) {
@@ -17222,7 +17475,7 @@ var DebugEndpoints = class {
   }
   handleSearchStats(res) {
     try {
-      const debugger_ = (0, import_core38.getSearchDebugger)();
+      const debugger_ = (0, import_core39.getSearchDebugger)();
       const stats = debugger_.getSearchStats();
       res.setHeader("Content-Type", "application/json");
       res.end(JSON.stringify(stats, null, 2));
@@ -17234,7 +17487,7 @@ var DebugEndpoints = class {
   async handleSearchHistory(req, res) {
     try {
       const body = await this.parseBody(req);
-      const debugger_ = (0, import_core38.getSearchDebugger)();
+      const debugger_ = (0, import_core39.getSearchDebugger)();
       let history;
       if (body.mapId) {
         history = debugger_.getHistoryByMap(body.mapId);
@@ -17302,7 +17555,7 @@ var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var crypto3 = __toESM(require("crypto"));
 var jwt2 = __toESM(require("jsonwebtoken"));
-var import_core39 = require("@topgunbuild/core");
+var import_core40 = require("@topgunbuild/core");
 var ENV_KEYS = {
   AUTO_SETUP: "TOPGUN_AUTO_SETUP",
   AUTO_SETUP_STRICT: "TOPGUN_AUTO_SETUP_STRICT",
@@ -17663,7 +17916,7 @@ var BootstrapController = class {
       const status = this.getClusterStatus();
       const transformedStatus = {
         ...status,
-        totalPartitions: import_core39.PARTITION_COUNT,
+        totalPartitions: import_core40.PARTITION_COUNT,
         // Fixed partition count (see PHASE_14D_AUTH_SECURITY.md)
         nodes: status.nodes.map((node) => ({
           nodeId: node.id,
@@ -17680,7 +17933,7 @@ var BootstrapController = class {
       this.sendJson(res, 200, {
         nodes: [],
         partitions: [],
-        totalPartitions: import_core39.PARTITION_COUNT,
+        totalPartitions: import_core40.PARTITION_COUNT,
         isRebalancing: false
       });
     }
@@ -17982,7 +18235,7 @@ function createBootstrapController(config2) {
 // src/settings/SettingsController.ts
 var fs2 = __toESM(require("fs"));
 var jwt3 = __toESM(require("jsonwebtoken"));
-var import_core40 = require("@topgunbuild/core");
+var import_core41 = require("@topgunbuild/core");
 var HOT_RELOADABLE = /* @__PURE__ */ new Set([
   "logLevel",
   "metricsEnabled",
@@ -18095,7 +18348,7 @@ var SettingsController = class {
         mode: config2?.deploymentMode || process.env.TOPGUN_DEPLOYMENT_MODE || "standalone",
         nodeId: process.env.TOPGUN_NODE_ID || "node-1",
         peers: [],
-        partitionCount: import_core40.PARTITION_COUNT
+        partitionCount: import_core41.PARTITION_COUNT
       },
       rateLimits: {
         connections: this.runtimeSettings.rateLimits.connections,
@@ -18567,6 +18820,25 @@ var ServerFactory = class _ServerFactory {
         journalSubscriptions
       }
     } = handlers;
+    const httpSyncHandler = new HttpSyncHandler({
+      authHandler,
+      operationHandler,
+      storageManager,
+      queryConversionHandler,
+      searchCoordinator,
+      hlc,
+      securityManager
+    });
+    if (network.setHttpRequestHandler) {
+      network.setHttpRequestHandler((req, res) => {
+        if (req.method === "POST" && req.url === "/sync") {
+          _ServerFactory.handleHttpSync(req, res, httpSyncHandler);
+          return;
+        }
+        res.writeHead(200);
+        res.end(config2.tls?.enabled ? "TopGun Server Running (Secure)" : "TopGun Server Running");
+      });
+    }
     const lifecycle = createLifecycleModule(
       { nodeId: config2.nodeId },
       {
@@ -18669,6 +18941,70 @@ var ServerFactory = class _ServerFactory {
     }
     return coordinator;
   }
+  /**
+   * Handle an HTTP sync request by parsing the body, validating auth,
+   * delegating to HttpSyncHandler, and serializing the response.
+   */
+  static handleHttpSync(req, res, handler) {
+    const authHeader = req.headers["authorization"] || "";
+    const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : "";
+    if (!token) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Missing Authorization header" }));
+      return;
+    }
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", async () => {
+      try {
+        const body = Buffer.concat(chunks);
+        const contentType = req.headers["content-type"] || "";
+        const isJson = contentType.includes("application/json");
+        let parsed;
+        if (isJson) {
+          parsed = JSON.parse(body.toString("utf-8"));
+        } else {
+          parsed = (0, import_core42.deserialize)(body);
+        }
+        const validation = import_core42.HttpSyncRequestSchema.safeParse(parsed);
+        if (!validation.success) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: "Invalid request body",
+            details: validation.error.issues
+          }));
+          return;
+        }
+        const response = await handler.handleSyncRequest(validation.data, token);
+        if (isJson) {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(response));
+        } else {
+          const responseBytes = (0, import_core42.serialize)(response);
+          res.writeHead(200, { "Content-Type": "application/x-msgpack" });
+          res.end(Buffer.from(responseBytes));
+        }
+      } catch (err) {
+        const message = err.message || "Internal server error";
+        if (message.startsWith("401:")) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: message.slice(5).trim() }));
+        } else if (message.startsWith("403:")) {
+          res.writeHead(403, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: message.slice(5).trim() }));
+        } else {
+          logger.error({ err }, "HTTP sync request failed");
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Internal server error" }));
+        }
+      }
+    });
+    req.on("error", (err) => {
+      logger.error({ err }, "HTTP sync request stream error");
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Request stream error" }));
+    });
+  }
   static createMetricsServer(bootstrap, settings, debug, metrics) {
     const server = (0, import_http.createServer)(async (req, res) => {
       const bootstrapHandled = await bootstrap.handle(req, res);
@@ -18699,7 +19035,7 @@ var ServerFactory = class _ServerFactory {
     const memberIds = cluster.getMembers();
     const nodes = memberIds.map((nodeId) => {
       let partitionCount = 0;
-      for (let i = 0; i < import_core41.PARTITION_COUNT; i++) {
+      for (let i = 0; i < import_core42.PARTITION_COUNT; i++) {
         if (partitionService.getPartitionOwner(i) === nodeId) partitionCount++;
       }
       return {
@@ -18713,7 +19049,7 @@ var ServerFactory = class _ServerFactory {
       };
     });
     const partitions = [];
-    for (let i = 0; i < import_core41.PARTITION_COUNT; i++) {
+    for (let i = 0; i < import_core42.PARTITION_COUNT; i++) {
       const owner = partitionService.getPartitionOwner(i);
       const backups = partitionService.getBackups(i);
       partitions.push({