noteconnection 1.7.0 → 1.9.0

package/dist/src/lfs.asset.policy.contract.test.js

@@ -0,0 +1,153 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+describe('LFS asset policy contracts', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const packageJsonPath = path.join(repoRoot, 'package.json');
+    const gitattributesPath = path.join(repoRoot, '.gitattributes');
+    const deadNodeSidecarPath = path.join(repoRoot, 'src-tauri', 'bin', 'node-x86_64-pc-windows-msvc.exe');
+    const deadGraphPayloadPaths = [
+        path.join(repoRoot, 'src', 'frontend', 'data.js'),
+        path.join(repoRoot, 'src', 'frontend', 'graph_data.json'),
+    ];
+    const policyUtilsPath = path.join(repoRoot, 'scripts', 'lfs-asset-policy-utils.js');
+    let policyUtils;
+    function readJson(filePath) {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    beforeAll(() => {
+        policyUtils = require(policyUtilsPath);
+    });
+    test('repository head no longer keeps removed LFS residues for dead node sidecar or bundled graph payloads', () => {
+        const gitattributes = fs.readFileSync(gitattributesPath, 'utf8');
+        expect(gitattributes).not.toContain('src-tauri/bin/node-x86_64-pc-windows-msvc.exe');
+        expect(gitattributes).not.toContain('src/frontend/data.js');
+        expect(gitattributes).not.toContain('src/frontend/graph_data.json');
+        expect(fs.existsSync(deadNodeSidecarPath)).toBe(false);
+        deadGraphPayloadPaths.forEach((filePath) => {
+            expect(fs.existsSync(filePath)).toBe(false);
+        });
+    });
+    test('unexpected-only mode tolerates current legacy protected entries while keeping protected roots explicit', () => {
+        const result = policyUtils.evaluateLfsAssetPolicy({
+            gitattributesText: [
+                'src-tauri/bin/server-x86_64-pc-windows-msvc.exe filter=lfs diff=lfs merge=lfs -text',
+                'src-tauri/bin/server-x86_64-unknown-linux-gnu filter=lfs diff=lfs merge=lfs -text',
+                'src-tauri/bin/server-aarch64-apple-darwin filter=lfs diff=lfs merge=lfs -text',
+                'src-tauri/bin/godot-x86_64-pc-windows-msvc.exe filter=lfs diff=lfs merge=lfs -text',
+                'assets/demo-large.zip filter=lfs diff=lfs merge=lfs -text',
+            ].join('\n'),
+            lfsLsFilesText: [
+                'bbbbbbbbbb - src-tauri/bin/server-x86_64-unknown-linux-gnu',
+            ].join('\n'),
+            mode: 'unexpected-only',
+        });
+        expect(policyUtils.PROTECTED_LFS_ROOTS).toEqual(['src/frontend/', 'src-tauri/bin/']);
+        expect(result.unexpectedProtectedPaths).toEqual([]);
+        expect(result.legacyProtectedPaths).toEqual([
+            'src-tauri/bin/godot-x86_64-pc-windows-msvc.exe',
+            'src-tauri/bin/server-aarch64-apple-darwin',
+            'src-tauri/bin/server-x86_64-pc-windows-msvc.exe',
+            'src-tauri/bin/server-x86_64-unknown-linux-gnu',
+        ]);
+    });
+    test('unexpected-only mode flags new protected LFS paths outside the approved legacy allowlist', () => {
+        const result = policyUtils.evaluateLfsAssetPolicy({
+            gitattributesText: [
+                'src-tauri/bin/new-helper.exe filter=lfs diff=lfs merge=lfs -text',
+            ].join('\n'),
+            mode: 'unexpected-only',
+        });
+        expect(result.unexpectedProtectedPaths).toEqual(['src-tauri/bin/new-helper.exe']);
+    });
+    test('unexpected-only mode now treats bundled graph payload LFS paths as drift to be removed', () => {
+        const result = policyUtils.evaluateLfsAssetPolicy({
+            gitattributesText: [
+                'src/frontend/data.js filter=lfs diff=lfs merge=lfs -text',
+                'src/frontend/graph_data.json filter=lfs diff=lfs merge=lfs -text',
+            ].join('\n'),
+            mode: 'unexpected-only',
+        });
+        expect(result.unexpectedProtectedPaths).toEqual([
+            'src/frontend/data.js',
+            'src/frontend/graph_data.json',
+        ]);
+    });
+    test('deleted working-tree residues listed by git lfs ls-files are ignored once the rule and file are gone', () => {
+        const result = policyUtils.evaluateLfsAssetPolicy({
+            gitattributesText: '',
+            lfsLsFilesText: 'aaaaaaaaaa - src-tauri/bin/node-x86_64-pc-windows-msvc.exe',
+            existingRepoPaths: [],
+            mode: 'unexpected-only',
+        });
+        expect(result.protectedTrackedPaths).toEqual([]);
+        expect(result.unexpectedProtectedPaths).toEqual([]);
+    });
+    test('strict mode is ready for the future no-LFS end state', () => {
+        const result = policyUtils.evaluateLfsAssetPolicy({
+            gitattributesText: 'src/frontend/data.js filter=lfs diff=lfs merge=lfs -text',
+            mode: 'strict',
+        });
+        expect(result.strictViolations).toEqual(['src/frontend/data.js']);
+    });
+    test('package scripts expose local policy verification and future strict mode', () => {
+        const packageJson = readJson(packageJsonPath);
+        const scripts = packageJson.scripts || {};
+        expect(scripts['verify:lfs:policy']).toBe('node scripts/verify-lfs-asset-policy.js');
+        expect(scripts['verify:lfs:policy:strict']).toBe('node scripts/verify-lfs-asset-policy.js --strict');
+    });
+    test('legacy allowlist no longer preserves the unused node sidecar path', () => {
+        expect(policyUtils.LEGACY_ALLOWED_PROTECTED_LFS_PATHS).not.toContain('src-tauri/bin/node-x86_64-pc-windows-msvc.exe');
+        expect(policyUtils.LEGACY_ALLOWED_PROTECTED_LFS_PATHS).not.toContain('src/frontend/data.js');
+        expect(policyUtils.LEGACY_ALLOWED_PROTECTED_LFS_PATHS).not.toContain('src/frontend/graph_data.json');
+    });
+    test('current legacy LFS scope is limited to desktop binary placeholders rather than markdown-worker or bridge source', () => {
+        const gitattributes = fs.readFileSync(gitattributesPath, 'utf8');
+        const tracked = policyUtils.evaluateLfsAssetPolicy({
+            gitattributesText: gitattributes,
+            mode: 'unexpected-only',
+        });
+        expect(tracked.legacyProtectedPaths).toEqual([
+            'src-tauri/bin/godot-x86_64-pc-windows-msvc.exe',
+            'src-tauri/bin/server-aarch64-apple-darwin',
+            'src-tauri/bin/server-x86_64-pc-windows-msvc.exe',
+            'src-tauri/bin/server-x86_64-unknown-linux-gnu',
+        ]);
+        expect(gitattributes).not.toContain('src-tauri/bin/markdown-worker');
+        expect(gitattributes).not.toContain('src/core/PathBridge.ts');
+    });
+});

