@smartmemory/compose 0.2.48-beta → 0.2.50-beta

package/server/file-watcher.js

@@ -10,6 +10,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { getTargetRoot, loadProjectConfig, ensureDataDir } from './project-root.js';
+import { resolveDocsPathFromConfig, resolveFeaturesPathFromConfig } from '../lib/project-paths.js';
 
 const PROJECT_ROOT = getTargetRoot();
 
@@ -69,7 +70,8 @@ export class FileWatcherServer {
     app.get('/api/files', (_req, res) => {
       const config = loadProjectConfig();
       const docsPrefix = config.paths?.docs || 'docs';
-      const docsDir = path.join(PROJECT_ROOT, docsPrefix);
+      // COMP-PATHS-EXTERNAL: list the RESOLVED docs dir (may be relocated).
+      const docsDir = resolveDocsPathFromConfig(PROJECT_ROOT, config);
       try {
         const files = this.listMarkdownFiles(docsDir, docsPrefix);
         res.json({ files });
@@ -164,7 +166,10 @@ export class FileWatcherServer {
           if (!filename || !fileFilter(filename)) return;
 
           const relativePath = path.join(prefix, filename);
-          const fullPath = path.join(PROJECT_ROOT, relativePath);
+          // COMP-PATHS-EXTERNAL: derive the real path from the WATCHED dir, not
+          // by re-rooting under PROJECT_ROOT — the dir may be relocated outside
+          // the workspace. Byte-identical to the old form for an in-root dir.
+          const fullPath = path.join(dir, filename);
 
           // Debounce: ignore events within 100ms of each other for the same file
           const now = Date.now();
@@ -180,10 +185,11 @@ export class FileWatcherServer {
       }
     };
 
-    // Watch docs/ — broadcast fileChanged events
+    // Watch docs/ — broadcast fileChanged events. COMP-PATHS-EXTERNAL: watch
+    // the RESOLVED absolute dir (may be relocated outside PROJECT_ROOT).
     const config = loadProjectConfig();
     const docsPrefix = config.paths?.docs || 'docs';
-    watchDir(path.join(PROJECT_ROOT, docsPrefix), docsPrefix, (relativePath, fullPath) => {
+    watchDir(resolveDocsPathFromConfig(PROJECT_ROOT, config), docsPrefix, (relativePath, fullPath) => {
       try {
         if (!fs.existsSync(fullPath)) return;
         const content = fs.readFileSync(fullPath, 'utf-8');
@@ -195,9 +201,9 @@ export class FileWatcherServer {
 
     // Watch features/ — notify for auto-reseed into vision store
     const featuresPrefix = config.paths?.features || 'docs/features';
-    watchDir(path.join(PROJECT_ROOT, featuresPrefix), featuresPrefix, (relativePath) => {
-      // Also broadcast as fileChanged (features are docs)
-      const fullPath = path.join(PROJECT_ROOT, relativePath);
+    watchDir(resolveFeaturesPathFromConfig(PROJECT_ROOT, config), featuresPrefix, (relativePath, fullPath) => {
+      // Also broadcast as fileChanged (features are docs). fullPath comes from
+      // the watched dir (COMP-PATHS-EXTERNAL) — do not re-root under PROJECT_ROOT.
       try {
         if (fs.existsSync(fullPath)) {
           const content = fs.readFileSync(fullPath, 'utf-8');

package/server/ideabox-routes.js

@@ -25,6 +25,7 @@ import {
 } from '../lib/ideabox.js'
 import { writeFeature } from '../lib/feature-json.js'
 import { IdeaboxCache } from './ideabox-cache.js'
+import { resolveIdeaboxPathFromConfig, resolveFeaturesPathFromConfig, relForDisplay } from '../lib/project-paths.js'
 
 /**
  * @param {object} app              — Express app
@@ -41,8 +42,7 @@ export function attachIdeaboxRoutes(app, { getProjectRoot, getDataDir, broadcast
     const dataDir = getDataDir()
     if (!_cache || _lastProjectRoot !== projectRoot || _lastDataDir !== dataDir) {
       const config = loadConfig(projectRoot)
-      const ideaboxRel = config?.paths?.ideabox || 'docs/product/ideabox.md'
-      const sourceFile = path.join(projectRoot, ideaboxRel)
+      const sourceFile = resolveIdeaboxPathFromConfig(projectRoot, config)
       _cache = new IdeaboxCache(dataDir, sourceFile)
       _lastProjectRoot = projectRoot
       _lastDataDir = dataDir
@@ -172,16 +172,17 @@ export function attachIdeaboxRoutes(app, { getProjectRoot, getDataDir, broadcast
         resolvedCode = `IDEA-${sourceIdea.num}-${slug}`.toUpperCase()
       }
 
-      // Create feature folder + feature.json (same logic as CLI promote)
+      // Create feature folder + feature.json (same logic as CLI promote).
+      // COMP-PATHS-EXTERNAL: resolve the ABSOLUTE features base (may be
+      // relocated outside projectRoot). Re-rooting under projectRoot would make
+      // existsSync check the wrong path and risk overwriting external canon.
       const composeJsonPath = path.join(projectRoot, '.compose', 'compose.json')
-      let featuresRel = 'docs/features'
+      let cfg = {}
       if (fs.existsSync(composeJsonPath)) {
-        try {
-          const cfg = JSON.parse(fs.readFileSync(composeJsonPath, 'utf-8'))
-          featuresRel = cfg?.paths?.features || 'docs/features'
-        } catch {}
+        try { cfg = JSON.parse(fs.readFileSync(composeJsonPath, 'utf-8')) } catch {}
       }
-      const featuresDir = path.join(projectRoot, featuresRel, resolvedCode)
+      const featuresBase = resolveFeaturesPathFromConfig(projectRoot, cfg)  // absolute
+      const featuresDir = path.join(featuresBase, resolvedCode)
       if (!fs.existsSync(featuresDir)) {
         // COMP-MCP-VALIDATE-1: route through the validated writer instead of a
         // raw fs.writeFileSync so the promoted feature.json is schema-guarded.
@@ -191,7 +192,7 @@ export function attachIdeaboxRoutes(app, { getProjectRoot, getDataDir, broadcast
           status: 'PLANNED',
           promotedFrom: sourceIdea.id,
           createdAt: new Date().toISOString(),
-        }, featuresRel)
+        }, featuresBase)
       }
 
       promoteIdea(parsed, id, resolvedCode)
@@ -200,7 +201,7 @@ export function attachIdeaboxRoutes(app, { getProjectRoot, getDataDir, broadcast
       broadcastUpdate()
 
       const updated = parsed.ideas.find(i => i.id.toUpperCase() === upper)
-      res.json({ ...(updated || { id }), featureCode: resolvedCode, featurePath: `${featuresRel}/${resolvedCode}` })
+      res.json({ ...(updated || { id }), featureCode: resolvedCode, featurePath: relForDisplay(projectRoot, featuresDir) })
     } catch (err) {
       const status = err.message.includes('not found') ? 404 : 500
       res.status(status).json({ error: err.message })

package/server/project-root.js

@@ -15,6 +15,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { findProjectRoot } from './find-root.js';
+import { DEFAULT_PATHS, resolvePathValue } from '../lib/paths-core.js';
 
 export { findProjectRoot } from './find-root.js';
 
@@ -99,7 +100,7 @@ export function ensureDataDir() {
 const DEFAULT_CONFIG = Object.freeze({
   version: 1,
   capabilities: Object.freeze({ stratum: true, lifecycle: true }),
-  paths: Object.freeze({ docs: 'docs', features: 'docs/features', journal: 'docs/journal' }),
+  paths: DEFAULT_PATHS,                        // single source of truth (COMP-PATHS-EXTERNAL)
 });
 
 function cloneConfig(obj) {
@@ -120,7 +121,23 @@ export function loadProjectConfig() {
 
 export function resolveProjectPath(key) {
   const config = loadProjectConfig();
-  const rel = config.paths?.[key];
-  if (!rel) return path.join(getTargetRoot(), DEFAULT_CONFIG.paths[key] || key);
-  return path.join(getTargetRoot(), rel);
+  // resolvePathValue handles in-root / ../-escaping / absolute overrides.
+  // Preserve the legacy `|| key` fallback for keys absent from DEFAULT_PATHS.
+  // (COMP-PATHS-EXTERNAL)
+  const value = config.paths?.[key] ?? DEFAULT_PATHS[key] ?? key;
+  return resolvePathValue(getTargetRoot(), value, key);
+}
+
+/**
+ * Whether the bound workspace runs the lifecycle/vision store.
+ *
+ * FORGE-ROADMAP-RETIRE-STORE: a workspace sets `capabilities.lifecycle: false`
+ * to RETIRE its vision store — used by narrative-owned workspaces (e.g. forge-top)
+ * where the prose ROADMAP is the single source of truth and a second, frozen
+ * `vision-state.json` would only be a drift-prone parallel answer. Default true
+ * (absent ⇒ enabled); only an explicit `false` disables it.
+ * @returns {boolean}
+ */
+export function isLifecycleEnabled() {
+  return loadProjectConfig().capabilities?.lifecycle !== false;
 }

package/server/session-routes.js

@@ -11,7 +11,7 @@
 
 import path from 'node:path';
 import { readSessionsByFeature } from './session-store.js';
-import { getTargetRoot, getDataDir } from './project-root.js';
+import { getTargetRoot, getDataDir, resolveProjectPath } from './project-root.js';
 import { appendPhaseHistory } from './lifecycle-phase-history.js';
 import { reconcile } from '../lib/checkpoint/reconciler.js';
 import { checkpointConfig } from '../lib/checkpoint/checkpoint-writer.js';
@@ -140,7 +140,7 @@ export function attachSessionRoutes(app, { sessionManager, scheduleBroadcast, br
         featureCode,
         item,
         cwd: targetRoot,
-        featureDir: path.join(targetRoot, 'docs', 'features', featureCode),
+        featureDir: path.join(resolveProjectPath('features'), featureCode),
         composeDir: path.join(targetRoot, '.compose'),
         dataDir,
         store: cpStore,

package/server/stratum-sync.js

@@ -2,7 +2,19 @@
  * stratum-sync.js — Stratum flow poller + route registration.
  *
  * Polls stratum flow state via stratum-client (not direct file reads) and syncs
- * into the vision store every 15 seconds.
+ * into the vision store on a self-scheduling, sleep-aware loop.
+ *
+ * Sleep behavior: each poll cold-starts a `stratum-mcp` subprocess (Python
+ * interpreter spin-up — the expensive part, not the query itself). Doing that
+ * every few seconds generated enough periodic activity to keep the host from
+ * sleeping. Two mitigations:
+ *   1. Cadence widened to 60s (override with COMPOSE_STRATUM_POLL_MS).
+ *   2. The spawn is skipped entirely when no bound flow can still change state
+ *      (`hasLiveFlows`), so an idle/finished Forge does zero periodic spawning
+ *      and the host is free to sleep. The cheap in-memory scan that gates this
+ *      holds no power assertion.
+ * On wake, a tick that fired far later than scheduled is treated as a
+ * post-sleep resync rather than business as usual.
  *
  * Routes: POST /api/stratum/bind, POST /api/stratum/audit/:itemId
  * (Flow/gate query routes are now in stratum-api.js)
@@ -10,6 +22,38 @@
 
 import { queryFlows } from './stratum-client.js';
 
+// Poll cadence. 60s is plenty for a flow list (slower than any build step) and
+// keeps periodic process-spawn activity low enough not to fight host sleep.
+const DEFAULT_POLL_MS = 60_000;
+const MIN_POLL_MS = 1_000;
+const POLL_MS = (() => {
+  const raw = parseInt(process.env.COMPOSE_STRATUM_POLL_MS ?? '', 10);
+  return Number.isFinite(raw) && raw >= MIN_POLL_MS ? raw : DEFAULT_POLL_MS;
+})();
+// A tick that fires later than POLL_MS * this factor means the host slept
+// through scheduled ticks — log it and treat the next sync as a wake resync.
+const WAKE_GAP_FACTOR = 1.5;
+
+/**
+ * Sleep-aware poll gate: true only when some bound vision item could still
+ * change state (i.e. is bound to a flow and not settled-`complete`). When this
+ * is false the poller skips the stratum-mcp spawn so an idle host can sleep.
+ *
+ * A bound `complete` item is steady-state (status only advances to `complete`
+ * via the audit route, never back), so polling it changes nothing. Anything
+ * else bound — `in_progress`, `blocked`, or mid-flight — can still transition
+ * and is worth a poll.
+ *
+ * @param {Iterable<{stratumFlowId?: string, status?: string}>} items
+ * @returns {boolean}
+ */
+export function hasLiveFlows(items) {
+  for (const item of items) {
+    if (item.stratumFlowId && item.status !== 'complete') return true;
+  }
+  return false;
+}
+
 // ---------------------------------------------------------------------------
 // StratumSync class
 // ---------------------------------------------------------------------------
@@ -18,6 +62,8 @@ export class StratumSync {
   #store;
   #scheduleBroadcast;
   #pollTimer = null;
+  #stopped = true;
+  #lastTickAt = 0;
 
   /**
    * @param {object} store — VisionStore instance
@@ -28,23 +74,53 @@ export class StratumSync {
     this.#scheduleBroadcast = scheduleBroadcast;
   }
 
-  /** Start the 15s polling interval. */
+  /** Start the self-scheduling, sleep-aware poll loop (default 60s). */
   start() {
-    this.#pollTimer = setInterval(() => {
-      this.#syncFlows().catch(err => {
-        console.error('[vision] Stratum poll error:', err.message);
-      });
-    }, 15_000);
+    this.#stopped = false;
+    this.#lastTickAt = Date.now();
+    this.#scheduleNext();
   }
 
-  /** Stop the polling interval. */
+  /** Stop the poll loop. */
   stop() {
+    this.#stopped = true;
     if (this.#pollTimer) {
-      clearInterval(this.#pollTimer);
+      clearTimeout(this.#pollTimer);
       this.#pollTimer = null;
     }
   }
 
+  /** Arm the next tick. No-op once stopped so stop() is final. */
+  #scheduleNext() {
+    if (this.#stopped) return;
+    this.#pollTimer = setTimeout(() => this.#tick(), POLL_MS);
+  }
+
+  /**
+   * One poll tick. Skips the stratum-mcp spawn when nothing is live (lets the
+   * host sleep); on a tick that fired far later than scheduled, notes the
+   * sleep gap before resyncing.
+   */
+  async #tick() {
+    if (this.#stopped) return;
+    const now = Date.now();
+    const gap = now - this.#lastTickAt;
+    this.#lastTickAt = now;
+
+    if (hasLiveFlows(this.#store.items.values())) {
+      if (gap > POLL_MS * WAKE_GAP_FACTOR) {
+        console.log(`[vision] Stratum sync resuming after ${Math.round(gap / 1000)}s gap (host likely slept) — resyncing`);
+      }
+      try {
+        await this.#syncFlows();
+      } catch (err) {
+        console.error('[vision] Stratum poll error:', err.message);
+      }
+    }
+
+    this.#scheduleNext();
+  }
+
   /**
    * Fetch flow summaries via stratum-client (stable contract, not direct file reads).
    * Maps stratum's query output to the shape the sync logic expects.

package/server/vision-routes.js

@@ -42,7 +42,8 @@ function getSchemaValidator() {
 }
 
 import { randomUUID } from 'node:crypto';
-import { getTargetRoot, resolveProjectPath, loadProjectConfig } from './project-root.js';
+import { getTargetRoot, resolveProjectPath } from './project-root.js';
+import { resolveFeaturesPathFromConfig } from '../lib/project-paths.js';
 import { anchorBoundary } from '../lib/checkpoint/checkpoint-writer.js';
 import { appendGateLogEntry, readGateLog, mapResolveOutcomeToSchema } from './gate-log-store.js';
 import { addOpenLoop, resolveOpenLoop, listOpenLoops } from './open-loops-store.js';
@@ -55,6 +56,20 @@ import { requireSensitiveOrPaired as requireSensitiveToken } from './security.js
 
 const PROJECT_ROOT = getTargetRoot();
 
+/**
+ * Read the compose.json config for an ARBITRARY workspace root (not the bound
+ * target). The alternate-root lifecycle branch must resolve `paths.features`
+ * against that root's own config, not the process-global cache
+ * (COMP-PATHS-EXTERNAL, Decision 1 / Codex finding 3).
+ */
+function loadComposeConfig(root) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(root, '.compose', 'compose.json'), 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
 /**
  * Attach vision CRUD and lifecycle REST routes to an Express app.
  *
@@ -167,7 +182,7 @@ export function attachVisionRoutes(app, { store, scheduleBroadcast, broadcastMes
 
   // ── Lifecycle endpoints (simplified — no state machine) ──────────────
   const featuresPath = projectRoot !== PROJECT_ROOT
-    ? path.join(projectRoot, loadProjectConfig().paths?.features || 'docs/features')
+    ? resolveFeaturesPathFromConfig(projectRoot, loadComposeConfig(projectRoot))
     : resolveProjectPath('features');
 
   // Phase graph + SKIPPABLE + TERMINAL are owned by lifecycle-guard.js (single

package/server/vision-server.js

@@ -55,7 +55,8 @@ const SETTINGS_DEFAULTS = {
   policyModes: ['gate', 'flag', 'skip'],
 };
 
-import { getTargetRoot, getDataDir } from './project-root.js';
+import { getTargetRoot, getDataDir, resolveProjectPath } from './project-root.js';
+import { relForDisplay } from '../lib/project-paths.js';
 
 export class VisionServer {
   constructor(store, sessionManager = null, { config } = {}) {
@@ -264,7 +265,7 @@ export class VisionServer {
         const projectsRoot = process.env.CC_PROJECTS_ROOT ||
           path.join(process.env.HOME || process.env.USERPROFILE || '', '.claude', 'projects');
         const sessionsFile = this.sessionManager?.sessionsFile || path.join(getDataDir(), 'sessions.json');
-        const featureRoot = path.join(getTargetRoot(), 'docs', 'features');
+        const featureRoot = resolveProjectPath('features');
 
         const findItemIdByFeatureCode = (fc) => {
           for (const it of this.store.items.values()) {
@@ -457,7 +458,7 @@ export class VisionServer {
   /** Resolve a file path to matching tracker items */
   resolveItems(filePath) {
     const rel = filePath.startsWith(getTargetRoot())
-      ? filePath.slice(getTargetRoot().length + 1)
+      ? relForDisplay(getTargetRoot(), filePath)
       : filePath.replace(/^\.\//, '');
     const matches = [];
     const matchType = new Map();

package/server/vision-store.js

@@ -13,6 +13,7 @@ export const VALID_CONNECTION_TYPES = ['informs', 'blocks', 'supports', 'contrad
 export const VALID_PHASES = ['vision', 'specification', 'planning', 'implementation', 'verification', 'release'];
 
 import { getDataDir as getDefaultDataDir } from './project-root.js';
+import { migrateVisionItemFeatureCode, normalizeGateOutcome } from '../lib/state-migrations.js';
 
 const DATA_FILE = path.join(getDefaultDataDir(), 'vision-state.json');
 
@@ -67,14 +68,8 @@ export class VisionStore {
       let migrated = false;
       if (Array.isArray(data.items)) {
         for (const item of data.items) {
-          // Migration: legacy featureCode → lifecycle.featureCode
-          if (item.featureCode && item.featureCode.startsWith('feature:') && !item.lifecycle?.featureCode) {
-            const bare = item.featureCode.replace(/^feature:/, '');
-            item.lifecycle = item.lifecycle || {};
-            item.lifecycle.featureCode = bare;
-            delete item.featureCode;
-            migrated = true;
-          }
+          // Migration: legacy featureCode → lifecycle.featureCode (shared impl)
+          if (migrateVisionItemFeatureCode(item).changed) migrated = true;
           if (!item.slug && item.title) item.slug = slugify(item.title);
           if (!item.files) item.files = [];
           // Group precedence (most-authoritative first):
@@ -110,10 +105,10 @@ export class VisionStore {
             if (seenPendingKeys.has(key)) { migrated = true; continue; }
             seenPendingKeys.add(key);
           }
-          // Migration: normalize legacy gate outcomes
+          // Migration: normalize legacy gate outcomes (shared impl)
           if (gate.outcome) {
-            const map = { approved: 'approve', killed: 'kill', revised: 'revise' };
-            if (map[gate.outcome]) { gate.outcome = map[gate.outcome]; migrated = true; }
+            const normalized = normalizeGateOutcome(gate.outcome);
+            if (normalized !== gate.outcome) { gate.outcome = normalized; migrated = true; }
           }
           this.gates.set(gate.id, gate);
         }

package/server/vision-utils.js

@@ -10,10 +10,25 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { getTargetRoot, loadProjectConfig } from './project-root.js';
+import { getTargetRoot } from './project-root.js';
+import { resolveJournalPathFromConfig, relForDisplay } from '../lib/project-paths.js';
 
 const PROJECT_ROOT = getTargetRoot();
 
+/**
+ * Read the compose.json config for an ARBITRARY workspace root (not the bound
+ * target). Routes/agents that serve an alternate `projectRoot` must resolve
+ * artifact paths against that root's own config, not the process-global cache
+ * (COMP-PATHS-EXTERNAL, Decision 1 / Codex finding 3).
+ */
+function loadComposeConfig(root) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(root, '.compose', 'compose.json'), 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Error detection
 // ---------------------------------------------------------------------------
@@ -71,8 +86,12 @@ export function detectError(tool, input, responseText) {
  * @param {string} [projectRoot] — defaults to PROJECT_ROOT
  */
 export function spawnJournalAgent(session, transcriptPath, projectRoot = PROJECT_ROOT) {
-  const config = loadProjectConfig();
-  const journalRel = config.paths?.journal || 'docs/journal';
+  // Resolve the journal path against the PASSED projectRoot's own config — not
+  // the process-global cached config of the bound target (COMP-PATHS-EXTERNAL).
+  const journalAbs = resolveJournalPathFromConfig(projectRoot, loadComposeConfig(projectRoot));
+  // Display path for the agent prompt: clean relative when in-root (the agent
+  // runs with cwd: projectRoot), absolute when the journal escapes the root.
+  const journalRel = relForDisplay(projectRoot, journalAbs);
 
   const itemSummaries = Object.entries(session.items || {})
     .map(([_id, data]) => `- ${data.title}: ${data.writes} writes, ${data.reads} reads. ${(data.summaries || []).map(s => s.summary || '').filter(Boolean).join('. ')}`)
@@ -88,7 +107,7 @@ export function spawnJournalAgent(session, transcriptPath, projectRoot = PROJECT
   const today = new Date().toISOString().slice(0, 10);
   let sessionNum = 0;
   try {
-    const entries = fs.readdirSync(path.join(projectRoot, journalRel));
+    const entries = fs.readdirSync(journalAbs);
     for (const f of entries) {
       const m = f.match(new RegExp(`^${today}-session-(\\d+)`));
       if (m) sessionNum = Math.max(sessionNum, parseInt(m[1]) + 1);

package/dist/assets/channel-Dh96pu1k.js

@@ -1 +0,0 @@
-import{ai as o,aj as n}from"./App-D7E7S49Q.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/dist/assets/classDiagram-4FO5ZUOK-BCqpDcaS.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-727SXJPM-zvXhT6iZ.js";import{_ as i}from"./App-D7E7S49Q.js";import"./chunk-FMBD7UC4-DlhrqkBp.js";import"./chunk-ND2GUHAM-lo_8kNzw.js";import"./chunk-55IACEB6-uUk1WzZ1.js";import"./chunk-2J33WTMH-b8Rdk4S-.js";import"./mobile-DwmxS_O4.js";import"./index-DNuHtZwR.js";import"./graph-BBXaecIU.js";var b={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{b as diagram};

package/dist/assets/classDiagram-v2-Q7XG4LA2-BCqpDcaS.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-727SXJPM-zvXhT6iZ.js";import{_ as i}from"./App-D7E7S49Q.js";import"./chunk-FMBD7UC4-DlhrqkBp.js";import"./chunk-ND2GUHAM-lo_8kNzw.js";import"./chunk-55IACEB6-uUk1WzZ1.js";import"./chunk-2J33WTMH-b8Rdk4S-.js";import"./mobile-DwmxS_O4.js";import"./index-DNuHtZwR.js";import"./graph-BBXaecIU.js";var b={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{b as diagram};