noteconnection 1.7.0 → 1.8.0

package/dist/src/routes/render.js

@@ -0,0 +1,285 @@
+"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 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()) {
+                        json(res, 400, { success: false, error: 'Missing expression' });
+                        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, { success: false, 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');
+                    }
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: '/api/render/graphviz',
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    json(res, 200, { success: true, message: 'graphviz render route' });
+                }
+                catch (e) {
+                    fail(res, e, 'POST /api/render/graphviz');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: '/api/clipboard/image',
+            handler: async (req, res) => {
+                try {
+                    const body = await readBody(req);
+                    const { pngBase64 } = JSON.parse(body);
+                    const { copyPngToClipboard } = await Promise.resolve().then(() => __importStar(require('../native_clipboard')));
+                    await copyPngToClipboard(Buffer.from(pngBase64 || '', 'base64'));
+                    json(res, 200, { success: true });
+                }
+                catch (e) {
+                    fail(res, e, 'POST /api/clipboard/image');
+                }
+            },
+        },
+        {
+            method: 'POST',
+            path: '/api/clipboard/image-binary',
+            handler: async (req, res) => {
+                try {
+                    const chunks = [];
+                    req.on('data', (c) => chunks.push(c));
+                    await new Promise((resolve, reject) => {
+                        req.on('end', resolve);
+                        req.on('error', reject);
+                    });
+                    const { copyPngToClipboard } = await Promise.resolve().then(() => __importStar(require('../native_clipboard')));
+                    await copyPngToClipboard(Buffer.concat(chunks));
+                    json(res, 200, { success: true });
+                }
+                catch (e) {
+                    fail(res, e, 'POST /api/clipboard/image-binary');
+                }
+            },
+        },
+    ];
+}

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,
+};