package/dist/src/license.policy.contract.test.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function readJson(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+describe('license policy contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const packageJsonPath = path.join(repoRoot, 'package.json');
+    const tauriCargoTomlPath = path.join(repoRoot, 'src-tauri', 'Cargo.toml');
+    const licensePath = path.join(repoRoot, 'LICENSE');
+    const readmePath = path.join(repoRoot, 'README.md');
+    const chineseReadmePath = path.join(repoRoot, 'README_zh.md');
+    test('root package manifest is pinned to GPL-3.0-only', () => {
+        const pkg = readJson(packageJsonPath);
+        expect(pkg.license).toBe('GPL-3.0-only');
+    });
+    test('tauri crate manifest is pinned to GPL-3.0-only', () => {
+        const cargoToml = fs.readFileSync(tauriCargoTomlPath, 'utf8');
+        expect(cargoToml).toContain('license = "GPL-3.0-only"');
+    });
+    test('repository license artifact ships GNU GPL v3 text', () => {
+        const license = fs.readFileSync(licensePath, 'utf8');
+        expect(license).toContain('GNU GENERAL PUBLIC LICENSE');
+        expect(license).toContain('Version 3, 29 June 2007');
+    });
+    test('README license sections advertise GPL-3.0-only in both locales', () => {
+        const readme = fs.readFileSync(readmePath, 'utf8');
+        const chineseReadme = fs.readFileSync(chineseReadmePath, 'utf8');
+        expect(readme).toContain('## License');
+        expect(readme).toContain('GNU General Public License v3.0');
+        expect(readme).toContain('GPL-3.0-only');
+        expect(chineseReadme).toContain('## 开源许可');
+        expect(chineseReadme).toContain('GNU General Public License v3.0');
+        expect(chineseReadme).toContain('GPL-3.0-only');
+    });
+});

