noteconnection 1.7.0 → 1.9.0

package/dist/src/notemd.workflow.pipeline.test.js

@@ -0,0 +1,162 @@
+"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 });
+/**
+ * Workflow Pipeline contract test — validates the 4-stage
+ * runWorkflow pipeline (extract → wikilinks → generate → mermaid).
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const NotemdService_1 = require("./notemd/NotemdService");
+class TempDir {
+    constructor(prefix) { this.root = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), prefix)); }
+    file(rel, content) {
+        const p = path.join(this.root, rel);
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, content, 'utf8');
+        return p;
+    }
+    cleanup() { fs.rmSync(this.root, { recursive: true, force: true }); }
+}
+function defaultSettings(overrides = {}) {
+    return {
+        activeProvider: 'OpenAI',
+        searchProvider: 'duckduckgo',
+        language: 'en',
+        providers: [],
+        enableStableApiCall: true,
+        enableApiErrorDebugMode: false,
+        maxRetries: 0,
+        retryDelayMs: 0,
+        maxTokens: 256,
+        chunkWordCount: 100,
+        enableDuplicateDetection: false,
+        enableExperimentalDiagramPipeline: false,
+        enableBatchParallelism: false,
+        developerMode: false,
+        developerDiagnosticCallMode: 'runtime-stable',
+        developerDiagnosticTimeoutMs: 60000,
+        developerDiagnosticStabilityRuns: 3,
+        experimentalDiagramCompatibilityMode: 'legacy-mermaid',
+        autoMermaidFixAfterGenerate: true,
+        tavilyApiKey: '',
+        tavilyMaxResults: 5,
+        tavilySearchDepth: 'basic',
+        ddgFetchTimeout: 10000,
+        useCustomConceptNoteFolder: false,
+        conceptNoteFolder: '',
+        ...overrides,
+    };
+}
+describe('Notemd Workflow Pipeline', () => {
+    let temp;
+    let service;
+    beforeEach(() => { temp = new TempDir('notemd-workflow-'); service = new NotemdService_1.NotemdService(); });
+    afterEach(() => { temp.cleanup(); });
+    test('runWorkflow executes all 3 stages (extract → generate → mermaid) on a simple file', async () => {
+        const src = temp.file('notes/topic.md', '# Graph Theory\n\nGraph theory studies **nodes** and **edges**.\n\n```mermaid\ngraph TD\nA-->B\n```');
+        const result = await service.runWorkflow({ filePath: src }, defaultSettings());
+        expect(result.sourceFilePath).toBe(src);
+        expect(result.outputFolderPath).toContain('topic_notemd_output');
+        expect(fs.existsSync(result.outputFolderPath)).toBe(true);
+        // All 3 stages should be present (no wiki-links)
+        expect(result.stages.length).toBeGreaterThanOrEqual(3);
+        const stageNames = result.stages.map(s => s.stage);
+        expect(stageNames).toContain('extract-concepts');
+        expect(stageNames).toContain('generate-titles');
+        expect(stageNames).toContain('mermaid-fix');
+        // Extract stage should have completed
+        const extractStage = result.stages.find(s => s.stage === 'extract-concepts');
+        expect(['completed', 'error']).toContain(extractStage.status);
+        // Summary should have valid numbers
+        expect(typeof result.summary.conceptsExtracted).toBe('number');
+        expect(typeof result.summary.totalElapsedMs).toBe('number');
+        expect(result.summary.totalElapsedMs).toBeGreaterThanOrEqual(0);
+    });
+    test('runWorkflow with addWikiLinks injects wiki-links and writes _wikified file', async () => {
+        const src = temp.file('notes/test.md', '# Machine Learning\n\nMachine learning uses neural networks and deep learning.');
+        const result = await service.runWorkflow({ filePath: src, addWikiLinks: true, skipGenerate: true, skipMermaidFix: true }, defaultSettings());
+        // Wiki-links stage should be present and completed
+        const wikiStage = result.stages.find(s => s.stage === 'add-wikilinks');
+        expect(wikiStage).toBeDefined();
+        // May be 'completed' with links or 'skipped' if LLM returned no concepts
+        expect(['completed', 'skipped']).toContain(wikiStage.status);
+        // Add stage names check
+        const stageNames = result.stages.map(s => s.stage);
+        expect(stageNames).toContain('add-wikilinks');
+        expect(stageNames).not.toContain('generate-titles');
+        expect(stageNames).not.toContain('mermaid-fix');
+    });
+    test('runWorkflow with skipGenerate and skipMermaidFix only runs extract', async () => {
+        const src = temp.file('notes/simple.md', '# Simple\n\nJust a simple note.');
+        const result = await service.runWorkflow({ filePath: src, skipGenerate: true, skipMermaidFix: true }, defaultSettings());
+        // Only 1 stage should run (extract) since generate + mermaid are skipped
+        const runningStages = result.stages.filter(s => s.status !== 'skipped');
+        expect(runningStages.length).toBeGreaterThanOrEqual(1);
+        const stageNames = result.stages.map(s => s.stage);
+        expect(stageNames).toContain('extract-concepts');
+    });
+    test('runWorkflow with wikiLinksInPlace modifies source file directly', async () => {
+        const src = temp.file('notes/inplace.md', '# AI\n\nArtificial intelligence uses machine learning and deep learning algorithms.');
+        const originalContent = fs.readFileSync(src, 'utf8');
+        const result = await service.runWorkflow({ filePath: src, addWikiLinks: true, wikiLinksInPlace: true, skipGenerate: true, skipMermaidFix: true }, defaultSettings());
+        const wikiStage = result.stages.find(s => s.stage === 'add-wikilinks');
+        expect(wikiStage).toBeDefined();
+        // If wikilinks were injected in-place, file content should differ
+        if (wikiStage.status === 'completed') {
+            const newContent = fs.readFileSync(src, 'utf8');
+            // Either content changed or no concepts were found
+            expect(typeof newContent).toBe('string');
+        }
+    });
+    test('runWorkflow errors are collected per-stage without blocking other stages', async () => {
+        const src = temp.file('notes/errors.md', 'test content');
+        const result = await service.runWorkflow({ filePath: src }, defaultSettings());
+        // Each stage should report its status
+        result.stages.forEach(stage => {
+            expect(['completed', 'error', 'skipped', 'running']).toContain(stage.status);
+        });
+        // Result should always have a valid structure even on errors
+        expect(result.sourceFilePath).toBe(src);
+        expect(Array.isArray(result.errors)).toBe(true);
+        expect(typeof result.summary.totalElapsedMs).toBe('number');
+    });
+    test('runWorkflow output folder is created', async () => {
+        const src = temp.file('notes/output.md', '# Test\n\nJust testing.');
+        const result = await service.runWorkflow({ filePath: src }, defaultSettings());
+        expect(fs.existsSync(result.outputFolderPath)).toBe(true);
+    });
+});

package/dist/src/pathbridge.handshake.contract.test.js

@@ -46,6 +46,20 @@ describe('path bridge handshake and transport verification contracts', () => {
     const pathModeUiPath = path.join(repoRoot, 'path_mode', 'scripts', 'path_mode_ui.gd');
     const readerRenderClientPath = path.join(repoRoot, 'path_mode', 'scripts', 'reader_render_client.gd');
     const pathRendererPath = path.join(repoRoot, 'path_mode', 'scripts', 'path_renderer.gd');
+    test('path bridge preserves explicit port zero for ephemeral bind fallback', async () => {
+        const bridge = new PathBridge_1.PathBridge({
+            port: 0,
+            host: '127.0.0.1',
+        });
+        try {
+            await bridge.waitUntilReady();
+            expect(bridge.getPort()).toBeGreaterThan(0);
+            expect(bridge.getPort()).not.toBe(9876);
+        }
+        finally {
+            bridge.close();
+        }
+    });
     test('path bridge supports explicit identify handshake and client tagging', () => {
         const bridge = fs.readFileSync(bridgePath, 'utf8');
         expect(bridge).toContain("case 'identify'");
@@ -77,6 +91,35 @@ describe('path bridge handshake and transport verification contracts', () => {
         });
         expect(validIdentify.ok).toBe(true);
         expect(validIdentify.envelope?.type).toBe('identify');
+        const validQuery = (0, PathBridge_1.parseBridgeInboundEnvelope)({
+            type: 'query',
+            version: PathBridge_1.PATH_BRIDGE_PROTOCOL_VERSION,
+            payload: {
+                requestId: 'query-1',
+                workspaceId: 'mobile-workspace',
+                sourceUri: 'note://workspace/v1/algebra/index.md',
+            },
+        });
+        expect(validQuery.ok).toBe(true);
+        const invalidQuery = (0, PathBridge_1.parseBridgeInboundEnvelope)({
+            type: 'query',
+            payload: { requestId: '' },
+        });
+        expect(invalidQuery.ok).toBe(false);
+        expect(invalidQuery.reason).toContain('requestId');
+        const invalidCapabilities = (0, PathBridge_1.parseBridgeInboundEnvelope)({
+            type: 'capabilities',
+            payload: { protocolVersion: PathBridge_1.PATH_BRIDGE_PROTOCOL_VERSION, capabilities: [''] },
+        });
+        expect(invalidCapabilities.ok).toBe(false);
+        expect(invalidCapabilities.reason).toContain('non-empty strings');
+        expect(PathBridge_1.PATH_BRIDGE_CAPABILITIES).toEqual(expect.arrayContaining([
+            'knowledge.analyze',
+            'knowledge.query',
+            'knowledge.readEvidence',
+            'knowledge.exportBundle',
+            'request.cancel',
+        ]));
         const invalidSwitchCenter = (0, PathBridge_1.parseBridgeInboundEnvelope)({
             type: 'switchCenter',
             payload: {
@@ -149,7 +192,7 @@ describe('path bridge handshake and transport verification contracts', () => {
         const invalidConfigureBrightness = (0, PathBridge_1.parseBridgeInboundEnvelope)({
             type: 'configure',
             payload: {
-                bg_brightness: 20,
+                bg_brightness: 0.2,
             },
         });
         expect(invalidConfigureBrightness.ok).toBe(false);
@@ -182,7 +225,7 @@ describe('path bridge handshake and transport verification contracts', () => {
                 retain_history: true,
                 focus_mode: false,
                 background: 'belfast_sunset_puresky_4k.exr',
-                bg_brightness: 1.2,
+                bg_brightness: 0.08,
                 reading_mode: 'window',
                 reader_render_mode: 'render',
                 reader_toggle_source_shortcut: 'Ctrl+Shift+M',

package/dist/src/pathbridge.host-adapter.contract.test.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ws_1 = require("ws");
+const PathBridge_1 = require("./core/PathBridge");
+function waitForMessage(socket, predicate) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            socket.off('message', onMessage);
+            reject(new Error('Timed out waiting for PathBridge message.'));
+        }, 3000);
+        const onMessage = (raw) => {
+            let payload;
+            try {
+                payload = JSON.parse(raw.toString('utf8'));
+            }
+            catch {
+                return;
+            }
+            if (!predicate(payload)) {
+                return;
+            }
+            clearTimeout(timer);
+            socket.off('message', onMessage);
+            resolve(payload);
+        };
+        socket.on('message', onMessage);
+    });
+}
+function connectClient(port) {
+    return new Promise((resolve, reject) => {
+        const socket = new ws_1.WebSocket(`ws://127.0.0.1:${port}`);
+        socket.once('open', () => resolve(socket));
+        socket.once('error', reject);
+    });
+}
+async function closeClient(socket) {
+    if (!socket || socket.readyState === ws_1.WebSocket.CLOSED) {
+        return;
+    }
+    await new Promise((resolve) => {
+        socket.once('close', () => resolve());
+        socket.close();
+    });
+}
+describe('PathBridge host adapter contract', () => {
+    test('executes knowledge requests in the host and returns correlated results', async () => {
+        const operations = [];
+        const bridge = new PathBridge_1.PathBridge({
+            port: 0,
+            hostAdapter: {
+                execute: async (operation) => {
+                    operations.push(operation);
+                    return { nodeCount: 2, execution: 'host' };
+                },
+            },
+        });
+        let client = null;
+        try {
+            await bridge.waitUntilReady();
+            client = await connectClient(bridge.getPort());
+            const capabilitiesPromise = waitForMessage(client, (message) => message.type === 'capabilities');
+            client.send(JSON.stringify({ type: 'identify', payload: { client: 'test-client' } }));
+            await capabilitiesPromise;
+            client.send(JSON.stringify({
+                type: 'query',
+                correlationId: 'corr-1',
+                payload: { requestId: 'query-1', workspaceId: 'mobile-workspace' },
+            }));
+            const result = await waitForMessage(client, (message) => message.type === 'operationResult');
+            expect(result.payload).toEqual(expect.objectContaining({
+                type: 'query',
+                requestId: 'query-1',
+                correlationId: 'corr-1',
+                ok: true,
+                result: { nodeCount: 2, execution: 'host' },
+            }));
+            expect(operations[0]).toEqual(expect.objectContaining({
+                type: 'query',
+                requestId: 'query-1',
+                correlationId: 'corr-1',
+                clientTag: 'test-client',
+            }));
+            expect(operations[0].signal).toBeInstanceOf(AbortSignal);
+        }
+        finally {
+            await closeClient(client);
+            bridge.close();
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    });
+    test('propagates cancellation to the host adapter and does not leak pending work', async () => {
+        let cancelledRequestId = '';
+        let operationSignal = null;
+        const bridge = new PathBridge_1.PathBridge({
+            port: 0,
+            hostAdapter: {
+                execute: (operation) => {
+                    operationSignal = operation.signal;
+                    return new Promise((_resolve, reject) => {
+                        operation.signal.addEventListener('abort', () => reject(new Error('aborted')));
+                    });
+                },
+                cancel: (requestId) => {
+                    cancelledRequestId = requestId;
+                },
+            },
+        });
+        let client = null;
+        try {
+            await bridge.waitUntilReady();
+            client = await connectClient(bridge.getPort());
+            const capabilitiesPromise = waitForMessage(client, (message) => message.type === 'capabilities');
+            client.send(JSON.stringify({ type: 'identify', payload: { client: 'cancel-client' } }));
+            await capabilitiesPromise;
+            client.send(JSON.stringify({ type: 'query', payload: { requestId: 'query-cancel' } }));
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            client.send(JSON.stringify({ type: 'cancel', payload: { requestId: 'query-cancel' } }));
+            const result = await waitForMessage(client, (message) => message.type === 'operationResult' && message.payload.type === 'cancel');
+            expect(result.payload).toEqual(expect.objectContaining({
+                requestId: 'query-cancel',
+                cancelled: true,
+                ok: false,
+            }));
+            expect(cancelledRequestId).toBe('query-cancel');
+            expect(operationSignal?.aborted).toBe(true);
+        }
+        finally {
+            await closeClient(client);
+            bridge.close();
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    });
+});

package/dist/src/pathcore.bundle.contract.test.js

@@ -80,6 +80,14 @@ describe('path core bundle contract', () => {
         ['A', 'B', 'C', 'D'].forEach((id) => {
             graph.addNode({ id, label: id, inDegree: 0, outDegree: 0 });
         });
+        graph.addNode({
+            id: 'Alias',
+            label: 'Alias',
+            inDegree: 0,
+            outDegree: 0,
+            identityAliases: ['folder/alias.md'],
+        });
+        expect(graph.hasNode('folder\\alias.md')).toBe(true);
         graph.addEdge('A', 'B');
         graph.addEdge('A', 'C');
         graph.addEdge('B', 'D');

package/dist/src/pathmode.background.contract.test.js

@@ -0,0 +1,69 @@
+"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('pathmode background safety contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const settingsPanelPath = path.join(repoRoot, 'path_mode', 'scripts', 'settings_panel.gd');
+    const pathRendererPath = path.join(repoRoot, 'path_mode', 'scripts', 'path_renderer.gd');
+    test('does not default path mode to a heavy HDR background at startup', () => {
+        const source = fs.readFileSync(settingsPanelPath, 'utf8');
+        expect(source).toContain('"background": ""');
+        expect(source).not.toContain('"background": "belfast_sunset_puresky_4k.exr"');
+    });
+    test('startup path-mode restore keeps runtime background values intact', () => {
+        const source = fs.readFileSync(pathRendererPath, 'utf8');
+        expect(source).toContain('func _filter_startup_settings(settings: Dictionary) -> Dictionary:');
+        expect(source).toContain('return settings.duplicate(true)');
+    });
+    test('desktop settings panel prefers runtime TOML over local cfg during load', () => {
+        const source = fs.readFileSync(settingsPanelPath, 'utf8');
+        expect(source).toContain('if not _runtime_base_url.is_empty():');
+        expect(source).toContain('call_deferred("_load_settings_from_runtime_async")');
+        expect(source).toContain('_load_settings_local()');
+    });
+    test('loads HDR backgrounds through the guarded resize-and-convert path', () => {
+        const source = fs.readFileSync(pathRendererPath, 'utf8');
+        expect(source).toContain('var _background_texture_cache: Dictionary = {}');
+        expect(source).toContain('var _last_applied_background_path: String = "__unset__"');
+        expect(source).toContain('func _load_hdr_background_safely(path: String) -> Texture2D:');
+        expect(source).toContain('var imported_tex = ResourceLoader.load(path)');
+        expect(source).toContain('var texture := imported_tex as Texture2D');
+        expect(source).not.toContain('MAX_SAFE_HDR_BACKGROUND_BYTES');
+        expect(source).not.toContain('(imported_tex as Texture2D).get_image()');
+        expect(source).not.toContain('var image_error := image.load(path)');
+    });
+});

package/dist/src/pathmode.settings.api.contract.test.js

@@ -45,4 +45,13 @@ describe('Path Mode settings API contract', () => {
         expect(serverSource).toContain('extractPathModeSettingsFromAppConfig');
         expect(serverSource).toContain('applyPathModeSettingsToAppConfig');
     });
+    test('server path-mode settings loader does not short-circuit on stale in-memory cache', () => {
+        const loadStart = serverSource.indexOf('async function loadPathModeSettings(): Promise<PathModeSettings> {');
+        const loadEnd = serverSource.indexOf('async function persistPathModeSettings(settingsLike: unknown): Promise<PathModeSettings> {');
+        const loadSlice = serverSource.slice(loadStart, loadEnd);
+        expect(loadStart).toBeGreaterThanOrEqual(0);
+        expect(loadEnd).toBeGreaterThan(loadStart);
+        expect(loadSlice).toContain('const appConfig = await loadAppConfigToml();');
+        expect(loadSlice).not.toContain('if (cachedPathModeSettings)');
+    });
 });

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

@@ -48,10 +48,14 @@ describe('pkg sidecar packaging contract', () => {
         const pkg = packageJson.pkg || {};
         const pkgScripts = pkg.scripts || [];
         const pkgAssets = pkg.assets || [];
+        const scripts = packageJson.scripts || {};
         expect(pkgScripts).toContain('dist/src/backend/workers/**/*.js');
         expect(pkgAssets).toContain('dist/src/**/*');
