noteconnection 1.7.0 → 1.9.0

package/dist/src/mobile.artifact.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 path = __importStar(require("path"));
+function createStoredZip(entries) {
+    const localParts = [];
+    const centralParts = [];
+    let localOffset = 0;
+    for (const entry of entries) {
+        const name = Buffer.from(entry.name, 'utf8');
+        const local = Buffer.alloc(30 + name.length + entry.content.length);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4);
+        local.writeUInt16LE(0, 6);
+        local.writeUInt16LE(0, 8);
+        local.writeUInt16LE(0, 10);
+        local.writeUInt16LE(0, 12);
+        local.writeUInt32LE(0, 14);
+        local.writeUInt32LE(entry.content.length, 18);
+        local.writeUInt32LE(entry.content.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        local.writeUInt16LE(0, 28);
+        name.copy(local, 30);
+        entry.content.copy(local, 30 + name.length);
+        localParts.push(local);
+        const central = Buffer.alloc(46 + name.length);
+        central.writeUInt32LE(0x02014b50, 0);
+        central.writeUInt16LE(20, 4);
+        central.writeUInt16LE(20, 6);
+        central.writeUInt16LE(0, 8);
+        central.writeUInt16LE(0, 10);
+        central.writeUInt16LE(0, 12);
+        central.writeUInt16LE(0, 14);
+        central.writeUInt32LE(0, 16);
+        central.writeUInt32LE(entry.content.length, 20);
+        central.writeUInt32LE(entry.content.length, 24);
+        central.writeUInt16LE(name.length, 28);
+        central.writeUInt16LE(0, 30);
+        central.writeUInt16LE(0, 32);
+        central.writeUInt16LE(0, 34);
+        central.writeUInt16LE(0, 36);
+        central.writeUInt32LE(0, 38);
+        central.writeUInt32LE(localOffset, 42);
+        name.copy(central, 46);
+        centralParts.push(central);
+        localOffset += local.length;
+    }
+    const localData = Buffer.concat(localParts);
+    const centralData = Buffer.concat(centralParts);
+    const eocd = Buffer.alloc(22);
+    eocd.writeUInt32LE(0x06054b50, 0);
+    eocd.writeUInt16LE(0, 8);
+    eocd.writeUInt16LE(entries.length, 10);
+    eocd.writeUInt32LE(centralData.length, 12);
+    eocd.writeUInt32LE(localData.length, 16);
+    return Buffer.concat([localData, centralData, eocd]);
+}
+describe('mobile APK/AAB artifact verifier contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const verifier = require(path.join(repoRoot, 'scripts', 'verify-mobile-artifact.js'));
+    let fixtureRoot;
+    beforeEach(() => {
+        fixtureRoot = fs.mkdtempSync(path.join(repoRoot, '.tmp-mobile-artifact-'));
+    });
+    afterEach(() => {
+        fs.rmSync(fixtureRoot, { recursive: true, force: true });
+    });
+    test('checks APK entries and requires RSS in release mode', () => {
+        const artifactPath = path.join(fixtureRoot, 'app-arm64-v8a.apk');
+        const rssPath = path.join(fixtureRoot, 'rss.json');
+        fs.writeFileSync(artifactPath, createStoredZip([
+            { name: 'assets/index.html', content: Buffer.from('<html />') },
+            { name: 'lib/arm64-v8a/libnoteconnection.so', content: Buffer.from('runtime') },
+        ]));
+        fs.writeFileSync(rssPath, JSON.stringify({ peakResidentBytes: 128 * 1024 * 1024 }));
+        const result = verifier.verifyMobileArtifact({
+            artifactPath,
+            profile: 'mobile-low',
+            rssEvidencePath: rssPath,
+            requireRss: true,
+            requireArm64Only: true,
+        });
+        expect(result.artifactKind).toBe('apk');
+        expect(result.rssStatus).toBe('within-budget');
+        expect(result.hasArm64Payload).toBe(true);
+        expect(result.nativeAbis).toEqual(['arm64-v8a']);
+        expect(result.compressedPayloadBytes).toBeGreaterThan(0);
+    });
+    test('rejects forbidden runtime entries and missing release RSS evidence', () => {
+        const artifactPath = path.join(fixtureRoot, 'app.aab');
+        fs.writeFileSync(artifactPath, createStoredZip([
+            { name: 'assets/models/tiny.gguf', content: Buffer.from('model') },
+        ]));
+        expect(() => verifier.verifyMobileArtifact({ artifactPath, profile: 'mobile-standard' }))
+            .toThrow(/Forbidden mobile artifact entries/);
+        const cleanArtifactPath = path.join(fixtureRoot, 'clean.aab');
+        fs.writeFileSync(cleanArtifactPath, createStoredZip([
+            { name: 'assets/index.html', content: Buffer.from('<html />') },
+        ]));
+        expect(() => verifier.verifyMobileArtifact({
+            artifactPath: cleanArtifactPath,
+            profile: 'mobile-standard',
+            requireRss: true,
+        })).toThrow(/RSS evidence is required/);
+        expect(() => verifier.verifyMobileArtifact({
+            artifactPath: cleanArtifactPath,
+            profile: 'mobile-standard',
+            requireSigned: true,
+        })).toThrow(/signature/i);
+    });
+});

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