package/dist/src/markdown/MarkdownGateway.js

@@ -697,6 +697,10 @@ class MarkdownGateway {
             candidates.push(path.join(path.dirname(process.execPath), binaryName));
             candidates.push(path.join(path.dirname(process.execPath), '..', 'Resources', binaryName));
         }
+        // Tauri removes the target triple from installed external binary names.
+        const installedBinaryName = process.platform === 'win32' ? 'markdown-worker.exe' : 'markdown-worker';
+        candidates.push(path.join(path.dirname(process.execPath), installedBinaryName));
+        candidates.push(path.join(path.dirname(process.execPath), '..', 'Resources', installedBinaryName));
         for (const candidate of candidates) {
             try {
                 if (!candidate) {

package/dist/src/markdown/MarkdownGateway.test.js

@@ -37,6 +37,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const MarkdownGateway_1 = require("./MarkdownGateway");
+const { resolveHostMarkdownWorkerBinaryName } = require('../../scripts/tauri-sidecar-utils');
 class TempDir {
     constructor(prefix) {
         this.path = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), `${prefix}-`));
@@ -192,4 +193,62 @@ describe('MarkdownGateway', () => {
             }
         }
     });
+    const testUnix = process.platform === 'win32' ? test.skip : test;
+    testUnix.each(['beside-server', 'Resources', 'explicit-override', 'build-filename'])('buildIndex discovers the %s worker and preserves lookup priority', async (location) => {
+        const installedDirectory = ctx.temp.mkdir('installed/bin');
+        const originalExecPath = process.execPath;
+        const originalWorkerPath = process.env.NOTE_CONNECTION_MARKDOWN_WORKER_PATH;
+        const writeWorker = (workerPath, anchorId) => {
+            fs.mkdirSync(path.dirname(workerPath), { recursive: true });
+            fs.writeFileSync(workerPath, `#!/usr/bin/env node
+const fs = require('fs');
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  const request = JSON.parse(input);
+  if (request.kind !== 'build_index') process.exit(1);
+  const content = fs.readFileSync(request.filePath);
+  const block = { id: 0, type: 'heading', startByte: 0, endByte: content.length, startLine: 1, endLine: 1, anchorId: ${JSON.stringify(anchorId)} };
+  process.stdout.write(JSON.stringify({ ok: true, index: { totalBytes: content.length, totalLines: 1, blocks: [block], anchors: [], wikiLinks: [] } }));
+});
+`, { mode: 0o755 });
+        };
+        try {
+            process.execPath = path.join(installedDirectory, 'server');
+            delete process.env.NOTE_CONNECTION_MARKDOWN_WORKER_PATH;
+            const installedWorker = location === 'Resources'
+                ? path.join(installedDirectory, '..', 'Resources', 'markdown-worker')
+                : path.join(installedDirectory, 'markdown-worker');
+            writeWorker(installedWorker, 'installed-worker');
+            if (location === 'explicit-override' || location === 'build-filename') {
+                writeWorker(path.join(ctx.projectRoot, 'src-tauri', 'bin', resolveHostMarkdownWorkerBinaryName()), 'build-worker');
+            }
+            if (location === 'explicit-override') {
+                const explicitWorker = path.join(ctx.temp.path, 'explicit-worker');
+                writeWorker(explicitWorker, 'explicit-worker');
+                process.env.NOTE_CONNECTION_MARKDOWN_WORKER_PATH = explicitWorker;
+            }
+            const filePath = ctx.temp.file(path.join('project', 'Knowledge_Base', 'installed.md'), '# Installed markdown worker');
+            const index = await ctx.gateway.buildIndex({ filePath }, {
+                markdownEngine: 'pulldown',
+                chunkBlockSize: 8,
+                prefetchBlocks: 2,
+                indexCacheTtlSec: 1800,
+                maxDocBytes: 32 * 1024 * 1024,
+            });
+            expect(index.engine).toBe('pulldown');
+            expect(index.fallbackReason).toBeUndefined();
+            const chunk = await ctx.gateway.getChunk({ indexId: index.indexId, startBlock: 0, blockCount: 1 });
+            const expectedAnchor = location === 'explicit-override' ? 'explicit-worker'
+                : location === 'build-filename' ? 'build-worker' : 'installed-worker';
+            expect(chunk.blocks[0].anchorId).toBe(expectedAnchor);
+        }
+        finally {
+            process.execPath = originalExecPath;
+            if (originalWorkerPath === undefined)
+                delete process.env.NOTE_CONNECTION_MARKDOWN_WORKER_PATH;
+            else
+                process.env.NOTE_CONNECTION_MARKDOWN_WORKER_PATH = originalWorkerPath;
+        }
+    });
 });

