noteconnection 1.6.8 → 1.8.0

package/dist/src/shared/types.contract.test.js

@@ -0,0 +1,107 @@
+"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 });
+/**
+ * Shared types contract test — validates shared type module integrity.
+ */
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+describe('shared types module', () => {
+    const sharedDir = path.resolve(__dirname);
+    const typesFile = path.join(sharedDir, 'types.ts');
+    test('shared types file exists on disk', () => {
+        expect(fs.existsSync(typesFile)).toBe(true);
+    });
+    test('shared types file is under 350 lines (contract boundary discipline, v2.9 expanded for CI contracts)', () => {
+        const source = fs.readFileSync(typesFile, 'utf8');
+        const lines = source.split('\n').length;
+        expect(lines).toBeLessThan(350);
+    });
+    test('shared types file contains canonical contract documentation', () => {
+        const source = fs.readFileSync(typesFile, 'utf8');
+        expect(source).toContain('Shared contract types');
+        expect(source).toContain('single source of truth');
+        expect(source).toContain('API contract boundary');
+    });
+    test('shared types re-exports from learning/types', () => {
+        const source = fs.readFileSync(typesFile, 'utf8');
+        expect(source).toContain("from '../learning/types'");
+        // Verify key contract types are re-exported
+        expect(source).toContain('KnowledgeAtom');
+        expect(source).toContain('KnowledgeQueryRequest');
+        expect(source).toContain('KnowledgeQueryResponse');
+        expect(source).toContain('AgentConversationRequest');
+        expect(source).toContain('AgentConversationResponse');
+    });
+    test('shared types defines RuntimeCapabilityContract', () => {
+        const source = fs.readFileSync(typesFile, 'utf8');
+        expect(source).toContain('RuntimeCapabilityContract');
+        expect(source).toContain('capabilityId');
+        expect(source).toContain('status');
+    });
+    test('shared types defines AgentWorkspaceContract', () => {
+        const source = fs.readFileSync(typesFile, 'utf8');
+        expect(source).toContain('AgentWorkspaceContract');
+        expect(source).toContain('conversationId');
+        expect(source).toContain('activePaneId');
+    });
+    test('shared types defines Notemd CLI and workflow contracts', () => {
+        const source = fs.readFileSync(typesFile, 'utf8');
+        expect(source).toContain('NotemdCliOperationContract');
+        expect(source).toContain('NotemdCliInvocationContract');
+        expect(source).toContain('NotemdWorkflowStageContract');
+        expect(source).toContain('NotemdWorkflowResultContract');
+    });
+    test('shared types defines Search and Diagram contracts', () => {
+        const source = fs.readFileSync(typesFile, 'utf8');
+        expect(source).toContain('SearchResultItemContract');
+        expect(source).toContain('SearchResultContract');
+        expect(source).toContain('DiagramGenerationContract');
+        expect(source).toContain('NotemdSettingsContract');
+    });
+    test('shared types defines CI and Infrastructure contracts (GitNexus pattern)', () => {
+        const source = fs.readFileSync(typesFile, 'utf8');
+        expect(source).toContain('CiGateStatusContract');
+        expect(source).toContain('CiDashboardContract');
+        expect(source).toContain('SnapshotStalenessContract');
+    });
+    test('SnapshotStalenessContract has staleness tracking fields', () => {
+        const source = fs.readFileSync(typesFile, 'utf8');
+        expect(source).toContain('lastSaveAt');
+        expect(source).toContain('staleSince');
+        expect(source).toContain('fileMtime');
+        expect(source).toContain('isStale');
+    });
+});

package/dist/src/shared/types.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * src/shared/types.ts — Shared contract types
+ *
+ * This module defines and re-exports the canonical types shared between
+ * the frontend (.mjs) and backend (.ts) code. These types constitute the
+ * API contract boundary and should be treated as the single source of truth
+ * for cross-cutting type definitions.
+ *
+ * === Usage ===
+ * - Backend (TypeScript):  import type { KnowledgeAtom, ... } from '../shared/types';
+ * - Frontend (JavaScript): @typedef {import('../shared/types').KnowledgeAtom} KnowledgeAtom
+ *
+ * === Design Principle ===
+ * Types defined here belong to the API contract, not to any single module.
+ * They are versioned with the project and must remain backward-compatible
+ * within a major version.
+ *
+ * @module shared/types
+ * @version 2.3.0 — added Notemd CLI, workflow, search, diagram contracts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/sidecar.replacement.boundary.contract.test.js

