@jsonstudio/llms 0.6.1739 → 0.6.1890

package/dist/router/virtual-router/routing-pre-command-state-codec.js

@@ -0,0 +1,24 @@
+export function serializePreCommandState(state) {
+    return {
+        ...(typeof state.preCommandSource === 'string' && state.preCommandSource.trim()
+            ? { preCommandSource: state.preCommandSource.trim() }
+            : {}),
+        ...(typeof state.preCommandScriptPath === 'string' && state.preCommandScriptPath.trim()
+            ? { preCommandScriptPath: state.preCommandScriptPath.trim() }
+            : {}),
+        ...(typeof state.preCommandUpdatedAt === 'number' && Number.isFinite(state.preCommandUpdatedAt)
+            ? { preCommandUpdatedAt: state.preCommandUpdatedAt }
+            : {})
+    };
+}
+export function deserializePreCommandState(data, state) {
+    if (typeof data.preCommandSource === 'string' && data.preCommandSource.trim()) {
+        state.preCommandSource = data.preCommandSource.trim();
+    }
+    if (typeof data.preCommandScriptPath === 'string' && data.preCommandScriptPath.trim()) {
+        state.preCommandScriptPath = data.preCommandScriptPath.trim();
+    }
+    if (typeof data.preCommandUpdatedAt === 'number' && Number.isFinite(data.preCommandUpdatedAt)) {
+        state.preCommandUpdatedAt = data.preCommandUpdatedAt;
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { RoutingInstruction, RoutingInstructionState } from './routing-instructions.js';
+export declare function applyStopMessageInstructionToState(instruction: RoutingInstruction, state: RoutingInstructionState): boolean;

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

@@ -0,0 +1,96 @@
+import { normalizeStopMessageStageMode } from './routing-stop-message-state-codec.js';
+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;
+            state.stopMessageText = text;
+            state.stopMessageMaxRepeats = maxRepeats;
+            state.stopMessageSource = 'explicit';
+            if (targetMode) {
+                state.stopMessageStageMode = targetMode;
+            }
+            if (shouldRearm) {
+                resetStopMessageRuntimeState(state, Date.now());
+            }
+            return true;
+        }
+        case 'stopMessageMode': {
+            const mode = normalizeStopMessageStageMode(instruction.stopMessageStageMode);
+            if (!mode) {
+                return true;
+            }
+            const maxRepeats = typeof instruction.stopMessageMaxRepeats === 'number' && Number.isFinite(instruction.stopMessageMaxRepeats)
+                ? Math.floor(instruction.stopMessageMaxRepeats)
+                : 0;
+            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)
+                : 0;
+            state.stopMessageStageMode = mode;
+            state.stopMessageSource = 'explicit';
+            if (maxRepeats > 0) {
+                state.stopMessageMaxRepeats = maxRepeats;
+            }
+            const shouldRearm = previousMode !== mode ||
+                (maxRepeats > 0 && previousMax !== maxRepeats) ||
+                typeof state.stopMessageUsed !== 'number' ||
+                !Number.isFinite(state.stopMessageUsed);
+            if (shouldRearm) {
+                resetStopMessageRuntimeState(state, Date.now());
+            }
+            return true;
+        }
+        case 'stopMessageClear':
+            clearStopMessageState(state);
+            return true;
+        default:
+            return false;
+    }
+}
+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;
+}
+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;
+}

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

@@ -0,0 +1,3 @@
+import type { RoutingInstruction } from './routing-instructions.js';
+export declare const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
+export declare function parseStopMessageInstruction(instruction: string): RoutingInstruction | null;

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

@@ -0,0 +1,142 @@
+import { resolveStopMessageText } from './stop-message-file-resolver.js';
+export const DEFAULT_STOP_MESSAGE_MAX_REPEATS = 10;
+export function parseStopMessageInstruction(instruction) {
+    if (!/^stopMessage\s*:/i.test(instruction)) {
+        return null;
+    }
+    const body = instruction.slice('stopMessage'.length + 1).trim();
+    if (!body) {
+        return null;
+    }
+    if (/^clear$/i.test(body)) {
+        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 } : {})
+    };
+}
+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

@@ -0,0 +1,4 @@
+import type { RoutingInstructionState } from './routing-instructions.js';
+export declare function serializeStopMessageState(state: RoutingInstructionState): Record<string, unknown>;
+export declare function deserializeStopMessageState(data: Record<string, unknown>, state: RoutingInstructionState): void;
+export declare function normalizeStopMessageStageMode(value: unknown): 'on' | 'off' | 'auto' | undefined;

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