package/dist/src/memory/MemoryGovernance.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeGovernedMemoryType = normalizeGovernedMemoryType;
+exports.normalizeGovernedMemoryPurpose = normalizeGovernedMemoryPurpose;
+exports.classifyMemoryEntry = classifyMemoryEntry;
+exports.computeGovernedMemoryWeight = computeGovernedMemoryWeight;
+exports.buildMemoryAuditRecord = buildMemoryAuditRecord;
+function normalizeGovernedMemoryType(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (normalized === 'study' || normalized === 'note' || normalized === 'system') {
+        return normalized;
+    }
+    return 'fact';
+}
+function normalizeGovernedMemoryPurpose(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (normalized === 'internalized' || normalized === 'supplementary' || normalized === 'systemic') {
+        return normalized;
+    }
+    return 'memorized';
+}
+function classifyMemoryEntry(entry) {
+    const tags = Array.isArray(entry.tags) ? entry.tags.map((tag) => String(tag || '').trim().toLowerCase()) : [];
+    const rawText = `${entry.key} ${entry.value} ${tags.join(' ')}`.toLowerCase();
+    const memoryType = normalizeGovernedMemoryType(entry.memoryType
+        || (tags.includes('study') || rawText.includes('quiz') || rawText.includes('review') ? 'study'
+            : tags.includes('note') || rawText.includes('note') ? 'note'
+                : tags.includes('system') ? 'system'
+                    : 'fact'));
+    const memoryPurpose = normalizeGovernedMemoryPurpose(entry.memoryPurpose
+        || (memoryType === 'study' ? 'internalized'
+            : memoryType === 'system' ? 'systemic'
+                : memoryType === 'note' ? 'supplementary'
+                    : 'memorized'));
+    return {
+        memoryType,
+        memoryPurpose,
+        classificationConfidence: Math.max(0.45, Math.min(0.98, Number(entry.confidence || 0.72))),
+    };
+}
+function computeGovernedMemoryWeight(entry) {
+    const { memoryType, memoryPurpose } = classifyMemoryEntry(entry);
+    const typeWeight = memoryType === 'study'
+        ? 1.25
+        : memoryType === 'note'
+            ? 1.1
+            : memoryType === 'system'
+                ? 0.7
+                : 1;
+    const purposeWeight = memoryPurpose === 'internalized'
+        ? 1.35
+        : memoryPurpose === 'supplementary'
+            ? 0.92
+            : memoryPurpose === 'systemic'
+                ? 0.75
+                : 1;
+    return Number((typeWeight * purposeWeight).toFixed(4));
+}
+function buildMemoryAuditRecord(nextId, params) {
+    const classification = classifyMemoryEntry(params.entry);
+    return {
+        auditId: nextId('memory_audit'),
+        userId: params.userId,
+        operation: params.operation,
+        layer: params.layer,
+        memoryKey: params.entry.key,
+        memoryType: classification.memoryType,
+        memoryPurpose: classification.memoryPurpose,
+        reason: params.reason,
+        scopeWorkspaceId: params.scopeWorkspaceId || null,
+        scopeCorpusId: params.scopeCorpusId || null,
+        recordedAt: params.recordedAt,
+    };
+}

