@creatornader/agent-bridge 0.2.0 → 0.3.1

package/dist/{chunk-4KAOBC5X.js → chunk-SPSMZOCJ.js}

@@ -2,21 +2,32 @@
 import {
   readClientConfigFile,
   resolveClientConfig
-} from "./chunk-KVR4JBRF.js";
+} from "./chunk-2EVLG3YA.js";
 import {
   createStore
-} from "./chunk-JTC5YURG.js";
+} from "./chunk-UAHMP6GC.js";
 import {
   legacyContextMetadata,
   legacyNumericMessageId
-} from "./chunk-AXL2I7FH.js";
+} from "./chunk-CEXBMOI5.js";
 import {
   BridgeService
-} from "./chunk-CKSKUBDQ.js";
+} from "./chunk-4VB44KJU.js";
 import {
+  ContractValidationError,
+  availableOperations,
+  capabilityDocument,
+  parseResponse,
+  validateRequest
+} from "./chunk-GADH244D.js";
+import {
+  BridgePrincipalMismatchError,
   BridgeValidationError,
-  normalizeReceiptId
-} from "./chunk-BV6W4AJK.js";
+  normalizeReceiptId,
+  uuidv7,
+  validateMessageDraft,
+  validateProject
+} from "./chunk-BZLMF5O5.js";
 
 // src/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -28,11 +39,9 @@ import {
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
 import { homedir } from "os";
-import { createRequire } from "module";
 import { join } from "path";
 
 // src/message-envelope.ts
