@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/router/virtual-router/routing-stop-message-actions.js

@@ -1,120 +1,99 @@
-import { DEFAULT_STOP_MESSAGE_MAX_REPEATS, ensureStopMessageModeMaxRepeats, normalizeStopMessageStageMode } from './routing-stop-message-state-codec.js';
+import { normalizeStopMessageStageMode } from './routing-stop-message-state-codec.js';
+import { applyStopMessageInstructionWithNative } from './engine-selection/native-virtual-router-stop-message-actions-semantics.js';
+const STOP_MESSAGE_FIELDS = [
+    'stopMessageSource',
+    'stopMessageText',
+    'stopMessageMaxRepeats',
+    'stopMessageUsed',
+    'stopMessageUpdatedAt',
+    'stopMessageLastUsedAt',
+    'stopMessageStageMode',
+    'stopMessageAiMode',
+    'stopMessageAiSeedPrompt',
+    'stopMessageAiHistory'
+];
+const SKIP_PATCH_VALUE = Symbol('skipPatchValue');
 export function applyStopMessageInstructionToState(instruction, state) {
-    switch (instruction.type) {
-        case 'stopMessageSet': {
-            const text = typeof instruction.stopMessageText === 'string' && instruction.stopMessageText.trim()
-                ? instruction.stopMessageText.trim()
-                : '';
-            const maxRepeats = typeof instruction.stopMessageMaxRepeats === 'number' && Number.isFinite(instruction.stopMessageMaxRepeats)
-                ? Math.floor(instruction.stopMessageMaxRepeats)
-                : 0;
-            if (!text || maxRepeats <= 0) {
-                return true;
-            }
-            const incomingMode = normalizeStopMessageStageMode(instruction.stopMessageStageMode);
-            const currentMode = normalizeStopMessageStageMode(state.stopMessageStageMode);
-            const targetMode = incomingMode ?? (currentMode === 'off' ? 'on' : currentMode);
-            const sameText = typeof state.stopMessageText === 'string' && state.stopMessageText.trim() === text;
-            const sameMax = typeof state.stopMessageMaxRepeats === 'number' &&
-                Math.floor(state.stopMessageMaxRepeats) === maxRepeats;
-            const sameMode = currentMode === targetMode;
-            const isSameInstruction = sameText && sameMax && sameMode;
-            const used = typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)
-                ? Math.max(0, Math.floor(state.stopMessageUsed))
-                : 0;
-            const hasLastUsedAt = typeof state.stopMessageLastUsedAt === 'number' && Number.isFinite(state.stopMessageLastUsedAt);
-            const shouldRearm = !isSameInstruction || used > 0 || hasLastUsedAt;
-            const shouldRearmForSource = instruction.fromHistoricalUserMessage
-                ? !isSameInstruction
-                : shouldRearm;
-            state.stopMessageText = text;
-            state.stopMessageMaxRepeats = maxRepeats;
-            state.stopMessageSource = 'explicit';
-            if (targetMode) {
-                state.stopMessageStageMode = targetMode;
-            }
-            if (shouldRearmForSource) {
-                resetStopMessageRuntimeState(state, Date.now());
-            }
-            return true;
+    const nowMs = Date.now();
+    const before = snapshotStopMessageState(state);
+    const patch = applyStopMessageInstructionWithNative(instruction, before, nowMs);
+    applyStopMessagePatch(state, patch);
+    return patch.applied;
+}
+function snapshotStopMessageState(state) {
+    return {
+        stopMessageSource: state.stopMessageSource,
+        stopMessageText: state.stopMessageText,
+        stopMessageMaxRepeats: state.stopMessageMaxRepeats,
+        stopMessageUsed: state.stopMessageUsed,
+        stopMessageUpdatedAt: state.stopMessageUpdatedAt,
+        stopMessageLastUsedAt: state.stopMessageLastUsedAt,
+        stopMessageStageMode: state.stopMessageStageMode,
+        stopMessageAiMode: state.stopMessageAiMode,
+        stopMessageAiSeedPrompt: state.stopMessageAiSeedPrompt,
+        stopMessageAiHistory: Array.isArray(state.stopMessageAiHistory) ? cloneHistory(state.stopMessageAiHistory) : undefined
+    };
+}
+function applyStopMessagePatch(state, patch) {
+    for (const field of patch.unset) {
+        if (!STOP_MESSAGE_FIELDS.includes(field)) {
+            continue;
         }
-        case 'stopMessageMode': {
-            const mode = normalizeStopMessageStageMode(instruction.stopMessageStageMode);
-            if (!mode) {
-                return true;
-            }
-            const explicitMaxRepeats = typeof instruction.stopMessageMaxRepeats === 'number' && Number.isFinite(instruction.stopMessageMaxRepeats)
-                ? Math.floor(instruction.stopMessageMaxRepeats)
-                : undefined;
-            if (mode === 'off') {
-                clearStopMessageState(state, { keepMode: 'off' });
-                return true;
-            }
-            const previousMode = normalizeStopMessageStageMode(state.stopMessageStageMode);
-            const previousMax = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
-                ? Math.floor(state.stopMessageMaxRepeats)
-                : undefined;
-            const preservedMax = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
-                ? Math.floor(state.stopMessageMaxRepeats)
-                : undefined;
-            const resolvedMax = typeof explicitMaxRepeats === 'number' && explicitMaxRepeats > 0
-                ? explicitMaxRepeats
-                : typeof preservedMax === 'number' && preservedMax > 0
-                    ? preservedMax
-                    : mode === 'on' || mode === 'auto'
-                        ? DEFAULT_STOP_MESSAGE_MAX_REPEATS
-                        : undefined;
-            state.stopMessageStageMode = mode;
-            state.stopMessageSource = 'explicit';
-            state.stopMessageMaxRepeats = resolvedMax;
-            ensureStopMessageModeMaxRepeats(state);
-            const nextMax = typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
-                ? Math.floor(state.stopMessageMaxRepeats)
-                : undefined;
-            const shouldRearm = previousMode !== mode ||
-                previousMax !== nextMax ||
-                typeof state.stopMessageUsed !== 'number' ||
-                !Number.isFinite(state.stopMessageUsed);
-            const shouldRearmForSource = instruction.fromHistoricalUserMessage
-                ? (previousMode !== mode || previousMax !== nextMax || typeof state.stopMessageUsed !== 'number' || !Number.isFinite(state.stopMessageUsed))
-                : shouldRearm;
-            if (shouldRearmForSource) {
-                resetStopMessageRuntimeState(state, Date.now());
+        state[field] = undefined;
+    }
+    for (const [field, rawValue] of Object.entries(patch.set)) {
+        const value = coerceStopMessagePatchValue(field, rawValue);
+        if (value === SKIP_PATCH_VALUE) {
+            continue;
+        }
+        state[field] = value;
+    }
+}
+function coerceStopMessagePatchValue(field, value) {
+    switch (field) {
+        case 'stopMessageSource':
+        case 'stopMessageText':
+        case 'stopMessageAiSeedPrompt':
+            return typeof value === 'string' ? value : SKIP_PATCH_VALUE;
+        case 'stopMessageStageMode': {
+            const normalized = normalizeStopMessageStageMode(value);
+            return normalized ?? SKIP_PATCH_VALUE;
+        }
+        case 'stopMessageAiMode': {
+            const normalizedAiMode = normalizeStopMessageAiMode(value);
+            return normalizedAiMode ?? SKIP_PATCH_VALUE;
+        }
+        case 'stopMessageMaxRepeats':
+        case 'stopMessageUsed':
+        case 'stopMessageUpdatedAt':
+        case 'stopMessageLastUsedAt':
+            return typeof value === 'number' && Number.isFinite(value) ? value : SKIP_PATCH_VALUE;
+        case 'stopMessageAiHistory': {
+            if (!Array.isArray(value)) {
+                return SKIP_PATCH_VALUE;
             }
-            return true;
+            return cloneHistory(value);
         }
-        case 'stopMessageClear':
-            clearStopMessageState(state);
-            return true;
-        default:
-            return false;
     }
+    return SKIP_PATCH_VALUE;
 }
-function resetStopMessageRuntimeState(state, atMs) {
-    state.stopMessageUsed = 0;
-    state.stopMessageUpdatedAt = atMs;
-    state.stopMessageLastUsedAt = undefined;
-    state.stopMessageStage = undefined;
-    state.stopMessageObservationHash = undefined;
-    state.stopMessageObservationStableCount = 0;
-    state.stopMessageBdWorkState = undefined;
-    state.stopMessageAssignedIssueId = undefined;
-    state.stopMessageAssignedIssueSource = undefined;
-    state.stopMessageNoTaskSummaryUsed = undefined;
+function cloneHistory(value) {
+    const out = [];
+    for (const item of value) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            continue;
+        }
+        out.push({ ...item });
+    }
+    return out;
 }
-function clearStopMessageState(state, options) {
-    state.stopMessageText = undefined;
-    state.stopMessageMaxRepeats = undefined;
-    state.stopMessageUsed = undefined;
-    state.stopMessageSource = undefined;
-    state.stopMessageUpdatedAt = undefined;
-    state.stopMessageLastUsedAt = undefined;
-    state.stopMessageStage = undefined;
-    state.stopMessageStageMode = options?.keepMode;
-    state.stopMessageObservationHash = undefined;
-    state.stopMessageObservationStableCount = undefined;
-    state.stopMessageBdWorkState = undefined;
-    state.stopMessageAssignedIssueId = undefined;
-    state.stopMessageAssignedIssueSource = undefined;
-    state.stopMessageNoTaskSummaryUsed = undefined;
+function normalizeStopMessageAiMode(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'on' || normalized === 'off') {
+        return normalized;
+    }
+    return undefined;
 }

package/dist/router/virtual-router/routing-stop-message-parser.js

@@ -1,142 +1,19 @@
-import { resolveStopMessageText } from './stop-message-file-resolver.js';
+import { isStopMessageFileReference, resolveStopMessageText } from './stop-message-file-resolver.js';
+import { parseStopMessageInstructionWithNative } from './engine-selection/native-virtual-router-stop-message-semantics.js';
 export const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
 export function parseStopMessageInstruction(instruction) {
-    if (!/^stopMessage\s*:/i.test(instruction)) {
+    const resolved = parseStopMessageInstructionWithNative(instruction);
+    if (!resolved) {
         return null;
     }
-    const body = instruction.slice('stopMessage'.length + 1).trim();
-    if (!body) {
-        return null;
-    }
-    if (/^clear$/i.test(body)) {
+    if (resolved.kind === 'clear') {
         return { type: 'stopMessageClear' };
     }
-    const modeOnly = parseStopMessageModeWithOptionalRepeats(body);
-    if (modeOnly) {
-        return {
-            type: 'stopMessageMode',
-            stopMessageStageMode: modeOnly.mode,
-            ...(typeof modeOnly.maxRepeats === 'number' ? { stopMessageMaxRepeats: modeOnly.maxRepeats } : {})
-        };
-    }
-    let text = '';
-    let maxRepeats = DEFAULT_STOP_MESSAGE_MAX_REPEATS;
-    let cursor = body;
-    let stageMode;
-    if (cursor[0] === '"') {
-        let escaped = false;
-        let endIndex = -1;
-        for (let i = 1; i < cursor.length; i += 1) {
-            const ch = cursor[i];
-            if (escaped) {
-                escaped = false;
-                continue;
-            }
-            if (ch === '\\') {
-                escaped = true;
-                continue;
-            }
-            if (ch === '"') {
-                endIndex = i;
-                break;
-            }
-        }
-        if (endIndex <= 0) {
-            return null;
-        }
-        const rawText = cursor.slice(1, endIndex);
-        text = rawText.replace(/\\"/g, '"');
-        cursor = cursor.slice(endIndex + 1).trim();
-        if (cursor.startsWith(',')) {
-            const tail = cursor.slice(1).trim();
-            const parsedTail = parseStopMessageTail(tail);
-            maxRepeats = parsedTail.maxRepeats;
-            stageMode = parsedTail.stageMode;
-        }
-    }
-    else {
-        const parts = cursor
-            .split(',')
-            .map((part) => part.trim())
-            .filter(Boolean);
-        if (!parts.length) {
-            return null;
-        }
-        text = parts[0];
-        const parsedTail = parseStopMessageTail(parts.slice(1));
-        maxRepeats = parsedTail.maxRepeats;
-        stageMode = parsedTail.stageMode;
-    }
-    if (!text) {
-        return null;
-    }
     return {
         type: 'stopMessageSet',
-        stopMessageText: resolveStopMessageText(text),
-        stopMessageMaxRepeats: maxRepeats,
-        ...(stageMode ? { stopMessageStageMode: stageMode } : {})
-    };
-}
-function parseStopMessageTail(input) {
-    const tokens = Array.isArray(input)
-        ? input.map((part) => part.trim()).filter(Boolean)
-        : input
-            .split(',')
-            .map((part) => part.trim())
-            .filter(Boolean);
-    let maxRepeats = DEFAULT_STOP_MESSAGE_MAX_REPEATS;
-    let stageMode;
-    for (const token of tokens) {
-        const mode = parseStopMessageStageModeToken(token);
-        if (mode) {
-            stageMode = mode;
-            continue;
-        }
-        const parsed = Number.parseInt(token, 10);
-        if (!Number.isNaN(parsed) && parsed > 0) {
-            maxRepeats = parsed;
-        }
-    }
-    return {
-        maxRepeats,
-        ...(stageMode ? { stageMode } : {})
+        stopMessageText: resolveStopMessageText(resolved.text),
+        stopMessageMaxRepeats: resolved.maxRepeats,
+        stopMessageSource: isStopMessageFileReference(resolved.text) ? 'explicit_file' : 'explicit_text',
+        ...(resolved.aiMode ? { stopMessageAiMode: resolved.aiMode } : {})
     };
 }
-function parseStopMessageModeWithOptionalRepeats(value) {
-    const normalized = value.trim().toLowerCase();
-    const match = normalized.match(/^(?:(?:stage|mode)\s*[:=]\s*)?(on|off|auto)\s*(?:,\s*(\d+)\s*)?$/i);
-    if (!match) {
-        return null;
-    }
-    const token = match[1].trim().toLowerCase();
-    const mode = token === 'on' || token === 'off' || token === 'auto'
-        ? token
-        : undefined;
-    if (!mode) {
-        return null;
-    }
-    if (mode === 'off') {
-        return { mode };
-    }
-    const repeatToken = match[2];
-    if (!repeatToken) {
-        return { mode, maxRepeats: DEFAULT_STOP_MESSAGE_MAX_REPEATS };
-    }
-    const parsed = Number.parseInt(repeatToken, 10);
-    if (Number.isNaN(parsed) || parsed <= 0) {
-        return { mode, maxRepeats: DEFAULT_STOP_MESSAGE_MAX_REPEATS };
-    }
-    return { mode, maxRepeats: parsed };
-}
-function parseStopMessageStageModeToken(value) {
-    const normalized = value.trim().toLowerCase();
-    const match = normalized.match(/^(?:(?:stage|mode)\s*[:=]\s*)?(on|off|auto)$/i);
-    if (!match) {
-        return undefined;
-    }
-    const token = match[1].trim().toLowerCase();
-    if (token === 'on' || token === 'off' || token === 'auto') {
-        return token;
-    }
-    return undefined;
-}

package/dist/router/virtual-router/routing-stop-message-state-codec.d.ts

@@ -4,3 +4,4 @@ export declare function serializeStopMessageState(state: RoutingInstructionState
 export declare function deserializeStopMessageState(data: Record<string, unknown>, state: RoutingInstructionState): void;
 export declare function normalizeStopMessageStageMode(value: unknown): 'on' | 'off' | 'auto' | undefined;
 export declare function ensureStopMessageModeMaxRepeats(state: RoutingInstructionState): boolean;
+export declare function normalizeStopMessageAiMode(value: unknown): 'on' | 'off' | undefined;

package/dist/router/virtual-router/routing-stop-message-state-codec.js

@@ -1,54 +1,13 @@
+import { deserializeStopMessageStateWithNative, serializeStopMessageStateWithNative } from './engine-selection/native-virtual-router-stop-message-state-semantics.js';
 export const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
 export function serializeStopMessageState(state) {
-    return {
-        ...(typeof state.stopMessageSource === 'string' && state.stopMessageSource.trim()
-            ? { stopMessageSource: state.stopMessageSource }
-            : {}),
-        ...(typeof state.stopMessageText === 'string' && state.stopMessageText.trim()
-            ? { stopMessageText: state.stopMessageText }
-            : {}),
-        ...(typeof state.stopMessageMaxRepeats === 'number' && Number.isFinite(state.stopMessageMaxRepeats)
-            ? { stopMessageMaxRepeats: state.stopMessageMaxRepeats }
-            : {}),
-        ...(typeof state.stopMessageUsed === 'number' && Number.isFinite(state.stopMessageUsed)
-            ? { stopMessageUsed: state.stopMessageUsed }
-            : {}),
-        ...(typeof state.stopMessageUpdatedAt === 'number' && Number.isFinite(state.stopMessageUpdatedAt)
-            ? { stopMessageUpdatedAt: state.stopMessageUpdatedAt }
-            : {}),
-        ...(typeof state.stopMessageLastUsedAt === 'number' && Number.isFinite(state.stopMessageLastUsedAt)
-            ? { stopMessageLastUsedAt: state.stopMessageLastUsedAt }
-            : {}),
-        ...(typeof state.stopMessageStage === 'string' && state.stopMessageStage.trim()
-            ? { stopMessageStage: state.stopMessageStage.trim() }
-            : {}),
-        ...(typeof state.stopMessageStageMode === 'string' && state.stopMessageStageMode.trim()
-            ? { stopMessageStageMode: state.stopMessageStageMode.trim() }
-            : {}),
-        ...(typeof state.stopMessageObservationHash === 'string' && state.stopMessageObservationHash.trim()
-            ? { stopMessageObservationHash: state.stopMessageObservationHash.trim() }
-            : {}),
-        ...(typeof state.stopMessageObservationStableCount === 'number' && Number.isFinite(state.stopMessageObservationStableCount)
-            ? { stopMessageObservationStableCount: Math.max(0, Math.floor(state.stopMessageObservationStableCount)) }
-            : {}),
-        ...(typeof state.stopMessageBdWorkState === 'string' && state.stopMessageBdWorkState.trim()
-            ? { stopMessageBdWorkState: state.stopMessageBdWorkState.trim() }
-            : {}),
-        ...(typeof state.stopMessageAssignedIssueId === 'string' && state.stopMessageAssignedIssueId.trim()
-            ? { stopMessageAssignedIssueId: state.stopMessageAssignedIssueId.trim() }
-            : {}),
-        ...(typeof state.stopMessageAssignedIssueSource === 'string' &&
-            (state.stopMessageAssignedIssueSource === 'in_progress' ||
-                state.stopMessageAssignedIssueSource === 'ready' ||
-                state.stopMessageAssignedIssueSource === 'open')
-            ? { stopMessageAssignedIssueSource: state.stopMessageAssignedIssueSource }
-            : {}),
-        ...(typeof state.stopMessageNoTaskSummaryUsed === 'boolean'
-            ? { stopMessageNoTaskSummaryUsed: state.stopMessageNoTaskSummaryUsed }
-            : {})
-    };
+    return serializeStopMessageStateWithNative(state);
 }
 export function deserializeStopMessageState(data, state) {
+    const patch = deserializeStopMessageStateWithNative(data, state);
+    deserializeStopMessageStateFallback(patch, state);
+}
+function deserializeStopMessageStateFallback(data, state) {
     if (typeof data.stopMessageSource === 'string' && data.stopMessageSource.trim()) {
         state.stopMessageSource = data.stopMessageSource.trim();
     }
@@ -68,39 +27,28 @@ export function deserializeStopMessageState(data, state) {
     if (typeof data.stopMessageLastUsedAt === 'number' && Number.isFinite(data.stopMessageLastUsedAt)) {
         state.stopMessageLastUsedAt = data.stopMessageLastUsedAt;
     }
-    if (typeof data.stopMessageStage === 'string' && data.stopMessageStage.trim()) {
-        state.stopMessageStage = data.stopMessageStage.trim();
-    }
     if (typeof data.stopMessageStageMode === 'string' && data.stopMessageStageMode.trim()) {
         const normalized = normalizeStopMessageStageMode(data.stopMessageStageMode);
         if (normalized) {
             state.stopMessageStageMode = normalized;
         }
     }
-    // Keep stopMessage mode state armed consistently across old/new snapshots.
-    if (!hasPersistedMaxRepeats) {
-        ensureStopMessageModeMaxRepeats(state);
-    }
-    if (typeof data.stopMessageObservationHash === 'string' && data.stopMessageObservationHash.trim()) {
-        state.stopMessageObservationHash = data.stopMessageObservationHash.trim();
-    }
-    if (typeof data.stopMessageObservationStableCount === 'number' && Number.isFinite(data.stopMessageObservationStableCount)) {
-        state.stopMessageObservationStableCount = Math.max(0, Math.floor(data.stopMessageObservationStableCount));
-    }
-    if (typeof data.stopMessageBdWorkState === 'string' && data.stopMessageBdWorkState.trim()) {
-        state.stopMessageBdWorkState = data.stopMessageBdWorkState.trim();
+    if (typeof data.stopMessageAiMode === 'string' && data.stopMessageAiMode.trim()) {
+        const normalizedAiMode = normalizeStopMessageAiMode(data.stopMessageAiMode);
+        if (normalizedAiMode) {
+            state.stopMessageAiMode = normalizedAiMode;
+        }
     }
-    if (typeof data.stopMessageAssignedIssueId === 'string' && data.stopMessageAssignedIssueId.trim()) {
-        state.stopMessageAssignedIssueId = data.stopMessageAssignedIssueId.trim();
+    if (typeof data.stopMessageAiSeedPrompt === 'string' && data.stopMessageAiSeedPrompt.trim()) {
+        state.stopMessageAiSeedPrompt = data.stopMessageAiSeedPrompt.trim();
     }
-    if (typeof data.stopMessageAssignedIssueSource === 'string') {
-        const source = data.stopMessageAssignedIssueSource.trim().toLowerCase();
-        if (source === 'in_progress' || source === 'ready' || source === 'open') {
-            state.stopMessageAssignedIssueSource = source;
-        }
+    const history = normalizeStopMessageAiHistoryEntries(data.stopMessageAiHistory);
+    if (history.length > 0) {
+        state.stopMessageAiHistory = history;
     }
-    if (typeof data.stopMessageNoTaskSummaryUsed === 'boolean') {
-        state.stopMessageNoTaskSummaryUsed = data.stopMessageNoTaskSummaryUsed;
+    // Keep stopMessage mode state armed consistently across old/new snapshots.
+    if (!hasPersistedMaxRepeats) {
+        ensureStopMessageModeMaxRepeats(state);
     }
 }
 export function normalizeStopMessageStageMode(value) {
@@ -132,3 +80,42 @@ export function ensureStopMessageModeMaxRepeats(state) {
     state.stopMessageMaxRepeats = DEFAULT_STOP_MESSAGE_MAX_REPEATS;
     return true;
 }
+export function normalizeStopMessageAiMode(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'on' || normalized === 'off') {
+        return normalized;
+    }
+    return undefined;
+}
+function normalizeStopMessageAiHistoryEntries(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const out = [];
+    for (const item of value) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            continue;
+        }
+        const record = item;
+        const normalized = {};
+        if (typeof record.ts === 'number' && Number.isFinite(record.ts)) {
+            normalized.ts = Math.floor(record.ts);
+        }
+        if (typeof record.round === 'number' && Number.isFinite(record.round)) {
+            normalized.round = Math.max(0, Math.floor(record.round));
+        }
+        for (const key of ['assistantText', 'reasoningText', 'responseExcerpt', 'followupText']) {
+            const raw = record[key];
+            if (typeof raw === 'string' && raw.trim()) {
+                normalized[key] = raw.trim();
+            }
+        }
+        if (Object.keys(normalized).length > 0) {
+            out.push(normalized);
+        }
+    }
+    return out.slice(-8);
+}

package/dist/router/virtual-router/sticky-session-store.d.ts

@@ -1,4 +1,8 @@
 import type { RoutingInstructionState } from './routing-instructions.js';
+export declare class StickySessionKeyMissingError extends Error {
+    readonly key: string | undefined;
+    constructor(key: string | undefined, message: string);
+}
 export declare function loadRoutingInstructionStateSync(key: string | undefined): RoutingInstructionState | null;
 export declare function saveRoutingInstructionStateAsync(key: string | undefined, state: RoutingInstructionState | null): void;
 export declare function saveRoutingInstructionStateSync(key: string | undefined, state: RoutingInstructionState | null): void;