package/dist/src/memory/MemoryGovernance.test.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MemoryGovernance_1 = require("./MemoryGovernance");
+describe('MemoryGovernance', () => {
+    test('classifies study memories and raises their retrieval weight', () => {
+        const entry = {
+            key: 'quiz_note',
+            value: 'Review this quiz correction before the next session.',
+            tags: ['study', 'review'],
+            confidence: 0.84,
+            references: ['atom_1'],
+            createdAt: '2026-05-26T00:00:00.000Z',
+            updatedAt: '2026-05-26T00:00:00.000Z',
+        };
+        const classification = (0, MemoryGovernance_1.classifyMemoryEntry)(entry);
+        expect(classification.memoryType).toBe('study');
+        expect(classification.memoryPurpose).toBe('internalized');
+        expect((0, MemoryGovernance_1.computeGovernedMemoryWeight)(entry)).toBeGreaterThan(1);
+    });
+    test('builds audit records with explicit scope fields', () => {
+        const entry = {
+            key: 'memory_1',
+            value: 'Scoped note',
+            tags: ['note'],
+            confidence: 0.7,
+            references: [],
+            scopeWorkspaceId: 'optics',
+            scopeCorpusId: 'optics',
+            createdAt: '2026-05-26T00:00:00.000Z',
+            updatedAt: '2026-05-26T00:00:00.000Z',
+        };
+        const audit = (0, MemoryGovernance_1.buildMemoryAuditRecord)((prefix = 'memory_audit') => `${prefix}_1`, {
+            userId: 'user_a',
+            operation: 'write',
+            layer: 'session',
+            entry,
+            reason: 'test',
+            scopeWorkspaceId: 'optics',
+            scopeCorpusId: 'optics',
+            recordedAt: '2026-05-26T00:01:00.000Z',
+        });
+        expect(audit.scopeWorkspaceId).toBe('optics');
+        expect(audit.scopeCorpusId).toBe('optics');
+        expect(audit.memoryKey).toBe('memory_1');
+    });
+});

package/dist/src/memory/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/mermaid.frontend.guard.contract.test.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+describe('mermaid frontend guard contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const appPath = path.join(repoRoot, 'src', 'frontend', 'app.js');
+    const readerPath = path.join(repoRoot, 'src', 'frontend', 'reader.js');
+    const stylesPath = path.join(repoRoot, 'src', 'frontend', 'styles.css');
+    test('installs a global Mermaid artifact suppression observer for leaked error SVGs', () => {
+        const source = fs.readFileSync(appPath, 'utf8');
+        expect(source).toContain('function suppressMermaidErrorArtifacts(root, context = {})');
+        expect(source).toContain('function installMermaidErrorArtifactObserver()');
+        expect(source).toContain('function installMermaidRuntimeGuards()');
+        expect(source).toContain('function exposeMermaidDebugInterface()');
+        expect(source).toContain('installMermaidErrorArtifactObserver();');
+        expect(source).toContain("normalized.includes('syntax error in text')");
+        expect(source).toContain("normalized.includes('mermaid version')");
+        expect(source).toContain('captureRuntimeState: () => ({');
+        expect(source).toContain('function isProtectedMermaidSuppressionHost(host)');
+        expect(source).toContain('root !== document.body');
+        expect(source).toContain("host.id === 'reading-body'");
+    });
+    test('reader mermaid suppression never selects the page root as a removable host', () => {
+        const source = fs.readFileSync(readerPath, 'utf8');
+        expect(source).toContain('isProtectedMermaidSuppressionHost(host)');
+        expect(source).toContain('root !== document.body');
+        expect(source).toContain("host.id === 'graph-wrapper'");
+        expect(source).toContain('Reader Mermaid offscreen host mount root is unavailable.');
+        expect(source).toContain('ensureReaderStructure()');
+        expect(source).toContain("replacementBody.id = 'reading-body'");
+        expect(source).toContain('this.contentBox.appendChild(replacementBody);');
+        expect(source).toContain('lookupNodeDataById(nodeId)');
+        expect(source).toContain("typeof graphData !== 'undefined'");
+        expect(source).toContain('isReaderBodyVisiblyEmpty()');
+        expect(source).toContain('Markdown protocol path completed without visible content. Falling back to raw markdown render.');
+    });
+    test('ships compact inline and toast styles for suppressed Mermaid errors', () => {
+        const source = fs.readFileSync(stylesPath, 'utf8');
+        expect(source).toContain('.mermaid-inline-guard');
+        expect(source).toContain('.mermaid-error-toast-stack');
+        expect(source).toContain('.mermaid-error-toast');
+    });
+});