@@ -0,0 +1,128 @@
+"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('sidecar replacement boundary contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const packageJsonPath = path.join(repoRoot, 'package.json');
+    const tauriConfigPath = path.join(repoRoot, 'src-tauri', 'tauri.conf.json');
+    const tauriAndroidConfigPath = path.join(repoRoot, 'src-tauri', 'tauri.android.conf.json');
+    const tauriLibPath = path.join(repoRoot, 'src-tauri', 'src', 'lib.rs');
+    const sourceManagerPath = path.join(repoRoot, 'src', 'frontend', 'source_manager.js');
+    const pathAppPath = path.join(repoRoot, 'src', 'frontend', 'path_app.js');
+    const serverPath = path.join(repoRoot, 'src', 'server.ts');
+    const pathBridgePath = path.join(repoRoot, 'src', 'core', 'PathBridge.ts');
+    const buildSidecarPath = path.join(repoRoot, 'scripts', 'build-sidecar.js');
+    const buildMarkdownWorkerPath = path.join(repoRoot, 'scripts', 'build-markdown-worker.js');
+    const ensureSidecarReadyPath = path.join(repoRoot, 'scripts', 'ensure-sidecar-ready.js');
+    const ensureGodotSidecarPath = path.join(repoRoot, 'scripts', 'ensure-godot-sidecar.js');
+    const markdownGatewayPath = path.join(repoRoot, 'src', 'markdown', 'MarkdownGateway.ts');
+    function readText(filePath) {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    function readJson(filePath) {
+        return JSON.parse(readText(filePath));
+    }
+    test('keeps node sidecar on the desktop build and startup path', () => {
+        const pkg = readJson(packageJsonPath);
+        const tauriConfig = readJson(tauriConfigPath);
+        const tauriLib = readText(tauriLibPath);
+        const sourceManager = readText(sourceManagerPath);
+        expect(pkg.scripts?.['build:sidecar']).toContain('node scripts/build-sidecar.js');
+        expect(pkg.scripts?.['tauri:build']).toContain('npm run build:sidecar');
+        expect(pkg.scripts?.['tauri:dev']).toContain('npm run ensure:sidecar:dev');
+        expect(tauriConfig.bundle?.externalBin || []).toContain('bin/server');
+        expect(tauriLib).toContain('let mut sidecar_command = app.shell().sidecar("server").unwrap();');
+        expect(tauriLib).toContain('Failed to spawn Node.js sidecar');
+        expect(sourceManager).toContain('if (runtimeCaps.supports_sidecar) {');
+        expect(sourceManager).toContain('const sidecarData = await fetchFoldersViaSidecar();');
+    });
+    test('keeps Godot bootstrap and spawn flow as part of the desktop contract', () => {
+        const pkg = readJson(packageJsonPath);
+        const tauriConfig = readJson(tauriConfigPath);
+        const tauriLib = readText(tauriLibPath);
+        const ensureSidecarReady = readText(ensureSidecarReadyPath);
+        const ensureGodotSidecar = readText(ensureGodotSidecarPath);
+        expect(pkg.scripts?.['prepare:godot:bin']).toBe('node scripts/ensure-godot-sidecar.js');
+        expect(tauriConfig.bundle?.externalBin || []).toContain('bin/godot');
+        expect(ensureSidecarReady).toContain("runNpmScript('prepare:godot:bin')");
+        expect(ensureGodotSidecar).toContain('prepareGodotSidecar');
+        expect(ensureGodotSidecar).toContain('resolveGodotBootstrapContext');
+        expect(tauriLib).toContain('match resolve_godot_executable(&project_root)');
+        expect(tauriLib).toContain('let mut godot_command = std::process::Command::new(&godot_exe);');
+        expect(tauriLib).toContain('Successfully spawned local Godot application.');
+    });
+    test('keeps markdown worker as a sidecar-era desktop dependency', () => {
+        const tauriConfig = readJson(tauriConfigPath);
+        const buildSidecar = readText(buildSidecarPath);
+        const buildMarkdownWorker = readText(buildMarkdownWorkerPath);
+        const markdownGateway = readText(markdownGatewayPath);
+        const server = readText(serverPath);
+        expect(tauriConfig.bundle?.externalBin || []).toContain('bin/markdown-worker');
+        expect(buildSidecar).toContain('runMarkdownWorkerBuild(');
+        expect(buildMarkdownWorker).toContain("outputName: 'markdown-worker-x86_64-pc-windows-msvc.exe'");
+        expect(buildMarkdownWorker).toContain("outputName: 'markdown-worker-x86_64-unknown-linux-gnu'");
+        expect(markdownGateway).toContain("return 'markdown-worker-x86_64-pc-windows-msvc.exe';");
+        expect(markdownGateway).toContain("return 'markdown-worker-x86_64-unknown-linux-gnu';");
+        expect(server).toContain("if (postPathname === '/api/markdown/resolve-node') {");
+        expect(server).toContain("if (postPathname === '/api/markdown/resolve-wiki') {");
+    });
+    test('keeps PathBridge as the desktop Godot synchronization boundary', () => {
+        const server = readText(serverPath);
+        const pathBridge = readText(pathBridgePath);
+        const sourceManager = readText(sourceManagerPath);
+        const pathApp = readText(pathAppPath);
+        expect(server).toContain("import { PathBridge } from './core/PathBridge';");
+        expect(server).toContain('pathBridge = new PathBridge({');
+        expect(server).toContain('PathBridge initialized on ws://');
+        expect(pathBridge).toContain("console.log('[PathBridge] Godot requested path data');");
+        expect(sourceManager).toContain('const bootstrapDesktopPathProducer = () => {');
+        expect(sourceManager).toContain('window.pathApp.setupEarlyWebSocket({');
+        expect(pathApp).toContain("window.NoteConnectionRuntime.getBridgeWsUrl('frontend')");
+        expect(pathApp).toContain("this._sendBridgeMessage('identify', this._getBridgeIdentifyPayload('frontend'))");
+    });
+    test('shows Android runtime decoupling without full build-chain decoupling yet', () => {
+        const pkg = readJson(packageJsonPath);
+        const tauriAndroidConfig = readJson(tauriAndroidConfigPath);
+        const tauriLib = readText(tauriLibPath);
+        expect(pkg.scripts?.['tauri:android:dev']).toContain('npm run build:sidecar');
+        expect(pkg.scripts?.['tauri:android:build']).toContain('npm run build:sidecar');
+        expect(tauriAndroidConfig.bundle?.externalBin || []).toEqual([]);
+        expect(tauriLib).toContain('supports_sidecar: false');
+        expect(tauriLib).toContain('supports_build: true');
+        expect(tauriLib).toContain('Android startup: desktop sidecar and Godot launch are intentionally disabled.');
+    });
+});

