@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/router/virtual-router/features.js

@@ -1,5 +1,5 @@
 import { analyzeMediaAttachments, detectExtendedThinkingKeyword, detectKeyword, extractMessageText, getLatestMessageRole, } from './message-utils.js';
-import { extractAntigravityGeminiSessionId } from '../../conversion/compat/antigravity-session-signature.js';
+import { extractAntigravityGeminiSessionIdWithNative } from './engine-selection/native-router-hotpath.js';
 import { detectCodingTool, detectLastAssistantToolCategory, detectVisionTool, detectWebSearchToolDeclared, detectWebTool, extractMeaningfulDeclaredToolNames } from './tool-signals.js';
 import { computeRequestTokens } from './token-estimator.js';
 const THINKING_KEYWORDS = ['let me think', 'chain of thought', 'cot', 'reason step', 'deliberate'];
@@ -12,7 +12,7 @@ export function buildRoutingFeatures(request, metadata) {
                 const text = msg ? extractMessageText(msg) : '';
                 return { role, parts: [{ text }] };
             });
-            return extractAntigravityGeminiSessionId({ contents });
+            return extractAntigravityGeminiSessionIdWithNative({ contents });
         }
         catch {
             return undefined;

package/dist/router/virtual-router/load-balancer.d.ts

@@ -6,6 +6,13 @@ export interface LoadBalancingOptions {
     weights?: Record<string, number>;
     availabilityCheck: (providerKey: string) => boolean;
 }
+export interface GroupedLoadBalancingOptions {
+    routeName: string;
+    groups: Map<string, string[]>;
+    stickyKey?: string;
+    weights?: Record<string, number>;
+    availabilityCheck: (providerKey: string) => boolean;
+}
 export declare class RouteLoadBalancer {
     private policy;
     private readonly states;
@@ -13,6 +20,7 @@ export declare class RouteLoadBalancer {
     updatePolicy(policy?: LoadBalancingPolicy): void;
     getPolicy(): LoadBalancingPolicy;
     select(options: LoadBalancingOptions, strategyOverride?: LoadBalancingPolicy['strategy']): string | null;
+    selectGrouped(options: GroupedLoadBalancingOptions, strategyOverride?: LoadBalancingPolicy['strategy']): string | null;
     private selectRoundRobin;
     private selectWeighted;
     private selectSticky;

package/dist/router/virtual-router/load-balancer.js

@@ -25,7 +25,7 @@ export class RouteLoadBalancer {
                 return this.selectWeighted(options.routeName, available, options.weights ?? this.policy.weights);
             default:
                 if (options.weights) {
-                    const distinct = new Set(available.map((candidate) => Math.max(1, options.weights?.[candidate] ?? 1)));
+                    const distinct = new Set(available.map((candidate) => normalizeWeight(options.weights?.[candidate])));
                     if (distinct.size > 1) {
                         return this.selectWeighted(options.routeName, available, options.weights);
                     }
@@ -33,6 +33,38 @@ export class RouteLoadBalancer {
                 return this.selectRoundRobin(options.routeName, available);
         }
     }
+    selectGrouped(options, strategyOverride) {
+        const groupIds = Array.from(options.groups.keys()).filter((groupId) => {
+            const members = options.groups.get(groupId) ?? [];
+            return members.some((candidate) => options.availabilityCheck(candidate));
+        });
+        if (groupIds.length === 0) {
+            return null;
+        }
+        const normalizedWeights = normalizeGroupWeights(groupIds, options.weights);
+        const strategy = strategyOverride ?? this.policy.strategy;
+        const groupRoute = `${options.routeName}:group`;
+        let selectedGroup = null;
+        switch (strategy) {
+            case 'sticky':
+                selectedGroup = this.selectSticky(groupRoute, groupIds, options.stickyKey, normalizedWeights);
+                break;
+            case 'weighted':
+                selectedGroup = this.selectWeighted(groupRoute, groupIds, normalizedWeights);
+                break;
+            default:
+                selectedGroup = this.selectRoundRobin(groupRoute, groupIds);
+                break;
+        }
+        if (!selectedGroup) {
+            return null;
+        }
+        const groupCandidates = (options.groups.get(selectedGroup) ?? []).filter((candidate) => options.availabilityCheck(candidate));
+        if (groupCandidates.length === 0) {
+            return null;
+        }
+        return this.selectRoundRobin(`${groupRoute}:${selectedGroup}`, groupCandidates);
+    }
     selectRoundRobin(routeName, candidates) {
         const state = this.getState(routeName);
         const choice = candidates[state.pointer % candidates.length];
@@ -55,8 +87,11 @@ export class RouteLoadBalancer {
                 current.set(key, 0);
             }
         }
-        const candidateWeights = candidates.map((candidate) => Math.max(1, weights?.[candidate] ?? 1));
+        const candidateWeights = candidates.map((candidate) => normalizeWeight(weights?.[candidate]));
         const totalWeight = candidateWeights.reduce((sum, w) => sum + w, 0);
+        if (!Number.isFinite(totalWeight) || totalWeight <= 0) {
+            return this.selectRoundRobin(routeName, candidates);
+        }
         let bestIndex = 0;
         let bestScore = Number.NEGATIVE_INFINITY;
         for (let i = 0; i < candidates.length; i += 1) {
@@ -95,3 +130,31 @@ export class RouteLoadBalancer {
         return this.states.get(routeName);
     }
 }
+function normalizeWeight(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+        return value;
+    }
+    return 1;
+}
+function normalizeGroupWeights(groupIds, weights) {
+    if (!weights || groupIds.length === 0) {
+        return undefined;
+    }
+    const normalized = {};
+    let total = 0;
+    for (const id of groupIds) {
+        const raw = weights[id];
+        const value = typeof raw === 'number' && Number.isFinite(raw) && raw > 0 ? raw : 0;
+        if (value > 0) {
+            normalized[id] = value;
+            total += value;
+        }
+    }
+    if (!Number.isFinite(total) || total <= 0) {
+        return undefined;
+    }
+    for (const id of Object.keys(normalized)) {
+        normalized[id] = normalized[id] / total;
+    }
+    return normalized;
+}

package/dist/router/virtual-router/provider-registry.js

@@ -84,6 +84,7 @@ export class ProviderRegistry {
             processMode: profile.processMode || 'chat',
             responsesConfig: profile.responsesConfig,
             streaming: profile.streaming,
+            maxOutputTokens: profile.maxOutputTokens,
             maxContextTokens: profile.maxContextTokens,
             ...(profile.deepseek ? { deepseek: profile.deepseek } : {})
         };
@@ -103,6 +104,7 @@ export class ProviderRegistry {
             processMode: profile.processMode || 'chat',
             responsesConfig: profile.responsesConfig,
             streaming: profile.streaming,
+            maxOutputTokens: profile.maxOutputTokens,
             maxContextTokens: profile.maxContextTokens,
             ...(profile.deepseek ? { deepseek: profile.deepseek } : {}),
             ...(profile.serverToolsDisabled ? { serverToolsDisabled: true } : {})

package/dist/router/virtual-router/routing-instructions/clean.d.ts

@@ -0,0 +1,3 @@
+import type { StandardizedMessage } from '../../../conversion/hub/types/standardized.js';
+export declare function stripCodeSegments(text: string): string;
+export declare function cleanMessagesFromRoutingInstructions(messages: StandardizedMessage[]): StandardizedMessage[];

package/dist/router/virtual-router/routing-instructions/clean.js

@@ -0,0 +1,34 @@
+import { ROUTING_INSTRUCTION_MARKER_GLOBAL_PATTERN } from './types.js';
+export function stripCodeSegments(text) {
+    if (!text) {
+        return '';
+    }
+    // Remove fenced code blocks ```...``` or ~~~...~~~
+    let sanitized = text.replace(/```[\s\S]*?```/g, ' ');
+    sanitized = sanitized.replace(/~~~[\s\S]*?~~~/g, ' ');
+    // Remove inline code `...`
+    sanitized = sanitized.replace(/`[^`]*`/g, ' ');
+    return sanitized;
+}
+export function cleanMessagesFromRoutingInstructions(messages) {
+    return messages
+        .map((message) => {
+        if (message.role !== 'user' || typeof message.content !== 'string') {
+            return message;
+        }
+        const cleanedContent = message.content.replace(ROUTING_INSTRUCTION_MARKER_GLOBAL_PATTERN, '').trim();
+        return {
+            ...message,
+            content: cleanedContent
+        };
+    })
+        .filter((message) => {
+        if (message.role !== 'user') {
+            return true;
+        }
+        if (typeof message.content !== 'string') {
+            return true;
+        }
+        return message.content.trim().length > 0;
+    });
+}

package/dist/router/virtual-router/routing-instructions/parse.d.ts

@@ -0,0 +1,18 @@
+import type { StandardizedMessage } from '../../../conversion/hub/types/standardized.js';
+import type { RoutingInstruction } from './types.js';
+export declare function parseRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
+/**
+ * 解析并预处理路由指令，优先处理 clear 指令，确保新指令能够覆盖旧状态。
+ * 返回清理后的指令列表，移除冗余的 stopMessageSet 指令。
+ */
+export declare function parseAndPreprocessRoutingInstructions(messages: StandardizedMessage[]): RoutingInstruction[];
+/**
+ * 提取 clear 指令（如果存在）。用于在路由选择前优先执行清理操作。
+ * @returns 是否存在 clear 指令
+ */
+export declare function extractClearInstruction(messages: StandardizedMessage[]): boolean;
+/**
+ * 提取 stopMessageClear 指令（如果存在）。
+ * @returns 是否存在 stopMessageClear 指令
+ */
+export declare function extractStopMessageClearInstruction(messages: StandardizedMessage[]): boolean;

package/dist/router/virtual-router/routing-instructions/parse.js

@@ -0,0 +1,377 @@
+import { extractMessageText } from '../message-utils.js';
+import { parseStopMessageInstruction } from '../routing-stop-message-parser.js';
+import { parsePreCommandInstruction } from '../routing-pre-command-parser.js';
+import { stripCodeSegments } from './clean.js';
+import { ROUTING_INSTRUCTION_MARKER_PATTERN } from './types.js';
+export function parseRoutingInstructions(messages) {
+    const instructions = [];
+    // 只解析“当前最新一条消息”中的 marker，避免历史 user marker 在后续轮次被重复回放。
+    const latestMessage = messages.length > 0 ? messages[messages.length - 1] : undefined;
+    if (!latestMessage || latestMessage.role !== 'user') {
+        return instructions;
+    }
+    const content = extractMessageText(latestMessage);
+    if (!content) {
+        return instructions;
+    }
+    const sanitized = stripCodeSegments(content);
+    if (!sanitized || !ROUTING_INSTRUCTION_MARKER_PATTERN.test(sanitized)) {
+        return instructions;
+    }
+    const regex = /<\*\*([\s\S]*?)\*\*>/g;
+    let match;
+    while ((match = regex.exec(sanitized)) !== null) {
+        const instruction = match[1].trim();
+        if (!instruction) {
+            continue;
+        }
+        const segments = expandInstructionSegments(instruction);
+        for (const segment of segments) {
+            const parsed = parseSingleInstruction(segment);
+            if (parsed) {
+                instructions.push(parsed);
+            }
+        }
+    }
+    return normalizeStopMessageInstructionPrecedence(instructions);
+}
+/**
+ * 解析并预处理路由指令，优先处理 clear 指令，确保新指令能够覆盖旧状态。
+ * 返回清理后的指令列表，移除冗余的 stopMessageSet 指令。
+ */
+export function parseAndPreprocessRoutingInstructions(messages) {
+    const rawInstructions = parseRoutingInstructions(messages);
+    if (rawInstructions.length === 0) {
+        return [];
+    }
+    // 检查是否有 clear 指令
+    const hasClear = rawInstructions.some((inst) => inst.type === 'clear');
+    if (!hasClear) {
+        return rawInstructions;
+    }
+    // 如果有 clear 指令，clear 之后的指令才有效，clear 之前的指令被清除
+    const clearIndex = rawInstructions.findIndex((inst) => inst.type === 'clear');
+    const effectiveInstructions = rawInstructions.slice(clearIndex + 1);
+    // 移除 clear 后冗余的 stopMessageSet 指令（如果与原指令相同）
+    // 这里的逻辑会在 applyRoutingInstructions 中处理，
+    // 所以我们只需要返回 clear 之后的指令即可
+    return effectiveInstructions;
+}
+/**
+ * 提取 clear 指令（如果存在）。用于在路由选择前优先执行清理操作。
+ * @returns 是否存在 clear 指令
+ */
+export function extractClearInstruction(messages) {
+    const instructions = parseRoutingInstructions(messages);
+    return instructions.some((inst) => inst.type === 'clear');
+}
+/**
+ * 提取 stopMessageClear 指令（如果存在）。
+ * @returns 是否存在 stopMessageClear 指令
+ */
+export function extractStopMessageClearInstruction(messages) {
+    const instructions = parseRoutingInstructions(messages);
+    return instructions.some((inst) => inst.type === 'stopMessageClear');
+}
+function expandInstructionSegments(instruction) {
+    const trimmed = instruction.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const normalizedLeading = normalizeInstructionLeading(trimmed);
+    // stopMessage 指令需要整体解析，不能按逗号拆分，否则类似
+    // "<**stopMessage:\"继续\",3**>" 会被错误拆成 ["stopMessage:\"继续\"", "3"]。
+    if (/^(?:"|')?stopMessage(?:"|')?\s*[:,]/i.test(normalizedLeading)) {
+        return [normalizeStopMessageCommandPrefix(normalizedLeading)];
+    }
+    if (/^precommand(?:\s*:|$)/i.test(normalizedLeading)) {
+        return [normalizedLeading];
+    }
+    const prefix = trimmed[0];
+    if (prefix === '!' || prefix === '#' || prefix === '@') {
+        const tokens = splitInstructionTargets(trimmed.substring(1));
+        return tokens
+            .map((token) => token.replace(/^[!#@]+/, '').trim())
+            .filter((token) => token.length > 0)
+            .map((token) => `${prefix}${token}`);
+    }
+    const splitTokens = splitInstructionTargets(trimmed);
+    const recoveredStopMessage = recoverSplitStopMessageInstruction(splitTokens);
+    if (recoveredStopMessage) {
+        return [recoveredStopMessage];
+    }
+    return splitTokens;
+}
+function splitInstructionTargets(content) {
+    return content
+        .split(',')
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0);
+}
+function normalizeInstructionLeading(content) {
+    // Remove common zero-width prefixes that may be injected by client/editor copies.
+    return content.replace(/^[\u200B-\u200D\u2060\uFEFF]+/, '').trimStart();
+}
+function normalizeStopMessageCommandPrefix(content) {
+    const normalized = normalizeInstructionLeading(content);
+    return normalized.replace(/^(?:"|')?stopMessage(?:"|')?\s*([:,])/i, 'stopMessage$1');
+}
+function normalizeSplitStopMessageHeadToken(token) {
+    return normalizeInstructionLeading(token)
+        .replace(/^["']+|["']+$/g, '')
+        .trim();
+}
+function recoverSplitStopMessageInstruction(tokens) {
+    if (!Array.isArray(tokens) || tokens.length < 2) {
+        return null;
+    }
+    const head = normalizeSplitStopMessageHeadToken(tokens[0]);
+    if (!/^stopmessage$/i.test(head)) {
+        return null;
+    }
+    const tail = tokens.slice(1).join(',').trim();
+    if (!tail) {
+        return null;
+    }
+    return `stopMessage:${tail}`;
+}
+function splitTargetAndProcessMode(rawTarget) {
+    const trimmed = typeof rawTarget === 'string' ? rawTarget.trim() : '';
+    if (!trimmed) {
+        return { target: '' };
+    }
+    const separatorIndex = trimmed.lastIndexOf(':');
+    if (separatorIndex <= 0 || separatorIndex === trimmed.length - 1) {
+        return { target: trimmed };
+    }
+    const target = trimmed.slice(0, separatorIndex).trim();
+    const modeToken = trimmed.slice(separatorIndex + 1).trim().toLowerCase();
+    if (!target) {
+        return { target: trimmed };
+    }
+    if (modeToken === 'passthrough') {
+        return { target, processMode: 'passthrough' };
+    }
+    if (modeToken === 'chat') {
+        return { target, processMode: 'chat' };
+    }
+    return { target };
+}
+function parseNamedTargetInstruction(instruction, prefix) {
+    const re = new RegExp('^' + prefix + '\\s*:', 'i');
+    if (!re.test(instruction)) {
+        return null;
+    }
+    const body = instruction.slice(instruction.indexOf(':') + 1).trim();
+    if (!body) {
+        return null;
+    }
+    const { target, processMode } = splitTargetAndProcessMode(body);
+    if (!target) {
+        return null;
+    }
+    const parsed = parseTarget(target);
+    if (!parsed) {
+        return null;
+    }
+    const normalized = normalizeStickyOrForceTarget(parsed);
+    return { type: prefix, ...normalized, ...(processMode ? { processMode } : {}) };
+}
+function parseSingleInstruction(instruction) {
+    if (/^clear$/i.test(instruction)) {
+        return { type: 'clear' };
+    }
+    const preCommandInstruction = parsePreCommandInstruction(instruction);
+    if (preCommandInstruction) {
+        return preCommandInstruction;
+    }
+    const stopMessageInstruction = parseStopMessageInstruction(instruction);
+    if (stopMessageInstruction) {
+        return stopMessageInstruction;
+    }
+    const stickyInstruction = parseNamedTargetInstruction(instruction, 'sticky');
+    if (stickyInstruction) {
+        return stickyInstruction;
+    }
+    const forceInstruction = parseNamedTargetInstruction(instruction, 'force');
+    if (forceInstruction) {
+        return forceInstruction;
+    }
+    const preferInstruction = parseNamedTargetInstruction(instruction, 'prefer');
+    if (preferInstruction) {
+        return preferInstruction;
+    }
+    if (instruction.startsWith('!')) {
+        const rawTarget = instruction.substring(1).trim();
+        const { target, processMode } = splitTargetAndProcessMode(rawTarget);
+        if (!target) {
+            return null;
+        }
+        const parsed = parseTarget(target);
+        if (!parsed) {
+            return null;
+        }
+        // 约定：
+        // - "!providerA,providerB"：允许列表（whitelist），用于快速限制可用 provider 集合；
+        // - "!provider.model" / "!provider[alias].model" / "!provider.2"：prefer 语义；
+        //   model 可用时只命中该 model（忽略路由），不可用则自动清除并回退到正常路由命中。
+        //
+        // 这样可以在不破坏既有 "!glm,openai" 语义的前提下，引入基于模型的优先命中行为。
+        if (!target.includes('.')) {
+            if (parsed.provider) {
+                return { type: 'allow', provider: parsed.provider, pathLength: parsed.pathLength };
+            }
+            return null;
+        }
+        const normalized = normalizeStickyOrForceTarget(parsed);
+        return { type: 'prefer', ...normalized, ...(processMode ? { processMode } : {}) };
+    }
+    if (instruction.startsWith('#')) {
+        const target = instruction.substring(1).trim();
+        const parsed = parseTarget(target);
+        if (parsed) {
+            return { type: 'disable', ...parsed };
+        }
+    }
+    else if (instruction.startsWith('@')) {
+        const target = instruction.substring(1).trim();
+        const parsed = parseTarget(target);
+        if (parsed) {
+            return { type: 'enable', ...parsed };
+        }
+    }
+    else if (isValidProviderModel(instruction)) {
+        const parsed = parseTarget(instruction);
+        if (parsed) {
+            const normalized = normalizeStickyOrForceTarget(parsed);
+            return { type: 'force', ...normalized };
+        }
+    }
+    else if (isValidIdentifier(instruction)) {
+        // 仅 provider 标识（无 .）时，视为 provider 级白名单，等价于 "<**!provider**>"。
+        // 这样可以用 "<**antigravity**>" 快速激活当前 routing 中所有 antigravity 相关池子，
+        // 并保证路由仅命中该 provider 的所有模型/key。
+        return {
+            type: 'allow',
+            provider: instruction,
+            pathLength: 1
+        };
+    }
+    return null;
+}
+function normalizeStopMessageInstructionPrecedence(instructions) {
+    if (!Array.isArray(instructions) || instructions.length <= 1) {
+        return instructions;
+    }
+    const isStopDirective = (inst) => inst.type === 'stopMessageSet' || inst.type === 'stopMessageMode' || inst.type === 'stopMessageClear';
+    const hasGlobalClear = instructions.some((inst) => inst.type === 'clear');
+    const hasStopClear = instructions.some((inst) => inst.type === 'stopMessageClear');
+    if (hasGlobalClear) {
+        const lastGlobalClearIndex = instructions.map((inst) => inst.type).lastIndexOf('clear');
+        return lastGlobalClearIndex >= 0 ? [instructions[lastGlobalClearIndex]] : instructions;
+    }
+    if (hasStopClear) {
+        const lastStopClearIndex = instructions.map((inst) => inst.type).lastIndexOf('stopMessageClear');
+        return lastStopClearIndex >= 0 ? [instructions[lastStopClearIndex]] : instructions;
+    }
+    let lastStopIndex = -1;
+    for (let idx = instructions.length - 1; idx >= 0; idx -= 1) {
+        if (isStopDirective(instructions[idx])) {
+            lastStopIndex = idx;
+            break;
+        }
+    }
+    if (lastStopIndex < 0) {
+        return instructions;
+    }
+    return instructions.filter((inst, idx) => !isStopDirective(inst) || idx === lastStopIndex);
+}
+function parseTarget(target) {
+    if (!target) {
+        return null;
+    }
+    // Accept "provider[alias].model" (as printed in virtual-router-hit logs) to avoid users
+    // needing to translate bracket notation back to dot notation manually.
+    // With the alias disambiguated, allow dots in model ids (e.g. gpt-5.2) without ambiguity.
+    const bracketMatch = target.match(/^([a-zA-Z0-9_-]+)\[([a-zA-Z0-9_-]*)\](?:\.(.+))?$/);
+    if (bracketMatch) {
+        const provider = bracketMatch[1];
+        const keyAliasRaw = bracketMatch[2];
+        const keyAlias = typeof keyAliasRaw === 'string' ? keyAliasRaw.trim() : '';
+        const model = typeof bracketMatch[3] === 'string' ? bracketMatch[3].trim() : '';
+        if (!provider || !isValidIdentifier(provider)) {
+            return null;
+        }
+        // Allow omitting the alias: "provider[].model" means "provider.model across all aliases".
+        // This also enables disambiguating model ids that contain dots, without requiring the user
+        // to specify the alias.
+        if (!keyAlias) {
+            if (!model) {
+                return { provider, pathLength: 1 };
+            }
+            if (!/^[a-zA-Z0-9_.-]+$/.test(model)) {
+                return null;
+            }
+            return { provider, model, pathLength: 2 };
+        }
+        if (!isValidIdentifier(keyAlias)) {
+            return null;
+        }
+        if (!model) {
+            // Treat as explicit alias selection. Use pathLength=3 so engine resolves keyAlias directly.
+            return { provider, keyAlias, pathLength: 3 };
+        }
+        // Model ids may contain dots (e.g. gpt-5.2); allow them here because alias is already explicit.
+        if (!/^[a-zA-Z0-9_.-]+$/.test(model)) {
+            return null;
+        }
+        return { provider, keyAlias, model, pathLength: 3 };
+    }
+    // Dot syntax: align with config parsing used by routing entries.
+    // - "provider.modelId" -> modelId may contain dots; it always means model across all aliases.
+    // - Key/alias selection must use bracket syntax: "provider[alias]" or "provider[alias].modelId".
+    const firstDot = target.indexOf('.');
+    if (firstDot < 0) {
+        const provider = target.trim();
+        if (!provider || !isValidIdentifier(provider)) {
+            return null;
+        }
+        return { provider, pathLength: 1 };
+    }
+    const provider = target.slice(0, firstDot).trim();
+    const remainder = target.slice(firstDot + 1).trim();
+    if (!provider || !isValidIdentifier(provider) || !remainder) {
+        return null;
+    }
+    // Support "provider.2" key-index notation (only when remainder is a plain integer).
+    if (/^\d+$/.test(remainder)) {
+        const keyIndex = Number.parseInt(remainder, 10);
+        if (Number.isFinite(keyIndex) && keyIndex > 0) {
+            return { provider, keyIndex, pathLength: 2 };
+        }
+    }
+    // Treat everything after the first dot as the model id, allowing dots.
+    if (!/^[a-zA-Z0-9_.-]+$/.test(remainder)) {
+        return null;
+    }
+    return { provider, model: remainder, pathLength: 2 };
+}
+function normalizeStickyOrForceTarget(target) {
+    if (target &&
+        target.pathLength === 2 &&
+        typeof target.model === 'string' &&
+        typeof target.keyAlias === 'string' &&
+        target.model === target.keyAlias) {
+        const clone = { ...target };
+        delete clone.keyAlias;
+        return clone;
+    }
+    return target;
+}
+function isValidIdentifier(id) {
+    return /^[a-zA-Z0-9_-]+$/.test(id);
+}
+function isValidProviderModel(providerModel) {
+    const pattern = /^[a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)+$/;
+    return pattern.test(providerModel);
+}

package/dist/router/virtual-router/routing-instructions/state.d.ts

@@ -0,0 +1,4 @@
+import type { RoutingInstruction, RoutingInstructionState } from './types.js';
+export declare function applyRoutingInstructions(instructions: RoutingInstruction[], currentState: RoutingInstructionState): RoutingInstructionState;
+export declare function serializeRoutingInstructionState(state: RoutingInstructionState): Record<string, unknown>;
+export declare function deserializeRoutingInstructionState(data: Record<string, unknown>): RoutingInstructionState;