@xtr-dev/rondevu-server 0.2.4 → 0.4.0

package/dist/index.js

@@ -607,6 +607,36 @@ function validateServiceFqn(fqn) {
   }
   return { valid: true };
 }
+function parseVersion(version) {
+  const match = version.match(/^([0-9]+)\.([0-9]+)\.([0-9]+)(-[a-z0-9.-]+)?$/);
+  if (!match) return null;
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10),
+    prerelease: match[4]?.substring(1)
+    // Remove leading dash
+  };
+}
+function isVersionCompatible(requested, available) {
+  const req = parseVersion(requested);
+  const avail = parseVersion(available);
+  if (!req || !avail) return false;
+  if (req.major !== avail.major) return false;
+  if (req.major === 0 && req.minor !== avail.minor) return false;
+  if (avail.minor < req.minor) return false;
+  if (avail.minor === req.minor && avail.patch < req.patch) return false;
+  if (req.prerelease && req.prerelease !== avail.prerelease) return false;
+  return true;
+}
+function parseServiceFqn(fqn) {
+  const parts = fqn.split("@");
+  if (parts.length !== 2) return null;
+  return {
+    serviceName: parts[0],
+    version: parts[1]
+  };
+}
 function validateTimestamp(timestamp) {
   if (typeof timestamp !== "number" || !Number.isFinite(timestamp)) {
     return { valid: false, error: "Timestamp must be a finite number" };
@@ -757,12 +787,35 @@ function createApp(storage, config) {
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  app.post("/usernames/claim", async (c) => {
+  app.get("/users/:username", async (c) => {
     try {
+      const username = c.req.param("username");
+      const claimed = await storage.getUsername(username);
+      if (!claimed) {
+        return c.json({
+          username,
+          available: true
+        }, 200);
+      }
+      return c.json({
+        username: claimed.username,
+        available: false,
+        claimedAt: claimed.claimedAt,
+        expiresAt: claimed.expiresAt,
+        publicKey: claimed.publicKey
+      }, 200);
+    } catch (err2) {
+      console.error("Error checking username:", err2);
+      return c.json({ error: "Internal server error" }, 500);
+    }
+  });
+  app.post("/users/:username", async (c) => {
+    try {
+      const username = c.req.param("username");
       const body = await c.req.json();
-      const { username, publicKey, signature, message } = body;
-      if (!username || !publicKey || !signature || !message) {
-        return c.json({ error: "Missing required parameters: username, publicKey, signature, message" }, 400);
+      const { publicKey, signature, message } = body;
+      if (!publicKey || !signature || !message) {
+        return c.json({ error: "Missing required parameters: publicKey, signature, message" }, 400);
       }
       const validation = await validateUsernameClaim(username, publicKey, signature, message);
       if (!validation.valid) {
@@ -779,7 +832,7 @@ function createApp(storage, config) {
           username: claimed.username,
           claimedAt: claimed.claimedAt,
           expiresAt: claimed.expiresAt
-        }, 200);
+        }, 201);
       } catch (err2) {
         if (err2.message?.includes("already claimed")) {
           return c.json({ error: "Username already claimed by different public key" }, 409);
@@ -791,47 +844,73 @@ function createApp(storage, config) {
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  app.get("/usernames/:username", async (c) => {
+  app.get("/users/:username/services/:fqn", async (c) => {
     try {
       const username = c.req.param("username");
-      const claimed = await storage.getUsername(username);
-      if (!claimed) {
+      const serviceFqn = decodeURIComponent(c.req.param("fqn"));
+      const parsed = parseServiceFqn(serviceFqn);
+      if (!parsed) {
+        return c.json({ error: "Invalid service FQN format" }, 400);
+      }
+      const { serviceName, version: requestedVersion } = parsed;
+      const matchingServices = await storage.findServicesByName(username, serviceName);
+      if (matchingServices.length === 0) {
+        return c.json({ error: "Service not found" }, 404);
+      }
+      const compatibleServices = matchingServices.filter((service2) => {
+        const serviceParsed = parseServiceFqn(service2.serviceFqn);
+        if (!serviceParsed) return false;
+        return isVersionCompatible(requestedVersion, serviceParsed.version);
+      });
+      if (compatibleServices.length === 0) {
         return c.json({
-          username,
-          available: true
-        }, 200);
+          error: "No compatible version found",
+          message: `Requested ${serviceFqn}, but no compatible versions available`
+        }, 404);
+      }
+      const service = compatibleServices[0];
+      const uuid = await storage.queryService(username, service.serviceFqn);
+      if (!uuid) {
+        return c.json({ error: "Service index not found" }, 500);
+      }
+      const serviceOffers = await storage.getOffersForService(service.id);
+      if (serviceOffers.length === 0) {
+        return c.json({ error: "No offers found for this service" }, 404);
+      }
+      const availableOffer = serviceOffers.find((offer) => !offer.answererPeerId);
+      if (!availableOffer) {
+        return c.json({
+          error: "No available offers",
+          message: "All offers from this service are currently in use. Please try again later."
+        }, 503);
       }
       return c.json({
-        username: claimed.username,
-        available: false,
-        claimedAt: claimed.claimedAt,
-        expiresAt: claimed.expiresAt,
-        publicKey: claimed.publicKey
+        uuid,
+        serviceId: service.id,
+        username: service.username,
+        serviceFqn: service.serviceFqn,
+        offerId: availableOffer.id,
+        sdp: availableOffer.sdp,
+        isPublic: service.isPublic,
+        metadata: service.metadata ? JSON.parse(service.metadata) : void 0,
+        createdAt: service.createdAt,
+        expiresAt: service.expiresAt
       }, 200);
     } catch (err2) {
-      console.error("Error checking username:", err2);
+      console.error("Error getting service:", err2);
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  app.get("/usernames/:username/services", async (c) => {
+  app.post("/users/:username/services", authMiddleware, async (c) => {
+    let serviceFqn;
+    let createdOffers = [];
     try {
       const username = c.req.param("username");
-      const services = await storage.listServicesForUsername(username);
-      return c.json({
-        username,
-        services
-      }, 200);
-    } catch (err2) {
-      console.error("Error listing services:", err2);
-      return c.json({ error: "Internal server error" }, 500);
-    }
-  });
-  app.post("/services", authMiddleware, async (c) => {
-    try {
       const body = await c.req.json();
-      const { username, serviceFqn, sdp, ttl, isPublic, metadata, signature, message } = body;
-      if (!username || !serviceFqn || !sdp) {
-        return c.json({ error: "Missing required parameters: username, serviceFqn, sdp" }, 400);
+      serviceFqn = body.serviceFqn;
+      const { offers, ttl, isPublic, metadata, signature, message } = body;
+      if (!serviceFqn || !offers || !Array.isArray(offers) || offers.length === 0) {
+        return c.json({ error: "Missing required parameters: serviceFqn, offers (must be non-empty array)" }, 400);
       }
       const fqnValidation = validateServiceFqn(serviceFqn);
       if (!fqnValidation.valid) {
@@ -848,11 +927,20 @@ function createApp(storage, config) {
       if (!signatureValidation.valid) {
         return c.json({ error: "Invalid signature for username" }, 403);
       }
-      if (typeof sdp !== "string" || sdp.length === 0) {
-        return c.json({ error: "Invalid SDP" }, 400);
+      const existingUuid = await storage.queryService(username, serviceFqn);
+      if (existingUuid) {
+        const existingService = await storage.getServiceByUuid(existingUuid);
+        if (existingService) {
+          await storage.deleteService(existingService.id, username);
+        }
       }
-      if (sdp.length > 64 * 1024) {
-        return c.json({ error: "SDP too large (max 64KB)" }, 400);
+      for (const offer of offers) {
+        if (!offer.sdp || typeof offer.sdp !== "string" || offer.sdp.length === 0) {
+          return c.json({ error: "Invalid SDP in offers array" }, 400);
+        }
+        if (offer.sdp.length > 64 * 1024) {
+          return c.json({ error: "SDP too large (max 64KB)" }, 400);
+        }
       }
       const peerId = getAuthenticatedPeerId(c);
       const offerTtl = Math.min(
@@ -860,70 +948,64 @@ function createApp(storage, config) {
         config.offerMaxTtl
       );
       const expiresAt = Date.now() + offerTtl;
-      const offers = await storage.createOffers([{
+      const offerRequests = offers.map((offer) => ({
         peerId,
-        sdp,
+        sdp: offer.sdp,
         expiresAt
-      }]);
-      if (offers.length === 0) {
-        return c.json({ error: "Failed to create offer" }, 500);
-      }
-      const offer = offers[0];
+      }));
       const result = await storage.createService({
         username,
         serviceFqn,
-        offerId: offer.id,
         expiresAt,
         isPublic: isPublic || false,
-        metadata: metadata ? JSON.stringify(metadata) : void 0
+        metadata: metadata ? JSON.stringify(metadata) : void 0,
+        offers: offerRequests
       });
+      createdOffers = result.offers;
       return c.json({
-        serviceId: result.service.id,
         uuid: result.indexUuid,
-        offerId: offer.id,
+        serviceFqn,
+        username,
+        serviceId: result.service.id,
+        offers: result.offers.map((o) => ({
+          offerId: o.id,
+          sdp: o.sdp,
+          createdAt: o.createdAt,
+          expiresAt: o.expiresAt
+        })),
+        isPublic: result.service.isPublic,
+        metadata,
+        createdAt: result.service.createdAt,
         expiresAt: result.service.expiresAt
       }, 201);
     } catch (err2) {
       console.error("Error creating service:", err2);
-      return c.json({ error: "Internal server error" }, 500);
+      console.error("Error details:", {
+        message: err2.message,
+        stack: err2.stack,
+        username: c.req.param("username"),
+        serviceFqn,
+        offerIds: createdOffers.map((o) => o.id)
+      });
+      return c.json({
+        error: "Internal server error",
+        details: err2.message
+      }, 500);
     }
   });
-  app.get("/services/:uuid", async (c) => {
+  app.delete("/users/:username/services/:fqn", authMiddleware, async (c) => {
     try {
-      const uuid = c.req.param("uuid");
+      const username = c.req.param("username");
+      const serviceFqn = decodeURIComponent(c.req.param("fqn"));
+      const uuid = await storage.queryService(username, serviceFqn);
+      if (!uuid) {
+        return c.json({ error: "Service not found" }, 404);
+      }
       const service = await storage.getServiceByUuid(uuid);
       if (!service) {
         return c.json({ error: "Service not found" }, 404);
       }
-      const offer = await storage.getOfferById(service.offerId);
-      if (!offer) {
-        return c.json({ error: "Associated offer not found" }, 404);
-      }
-      return c.json({
-        serviceId: service.id,
-        username: service.username,
-        serviceFqn: service.serviceFqn,
-        offerId: service.offerId,
-        sdp: offer.sdp,
-        isPublic: service.isPublic,
-        metadata: service.metadata ? JSON.parse(service.metadata) : void 0,
-        createdAt: service.createdAt,
-        expiresAt: service.expiresAt
-      }, 200);
-    } catch (err2) {
-      console.error("Error getting service:", err2);
-      return c.json({ error: "Internal server error" }, 500);
-    }
-  });
-  app.delete("/services/:serviceId", authMiddleware, async (c) => {
-    try {
-      const serviceId = c.req.param("serviceId");
-      const body = await c.req.json();
-      const { username } = body;
-      if (!username) {
-        return c.json({ error: "Missing required parameter: username" }, 400);
-      }
-      const deleted = await storage.deleteService(serviceId, username);
+      const deleted = await storage.deleteService(service.id, username);
       if (!deleted) {
         return c.json({ error: "Service not found or not owned by this username" }, 404);
       }
@@ -933,112 +1015,46 @@ function createApp(storage, config) {
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  app.post("/index/:username/query", async (c) => {
+  app.get("/services/:uuid", async (c) => {
     try {
-      const username = c.req.param("username");
-      const body = await c.req.json();
-      const { serviceFqn } = body;
-      if (!serviceFqn) {
-        return c.json({ error: "Missing required parameter: serviceFqn" }, 400);
-      }
-      const uuid = await storage.queryService(username, serviceFqn);
-      if (!uuid) {
+      const uuid = c.req.param("uuid");
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
         return c.json({ error: "Service not found" }, 404);
       }
-      return c.json({
-        uuid,
-        allowed: true
-      }, 200);
-    } catch (err2) {
-      console.error("Error querying service:", err2);
-      return c.json({ error: "Internal server error" }, 500);
-    }
-  });
-  app.post("/offers", authMiddleware, async (c) => {
-    try {
-      const body = await c.req.json();
-      const { offers } = body;
-      if (!Array.isArray(offers) || offers.length === 0) {
-        return c.json({ error: "Missing or invalid required parameter: offers (must be non-empty array)" }, 400);
+      const serviceOffers = await storage.getOffersForService(service.id);
+      if (serviceOffers.length === 0) {
+        return c.json({ error: "No offers found for this service" }, 404);
       }
-      if (offers.length > config.maxOffersPerRequest) {
-        return c.json({ error: `Too many offers (max ${config.maxOffersPerRequest})` }, 400);
+      const availableOffer = serviceOffers.find((offer) => !offer.answererPeerId);
+      if (!availableOffer) {
+        return c.json({
+          error: "No available offers",
+          message: "All offers from this service are currently in use. Please try again later."
+        }, 503);
       }
-      const peerId = getAuthenticatedPeerId(c);
-      const validated = offers.map((offer) => {
-        const { sdp, ttl, secret } = offer;
-        if (typeof sdp !== "string" || sdp.length === 0) {
-          throw new Error("Invalid SDP in offer");
-        }
-        if (sdp.length > 64 * 1024) {
-          throw new Error("SDP too large (max 64KB)");
-        }
-        const offerTtl = Math.min(
-          Math.max(ttl || config.offerDefaultTtl, config.offerMinTtl),
-          config.offerMaxTtl
-        );
-        return {
-          peerId,
-          sdp,
-          expiresAt: Date.now() + offerTtl,
-          secret: secret ? String(secret).substring(0, 128) : void 0
-        };
-      });
-      const created = await storage.createOffers(validated);
       return c.json({
-        offers: created.map((offer) => ({
-          id: offer.id,
-          peerId: offer.peerId,
-          expiresAt: offer.expiresAt,
-          createdAt: offer.createdAt,
-          hasSecret: !!offer.secret
-        }))
-      }, 201);
-    } catch (err2) {
-      console.error("Error creating offers:", err2);
-      return c.json({ error: err2.message || "Internal server error" }, 500);
-    }
-  });
-  app.get("/offers/mine", authMiddleware, async (c) => {
-    try {
-      const peerId = getAuthenticatedPeerId(c);
-      const offers = await storage.getOffersByPeerId(peerId);
-      return c.json({
-        offers: offers.map((offer) => ({
-          id: offer.id,
-          sdp: offer.sdp,
-          createdAt: offer.createdAt,
-          expiresAt: offer.expiresAt,
-          lastSeen: offer.lastSeen,
-          hasSecret: !!offer.secret,
-          answererPeerId: offer.answererPeerId,
-          answered: !!offer.answererPeerId
-        }))
+        uuid,
+        serviceId: service.id,
+        username: service.username,
+        serviceFqn: service.serviceFqn,
+        offerId: availableOffer.id,
+        sdp: availableOffer.sdp,
+        isPublic: service.isPublic,
+        metadata: service.metadata ? JSON.parse(service.metadata) : void 0,
+        createdAt: service.createdAt,
+        expiresAt: service.expiresAt
       }, 200);
     } catch (err2) {
-      console.error("Error getting offers:", err2);
-      return c.json({ error: "Internal server error" }, 500);
-    }
-  });
-  app.delete("/offers/:offerId", authMiddleware, async (c) => {
-    try {
-      const offerId = c.req.param("offerId");
-      const peerId = getAuthenticatedPeerId(c);
-      const deleted = await storage.deleteOffer(offerId, peerId);
-      if (!deleted) {
-        return c.json({ error: "Offer not found or not owned by this peer" }, 404);
-      }
-      return c.json({ success: true }, 200);
-    } catch (err2) {
-      console.error("Error deleting offer:", err2);
+      console.error("Error getting service:", err2);
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  app.post("/offers/:offerId/answer", authMiddleware, async (c) => {
+  app.post("/services/:uuid/answer", authMiddleware, async (c) => {
     try {
-      const offerId = c.req.param("offerId");
+      const uuid = c.req.param("uuid");
       const body = await c.req.json();
-      const { sdp, secret } = body;
+      const { sdp } = body;
       if (!sdp) {
         return c.json({ error: "Missing required parameter: sdp" }, 400);
       }
@@ -1048,75 +1064,126 @@ function createApp(storage, config) {
       if (sdp.length > 64 * 1024) {
         return c.json({ error: "SDP too large (max 64KB)" }, 400);
       }
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: "Service not found" }, 404);
+      }
+      const serviceOffers = await storage.getOffersForService(service.id);
+      const availableOffer = serviceOffers.find((offer) => !offer.answererPeerId);
+      if (!availableOffer) {
+        return c.json({ error: "No available offers" }, 503);
+      }
       const answererPeerId = getAuthenticatedPeerId(c);
-      const result = await storage.answerOffer(offerId, answererPeerId, sdp, secret);
+      const result = await storage.answerOffer(availableOffer.id, answererPeerId, sdp);
       if (!result.success) {
         return c.json({ error: result.error }, 400);
       }
-      return c.json({ success: true }, 200);
+      return c.json({
+        success: true,
+        offerId: availableOffer.id
+      }, 200);
     } catch (err2) {
-      console.error("Error answering offer:", err2);
+      console.error("Error answering service:", err2);
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  app.get("/offers/answers", authMiddleware, async (c) => {
+  app.get("/services/:uuid/answer", authMiddleware, async (c) => {
     try {
+      const uuid = c.req.param("uuid");
       const peerId = getAuthenticatedPeerId(c);
-      const offers = await storage.getAnsweredOffers(peerId);
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: "Service not found" }, 404);
+      }
+      const serviceOffers = await storage.getOffersForService(service.id);
+      const myOffer = serviceOffers.find((offer) => offer.peerId === peerId && offer.answererPeerId);
+      if (!myOffer || !myOffer.answerSdp) {
+        return c.json({ error: "Offer not yet answered" }, 404);
+      }
       return c.json({
-        answers: offers.map((offer) => ({
-          offerId: offer.id,
-          answererPeerId: offer.answererPeerId,
-          answerSdp: offer.answerSdp,
-          answeredAt: offer.answeredAt
-        }))
+        offerId: myOffer.id,
+        answererId: myOffer.answererPeerId,
+        sdp: myOffer.answerSdp,
+        answeredAt: myOffer.answeredAt
       }, 200);
     } catch (err2) {
-      console.error("Error getting answers:", err2);
+      console.error("Error getting service answer:", err2);
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  app.post("/offers/:offerId/ice-candidates", authMiddleware, async (c) => {
+  app.post("/services/:uuid/ice-candidates", authMiddleware, async (c) => {
     try {
-      const offerId = c.req.param("offerId");
+      const uuid = c.req.param("uuid");
       const body = await c.req.json();
-      const { candidates } = body;
+      const { candidates, offerId } = body;
       if (!Array.isArray(candidates) || candidates.length === 0) {
         return c.json({ error: "Missing or invalid required parameter: candidates" }, 400);
       }
       const peerId = getAuthenticatedPeerId(c);
-      const offer = await storage.getOfferById(offerId);
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: "Service not found" }, 404);
+      }
+      let targetOfferId = offerId;
+      if (!targetOfferId) {
+        const serviceOffers = await storage.getOffersForService(service.id);
+        const myOffer = serviceOffers.find(
+          (offer2) => offer2.peerId === peerId || offer2.answererPeerId === peerId
+        );
+        if (!myOffer) {
+          return c.json({ error: "No offer found for this peer" }, 404);
+        }
+        targetOfferId = myOffer.id;
+      }
+      const offer = await storage.getOfferById(targetOfferId);
       if (!offer) {
         return c.json({ error: "Offer not found" }, 404);
       }
       const role = offer.peerId === peerId ? "offerer" : "answerer";
-      const count = await storage.addIceCandidates(offerId, peerId, role, candidates);
-      return c.json({ count }, 200);
+      const count = await storage.addIceCandidates(targetOfferId, peerId, role, candidates);
+      return c.json({ count, offerId: targetOfferId }, 200);
     } catch (err2) {
-      console.error("Error adding ICE candidates:", err2);
+      console.error("Error adding ICE candidates to service:", err2);
       return c.json({ error: "Internal server error" }, 500);
     }
   });
-  app.get("/offers/:offerId/ice-candidates", authMiddleware, async (c) => {
+  app.get("/services/:uuid/ice-candidates", authMiddleware, async (c) => {
     try {
-      const offerId = c.req.param("offerId");
+      const uuid = c.req.param("uuid");
       const since = c.req.query("since");
+      const offerId = c.req.query("offerId");
       const peerId = getAuthenticatedPeerId(c);
-      const offer = await storage.getOfferById(offerId);
+      const service = await storage.getServiceByUuid(uuid);
+      if (!service) {
+        return c.json({ error: "Service not found" }, 404);
+      }
+      let targetOfferId = offerId;
+      if (!targetOfferId) {
+        const serviceOffers = await storage.getOffersForService(service.id);
+        const myOffer = serviceOffers.find(
+          (offer2) => offer2.peerId === peerId || offer2.answererPeerId === peerId
+        );
+        if (!myOffer) {
+          return c.json({ error: "No offer found for this peer" }, 404);
+        }
+        targetOfferId = myOffer.id;
+      }
+      const offer = await storage.getOfferById(targetOfferId);
       if (!offer) {
         return c.json({ error: "Offer not found" }, 404);
       }
       const targetRole = offer.peerId === peerId ? "answerer" : "offerer";
       const sinceTimestamp = since ? parseInt(since, 10) : void 0;
-      const candidates = await storage.getIceCandidates(offerId, targetRole, sinceTimestamp);
+      const candidates = await storage.getIceCandidates(targetOfferId, targetRole, sinceTimestamp);
       return c.json({
         candidates: candidates.map((c2) => ({
           candidate: c2.candidate,
           createdAt: c2.createdAt
-        }))
+        })),
+        offerId: targetOfferId
       }, 200);
     } catch (err2) {
-      console.error("Error getting ICE candidates:", err2);
+      console.error("Error getting ICE candidates for service:", err2);
       return c.json({ error: "Internal server error" }, 500);
     }
   });
@@ -1143,8 +1210,7 @@ function loadConfig() {
     offerMaxTtl: parseInt(process.env.OFFER_MAX_TTL || "86400000", 10),
     offerMinTtl: parseInt(process.env.OFFER_MIN_TTL || "60000", 10),
     cleanupInterval: parseInt(process.env.CLEANUP_INTERVAL || "60000", 10),
-    maxOffersPerRequest: parseInt(process.env.MAX_OFFERS_PER_REQUEST || "100", 10),
-    maxTopicsPerOffer: parseInt(process.env.MAX_TOPICS_PER_OFFER || "50", 10)
+    maxOffersPerRequest: parseInt(process.env.MAX_OFFERS_PER_REQUEST || "100", 10)
   };
 }
 
@@ -1153,11 +1219,9 @@ var import_better_sqlite3 = __toESM(require("better-sqlite3"));
 var import_node_crypto = require("node:crypto");
 
 // src/storage/hash-id.ts
-async function generateOfferHash(sdp, topics) {
+async function generateOfferHash(sdp) {
   const sanitizedOffer = {
-    sdp,
-    topics: [...topics].sort()
-    // Sort topics for consistency
+    sdp
   };
   const jsonString = JSON.stringify(sanitizedOffer);
   const encoder = new TextEncoder();
@@ -1184,10 +1248,11 @@ var SQLiteStorage = class {
    */
   initializeDatabase() {
     this.db.exec(`
-      -- Offers table (no topics)
+      -- WebRTC signaling offers
       CREATE TABLE IF NOT EXISTS offers (
         id TEXT PRIMARY KEY,
         peer_id TEXT NOT NULL,
+        service_id TEXT,
         sdp TEXT NOT NULL,
         created_at INTEGER NOT NULL,
         expires_at INTEGER NOT NULL,
@@ -1195,10 +1260,12 @@ var SQLiteStorage = class {
         secret TEXT,
         answerer_peer_id TEXT,
         answer_sdp TEXT,
-        answered_at INTEGER
+        answered_at INTEGER,
+        FOREIGN KEY (service_id) REFERENCES services(id) ON DELETE CASCADE
       );
 
       CREATE INDEX IF NOT EXISTS idx_offers_peer ON offers(peer_id);
+      CREATE INDEX IF NOT EXISTS idx_offers_service ON offers(service_id);
       CREATE INDEX IF NOT EXISTS idx_offers_expires ON offers(expires_at);
       CREATE INDEX IF NOT EXISTS idx_offers_last_seen ON offers(last_seen);
       CREATE INDEX IF NOT EXISTS idx_offers_answerer ON offers(answerer_peer_id);
@@ -1232,25 +1299,22 @@ var SQLiteStorage = class {
       CREATE INDEX IF NOT EXISTS idx_usernames_expires ON usernames(expires_at);
       CREATE INDEX IF NOT EXISTS idx_usernames_public_key ON usernames(public_key);
 
-      -- Services table
+      -- Services table (one service can have multiple offers)
       CREATE TABLE IF NOT EXISTS services (
         id TEXT PRIMARY KEY,
         username TEXT NOT NULL,
         service_fqn TEXT NOT NULL,
-        offer_id TEXT NOT NULL,
         created_at INTEGER NOT NULL,
         expires_at INTEGER NOT NULL,
         is_public INTEGER NOT NULL DEFAULT 0,
         metadata TEXT,
         FOREIGN KEY (username) REFERENCES usernames(username) ON DELETE CASCADE,
-        FOREIGN KEY (offer_id) REFERENCES offers(id) ON DELETE CASCADE,
         UNIQUE(username, service_fqn)
       );
 
       CREATE INDEX IF NOT EXISTS idx_services_username ON services(username);
       CREATE INDEX IF NOT EXISTS idx_services_fqn ON services(service_fqn);
       CREATE INDEX IF NOT EXISTS idx_services_expires ON services(expires_at);
-      CREATE INDEX IF NOT EXISTS idx_services_offer ON services(offer_id);
 
       -- Service index table (privacy layer)
       CREATE TABLE IF NOT EXISTS service_index (
@@ -1274,19 +1338,20 @@ var SQLiteStorage = class {
     const offersWithIds = await Promise.all(
       offers.map(async (offer) => ({
         ...offer,
-        id: offer.id || await generateOfferHash(offer.sdp, [])
+        id: offer.id || await generateOfferHash(offer.sdp)
       }))
     );
     const transaction = this.db.transaction((offersWithIds2) => {
       const offerStmt = this.db.prepare(`
-        INSERT INTO offers (id, peer_id, sdp, created_at, expires_at, last_seen, secret)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
+        INSERT INTO offers (id, peer_id, service_id, sdp, created_at, expires_at, last_seen, secret)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
       `);
       for (const offer of offersWithIds2) {
         const now = Date.now();
         offerStmt.run(
           offer.id,
           offer.peerId,
+          offer.serviceId || null,
           offer.sdp,
           now,
           offer.expiresAt,
@@ -1296,6 +1361,7 @@ var SQLiteStorage = class {
         created.push({
           id: offer.id,
           peerId: offer.peerId,
+          serviceId: offer.serviceId || void 0,
           sdp: offer.sdp,
           createdAt: now,
           expiresAt: offer.expiresAt,
@@ -1498,16 +1564,20 @@ var SQLiteStorage = class {
     const serviceId = (0, import_node_crypto.randomUUID)();
     const indexUuid = (0, import_node_crypto.randomUUID)();
     const now = Date.now();
+    const offerRequests = request.offers.map((offer) => ({
+      ...offer,
+      serviceId
+    }));
+    const offers = await this.createOffers(offerRequests);
     const transaction = this.db.transaction(() => {
       const serviceStmt = this.db.prepare(`
-        INSERT INTO services (id, username, service_fqn, offer_id, created_at, expires_at, is_public, metadata)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        INSERT INTO services (id, username, service_fqn, created_at, expires_at, is_public, metadata)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
       `);
       serviceStmt.run(
         serviceId,
         request.username,
         request.serviceFqn,
-        request.offerId,
         now,
         request.expiresAt,
         request.isPublic ? 1 : 0,
@@ -1533,15 +1603,23 @@ var SQLiteStorage = class {
         id: serviceId,
         username: request.username,
         serviceFqn: request.serviceFqn,
-        offerId: request.offerId,
         createdAt: now,
         expiresAt: request.expiresAt,
         isPublic: request.isPublic || false,
         metadata: request.metadata
       },
-      indexUuid
+      indexUuid,
+      offers
     };
   }
+  async batchCreateServices(requests) {
+    const results = [];
+    for (const request of requests) {
+      const result = await this.createService(request);
+      results.push(result);
+    }
+    return results;
+  }
   async getServiceById(serviceId) {
     const stmt = this.db.prepare(`
       SELECT * FROM services
@@ -1590,6 +1668,15 @@ var SQLiteStorage = class {
     const row = stmt.get(username, serviceFqn, Date.now());
     return row ? row.uuid : null;
   }
+  async findServicesByName(username, serviceName) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM services
+      WHERE username = ? AND service_fqn LIKE ? AND expires_at > ?
+      ORDER BY created_at DESC
+    `);
+    const rows = stmt.all(username, `${serviceName}@%`, Date.now());
+    return rows.map((row) => this.rowToService(row));
+  }
   async deleteService(serviceId, username) {
     const stmt = this.db.prepare(`
       DELETE FROM services
@@ -1614,6 +1701,7 @@ var SQLiteStorage = class {
     return {
       id: row.id,
       peerId: row.peer_id,
+      serviceId: row.service_id || void 0,
       sdp: row.sdp,
       createdAt: row.created_at,
       expiresAt: row.expires_at,
@@ -1632,13 +1720,24 @@ var SQLiteStorage = class {
       id: row.id,
       username: row.username,
       serviceFqn: row.service_fqn,
-      offerId: row.offer_id,
       createdAt: row.created_at,
       expiresAt: row.expires_at,
       isPublic: row.is_public === 1,
       metadata: row.metadata || void 0
     };
   }
+  /**
+   * Get all offers for a service
+   */
+  async getOffersForService(serviceId) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM offers
+      WHERE service_id = ? AND expires_at > ?
+      ORDER BY created_at ASC
+    `);
+    const rows = stmt.all(serviceId, Date.now());
+    return rows.map((row) => this.rowToOffer(row));
+  }
 };
 
 // src/index.ts
@@ -1654,7 +1753,6 @@ async function main() {
     offerMinTtl: `${config.offerMinTtl}ms`,
     cleanupInterval: `${config.cleanupInterval}ms`,
     maxOffersPerRequest: config.maxOffersPerRequest,
-    maxTopicsPerOffer: config.maxTopicsPerOffer,
     corsOrigins: config.corsOrigins,
     version: config.version
   });