@@ -0,0 +1,90 @@
+"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"));
+const MobileBudget_1 = require("./platform/MobileBudget");
+describe('versioned mobile budget contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const contractPath = path.join(repoRoot, 'config', 'mobile-budget.v1.json');
+    const contractModulePath = path.join(repoRoot, 'scripts', 'mobile-budget-contract.js');
+    const slimVerifierPath = path.join(repoRoot, 'scripts', 'verify-mobile-slim-budget.js');
+    const artifactVerifierPath = path.join(repoRoot, 'scripts', 'verify-mobile-artifact.js');
+    const preparePath = path.join(repoRoot, 'scripts', 'prepare-mobile-slim.js');
+    const runtimeProjectionPath = path.join(repoRoot, 'src', 'frontend', 'mobile_budget_runtime.js');
+    test('declares matching low and standard artifact/RSS profiles plus runtime limits', () => {
+        const contract = JSON.parse(fs.readFileSync(contractPath, 'utf8'));
+        const loaded = require(contractModulePath);
+        const slimVerifier = require(slimVerifierPath);
+        const artifactVerifier = require(artifactVerifierPath);
+        expect(loaded.MOBILE_BUDGET_CONTRACT.schemaVersion).toBe(contract.schemaVersion);
+        expect(loaded.MOBILE_BUDGET_CONTRACT.profiles).toEqual(contract.profiles);
+        expect(loaded.MOBILE_BUDGET_CONTRACT.runtime).toEqual(contract.runtime);
+        expect(loaded.MOBILE_BUDGET_CONTRACT.contractSha256).toMatch(/^[a-f0-9]{64}$/);
+        expect(slimVerifier.DEFAULT_ASSET_BUDGET_BYTES).toBe(contract.profiles['mobile-low'].artifactCompressedBytes);
+        expect(slimVerifier.DEFAULT_MAX_RESIDENT_BYTES).toBe(contract.profiles['mobile-low'].maxResidentBytes);
+        expect(artifactVerifier.PROFILES['mobile-low'].compressedBudgetBytes).toBe(contract.profiles['mobile-low'].artifactCompressedBytes);
+        expect(artifactVerifier.PROFILES['mobile-standard'].maxResidentBytes).toBe(contract.profiles['mobile-standard'].maxResidentBytes);
+        expect(artifactVerifier.PROFILES['mobile-low'].maxDeviceRamBytes).toBe(contract.profiles['mobile-low'].maxDeviceRamBytes);
+    });
+    test('persists runtime budgets into the slim manifest and keeps the contract outside the runtime bundle', () => {
+        const prepareSource = fs.readFileSync(preparePath, 'utf8');
+        expect(prepareSource).toContain("require('./mobile-budget-contract')");
+        expect(prepareSource).toContain('contractSchemaVersion');
+        expect(prepareSource).toContain('runtime: MOBILE_BUDGET_CONTRACT.runtime');
+        expect(fs.readFileSync(contractPath, 'utf8')).not.toContain('mobile_exact_analyzer');
+        expect(prepareSource).toContain("profile: 'mobile-low'");
+        expect(prepareSource).toContain('contractSha256');
+    });
+    test('excludes Vite verification chunks from the mobile staging input', () => {
+        const prepare = require(preparePath);
+        expect(prepare.shouldExcludeSourceAsset('assets/main-stale.js')).toBe(true);
+        expect(prepare.shouldExcludeSourceAsset('vite-assets/main-stale.js')).toBe(true);
+        expect(prepare.shouldExcludeSourceAsset('workspace_panes.js')).toBe(false);
+    });
+    test('browser budget projection stays aligned with the versioned contract', () => {
+        const contract = JSON.parse(fs.readFileSync(contractPath, 'utf8'));
+        const context = {};
+        vm.runInNewContext(fs.readFileSync(runtimeProjectionPath, 'utf8'), context);
+        const runtime = context.NoteConnectionMobileBudget;
+        expect(runtime?.schemaVersion).toBe(contract.schemaVersion);
+        expect(runtime?.profiles).toEqual(contract.profiles);
+        expect(runtime?.runtime).toEqual(contract.runtime);
+        expect(MobileBudget_1.MOBILE_LOW_ARTIFACT_BUDGET_BYTES).toBe(contract.profiles['mobile-low'].artifactCompressedBytes);
+        expect(MobileBudget_1.MOBILE_LOW_MAX_RESIDENT_BYTES).toBe(contract.profiles['mobile-low'].maxResidentBytes);
+        expect(MobileBudget_1.MOBILE_LOW_MAX_DEVICE_RAM_BYTES).toBe(contract.profiles['mobile-low'].maxDeviceRamBytes);
+    });
+});

