noteconnection 1.7.0 → 1.9.0

package/dist/src/mobile.identity.corpus.test.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ResourceIdentity_1 = require("./backend/ResourceIdentity");
+const Graph_1 = require("./core/Graph");
+describe('mobile identity migration corpus', () => {
+    test('keeps same-content documents isolated while preserving cross-root identity', () => {
+        const first = (0, ResourceIdentity_1.createResourceIdentity)('notes/first.md', 'First', 'same body');
+        const second = (0, ResourceIdentity_1.createResourceIdentity)('notes/second.md', 'Second', 'same body');
+        const fromWindows = (0, ResourceIdentity_1.createResourceIdentity)('Notes\\Cafe\u0301.md', 'Cafe', 'body');
+        const fromPosix = (0, ResourceIdentity_1.createResourceIdentity)('notes/caf\u00e9.md', 'Cafe', 'body');
+        expect(first.revision).toBe(second.revision);
+        expect(first.sourceUri).not.toBe(second.sourceUri);
+        expect(fromWindows.sourceUri).toBe(fromPosix.sourceUri);
+        expect(fromWindows.revision).toBe(fromPosix.revision);
+    });
+    test('rejects NFC/case collisions before graph mutation', () => {
+        expect(() => (0, ResourceIdentity_1.assertUniqueLegacyResourceIds)([
+            { filename: 'Cafe\u0301', filepath: 'one/Cafe\u0301.md' },
+            { filename: 'Caf\u00e9', filepath: 'two/Caf\u00e9.md' },
+        ])).toThrow(/ambiguous|duplicate/i);
+    });
+    test('replays a legacy snapshot and rolls back a corrupt candidate atomically', () => {
+        const graph = Graph_1.Graph.fromJSON({
+            nodes: [
+                { id: 'legacy-a', label: 'A', inDegree: 0, outDegree: 1 },
+                { id: 'legacy-b', label: 'B', inDegree: 1, outDegree: 0 },
+            ],
+            edges: [{ source: 'legacy-a', target: 'legacy-b', type: 'legacy-link', weight: 1 }],
+        });
+        expect(graph.getOutgoingEdges('legacy-a')).toEqual([
+            { source: 'legacy-a', target: 'legacy-b', type: 'legacy-link', weight: 1 },
+        ]);
+        expect(() => graph.restore({
+            nodes: [{ id: 'candidate', label: 'Candidate' }],
+            edges: [{ source: 'candidate', target: 'missing' }],
+        })).toThrow(/undeclared node/i);
+        expect(graph.hasNode('legacy-a')).toBe(true);
+        expect(graph.hasNode('candidate')).toBe(false);
+    });
+});

package/dist/src/mobile.native.recovery.contract.test.js

