noteconnection 1.7.0 → 1.9.0

package/dist/src/utils/platform.js

@@ -0,0 +1,153 @@
+"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 });
+exports.getPlatform = getPlatform;
+exports.getAppDataDir = getAppDataDir;
+exports.getConfigDir = getConfigDir;
+exports.getCacheDir = getCacheDir;
+exports.getSidecarName = getSidecarName;
+exports.getGodotEnv = getGodotEnv;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const cachedPlatform = detectPlatform();
+function detectPlatform() {
+    const rawOs = process.platform;
+    const rawArch = process.arch;
+    let osName;
+    if (rawOs === 'linux')
+        osName = 'linux';
+    else if (rawOs === 'darwin')
+        osName = 'macos';
+    else if (rawOs === 'win32')
+        osName = 'windows';
+    else if (rawOs === 'android')
+        osName = 'android';
+    else
+        osName = 'unknown';
+    let archName;
+    if (rawArch === 'x64')
+        archName = 'x64';
+    else if (rawArch === 'arm64')
+        archName = 'arm64';
+    else
+        archName = 'unknown';
+    const triplet = buildTargetTriple(osName, archName);
+    const exeSuffix = osName === 'windows' ? '.exe' : '';
+    const isWayland = osName === 'linux' && process.env.XDG_SESSION_TYPE === 'wayland';
+    return { os: osName, arch: archName, triplet, exeSuffix, isWayland };
+}
+function buildTargetTriple(osName, archName) {
+    switch (osName) {
+        case 'linux':
+            return `x86_64-unknown-linux-gnu`;
+        case 'macos':
+            return archName === 'arm64'
+                ? 'aarch64-apple-darwin'
+                : 'x86_64-apple-darwin';
+        case 'windows':
+            return 'x86_64-pc-windows-msvc';
+        default:
+            return `${process.arch}-unknown-${process.platform}`;
+    }
+}
+function getPlatform() {
+    return cachedPlatform;
+}
+function getAppDataDir() {
+    const home = os.homedir();
+    const platform = cachedPlatform.os;
+    switch (platform) {
+        case 'macos':
+            return path.join(home, 'Library', 'Application Support', 'NoteConnection');
+        case 'linux': {
+            const xdgData = process.env.XDG_DATA_HOME || path.join(home, '.local', 'share');
+            return path.join(xdgData, 'NoteConnection');
+        }
+        case 'windows': {
+            const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+            return path.join(localAppData, 'NoteConnection');
+        }
+        default:
+            return path.join(home, '.noteconnection');
+    }
+}
+function getConfigDir() {
+    const home = os.homedir();
+    const platform = cachedPlatform.os;
+    switch (platform) {
+        case 'macos':
+            return path.join(home, 'Library', 'Preferences', 'NoteConnection');
+        case 'linux': {
+            const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(home, '.config');
+            return path.join(xdgConfig, 'NoteConnection');
+        }
+        case 'windows': {
+            const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+            return path.join(appData, 'NoteConnection');
+        }
+        default:
+            return path.join(home, '.config', 'noteconnection');
+    }
+}
+function getCacheDir() {
+    const home = os.homedir();
+    const platform = cachedPlatform.os;
+    switch (platform) {
+        case 'macos':
+            return path.join(home, 'Library', 'Caches', 'NoteConnection');
+        case 'linux': {
+            const xdgCache = process.env.XDG_CACHE_HOME || path.join(home, '.cache');
+            return path.join(xdgCache, 'NoteConnection');
+        }
+        case 'windows': {
+            const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+            return path.join(localAppData, 'NoteConnection', 'Cache');
+        }
+        default:
+            return path.join(home, '.cache', 'noteconnection');
+    }
+}
+function getSidecarName(baseName) {
+    return `${baseName}-${cachedPlatform.triplet}${cachedPlatform.exeSuffix}`;
+}
+function getGodotEnv() {
+    if (cachedPlatform.isWayland) {
+        return {
+            GDK_BACKEND: 'x11',
+            WEBKIT_DISABLE_DMABUF_RENDERER: '1',
+        };
+    }
+    return {};
+}

package/dist/src/windows.installer.build.test.js