package/dist/src/sidecar.supply.readiness.contract.test.js

@@ -0,0 +1,144 @@
+"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"));
+class TempDir {
+    constructor(prefix) {
+        this.path = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), `${prefix}-`));
+    }
+    child(relative) {
+        return path.join(this.path, relative);
+    }
+    mkdir(relative) {
+        const target = this.child(relative);
+        fs.mkdirSync(target, { recursive: true });
+        return target;
+    }
+    cleanup() {
+        fs.rmSync(this.path, { recursive: true, force: true });
+    }
+}
+describe('sidecar supply readiness contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const packageJsonPath = path.join(repoRoot, 'package.json');
+    const utilsPath = path.join(repoRoot, 'scripts', 'sidecar-supply-readiness-utils.js');
+    let utils;
+    let temp;
+    beforeAll(() => {
+        utils = require(utilsPath);
+    });
+    beforeEach(() => {
+        temp = new TempDir('noteconnection-sidecar-supply');
+    });
+    afterEach(() => {
+        temp.cleanup();
+    });
+    test('package exposes a local sidecar supply verifier command', () => {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        expect(pkg.scripts?.['verify:sidecar:supply']).toBe('node scripts/verify-sidecar-supply-readiness.js');
+    });
+    test('reports offline-ready when host artifacts already exist locally', () => {
+        const fakeRepo = temp.mkdir('repo');
+        const binDir = temp.mkdir(path.join('repo', 'src-tauri', 'bin'));
+        temp.mkdir(path.join('repo', '.github', 'workflows'));
+        fs.writeFileSync(path.join(fakeRepo, '.gitattributes'), '');
+        fs.writeFileSync(path.join(binDir, 'server-x86_64-unknown-linux-gnu'), 'server');
+        fs.writeFileSync(path.join(binDir, 'markdown-worker-x86_64-unknown-linux-gnu'), 'worker');
+        fs.writeFileSync(path.join(binDir, 'godot-x86_64-unknown-linux-gnu'), Buffer.alloc(1024 * 1024 + 64, 7));
+        const result = utils.evaluateSidecarSupplyReadiness({
+            repoRoot: fakeRepo,
+            platform: 'linux',
+            arch: 'x64',
+            env: {},
+        });
+        expect(result.offlineBootstrapReady).toBe(true);
+        expect(result.rating).toBe('offline-ready');
+        expect(result.artifacts.server.ready).toBe(true);
+        expect(result.artifacts.markdownWorker.ready).toBe(true);
+        expect(result.artifacts.godot.ready).toBe(true);
+        expect(result.artifacts.godot.networkRequiredForBootstrap).toBe(false);
+        expect(result.ci.releaseWorkflowMirrorFirstDownload).toBe(false);
+        expect(result.ci.releaseWorkflowDirectUpstreamDownload).toBe(false);
+        expect(result.ci.releaseWorkflowArchiveDigestPinned).toBe(false);
+        expect(result.ci.releaseWorkflowMirrorOnlyModeAvailable).toBe(false);
+        expect(result.ci.releaseWorkflowDefaultUpstreamFallbackEnabled).toBe(false);
+    });
+    test('reports network-dependent when godot is only reachable through configured download fallback', () => {
+        const fakeRepo = temp.mkdir('repo');
+        const binDir = temp.mkdir(path.join('repo', 'src-tauri', 'bin'));
+        temp.mkdir(path.join('repo', '.github', 'workflows'));
+        fs.writeFileSync(path.join(fakeRepo, '.gitattributes'), '');
+        fs.writeFileSync(path.join(binDir, 'server-x86_64-unknown-linux-gnu'), 'server');
+        fs.writeFileSync(path.join(binDir, 'markdown-worker-x86_64-unknown-linux-gnu'), 'worker');
+        const result = utils.evaluateSidecarSupplyReadiness({
+            repoRoot: fakeRepo,
+            platform: 'linux',
+            arch: 'x64',
+            env: {
+                NOTE_CONNECTION_GODOT_DOWNLOAD_URL: 'https://mirror.example/godot.zip',
+                NOTE_CONNECTION_GODOT_DOWNLOAD_SHA256: 'a'.repeat(64),
+            },
+        });
+        expect(result.offlineBootstrapReady).toBe(false);
+        expect(result.rating).toBe('network-dependent');
+        expect(result.artifacts.godot.ready).toBe(false);
+        expect(result.artifacts.godot.downloadConfigured).toBe(true);
+        expect(result.artifacts.godot.pinnedDownload).toBe(true);
+        expect(result.artifacts.godot.networkRequiredForBootstrap).toBe(true);
+        expect(result.artifacts.godot.sourceKindsAvailable).toContain('download');
+    });
+    test('current repo pins archive digests and can disable upstream fallback for mirror-only release smoke runs', () => {
+        const result = utils.evaluateSidecarSupplyReadiness({
+            repoRoot,
+            platform: 'linux',
+            arch: 'x64',
+            env: {},
+        });
+        expect(result.ci.releaseWorkflowMirrorFirstDownload).toBe(true);
+        expect(result.ci.releaseWorkflowDirectUpstreamDownload).toBe(true);
+        expect(result.ci.releaseWorkflowArchiveDigestPinned).toBe(true);
+        expect(result.ci.releaseWorkflowMirrorOnlyModeAvailable).toBe(true);
+        expect(result.ci.releaseWorkflowDefaultUpstreamFallbackEnabled).toBe(true);
+        expect(result.legacyLfsProtectedPaths).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(result.recommendations).toContain('Keep the release workflow mirror-first, keep archive digest pinning enforced, exercise mirror-only smoke runs regularly, and remove default upstream fallback reliance before strict no-LFS mode.');
+    });
+});

