noteconnection 1.8.0 → 1.9.0

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

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

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

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

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const verifier = require(path.resolve(__dirname, '..', 'scripts', 'verify-mobile-native-recovery.js'));
+describe('mobile native recovery state-machine contract', () => {
+    test('replays all journal phases and fail-closed cases without claiming native evidence', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'noteconnection-recovery-contract-'));
+        const outputPath = path.join(root, 'report.json');
+        try {
+            const evidence = verifier.runRecoveryVerification({ outputPath });
+            expect(evidence.evidenceLevel).toBe('host-recovery-state-machine');
+            expect(evidence.nativeDeviceEvidence).toBe(false);
+            expect(evidence.scenarios).toEqual(expect.arrayContaining([
+                expect.objectContaining({ name: 'staging-target-wins', action: 'target-preserved' }),
+                expect.objectContaining({ name: 'backup-restored', action: 'previous-restored' }),
+                expect.objectContaining({ name: 'backup-rename-retry', action: 'recovery-pending', backupExists: true, journalExists: true }),
+                expect.objectContaining({ name: 'activated-target-wins', action: 'target-preserved' }),
+                expect.objectContaining({ name: 'orphan-backup-restored', action: 'orphan-backup-restored' }),
+                expect.objectContaining({ name: 'orphan-backup-retry', action: 'orphan-recovery-pending', backupExists: true }),
+                expect.objectContaining({ name: 'unsafe-journal-rejected', action: 'unsafe_import_journal' }),
+                expect.objectContaining({ name: 'unknown-schema-rejected', action: 'invalid_import_journal' }),
+            ]));
+            expect(JSON.parse(fs.readFileSync(outputPath, 'utf8')).scenarios).toHaveLength(8);
+        }
+        finally {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

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

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