@@ -0,0 +1,109 @@
+"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("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+jest.mock('node:child_process', () => ({ ...jest.requireActual('node:child_process'), spawnSync: jest.fn() }));
+const { recordInstallerBuild, readInstallerBuild } = require('../scripts/verify-windows-installers');
+describe('installer build provenance across fresh runners', () => {
+    let directory;
+    let receiptPath;
+    const environment = { GITHUB_SHA: 'a'.repeat(40), GITHUB_RUN_ID: '123', GITHUB_RUN_ATTEMPT: '1' };
+    const write = (relative, contents) => {
+        const file = path.join(directory, relative);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, contents);
+    };
+    beforeEach(() => {
+        const temporaryRoot = path.resolve(__dirname, '../output/verification/installer-build-tests');
+        fs.mkdirSync(temporaryRoot, { recursive: true });
+        directory = fs.mkdtempSync(path.join(temporaryRoot, 'receipt-'));
+        receiptPath = path.join(directory, 'output/verification/windows-installer-build.json');
+        write('package.json', JSON.stringify({ version: '1.8.0' }));
+        write('src/fixture.ts', 'export const source = 1;');
+        write('src-tauri/target/release/npm.exe', 'PE __TAURI_BUNDLE_TYPE_VAR_UNK fixture');
+        for (const name of ['server', 'godot', 'markdown-worker'])
+            write(`src-tauri/bin/${name}-x86_64-pc-windows-msvc.exe`, name);
+        write('output/desktop/path_mode.pck', 'GDPC fixture');
+        write('src-tauri/target/release/bundle/nsis/NoteConnection_1.8.0_x64-setup.exe', 'NSIS fixture');
+        write('src-tauri/target/release/bundle/msi/NoteConnection_1.8.0_x64_en-US.msi', 'MSI fixture');
+        recordInstallerBuild(directory, environment);
+    });
+    afterEach(() => {
+        expect(node_child_process_1.spawnSync).not.toHaveBeenCalled();
+        jest.clearAllMocks();
+        fs.rmSync(directory, { recursive: true, force: true });
+    });
+    test.each(['nsis', 'msi'])('accepts %s without build dependencies, including failed-only retries', format => {
+        // A qualification runner has only source, the receipt and its installer.
+        fs.rmSync(path.join(directory, 'src-tauri/bin'), { recursive: true });
+        fs.unlinkSync(path.join(directory, 'src-tauri/target/release/npm.exe'));
+        fs.rmSync(path.join(directory, 'output/desktop'), { recursive: true });
+        const receipt = readInstallerBuild(format, directory, { ...environment, GITHUB_RUN_ATTEMPT: '2' });
+        expect(receipt.buildRunAttempt).toBe('1');
+        expect(receipt.expectedFiles[format]).toHaveLength(5);
+        expect(readInstallerBuild(format, directory, environment)).toEqual(receipt);
+    });
+    test.each([
+        ['sourceRevision', 'b'.repeat(40), /source revision differs/],
+        ['runId', '456', /workflow run differs/],
+        ['version', '9.0.0', /version differs/],
+        ['buildRunAttempt', '0', /build attempt/],
+        ['buildRunAttempt', '2', /build attempt/],
+        ['sourceFingerprint', {}, /source fingerprint differs/],
+    ])('rejects tampered %s before executing anything', (field, replacement, message) => {
+        const receipt = JSON.parse(fs.readFileSync(receiptPath, 'utf8'));
+        receipt[field] = replacement;
+        fs.writeFileSync(receiptPath, JSON.stringify(receipt));
+        expect(() => readInstallerBuild('msi', directory, environment)).toThrow(message);
+    });
+    test.each(['name', 'path'])('rejects redirected installer %s', field => {
+        const receipt = JSON.parse(fs.readFileSync(receiptPath, 'utf8'));
+        receipt.installers.msi[field] = '../other.msi';
+        fs.writeFileSync(receiptPath, JSON.stringify(receipt));
+        expect(() => readInstallerBuild('msi', directory, environment)).toThrow(/Installer (basename|path) differs/);
+    });
+    test.each(['MSI altered', 'truncated'])('rejects altered installer bytes (%s)', contents => {
+        write('src-tauri/target/release/bundle/msi/NoteConnection_1.8.0_x64_en-US.msi', contents);
+        expect(() => readInstallerBuild('msi', directory, environment)).toThrow(/Installer (size|hash) differs/);
+    });
+    test('rejects changed source and missing receipts without recomputing build expectations', () => {
+        write('src/fixture.ts', 'export const source = 2;');
+        expect(() => readInstallerBuild('msi', directory, environment)).toThrow(/source fingerprint differs/);
+        fs.unlinkSync(receiptPath);
+        expect(() => readInstallerBuild('msi', directory, environment)).toThrow(/ENOENT/);
+    });
+});

