the-campfire 0.2.1 → 0.3.0

package/server/session-types.ts

@@ -223,6 +223,10 @@ export type BrowserIncomingMessageBase =
   | { type: "memory_stored"; fragment: import("./semantic-memory.js").MemoryFragment }
   | { type: "memory_query_result"; query: string; results: import("./semantic-memory.js").MemoryFragment[] }
   | { type: "memory_consolidated"; tag: string; knowledge: import("./semantic-memory.js").ConsolidatedKnowledge }
+  // Emitted when a user_message was enriched with recalled memories, so the
+  // UI can render a collapsible "recalled context" chip instead of the
+  // injected text being invisible. `items` lists exactly what was included.
+  | { type: "memory_enriched"; user_message_id?: string; items: MemoryEnrichmentItem[]; truncated?: boolean }
   // Layer 2: Deliberation
   | { type: "deliberation_proposal"; proposal: import("./deliberation-engine.js").DeliberationProposal }
   | { type: "deliberation_response"; response: import("./deliberation-engine.js").DeliberationResponse }
@@ -237,6 +241,17 @@ export type BrowserIncomingMessageBase =
   | { type: "semantic_link_added"; sourceId: string; targetId: string; relation: string }
   | { type: "consensus_update"; state: import("./shared-context.js").ConsensusState };
 
+/** One recalled memory included in an enriched prompt (for the UI chip). */
+export interface MemoryEnrichmentItem {
+  id: string;
+  kind: "knowledge" | "fragment";
+  namespace: string;
+  summary: string;
+  tag?: string;
+  /** Decayed weight at recall time (0..1). */
+  weight: number;
+}
+
 export type BrowserIncomingMessage = BrowserIncomingMessageBase & { seq?: number };
 
 export type ReplayableBrowserIncomingMessage = Exclude<BrowserIncomingMessageBase, { type: "event_replay" }>;

package/server/settings-manager.ts

@@ -11,6 +11,85 @@ export const DEFAULT_OPENROUTER_MODEL = "openrouter/free";
 
 export type EmbeddingProvider = "openai" | "ollama" | "none";
 
