noteconnection 1.7.0 → 1.9.0

package/dist/src/routes/registry.contract.test.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Route Registry Contract Tests
+ * Verifies the modular route registration and dispatch infrastructure.
+ */
+const index_1 = require("./index");
+const constants_1 = require("../notemd/constants");
+function createMockContext() {
+    const scheduleKnowledgeLearningPlatformWarmup = jest.fn();
+    return {
+        knowledgeLearningPlatform: {
+            getKnowledgeState: async () => ({ documents: 0 })
+        },
+        scheduleKnowledgeLearningPlatformWarmup,
+        knowledgeIngestor: { ingestKnowledge: async () => ({}), averageIngestLatencyMs: () => 0, getDiagnostics: () => ({}) },
+        knowledgeQuerier: { queryKnowledge: async () => ({}), getDiagnosticsSummary: () => ({}) },
+        conversationManager: { getDiagnosticsSummary: () => ({}) },
+        masteryEngine: { getDiagnosticsSummary: () => ({}) },
+        qualityEvaluator: { getDiagnosticsSummary: () => ({}) },
+        tutorRouter: { getDiagnosticsSummary: () => ({}) },
+        memoryPolicyManager: { getDiagnosticsSummary: () => ({}) },
+        notemdService: {},
+        loadNotemdSettings: async () => structuredClone(constants_1.DEFAULT_SETTINGS),
+        persistNotemdSettings: async () => structuredClone(constants_1.DEFAULT_SETTINGS),
+        notemdHttp: {},
+        LOOPBACK_HOST: '127.0.0.1',
+        finalPort: 3000,
+        KNOWLEDGE_GRAPH_STORE_BACKEND: 'file',
+        KNOWLEDGE_GRAPHDB_ADAPTER_PROVIDER: 'none',
+        KNOWLEDGE_GRAPHDB_ADAPTER_ID: '',
+        KNOWLEDGE_GRAPHDB_FALLBACK_ENABLED: false,
+        KNOWLEDGE_GRAPHDB_OPERATION_MODE: 'read_write',
+        kbRoot: '/tmp/test-kb',
+        runtimeDataDir: '/tmp/test-runtime-data',
+    };
+}
+describe('Route Registry', () => {
+    const ctx = createMockContext();
+    const routes = (0, index_1.registerAllRoutes)(ctx);
+    test('registers all route groups', () => {
+        expect(routes.length).toBeGreaterThanOrEqual(70);
+    });
+    test('every route has required fields', () => {
+        for (const route of routes) {
+            expect(route.method).toMatch(/^(GET|POST|PUT|DELETE)$/);
+            expect(route.path).toBeTruthy();
+            expect(typeof route.handler).toBe('function');
+        }
+    });
+    test('knowledge routes are registered', () => {
+        const knowledgeRoutes = routes.filter(r => r.path.startsWith('/api/knowledge'));
+        expect(knowledgeRoutes.length).toBeGreaterThanOrEqual(30);
+        // Verify key endpoints exist
+        const paths = new Set(knowledgeRoutes.map(r => `${r.method} ${r.path}`));
+        expect(paths.has('GET /api/knowledge/state')).toBe(true);
+        expect(paths.has('GET /api/knowledge/workflow-artifacts')).toBe(true);
+        expect(paths.has('POST /api/knowledge/workflow-artifacts/review-follow-up')).toBe(true);
+        expect(paths.has('POST /api/knowledge/ingest')).toBe(true);
+        expect(paths.has('POST /api/knowledge/query')).toBe(true);
+        expect(paths.has('POST /api/knowledge/export/workspace')).toBe(true);
+        expect(paths.has('POST /api/knowledge/session/graph-focus-diagnostics')).toBe(true);
+        expect(paths.has('POST /api/knowledge/conversation')).toBe(false);
+    });
+    test('notemd routes are registered', () => {
+        const notemdRoutes = routes.filter(r => r.path.startsWith('/api/notemd'));
+        expect(notemdRoutes.length).toBeGreaterThanOrEqual(10);
+        const paths = new Set(notemdRoutes.map(r => `${r.method} ${r.path}`));
+        expect(paths.has('GET /api/notemd/settings')).toBe(true);
+        expect(paths.has('POST /api/notemd/process-file')).toBe(true);
+    });
+    test('render routes are registered', () => {
+        const renderRoutes = routes.filter(r => r.path.startsWith('/api/render') || r.path.startsWith('/api/clipboard'));
+        expect(renderRoutes.map(route => route.path).sort()).toEqual(['/api/render/math', '/api/render/mermaid']);
+    });
+    test('no duplicate method+path combinations', () => {
+        const seen = new Set();
+        for (const route of routes) {
+            const key = `${route.method} ${route.path}`;
+            expect(seen.has(key)).toBe(false);
+            seen.add(key);
+        }
+    });
+    test('all GET routes have idempotent paths', () => {
+        const getRoutes = routes.filter(r => r.method === 'GET');
+        for (const route of getRoutes) {
+            expect(route.path).toMatch(/^\/api\//);
+        }
+    });
+    test('domain diagnostics are exposed via context', () => {
+        // All 7 domain classes are available through ServerContext
+        expect(ctx.knowledgeIngestor).toBeDefined();
+        expect(ctx.knowledgeQuerier).toBeDefined();
+        expect(ctx.conversationManager).toBeDefined();
+        expect(ctx.masteryEngine).toBeDefined();
+        expect(ctx.qualityEvaluator).toBeDefined();
+        expect(ctx.tutorRouter).toBeDefined();
+        expect(ctx.memoryPolicyManager).toBeDefined();
+    });
+    test('domain diagnostics have required methods', () => {
+        expect(typeof ctx.knowledgeIngestor.getDiagnostics).toBe('function');
+        expect(typeof ctx.knowledgeQuerier.getDiagnosticsSummary).toBe('function');
+        expect(typeof ctx.conversationManager.getDiagnosticsSummary).toBe('function');
+        expect(typeof ctx.masteryEngine.getDiagnosticsSummary).toBe('function');
+        expect(typeof ctx.qualityEvaluator.getDiagnosticsSummary).toBe('function');
+        expect(typeof ctx.tutorRouter.getDiagnosticsSummary).toBe('function');
+        expect(typeof ctx.memoryPolicyManager.getDiagnosticsSummary).toBe('function');
+    });
+    test('knowledge routes can be dispatched', async () => {
+        const stateRoute = routes.find(r => r.method === 'GET' && r.path === '/api/knowledge/state');
+        expect(stateRoute).toBeDefined();
+        // Mock request/response
+        const mockRes = {
+            _statusCode: 0,
+            _headers: {},
+            _body: '',
+            writeHead(code, headers) {
+                this._statusCode = code;
+                this._headers = headers;
+            },
+            end(data) {
+                this._body = data;
+            },
+            setHeader(_name, _value) { },
+            getHeader(_name) { return ''; },
+        };
+        await stateRoute.handler({ url: '/api/knowledge/state', method: 'GET', headers: {} }, mockRes, ctx);
+        // The handler should produce a JSON response
+        expect(mockRes._statusCode).toBeGreaterThanOrEqual(200);
+        expect(mockRes._statusCode).toBeLessThan(600);
+        expect(ctx.scheduleKnowledgeLearningPlatformWarmup).toHaveBeenCalledWith('knowledge_state_request');
+    });
+});

package/dist/src/routes/registry.shadow.contract.test.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+describe('route registry shadow parity gate', () => {
+    const repoRoot = node_path_1.default.resolve(__dirname, '..', '..');
+    const serverSource = node_fs_1.default.readFileSync(node_path_1.default.join(repoRoot, 'src', 'server.ts'), 'utf8');
+    const packageJson = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(repoRoot, 'package.json'), 'utf8'));
+    test('supports an explicit legacy mode without changing the default registry mode', () => {
+        expect(serverSource.includes('NOTE_CONNECTION_ROUTE_DISPATCH_MODE')).toBe(true);
+        expect(serverSource.includes("ROUTE_DISPATCH_MODE === 'registry'")).toBe(true);
+        expect(serverSource.includes("registeredRoute && (USE_REGISTRY_DISPATCH || requestPath.startsWith('/api/notemd/'))")).toBe(true);
+        expect(/(?:get|post)Pathname === '\/api\/notemd\//.test(serverSource)).toBe(false);
+    });
+    test('ships an executable parity harness as a release gate', () => {
+        expect(packageJson.scripts?.['verify:route:shadow']).toBe('npm run build:mini && node scripts/verify-route-registry-shadow.js');
+        expect(node_fs_1.default.existsSync(node_path_1.default.join(repoRoot, 'scripts', 'verify-route-registry-shadow.js'))).toBe(true);
+    });
+});