-import { randomUUID } from "crypto";
 var MESSAGE_ENVELOPE_SCHEMA = "agent-bridge.message-envelope.v1";
 var RECORD_HASH_RE = /^sha256:[a-f0-9]{64}$/i;
 function isRecord(value) {
@@ -77,7 +86,7 @@ function buildMessageEnvelope(args, receiptId) {
   const source = normalizeString(args?.source) ?? "unknown";
   const category = normalizeString(args?.category);
   const kind = normalizeString(args?.kind) ?? category ?? "operational";
-  const messageId = normalizeString(args?.message_id) ?? randomUUID();
+  const messageId = normalizeString(args?.message_id) ?? uuidv7();
   const envelope = {
     schema: MESSAGE_ENVELOPE_SCHEMA,
     message_id: messageId,
@@ -168,7 +177,7 @@ function resolvePostSource(requestedSource, configuredAgent) {
 }
 
 // src/server.ts
-var packageVersion = createRequire(import.meta.url)("../package.json").version;
+var MCP_IMPLEMENTATION_VERSION = "2.0.0";
 function normalizedConfigValue(value) {
   const trimmed = value?.trim();
   return trimmed || void 0;
@@ -244,9 +253,14 @@ function buildSupabaseRequest(config) {
 }
 function createAgentBridgeServer(config) {
   const supabaseRequest = config.supabaseUrl && config.supabaseKey ? buildSupabaseRequest(config) : void 0;
-  const principal = config.agent ? { workspace: config.workspace ?? "default", agent: config.agent, instance: config.instance } : void 0;
+  const provider = config.provider ?? (config.gatewayToken ? "gateway" : config.supabaseUrl ? "legacy-supabase" : "local");
+  const principal = config.agent ? {
+    workspace: provider === "legacy-supabase" ? "*" : config.workspace ?? "default",
+    agent: config.agent,
+    instance: config.instance
+  } : void 0;
   const clientConfig = principal ? {
-    provider: config.provider ?? (config.gatewayToken ? "gateway" : config.supabaseUrl ? "legacy-supabase" : "local"),
+    provider,
     principal,
     url: config.gatewayUrl ?? config.supabaseUrl,
     credential: config.gatewayToken ?? config.supabaseKey,
@@ -257,15 +271,12 @@ function createAgentBridgeServer(config) {
   } : void 0;
   const store = clientConfig ? createStore(clientConfig) : void 0;
   const service = store ? new BridgeService(store) : void 0;
-  const deliveryToolsAvailable = Boolean(
-    service && clientConfig?.provider !== "legacy-supabase"
-  );
   const server = new Server(
-    { name: "agent-bridge", version: packageVersion },
+    { name: "agent-bridge", version: MCP_IMPLEMENTATION_VERSION },
     { capabilities: { tools: {} } }
   );
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const legacyTools = [
       {
         name: "post_context",
         description: "Post a shared context entry visible to all agents. Categories: operational, config-change, goal-update, flag, bridge-meta (for suggesting improvements to the Agent Bridge itself).",
@@ -290,7 +301,7 @@ function createAgentBridgeServer(config) {
             },
             project: {
               type: "string",
-              description: "Scope to a project (e.g. project-a, project-b). Omit for cross-project."
+              description: "Optional immutable message label. Omit for an unlabeled message."
             },
             metadata: {
               type: "object",
@@ -377,7 +388,7 @@ function createAgentBridgeServer(config) {
             },
             project: {
               type: "string",
-              description: "Filter by project scope"
+              description: "Filter by an exact project label"
             },
             unacked_by: {
               type: "string",
@@ -402,6 +413,19 @@ function createAgentBridgeServer(config) {
               description: "Filter by metadata.message_envelope.kind."
             }
           }
+        },
+        outputSchema: {
+          type: "object",
+          properties: {
+            entries: { type: "array", items: { type: "object", additionalProperties: true } },
+            source: { type: "string", enum: ["remote", "cache"] },
+            stale: { type: "boolean" },
+            degraded: { type: "boolean" },
+            acknowledgements: { type: "string", enum: ["authoritative", "unknown"] },
+            lastSyncedAt: { type: ["string", "null"] }
+          },
+          required: ["entries"],
+          additionalProperties: false
         }
       },
       {
@@ -422,99 +446,31 @@ function createAgentBridgeServer(config) {
           },
           required: ["ids"]
         }
-      },
-      ...service ? [
-        {
-          name: "send",
-          description: "Create an immutable Agent Bridge v2 message.",
-          inputSchema: {
-            type: "object",
-            properties: {
-              source: { type: "string", description: "Optional identity assertion; must match AGENT_BRIDGE_AGENT." },
-              type: { type: "string" },
-              content: { type: "string" },
-              contentType: { type: "string" },
-              data: {},
-              targets: { type: "array", items: { type: "string" } },
-              threadId: { type: "string" },
-              replyToId: { type: "string" },
-              correlationId: { type: "string" },
-              causationId: { type: "string" },
-              priority: { type: "string", enum: ["info", "high", "urgent"] },
-              expiresAt: { type: "string" },
-              idempotencyKey: { type: "string" },
-              atribReceiptId: { type: "string" },
-              informedBy: { type: "array", items: { type: "string" } },
-              metadata: {}
-            },
-            required: ["type", "content"],
-            additionalProperties: false
-          },
-          outputSchema: { type: "object", properties: { created: { type: "boolean" }, message: { type: "object", additionalProperties: true } }, required: ["created", "message"] }
-        },
-        {
-          name: "history",
-          description: "Read visible Agent Bridge v2 messages after an opaque cursor.",
-          inputSchema: { type: "object", properties: {
-            cursor: { type: "string" },
-            limit: { type: "number", minimum: 1, maximum: 200 },
-            types: { type: "array", items: { type: "string" } },
-            includeExpired: { type: "boolean" },
-            source: { type: "string" },
-            since: { type: "string" },
-            unacknowledgedBy: { type: "string" },
-            threadId: { type: "string" },
-            latest: { type: "boolean" }
-          }, additionalProperties: false },
-          outputSchema: { type: "object", properties: { messages: { type: "array", items: { type: "object", additionalProperties: true } }, cursor: { type: "string" } }, required: ["messages"] }
-        }
-      ] : [],
-      ...deliveryToolsAvailable ? [
-        {
-          name: "claim",
-          description: "Atomically claim the next targeted delivery.",
-          inputSchema: { type: "object", properties: { leaseMs: { type: "number" }, maxAttempts: { type: "number" } }, additionalProperties: false },
-          outputSchema: { type: "object", additionalProperties: true }
-        },
-        ...["extend", "acknowledge", "negative_acknowledge"].map((name) => ({
-          name,
-          description: `Agent Bridge v2 ${name.replace(/_/g, " ")} delivery operation.`,
-          inputSchema: {
-            type: "object",
-            properties: {
-              deliveryId: { type: "string" },
-              leaseToken: { type: "string" },
-              ...name === "extend" ? { leaseMs: { type: "number" } } : {},
-              ...name === "negative_acknowledge" ? { error: { type: "string" }, dead: { type: "boolean" }, retryPolicy: { type: "object", additionalProperties: true } } : {}
-            },
-            required: ["deliveryId", "leaseToken"],
-            additionalProperties: false
-          },
-          outputSchema: { type: "object", additionalProperties: true }
-        })),
-        {
-          name: "heartbeat",
-          description: "Publish a leased runtime presence record and capabilities.",
-          inputSchema: { type: "object", properties: {
-            leaseMs: { type: "number", minimum: 1e3, maximum: 9e5 },
-            runtimeType: { type: "string" },
-            capabilities: { type: "array", items: { type: "string" } }
-          }, additionalProperties: false },
-          outputSchema: { type: "object", additionalProperties: true }
-        },
-        {
-          name: "presence",
-          description: "List active agent runtime instances in this workspace.",
-          inputSchema: { type: "object", properties: {}, additionalProperties: false },
-          outputSchema: { type: "object", properties: { agents: { type: "array", items: { type: "object", additionalProperties: true } } }, required: ["agents"] }
-        }
-      ] : []
-    ]
-  }));
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      }
+    ];
+    const canonical = service ? availableOperations({ surface: "mcp", provider }).map((operation) => ({
+      name: operation.mcp.name,
+      description: operation.summary,
+      inputSchema: operation.request,
+      outputSchema: operation.response
+    })) : [];
+    return { tools: [...legacyTools, ...canonical] };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
     const { name, arguments: args } = request.params;