package/dist/src/windows.installer.payload.test.js

@@ -0,0 +1,76 @@
+"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 { verifyInstalledPayload, fingerprintTauriInstallerExecutable } = require('../scripts/verify-windows-installers');
+const { sha256File } = require('../scripts/sidecar-build-fingerprint');
+describe('installed Windows payload verification', () => {
+    let directory;
+    let expected;
+    beforeEach(() => {
+        directory = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'installed payload '));
+        fs.writeFileSync(path.join(directory, 'path_mode.pck'), 'GDPC fixture');
+        expected = [{ name: 'path_mode.pck', bytes: 12, sha256: sha256File(path.join(directory, 'path_mode.pck')) }];
+    });
+    afterEach(() => fs.rmSync(directory, { recursive: true, force: true }));
+    test('matches exact packaged bytes under paths containing spaces', () => {
+        expect(verifyInstalledPayload(directory, expected)).toEqual(expected);
+    });
+    test('rejects missing resources even when the installer reported success', () => {
+        fs.unlinkSync(path.join(directory, 'path_mode.pck'));
+        expect(() => verifyInstalledPayload(directory, expected)).toThrow(/missing path_mode.pck/);
+    });
+    test('rejects same-sized stale resources', () => {
+        fs.writeFileSync(path.join(directory, 'path_mode.pck'), 'GDPC altered');
+        expect(() => verifyInstalledPayload(directory, expected)).toThrow(/hash differs/);
+    });
+    test.each(['NSS', 'MSI'])('checks the exact Tauri %s stamp without ignoring executable bytes', (bundleCode) => {
+        const executable = path.join(directory, 'build.exe');
+        fs.writeFileSync(executable, 'PE before\0__TAURI_BUNDLE_TYPE_VAR_UNK\0PE after');
+        const fingerprint = fingerprintTauriInstallerExecutable(executable, bundleCode);
+        fs.writeFileSync(path.join(directory, 'npm.exe'), `PE before\0__TAURI_BUNDLE_TYPE_VAR_${bundleCode}\0PE after`);
+        expect(verifyInstalledPayload(directory, [fingerprint])).toEqual([fingerprint]);
+        fs.writeFileSync(path.join(directory, 'npm.exe'), `PE edited\0__TAURI_BUNDLE_TYPE_VAR_${bundleCode}\0PE after`);
+        expect(() => verifyInstalledPayload(directory, [fingerprint])).toThrow(/hash differs/);
+        expect(fs.readFileSync(executable, 'utf8')).toContain('_VAR_UNK');
+    });
+    test.each(['missing marker', '__TAURI_BUNDLE_TYPE_VAR_UNK__TAURI_BUNDLE_TYPE_VAR_UNK'])('rejects missing or ambiguous bundle stamps (%s)', (contents) => {
+        const executable = path.join(directory, 'build.exe');
+        fs.writeFileSync(executable, contents);
+        expect(() => fingerprintTauriInstallerExecutable(executable, 'NSS')).toThrow(/exactly one/);
+    });
+});