package/dist/src/mobile.canonical-id.readiness.test.js

@@ -0,0 +1,54 @@
+"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('canonical ID migration readiness boundary', () => {
+    const scriptPath = path.resolve(process.cwd(), 'scripts', 'verify-canonical-id-readiness.js');
+    const manifestPath = path.resolve(process.cwd(), 'config', 'identity-corpus.v1.json');
+    test('keeps readiness read-only and public-ID cutover blocked', () => {
+        const source = fs.readFileSync(scriptPath, 'utf8');
+        expect(source).toContain("canonicalPublicIdCutover: 'blocked'");
+        expect(source).toContain('independentReviewRequired: true');
+        expect(source).toContain("nativeDeviceEvidence === true");
+        expect(source).toContain("process.argv.includes('--strict')");
+        expect(source).not.toContain('migratePublicIds(');
+        expect(source).not.toContain('switchPublicIds(');
+    });
+    test('manifest keeps all compatibility changes false before review', () => {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        expect(Object.values(manifest.compatibility)).toEqual([false, false, false, false]);
+    });
+});

package/dist/src/mobile.graph.parity.contract.test.js

@@ -0,0 +1,207 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const vm = __importStar(require("vm"));
+describe('Capacitor mobile graph edge contract', () => {
+    const modulePath = path.resolve(__dirname, 'frontend', 'storage_provider.js');
+    let graphBuilder;
+    let workerSourceFactory;
+    beforeAll(() => {
+        const runtimeGlobal = globalThis;
+        runtimeGlobal.window = {};
+        runtimeGlobal.NoteConnectionMobileIdentity = require(path.resolve(__dirname, 'frontend', 'mobile_identity_contract.js'));
+        const providerModule = require(modulePath);
+        graphBuilder = providerModule.buildCapacitorGraphData;
+        workerSourceFactory = providerModule.getCapacitorGraphBuildWorkerSource;
+    });
+    afterAll(() => {
+        const runtimeGlobal = globalThis;
+        delete runtimeGlobal.window;
+        delete runtimeGlobal.NoteConnectionMobileIdentity;
+        jest.resetModules();
+    });
+    test('uses source-to-target orientation and carries portable edge endpoints', () => {
+        const graph = graphBuilder([
+            {
+                id: 'base',
+                label: 'Base',
+                path: 'financial/base.md',
+                sourceUri: 'note://workspace/v1/financial/base.md',
+                metadata: { tags: [], prerequisites: [], next: [] },
+                content: '# Base',
+            },
+            {
+                id: 'intro',
+                label: 'Intro',
+                path: 'financial/intro.md',
+                sourceUri: 'note://workspace/v1/financial/intro.md',
+                metadata: { tags: [], prerequisites: ['base'], next: [] },
+                content: '# Intro\n[[advanced]]',
+            },
+            {
+                id: 'advanced',
+                label: 'Advanced',
+                path: 'financial/advanced.md',
+                sourceUri: 'note://workspace/v1/financial/advanced.md',
+                metadata: { tags: [], prerequisites: [], next: [] },
+                content: '# Advanced',
+            },
+        ]);
+        expect(graph.edges).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                source: 'base',
+                target: 'intro',
+                sourceUri: 'note://workspace/v1/financial/base.md',
+                targetUri: 'note://workspace/v1/financial/intro.md',
+                type: 'explicit-prerequisite',
+            }),
+            expect.objectContaining({
+                source: 'intro',
+                target: 'advanced',
+                sourceUri: 'note://workspace/v1/financial/intro.md',
+                targetUri: 'note://workspace/v1/financial/advanced.md',
+                type: 'wiki-link',
+            }),
+        ]));
+        expect(graph.edges).not.toEqual(expect.arrayContaining([
+            expect.objectContaining({ source: 'advanced', target: 'intro', type: 'wiki-link' }),
+        ]));
+    });
+    test('retains a path-derived canonical id alongside the legacy public id', () => {
+        const graph = graphBuilder([
+            {
+                id: 'Index',
+                canonicalId: 'algebra/index',
+                label: 'Index',
+                path: 'algebra/index.md',
+                sourceUri: 'note://workspace/v1/algebra/index.md',
+                identityAliases: ['Index', 'algebra/index.md'],
+                metadata: { tags: [], prerequisites: [], next: [] },
+                content: '# Index',
+            },
+        ]);
+        expect(graph.nodes[0]).toEqual(expect.objectContaining({
+            id: 'Index',
+            canonicalId: 'algebra/index',
+        }));
+    });
+    test('resolves nested relative and markdown links by canonical path', () => {
+        const graph = graphBuilder([
+            {
+                id: 'base',
+                canonicalId: 'shared/base',
+                path: 'Knowledge_Base/shared/base.md',
+                sourceUri: 'note://workspace/v1/shared/base.md',
+                metadata: { tags: [], prerequisites: [], next: [] },
+                content: '# Base',
+            },
+            {
+                id: 'intro',
+                canonicalId: 'algebra/intro',
+                path: 'Knowledge_Base/algebra/intro.md',
+                sourceUri: 'note://workspace/v1/algebra/intro.md',
+                metadata: { tags: [], prerequisites: [], next: [] },
+                content: '# Intro\n[base](../shared/base.md)',
+            },
+        ]);
+        expect(graph.edges).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                source: 'intro',
+                target: 'base',
+                type: 'markdown-link',
+                sourceUri: 'note://workspace/v1/algebra/intro.md',
+                targetUri: 'note://workspace/v1/shared/base.md',
+            }),
+        ]));
+    });
+    test('fails closed when legacy basenames are ambiguous across directories', () => {
+        expect(() => graphBuilder([
+            {
+                id: 'index',
+                canonicalId: 'algebra/index',
+                path: 'Knowledge_Base/algebra/index.md',
+                sourceUri: 'note://workspace/v1/algebra/index.md',
+                metadata: { tags: [], prerequisites: [], next: [] },
+                content: '# Algebra',
+            },
+            {
+                id: 'INDEX',
+                canonicalId: 'physics/index',
+                path: 'Knowledge_Base/physics/index.md',
+                sourceUri: 'note://workspace/v1/physics/index.md',
+                metadata: { tags: [], prerequisites: [], next: [] },
+                content: '# Physics',
+            },
+        ])).toThrow(/ambiguous legacy basename/i);
+    });
+    test('keeps worker and single-thread resolution equivalent for sourceUri-only files', () => {
+        const files = [
+            {
+                id: 'base',
+                sourceUri: 'note://workspace/v1/shared/base.md',
+                metadata: { tags: [], prerequisites: [], next: [] },
+                content: '# Base',
+            },
+            {
+                id: 'intro',
+                sourceUri: 'note://workspace/v1/algebra/intro.md',
+                metadata: { tags: [], prerequisites: [], next: [] },
+                content: '# Intro\n[base](../shared/base.md)',
+            },
+        ];
+        const singleThreadGraph = graphBuilder(files.map((file) => ({
+            ...file,
+            metadata: { ...file.metadata },
+        })));
+        expect(files[0]).not.toHaveProperty('__canonicalId');
+        const messages = [];
+        const context = {
+            self: {
+                postMessage(message) {
+                    messages.push(message);
+                },
+            },
+        };
+        vm.runInNewContext(workerSourceFactory(), context);
+        context.self.onmessage({
+            data: { files },
+        });
+        expect(messages).toHaveLength(1);
+        expect(messages[0].ok).toBe(true);
+        expect(messages[0].error).toBeUndefined();
+        expect(messages[0].graphData).toEqual(singleThreadGraph);
+    });
+});

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