package/dist/src/middleware/SseResponseWriter.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SseResponseWriter = void 0;
+/** Owns backpressure and the single terminal outcome of one HTTP event stream. */
+class SseResponseWriter {
+    constructor(destination, policy = {
+        maxBufferedBytes: 64 * 1024 * 1024 + 256 * 1024,
+        drainTimeoutMs: 15000,
+    }) {
+        this.destination = destination;
+        this.policy = policy;
+        this.pending = [];
+        this.queuedBytes = 0;
+        this.blocked = false;
+        this.finishing = false;
+        this.finished = false;
+        this.onDrain = () => {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+            this.blocked = false;
+            try {
+                while (this.pending.length && !this.blocked && !this.failure) {
+                    const frame = this.pending.shift();
+                    this.queuedBytes -= Buffer.byteLength(frame);
+                    this.send(frame);
+                }
+                if (this.finishing && !this.blocked && !this.failure)
+                    this.destination.end();
+            }
+            catch (error) {
+                this.fail(error instanceof Error ? error : new Error(String(error)));
+            }
+        };
+        this.onError = (error) => { this.fail(error); };
+        this.onClose = () => {
+            if (!this.finished)
+                this.fail(new Error('sse_closed'));
+            this.cleanup();
+        };
+        this.onFinish = () => {
+            if (this.failure)
+                return;
+            this.finished = true;
+            this.cleanup();
+            this.resolveCompletion?.();
+        };
+        if (!Number.isFinite(policy.maxBufferedBytes) || policy.maxBufferedBytes < 1
+            || !Number.isFinite(policy.drainTimeoutMs) || policy.drainTimeoutMs < 1)
+            throw new TypeError('Invalid SSE delivery policy');
+        destination.on('drain', this.onDrain);
+        destination.on('error', this.onError);
+        destination.once('close', this.onClose);
+        destination.once('finish', this.onFinish);
+    }
+    get pendingBytes() { return this.failure || this.finished ? 0 : this.queuedBytes + this.destination.writableLength; }
+    write(frame) {
+        if (this.failure)
+            throw this.failure;
+        if (this.finishing || this.finished || this.destination.destroyed || this.destination.writableEnded)
+            throw new Error('sse_closed');
+        const bytes = Buffer.byteLength(frame);
+        if (this.pending.length >= 128 || this.pendingBytes + bytes > this.policy.maxBufferedBytes) {
+            this.fail(new Error('sse_buffer_limit'));
+            throw this.failure;
+        }
+        if (this.blocked) {
+            this.pending.push(frame);
+            this.queuedBytes += bytes;
+            return;
+        }
+        this.send(frame);
+    }
+    finish() {
+        if (this.failure)
+            return Promise.reject(this.failure);
+        if (this.finished)
+            return Promise.resolve();
+        if (this.completion)
+            return this.completion;
+        this.finishing = true;
+        this.completion = new Promise((resolve, reject) => {
+            this.resolveCompletion = resolve;
+            this.rejectCompletion = reject;
+        });
+        if (!this.blocked && this.pending.length === 0)
+            this.destination.end();
+        return this.completion;
+    }
+    send(frame) {
+        try {
+            if (!this.destination.write(frame)) {
+                this.blocked = true;
+                this.timer = setTimeout(() => this.fail(new Error('sse_drain_timeout')), this.policy.drainTimeoutMs);
+                this.timer.unref();
+            }
+        }
+        catch (error) {
+            this.fail(error instanceof Error ? error : new Error(String(error)));
+            throw this.failure;
+        }
+    }
+    fail(error) {
+        if (this.failure || this.finished)
+            return;
+        this.failure = error;
+        this.pending.length = 0;
+        this.queuedBytes = 0;
+        clearTimeout(this.timer);
+        this.destination.removeListener('drain', this.onDrain);
+        this.rejectCompletion?.(error);
+        // Preserve the error for finish(); destroy without an unhandled second error event.
+        this.destination.destroy();
+    }
+    cleanup() {
+        clearTimeout(this.timer);
+        this.destination.removeListener('drain', this.onDrain);
+        this.destination.removeListener('error', this.onError);
+        this.destination.removeListener('close', this.onClose);
+        this.destination.removeListener('finish', this.onFinish);
+    }
+}
+exports.SseResponseWriter = SseResponseWriter;