package/dist/src/windows.installer.runtime.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("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+jest.mock('node:child_process', () => ({ ...jest.requireActual('node:child_process'), spawnSync: jest.fn() }));
+const { verifyInstalledRuntime } = require('../scripts/verify-windows-installers');
+const spawn = node_child_process_1.spawnSync;
+describe('installed runtime evidence verdict', () => {
+    let directory;
+    let run;
+    beforeEach(() => {
+        directory = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'installer-runtime-'));
+        run = path.join(directory, 'runtime');
+        fs.mkdirSync(run);
+        spawn.mockReturnValue({ status: 0, stdout: '', stderr: '' });
+        fs.writeFileSync(path.join(run, 'report.json'), JSON.stringify({ passed: true, checks: { godotLayout: true, windowTransitions: true } }));
+        fs.writeFileSync(path.join(run, 'native-debug-policy.json'), '\uFEFF' + JSON.stringify({ policyValuesRemoved: true }));
+    });
+    afterEach(() => { jest.resetAllMocks(); fs.rmSync(directory, { recursive: true, force: true }); });
+    test('accepts completed runtime evidence only after temporary policies are removed', () => {
+        expect(verifyInstalledRuntime(directory, run).passed).toBe(true);
+        expect(spawn.mock.calls[0][0]).toBe('powershell.exe');
+        expect(spawn.mock.calls[0][1]).toContain(path.resolve(__dirname, '../scripts/verify-elevated-desktop-runtime.ps1'));
+    });
+    test('rejects a successful runtime when machine policy cleanup did not complete', () => {
+        fs.writeFileSync(path.join(run, 'native-debug-policy.json'), JSON.stringify({ policyValuesRemoved: false }));
+        expect(() => verifyInstalledRuntime(directory, run)).toThrow(/policies must be removed/);
+    });
+    test('does not accept an empty successful process or lose its setup failure', () => {
+        fs.unlinkSync(path.join(run, 'report.json'));
+        spawn.mockReturnValue({ status: 1, stdout: '', stderr: 'Existing app policy cannot be overwritten' });
+        expect(() => verifyInstalledRuntime(directory, run)).toThrow(/Existing app policy cannot be overwritten/);
+    });
+});

package/dist/src/workflows/WorkflowArtifactStore.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowArtifactStore = void 0;
+class WorkflowArtifactStore {
+    constructor(nextId) {
+        this.nextId = nextId;
+        this.artifacts = [];
+    }
+    clonePayload(payload) {
+        return JSON.parse(JSON.stringify(payload || {}));
+    }
+    cloneArtifact(record) {
+        return {
+            ...record,
+            sourceResourceIds: [...record.sourceResourceIds],
+            sourceProjectionIds: [...record.sourceProjectionIds],
+            payload: this.clonePayload(record.payload),
+        };
+    }
+    recordArtifact(input) {
+        const record = {
+            artifactId: this.nextId('workflow_artifact'),
+            kind: input.kind,
+            sessionId: input.sessionId || null,
+            userId: input.userId || null,
+            workspaceId: input.workspaceId || null,
+            corpusId: input.corpusId || null,
+            title: input.title,
+            sourceResourceIds: Array.from(new Set(input.sourceResourceIds)).filter(Boolean),
+            sourceProjectionIds: Array.from(new Set(input.sourceProjectionIds)).filter(Boolean),
+            summary: input.summary,
+            payload: this.clonePayload(input.payload || {}),
+            status: input.status,
+            createdAt: input.recordedAt,
+            updatedAt: input.recordedAt,
+        };
+        this.artifacts.unshift(record);
+        if (this.artifacts.length > 400) {
+            this.artifacts.splice(400);
+        }
+        return this.cloneArtifact(record);
+    }
+    getArtifactById(artifactId) {
+        const normalizedArtifactId = String(artifactId || '').trim();
+        if (!normalizedArtifactId) {
+            return null;
+        }
+        const record = this.artifacts.find((artifact) => artifact.artifactId === normalizedArtifactId);
+        return record ? this.cloneArtifact(record) : null;
+    }
+    listAll() {
+        return this.artifacts.map((record) => this.cloneArtifact(record));
+    }
+    updateArtifact(artifactId, updater) {
+        const normalizedArtifactId = String(artifactId || '').trim();
+        if (!normalizedArtifactId) {
+            return null;
+        }
+        const index = this.artifacts.findIndex((artifact) => artifact.artifactId === normalizedArtifactId);
+        if (index < 0) {
+            return null;
+        }
+        const current = this.cloneArtifact(this.artifacts[index]);
+        const updated = updater(current);
+        this.artifacts[index] = this.cloneArtifact(updated);
+        return this.cloneArtifact(this.artifacts[index]);
+    }
+    listBySession(sessionId) {
+        return this.artifacts
+            .filter((record) => record.sessionId === String(sessionId || '').trim())
+            .map((record) => this.cloneArtifact(record));
+    }
+    listByWorkspace(workspaceId, userId) {
+        const normalizedWorkspaceId = String(workspaceId || '').trim().toLowerCase();
+        const normalizedUserId = String(userId || '').trim();
+        if (!normalizedWorkspaceId) {
+            return [];
+        }
+        return this.artifacts
+            .filter((record) => record.workspaceId === normalizedWorkspaceId)
+            .filter((record) => !normalizedUserId || record.userId === normalizedUserId)
+            .map((record) => this.cloneArtifact(record));
+    }
+    buildSnapshot() {
+        return {
+            artifacts: this.artifacts.map((artifact) => this.cloneArtifact(artifact)),
+        };
+    }
+    restoreFromSnapshot(snapshot) {
+        this.artifacts.length = 0;
+        (snapshot?.artifacts || []).forEach((artifact) => {
+            this.artifacts.push(this.cloneArtifact(artifact));
+        });
+    }
+}
+exports.WorkflowArtifactStore = WorkflowArtifactStore;

