@productbrain/mcp 0.0.1-beta.31 → 0.0.1-beta.32

package/dist/{chunk-AZHB7KMP.js → chunk-THAYIBTL.js}

@@ -22,11 +22,10 @@ import {
   requireWriteAccess,
   runWithToolContext,
   setSessionOriented,
-  setWriteToolsEnabled,
   startAgentSession,
   trackWriteTool,
   translateStaleToolNames
-} from "./chunk-3JSR5JCU.js";
+} from "./chunk-UOT3O5FN.js";
 import {
   trackQualityCheck,
   trackQualityVerdict
@@ -126,7 +125,7 @@ ${formatted}` }]
     },
     async ({ entryId }) => {
       requireWriteAccess();
-      const { runContradictionCheck } = await import("./smart-capture-X7BWHT4P.js");
+      const { runContradictionCheck } = await import("./smart-capture-6TQM35CV.js");
       const entry = await mcpQuery("chain.getEntry", { entryId });
       if (!entry) {
         return {
@@ -282,7 +281,8 @@ function registerEntriesTools(server) {
       title: "Entries",
       description: 'Read entries from the Chain. One tool for all entry reading.\n\n- **list**: Browse entries with optional filters (collection, status, tag, label). Use collections action=list first to discover slugs.\n- **get**: Fetch a single entry by ID \u2014 full record with data, labels, relations, history.\n- **batch**: Fetch multiple entries (max 20) in one call. Same shape as get per entry.\n- **search**: Full-text search across entries. Scope by collection or filter by status.\n\nUse `entries action=get entryId="..."` to fetch one. Use `entries action=search query="..."` to discover.',
       inputSchema: entriesSchema,
-      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+      _meta: { ui: { resourceUri: "ui://entries/entry-cards.html" } }
     },
     async (args) => {
       const parsed = entriesSchema.safeParse(args);
@@ -371,6 +371,7 @@ async function handleGet(entryId) {
     name: String(e.name ?? ""),
     collection: String(e.canonicalKey ?? ""),
     status: String(e.status ?? ""),
+    entries: [{ entryId: e.entryId, name: e.name, status: e.status, collectionName: String(e.collectionName ?? e.canonicalKey ?? "\u2014") }],
     ...e.data && typeof e.data === "object" ? { data: e.data } : {},
     ...Array.isArray(e.relations) && e.relations.length > 0 ? {
       relations: e.relations.map((r) => ({
@@ -543,13 +544,24 @@ async function handleSearch(server, query, collection, status) {
     status: String(e.status ?? ""),
     ...e.score != null ? { score: e.score } : {}
   }));
+  const entriesForView = structuredResults.map((e) => ({
+    entryId: e.entryId,
+    name: e.name,
+    status: e.status,
+    collectionName: e.collection
+  }));
   return {
     content: [{ type: "text", text: `${header}
 
 ${formatted}
 
 ${footer}` }],
-    structuredContent: { results: structuredResults, total: structuredResults.length, query }
+    structuredContent: {
+      results: structuredResults,
+      entries: entriesForView,
+      total: structuredResults.length,
+      query
+    }
   };
 }
 
@@ -594,7 +606,8 @@ function registerGraphTools(server) {
       title: "Graph",
       description: "Read from the knowledge graph. Two actions:\n\n- **find**: Traverse relations from a specific entry \u2014 shows incoming/outgoing connections. Use after entries action=get to explore connections. This is NOT full-text search (use entries action=search).\n- **suggest**: Discover potential relations for an entry using graph-aware intelligence. Returns ranked suggestions with confidence scores. Use relations action=create or relations action=batch-create to create the ones that make sense.",
       inputSchema: graphSchema,
-      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+      _meta: { ui: { resourceUri: "ui://graph/constellation.html" } }
     },
     async (args) => {
       const parsed = graphSchema.safeParse(args);
@@ -686,11 +699,26 @@ async function handleFind(entryId, direction) {
     type: r.type,
     direction: r.isOutgoing ? "outgoing" : "incoming"
   }));
+  const nodes = [
+    { id: entryId, name: sourceEntry.name, collectionName: "" },
+    ...shown.map((r) => ({
+      id: r.otherEntryId ?? String(Math.random()),
+      name: r.otherName,
+      collectionName: r.colSlug
+    }))
+  ];
+  const edges = shown.filter((r) => r.otherEntryId).map((r) => ({
+    source: entryId,
+    target: r.otherEntryId,
+    type: r.type
+  }));
   return {
     content: [{ type: "text", text: lines.join("\n") }],
     structuredContent: {
       entryId,
       relations: structuredRelations,
+      nodes,
+      edges,
       total: relations.length
     }
   };
@@ -755,11 +783,26 @@ async function handleSuggest(entryId, limit, depth) {
     confidence: s.score,
     reason: s.reasoning
   }));
+  const nodes = [
+    { id: sourceId, name: resolved?.name ?? entryId, collectionName: "" },
+    ...suggestions.map((s) => ({
+      id: s.entryId ?? String(Math.random()),
+      name: s.name,
+      collectionName: s.collectionSlug
+    }))
+  ];
+  const edges = suggestions.filter((s) => s.entryId).map((s) => ({
+    source: sourceId,
+    target: s.entryId,
+    type: s.recommendedRelationType || "suggested"
+  }));
   return {
     content: [{ type: "text", text: lines.join("\n") }],
     structuredContent: {
       entryId: sourceId,
       suggestions: structuredSuggestions,
+      nodes,
+      edges,
       total: suggestions.length
     }
   };
@@ -963,7 +1006,8 @@ function registerContextTools(server) {
       title: "Context",
       description: "Assemble knowledge context in one call. Two actions:\n\n- **gather**: Three modes \u2014 (1) By entry: traverse the graph around a specific entry. (2) By task: auto-load relevant domain knowledge for a natural-language task. (3) Graph mode (entryId + mode='graph'): enhanced traversal with provenance paths.\n- **build**: Structured build spec for any entry \u2014 data, related entries, business rules, glossary terms, chain refs. Use when starting a build. Requires active session.",
       inputSchema: contextSchema,
-      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false }
+      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+      _meta: { ui: { resourceUri: "ui://graph/constellation.html" } }
     },
     async (args) => {
       const parsed = contextSchema.safeParse(args);
@@ -1048,7 +1092,24 @@ Use \`graph action=suggest\` to discover potential connections.`
       }
       lines2.push("");
     }