package/dist/src/routes/runtimeRunbookRouteOps.test.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtimeRunbookRouteOps_1 = require("./runtimeRunbookRouteOps");
+function createRuntimeCapabilityMatrix(overrides = {}) {
+    return {
+        generatedAt: '2026-06-06T10:00:00.000Z',
+        overallStatus: 'degraded',
+        summary: {
+            passCount: 0,
+            warnCount: 0,
+            failCount: 1,
+        },
+        checks: [
+            {
+                checkId: 'alpha_check',
+                status: 'fail',
+                message: 'alpha failed',
+                observed: 'observed',
+                priorityScore: 12,
+                recommendedActions: ['Inspect alpha'],
+            },
+        ],
+        signals: {
+            topRiskCheckId: 'alpha_check',
+        },
+        ...overrides,
+    };
+}
+function createDependencies(overrides = {}) {
+    return {
+        buildRuntimePayload: jest.fn(async (generatedAt) => ({
+            runtimeCapabilityMatrix: createRuntimeCapabilityMatrix({
+                generatedAt,
+            }),
+        })),
+        normalizeCheckId: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        replayVerificationForCheck: jest.fn(async () => null),
+        buildIndexSyncHealthSummary: jest.fn(() => ({ health: 'index-sync-ok' })),
+        queryHistory: jest.fn(async (request) => request),
+        parseHistoryLimit: jest.fn((value) => Number(value || 20)),
+        parseHistorySinceMinutes: jest.fn((value) => Number(value || 1440)),
+        normalizeVerificationStatus: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        queryChecks: jest.fn(async (request) => request),
+        parseChecksLimit: jest.fn((value) => Number(value || 8)),
+        queryActionQueue: jest.fn(async (request) => request),
+        parseActionQueueLimit: jest.fn((value) => Number(value || 12)),
+        normalizeActionQueuePriorityFilter: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        normalizeActionQueueCategoryFilter: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        normalizeActionQueueRemediationStatusFilter: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        normalizeActionQueueRemediationTrendFilter: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        queryRemediationHistory: jest.fn(async (request) => request),
+        parseRemediationLimit: jest.fn((value) => Number(value || 20)),
+        normalizeRemediationStatusQuery: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        normalizeRemediationSource: jest.fn((value) => String(value || '').trim().toLowerCase()),
+        getReplaySchedule: jest.fn(async () => ({ enabled: true })),
+        normalizeRemediationEventPayload: jest.fn((payload, requestId) => ({
+            payload,
+            requestId,
+        })),
+        appendRemediationEventRecord: jest.fn(),
+        getRemediationEventCount: jest.fn(() => 3),
+        triggerReplayScheduleFromEvent: jest.fn(),
+        normalizeRemediationReplayRequestPayload: jest.fn((payload) => ({
+            normalizedReplayPayload: payload,
+        })),
+        replayRemediationEvents: jest.fn(async (payload) => payload),
+        updateReplaySchedule: jest.fn(async (payload) => ({
+            updated: payload,
+        })),
+        normalizeReplayScheduleTickPayload: jest.fn((payload) => ({
+            force: Boolean(payload?.force),
+            dryRunOverride: payload?.dryRunOverride,
+        })),
+        tickReplaySchedule: jest.fn(async (options) => options),
+        ...overrides,
+    };
+}
+describe('runtimeRunbookRouteOps', () => {
+    test('verify reuses replay result and resolves selected/effective check ids', async () => {
+        const deps = createDependencies({
+            replayVerificationForCheck: jest.fn(async () => ({
+                resolvedCheckId: 'alpha_check_resolved',
+                replayedAt: '2026-06-06T10:01:00.000Z',
+                selectedCheckStatus: 'fail',
+            })),
+        });
+        const ops = (0, runtimeRunbookRouteOps_1.createRuntimeRunbookRouteOps)(deps);
+        const result = await ops.verify?.({
+            checkId: 'alpha_check',
+            sinceMinutes: 60,
+            limit: 15,
+        });
+        expect(deps.replayVerificationForCheck).toHaveBeenCalledWith({
+            checkId: 'alpha_check',
+            sinceMinutes: 60,
+            traceLimit: 15,
+        });
+        expect(result).toMatchObject({
+            resolvedCheckId: 'alpha_check_resolved',
+            selectedCheckId: 'alpha_check_resolved',
+            effectiveCheckId: 'alpha_check_resolved',
+            selectedCheckStatus: 'fail',
+        });
+    });
+    test('verify returns stable fallback result when no verification history is available', async () => {
+        const deps = createDependencies();
+        const ops = (0, runtimeRunbookRouteOps_1.createRuntimeRunbookRouteOps)(deps);
+        const result = await ops.verify?.({
+            checkId: 'alpha_check',
+        });
+        expect(result).toMatchObject({
+            requestedCheckId: 'alpha_check',
+            selectedCheckId: '',
+            effectiveCheckId: '',
+            selectedCheckStatus: 'unknown',
+            selectedCheckEscalation: 'normal',
+            selectedCheckMessage: 'No verification history available yet.',
+            selectedCheckHistory: {
+                returnedRecords: 0,
+                activeRiskStreak: 0,
+                activeFailStreak: 0,
+                trendStatus: 'insufficient_data',
+            },
+            selectedCheckRemediation: {
+                latestStatus: '',
+                trendStatus: 'insufficient_data',
+                riskRatioPct: 0,
+            },
+            queryVectorAccelerationIndexSyncHealth: {
+                health: 'index-sync-ok',
+            },
+        });
+        expect(Array.isArray(result.verificationTargets)).toBe(true);
+        expect(result.verificationTargets.length).toBeGreaterThan(0);
+    });
+    test('getActionQueue delegates normalized filters to the query owner', async () => {
+        const deps = createDependencies();
+        const ops = (0, runtimeRunbookRouteOps_1.createRuntimeRunbookRouteOps)(deps);
+        await ops.getActionQueue?.({
+            limit: 9,
+            sinceMinutes: 33,
+            status: 'WARN',
+            checkQuery: 'alpha',
+            queueLimit: 7,
+            priority: 'P1',
+            category: 'trend',
+            checkId: 'ALPHA_CHECK',
+            remediationStatus: 'SUCCESS',
+            remediationTrend: 'REGRESSING',
+        });
+        expect(deps.queryActionQueue).toHaveBeenCalledWith({
+            checksQuery: {
+                limit: 9,
+                sinceMinutes: 33,
+                status: 'warn',
+                checkQuery: 'alpha',
+            },
+            queueLimit: 7,
+            priorityFilter: 'p1',
+            categoryFilter: 'trend',
+            checkIdFilter: 'alpha_check',
+            remediationStatusFilter: 'success',
+            remediationTrendFilter: 'regressing',
+        });
+    });
+    test('recordRemediationEvent appends the normalized record and returns count summary', async () => {
+        const deps = createDependencies();
+        const ops = (0, runtimeRunbookRouteOps_1.createRuntimeRunbookRouteOps)(deps);
+        const result = await ops.recordRemediationEvent?.({
+            action: 'retry',
+        }, 'req-123');
+        expect(deps.normalizeRemediationEventPayload).toHaveBeenCalledWith({
+            action: 'retry',
+        }, 'req-123');
+        expect(deps.appendRemediationEventRecord).toHaveBeenCalledWith({
+            payload: {
+                action: 'retry',
+            },
+            requestId: 'req-123',
+        });
+        expect(deps.triggerReplayScheduleFromEvent).toHaveBeenCalled();
+        expect(result).toEqual({
+            record: {
+                payload: {
+                    action: 'retry',
+                },
+                requestId: 'req-123',
+            },
+            summary: {
+                totalRecords: 3,
+            },
+        });
+    });
+});

package/dist/src/routes/settings.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSettingsRoutes = registerSettingsRoutes;
+function registerSettingsRoutes(_ctx) {
+    return [];
+}