@@ -0,0 +1,64 @@
+"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 os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const verifier = require(path.resolve(__dirname, '..', 'scripts', 'verify-mobile-native-recovery.js'));
+describe('mobile native recovery state-machine contract', () => {
+    test('replays all journal phases and fail-closed cases without claiming native evidence', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-recovery-contract-'));
+        const outputPath = path.join(root, 'report.json');
+        try {
+            const evidence = verifier.runRecoveryVerification({ outputPath });
+            expect(evidence.evidenceLevel).toBe('host-recovery-state-machine');
+            expect(evidence.nativeDeviceEvidence).toBe(false);
+            expect(evidence.scenarios).toEqual(expect.arrayContaining([
+                expect.objectContaining({ name: 'staging-target-wins', action: 'target-preserved' }),
+                expect.objectContaining({ name: 'backup-restored', action: 'previous-restored' }),
+                expect.objectContaining({ name: 'backup-rename-retry', action: 'recovery-pending', backupExists: true, journalExists: true }),
+                expect.objectContaining({ name: 'activated-target-wins', action: 'target-preserved' }),
+                expect.objectContaining({ name: 'orphan-backup-restored', action: 'orphan-backup-restored' }),
+                expect.objectContaining({ name: 'orphan-backup-retry', action: 'orphan-recovery-pending', backupExists: true }),
+                expect.objectContaining({ name: 'unsafe-journal-rejected', action: 'unsafe_import_journal' }),
+                expect.objectContaining({ name: 'unknown-schema-rejected', action: 'invalid_import_journal' }),
+            ]));
+            expect(JSON.parse(fs.readFileSync(outputPath, 'utf8')).scenarios).toHaveLength(8);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/src/mobile.pipeline.test.js

@@ -59,6 +59,7 @@ describe('dual mobile pipeline configuration', () => {
         const scripts = pkg.scripts || {};
         expect(scripts['verify:android:env']).toContain('verify-tauri-android-prereqs.js');
         expect(scripts['tauri:android:patch:pathmode']).toContain('apply-tauri-android-pathmode.js');
+        expect(scripts['configure:tauri:android:signing']).toContain('configure-tauri-android-signing.js');
         expect(scripts['smoke:android:pathmode']).toContain('smoke-android-pathmode.js');
         expect(scripts['mobile:build:capacitor']).toBe('build_apk.bat');
         expect(scripts['capture:capacitor:evidence']).toContain('capture-capacitor-device-evidence.js');
@@ -72,8 +73,17 @@ describe('dual mobile pipeline configuration', () => {
         expect(scripts['tauri:android:dev:universal']).toContain('NOTE_CONNECTION_TAURI_ANDROID_TARGET=universal');
         expect(scripts['tauri:android:build:universal']).toContain('NOTE_CONNECTION_TAURI_ANDROID_TARGET=universal');
         expect(scripts['mobile:build:tauri-android']).toBe('npm run tauri:android:build');
+        expect(scripts['mobile:build:release']).toBe('npm run mobile:build:tauri-android');
+        expect(scripts['mobile:build:release']).not.toContain('capacitor');
+        expect(scripts['mobile:build:compatibility']).toBe('npm run mobile:build:both');
         expect(scripts['mobile:build:both']).toContain('mobile:build:capacitor');
         expect(scripts['mobile:build:both']).toContain('mobile:build:tauri-android');
+        expect(scripts['verify:mobile:artifact']).toContain('verify-mobile-artifact.js');
+        expect(scripts['verify:mobile:artifact:release']).toContain('--require-rss');
+        expect(scripts['verify:mobile:artifact:release']).toContain('--require-arm64');
+        expect(scripts['verify:mobile:artifact:release']).toContain('--require-signed');
+        expect(scripts['capture:tauri:android:evidence']).toContain('capture-tauri-android-rss-evidence.js');
+        expect(fs.existsSync(path.join(repoRoot, 'scripts', 'verify-mobile-artifact.js'))).toBe(true);
     });
     test('defaults tauri android build/dev to arm64 target with override support', () => {
         const runnerScript = fs.readFileSync(tauriAndroidRunnerPath, 'utf8');
@@ -90,7 +100,7 @@ describe('dual mobile pipeline configuration', () => {
         expect(capacitorConfig).toContain("allowNavigation: ['localhost', '127.0.0.1']");
         const buildApkScript = fs.readFileSync(buildApkScriptPath, 'utf8');
         expect(buildApkScript).toContain('NOTE_CONNECTION_NO_PAUSE');
-        expect(buildApkScript).toContain("dist\\src\\frontend");
+        expect(buildApkScript).toContain("dist\\mobile-slim\\frontend");
         expect(buildApkScript).toContain('npx cap sync android');
         expect(buildApkScript).toContain('align-capacitor-java-compat.js');
         expect(buildApkScript).toContain('requires JDK 21 or newer.');

package/dist/src/mobile.profile.contract.test.js

@@ -0,0 +1,225 @@
+"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 crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const PlatformCapabilities_1 = require("./platform/PlatformCapabilities");
+const RenderMaterializer_1 = require("./platform/RenderMaterializer");
+describe('mobile-slim profile contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const analyzerPath = path.join(repoRoot, 'src', 'frontend', 'mobile_exact_analyzer.js');
+    const projectionContractPath = path.join(repoRoot, 'src', 'frontend', 'knowledge_projection_contract.js');
+    const verifierPath = path.join(repoRoot, 'scripts', 'verify-mobile-slim-budget.js');
+    const preparePath = path.join(repoRoot, 'scripts', 'prepare-mobile-slim.js');
+    test('declares sidecar-free local analysis with optional remote inference and hard budgets', () => {
+        const capabilities = (0, PlatformCapabilities_1.resolvePlatformCapabilities)({ exportProfileId: 'mobile-slim' });
+        expect(capabilities.retrieval.supportsSidecar).toBe(false);
+        expect(capabilities.retrieval.supportsLocalIngest).toBe(true);
+        expect(capabilities.retrieval.supportsLocalExactQuery).toBe(true);
+        expect(capabilities.retrieval.supportsRemoteInference).toBe(true);
+        expect(capabilities.retrieval.requiresRemoteInference).toBe(false);
+        expect(capabilities.export.assetBudgetBytes).toBe(25 * 1024 * 1024);
+        expect(capabilities.export.maxResidentBytes).toBe(256 * 1024 * 1024);
+    });
+    test('rejects SVG materialization for mobile even when explicitly requested', () => {
+        const decision = (0, RenderMaterializer_1.resolveRenderMaterializationDecision)({
+            exportProfileId: 'mobile-slim',
+            includeSvg: true,
+            includeStages: true,
+            rendererPreference: 'frontend',
+        });
+        expect(decision.includeSvg).toBe(false);
+        expect(decision.vectorSuppressed).toBe(true);
+        expect(decision.responseArtifact).toBe('png');
+        expect(decision.rendererPreference).toBe('local');
+    });
+    test('ships a callable bounded exact graph analyzer without retaining document bodies', () => {
+        expect(fs.existsSync(analyzerPath)).toBe(true);
+        const analyzer = require(analyzerPath);
+        const index = analyzer.createMobileExactIndex({
+            nodes: [
+                { id: 'fundamentals/alpha', label: 'Alpha', content: 'must not be retained' },
+                { id: 'fundamentals/beta', label: 'Beta', metadata: { tags: ['core'] } },
+                { id: 'advanced/gamma', label: 'Gamma' },
+            ],
+            edges: [
+                { source: 'fundamentals/alpha', target: 'fundamentals/beta', type: 'prerequisite' },
+                { source: 'fundamentals/beta', target: 'advanced/gamma', type: 'next' },
+            ],
+        });
+        expect(index.searchExact('beta')).toEqual([
+            expect.objectContaining({ id: 'fundamentals/beta' }),
+        ]);
+        expect(index.searchExact('core')).toEqual([
+            expect.objectContaining({ id: 'fundamentals/beta' }),
+        ]);
+        expect(index.neighbors('fundamentals/beta')).toEqual([
+            expect.objectContaining({ id: 'advanced/gamma' }),
+            expect.objectContaining({ id: 'fundamentals/alpha' }),
+        ]);
+        expect(index.shortestPath('fundamentals/alpha', 'advanced/gamma')).toEqual([
+            'fundamentals/alpha',
+            'fundamentals/beta',
+            'advanced/gamma',
+        ]);
+        expect(index.statistics()).toEqual({ nodeCount: 3, edgeCount: 2 });
+        expect(JSON.stringify(index.searchExact('alpha'))).not.toContain('must not be retained');
+    });
+    test('normalizes exact lookup keys independently of the device locale', () => {
+        const analyzerSource = fs.readFileSync(analyzerPath, 'utf8');
+        const analyzer = require(analyzerPath);
+        const index = analyzer.createMobileExactIndex({
+            nodes: [{ id: 'unicode-i', label: '\u0130' }],
+            edges: [],
+        });
+        expect(analyzerSource).not.toContain('.toLocaleLowerCase(');
+        expect(index.searchExact('i\u0307')).toEqual([
+            expect.objectContaining({ id: 'unicode-i' }),
+        ]);
+    });
+    test('does not cross the requested visited-node ceiling during path traversal', () => {
+        const analyzer = require(analyzerPath);
+        const index = analyzer.createMobileExactIndex({
+            nodes: [
+                { id: 'source' },
+                { id: 'first-branch' },
+                { id: 'target' },
+            ],
+            edges: [
+                { source: 'source', target: 'first-branch' },
+                { source: 'source', target: 'target' },
+            ],
+        });
+        expect(index.shortestPath('source', 'target', 2, 2)).toBeNull();
+    });
+    test('exposes exact query and path operations through the runtime storage boundary', () => {
+        const storageProvider = fs.readFileSync(path.join(repoRoot, 'src', 'frontend', 'storage_provider.js'), 'utf8');
+        const indexHtml = fs.readFileSync(path.join(repoRoot, 'src', 'frontend', 'index.html'), 'utf8');
+        const analyzerScriptOffset = indexHtml.indexOf('<script src="mobile_exact_analyzer.js"></script>');
+        const identityScriptOffset = indexHtml.indexOf('<script src="mobile_identity_contract.js"></script>');
+        const storageScriptOffset = indexHtml.indexOf('<script src="storage_provider.js"></script>');
+        expect(storageProvider).toContain('async queryKnowledgeBaseExact(request)');
+        expect(storageProvider).toContain('async findKnowledgePath(request)');
+        expect(storageProvider).toContain("this.readGeneratedAsset('graph_data.json')");
+        expect(analyzerScriptOffset).toBeGreaterThan(-1);
+        expect(identityScriptOffset).toBeGreaterThan(analyzerScriptOffset);
+        expect(identityScriptOffset).toBeLessThan(storageScriptOffset);
+        expect(analyzerScriptOffset).toBeLessThan(storageScriptOffset);
+    });
+    test('loads one versioned projection contract before both mobile consumers', () => {
+        const projectionContract = fs.readFileSync(projectionContractPath, 'utf8');
+        const storageProvider = fs.readFileSync(path.join(repoRoot, 'src', 'frontend', 'storage_provider.js'), 'utf8');
+        const indexHtml = fs.readFileSync(path.join(repoRoot, 'src', 'frontend', 'index.html'), 'utf8');
+        const projectionScriptOffset = indexHtml.indexOf('<script src="knowledge_projection_contract.js"></script>');
+        expect(projectionContract).toContain('schemaVersion: SCHEMA_VERSION');
+        expect(projectionContract).toContain('MAX_NEIGHBORS');
+        expect(storageProvider).toContain('window.NoteConnectionKnowledgeProjection');
+        expect(storageProvider).toContain('createKnowledgeProjection');
+        expect(storageProvider).toContain('createFileProjectionStore');
+        expect(storageProvider).toContain("fileName: 'graph_data.json'");
+        expect(projectionScriptOffset).toBeGreaterThan(-1);
+        expect(projectionScriptOffset).toBeLessThan(indexHtml.indexOf('<script src="mobile_exact_analyzer.js"></script>'));
+        expect(projectionScriptOffset).toBeLessThan(indexHtml.indexOf('<script src="storage_provider.js"></script>'));
+    });
+    test('fails closed for oversized, forbidden, and over-RSS mobile staging evidence', () => {
+        expect(fs.existsSync(verifierPath)).toBe(true);
+        const verifier = require(verifierPath);
+        const fixtureRoot = fs.mkdtempSync(path.join(repoRoot, '.mobile-slim-contract-'));
+        try {
+            fs.writeFileSync(path.join(fixtureRoot, 'index.html'), crypto.randomBytes(2048));
+            expect(() => verifier.assertMobileSlimBudget({
+                stagingDir: fixtureRoot,
+                assetBudgetBytes: 128,
+                maxResidentBytes: 1024,
+            })).toThrow(/compressed payload/i);
+            fs.rmSync(path.join(fixtureRoot, 'index.html'));
+            fs.writeFileSync(path.join(fixtureRoot, 'server-aarch64-linux'), 'forbidden');
+            expect(() => verifier.assertMobileSlimBudget({
+                stagingDir: fixtureRoot,
+                assetBudgetBytes: 4096,
+                maxResidentBytes: 1024,
+            })).toThrow(/forbidden mobile artifact/i);
+            fs.rmSync(path.join(fixtureRoot, 'server-aarch64-linux'));
+            fs.writeFileSync(path.join(fixtureRoot, 'index.html'), 'ok');
+            const rssEvidencePath = path.join(fixtureRoot, 'rss-evidence.json');
+            fs.writeFileSync(rssEvidencePath, JSON.stringify({ peakResidentBytes: 2048 }));
+            expect(() => verifier.assertMobileSlimBudget({
+                stagingDir: fixtureRoot,
+                assetBudgetBytes: 4096,
+                maxResidentBytes: 1024,
+                rssEvidencePath,
+            })).toThrow(/peak RSS/i);
+        }
+        finally {
+            fs.rmSync(fixtureRoot, { recursive: true, force: true });
+        }
+    });
+    test('routes both Android packagers through the deterministic mobile staging directory', () => {
+        expect(fs.existsSync(preparePath)).toBe(true);
+        const pkg = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+        const capacitorConfig = fs.readFileSync(path.join(repoRoot, 'capacitor.config.ts'), 'utf8');
+        const capacitorBuild = fs.readFileSync(path.join(repoRoot, 'build_apk.bat'), 'utf8');
+        const tauriAndroidConfig = JSON.parse(fs.readFileSync(path.join(repoRoot, 'src-tauri', 'tauri.android.conf.json'), 'utf8'));
+        expect(pkg.scripts['mobile:prepare:slim']).toContain('prepare-mobile-slim.js');
+        expect(pkg.scripts['mobile:prepare:slim']).toContain('verify-mobile-slim-budget.js');
+        expect(pkg.scripts['tauri:android:init']).toContain('mobile:prepare:slim');
+        expect(pkg.scripts['verify:mobile:slim:budget']).toContain('verify-mobile-slim-budget.js');
+        expect(pkg.scripts['tauri:android:build']).toContain('mobile:prepare:slim');
+        expect(pkg.scripts['tauri:android:build']).not.toContain('build:sidecar');
+        expect(capacitorConfig).toContain('NOTE_CONNECTION_MOBILE_WEB_DIR');
+        expect(capacitorBuild).toContain('npm run mobile:prepare:slim');
+        expect(capacitorBuild).toContain('NOTE_CONNECTION_MOBILE_WEB_DIR');
+        expect(tauriAndroidConfig.build?.frontendDist).toBe('../dist/mobile-slim/frontend');
+        expect(tauriAndroidConfig.bundle?.externalBin).toEqual([]);
+    });
+    test('keeps Godot Android integration explicit instead of enabling it in mobile-slim', () => {
+        const runner = fs.readFileSync(path.join(repoRoot, 'scripts', 'run-tauri-android.js'), 'utf8');
+        const patcher = fs.readFileSync(path.join(repoRoot, 'scripts', 'apply-tauri-android-pathmode.js'), 'utf8');
+        expect(runner).toContain('NOTE_CONNECTION_ANDROID_INCLUDE_GODOT_PATHMODE');
+        expect(runner).toContain("runPathmodePatch({ mode: 'disable'");
+        expect(patcher).toContain("process.argv.includes('--disable')");
+        expect(patcher).toContain('removePathmodeAssets');
+    });
+    test('keeps the semantic comparator out of mobile-slim runtime staging', () => {
+        const prepareSource = fs.readFileSync(preparePath, 'utf8');
+        expect(prepareSource).toContain('mobile_semantic_comparator\\.js');
+    });
+    test('does not allocate the full-content graph on Android runtime builds', () => {
+        const rustSource = fs.readFileSync(path.join(repoRoot, 'src-tauri', 'src', 'lib.rs'), 'utf8');
+        expect(rustSource).toContain('#[cfg(not(target_os = "android"))]\n    let full_nodes');
+        expect(rustSource).toContain('#[cfg(not(target_os = "android"))]\n    let full_graph');
+    });
+});

package/dist/src/mobile.semantic.parity.test.js

@@ -0,0 +1,92 @@
+"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 path = __importStar(require("path"));
+const comparator = require(path.resolve(__dirname, 'frontend', 'mobile_semantic_comparator.js'));
+const projectionContract = require(path.resolve(__dirname, 'frontend', 'knowledge_projection_contract.js'));
+describe('cross-host mobile semantic parity', () => {
+    test('matches canonical nodes and directed edge provenance across host-specific ids', () => {
+        const left = projectionContract.createKnowledgeProjection({
+            nodes: [
+                { id: 'base', canonicalId: 'financial/base', sourceUri: 'note://workspace/v1/financial/base.md' },
+                { id: 'intro', canonicalId: 'financial/intro', sourceUri: 'note://workspace/v1/financial/intro.md' },
+            ],
+            edges: [{
+                    source: 'base',
+                    target: 'intro',
+                    sourceUri: 'note://workspace/v1/financial/base.md',
+                    targetUri: 'note://workspace/v1/financial/intro.md',
+                    type: 'explicit-prerequisite',
+                    kind: 'explicit',
+                    provenance: 'explicit-prerequisite',
+                }],
+        });
+        const right = projectionContract.createKnowledgeProjection({
+            nodes: [
+                { id: 'financial/base', canonicalId: 'financial/base', sourceUri: 'note://workspace/v1/financial/base.md' },
+                { id: 'financial/intro', canonicalId: 'financial/intro', sourceUri: 'note://workspace/v1/financial/intro.md' },
+            ],
+            edges: [{
+                    source: 'financial/base',
+                    target: 'financial/intro',
+                    type: 'explicit-prerequisite',
+                    kind: 'explicit',
+                    provenance: 'explicit-prerequisite',
+                }],
+        });
+        expect(comparator.compareSemanticProjections(left, right).equal).toBe(true);
+        expect(() => comparator.assertSemanticParity(left, right, 'fixture')).not.toThrow();
+    });
+    test('reports provenance changes instead of collapsing same-endpoint edges', () => {
+        const left = {
+            nodes: [
+                { id: 'a', canonicalId: 'a', sourceUri: 'note://workspace/v1/a.md' },
+                { id: 'b', canonicalId: 'b', sourceUri: 'note://workspace/v1/b.md' },
+            ],
+            edges: [{ source: 'a', target: 'b', type: 'wiki-link', provenance: 'wiki-link' }],
+        };
+        const right = {
+            nodes: [
+                { id: 'a', canonicalId: 'a', sourceUri: 'note://workspace/v1/a.md' },
+                { id: 'b', canonicalId: 'b', sourceUri: 'note://workspace/v1/b.md' },
+            ],
+            edges: [{ source: 'a', target: 'b', type: 'markdown-link', provenance: 'markdown-link' }],
+        };
+        const comparison = comparator.compareSemanticProjections(left, right);
+        expect(comparison.equal).toBe(false);
+        expect(comparison.extraEdges.length).toBeGreaterThan(0);
+        expect(() => comparator.assertSemanticParity(left, right, 'provenance')).toThrow(/semantic projection parity failed/);
+    });
+});

package/dist/src/mobile_exact_analyzer.test.js

@@ -0,0 +1,113 @@
+"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 path = __importStar(require("path"));
+// The analyzer is deliberately a browser-compatible CommonJS/IIFE artifact so
+// the same projection can be replayed in Capacitor and the desktop test runner.
+const analyzer = require(path.resolve(__dirname, 'frontend', 'mobile_exact_analyzer.js'));
+describe('mobile exact projection contract', () => {
+    test('indexes stable URI aliases and separates explicit from inferred edges', () => {
+        const index = analyzer.createMobileExactIndex({
+            nodes: [
+                {
+                    id: 'Legacy A',
+                    label: 'A',
+                    sourceUri: 'note://workspace/v1/a.md',
+                    identityAliases: ['a.md'],
+                    metadata: { tags: ['algebra'] },
+                },
+                { id: 'B', label: 'B' },
+            ],
+            edges: [
+                { source: 'Legacy A', target: 'B', type: 'explicit-prerequisite' },
+                { source: 'B', target: 'Legacy A', type: 'vector-association' },
+            ],
+        });
+        expect(index.searchExact('note://workspace/v1/a.md', 5)[0]).toEqual(expect.objectContaining({
+            id: 'Legacy A',
+            sourceUri: 'note://workspace/v1/a.md',
+        }));
+        expect(index.neighbors('note://workspace/v1/a.md', 5, ['explicit'])).toEqual([
+            expect.objectContaining({ id: 'B', edgeKind: 'explicit' }),
+        ]);
+        expect(index.statistics({ includeProvenance: true })).toEqual(expect.objectContaining({
+            projectionVersion: 1,
+            edgeCount: 2,
+            explicitEdgeCount: 1,
+            inferredEdgeCount: 1,
+        }));
+    });
+    test('resolves a source URI in bounded path queries', () => {
+        const index = analyzer.createMobileExactIndex({
+            nodes: [
+                { id: 'A', sourceUri: 'note://workspace/v1/a.md' },
+                { id: 'B', sourceUri: 'note://workspace/v1/b.md' },
+            ],
+            edges: [{ source: 'A', target: 'B', type: 'sequence' }],
+        });
+        expect(index.shortestPath('note://workspace/v1/a.md', 'note://workspace/v1/b.md', 4, 10)).toEqual(['A', 'B']);
+    });
+    test('resolves a path-derived canonical id without changing the legacy node id', () => {
+        const index = analyzer.createMobileExactIndex({
+            nodes: [{ id: 'Index', canonicalId: 'algebra/index', label: 'Index' }],
+            edges: [],
+        });
+        expect(index.searchExact('algebra/index', 5)).toEqual([
+            expect.objectContaining({ id: 'Index', canonicalId: 'algebra/index' }),
+        ]);
+    });
+    test('builds a bounded prerequisite-aware learning route from explicit graph edges', () => {
+        const index = analyzer.createMobileExactIndex({
+            nodes: [
+                { id: 'water', label: 'Water molecules' },
+                { id: 'ice', label: 'Amorphous ice' },
+                { id: 'rdf', label: 'Radial distribution function g(r)' },
+                { id: 'application', label: 'Applications' },
+            ],
+            edges: [
+                { source: 'water', target: 'ice', type: 'explicit-prerequisite' },
+                { source: 'ice', target: 'rdf', type: 'sequence' },
+                { source: 'ice', target: 'application', type: 'application' },
+            ],
+        });
+        expect(index.learningRoute('ice', 6)).toEqual([
+            expect.objectContaining({ nodeId: 'water', role: 'prerequisite', order: 1, orderingBasis: 'explicit_prerequisite' }),
+            expect.objectContaining({ nodeId: 'ice', role: 'core', order: 2 }),
+            expect.objectContaining({ nodeId: 'rdf', role: 'mechanism', order: 3 }),
+            expect.objectContaining({ nodeId: 'application', role: 'application', order: 4 }),
+        ]);
+        expect(index.learningRoute('ice', 2)).toHaveLength(2);
+    });
+});

package/dist/src/notemd/AppConfigToml.js

@@ -48,6 +48,7 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const TOML = __importStar(require("@iarna/toml"));
 const constants_1 = require("./constants");
+const providerTemplates_1 = require("./providerTemplates");
 const NOTEMD_BOOLEAN_KEYS = [
     'developerMode',
     'useCustomConceptNoteFolder',
@@ -142,8 +143,8 @@ exports.DEFAULT_PATH_MODE_SETTINGS = {
     auto_reconstruct: true,
     retain_history: true,
     focus_mode: true,
-    background: 'belfast_sunset_puresky_4k.exr',
-    bg_brightness: 1.0,
+    background: '',
+    bg_brightness: 0.1,
     reading_mode: 'window',
     reader_render_mode: 'render',
     reader_toggle_source_shortcut: 'Ctrl+M',
@@ -382,7 +383,7 @@ function normalizePathModeSettingsValue(raw) {
     }
     const brightness = readNumber(section, 'bg_brightness');
     if (typeof brightness === 'number') {
-        merged.bg_brightness = clampNumber(brightness, 0.01, 10.0);
+        merged.bg_brightness = clampNumber(brightness, 0.0, 0.1);
     }
     merged.reading_mode = normalizePathModeReadingMode(readString(section, 'reading_mode') || merged.reading_mode);
     merged.reader_render_mode = normalizePathModeRenderMode(readString(section, 'reader_render_mode') || merged.reader_render_mode);
@@ -597,7 +598,7 @@ function extractNotemdSettingsFromAppConfig(appConfig) {
     return mergedSettings;
 }
 function applyNotemdSettingsToAppConfig(appConfig, settings) {
-    const nextNotemdSection = isObjectRecord(appConfig.notemd) ? { ...appConfig.notemd } : {};
+    let nextNotemdSection = isObjectRecord(appConfig.notemd) ? { ...appConfig.notemd } : {};
     const activeProvider = settings.providers.find((provider) => provider.name === settings.activeProvider) ||
         settings.providers[0] ||
         constants_1.DEFAULT_SETTINGS.providers[0];
@@ -656,6 +657,7 @@ function applyNotemdSettingsToAppConfig(appConfig, settings) {
         api_version: activeProvider.apiVersion || '',
         temperature: activeProvider.temperature,
     };
+    nextNotemdSection = (0, providerTemplates_1.mergeProviderTemplatesIntoNotemdSection)(nextNotemdSection);
     return {
         ...appConfig,
         notemd: nextNotemdSection,