package/dist/src/routes/render.js

@@ -0,0 +1,248 @@
+"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.registerRenderRoutes = registerRenderRoutes;
+const isPngBuffer = (value) => value.length >= 8
+    && value[0] === 0x89
+    && value[1] === 0x50
+    && value[2] === 0x4e
+    && value[3] === 0x47
+    && value[4] === 0x0d
+    && value[5] === 0x0a
+    && value[6] === 0x1a
+    && value[7] === 0x0a;
+const CrashLogger_1 = require("../backend/utils/CrashLogger");
+const RenderMaterializer_1 = require("../platform/RenderMaterializer");
+function normalizeMermaidRendererPreference(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (normalized === 'local') {
+        return 'local';
+    }
+    if (normalized === 'frontend' || normalized === 'bridge') {
+        return 'frontend';
+    }
+    return 'auto';
+}
+function registerRenderRoutes(ctx) {
+    const json = (res, code, data) => {
+        res.writeHead(code, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+    const fail = (res, error, label) => {
+        console.error(error);
+        CrashLogger_1.CrashLogger.log(error, label);
+        json(res, 500, { success: false, error: String(error) });
+    };
+    const readBody = (req) => new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+    const parseOptionalPositiveDimension = (value) => {
+        const numeric = Number(value);
+        if (!Number.isFinite(numeric) || numeric <= 0) {
+            return undefined;
+        }
+        return Math.floor(numeric);
+    };
+    const parseOptionalPositiveScale = (value) => {
+        const numeric = Number(value);
+        if (!Number.isFinite(numeric) || numeric <= 0) {
+            return undefined;
+        }
+        return numeric;
+    };
+    const renderMermaidWithPreference = async (source, options) => {
+        const includeSvg = options.includeStages || options.includeSvg;
+        const { normalizeMermaidDefinition } = await Promise.resolve().then(() => __importStar(require('../reader_renderer')));
+        const normalizedSource = normalizeMermaidDefinition(source);
+        const pathBridge = typeof ctx.getPathBridge === 'function' ? ctx.getPathBridge() : null;
+        if (options.rendererPreference !== 'local'
+            && pathBridge
+            && typeof pathBridge.requestFrontendMermaidRender === 'function') {
+            try {
+                const frontendRendered = await pathBridge.requestFrontendMermaidRender({
+                    source,
+                    theme: 'dark',
+                    maxWidth: options.maxWidth,
+                    maxHeight: options.maxHeight,
+                    renderScale: options.renderScale,
+                    includeStages: options.includeStages,
+                    includeSvg,
+                });
+                const frontendResult = {
+                    pngBase64: frontendRendered.pngBase64,
+                    width: frontendRendered.width,
+                    height: frontendRendered.height,
+                    renderer: frontendRendered.renderer || 'frontend-bridge',
+                    normalizedSource,
+                };
+                if (includeSvg && typeof frontendRendered.svg === 'string' && frontendRendered.svg.trim()) {
+                    frontendResult.svg = frontendRendered.svg;
+                }
+                if (options.includeStages && Array.isArray(frontendRendered.stages)) {
+                    frontendResult.stages = frontendRendered.stages;
+                }
+                return frontendResult;
+            }
+            catch (error) {
+                if (options.rendererPreference === 'frontend') {
+                    throw error;
+                }
+                console.warn('[Render Route] Frontend Mermaid renderer unavailable, falling back to local resvg.', error);
+            }
+        }
+        const { collectMermaidRenderStageSnapshots, renderMermaidPng, } = await Promise.resolve().then(() => __importStar(require('../reader_renderer')));
+        const localRendered = await renderMermaidPng(source, {
+            theme: 'dark',
+            maxWidth: options.maxWidth,
+            maxHeight: options.maxHeight,
+            renderScale: options.renderScale,
+        });
+        const localResult = {
+            pngBase64: localRendered.pngBase64,
+            width: localRendered.width,
+            height: localRendered.height,
+            renderer: 'local-resvg',
+            normalizedSource,
+        };
+        if (includeSvg && typeof localRendered.svg === 'string' && localRendered.svg.trim()) {
+            localResult.svg = localRendered.svg;
+        }
+        if (options.includeStages) {
+            localResult.stages = await collectMermaidRenderStageSnapshots(source, {
+                theme: 'dark',
+                maxWidth: options.maxWidth,
+                maxHeight: options.maxHeight,
+                renderScale: options.renderScale,
+            });
+        }
+        return localResult;
+    };
+    return [
+        {
+            method: 'POST',
+            path: '/api/render/math',
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const payload = JSON.parse(body);
+                    const expression = typeof payload?.expression === 'string'
+                        ? payload.expression
+                        : (typeof payload?.source === 'string' ? payload.source : '');
+                    if (!expression.trim()) {
+                        const hasExpressionField = Object.prototype.hasOwnProperty.call(payload || {}, 'expression');
+                        json(res, 400, hasExpressionField
+                            ? { success: false, error: 'Missing expression' }
+                            : { error: 'Missing source' });
+                        return;
+                    }
+                    const { renderMathPng } = await Promise.resolve().then(() => __importStar(require('../reader_renderer')));
+                    const result = await renderMathPng(expression, {
+                        displayMode: payload?.displayMode !== false,
+                        maxWidth: parseOptionalPositiveDimension(payload?.maxWidth),
+                        maxHeight: parseOptionalPositiveDimension(payload?.maxHeight),
+                        renderScale: parseOptionalPositiveScale(payload?.renderScale),
+                    });
+                    const materialization = (0, RenderMaterializer_1.resolveRenderMaterializationDecision)({
+                        exportProfileId: payload?.exportProfileId,
+                        platformTarget: payload?.platformTarget,
+                    });
+                    json(res, 200, {
+                        success: true,
+                        pngBase64: result.pngBase64,
+                        width: result.width,
+                        height: result.height,
+                        materialization,
+                    });
+                }
+                catch (e) {
+                    fail(res, e, 'POST /api/render/math');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: '/api/render/mermaid',
+            handler: async (req, res) => {
+                let source = '';
+                try {
+                    const body = await readBody(req);
+                    const payload = JSON.parse(body);
+                    source = typeof payload?.source === 'string'
+                        ? payload.source
+                        : (typeof payload?.diagram === 'string' ? payload.diagram : '');
+                    if (!source.trim()) {
+                        json(res, 400, { error: 'Missing source' });
+                        return;
+                    }
+                    const includeStages = payload?.includeStages === true;
+                    const materialization = (0, RenderMaterializer_1.resolveRenderMaterializationDecision)({
+                        exportProfileId: payload?.exportProfileId,
+                        platformTarget: payload?.platformTarget,
+                        includeSvg: payload?.includeSvg === true,
+                        includeStages,
+                        rendererPreference: payload?.renderer,
+                    });
+                    const rendererPreference = normalizeMermaidRendererPreference(materialization.rendererPreference);
+                    const responsePayload = await renderMermaidWithPreference(source, {
+                        rendererPreference,
+                        includeStages: materialization.includeStages,
+                        includeSvg: materialization.includeSvg,
+                        maxWidth: parseOptionalPositiveDimension(payload?.maxWidth),
+                        maxHeight: parseOptionalPositiveDimension(payload?.maxHeight),
+                        renderScale: parseOptionalPositiveScale(payload?.renderScale),
+                    });
+                    responsePayload.materialization = materialization;
+                    json(res, 200, responsePayload);
+                }
+                catch (e) {
+                    try {
+                        const { normalizeMermaidDefinition } = await Promise.resolve().then(() => __importStar(require('../reader_renderer')));
+                        json(res, 500, {
+                            success: false,
+                            error: String(e),
+                            normalizedSource: normalizeMermaidDefinition(source),
+                        });
+                    }
+                    catch {
+                        fail(res, e, 'POST /api/render/mermaid');
+                    }
+                }
+            },
+        },
+    ];
+}

package/dist/src/routes/runtimeRunbookRouteOps.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__runtimeRunbookRouteOpsTestUtils = void 0;
+exports.createRuntimeRunbookRouteOps = createRuntimeRunbookRouteOps;
+const learning_1 = require("../learning");
+function normalizeVerificationStatus(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    return (normalized === 'pass'
+        || normalized === 'warn'
+        || normalized === 'fail')
+        ? normalized
+        : 'unknown';
+}
+function buildRuntimeRunbookVerifyFallbackResult(input) {
+    return {
+        generatedAt: input.generatedAt,
+        requestedCheckId: input.requestedCheckId,
+        selectedCheckId: '',
+        effectiveCheckId: '',
+        selectedCheckStatus: 'unknown',
+        selectedCheckEscalation: 'normal',
+        selectedCheckPriorityScore: 0,
+        selectedCheckMessage: 'No verification history available yet.',
+        verificationTargets: Array.isArray(input.runbook.verificationTargets)
+            ? input.runbook.verificationTargets
+            : [],
+        selectedCheckEscalationActions: [],
+        traceSummary: {
+            returnedRecords: 0,
+            errorRequests: 0,
+            errorRatioPct: 0,
+            p95DurationMs: 0,
+        },
+        selectedCheckHistory: {
+            returnedRecords: 0,
+            activeRiskStreak: 0,
+            activeFailStreak: 0,
+            trendStatus: 'insufficient_data',
+        },
+        selectedCheckRemediation: {
+            latestStatus: '',
+            trendStatus: 'insufficient_data',
+            riskRatioPct: 0,
+        },
+        queryVectorAccelerationIndexSyncHealth: input.buildIndexSyncHealthSummary(input.runtimeCapabilityMatrix),
+    };
+}
+function createRuntimeRunbookRouteOps(deps) {
+    return {
+        getRunbook: async (request = {}) => {
+            const generatedAt = new Date().toISOString();
+            const runtimePayload = await deps.buildRuntimePayload(generatedAt);
+            return (0, learning_1.buildRuntimeCapabilityRunbook)(runtimePayload.runtimeCapabilityMatrix, String(request.checkId || '').trim());
+        },
+        verify: async (request = {}) => {
+            const requestedCheckId = deps.normalizeCheckId(request.checkId || '');
+            const sinceMinutes = Math.max(0, Math.floor(Number(request.sinceMinutes || 1440)));
+            const traceLimit = Math.max(1, Math.floor(Number(request.limit || 20)));
+            const generatedAt = new Date().toISOString();
+            const runtimePayload = await deps.buildRuntimePayload(generatedAt);
+            const runbook = (0, learning_1.buildRuntimeCapabilityRunbook)(runtimePayload.runtimeCapabilityMatrix, requestedCheckId);
+            const selectedCheckId = deps.normalizeCheckId(String(runbook.selectedCheck?.checkId || requestedCheckId));
+            if (selectedCheckId) {
+                const replayResult = await deps.replayVerificationForCheck({
+                    checkId: selectedCheckId,
+                    sinceMinutes,
+                    traceLimit,
+                });
+                if (replayResult) {
+                    const resolvedCheckId = deps.normalizeCheckId(String(replayResult.resolvedCheckId || selectedCheckId));
+                    return {
+                        ...replayResult,
+                        selectedCheckId: resolvedCheckId || selectedCheckId,
+                        effectiveCheckId: resolvedCheckId || selectedCheckId,
+                    };
+                }
+            }
+            return buildRuntimeRunbookVerifyFallbackResult({
+                generatedAt,
+                requestedCheckId,
+                runbook,
+                runtimeCapabilityMatrix: runtimePayload.runtimeCapabilityMatrix,
+                buildIndexSyncHealthSummary: deps.buildIndexSyncHealthSummary,
+            });
+        },
+        getHistory: async (request = {}) => deps.queryHistory({
+            limit: deps.parseHistoryLimit(request.limit),
+            checkId: deps.normalizeCheckId(request.checkId || ''),
+            sinceMinutes: deps.parseHistorySinceMinutes(request.sinceMinutes),
+            status: deps.normalizeVerificationStatus(request.status || ''),
+        }),
+        getChecks: async (request = {}) => deps.queryChecks({
+            limit: deps.parseChecksLimit(request.limit),
+            sinceMinutes: deps.parseHistorySinceMinutes(request.sinceMinutes),
+            status: deps.normalizeVerificationStatus(request.status || ''),
+            checkQuery: String(request.checkQuery || '').trim(),
+        }),
+        getActionQueue: async (request = {}) => deps.queryActionQueue({
+            checksQuery: {
+                limit: deps.parseChecksLimit(request.limit),
+                sinceMinutes: deps.parseHistorySinceMinutes(request.sinceMinutes),
+                status: deps.normalizeVerificationStatus(request.status || ''),
+                checkQuery: String(request.checkQuery || '').trim(),
+            },
+            queueLimit: deps.parseActionQueueLimit(request.queueLimit),
+            priorityFilter: deps.normalizeActionQueuePriorityFilter(request.priority || ''),
+            categoryFilter: deps.normalizeActionQueueCategoryFilter(request.category || ''),
+            checkIdFilter: deps.normalizeCheckId(request.checkId || ''),
+            remediationStatusFilter: deps.normalizeActionQueueRemediationStatusFilter(request.remediationStatus || ''),
+            remediationTrendFilter: deps.normalizeActionQueueRemediationTrendFilter(request.remediationTrend || ''),
+        }),
+        getRemediationHistory: async (request = {}) => deps.queryRemediationHistory({
+            limit: deps.parseRemediationLimit(request.limit),
+            sinceMinutes: deps.parseHistorySinceMinutes(request.sinceMinutes),
+            status: deps.normalizeRemediationStatusQuery(request.status || ''),
+            source: deps.normalizeRemediationSource(request.source || ''),
+            checkId: deps.normalizeCheckId(request.checkId || ''),
+        }),
+        getReplaySchedule: async () => deps.getReplaySchedule(),
+        recordRemediationEvent: async (payload, requestId = '') => {
+            const record = deps.normalizeRemediationEventPayload(payload, requestId);
+            deps.appendRemediationEventRecord(record);
+            deps.triggerReplayScheduleFromEvent();
+            return {
+                record,
+                summary: {
+                    totalRecords: Math.max(0, Math.floor(Number(deps.getRemediationEventCount() || 0))),
+                },
+            };
+        },
+        replayRemediationEvent: async (payload) => {
+            const replayOptions = deps.normalizeRemediationReplayRequestPayload(payload);
+            return deps.replayRemediationEvents(replayOptions);
+        },
+        updateReplaySchedule: async (payload) => deps.updateReplaySchedule(payload),
+        tickReplaySchedule: async (payload = {}) => {
+            const tickOptions = deps.normalizeReplayScheduleTickPayload(payload);
+            return deps.tickReplaySchedule({
+                force: tickOptions.force,
+                dryRunOverride: tickOptions.dryRunOverride,
+                actor: 'modular_route',
+            });
+        },
+    };
+}
+exports.__runtimeRunbookRouteOpsTestUtils = {
+    buildRuntimeRunbookVerifyFallbackResult,
+    normalizeVerificationStatus,
+};