@@ -0,0 +1,85 @@
+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() }
+            : {})
+    };
+}
+export function deserializeStopMessageState(data, state) {
+    if (typeof data.stopMessageSource === 'string' && data.stopMessageSource.trim()) {
+        state.stopMessageSource = data.stopMessageSource.trim();
+    }
+    if (typeof data.stopMessageText === 'string' && data.stopMessageText.trim()) {
+        state.stopMessageText = data.stopMessageText;
+    }
+    if (typeof data.stopMessageMaxRepeats === 'number' && Number.isFinite(data.stopMessageMaxRepeats)) {
+        state.stopMessageMaxRepeats = Math.floor(data.stopMessageMaxRepeats);
+    }
+    if (typeof data.stopMessageUsed === 'number' && Number.isFinite(data.stopMessageUsed)) {
+        state.stopMessageUsed = Math.max(0, Math.floor(data.stopMessageUsed));
+    }
+    if (typeof data.stopMessageUpdatedAt === 'number' && Number.isFinite(data.stopMessageUpdatedAt)) {
+        state.stopMessageUpdatedAt = data.stopMessageUpdatedAt;
+    }
+    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;
+        }
+    }
+    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();
+    }
+}
+export function normalizeStopMessageStageMode(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'on' || normalized === 'off' || normalized === 'auto') {
+        return normalized;
+    }
+    return undefined;
+}

package/dist/router/virtual-router/sticky-session-store.js

@@ -8,17 +8,62 @@ function isPersistentKey(key) {
         return false;
     return key.startsWith('session:') || key.startsWith('conversation:');
 }
