noteconnection 1.8.0 → 1.9.0

package/dist/src/sidecar.build.lock.contract.test.js

@@ -0,0 +1,201 @@
+"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 child_process_1 = require("child_process");
+function runChild(script, args = []) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(process.execPath, ['-e', script, ...args], {
+            cwd: path.resolve(__dirname, '..'),
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        let output = '';
+        child.stdout.on('data', (chunk) => { output += String(chunk); });
+        child.stderr.on('data', (chunk) => { output += String(chunk); });
+        child.once('error', reject);
+        child.once('close', (code) => resolve({ code, output }));
+    });
+}
+function waitForOutput(childScript, args = []) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(process.execPath, ['-e', childScript, ...args], {
+            cwd: path.resolve(__dirname, '..'),
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        let output = '';
+        let timer;
+        const onData = (chunk) => {
+            output += String(chunk);
+            if (output.includes('acquired')) {
+                clearTimeout(timer);
+                child.stdout.off('data', onData);
+                resolve({ child, output });
+            }
+        };
+        child.stdout.on('data', onData);
+        child.stderr.on('data', onData);
+        timer = setTimeout(() => {
+            child.kill();
+            reject(new Error(`Timed out waiting for child lock acquisition. Output: ${output}`));
+        }, 2500);
+        child.once('close', (code) => {
+            if (!output.includes('acquired')) {
+                clearTimeout(timer);
+                reject(new Error(`Lock holder exited before acquisition (code=${String(code)}). Output: ${output}`));
+            }
+        });
+        child.once('error', reject);
+    });
+}
+function waitForChildClose(child) {
+    if (child.exitCode !== null) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => child.once('close', () => resolve()));
+}
+describe('sidecar build lock', () => {
+    test('rejects an empty lock path at the boundary', () => {
+        expect(() => {
+            const { acquireSidecarBuildLock } = require('../scripts/sidecar-build-lock.js');
+            acquireSidecarBuildLock('');
+        }).toThrow('A concrete sidecar build lock path is required.');
+    });
+    test('serializes independent ensure processes and releases the lock', async () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-sidecar-lock-'));
+        const lockPath = path.join(tempRoot, 'sidecar-build.lock');
+        const holderScript = `
+            const { acquireSidecarBuildLock } = require('./scripts/sidecar-build-lock.js');
+            const lock = acquireSidecarBuildLock(process.argv[1], { timeoutMs: 3000, staleMs: 30000, pollMs: 25 });
+            console.log('acquired');
+            setTimeout(() => { lock.release(); process.exit(0); }, 800);
+        `;
+        const waiterScript = `
+            const { acquireSidecarBuildLock } = require('./scripts/sidecar-build-lock.js');
+            const startedAt = Date.now();
+            const lock = acquireSidecarBuildLock(process.argv[1], { timeoutMs: 3000, staleMs: 30000, pollMs: 25 });
+            console.log(JSON.stringify({ acquired: true, waitedMs: Date.now() - startedAt }));
+            lock.release();
+        `;
+        try {
+            const holder = await waitForOutput(holderScript, [lockPath]);
+            const waiter = await runChild(waiterScript, [lockPath]);
+            expect(waiter.code).toBe(0);
+            expect(waiter.output).toContain('acquired');
+            const parsed = JSON.parse(waiter.output.match(/\{[^\n]+\}/)?.[0] || '{}');
+            expect(Number(parsed.waitedMs || 0)).toBeGreaterThanOrEqual(250);
+            await waitForChildClose(holder.child);
+            expect(fs.existsSync(lockPath)).toBe(false);
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('reclaims an old lock whose owner process is no longer alive', async () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-sidecar-lock-stale-'));
+        const lockPath = path.join(tempRoot, 'sidecar-build.lock');
+        try {
+            fs.writeFileSync(lockPath, JSON.stringify({
+                pid: 2147483647,
+                hostname: 'stale-test',
+                startedAt: '2020-01-01T00:00:00.000Z',
+                token: 'stale-token',
+            }), 'utf8');
+            const result = await runChild(`
+                const { acquireSidecarBuildLock } = require('./scripts/sidecar-build-lock.js');
+                const lock = acquireSidecarBuildLock(process.argv[1], { timeoutMs: 500, staleMs: 1, pollMs: 10 });
+                console.log('acquired');
+                lock.release();
+            `, [lockPath]);
+            expect(result.code).toBe(0);
+            expect(result.output).toContain('acquired');
+            expect(fs.existsSync(lockPath)).toBe(false);
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('reclaims an old lock owned by a different host without trusting a reused pid', async () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-sidecar-lock-host-'));
+        const lockPath = path.join(tempRoot, 'sidecar-build.lock');
+        try {
+            fs.writeFileSync(lockPath, JSON.stringify({
+                pid: process.pid,
+                hostname: 'different-host',
+                startedAt: '2020-01-01T00:00:00.000Z',
+                token: 'foreign-token',
+            }), 'utf8');
+            const result = await runChild(`
+                const { acquireSidecarBuildLock } = require('./scripts/sidecar-build-lock.js');
+                const lock = acquireSidecarBuildLock(process.argv[1], { timeoutMs: 500, staleMs: 1, pollMs: 10 });
+                console.log('acquired');
+                lock.release();
+            `, [lockPath]);
+            expect(result.code).toBe(0);
+            expect(result.output).toContain('acquired');
+            expect(fs.existsSync(lockPath)).toBe(false);
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('fails closed when a live owner holds the lock past the wait budget', async () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-sidecar-lock-timeout-'));
+        const lockPath = path.join(tempRoot, 'sidecar-build.lock');
+        const holderScript = `
+            const { acquireSidecarBuildLock } = require('./scripts/sidecar-build-lock.js');
+            const lock = acquireSidecarBuildLock(process.argv[1], { timeoutMs: 3000, staleMs: 30000, pollMs: 25 });
+            console.log('acquired');
+            setTimeout(() => { lock.release(); process.exit(0); }, 700);
+        `;
+        try {
+            const holder = await waitForOutput(holderScript, [lockPath]);
+            const result = await runChild(`
+                const { acquireSidecarBuildLock } = require('./scripts/sidecar-build-lock.js');
+                acquireSidecarBuildLock(process.argv[1], { timeoutMs: 100, staleMs: 30000, pollMs: 25 });
+            `, [lockPath]);
+            expect(result.code).not.toBe(0);
+            expect(result.output).toContain('Timed out waiting for sidecar build lock');
+            holder.child.kill();
+            await waitForChildClose(holder.child);
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+});

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

@@ -114,13 +114,16 @@ describe('sidecar replacement boundary contract', () => {
         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', () => {
+    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 build:sidecar');
-        expect(pkg.scripts?.['tauri:android:build']).toContain('npm run build:sidecar');
+        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

@@ -121,6 +121,17 @@ describe('sidecar supply readiness contract', () => {
         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,

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/storage.provider.capacitor.content.contract.test.js

@@ -41,6 +41,9 @@ describe('storage provider capacitor content mapping contract', () => {
     test('maps desktop-style Knowledge_Base paths for capacitor content reads', () => {
         const source = fs.readFileSync(storageProviderPath, 'utf8');
         expect(source).toContain('function extractRelativePathFromKbMarker(rawFilePath)');
+        expect(source).toContain('function extractRelativePathFromWorkspaceUri(rawFilePath)');
+        expect(source).toContain("const prefix = 'note://workspace/v1/'");
+        expect(source).toContain('const relativeFromWorkspaceUri = extractRelativePathFromWorkspaceUri(raw);');
         expect(source).toContain('function resolveCapacitorContentCandidatePath(rawFilePath)');
         expect(source).toContain("if (/^[A-Za-z]:\\//.test(normalized) || normalized.startsWith('/')) {");
         expect(source).toContain('Cannot map absolute desktop path on Capacitor without Knowledge_Base marker.');
@@ -49,6 +52,6 @@ describe('storage provider capacitor content mapping contract', () => {
         const source = fs.readFileSync(storageProviderPath, 'utf8');
         expect(source).toContain('if (isCapacitorNativeRuntime()) {');
         expect(source).toContain('const capacitorPath = resolveCapacitorContentCandidatePath(filePath);');
-        expect(source).toContain('return await capacitorReadText(capacitorPath);');
+        expect(source).toContain('return await capacitorReadText(capacitorPath, {');
     });
 });