noteconnection 1.8.0 → 1.9.0

package/dist/src/routes/registry.contract.test.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * Verifies the modular route registration and dispatch infrastructure.
  */
 const index_1 = require("./index");
+const constants_1 = require("../notemd/constants");
 function createMockContext() {
     const scheduleKnowledgeLearningPlatformWarmup = jest.fn();
     return {
@@ -20,7 +21,9 @@ function createMockContext() {
         tutorRouter: { getDiagnosticsSummary: () => ({}) },
         memoryPolicyManager: { getDiagnosticsSummary: () => ({}) },
         notemdService: {},
-        loadNotemdSettings: async () => ({}),
+        loadNotemdSettings: async () => structuredClone(constants_1.DEFAULT_SETTINGS),
+        persistNotemdSettings: async () => structuredClone(constants_1.DEFAULT_SETTINGS),
+        notemdHttp: {},
         LOOPBACK_HOST: '127.0.0.1',
         finalPort: 3000,
         KNOWLEDGE_GRAPH_STORE_BACKEND: 'file',
@@ -68,7 +71,7 @@ describe('Route Registry', () => {
     });
     test('render routes are registered', () => {
         const renderRoutes = routes.filter(r => r.path.startsWith('/api/render') || r.path.startsWith('/api/clipboard'));
-        expect(renderRoutes.length).toBeGreaterThanOrEqual(4);
+        expect(renderRoutes.map(route => route.path).sort()).toEqual(['/api/render/math', '/api/render/mermaid']);
     });
     test('no duplicate method+path combinations', () => {
         const seen = new Set();

package/dist/src/routes/registry.shadow.contract.test.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+describe('route registry shadow parity gate', () => {
+    const repoRoot = node_path_1.default.resolve(__dirname, '..', '..');
+    const serverSource = node_fs_1.default.readFileSync(node_path_1.default.join(repoRoot, 'src', 'server.ts'), 'utf8');
+    const packageJson = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(repoRoot, 'package.json'), 'utf8'));
+    test('supports an explicit legacy mode without changing the default registry mode', () => {
+        expect(serverSource.includes('NOTE_CONNECTION_ROUTE_DISPATCH_MODE')).toBe(true);
+        expect(serverSource.includes("ROUTE_DISPATCH_MODE === 'registry'")).toBe(true);
+        expect(serverSource.includes("registeredRoute && (USE_REGISTRY_DISPATCH || requestPath.startsWith('/api/notemd/'))")).toBe(true);
+        expect(/(?:get|post)Pathname === '\/api\/notemd\//.test(serverSource)).toBe(false);
+    });
+    test('ships an executable parity harness as a release gate', () => {
+        expect(packageJson.scripts?.['verify:route:shadow']).toBe('npm run build:mini && node scripts/verify-route-registry-shadow.js');
+        expect(node_fs_1.default.existsSync(node_path_1.default.join(repoRoot, 'scripts', 'verify-route-registry-shadow.js'))).toBe(true);
+    });
+});

package/dist/src/routes/render.js

@@ -34,6 +34,15 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerRenderRoutes = registerRenderRoutes;
+const isPngBuffer = (value) => value.length >= 8
+    && value[0] === 0x89
+    && value[1] === 0x50
+    && value[2] === 0x4e
+    && value[3] === 0x47
+    && value[4] === 0x0d
+    && value[5] === 0x0a
+    && value[6] === 0x1a
+    && value[7] === 0x0a;
 const CrashLogger_1 = require("../backend/utils/CrashLogger");
 const RenderMaterializer_1 = require("../platform/RenderMaterializer");
 function normalizeMermaidRendererPreference(value) {
@@ -155,7 +164,10 @@ function registerRenderRoutes(ctx) {
                         ? payload.expression
                         : (typeof payload?.source === 'string' ? payload.source : '');
                     if (!expression.trim()) {
-                        json(res, 400, { success: false, error: 'Missing expression' });
+                        const hasExpressionField = Object.prototype.hasOwnProperty.call(payload || {}, 'expression');
+                        json(res, 400, hasExpressionField
+                            ? { success: false, error: 'Missing expression' }
+                            : { error: 'Missing source' });
                         return;
                     }
                     const { renderMathPng } = await Promise.resolve().then(() => __importStar(require('../reader_renderer')));
@@ -194,7 +206,7 @@ function registerRenderRoutes(ctx) {
                         ? payload.source
                         : (typeof payload?.diagram === 'string' ? payload.diagram : '');
                     if (!source.trim()) {
-                        json(res, 400, { success: false, error: 'Missing source' });
+                        json(res, 400, { error: 'Missing source' });
                         return;
                     }
                     const includeStages = payload?.includeStages === true;
@@ -232,54 +244,5 @@ function registerRenderRoutes(ctx) {
                 }
             },
         },
-        {
-            method: 'POST',
-            path: '/api/render/graphviz',
-            handler: async (req, res) => {
-                try {
-                    const body = await readBody(req);
-                    json(res, 200, { success: true, message: 'graphviz render route' });
-                }
-                catch (e) {
-                    fail(res, e, 'POST /api/render/graphviz');
-                }
-            },
-        },
-        {
-            method: 'POST',
-            path: '/api/clipboard/image',
-            handler: async (req, res) => {
-                try {
-                    const body = await readBody(req);
-                    const { pngBase64 } = JSON.parse(body);
-                    const { copyPngToClipboard } = await Promise.resolve().then(() => __importStar(require('../native_clipboard')));
-                    await copyPngToClipboard(Buffer.from(pngBase64 || '', 'base64'));
-                    json(res, 200, { success: true });
-                }
-                catch (e) {
-                    fail(res, e, 'POST /api/clipboard/image');
-                }
-            },
-        },
-        {
-            method: 'POST',
-            path: '/api/clipboard/image-binary',
-            handler: async (req, res) => {
-                try {
-                    const chunks = [];
-                    req.on('data', (c) => chunks.push(c));
-                    await new Promise((resolve, reject) => {
-                        req.on('end', resolve);
-                        req.on('error', reject);
-                    });
-                    const { copyPngToClipboard } = await Promise.resolve().then(() => __importStar(require('../native_clipboard')));
-                    await copyPngToClipboard(Buffer.concat(chunks));
-                    json(res, 200, { success: true });
-                }
-                catch (e) {
-                    fail(res, e, 'POST /api/clipboard/image-binary');
-                }
-            },
-        },
     ];
 }

package/dist/src/runtime.capabilities.test.js

@@ -56,6 +56,11 @@ describe('runtime capability gating contract', () => {
         expect(sourceManager).toContain('supports_mobile_wasm_compute');
         expect(sourceManager).toContain('mobile_wasm_reason');
         expect(sourceManager).toContain('detectMobileWasmCapability');
+        expect(sourceManager).toContain('storage_requested_provider');
+        expect(sourceManager).toContain('storage_resolved_provider');
+        expect(sourceManager).toContain('storage_fallback_reason');
+        expect(sourceManager).toContain('supports_sqlite');
+        expect(sourceManager).toContain('refreshStorageResolution');
     });
     test('source manager blocks build path when runtime does not support build', () => {
         const sourceManager = fs.readFileSync(sourceManagerPath, 'utf8');
@@ -76,18 +81,29 @@ describe('runtime capability gating contract', () => {
         expect(reader).toContain('supports_content_api');
         expect(reader).toContain("window.i18n.t('source.error.contentUnavailableMobile')");
     });
-    test('rust runtime capabilities command is registered and has android-safe defaults', () => {
+    test('rust runtime capabilities command is registered and keeps Godot Pathmode opt-in', () => {
         const tauriLib = fs.readFileSync(tauriLibPath, 'utf8');
         expect(tauriLib).toContain('fn get_runtime_capabilities()');
         expect(tauriLib).toContain('get_runtime_capabilities,');
         expect(tauriLib).toContain('choose_kb_path,');
+        expect(tauriLib).toContain('request_kb_path_change,');
+        expect(tauriLib).toContain('poll_kb_path_change,');
         expect(tauriLib).toContain('reset_kb_path,');
         expect(tauriLib).toContain('open_native_pathmode,');
         expect(tauriLib).toContain('build_graph_runtime,');
         expect(tauriLib).toContain('supports_sidecar: false');
         expect(tauriLib).toContain('supports_build: true');
         expect(tauriLib).toContain('supports_content_api: true');
-        expect(tauriLib).toContain('supports_native_pathmode: true');
+        expect(tauriLib).toContain('supports_kb_import: true');
+        expect(tauriLib).toContain('kb_import_mode: "android-saf-copy"');
+        expect(tauriLib).toContain('supports_projection_store: true');
+        expect(tauriLib).toContain('storage_requested_provider: "projection".to_string()');
+        expect(tauriLib).toContain('storage_resolved_provider: "projection".to_string()');
+        expect(tauriLib).toContain('storage_requested_provider: "sqlite".to_string()');
+        expect(tauriLib).toContain('storage_resolved_provider: "unknown".to_string()');
+        expect(tauriLib).toContain('supports_sqlite: false');
+        expect(tauriLib).toContain('supports_sqlite: true');
+        expect(tauriLib).toContain('supports_native_pathmode: option_env!("NOTE_CONNECTION_ANDROID_INCLUDE_GODOT_PATHMODE")');
         expect(tauriLib).toContain('read_node_content');
     });
     test('path mode entry prefers native android activity when capability is enabled', () => {