@@ -0,0 +1,66 @@
+"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('mobile portable identity contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const modulePath = path.join(repoRoot, 'src', 'frontend', 'mobile_identity_contract.js');
+    const identity = require(modulePath);
+    test('ships as a browser-compatible asset and normalizes paths identically', () => {
+        expect(fs.readFileSync(modulePath, 'utf8')).toContain('NoteConnectionMobileIdentity');
+        expect(identity.normalizePortablePath('Knowledge_Base\\Algebra Notes\\Index #1.MD'))
+            .toBe('algebra notes/index #1.md');
+        expect(identity.createSourceUri('algebra notes/index #1.md'))
+            .toBe('note://workspace/v1/algebra%20notes/index%20%231.md');
+    });
+    test('uses SHA-256 even without Web Crypto and normalizes Unicode content', async () => {
+        expect(identity.sha256HexSync(''))
+            .toBe('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855');
+        expect(identity.sha256HexSync('abc'))
+            .toBe('ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad');
+        const decomposed = await identity.createResourceIdentity('notes/cafe.md', 'cafe', 'Cafe\u0301');
+        const composed = await identity.createResourceIdentity('notes/cafe.md', 'cafe', 'Caf\u00e9');
+        expect(decomposed.revision).toMatch(/^sha256:[0-9a-f]{64}$/);
+        expect(decomposed.revision).toBe(composed.revision);
+        expect(decomposed.identityAliases).toEqual(expect.arrayContaining(['notes/cafe.md', 'cafe']));
+    });
+    test('preserves the legacy id while exposing extension-inclusive portable identity', async () => {
+        const result = await identity.createResourceIdentity('algebra/index.md', 'index', '# Algebra');
+        expect(result.sourceUri).toBe('note://workspace/v1/algebra/index.md');
+        expect(result.canonicalId).toBe('algebra/index');
+        expect(result.identityAliases).toEqual(expect.arrayContaining(['index', 'index.md', 'algebra/index.md']));
+    });
+});

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