-        expect(pkgAssets).toContain('data.js');
-        expect(pkgAssets).toContain('graph_data.json');
+        expect(pkgAssets).not.toContain('data.js');
+        expect(pkgAssets).not.toContain('graph_data.json');
+        expect(scripts['build:full']).toContain('--include-generated-graph-assets');
+        expect(scripts['tauri:build:full']).toContain('npm run build:full');
+        expect(scripts.prepublishOnly).toBe('npm run build');
     });
     test('retains hardened node22 sidecar build args and target mapping', () => {
         const buildSidecar = fs.readFileSync(buildSidecarPath, 'utf8');
@@ -61,6 +65,8 @@ describe('pkg sidecar packaging contract', () => {
         expect(buildSidecar).toContain("'--compress'");
         expect(buildSidecar).toContain("'Brotli'");
         expect(buildSidecar).toContain("'--no-bytecode'");
-        expect(buildSidecar).toContain("'--public'");
+        expect(buildSidecar).toContain("'--public-packages'");
+        expect(buildSidecar).toContain('PKG_NO_BYTECODE_RETRY_PATTERN');
+        expect(buildSidecar).toContain('without --no-bytecode');
     });
 });

package/dist/src/platform/ExportProfile.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOBILE_SLIM_MAX_RESIDENT_BYTES = exports.MOBILE_SLIM_ASSET_BUDGET_BYTES = void 0;
+exports.getExportProfile = getExportProfile;
+exports.listExportProfiles = listExportProfiles;
+const MobileBudget_1 = require("./MobileBudget");
+exports.MOBILE_SLIM_ASSET_BUDGET_BYTES = MobileBudget_1.MOBILE_LOW_ARTIFACT_BUDGET_BYTES;
+exports.MOBILE_SLIM_MAX_RESIDENT_BYTES = MobileBudget_1.MOBILE_LOW_MAX_RESIDENT_BYTES;
+const EXPORT_PROFILES = {
+    'desktop-full': {
+        id: 'desktop-full',
+        platformTarget: 'tauri',
+        description: 'Full desktop runtime with sidecar-backed retrieval, streaming, and indexing.',
+        supportsSidecar: true,
+        supportsBackgroundIndexing: true,
+        supportsConversationStreaming: true,
+        supportsSvgRenderArtifacts: true,
+        supportsPngRenderArtifacts: true,
+        supportsLocalIngest: true,
+        supportsLocalExactQuery: true,
+        supportsRemoteInference: true,
+        requiresRemoteInference: false,
+        assetBudgetBytes: null,
+        maxResidentBytes: null,
+        preferredMermaidRenderer: 'auto',
+    },
+    'desktop-reader': {
+        id: 'desktop-reader',
+        platformTarget: 'browser',
+        description: 'Reader-oriented desktop profile with lightweight retrieval and PNG-safe rendering.',
+        supportsSidecar: true,
+        supportsBackgroundIndexing: false,
+        supportsConversationStreaming: true,
+        supportsSvgRenderArtifacts: true,
+        supportsPngRenderArtifacts: true,
+        supportsLocalIngest: false,
+        supportsLocalExactQuery: true,
+        supportsRemoteInference: true,
+        requiresRemoteInference: false,
+        assetBudgetBytes: null,
+        maxResidentBytes: null,
+        preferredMermaidRenderer: 'auto',
+    },
+    'godot-path-mode': {
+        id: 'godot-path-mode',
+        platformTarget: 'godot',
+        description: 'Godot reader/profile with PNG-first render materialization and no SVG dependency.',
+        supportsSidecar: true,
+        supportsBackgroundIndexing: false,
+        supportsConversationStreaming: false,
+        supportsSvgRenderArtifacts: false,
+        supportsPngRenderArtifacts: true,
+        supportsLocalIngest: false,
+        supportsLocalExactQuery: false,
+        supportsRemoteInference: false,
+        requiresRemoteInference: false,
+        assetBudgetBytes: null,
+        maxResidentBytes: null,
+        preferredMermaidRenderer: 'auto',
+    },
+    'mobile-slim': {
+        id: 'mobile-slim',
+        platformTarget: 'mobile',
+        description: 'Slim mobile export with bounded memory footprint and PNG-only render artifacts.',
+        supportsSidecar: false,
+        supportsBackgroundIndexing: false,
+        supportsConversationStreaming: false,
+        supportsSvgRenderArtifacts: false,
+        supportsPngRenderArtifacts: true,
+        supportsLocalIngest: true,
+        supportsLocalExactQuery: true,
+        supportsRemoteInference: true,
+        requiresRemoteInference: false,
+        assetBudgetBytes: exports.MOBILE_SLIM_ASSET_BUDGET_BYTES,
+        maxResidentBytes: exports.MOBILE_SLIM_MAX_RESIDENT_BYTES,
+        preferredMermaidRenderer: 'local',
+    },
+};
+function getExportProfile(profileId) {
+    const normalized = typeof profileId === 'string' ? profileId.trim().toLowerCase() : '';
+    const candidate = normalized;
+    return EXPORT_PROFILES[candidate] || EXPORT_PROFILES['desktop-full'];
+}
+function listExportProfiles() {
+    return Object.values(EXPORT_PROFILES).map((profile) => ({ ...profile }));
+}

