noteconnection 1.7.0 → 1.8.0

package/dist/src/pathbridge.handshake.contract.test.js

@@ -46,6 +46,20 @@ describe('path bridge handshake and transport verification contracts', () => {
     const pathModeUiPath = path.join(repoRoot, 'path_mode', 'scripts', 'path_mode_ui.gd');
     const readerRenderClientPath = path.join(repoRoot, 'path_mode', 'scripts', 'reader_render_client.gd');
     const pathRendererPath = path.join(repoRoot, 'path_mode', 'scripts', 'path_renderer.gd');
+    test('path bridge preserves explicit port zero for ephemeral bind fallback', async () => {
+        const bridge = new PathBridge_1.PathBridge({
+            port: 0,
+            host: '127.0.0.1',
+        });
+        try {
+            await bridge.waitUntilReady();
+            expect(bridge.getPort()).toBeGreaterThan(0);
+            expect(bridge.getPort()).not.toBe(9876);
+        }
+        finally {
+            bridge.close();
+        }
+    });
     test('path bridge supports explicit identify handshake and client tagging', () => {
         const bridge = fs.readFileSync(bridgePath, 'utf8');
         expect(bridge).toContain("case 'identify'");
@@ -149,7 +163,7 @@ describe('path bridge handshake and transport verification contracts', () => {
         const invalidConfigureBrightness = (0, PathBridge_1.parseBridgeInboundEnvelope)({
             type: 'configure',
             payload: {
-                bg_brightness: 20,
+                bg_brightness: 0.2,
             },
         });
         expect(invalidConfigureBrightness.ok).toBe(false);
@@ -182,7 +196,7 @@ describe('path bridge handshake and transport verification contracts', () => {
                 retain_history: true,
                 focus_mode: false,
                 background: 'belfast_sunset_puresky_4k.exr',
-                bg_brightness: 1.2,
+                bg_brightness: 0.08,
                 reading_mode: 'window',
                 reader_render_mode: 'render',
                 reader_toggle_source_shortcut: 'Ctrl+Shift+M',

package/dist/src/pathmode.background.contract.test.js

@@ -0,0 +1,69 @@
+"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('pathmode background safety contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const settingsPanelPath = path.join(repoRoot, 'path_mode', 'scripts', 'settings_panel.gd');
+    const pathRendererPath = path.join(repoRoot, 'path_mode', 'scripts', 'path_renderer.gd');
+    test('does not default path mode to a heavy HDR background at startup', () => {
+        const source = fs.readFileSync(settingsPanelPath, 'utf8');
+        expect(source).toContain('"background": ""');
+        expect(source).not.toContain('"background": "belfast_sunset_puresky_4k.exr"');
+    });
+    test('startup path-mode restore keeps runtime background values intact', () => {
+        const source = fs.readFileSync(pathRendererPath, 'utf8');
+        expect(source).toContain('func _filter_startup_settings(settings: Dictionary) -> Dictionary:');
+        expect(source).toContain('return settings.duplicate(true)');
+    });
+    test('desktop settings panel prefers runtime TOML over local cfg during load', () => {
+        const source = fs.readFileSync(settingsPanelPath, 'utf8');
+        expect(source).toContain('if not _runtime_base_url.is_empty():');
+        expect(source).toContain('call_deferred("_load_settings_from_runtime_async")');
+        expect(source).toContain('_load_settings_local()');
+    });
+    test('loads HDR backgrounds through the guarded resize-and-convert path', () => {
+        const source = fs.readFileSync(pathRendererPath, 'utf8');
+        expect(source).toContain('var _background_texture_cache: Dictionary = {}');
+        expect(source).toContain('var _last_applied_background_path: String = "__unset__"');
+        expect(source).toContain('func _load_hdr_background_safely(path: String) -> Texture2D:');
+        expect(source).toContain('var imported_tex = ResourceLoader.load(path)');
+        expect(source).toContain('var texture := imported_tex as Texture2D');
+        expect(source).not.toContain('MAX_SAFE_HDR_BACKGROUND_BYTES');
+        expect(source).not.toContain('(imported_tex as Texture2D).get_image()');
+        expect(source).not.toContain('var image_error := image.load(path)');
+    });
+});

package/dist/src/pathmode.settings.api.contract.test.js

@@ -45,4 +45,13 @@ describe('Path Mode settings API contract', () => {
         expect(serverSource).toContain('extractPathModeSettingsFromAppConfig');
         expect(serverSource).toContain('applyPathModeSettingsToAppConfig');
     });
+    test('server path-mode settings loader does not short-circuit on stale in-memory cache', () => {
+        const loadStart = serverSource.indexOf('async function loadPathModeSettings(): Promise<PathModeSettings> {');
+        const loadEnd = serverSource.indexOf('async function persistPathModeSettings(settingsLike: unknown): Promise<PathModeSettings> {');
+        const loadSlice = serverSource.slice(loadStart, loadEnd);
+        expect(loadStart).toBeGreaterThanOrEqual(0);
+        expect(loadEnd).toBeGreaterThan(loadStart);
+        expect(loadSlice).toContain('const appConfig = await loadAppConfigToml();');
+        expect(loadSlice).not.toContain('if (cachedPathModeSettings)');
+    });
 });

package/dist/src/pkg.sidecar.contract.test.js

@@ -48,10 +48,14 @@ describe('pkg sidecar packaging contract', () => {
         const pkg = packageJson.pkg || {};
         const pkgScripts = pkg.scripts || [];
         const pkgAssets = pkg.assets || [];
+        const scripts = packageJson.scripts || {};
         expect(pkgScripts).toContain('dist/src/backend/workers/**/*.js');
         expect(pkgAssets).toContain('dist/src/**/*');
-        expect(pkgAssets).toContain('data.js');
-        expect(pkgAssets).toContain('graph_data.json');
+        expect(pkgAssets).not.toContain('data.js');
+        expect(pkgAssets).not.toContain('graph_data.json');
+        expect(scripts['build:full']).toContain('--include-generated-graph-assets');
+        expect(scripts['tauri:build:full']).toContain('npm run build:full');
+        expect(scripts.prepublishOnly).toBe('npm run build');
     });
     test('retains hardened node22 sidecar build args and target mapping', () => {
         const buildSidecar = fs.readFileSync(buildSidecarPath, 'utf8');
@@ -61,6 +65,8 @@ describe('pkg sidecar packaging contract', () => {
         expect(buildSidecar).toContain("'--compress'");
         expect(buildSidecar).toContain("'Brotli'");
         expect(buildSidecar).toContain("'--no-bytecode'");
-        expect(buildSidecar).toContain("'--public'");
+        expect(buildSidecar).toContain("'--public-packages'");
+        expect(buildSidecar).toContain('PKG_NO_BYTECODE_RETRY_PATTERN');
+        expect(buildSidecar).toContain('without --no-bytecode');
     });
 });

package/dist/src/platform/ExportProfile.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExportProfile = getExportProfile;
+exports.listExportProfiles = listExportProfiles;
+const EXPORT_PROFILES = {
+    'desktop-full': {
+        id: 'desktop-full',
+        platformTarget: 'tauri',
+        description: 'Full desktop runtime with sidecar-backed retrieval, streaming, and indexing.',
+        supportsSidecar: true,
+        supportsBackgroundIndexing: true,
+        supportsConversationStreaming: true,
+        supportsSvgRenderArtifacts: true,
+        supportsPngRenderArtifacts: true,
+        preferredMermaidRenderer: 'auto',
+    },
+    'desktop-reader': {
+        id: 'desktop-reader',
+        platformTarget: 'browser',
+        description: 'Reader-oriented desktop profile with lightweight retrieval and PNG-safe rendering.',
+        supportsSidecar: true,
+        supportsBackgroundIndexing: false,
+        supportsConversationStreaming: true,
+        supportsSvgRenderArtifacts: true,
+        supportsPngRenderArtifacts: true,
+        preferredMermaidRenderer: 'auto',
+    },
+    'godot-path-mode': {
+        id: 'godot-path-mode',
+        platformTarget: 'godot',
+        description: 'Godot reader/profile with PNG-first render materialization and no SVG dependency.',
+        supportsSidecar: true,
+        supportsBackgroundIndexing: false,
+        supportsConversationStreaming: false,
+        supportsSvgRenderArtifacts: false,
+        supportsPngRenderArtifacts: true,
+        preferredMermaidRenderer: 'auto',
+    },
+    'mobile-slim': {
+        id: 'mobile-slim',
+        platformTarget: 'mobile',
+        description: 'Slim mobile export with bounded memory footprint and PNG-only render artifacts.',
+        supportsSidecar: false,
+        supportsBackgroundIndexing: false,
+        supportsConversationStreaming: false,
+        supportsSvgRenderArtifacts: false,
+        supportsPngRenderArtifacts: true,
+        preferredMermaidRenderer: 'local',
+    },
+};
+function getExportProfile(profileId) {
+    const normalized = typeof profileId === 'string' ? profileId.trim().toLowerCase() : '';
+    const candidate = normalized;
+    return EXPORT_PROFILES[candidate] || EXPORT_PROFILES['desktop-full'];
+}
+function listExportProfiles() {
+    return Object.values(EXPORT_PROFILES).map((profile) => ({ ...profile }));
+}

package/dist/src/platform/PlatformCapabilities.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePlatformCapabilities = resolvePlatformCapabilities;
+const ExportProfile_1 = require("./ExportProfile");
+function cloneProfile(profile) {
+    return { ...profile };
+}
+function resolvePlatformCapabilities(input = {}) {
+    let profile = cloneProfile((0, ExportProfile_1.getExportProfile)(input.exportProfileId));
+    const requestedTarget = typeof input.platformTarget === 'string'
+        ? input.platformTarget.trim().toLowerCase()
+        : '';
+    if (requestedTarget) {
+        const compatibleProfile = (requestedTarget === 'godot' ? (0, ExportProfile_1.getExportProfile)('godot-path-mode')
+            : requestedTarget === 'mobile' ? (0, ExportProfile_1.getExportProfile)('mobile-slim')
+                : requestedTarget === 'browser' ? (0, ExportProfile_1.getExportProfile)('desktop-reader')
+                    : (0, ExportProfile_1.getExportProfile)('desktop-full'));
+        if (compatibleProfile.platformTarget === requestedTarget) {
+            profile = cloneProfile(compatibleProfile);
+        }
+    }
+    return {
+        exportProfileId: profile.id,
+        platformTarget: profile.platformTarget,
+        export: {
+            supportsWorkspaceBundles: true,
+            deterministicBundles: true,
+            bundlePackagingMode: profile.supportsSidecar ? 'full' : 'slim',
+            requiresIndexedReadiness: true,
+        },
+        render: {
+            supportsSvgArtifacts: profile.supportsSvgRenderArtifacts,
+            supportsPngArtifacts: profile.supportsPngRenderArtifacts,
+            preferredArtifact: profile.supportsSvgRenderArtifacts ? 'svg' : 'png',
+            preferredMermaidRenderer: profile.preferredMermaidRenderer,
+        },
+        retrieval: {
+            supportsSidecar: profile.supportsSidecar,
+            supportsBackgroundIndexing: profile.supportsBackgroundIndexing,
+        },
+        conversation: {
+            supportsStreaming: profile.supportsConversationStreaming,
+        },
+    };
+}

package/dist/src/platform/PlatformCapabilities.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PlatformCapabilities_1 = require("./PlatformCapabilities");
+describe('PlatformCapabilities', () => {
+    test('resolves Godot profile as PNG-first and non-streaming', () => {
+        const capabilities = (0, PlatformCapabilities_1.resolvePlatformCapabilities)({ exportProfileId: 'godot-path-mode' });
+        expect(capabilities.platformTarget).toBe('godot');
+        expect(capabilities.export.supportsWorkspaceBundles).toBe(true);
+        expect(capabilities.export.bundlePackagingMode).toBe('full');
+        expect(capabilities.render.supportsSvgArtifacts).toBe(false);
+        expect(capabilities.render.preferredArtifact).toBe('png');
+        expect(capabilities.conversation.supportsStreaming).toBe(false);
+    });
+    test('resolves mobile slim profile as sidecar-free and PNG-only', () => {
+        const capabilities = (0, PlatformCapabilities_1.resolvePlatformCapabilities)({ exportProfileId: 'mobile-slim' });
+        expect(capabilities.platformTarget).toBe('mobile');
+        expect(capabilities.export.bundlePackagingMode).toBe('slim');
+        expect(capabilities.export.requiresIndexedReadiness).toBe(true);
+        expect(capabilities.retrieval.supportsSidecar).toBe(false);
+        expect(capabilities.render.supportsSvgArtifacts).toBe(false);
+    });
+    test('platform target override selects the compatible profile family', () => {
+        const capabilities = (0, PlatformCapabilities_1.resolvePlatformCapabilities)({
+            exportProfileId: 'desktop-full',
+            platformTarget: 'browser',
+        });
+        expect(capabilities.exportProfileId).toBe('desktop-reader');
+        expect(capabilities.platformTarget).toBe('browser');
+    });
+});

package/dist/src/platform/RenderMaterializer.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRenderMaterializationDecision = resolveRenderMaterializationDecision;
+const PlatformCapabilities_1 = require("./PlatformCapabilities");
+function resolveRenderMaterializationDecision(input = {}) {
+    const capabilities = (0, PlatformCapabilities_1.resolvePlatformCapabilities)({
+        exportProfileId: input.exportProfileId,
+        platformTarget: input.platformTarget,
+    });
+    const requestedRenderer = typeof input.rendererPreference === 'string'
+        ? input.rendererPreference.trim().toLowerCase()
+        : '';
+    let rendererPreference = (requestedRenderer === 'local'
+        || requestedRenderer === 'frontend'
+        || requestedRenderer === 'auto')
+        ? requestedRenderer
+        : capabilities.render.preferredMermaidRenderer;
+    if (!capabilities.render.supportsSvgArtifacts && rendererPreference === 'frontend') {
+        rendererPreference = capabilities.render.preferredMermaidRenderer;
+    }
+    const includeStages = input.includeStages === true;
+    const includeSvgRequested = input.includeSvg === true || includeStages;
+    const includeSvg = capabilities.render.supportsSvgArtifacts && includeSvgRequested;
+    return {
+        exportProfileId: capabilities.exportProfileId,
+        platformTarget: capabilities.platformTarget,
+        includeSvg,
+        includeStages,
+        responseArtifact: capabilities.render.preferredArtifact,
+        rendererPreference,
+        vectorSuppressed: includeSvgRequested && !capabilities.render.supportsSvgArtifacts,
+    };
+}

package/dist/src/platform/RenderMaterializer.test.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RenderMaterializer_1 = require("./RenderMaterializer");
+describe('RenderMaterializer', () => {
+    test('suppresses SVG for Godot even when includeSvg is requested', () => {
+        const decision = (0, RenderMaterializer_1.resolveRenderMaterializationDecision)({
+            exportProfileId: 'godot-path-mode',
+            includeSvg: true,
+        });
+        expect(decision.includeSvg).toBe(false);
+        expect(decision.vectorSuppressed).toBe(true);
+        expect(decision.responseArtifact).toBe('png');
+    });
+    test('preserves SVG diagnostics for desktop-full profile', () => {
+        const decision = (0, RenderMaterializer_1.resolveRenderMaterializationDecision)({
+            exportProfileId: 'desktop-full',
+            includeSvg: true,
+            includeStages: true,
+        });
+        expect(decision.includeSvg).toBe(true);
+        expect(decision.includeStages).toBe(true);
+        expect(decision.vectorSuppressed).toBe(false);
+    });
+    test('falls back to local renderer for mobile slim profile', () => {
+        const decision = (0, RenderMaterializer_1.resolveRenderMaterializationDecision)({
+            exportProfileId: 'mobile-slim',
+            rendererPreference: 'frontend',
+        });
+        expect(decision.rendererPreference).toBe('local');
+        expect(decision.responseArtifact).toBe('png');
+    });
+});