@@ -0,0 +1,72 @@
+"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('versioned identity corpus manifest', () => {
+    const manifestPath = path.resolve(process.cwd(), 'config', 'identity-corpus.v1.json');
+    const verifierPath = path.resolve(process.cwd(), 'scripts', 'verify-identity-corpus.js');
+    test('declares the complete G4 corpus and keeps compatibility cutover frozen', () => {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        expect(manifest.schemaVersion).toBe(1);
+        expect(manifest.corpusId).toBe('noteconnection-identity-g4-v1');
+        expect(manifest.requiredCases).toEqual(expect.arrayContaining([
+            'legacy_snapshot_restore',
+            'same_content_isolation',
+            'cross_root_nfc_identity',
+            'nfc_case_collision_rejection',
+            'move_journal_restart_alias_delete',
+            'mixed_batch_rollback',
+            'four_owner_convergence',
+            'upsert_alias_collision_rejection',
+        ]));
+        expect(manifest.requiredProjectionHosts).toEqual(['web', 'tauri', 'capacitor', 'android']);
+        expect(manifest.compatibility).toEqual({
+            publicIdsChanged: false,
+            snapshotSchemaChanged: false,
+            projectionSchemaChanged: false,
+            mobileRuntimeChanged: false,
+        });
+        expect(manifest.gates.canonicalPublicIdCutover).toContain('blocked');
+    });
+    test('verifier reports host-code evidence separately from native evidence', () => {
+        const verifier = fs.readFileSync(verifierPath, 'utf8');
+        expect(verifier).toContain("require('ts-node/register/transpile-only')");
+        expect(verifier).toContain("evidenceLevel: 'host-code-replay'");
+        expect(verifier).toContain('nativeDeviceEvidence: false');
+        expect(verifier).toContain("canonicalPublicIdCutover: 'blocked'");
+        expect(verifier).toContain('verify-mobile-projection-replay.js');
+    });
+});