package/dist/src/platform/MobileBudget.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOBILE_LOW_MAX_DEVICE_RAM_BYTES = exports.MOBILE_LOW_MAX_RESIDENT_BYTES = exports.MOBILE_LOW_ARTIFACT_BUDGET_BYTES = exports.MOBILE_BUDGET_SCHEMA_VERSION = void 0;
+/**
+ * TypeScript projection of config/mobile-budget.v1.json for server-side export metadata.
+ * Keep this small and compare it with the checked-in contract in mobile budget tests.
+ */
+exports.MOBILE_BUDGET_SCHEMA_VERSION = 1;
+exports.MOBILE_LOW_ARTIFACT_BUDGET_BYTES = 25 * 1024 * 1024;
+exports.MOBILE_LOW_MAX_RESIDENT_BYTES = 256 * 1024 * 1024;
+exports.MOBILE_LOW_MAX_DEVICE_RAM_BYTES = 4 * 1024 * 1024 * 1024;

package/dist/src/platform/PlatformCapabilities.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePlatformCapabilities = resolvePlatformCapabilities;
+const ExportProfile_1 = require("./ExportProfile");
+function cloneProfile(profile) {
+    return { ...profile };
+}
+function resolvePlatformCapabilities(input = {}) {
+    let profile = cloneProfile((0, ExportProfile_1.getExportProfile)(input.exportProfileId));
+    const requestedTarget = typeof input.platformTarget === 'string'
+        ? input.platformTarget.trim().toLowerCase()
+        : '';
+    if (requestedTarget) {
+        const compatibleProfile = (requestedTarget === 'godot' ? (0, ExportProfile_1.getExportProfile)('godot-path-mode')
+            : requestedTarget === 'mobile' ? (0, ExportProfile_1.getExportProfile)('mobile-slim')
+                : requestedTarget === 'browser' ? (0, ExportProfile_1.getExportProfile)('desktop-reader')
+                    : (0, ExportProfile_1.getExportProfile)('desktop-full'));
+        if (compatibleProfile.platformTarget === requestedTarget) {
+            profile = cloneProfile(compatibleProfile);
+        }
+    }
+    return {
+        exportProfileId: profile.id,
+        platformTarget: profile.platformTarget,
+        export: {
+            supportsWorkspaceBundles: true,
+            deterministicBundles: true,
+            bundlePackagingMode: profile.supportsSidecar ? 'full' : 'slim',
+            requiresIndexedReadiness: true,
+            assetBudgetBytes: profile.assetBudgetBytes,
+            maxResidentBytes: profile.maxResidentBytes,
+        },
+        render: {
+            supportsSvgArtifacts: profile.supportsSvgRenderArtifacts,
+            supportsPngArtifacts: profile.supportsPngRenderArtifacts,
+            preferredArtifact: profile.supportsSvgRenderArtifacts ? 'svg' : 'png',
+            preferredMermaidRenderer: profile.preferredMermaidRenderer,
+        },
+        retrieval: {
+            supportsSidecar: profile.supportsSidecar,
+            supportsBackgroundIndexing: profile.supportsBackgroundIndexing,
+            supportsLocalIngest: profile.supportsLocalIngest,
+            supportsLocalExactQuery: profile.supportsLocalExactQuery,
+            supportsRemoteInference: profile.supportsRemoteInference,
+            requiresRemoteInference: profile.requiresRemoteInference,
+        },
+        storage: {
+            preferredProvider: profile.platformTarget === 'mobile' ? 'projection' : 'sqlite',
+            supportedProviders: profile.platformTarget === 'mobile'
+                ? ['projection']
+                : ['sqlite', 'file', 'remote'],
+            supportsSqlite: profile.platformTarget !== 'mobile',
+            supportsProjection: profile.platformTarget === 'mobile',
+        },
+        conversation: {
+            supportsStreaming: profile.supportsConversationStreaming,
+        },
+    };
+}