package/dist/src/workflows/WorkflowArtifactStore.test.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const WorkflowArtifactStore_1 = require("./WorkflowArtifactStore");
+describe('WorkflowArtifactStore', () => {
+    test('records artifacts and lists them by session and workspace', () => {
+        let idCounter = 0;
+        const store = new WorkflowArtifactStore_1.WorkflowArtifactStore((prefix = 'workflow_artifact') => `${prefix}_${++idCounter}`);
+        const artifact = store.recordArtifact({
+            kind: 'knowledge_run',
+            sessionId: 'session_a',
+            userId: 'user_a',
+            workspaceId: 'optics',
+            corpusId: 'optics',
+            title: 'Knowledge run',
+            sourceResourceIds: ['resource_1'],
+            sourceProjectionIds: ['projection_1'],
+            summary: 'Evidence claims recorded',
+            payload: {
+                knowledgeRun: {
+                    runId: 'knowledge_run_1',
+                },
+            },
+            status: 'active',
+            recordedAt: '2026-05-26T00:00:00.000Z',
+        });
+        expect(store.listBySession('session_a')).toEqual([artifact]);
+        expect(store.listByWorkspace('optics')).toHaveLength(1);
+        const restored = new WorkflowArtifactStore_1.WorkflowArtifactStore((prefix = 'workflow_artifact') => `${prefix}_${++idCounter}`);
+        restored.restoreFromSnapshot(store.buildSnapshot());
+        expect(restored.listByWorkspace('optics')[0]?.artifactId).toBe(artifact.artifactId);
+    });
+    test('updates persisted artifacts without exposing mutable internal references', () => {
+        let idCounter = 0;
+        const store = new WorkflowArtifactStore_1.WorkflowArtifactStore((prefix = 'workflow_artifact') => `${prefix}_${++idCounter}`);
+        const artifact = store.recordArtifact({
+            kind: 'flashcard_batch',
+            sessionId: 'session_b',
+            userId: 'user_b',
+            workspaceId: 'optics',
+            corpusId: 'optics',
+            title: 'Review batch',
+            sourceResourceIds: ['resource_2'],
+            sourceProjectionIds: ['projection_2'],
+            summary: 'Prepared 1 review card.',
+            payload: {
+                reviewState: {
+                    consumedCardIds: [],
+                    completedReviewCardCount: 0,
+                    remainingReviewCardCount: 1,
+                    completedAt: null,
+                },
+            },
+            status: 'active',
+            recordedAt: '2026-05-26T01:00:00.000Z',
+        });
+        const updated = store.updateArtifact(artifact.artifactId, (current) => ({
+            ...current,
+            status: 'archived',
+            updatedAt: '2026-05-26T01:05:00.000Z',
+            payload: {
+                ...current.payload,
+                reviewState: {
+                    consumedCardIds: ['card_1'],
+                    completedReviewCardCount: 1,
+                    remainingReviewCardCount: 0,
+                    completedAt: '2026-05-26T01:05:00.000Z',
+                },
+            },
+        }));
+        expect(updated).not.toBeNull();
+        expect(updated?.status).toBe('archived');
+        expect((updated?.payload.reviewState).consumedCardIds).toEqual(['card_1']);
+        const fetched = store.getArtifactById(artifact.artifactId);
+        expect(fetched?.status).toBe('archived');
+        expect((fetched?.payload.reviewState).remainingReviewCardCount).toBe(0);
+        (updated?.payload.reviewState).consumedCardIds.push('card_2');
+        const refetched = store.getArtifactById(artifact.artifactId);
+        expect((refetched?.payload.reviewState).consumedCardIds).toEqual(['card_1']);
+    });
+});

package/dist/src/workflows/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });