noteconnection 1.7.0 → 1.9.0

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

@@ -0,0 +1,184 @@
+"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"));
+describe('sidecar input freshness contract', () => {
+    const fingerprintPath = path.join(__dirname, '..', 'scripts', 'sidecar-build-fingerprint.js');
+    let fingerprint;
+    beforeAll(() => {
+        fingerprint = require(fingerprintPath);
+    });
+    test('content fingerprint changes even when an input keeps an older mtime', () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-sidecar-fingerprint-'));
+        const distRoot = path.join(repoRoot, 'dist', 'src');
+        try {
+            fs.mkdirSync(distRoot, { recursive: true });
+            fs.mkdirSync(path.join(repoRoot, 'scripts'), { recursive: true });
+            fs.writeFileSync(path.join(repoRoot, 'package.json'), '{"name":"fixture"}', 'utf8');
+            fs.writeFileSync(path.join(repoRoot, 'tsconfig.json'), '{}', 'utf8');
+            fs.writeFileSync(path.join(repoRoot, 'scripts', 'build-sidecar.js'), 'build-v1', 'utf8');
+            const entryPath = path.join(distRoot, 'server.js');
+            fs.writeFileSync(entryPath, 'payload-v1', 'utf8');
+            const before = fingerprint.computeSidecarInputFingerprint(repoRoot);
+            fs.writeFileSync(entryPath, 'payload-v2', 'utf8');
+            const after = fingerprint.computeSidecarInputFingerprint(repoRoot);
+            expect(after.digest).not.toBe(before.digest);
+            expect(after.files.some((file) => file.path === 'dist/src/server.js')).toBe(true);
+        }
+        finally {
+            fs.rmSync(repoRoot, { recursive: true, force: true });
+        }
+    });
+    test('manifest validation rejects a stale packaged input and accepts the current digest', () => {
+        const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-sidecar-manifest-'));
+        try {
+            fs.mkdirSync(path.join(repoRoot, 'dist', 'src'), { recursive: true });
+            fs.mkdirSync(path.join(repoRoot, 'scripts'), { recursive: true });
+            fs.writeFileSync(path.join(repoRoot, 'package.json'), '{"name":"fixture"}', 'utf8');
+            fs.writeFileSync(path.join(repoRoot, 'tsconfig.json'), '{}', 'utf8');
+            fs.writeFileSync(path.join(repoRoot, 'scripts', 'build-sidecar.js'), 'build-v1', 'utf8');
+            const entryPath = path.join(repoRoot, 'dist', 'src', 'server.js');
+            fs.writeFileSync(entryPath, 'payload-v1', 'utf8');
+            fingerprint.writeSidecarBuildManifest(repoRoot, ['server-fixture']);
+            expect(fingerprint.isSidecarBuildManifestCurrent(repoRoot)).toBe(true);
+            fs.writeFileSync(entryPath, 'payload-v2', 'utf8');
+            expect(fingerprint.isSidecarBuildManifestCurrent(repoRoot)).toBe(false);
+            expect(fingerprint.readSidecarBuildManifest(repoRoot)).not.toBeNull();
+        }
+        finally {
+            fs.rmSync(repoRoot, { recursive: true, force: true });
+        }
+    });
+    test('build and ensure scripts consume the same manifest contract', () => {
+        const buildSource = fs.readFileSync(path.join(repoRoot(), 'scripts', 'build-sidecar.js'), 'utf8');
+        const ensureSource = fs.readFileSync(path.join(repoRoot(), 'scripts', 'ensure-sidecar-ready.js'), 'utf8');
+        expect(buildSource).toContain("require('./sidecar-build-fingerprint.js')");
+        expect(buildSource).toContain('writeSidecarBuildManifest');
+        expect(ensureSource).toContain("require('./sidecar-build-fingerprint.js')");
+        expect(ensureSource).toContain('isSidecarBuildManifestCurrent');
+        expect(ensureSource).toContain('Sidecar input fingerprint is missing or stale');
+    });
+    test('uncompiled source changes invalidate otherwise unchanged packaged inputs', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-source-fingerprint-'));
+        try {
+            fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+            fs.mkdirSync(path.join(root, 'dist', 'src'), { recursive: true });
+            const source = path.join(root, 'src', 'server.ts');
+            fs.writeFileSync(source, 'const revision = 1;\r\n');
+            fs.writeFileSync(path.join(root, 'dist', 'src', 'server.js'), 'const revision = 1;\n');
+            fingerprint.writeSidecarBuildManifest(root, ['server-fixture']);
+            const inputs = fingerprint.computeSidecarInputFingerprint(root).digest;
+            fs.writeFileSync(source, 'const revision = 1;\n');
+            expect(fingerprint.isSidecarBuildManifestCurrent(root)).toBe(true);
+            fs.writeFileSync(source, 'const revision = 2;\n');
+            expect(fingerprint.computeSidecarInputFingerprint(root).digest).toBe(inputs);
+            expect(fingerprint.isSidecarBuildManifestCurrent(root)).toBe(false);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    test('Rust WASM compiler caches do not change source identity', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-source-cache-'));
+        try {
+            const source = path.join(root, 'src', 'backend', 'wasm', 'src');
+            fs.mkdirSync(source, { recursive: true });
+            fs.writeFileSync(path.join(source, 'lib.rs'), 'pub fn compute() {}\n');
+            const before = fingerprint.computeSidecarSourceFingerprint(root);
+            const cache = path.join(root, 'src', 'backend', 'wasm', 'target', 'release');
+            fs.mkdirSync(cache, { recursive: true });
+            fs.writeFileSync(path.join(cache, '.rustc_info.json'), '{"host":"one"}');
+            fs.writeFileSync(path.join(cache, 'compiler-output.rlib'), Buffer.from([0, 1, 2, 3]));
+            expect(fingerprint.computeSidecarSourceFingerprint(root)).toEqual(before);
+            fs.writeFileSync(path.join(source, 'lib.rs'), 'pub fn compute() { panic!(); }\n');
+            expect(fingerprint.computeSidecarSourceFingerprint(root).digest).not.toBe(before.digest);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    test.each(['Cargo.lock', 'src/lib.rs'])('%s has the same source identity under LF and CRLF checkouts', (relativePath) => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-source-newline-'));
+        try {
+            const file = path.join(root, 'src', 'backend', 'wasm', relativePath);
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, 'first line\nsecond line\n');
+            const before = fingerprint.computeSidecarSourceFingerprint(root).digest;
+            fs.writeFileSync(file, 'first line\r\nsecond line\r\n');
+            expect(fingerprint.computeSidecarSourceFingerprint(root).digest).toBe(before);
+            fs.writeFileSync(file, 'first line\nchanged line\n');
+            expect(fingerprint.computeSidecarSourceFingerprint(root).digest).not.toBe(before);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    test('ordinary target directories and new tests remain source inputs', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-source-target-'));
+        try {
+            const directory = path.join(root, 'src', 'learning', 'target');
+            fs.mkdirSync(directory, { recursive: true });
+            const initial = fingerprint.computeSidecarSourceFingerprint(root).digest;
+            fs.writeFileSync(path.join(directory, 'Reducer.ts'), 'export const revision = 1;\n');
+            const withSource = fingerprint.computeSidecarSourceFingerprint(root).digest;
+            expect(withSource).not.toBe(initial);
+            fs.writeFileSync(path.join(directory, 'Reducer.test.ts'), 'test("revision", () => {});\n');
+            expect(fingerprint.computeSidecarSourceFingerprint(root).digest).not.toBe(withSource);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+    test('compiled target directories remain fully bound by the artifact input fingerprint', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-dist-target-'));
+        try {
+            const directory = path.join(root, 'dist', 'src', 'backend', 'wasm', 'target');
+            fs.mkdirSync(directory, { recursive: true });
+            const file = path.join(directory, 'runtime.wasm');
+            fs.writeFileSync(file, Buffer.from([0, 1, 2, 3]));
+            const before = fingerprint.computeSidecarInputFingerprint(root).digest;
+            fs.writeFileSync(file, Buffer.from([0, 1, 2, 4]));
+            expect(fingerprint.computeSidecarInputFingerprint(root).digest).not.toBe(before);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});
+function repoRoot() {
+    return path.resolve(__dirname, '..');
+}

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

@@ -0,0 +1,131 @@
+"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('keeps the default Android build sidecar-free and makes Godot opt-in', () => {
+        const pkg = readJson(packageJsonPath);
+        const tauriAndroidConfig = readJson(tauriAndroidConfigPath);
+        const tauriLib = readText(tauriLibPath);
+        expect(pkg.scripts?.['tauri:android:dev']).toContain('npm run mobile:prepare:slim');
+        expect(pkg.scripts?.['tauri:android:build']).toContain('npm run mobile:prepare:slim');
+        expect(pkg.scripts?.['tauri:android:dev']).not.toContain('npm run build:sidecar');
+        expect(pkg.scripts?.['tauri:android:build']).not.toContain('npm run build:sidecar');
+        expect(tauriAndroidConfig.bundle?.externalBin || []).toEqual([]);
+        expect(tauriAndroidConfig.build?.frontendDist).toBe('../dist/mobile-slim/frontend');
+        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,155 @@
+"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('does not accept a malformed centralized archive digest', () => {
+        const fakeRepo = temp.mkdir('repo');
+        temp.mkdir(path.join('repo', '.github', 'workflows'));
+        temp.mkdir(path.join('repo', 'config'));
+        fs.copyFileSync(path.join(repoRoot, '.github/workflows/release-desktop-multi-os.yml'), path.join(fakeRepo, '.github/workflows/release-desktop-multi-os.yml'));
+        const runtime = JSON.parse(fs.readFileSync(path.join(repoRoot, 'config/godot-desktop-runtime.json'), 'utf8'));
+        runtime.archives.windows.sha256 = 'unverified';
+        fs.writeFileSync(path.join(fakeRepo, 'config/godot-desktop-runtime.json'), JSON.stringify(runtime));
+        const result = utils.evaluateSidecarSupplyReadiness({ repoRoot: fakeRepo, platform: 'linux', arch: 'x64', env: {} });
+        expect(result.ci.releaseWorkflowArchiveDigestPinned).toBe(false);
+    });
+    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/simulation.worker.offline.test.js

@@ -0,0 +1,104 @@
+"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"));
+const vm = __importStar(require("vm"));
+describe('offline graph simulation worker', () => {
+    beforeEach(() => jest.useFakeTimers());
+    afterEach(() => {
+        jest.clearAllTimers();
+        jest.useRealTimers();
+    });
+    test.each(['force', 'dag'])('computes %s layout using only packaged dependencies', (mode) => {
+        const frontend = path.join(__dirname, 'frontend');
+        const ticks = [];
+        const worker = vm.createContext({
+            console: { log() { }, warn() { }, error() { } },
+            Date,
+            performance: { now: () => Date.now() },
+            setTimeout,
+            clearTimeout,
+            setInterval,
+            clearInterval,
+            postMessage(message) {
+                if (message.type === 'tick')
+                    ticks.push(message);
+            },
+        });
+        worker.self = worker;
+        worker.importScripts = (...scripts) => {
+            for (const script of scripts) {
+                const url = new URL(script, 'http://appimage.local/simulationWorker.js');
+                if (url.origin !== 'http://appimage.local') {
+                    throw new Error(`External network is disabled: ${url.href}`);
+                }
+                const filename = path.join(frontend, url.pathname);
+                vm.runInContext(fs.readFileSync(filename, 'utf8'), worker, { filename });
+            }
+        };
+        vm.runInContext(fs.readFileSync(path.join(frontend, 'simulationWorker.js'), 'utf8'), worker);
+        worker.onmessage({ data: { type: 'init', payload: {
+                    nodes: [{ id: 'start', rank: 0 }, { id: 'middle', rank: 1 }, { id: 'end', rank: 2 }],
+                    links: [{ source: 'start', target: 'middle' }, { source: 'middle', target: 'end' }],
+                    width: 800,
+                    height: 600,
+                    settings: { gpuRendering: false },
+                } } });
+        if (mode === 'dag')
+            worker.onmessage({ data: { type: 'updateLayout', payload: { mode, width: 800 } } });
+        jest.advanceTimersByTime(2500);
+        worker.onmessage({ data: { type: 'stop' } });
+        expect(ticks.length).toBeGreaterThan(5);
+        const first = ticks[0];
+        const last = ticks[ticks.length - 1];
+        expect(last.tickMode).toBe('full');
+        expect(last.nodes.map(node => node.id)).toEqual(['start', 'middle', 'end']);
+        expect(Number.isFinite(last.alpha)).toBe(true);
+        expect(last.alpha).toBeLessThan(first.alpha);
+        for (const node of last.nodes) {
+            expect(Number.isFinite(node.x)).toBe(true);
+            expect(Number.isFinite(node.y)).toBe(true);
+            for (const other of last.nodes.filter(other => other.id !== node.id)) {
+                expect(Math.hypot(node.x - other.x, node.y - other.y)).toBeGreaterThan(1);
+            }
+        }
+        expect(last.nodes.some((node, index) => Math.hypot(node.x - first.nodes[index].x, node.y - first.nodes[index].y) > 1)).toBe(true);
+        if (mode === 'dag') {
+            expect(last.nodes[0].y).toBeLessThan(last.nodes[1].y);
+            expect(last.nodes[1].y).toBeLessThan(last.nodes[2].y);
+        }
+    });
+});

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"');
+    });
 });