-    return { content: [{ type: "text", text: lines2.join("\n") }] };
+    const rootId2 = result2.root.entryId ?? "root";
+    const nodes2 = [
+      { id: rootId2, name: result2.root.name, collectionName: "" },
+      ...result2.context.map((e) => ({
+        id: e.entryId ?? String(Math.random()),
+        name: e.name,
+        collectionName: e.collectionName
+      }))
+    ];
+    const edges2 = result2.context.filter((e) => e.entryId).map((e) => ({
+      source: rootId2,
+      target: e.entryId,
+      type: e.relationType
+    }));
+    return {
+      content: [{ type: "text", text: lines2.join("\n") }],
+      structuredContent: { nodes: nodes2, edges: edges2 }
+    };
   }
   if (task && !entryId) {
     await server.sendLoggingMessage({
@@ -1101,7 +1162,15 @@ _Consider capturing domain knowledge discovered during this task via \`capture\`
       lines2.push("");
     }
     lines2.push(`_Use \`entries action=get\` for full details on any entry._`);
-    return { content: [{ type: "text", text: lines2.join("\n") }] };
+    const taskEntries = result2.context.map((e) => ({
+      entryId: e.entryId ?? String(Math.random()),
+      name: e.name,
+      collectionName: e.collectionName
+    }));
+    return {
+      content: [{ type: "text", text: lines2.join("\n") }],
+      structuredContent: { entries: taskEntries }
+    };
   }
   await server.sendLoggingMessage({
     level: "info",
@@ -1145,7 +1214,24 @@ Use \`graph action=suggest\` to discover potential connections, or \`relations a
     }
     lines.push("");
   }
-  return { content: [{ type: "text", text: lines.join("\n") }] };
+  const rootId = result.root.entryId ?? "root";
+  const nodes = [
+    { id: rootId, name: result.root.name, collectionName: "" },
+    ...result.related.map((e) => ({
+      id: e.entryId ?? String(Math.random()),
+      name: e.name,
+      collectionName: e.collectionName
+    }))
+  ];
+  const edges = result.related.filter((e) => e.entryId).map((e) => ({
+    source: rootId,
+    target: e.entryId,
+    type: e.relationType
+  }));
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    structuredContent: { nodes, edges }
+  };
 }
 async function handleBuild(server, entryId, maxHops) {
   requireActiveSession();
@@ -1769,7 +1855,6 @@ async function handleStart() {
         ""
       );
     }
-    setWriteToolsEnabled(true);
     lines.push(
       `Session ${result.sessionId} active. Initiated by ${result.initiatedBy}. Workspace ${result.workspaceName}. Scope: ${result.toolsScope}. Write tools available after orient.`
     );
@@ -1813,7 +1898,6 @@ async function handleClose() {
       }
     }
     await closeAgentSession();
-    setWriteToolsEnabled(false);
     const lines = [
       `Session ${sessionId} closed.`,
       ""
@@ -2924,6 +3008,70 @@ function buildPlannedWorkSection(work, priorSessions, recoveryBlock) {
   return lines;
 }
 
+// src/tools/orient-shared.ts
+function runAlignmentCheck(task, activeBets, taskContextHits) {
+  const betNames = activeBets.map((b) => b.name);
+  const taskWords = task.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+  const matchingBet = activeBets.find((b) => {
+    const name = (b.name ?? "").toLowerCase();
+    return taskWords.some((w) => name.includes(w));
+  });
+  const betHits = (taskContextHits ?? []).filter(
+    (e) => e.collectionSlug === "bets"
+  );
+  const aligned = !!matchingBet || betHits.length > 0;
+  const matchedBet = matchingBet?.name ?? betHits[0]?.name ?? null;
+  return { aligned, matchedBet, betNames };
+}
+function buildAlignmentCheckLines(result) {
+  const lines = ["## Alignment Check"];
+  if (result.aligned) {
+    lines.push(
+      `Task appears related to active bet: **${result.matchedBet}**. Proceed.`
+    );
+  } else if (result.betNames.length === 0) {
+    lines.push(
+      "No active bets in workspace. Consider shaping a bet before building."
+    );
+  } else {
+    lines.push("**This task does not match any active bet.**");
+    lines.push(`Active bets: ${result.betNames.join(", ")}`);
+    lines.push(
+      "Stop and confirm with the user before designing. This may be out of scope."
+    );
+  }
+  lines.push("");
+  return lines;
+}
+var CORE_PROTOCOL = [
+  '**Search before proposing.** Before suggesting new features, architecture, or changes, search the Chain: `entries action=search query="<relevant terms>"`. Build on what exists.',
+  "**Reference by ID.** When discussing a topic that has Chain entries, cite them by entry ID (e.g. `DEC-50`, `PRI-3`). This keeps conversations grounded in shared knowledge.",
+  "**Check scope.** If the proposed work doesn't fall under an active bet, stop and say so. Do not design implementation for out-of-scope work without explicit user go-ahead.",
+  `**Capture continuously.** When a decision, tension, insight, or new term surfaces during work, capture it as a draft immediately. Don't defer to "later."`,
+  "**Validate against governance.** Before finalizing any proposal, check it against the Workspace Governance section above. If it conflicts with a principle, standard, or business rule, flag the conflict explicitly."
+];
+function buildOperatingProtocol(workspaceStandards) {
+  const lines = [
+    "## Operating Protocol",
+    "_How to work in this workspace. Follow these before and during every task._",
+    ""
+  ];
+  for (let i = 0; i < CORE_PROTOCOL.length; i++) {
+    lines.push(`${i + 1}. ${CORE_PROTOCOL[i]}`);
+  }
+  if (workspaceStandards && workspaceStandards.length > 0) {
+    lines.push("");
+    lines.push("**Workspace-specific standards:**");
+    for (const s of workspaceStandards) {
+      const id = s.entryId ?? s.name;
+      const desc = s.description ? ` \u2014 ${s.description.slice(0, 120)}${s.description.length > 120 ? "..." : ""}` : "";
+      lines.push(`- \`${id}\` **${s.name}**${desc}`);
+    }
+  }
+  lines.push("");
+  return lines;
+}
+
 // src/tools/start.ts
 var startSchema = z13.object({
   preset: z13.string().optional().describe(
@@ -3152,6 +3300,60 @@ async function buildOrientResponse(wsCtx, agentSessionId, errors) {
     if (readiness) {
       lines.push(`Readiness: ${readiness.score}% (${readiness.passedChecks}/${readiness.totalChecks}).`);
     }
+    let wsStandards = [];
+    try {
+      const govSlugs = ["principles", "standards", "business-rules"];
+      const govLabels = {
+        principles: "Principles",
+        standards: "Standards",
+        "business-rules": "Business Rules"
+      };
+      const govEntries = [];
+      for (const slug of govSlugs) {
+        const entries = await mcpQuery("chain.listEntries", { collectionSlug: slug });
+        const active = (entries ?? []).filter((e) => e.status === "active" || e.status === "verified");
+        if (active.length > 0) {
+          govEntries.push({ slug, entries: active });
+          if (slug === "standards") wsStandards = active;
+        }
+      }
+      if (govEntries.length > 0) {
+        lines.push("");
+        lines.push("## Workspace Governance \u2014 constraints");
+        lines.push("_These constrain what you build. If your proposal conflicts with any of these, stop and flag it._");
+        lines.push("");
+        for (const g of govEntries) {
+          lines.push(`**${govLabels[g.slug]}:**`);
+          for (const e of g.entries.slice(0, 8)) {
+            lines.push(`- \`${e.entryId ?? e.name}\` ${e.name}`);
+          }
+          lines.push("");
+        }
+      }
+    } catch {
+    }
+    let activeBets = [];
+    try {
+      const betEntries = await mcpQuery("chain.listEntries", { collectionSlug: "bets" });
+      activeBets = (betEntries ?? []).filter((e) => e.status === "active" && e.data?.horizon === "now").slice(0, 8);
+      if (activeBets.length > 0) {
+        lines.push("");
+        lines.push("## Active bets \u2014 current scope");
+        lines.push("_These define what you're building now. Work outside these bets requires explicit user confirmation before designing._");
+        lines.push("");
+        for (const e of activeBets) {
+          lines.push(`- \`${e.entryId ?? e.name}\` ${e.name}`);
+        }
+        lines.push("");
+      }
+    } catch {
+    }
+    const standardsForProtocol = wsStandards.map((e) => ({
+      entryId: e.entryId,
+      name: e.name,
+      description: typeof e.data?.description === "string" ? e.data.description : typeof e.description === "string" ? e.description : void 0
+    }));
+    lines.push(...buildOperatingProtocol(standardsForProtocol));
     const plannedWork = await queryPlannedWork();
     if (hasPlannedWork(plannedWork)) {
       lines.push("");
@@ -5337,6 +5539,14 @@ function registerHealthTools(server) {
           }
           lines.push("");
         }
+        if (task && orientEntries) {
+          const result = runAlignmentCheck(
+            task,
+            orientEntries.activeBets ?? [],
+            orientEntries.taskContext?.context
+          );
+          lines.push(...buildAlignmentCheckLines(result));
+        }
         if (orientEntries) {
           const fmt = (e) => {
             const type = e.canonicalKey ?? "generic";
@@ -5344,7 +5554,9 @@ function registerHealthTools(server) {
             return `- \`${e.entryId ?? e._id}\` [${type} \xB7 ${stratum}] ${e.name}`;
           };
           if (orientEntries.activeBets?.length > 0) {
-            lines.push("## Active bets");
+            lines.push("## Active bets \u2014 current scope");
+            lines.push("_These define what you're building now. Work outside these bets requires explicit user confirmation before designing._");
+            lines.push("");
             for (const e of orientEntries.activeBets) {
               lines.push(fmt(e));
               const tensions = e.linkedTensions;
@@ -5381,16 +5593,40 @@ function registerHealthTools(server) {
             orientEntries.staleEntries.forEach((e) => lines.push(fmt(e)));
             lines.push("");
           }
-          if (orientEntries.businessRules.length > 0) {
-            lines.push("## Business rules");
-            orientEntries.businessRules.forEach((e) => lines.push(fmt(e)));
+          const hasPrinciples = orientEntries.principles?.length > 0;
+          const hasStandards = orientEntries.standards?.length > 0;
+          const hasBusinessRules = orientEntries.businessRules.length > 0;
+          if (hasPrinciples || hasStandards || hasBusinessRules) {
+            lines.push("## Workspace Governance \u2014 constraints");
+            lines.push("_These constrain what you build. If your proposal conflicts with any of these, stop and flag it. Do not design around them without explicit user confirmation._");
             lines.push("");
+            if (hasPrinciples) {
+              lines.push("**Principles** \u2014 beliefs that guide decisions:");
+              orientEntries.principles.forEach((e) => lines.push(fmt(e)));
+              lines.push("");
+            }
+            if (hasStandards) {
+              lines.push("**Standards** \u2014 conventions for how work is done:");
+              orientEntries.standards.forEach((e) => lines.push(fmt(e)));
+              lines.push("");
+            }
+            if (hasBusinessRules) {
+              lines.push("**Business Rules** \u2014 system constraints:");
+              orientEntries.businessRules.forEach((e) => lines.push(fmt(e)));
+              lines.push("");
+            }
           }
           if (orientEntries.architectureNotes.length > 0) {
             lines.push("## Architecture notes");
             orientEntries.architectureNotes.forEach((e) => lines.push(fmt(e)));
             lines.push("");
           }
+          const standardsForProtocol = (orientEntries.standards ?? []).map((e) => ({
+            entryId: e.entryId,
+            name: e.name,
+            description: typeof e.description === "string" ? e.description : void 0
+          }));
+          lines.push(...buildOperatingProtocol(standardsForProtocol));
         }
         const plannedWork = await queryPlannedWork();
         if (hasPlannedWork(plannedWork)) {
@@ -5457,7 +5693,13 @@ function registerHealthTools(server) {
 }
 
 // src/resources/index.ts
+import { readFile } from "fs/promises";
+import { join, resolve as resolve3 } from "path";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+var UI_VIEWS = {
+  "ui://entries/entry-cards.html": "src/entry-cards/index.html",
+  "ui://graph/constellation.html": "src/graph-constellation/index.html"
+};
 function formatEntryMarkdown(entry) {
   const id = entry.entryId ? `${entry.entryId}: ` : "";
   const lines = [`## ${id}${entry.name} [${entry.status}]`];
@@ -5830,6 +6072,23 @@ ${entry.labels.map((l) => `- ${l.name ?? l.slug}`).join("\n")}`);
       };
     }
   );
+  const viewsBase = resolve3(process.cwd(), "packages", "mcp-views", "dist");
+  for (const [uri, filePath] of Object.entries(UI_VIEWS)) {
+    server.resource(`ui-view-${uri.replace(/[^a-z0-9]/gi, "-")}`, uri, async (uriObj) => {
+      try {
+        const html = await readFile(join(viewsBase, filePath), "utf-8");
+        return { contents: [{ uri: uriObj.href, text: html, mimeType: "text/html" }] };
+      } catch {
+        return {
+          contents: [{
+            uri: uriObj.href,
+            text: "View not found. Run npm run build in packages/mcp-views.",
+            mimeType: "text/plain"
+          }]
+        };
+      }
+    });
+  }
 }
 
 // src/prompts/index.ts
@@ -6110,6 +6369,75 @@ Description field: ${wf.kbOutputTemplate.descriptionField}
       };
     }
   );
+  server.prompt(
+    "shape-a-bet",
+    "Choreograph shaping a product bet using the constellation capture pattern. Guides through problem framing, appetite, solution elements, risk identification, boundaries, and constellation capture. Use when the user wants to shape a bet, define a pitch, or scope work using Shape Up methodology.",
+    {
+      idea: z19.string().describe("Brief description of the idea or feature to shape (e.g. 'Improve the glossary editing flow')")
+    },
+    async ({ idea }) => {
+      return {
+        messages: [{
+          role: "user",
+          content: {
+            type: "text",
+            text: `# Shape a Bet: ${idea}
+
+You are shaping a product bet using the **constellation capture pattern**. The bet will live on the Chain with connected elements, tensions, and decisions.
+
+## Prerequisites
+1. **Start session** (if not already): \`session action=start\`
+2. **Orient**: \`orient\` \u2014 loads workspace context and recent activity
+
+## Shaping Steps (execute in order)
+
+### Step 1: Problem Framing
+Discuss the problem with the user. Narrow to a specific, concrete problem statement. Capture the problem in 2\u20133 sentences.
+
+### Step 2: Set Appetite
+Agree on appetite (e.g. "2 weeks", "6 weeks"). This bounds the solution.
+
+### Step 3: Solution Elements
+Identify 3\u20135 solution elements. For each element that is a distinct feature, capture it:
+\`\`\`
+capture collection="features" name="<Element Name>" description="<What this element does>"
+\`\`\`
+Note the entryIds for relation linking.
+
+### Step 4: Rabbit Holes
+Identify risks. For each risk that is a known tension, capture or link:
+\`\`\`
+capture collection="tensions" name="<Risk>" description="<Risk, patch, mitigation>"
+\`\`\`
+Or link existing tensions.
+
+### Step 5: No-Gos
+Declare what is out of scope. List explicitly.
+
+### Step 6: Constellation Capture
+Capture the bet and connect the constellation:
+\`\`\`
+capture collection="bets" name="<Bet Name>" description="<Problem statement>" data='{"problem":"...","appetite":"...","elements":"...","rabbitHoles":"...","noGos":"..."}'
+\`\`\`
+Then create relations:
+\`\`\`
+relations action=batch-create relations=[
+  {from:"<element-entry-id>",to:"<bet-entry-id>",type:"part_of"},
+  {from:"<tension-entry-id>",to:"<element-or-bet-id>",type:"constrains"},
+  ...
+]
+\`\`\`
+Use \`graph action=suggest entryId="<bet-id>"\` to discover more connections.
+
+### Step 7: Present & Commit
+Show the user the captured bet and constellation. The capture response includes a **View in Studio** link for bets \u2014 share it. Only call \`commit-entry\` when the user confirms.
+
+**Begin with Step 1.** Ask the user to describe the problem they want to solve.`
+          }
+        }]
+      };
+    }
+  );
   server.prompt(
     "capture-and-connect",
     "Guided workflow: capture a knowledge entry, discover graph connections, create relations, and prepare for commit. Encodes the capture \u2192 suggest \u2192 batch-create \u2192 commit choreography as a step-by-step guide.",
@@ -6310,7 +6638,7 @@ If ready, ask the user to confirm. If not, suggest specific improvements.
 }
 
 // src/server.ts
-var SERVER_VERSION = "0.4.0";
+var SERVER_VERSION = "0.7.0";
 var INSTRUCTIONS = [
   "Product Brain \u2014 the single source of truth for product knowledge.",
   "Terminology, standards, and core data all live here \u2014 no need to check external docs.",
@@ -6368,6 +6696,13 @@ var INSTRUCTIONS = [
   "Only call `commit-entry` when the user explicitly confirms (e.g. 'commit', 'looks good', 'yes').",
   "This builds trust \u2014 the Chain (main) is SSOT; nothing goes there without user consent.",
   "",
+  "Alignment-first: before proposing or building anything, check orient's Workspace Governance",
+  "and Active bets sections. These are constraints, not reference material.",
+  "If the proposal conflicts with a principle, standard, or business rule \u2014 stop, flag the conflict,",
+  "and get explicit user confirmation before proceeding. Do not design around governance.",
+  "If the work is outside the scope of active bets \u2014 stop, name the gap, and ask the user",
+  "to confirm before designing. Do not propose implementation for out-of-scope work without a go-ahead.",
+  "",
   "Workspace setup: use `collections action=create` and `collections action=update` to shape the workspace",
   "structure with the user. Ask what they need to track; presets are starting points, not fixed.",
   "",
@@ -6406,7 +6741,6 @@ function createProductBrainServer() {
   registerUsageTools(server);
   registerResources(server);
   registerPrompts(server);
-  setWriteToolsEnabled(false);
   return server;
 }
 
@@ -6414,4 +6748,4 @@ export {
   SERVER_VERSION,
   createProductBrainServer
 };
-//# sourceMappingURL=chunk-AZHB7KMP.js.map
+//# sourceMappingURL=chunk-THAYIBTL.js.map