+    const canonicalResult = (operationId, value) => {
+      const parsed = parseResponse(operationId, value);
+      return {
+        content: [{ type: "text", text: JSON.stringify(parsed) }],
+        ...parsed !== null && typeof parsed === "object" ? { structuredContent: parsed } : {}
+      };
+    };
     try {
       switch (name) {
+        case "capabilities": {
+          validateRequest("capabilities", args ?? {});
+          return canonicalResult("capabilities", capabilityDocument({ surface: "mcp", provider }));
+        }
         case "post_context": {
           let source;
           try {
@@ -530,40 +486,40 @@ function createAgentBridgeServer(config) {
               e instanceof Error ? e.message : "source identity mismatch"
             );
           }
-          const postArgs = { ...args ?? {}, source };
+          const project = validateProject(args?.project);
+          const postArgs = { ...args ?? {}, source, project };
           const receiptId = normalizeReceiptId(args?.atrib_receipt_id);
           const envelope = buildMessageEnvelope(postArgs, receiptId);
+          const draft = validateMessageDraft({
+            id: String(envelope.message_id),
+            project,
+            type: String(args?.kind ?? args?.category),
+            content: String(args?.content ?? ""),
+            contentType: String(args?.payload_mime ?? "text/plain"),
+            data: args?.payload,
+            targets: Array.isArray(args?.target_agents) ? args.target_agents.map(String) : [],
+            threadId: args?.thread_id,
+            replyToId: args?.reply_to_id,
+            priority: args?.priority ?? "info",
+            expiresAt: args?.expires_at,
+            atribReceiptId: receiptId,
+            informedBy: Array.isArray(args?.informed_by) ? args.informed_by.map(String) : [],
+            metadata: mergeEnvelopeMetadata(args?.metadata, envelope)
+          });
           const body = {
             source,
-            category: args?.category,
-            content: args?.content,
-            priority: args?.priority || "info",
-            project: args?.project || null,
-            metadata: mergeEnvelopeMetadata(args?.metadata, envelope)
+            category: draft.type,
+            content: draft.content,
+            priority: draft.priority,
+            project: draft.project ?? null,
+            metadata: draft.metadata
           };
           if (receiptId) {
             body.atrib_receipt_id = receiptId;
           }
           if (!supabaseRequest) {
             if (!service || !principal) throw new McpError(ErrorCode.InternalError, "bridge provider is not configured");
-            if (args?.project && String(args.project) !== principal.workspace) {
-              throw new McpError(ErrorCode.InvalidParams, "project must match AGENT_BRIDGE_WORKSPACE");
-            }
-            const result = await service.publish(principal, {
-              id: String(envelope.message_id),
-              type: String(args?.kind ?? args?.category),
-              content: String(args?.content ?? ""),
-              contentType: String(args?.payload_mime ?? "text/plain"),
-              data: args?.payload,
-              targets: Array.isArray(args?.target_agents) ? args.target_agents.map(String) : [],
-              threadId: args?.thread_id,
-              replyToId: args?.reply_to_id,
-              priority: args?.priority ?? "info",
-              expiresAt: args?.expires_at,
-              atribReceiptId: receiptId,
-              informedBy: Array.isArray(args?.informed_by) ? args.informed_by.map(String) : [],
-              metadata: body.metadata
-            });
+            const result = await service.publish(principal, draft);
             return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result };
           }
           if (!supabaseRequest) throw new McpError(ErrorCode.InternalError, "bridge provider is not configured");
@@ -576,16 +532,18 @@ function createAgentBridgeServer(config) {
           };
         }
         case "get_context": {
+          const project = validateProject(args?.project);
+          const contextArgs = { ...args ?? {}, project };
           const rawLimit = args?.limit;
           if (rawLimit !== void 0 && (typeof rawLimit !== "number" || !Number.isSafeInteger(rawLimit) || rawLimit < 1 || rawLimit > 200)) {
             throw new McpError(ErrorCode.InvalidParams, "limit must be between 1 and 200");
           }
           const requestedLimit = rawLimit ?? 20;
+          if (args?.unacked_by !== void 0 && String(args.unacked_by) !== config.agent) {
+            throw new McpError(ErrorCode.InvalidParams, "unacked_by must equal the configured principal");
+          }
           if (service && principal) {
             if (!service || !principal) throw new McpError(ErrorCode.InternalError, "bridge provider is not configured");
-            if (args?.project && String(args.project) !== principal.workspace) {
-              return { content: [{ type: "text", text: "[]" }], structuredContent: { entries: [] } };
-            }
             if (args?.target_agent && String(args.target_agent) !== principal.agent) {
               return { content: [{ type: "text", text: "[]" }], structuredContent: { entries: [] } };
             }
@@ -593,8 +551,9 @@ function createAgentBridgeServer(config) {
               limit: requestedLimit,
               types: args?.kind ? [String(args.kind)] : args?.category ? [String(args.category)] : void 0,
               source: args?.source ? String(args.source) : void 0,
+              project,
               since: args?.since ? String(args.since) : void 0,
-              unacknowledgedBy: args?.unacked_by ? String(args.unacked_by) : config.agent,
+              receiptState: "unread",
               threadId: args?.thread_id ? String(args.thread_id) : void 0,
               latest: true
             });
@@ -604,7 +563,7 @@ function createAgentBridgeServer(config) {
               category: message.type,
               content: message.content,
               priority: message.priority,
-              project: message.workspace,
+              project: message.project ?? null,
               metadata: legacyContextMetadata(message),
               atrib_receipt_id: message.atribReceiptId ?? null,
               created_at: message.createdAt
@@ -613,10 +572,18 @@ function createAgentBridgeServer(config) {
             const cacheMetadata = cachedResult.source ? {
               source: cachedResult.source,
               stale: Boolean(cachedResult.stale),
+              degraded: Boolean(cachedResult.degraded),
+              acknowledgements: cachedResult.acknowledgements ?? "authoritative",
               lastSyncedAt: cachedResult.lastSyncedAt ?? null
             } : {};
             return {
-              content: [{ type: "text", text: JSON.stringify(entries, null, 2) }],
+              content: [
+                { type: "text", text: JSON.stringify(entries, null, 2) },
+                ...cachedResult.stale || cachedResult.degraded ? [{
+                  type: "text",
+                  text: `WARNING: cached Agent Bridge context is ${cachedResult.stale ? "stale" : "degraded"}; acknowledgement authority is ${cachedResult.acknowledgements ?? "unknown"}.`
+                }] : []
+              ],
               structuredContent: { entries, ...cacheMetadata }
             };
           }
@@ -638,8 +605,8 @@ function createAgentBridgeServer(config) {
             params.push(
               `category=eq.${encodeURIComponent(String(args.category))}`
             );
-          if (args?.project)
-            params.push(`project=eq.${encodeURIComponent(String(args.project))}`);
+          if (project)
+            params.push(`project=eq.${encodeURIComponent(project)}`);
           const unackedBy = args?.unacked_by ?? config.agent;
           if (unackedBy)
             params.push(
@@ -649,9 +616,10 @@ function createAgentBridgeServer(config) {
           const data = await supabaseRequest(
             `/shared_context?${params.join("&")}`
           );
-          const filtered = filterContextRows(data, args, requestedLimit);
+          const filtered = filterContextRows(data, contextArgs, requestedLimit);
           return {
-            content: [{ type: "text", text: JSON.stringify(filtered, null, 2) }]
+            content: [{ type: "text", text: JSON.stringify(filtered, null, 2) }],
+            structuredContent: { entries: filtered }
           };
         }
         case "ack_context": {
@@ -696,66 +664,122 @@ function createAgentBridgeServer(config) {
         }
         case "send": {
           if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
+          const input = validateRequest("publish_message", args ?? {});
           try {
-            resolvePostSource(args?.source, principal.agent);
+            resolvePostSource(input.source, principal.agent);
           } catch (error) {
             throw new McpError(ErrorCode.InvalidParams, error instanceof Error ? error.message : "source identity mismatch");
           }
-          const result = await service.publish(principal, args);
-          return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result };
+          const { source: _source, ...draft } = input;
+          return canonicalResult("publish_message", await service.publish(principal, draft));
         }
         case "history": {
           if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
-          const result = await service.history(principal, args ?? {});
-          return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result };
+          const input = validateRequest("history", args ?? {});
+          return canonicalResult("history", await service.history(principal, input));
+        }
+        case "sync": {
+          if (!store?.sync) throw new McpError(ErrorCode.InvalidParams, "sync is available only with the gateway provider");
+          const input = validateRequest("sync", args ?? {});
+          const result = await store.sync({
+            maxPush: input.maxPush,
+            maxPages: input.maxPages,
+            signal: extra.signal
+          });
+          return canonicalResult("sync", result);
         }
         case "claim": {
           if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
-          const result = await service.claim(principal, { leaseMs: args?.leaseMs, maxAttempts: args?.maxAttempts });
-          return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result ?? { delivery: null } };
+          const input = validateRequest("claim_delivery", args ?? {});
+          const result = await service.claim(principal, {
+            leaseMs: input.leaseMs,
+            maxAttempts: input.maxAttempts
+          });
+          return canonicalResult("claim_delivery", result ?? { delivery: null });
+        }
+        case "list_deliveries":
+        case "list_delivery_events":
+        case "cancel_delivery":
+        case "requeue_delivery": {
+          if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
+          const operationId = name === "list_deliveries" ? "list_deliveries" : name === "list_delivery_events" ? "list_delivery_events" : name === "cancel_delivery" ? "cancel_delivery" : "requeue_delivery";
+          const input = validateRequest(operationId, args ?? {});
+          const result = name === "list_deliveries" ? await service.deliveries(principal, input) : name === "list_delivery_events" ? await service.deliveryEvents(principal, String(input.deliveryId), input) : name === "cancel_delivery" ? await service.cancel(principal, String(input.deliveryId)) : await service.requeue(principal, String(input.deliveryId));
+          return canonicalResult(operationId, name === "list_deliveries" || name === "list_delivery_events" ? result : { delivery: result });
         }
         case "extend":
         case "acknowledge":
         case "negative_acknowledge": {
           if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
-          const id = String(args?.deliveryId ?? ""), token = String(args?.leaseToken ?? "");
-          const result = name === "extend" ? await service.extend(principal, id, token, args?.leaseMs) : name === "acknowledge" ? await service.ack(principal, id, token) : await service.nack(
+          const operationId = name === "extend" ? "extend_delivery" : name === "acknowledge" ? "acknowledge_delivery" : "negative_acknowledge_delivery";
+          const input = validateRequest(operationId, args ?? {});
+          const id = String(input.deliveryId), token = String(input.leaseToken);
+          const result = name === "extend" ? await service.extend(principal, id, token, input.leaseMs) : name === "acknowledge" ? await service.ack(principal, id, token) : await service.nack(
             principal,
             id,
             token,
-            args?.error ?? "negative acknowledgment",
-            args?.dead ?? false,
-            args?.retryPolicy
+            input.error,
+            input.disposition ?? input.dead ?? "retry",
+            input.retryPolicy
           );
-          return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result ?? { delivery: null } };
+          return canonicalResult(operationId, { delivery: result });
         }
         case "heartbeat": {
           if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
+          const input = validateRequest("heartbeat", args ?? {});
           const result = await service.heartbeat(principal, {
-            leaseMs: args?.leaseMs,
-            runtimeType: args?.runtimeType,
-            capabilities: args?.capabilities
+            leaseMs: input.leaseMs,
+            runtimeType: input.runtimeType,
+            capabilities: input.capabilities
           });
-          return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result };
+          return canonicalResult("heartbeat", result);
         }
         case "presence": {
           if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
+          validateRequest("presence", args ?? {});
           const result = { agents: await service.presence(principal) };
-          return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result };
+          return canonicalResult("presence", result);
         }
         default:
           throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
       }
     } catch (error) {
       if (error instanceof McpError) throw error;
-      if (error instanceof BridgeValidationError) {
+      if (error instanceof ContractValidationError || error instanceof BridgeValidationError || error instanceof BridgePrincipalMismatchError) {
         throw new McpError(ErrorCode.InvalidParams, error.message);
       }
       throw error;
     }
   });