+// ─── Semantic memory settings (design doc §3.1/§3.2) ─────────────────────────
+
+/** Decay policy for one namespace class. halfLifeHours = null → never decays. */
+export interface MemoryDecayPolicy {
+  halfLifeHours: number | null;
+  reinforceMultiplier: number;
+}
+
+export interface MemorySettings {
+  decay: {
+    global: MemoryDecayPolicy;
+    repo: MemoryDecayPolicy;
+    session: MemoryDecayPolicy;
+    agent: MemoryDecayPolicy;
+  };
+  /** Per-namespace recall depth for retrieval (ADR-161's "depth is a tunable"). */
+  recallDepth: {
+    session: number;
+    repo: number;
+    agent: number;
+    global: number;
+  };
+}
+
+/** Defaults per §3.1: 90d/30d/7d/60d half-lives (in hours), ×1.5/1.5/1.2/1.2. */
+export const DEFAULT_MEMORY_SETTINGS: MemorySettings = {
+  decay: {
+    global: { halfLifeHours: 90 * 24, reinforceMultiplier: 1.5 },
+    repo: { halfLifeHours: 30 * 24, reinforceMultiplier: 1.5 },
+    session: { halfLifeHours: 7 * 24, reinforceMultiplier: 1.2 },
+    agent: { halfLifeHours: 60 * 24, reinforceMultiplier: 1.2 },
+  },
+  recallDepth: { session: 4, repo: 6, agent: 2, global: 3 },
+};
+
+function normalizeDecayPolicy(raw: unknown, fallback: MemoryDecayPolicy): MemoryDecayPolicy {
+  const r = (raw ?? {}) as Partial<MemoryDecayPolicy>;
+  const halfLifeHours =
+    r.halfLifeHours === null
+      ? null
+      : typeof r.halfLifeHours === "number" && Number.isFinite(r.halfLifeHours) && r.halfLifeHours > 0
+        ? r.halfLifeHours
+        : fallback.halfLifeHours;
+  const reinforceMultiplier =
+    typeof r.reinforceMultiplier === "number" &&
+    Number.isFinite(r.reinforceMultiplier) &&
+    r.reinforceMultiplier >= 1
+      ? r.reinforceMultiplier
+      : fallback.reinforceMultiplier;
+  return { halfLifeHours, reinforceMultiplier };
+}
+
+function normalizeRecallDepth(raw: unknown, key: keyof MemorySettings["recallDepth"]): number {
+  const r = (raw ?? {}) as Record<string, unknown>;
+  const v = r[key];
+  if (typeof v === "number" && Number.isFinite(v) && v >= 0) return Math.floor(v);
+  return DEFAULT_MEMORY_SETTINGS.recallDepth[key];
+}
+
+/** Deep-merge a (possibly partial/invalid) saved memory section over the defaults. */
+export function normalizeMemorySettings(raw: unknown): MemorySettings {
+  const r = (raw ?? {}) as { decay?: Record<string, unknown>; recallDepth?: unknown };
+  const decayRaw = r.decay ?? {};
+  return {
+    decay: {
+      global: normalizeDecayPolicy(decayRaw.global, DEFAULT_MEMORY_SETTINGS.decay.global),
+      repo: normalizeDecayPolicy(decayRaw.repo, DEFAULT_MEMORY_SETTINGS.decay.repo),
+      session: normalizeDecayPolicy(decayRaw.session, DEFAULT_MEMORY_SETTINGS.decay.session),
+      agent: normalizeDecayPolicy(decayRaw.agent, DEFAULT_MEMORY_SETTINGS.decay.agent),
+    },
+    recallDepth: {
+      session: normalizeRecallDepth(r.recallDepth, "session"),
+      repo: normalizeRecallDepth(r.recallDepth, "repo"),
+      agent: normalizeRecallDepth(r.recallDepth, "agent"),
+      global: normalizeRecallDepth(r.recallDepth, "global"),
+    },
+  };
+}
+
 export interface CampfireSettings {
   openrouterApiKey: string;
   openrouterModel: string;
@@ -28,6 +107,13 @@ export interface CampfireSettings {
   embeddingApiKey: string;    // OpenAI API key (if provider = "openai")
   embeddingModel: string;     // e.g. "text-embedding-3-small" or "nomic-embed-text"
   embeddingBaseUrl: string;   // Ollama base URL (if provider = "ollama"), default http://localhost:11434
+  /**
+   * Semantic memory v2: decay policies + recall depths per namespace class.
+   * Always populated by normalize() at runtime — typed optional only so
+   * pre-v2 CampfireSettings literals (test mocks) keep compiling. Use
+   * getMemorySettings() for guaranteed-present typed access.
+   */
+  memory?: MemorySettings;
   /** Whether the onboarding wizard has been completed or skipped */
   onboardingCompleted: boolean;
   updatedAt: number;
@@ -49,6 +135,7 @@ let settings: CampfireSettings = {
   embeddingApiKey: "",
   embeddingModel: "",
   embeddingBaseUrl: "http://localhost:11434",
+  memory: normalizeMemorySettings(null),
   onboardingCompleted: false,
   updatedAt: 0,
 };
@@ -71,6 +158,7 @@ function normalize(raw: Partial<CampfireSettings> | null | undefined): CampfireS
     embeddingBaseUrl: typeof raw?.embeddingBaseUrl === "string" && raw.embeddingBaseUrl.trim()
       ? raw.embeddingBaseUrl
       : "http://localhost:11434",
+    memory: normalizeMemorySettings(raw?.memory),
     onboardingCompleted: raw?.onboardingCompleted === true,
     updatedAt: typeof raw?.updatedAt === "number" ? raw.updatedAt : 0,
   };
@@ -99,14 +187,45 @@ export function getSettings(): CampfireSettings {
   return { ...settings };
 }
 
+/** Semantic memory settings with defaults guaranteed (never undefined). */
+export function getMemorySettings(): MemorySettings {
+  ensureLoaded();
+  return settings.memory ?? normalizeMemorySettings(null);
+}
+
+/** Deep-merge a partial memory patch over the current memory settings, then normalize. */
+function mergeMemoryPatch(current: MemorySettings, patch: unknown): MemorySettings {
+  if (!patch || typeof patch !== "object") return current;
+  const p = patch as {
+    decay?: Record<string, Record<string, unknown> | undefined>;
+    recallDepth?: Record<string, unknown>;
+  };
+  return normalizeMemorySettings({
+    decay: {
+      global: { ...current.decay.global, ...p.decay?.global },
+      repo: { ...current.decay.repo, ...p.decay?.repo },
+      session: { ...current.decay.session, ...p.decay?.session },
+      agent: { ...current.decay.agent, ...p.decay?.agent },
+    },
+    recallDepth: { ...current.recallDepth, ...p.recallDepth },
+  });
+}
+
 export function updateSettings(
-  patch: Partial<Pick<CampfireSettings, "openrouterApiKey" | "openrouterModel" | "moltbookApiKey" | "linearApiKey" | "claudeOAuthToken" | "openaiApiKey" | "anthropicApiKey" | "embeddingProvider" | "embeddingApiKey" | "embeddingModel" | "embeddingBaseUrl" | "onboardingCompleted">>,
+  patch: Partial<Pick<CampfireSettings, "openrouterApiKey" | "openrouterModel" | "moltbookApiKey" | "linearApiKey" | "claudeOAuthToken" | "openaiApiKey" | "anthropicApiKey" | "embeddingProvider" | "embeddingApiKey" | "embeddingModel" | "embeddingBaseUrl" | "onboardingCompleted">> & {
+    /** Partial memory settings — deep-merged over the current values. */
+    memory?: unknown;
+  },
 ): CampfireSettings {
   ensureLoaded();
+  const { memory: memoryPatch, ...rest } = patch;
   settings = {
     ...settings,
-    ...patch,
-    openrouterModel: patch.openrouterModel?.trim() || settings.openrouterModel || DEFAULT_OPENROUTER_MODEL,
+    ...rest,
+    openrouterModel: rest.openrouterModel?.trim() || settings.openrouterModel || DEFAULT_OPENROUTER_MODEL,
+    memory: memoryPatch !== undefined
+      ? mergeMemoryPatch(settings.memory ?? normalizeMemorySettings(null), memoryPatch)
+      : settings.memory,
     updatedAt: Date.now(),
   };
   persist();

package/server/ws-bridge.ts

@@ -35,6 +35,7 @@ import type { CodexAdapter } from "./codex-adapter.js";
 import type { AgentAdapter } from "./adapter-types.js";
 import type { RecorderManager } from "./recorder.js";
 import type { CollectiveIntelligenceLayer } from "./collective-intelligence.js";
+import { consolidate, noteSessionActivity, shouldConsolidateOnTurn } from "./memory-consolidation.js";
 import { evaluateAutoInjection, scanMcpServers } from "./mcp-policy.js";
 
 // ─── WebSocket data tags ──────────────────────────────────────────────────────
@@ -294,6 +295,8 @@ export class WsBridge {
   ]);
   private static readonly VOTE_DEADLINE_MS = 30_000; // 30 seconds to vote
   private static readonly INVITE_TOKEN_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+  /** Memory-enrichment budget (§3.6.1): past this, the original prompt is sent unenriched. */
+  private static readonly ENRICHMENT_TIMEOUT_MS = 250;
   private readonly sessions = new Map<string, Session>();
   private readonly inviteTokens = new Map<string, { sessionId: string; role: SessionRole; expiresAt: number }>();
   private viewerCounter = 0;
@@ -309,6 +312,8 @@ export class WsBridge {
   private readonly environmentMcpInjected = new Set<string>();
   private readonly autoNamingAttempted = new Set<string>();
   private userMsgCounter = 0;
+  /** Per-session promise chain serializing enriched user_message dispatch (§3.6.1). */
+  private readonly userMessageChains = new Map<string, Promise<void>>();
   private onGitInfoReady: ((sessionId: string, cwd: string, branch: string) => void) | null = null;
   private static readonly GIT_SESSION_KEYS: GitSessionKey[] = [
     "git_branch",
@@ -1054,6 +1059,8 @@ export class WsBridge {
       }
       session.messageHistory.push(msg);
       this.persistSession(session);
+      // §3.4 trigger 1 (adapter result path): consolidate on turn boundary
+      this.maybeConsolidateOnTurn(session);
     }
 
     // Handle permission requests
@@ -1582,6 +1589,9 @@ export class WsBridge {
 
     this.emitResultWebhooks(session, msg);
 
+    // §3.4 trigger 1: consolidate on turn boundary (fire-and-forget)
+    this.maybeConsolidateOnTurn(session);
+
     // Trigger auto-naming after the first successful result
     this.tryAutoNaming(session, browserMsg);
   }
@@ -1690,21 +1700,31 @@ export class WsBridge {
     return true;
   }
 
-  /** Route a browser message to an adapter-based backend (Codex, Goose, etc.). */
+  /** Append a user message to session history with a stable id for reconnect dedup. */
+  private pushUserHistoryEntry(session: Session, content: string): string {
+    const ts = Date.now();
+    const id = `user-${ts}-${this.userMsgCounter++}`;
+    session.messageHistory.push({ type: "user_message", content, timestamp: ts, id });
+    return id;
+  }
+
+  /**
+   * Route a browser message to an adapter-based backend (Codex, Goose, etc.).
+   * For user_message, `userHistoryContent` (when set) is what goes into
+   * messageHistory — the original user text — while `msg.content` (possibly
+   * memory-enriched, §3.6.1) is what the adapter receives. Returns the
+   * history entry id for user messages.
+   */
   private routeToAdapter(
     session: Session,
     msg: BrowserOutgoingMessage,
     ws?: ServerWebSocket<SocketData>,
-  ): void {
+    userHistoryContent?: string,
+  ): string | null {
+    let userHistoryId: string | null = null;
     // Store user messages in history for replay with stable ID for dedup on reconnect
     if (msg.type === "user_message") {
-      const ts = Date.now();
-      session.messageHistory.push({
-        type: "user_message",
-        content: msg.content,
-        timestamp: ts,
-        id: `user-${ts}-${this.userMsgCounter++}`,
-      });
+      userHistoryId = this.pushUserHistoryEntry(session, userHistoryContent ?? msg.content);
       this.persistSession(session);
     }
 
@@ -1714,7 +1734,7 @@ export class WsBridge {
       const eligibleVoters = this.countEligibleVoters(session);
       if (eligibleVoters > 1) {
         this.recordVote(session, msg.request_id, ws, msg.behavior, msg);
-        return;
+        return null;
       }
       const pending = session.pendingPermissions.get(msg.request_id);
       if (session.backendType === "claude" && msg.behavior === "allow" && !msg.updated_input && pending) {
@@ -1731,18 +1751,24 @@ export class WsBridge {
       console.log(`[ws-bridge] ${session.backendType} adapter not yet attached for session ${session.id}, queuing ${msg.type}`);
       session.pendingMessages.push(JSON.stringify(outboundMsg));
     }
+    return userHistoryId;
   }
 
-  /** Route a browser message to the Claude Code CLI backend. */
+  /**
+   * Route a browser message to the Claude Code CLI backend.
+   * `userHistoryContent` behaves as in routeToAdapter (§3.6.1): history text
+   * override for user messages. Returns the history entry id for user
+   * messages, null otherwise.
+   */
   private routeToClaude(
     session: Session,
     msg: BrowserOutgoingMessage,
     ws?: ServerWebSocket<SocketData>,
-  ): void {
+    userHistoryContent?: string,
+  ): string | null {
     switch (msg.type) {
       case "user_message":
-        this.handleUserMessage(session, msg);
-        break;
+        return this.handleUserMessage(session, msg, userHistoryContent);
       case "permission_response":
         this.handlePermissionResponse(session, msg, ws);
         break;
@@ -1768,6 +1794,7 @@ export class WsBridge {
         this.handleMcpSetServers(session, msg.servers);
         break;
     }
+    return null;
   }
 
   private routeBrowserMessage(
@@ -1819,15 +1846,167 @@ export class WsBridge {
       this.rememberClientMessage(session, msg.client_msg_id);
     }
 
+    // §3.6.1: user messages take the (possibly async) memory-enrichment path
+    // after all RBAC / idempotency gates above. Everything else dispatches
+    // synchronously exactly as before.
+    if (msg.type === "user_message") {
+      this.handleUserMessageWithEnrichment(session, msg, ws);
+      return;
+    }
+
+    this.dispatchBrowserMessage(session, msg, ws);
+  }
+
+  /**
+   * Final backend dispatch (adapter vs Claude CLI), extracted from
+   * routeBrowserMessage so the enrichment path can reuse it.
+   *
+   * For user_message, `userHistoryContent` overrides the text stored in
+   * messageHistory (history shows what the user typed; `msg.content` — which
+   * may carry the enrichment block — goes to the backend). Returns the
+   * history entry id for user messages, null otherwise.
+   */
+  private dispatchBrowserMessage(
+    session: Session,
+    msg: BrowserOutgoingMessage,
+    ws?: ServerWebSocket<SocketData>,
+    userHistoryContent?: string,
+  ): string | null {
     if (session.adapter) {
-      this.routeToAdapter(session, msg, ws);
+      return this.routeToAdapter(session, msg, ws, userHistoryContent);
     } else if (session.backendType === "claude") {
-      this.routeToClaude(session, msg, ws);
+      return this.routeToClaude(session, msg, ws, userHistoryContent);
     } else {
-      this.routeToAdapter(session, msg, ws);
+      return this.routeToAdapter(session, msg, ws, userHistoryContent);
+    }
+  }
+
+  /**
+   * user_message routing with the memory-enrichment hook (§3.6.1–3.6.4).
+   *
+   * ASYNC-RIPPLE DECISION: routeBrowserMessage stays synchronous. Enrichment
+   * is an async pre-step performed only for user_message and only when a
+   * collective-intelligence layer is attached — so all existing synchronous
+   * callers (handleBrowserMessage, injectUserMessage, setMcpServers,
+   * injectDetectedEnvironmentMcp) keep their contracts, and sessions without
+   * CI keep the fully synchronous v1 path. Because each enrichment awaits
+   * independently, two rapid user messages could otherwise dispatch out of
+   * order (a slow enrichment on msg1 racing a fast one on msg2); to preserve
+   * per-session ordering we serialize user-message dispatch through a
+   * per-session promise chain. The chain can back up at most
+   * ENRICHMENT_TIMEOUT_MS per message, so chat never blocks on memory.
+   */
+  private handleUserMessageWithEnrichment(
+    session: Session,
+    msg: BrowserOutgoingMessage & { type: "user_message" },
+    ws?: ServerWebSocket<SocketData>,
+  ): void {
+    // §3.4 idle trigger: any user activity resets the idle clock.
+    try {
+      noteSessionActivity(this.consolidationContext(session));
+    } catch (err) {
+      console.warn(`[ws-bridge] noteSessionActivity failed for ${session.id}:`, err);
+    }
+
+    const ci = this.collectiveIntelligence;
+    if (!ci || typeof ci.enrichUserMessage !== "function") {
+      // No CI layer attached — keep the fully synchronous dispatch path.
+      this.dispatchBrowserMessage(session, msg, ws);
+      return;
+    }
+
+    const prior = this.userMessageChains.get(session.id) ?? Promise.resolve();
+    const next = prior.then(() =>
+      this.enrichAndDispatchUserMessage(session, msg, ws).catch((err) => {
+        console.warn(`[ws-bridge] user_message dispatch failed for ${session.id}:`, err);
+      }),
+    );
+    this.userMessageChains.set(session.id, next);
+    // Drop the chain entry once fully drained so the map doesn't grow forever.
+    void next.finally(() => {
+      if (this.userMessageChains.get(session.id) === next) {
+        this.userMessageChains.delete(session.id);
+      }
+    });
+  }
+
+  /**
+   * Enrich a user message with recalled memory, dispatch it, and surface the
+   * recall to browsers (§3.6.1–3.6.4):
+   *  - enrichment is raced against ENRICHMENT_TIMEOUT_MS and try/caught —
+   *    on timeout or error the ORIGINAL content is sent unchanged;
+   *  - the backend receives `<block>\n\n<original>`, while messageHistory
+   *    stores the original user text;
+   *  - after the history entry exists, a memory_enriched message carrying its
+   *    id + the recalled items is broadcast (skipped when block is null).
+   */
+  private async enrichAndDispatchUserMessage(
+    session: Session,
+    msg: BrowserOutgoingMessage & { type: "user_message" },
+    ws?: ServerWebSocket<SocketData>,
+  ): Promise<void> {
+    let enrichment: import("./semantic-memory.js").EnrichmentResult | null = null;
+    try {
+      const timeout = new Promise<null>((resolveRace) => {
+        const timer = setTimeout(() => resolveRace(null), WsBridge.ENRICHMENT_TIMEOUT_MS);
+        timer.unref?.();
+      });
+      enrichment = await Promise.race([
+        this.collectiveIntelligence!.enrichUserMessage(this.consolidationContext(session), msg.content),
+        timeout,
+      ]);
+    } catch (err) {
+      console.warn(`[ws-bridge] memory enrichment failed for ${session.id} (sending original):`, err);
+      enrichment = null;
+    }
+
+    const block = enrichment?.block ?? null;
+    const outbound = block ? { ...msg, content: `${block}\n\n${msg.content}` } : msg;
+    const historyId = this.dispatchBrowserMessage(session, outbound, ws, msg.content);
+
+    if (block && enrichment && enrichment.items.length > 0) {
+      this.broadcastToBrowsers(session, {
+        type: "memory_enriched",
+        user_message_id: historyId ?? undefined,
+        items: enrichment.items,
+      });
     }
   }
 
+  /** Session context for memory consolidation / enrichment (§3.6 item 5). */
+  private consolidationContext(session: Session): {
+    sessionId: string;
+    repoRoot: string;
+    backendType: BackendType;
+  } {
+    return {
+      sessionId: session.id,
+      repoRoot: session.state.repo_root || session.state.cwd || "",
+      backendType: session.backendType,
+    };
+  }
+
+  /**
+   * §3.4 turn-boundary trigger: on every result message, record activity for
+   * the idle watcher and — fire-and-forget, off the hot path — consolidate
+   * when the un-consolidated fragment threshold is met.
+   */
+  private maybeConsolidateOnTurn(session: Session): void {
+    const ctx = this.consolidationContext(session);
+    try {
+      noteSessionActivity(ctx);
+    } catch (err) {
+      console.warn(`[ws-bridge] noteSessionActivity failed for ${session.id}:`, err);
+    }
+    void (async () => {
+      if (await shouldConsolidateOnTurn(session.id)) {
+        await consolidate({ ...ctx, reason: "turn_boundary" });
+      }
+    })().catch((err) => {
+      console.warn(`[ws-bridge] turn-boundary consolidation failed for ${session.id}:`, err);
+    });
+  }
+
   private isDuplicateClientMessage(session: Session, clientMsgId: string): boolean {
     return session.processedClientMessageIdSet.has(clientMsgId);
   }
@@ -1902,18 +2081,19 @@ export class WsBridge {
     }
   }
 
+  /**
+   * Send a user message to the Claude CLI. `historyContent` (when set) is the
+   * text stored in messageHistory — the original user prompt — while
+   * `msg.content` (possibly memory-enriched, §3.6.1) goes to the CLI.
+   * Returns the history entry id.
+   */
   private handleUserMessage(
     session: Session,
-    msg: { type: "user_message"; content: string; session_id?: string; images?: { media_type: string; data: string }[] }
-  ) {
+    msg: { type: "user_message"; content: string; session_id?: string; images?: { media_type: string; data: string }[] },
+    historyContent?: string,
+  ): string {
     // Store user message in history for replay with stable ID for dedup on reconnect
-    const ts = Date.now();
-    session.messageHistory.push({
-      type: "user_message",
-      content: msg.content,
-      timestamp: ts,
-      id: `user-${ts}-${this.userMsgCounter++}`,
-    });
+    const historyId = this.pushUserHistoryEntry(session, historyContent ?? msg.content);
 
     // Build content: if images are present, use content block array; otherwise plain string
     let content: string | unknown[];
@@ -1939,6 +2119,7 @@ export class WsBridge {
     });
     this.sendToCLI(session, ndjson);
     this.persistSession(session);
+    return historyId;
   }
 
   private handlePermissionResponse(

package/dist/assets/channel-D6cof2B8.js

@@ -1 +0,0 @@
-import{ap as o,aq as n}from"./mermaid.core-Z9YQUdi5.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/dist/assets/classDiagram-2ON5EDUG-BG_dxrC_.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-B4BG7PRW-DGvVY1Y_.js";import{_ as i}from"./mermaid.core-Z9YQUdi5.js";import"./chunk-FMBD7UC4-Ctqs0bWj.js";import"./chunk-55IACEB6-BbI83gIK.js";import"./chunk-QN33PNHL-CfvfTLi4.js";import"./index-CAGJQXdJ.js";var u={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{u as diagram};

package/dist/assets/classDiagram-v2-WZHVMYZB-BG_dxrC_.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-B4BG7PRW-DGvVY1Y_.js";import{_ as i}from"./mermaid.core-Z9YQUdi5.js";import"./chunk-FMBD7UC4-Ctqs0bWj.js";import"./chunk-55IACEB6-BbI83gIK.js";import"./chunk-QN33PNHL-CfvfTLi4.js";import"./index-CAGJQXdJ.js";var u={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{u as diagram};

package/dist/assets/clone-vuZ4vhTG.js

@@ -1 +0,0 @@
-import{b as r}from"./_baseUniq-CZ0BR5Mx.js";var e=4;function a(o){return r(o,e)}export{a as c};