package/dist/src/source_manager.loadflow.test.js

@@ -79,6 +79,7 @@ describe('source manager load-flow guards', () => {
     test('waits for sidecar readiness and retries data.js fetch during tauri startup race', () => {
         const source = fs.readFileSync(sourceManagerPath, 'utf8');
         expect(source).toContain('const waitForSidecarReady = async () => {');
+        expect(source).toContain("if (window.__TAURI__ && runtimeCaps.supports_sidecar) {");
         expect(source).toContain('await waitForSidecarReady();');
         expect(source).toContain("data.js fetch raced sidecar startup, retrying");
         expect(source).toContain('const maxAttempts = (window.__TAURI__ && runtimeCaps.supports_sidecar) ? 20 : 1;');
@@ -88,6 +89,7 @@ describe('source manager load-flow guards', () => {
     });
     test('parses graph payload fallback without runtime eval', () => {
         const source = fs.readFileSync(sourceManagerPath, 'utf8');
+        expect(source).toContain('const extractAssignedJson = (sourceText, equalsIndex) => {');
         expect(source).toContain('const assignmentTargets = [');
         expect(source).not.toContain('new Function(');
         expect(source).toContain('Invalid graph data payload from sidecar (unsupported format).');
@@ -114,6 +116,31 @@ describe('source manager load-flow guards', () => {
         expect(indexHtml.indexOf('<script src="runtime_bridge.js"></script>')).toBeLessThan(indexHtml.indexOf('<script src="source_manager.js"></script>'));
         expect(indexHtml.indexOf('<script src="storage_provider.js"></script>')).toBeLessThan(indexHtml.indexOf('<script src="source_manager.js"></script>'));
     });
+    test('disables ES module bootstrap when the legacy script chain is already active', () => {
+        const indexPath = path.join(repoRoot, 'src', 'frontend', 'index.html');
+        const mainModulePath = path.join(repoRoot, 'src', 'frontend', 'main.mjs');
+        const indexHtml = fs.readFileSync(indexPath, 'utf8');
+        const mainModule = fs.readFileSync(mainModulePath, 'utf8');
+        expect(indexHtml).toContain('<script type="module" src="./main.mjs"></script>');
+        expect(indexHtml).not.toContain('window.__NC_DISABLE_MODULE_BOOT = true;');
+        expect(mainModule).toContain('function shouldSkipModuleBootstrap()');
+        expect(mainModule).toContain('window.i18n || window.NoteConnectionRuntime || window.settingsManager');
+        expect(mainModule).toContain("src.endsWith('i18n.js')");
+        expect(mainModule).toContain("await import('./i18n.mjs');");
+        expect(mainModule).not.toContain("import './i18n.mjs';");
+    });
+    test('allows Tauri ipc localhost in frontend CSP without relying on meta frame-ancestors', () => {
+        const indexPath = path.join(repoRoot, 'src', 'frontend', 'index.html');
+        const notemdPath = path.join(repoRoot, 'src', 'frontend', 'notemd.html');
+        const indexHtml = fs.readFileSync(indexPath, 'utf8');
+        const notemdHtml = fs.readFileSync(notemdPath, 'utf8');
+        expect(indexHtml).toContain("http://ipc.localhost");
+        expect(indexHtml).toContain("ipc:");
+        expect(indexHtml).not.toContain("frame-ancestors");
+        expect(notemdHtml).toContain("http://ipc.localhost");
+        expect(notemdHtml).toContain("ipc:");
+        expect(notemdHtml).not.toContain("frame-ancestors");
+    });
     test('loads runtime bridge before path_app on the dedicated path mode page', () => {
         const pathHtmlPath = path.join(repoRoot, 'src', 'frontend', 'path.html');
         const pathHtml = fs.readFileSync(pathHtmlPath, 'utf8');
@@ -135,4 +162,23 @@ describe('source manager load-flow guards', () => {
         expect(pathAppSource).toContain("bridge.whenReady()");
         expect(() => new (require('vm').Script)(pathAppSource)).not.toThrow();
     });
+    test('keeps analysis panel resilient when graphData is not available yet', () => {
+        const analysisPath = path.join(repoRoot, 'src', 'frontend', 'analysis.js');
+        const analysisSource = fs.readFileSync(analysisPath, 'utf8');
+        expect(analysisSource).toContain('function getGraphDataSafe()');
+        expect(analysisSource).toContain('return { nodes: [], edges: [] };');
+        expect(analysisSource).toContain("const tot = graphData ? graphData.nodes.length : 0;");
+    });
+    test('treats detached frontend preview pages as backend-less runtimes and loads data assets via validated text parsing', () => {
+        const source = fs.readFileSync(sourceManagerPath, 'utf8');
+        const enLocale = fs.readFileSync(path.join(repoRoot, 'src', 'frontend', 'locales', 'en.json'), 'utf8');
+        const zhLocale = fs.readFileSync(path.join(repoRoot, 'src', 'frontend', 'locales', 'zh.json'), 'utf8');
+        expect(source).toContain('const canUseBrowserRuntimeBackend = () => {');
+        expect(source).toContain("Frontend preview runtime detected: backend-dependent APIs disabled");
+        expect(source).toContain('const isStandaloneFrontendPreviewRuntime = () =>');
+        expect(source).toContain('Loaded ${src} via frontend preview asset');
+        expect(source).toContain("previewOption.textContent = t('source.previewPath')");
+        expect(enLocale).toContain('"previewPath"');
+        expect(zhLocale).toContain('"previewPath"');
+    });
 });

package/dist/src/startup.layout.snapshot.contract.test.js

@@ -0,0 +1,57 @@
+"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('startup layout snapshot contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const appPath = path.join(repoRoot, 'src', 'frontend', 'app.js');
+    test('rejects and purges degenerate persisted layout snapshots', () => {
+        const source = fs.readFileSync(appPath, 'utf8');
+        expect(source).toContain('async function deleteStartupLayoutSnapshotRecord(fingerprint)');
+        expect(source).toContain("reason: 'degenerate-layout'");
+        expect(source).toContain("reason: 'degenerate-layout-vs-source'");
+        expect(source).toContain('function isDegenerateLayoutSummary(summary)');
+        expect(source).toContain('function isSnapshotLayoutCollapsedVsSource(summary, sourceSummary)');
+        expect(source).toContain('if (validation.purge === true && record.fingerprint)');
+    });
+    test('restores startup snapshots without re-applying persisted fx/fy pinning and re-seeds collapsed layouts', () => {
+        const source = fs.readFileSync(appPath, 'utf8');
+        expect(source).toContain('n.fx = null;');
+        expect(source).toContain('n.fy = null;');
+        expect(source).toContain("restoreSourceLayoutOrJitterNodes(nodes, width, height, 'worker-init');");
+        expect(source).toContain('function restoreSourceLayoutOrJitterNodes(nodeList, viewportWidth, viewportHeight, reason = \'\')');
+    });
+});

package/dist/src/tauri.frontend.build.contract.test.js

@@ -0,0 +1,60 @@
+"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('tauri frontend build contracts', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const packageJsonPath = path.join(repoRoot, 'package.json');
+    const tauriConfigPath = path.join(repoRoot, 'src-tauri', 'tauri.conf.json');
+    const wrapperScriptPath = path.join(repoRoot, 'scripts', 'run-tauri-frontend-build.js');
+    function readJson(filePath) {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    test('tauri full build keeps explicit frontend full-mode through tauri beforeBuildCommand', () => {
+        const packageJson = readJson(packageJsonPath);
+        const tauriConfig = readJson(tauriConfigPath);
+        const scripts = packageJson.scripts || {};
+        expect(tauriConfig.build?.beforeBuildCommand).toBe('node scripts/run-tauri-frontend-build.js');
+        expect(scripts['tauri:build:full']).toContain('node scripts/run-tauri-build.js --frontend-build-mode full');
+    });
+    test('tauri frontend build wrapper defaults to runtime-first and supports explicit full mode', () => {
+        const wrapper = require(wrapperScriptPath);
+        expect(wrapper.resolveFrontendBuildCommand()).toBe('npm run build');
+        expect(wrapper.resolveFrontendBuildCommand({ frontendBuildMode: 'runtime-first' })).toBe('npm run build');
+        expect(wrapper.resolveFrontendBuildCommand({ frontendBuildMode: 'full' })).toBe('npm run build:full');
+        expect(() => wrapper.resolveFrontendBuildCommand({ frontendBuildMode: 'legacy-full' })).toThrow(/Unsupported tauri frontend build mode/i);
+    });
+});

package/dist/src/tauri.sidecar.cleanup.contract.test.js

@@ -41,6 +41,7 @@ describe('tauri sidecar cleanup integration', () => {
     const cleanupScriptPath = path.join(repoRoot, 'scripts', 'cleanup-tauri-sidecars.js');
     const sidecarEnsureScriptPath = path.join(repoRoot, 'scripts', 'ensure-sidecar-ready.js');
     const tauriBuildRunnerPath = path.join(repoRoot, 'scripts', 'run-tauri-build.js');
+    const tauriDevRunnerPath = path.join(repoRoot, 'scripts', 'run-tauri-dev.js');
     const tauriRunnerPath = path.join(repoRoot, 'scripts', 'run-tauri-tests.js');
     test('desktop tauri scripts run stale sidecar cleanup before cargo build flow', () => {
         const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
@@ -51,6 +52,8 @@ describe('tauri sidecar cleanup integration', () => {
         expect(pkg.scripts['tauri:dev:mini']).toContain('npm run cleanup:tauri:sidecars');
         expect(pkg.scripts['tauri:dev']).toContain('npm run ensure:sidecar:dev');
         expect(pkg.scripts['tauri:dev:mini']).toContain('npm run ensure:sidecar:dev');
+        expect(pkg.scripts['tauri:dev']).toContain('node scripts/run-tauri-dev.js');
+        expect(pkg.scripts['tauri:dev:mini']).toContain('node scripts/run-tauri-dev.js');
         expect(pkg.scripts['tauri:build']).toContain('npm run cleanup:tauri:sidecars');
         expect(pkg.scripts['tauri:build:mini']).toContain('npm run cleanup:tauri:sidecars');
         expect(pkg.scripts['tauri:build']).toContain('node scripts/run-tauri-build.js');
@@ -64,6 +67,15 @@ describe('tauri sidecar cleanup integration', () => {
         expect(tauriBuildRunner).toContain('CARGO_PROFILE_RELEASE_OPT_LEVEL');
         expect(tauriBuildRunner).toContain('CARGO_PROFILE_RELEASE_CODEGEN_UNITS');
         expect(tauriBuildRunner).toContain("['tauri', 'build', '--ci'");
+        const tauriDevRunner = fs.readFileSync(tauriDevRunnerPath, 'utf8');
+        expect(tauriDevRunner).toContain('CARGO_TARGET_DIR');
+        expect(tauriDevRunner).toContain('target-dev-lowmem');
+        expect(tauriDevRunner).toContain('process.pid');
+        expect(tauriDevRunner).toContain('Date.now().toString(36)');
+        expect(tauriDevRunner).toContain('CARGO_BUILD_JOBS');
+        expect(tauriDevRunner).toContain('CARGO_PROFILE_DEV_DEBUG');
+        expect(tauriDevRunner).toContain('CARGO_INCREMENTAL');
+        expect(tauriDevRunner).toContain("['tauri', 'dev'");
         const sidecarEnsureScript = fs.readFileSync(sidecarEnsureScriptPath, 'utf8');
         expect(sidecarEnsureScript).toContain('Sidecar binaries are valid and up-to-date');
         expect(sidecarEnsureScript).toContain("runNodeScript('build-sidecar.js')");
@@ -71,9 +83,18 @@ describe('tauri sidecar cleanup integration', () => {
     });
     test('cleanup script targets copied tauri sidecars in debug and release outputs', () => {
         const script = fs.readFileSync(cleanupScriptPath, 'utf8');
+        expect(script).toContain("const defaultTargetRoots = [");
+        expect(script).toContain("path.join(repoRoot, 'src-tauri', 'target')");
+        expect(script).toContain("path.join(repoRoot, 'src-tauri', 'target-dev-lowmem')");
         expect(script).toContain("const targetModes = ['debug', 'release'];");
         expect(script).toContain("const sidecarNames = ['server', 'godot', 'markdown-worker'];");
+        expect(script).toContain('function resolveTargetRoots()');
+        expect(script).toContain('process.env.CARGO_TARGET_DIR');
         expect(script).toContain("targetRoot, mode, `${name}.exe`");
+        expect(script).toContain('function removeExistingArtifacts(targetPaths)');
+        expect(script).toContain('function runPowerShellNameFallbackCleanup(targetPath)');
+        expect(script).toContain('KILLED_BY_NAME|');
+        expect(script).toContain('[Tauri Sidecar Cleanup] REMOVED|');
         expect(script).toContain('Failed to terminate stale copied sidecars');
     });
 });