+  let initialization;
+  const initializeStore = () => initialization ?? (initialization = clientConfig?.provider === "gateway" ? store?.initialize() ?? Promise.resolve() : Promise.resolve());
+  let closure;
+  const closeStore = () => closure ?? (closure = store?.close?.() ?? Promise.resolve());
+  const connect = server.connect.bind(server);
+  server.connect = async (transport) => {
+    await initializeStore();
+    await connect(transport);
+  };
+  const close = server.close.bind(server);
+  server.close = async () => {
+    let transportError;
+    try {
+      await close();
+    } catch (error) {
+      transportError = error;
+    }
+    try {
+      await closeStore();
+    } catch (error) {
+      if (transportError) throw Object.assign(new Error("failed to close Agent Bridge server"), {
+        errors: [transportError, error]
+      });
+      throw error;
+    }
+    if (transportError) throw transportError;
+  };
   server.onclose = () => {
-    void store?.close?.();
+    void closeStore().catch((error) => server.onerror?.(error instanceof Error ? error : new Error(String(error))));
   };
   return server;
 }
@@ -766,8 +790,9 @@ async function startServer(config = configFromEnv()) {
 }
 
 export {
+  MCP_IMPLEMENTATION_VERSION,
   configFromEnv,
   createAgentBridgeServer,
   startServer
 };
-//# sourceMappingURL=chunk-4KAOBC5X.js.map
+//# sourceMappingURL=chunk-SPSMZOCJ.js.map