+function resolveRoutecodexUserDir() {
+    try {
+        const override = String(process.env.ROUTECODEX_USER_DIR || '').trim();
+        if (override) {
+            return path.resolve(override);
+        }
+        const home = os.homedir();
+        if (!home) {
+            return null;
+        }
+        return path.join(home, '.routecodex');
+    }
+    catch {
+        return null;
+    }
+}
+function resolveDefaultSessionDir() {
+    try {
+        const userDir = resolveRoutecodexUserDir();
+        if (!userDir) {
+            return null;
+        }
+        return path.join(userDir, 'sessions');
+    }
+    catch {
+        return null;
+    }
+}
 function resolveSessionDir() {
     try {
         const override = process.env.ROUTECODEX_SESSION_DIR;
         if (override && override.trim()) {
-            return override.trim();
+            return path.resolve(override.trim());
         }
-        const home = os.homedir();
-        if (!home) {
+        return resolveDefaultSessionDir();
+    }
+    catch {
+        return null;
+    }
+}
+function resolveSessionFallbackDir(primaryDir) {
+    try {
+        const defaultDir = resolveDefaultSessionDir();
+        if (!defaultDir) {
+            return null;
+        }
+        const normalizedPrimary = path.resolve(primaryDir);
+        const normalizedDefault = path.resolve(defaultDir);
+        if (normalizedPrimary === normalizedDefault) {
             return null;
         }
-        return path.join(home, '.routecodex', 'sessions');
+        if (normalizedPrimary.startsWith(`${normalizedDefault}${path.sep}`) ||
+            normalizedPrimary === normalizedDefault) {
+            return normalizedDefault;
+        }
+        return null;
     }
     catch {
         return null;
@@ -37,16 +82,102 @@ function keyToFilename(key) {
     const safeId = rawId.replace(/[^a-zA-Z0-9_.-]/g, '_');
     return `${scope}-${safeId}.json`;
 }
-export function loadRoutingInstructionStateSync(key) {
+function resolveSessionFilepaths(key) {
     if (!isPersistentKey(key)) {
-        return null;
+        return [];
+    }
+    const dir = resolveSessionDir();
+    const filename = keyToFilename(key);
+    if (!dir || !filename) {
+        return [];
+    }
+    const filepaths = [path.join(dir, filename)];
+    const fallbackDir = resolveSessionFallbackDir(dir);
+    if (fallbackDir) {
+        const fallbackPath = path.join(fallbackDir, filename);
+        if (!filepaths.includes(fallbackPath)) {
+            filepaths.push(fallbackPath);
+        }
+    }
+    return filepaths;
+}
+function resolveSessionLoadFilepaths(key) {
+    if (!isPersistentKey(key)) {
+        return [];
+    }
+    const filepaths = resolveSessionFilepaths(key);
+    if (filepaths.length === 0) {
+        return [];
     }
     const dir = resolveSessionDir();
     const filename = keyToFilename(key);
     if (!dir || !filename) {
+        return filepaths;
+    }
+    const legacyFallbacks = resolveLegacyServerScopedFilepaths(dir, filename);
+    for (const candidate of legacyFallbacks) {
+        if (!filepaths.includes(candidate)) {
+            filepaths.push(candidate);
+        }
+    }
+    return filepaths;
+}
+function resolveLegacyServerScopedFilepaths(primaryDir, filename) {
+    try {
+        const normalizedPrimary = path.resolve(primaryDir);
+        const searchRoot = resolveSessionSearchRoot(normalizedPrimary);
+        if (!searchRoot) {
+            return [];
+        }
+        const currentDirName = path.dirname(normalizedPrimary) === searchRoot ? path.basename(normalizedPrimary) : '';
+        const entries = fs.readdirSync(searchRoot, { withFileTypes: true });
+        const candidates = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            if (currentDirName && entry.name === currentDirName) {
+                continue;
+            }
+            const candidatePath = path.join(searchRoot, entry.name, filename);
+            try {
+                const stat = fs.statSync(candidatePath);
+                if (!stat.isFile()) {
+                    continue;
+                }
+                candidates.push({
+                    filepath: candidatePath,
+                    mtimeMs: Number.isFinite(stat.mtimeMs) ? stat.mtimeMs : 0
+                });
+            }
+            catch {
+                // ignore missing legacy files
+            }
+        }
+        candidates.sort((left, right) => right.mtimeMs - left.mtimeMs);
+        return candidates.map((entry) => entry.filepath);
+    }
+    catch {
+        return [];
+    }
+}
+function resolveSessionSearchRoot(sessionDir) {
+    try {
+        const normalized = path.resolve(sessionDir);
+        if (path.basename(normalized) === 'sessions') {
+            return normalized;
+        }
+        const parent = path.dirname(normalized);
+        if (path.basename(parent) === 'sessions') {
+            return parent;
+        }
+        return null;
+    }
+    catch {
         return null;
     }
-    const filepath = path.join(dir, filename);
+}
+function readPersistedStateFromFile(filepath) {
     try {
         if (!fs.existsSync(filepath)) {
             return null;
@@ -87,81 +218,99 @@ export function loadRoutingInstructionStateSync(key) {
         return null;
     }
 }
-export function saveRoutingInstructionStateAsync(key, state) {
-    if (!isPersistentKey(key)) {
-        return;
+export function loadRoutingInstructionStateSync(key) {
+    const filepaths = resolveSessionLoadFilepaths(key);
+    if (filepaths.length === 0) {
+        return null;
     }
-    const dir = resolveSessionDir();
-    const filename = keyToFilename(key);
-    if (!dir || !filename) {
+    const writeTargets = resolveSessionFilepaths(key);
+    for (const filepath of filepaths) {
+        const loaded = readPersistedStateFromFile(filepath);
+        if (!loaded) {
+            continue;
+        }
+        if (writeTargets.length > 0 && !writeTargets.includes(filepath)) {
+            saveRoutingInstructionStateSync(key, loaded);
+        }
+        return loaded;
+    }
+    return null;
+}
+export function saveRoutingInstructionStateAsync(key, state) {
+    const filepaths = resolveSessionFilepaths(key);
+    if (filepaths.length === 0) {
         return;
     }
-    const filepath = path.join(dir, filename);
     // 空状态意味着清除持久化文件
     if (!state) {
+        for (const filepath of filepaths) {
+            scheduleWrite(filepath, async () => {
+                try {
+                    await fs.promises.unlink(filepath);
+                }
+                catch {
+                    // ignore unlink errors (e.g. ENOENT)
+                }
+            });
+        }
+        return;
+    }
+    const payload = {
+        version: 1,
+        state: serializeRoutingInstructionState(state)
+    };
+    for (const filepath of filepaths) {
+        const dir = path.dirname(filepath);
         scheduleWrite(filepath, async () => {
             try {
-                await fs.promises.unlink(filepath);
+                await fs.promises.mkdir(dir, { recursive: true });
+            }
+            catch {
+                // ignore mkdir errors; write below will fail silently
+            }
+            try {
+                await atomicWriteFile(filepath, JSON.stringify(payload));
             }
             catch {
-                // ignore unlink errors (e.g. ENOENT)
+                // ignore async write failures
             }
         });
+    }
+}
+export function saveRoutingInstructionStateSync(key, state) {
+    const filepaths = resolveSessionFilepaths(key);
+    if (filepaths.length === 0) {
+        return;
+    }
+    if (!state) {
+        for (const filepath of filepaths) {
+            try {
+                fs.unlinkSync(filepath);
+            }
+            catch {
+                // ignore unlink failures
+            }
+        }
         return;
     }
     const payload = {
         version: 1,
         state: serializeRoutingInstructionState(state)
     };
-    scheduleWrite(filepath, async () => {
-        try {
-            await fs.promises.mkdir(dir, { recursive: true });
-        }
-        catch {
-            // ignore mkdir errors; write below will fail silently
-        }
+    for (const filepath of filepaths) {
+        const dir = path.dirname(filepath);
         try {
-            await atomicWriteFile(filepath, JSON.stringify(payload));
+            fs.mkdirSync(dir, { recursive: true });
         }
         catch {
-            // ignore async write failures
+            // ignore mkdir errors
         }
-    });
-}
-export function saveRoutingInstructionStateSync(key, state) {
-    if (!isPersistentKey(key)) {
-        return;
-    }
-    const dir = resolveSessionDir();
-    const filename = keyToFilename(key);
-    if (!dir || !filename) {
-        return;
-    }
-    const filepath = path.join(dir, filename);
-    if (!state) {
         try {
-            fs.unlinkSync(filepath);
+            atomicWriteFileSync(filepath, JSON.stringify(payload));
         }
         catch {
-            // ignore unlink failures
+            // ignore sync write failures
         }
-        return;
-    }
-    const payload = {
-        version: 1,
-        state: serializeRoutingInstructionState(state)
-    };
-    try {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    catch {
-        // ignore mkdir errors
-    }
-    try {
-        atomicWriteFileSync(filepath, JSON.stringify(payload));
-    }
-    catch {
-        // ignore sync write failures
     }
 }
 function scheduleWrite(filepath, task) {