@oh-my-pi/pi-catalog 15.10.11

package/src/compat/anthropic.ts

@@ -0,0 +1,67 @@
+/**
+ * Anthropic-messages compat builder — the anthropic-side analogue of
+ * `./openai`. Runs exactly once per model (from `buildModel`); detect-time
+ * defaults come from provider ids, strict host checks, and model-id
+ * classification, with explicit spec overrides assigned on top.
+ */
+import { modelMatchesHost } from "../hosts";
+import {
+	hasOpus47ApiRestrictions,
+	isAnthropicFableOrMythosModel,
+	supportsMidConversationSystemMessages,
+} from "../identity/family";
+import type { ModelSpec, ResolvedAnthropicCompat } from "../types";
+import { applyCompatOverrides } from "./apply";
+
+const OFFICIAL_ANTHROPIC_URL = "https://api.anthropic.com";
+
+/**
+ * Official first-party Anthropic API. A missing baseUrl is official on purpose:
+ * request dispatch falls back to `https://api.anthropic.com`. This is the one
+ * auth-sensitive host check — OAuth credentials are attached based on it — so
+ * it requires the exact origin or a path boundary (`/`) after it; a bare
+ * prefix check would accept lookalikes like `https://api.anthropic.com.evil.com`.
+ */
+export function isOfficialAnthropicApiUrl(baseUrl?: string): boolean {
+	if (!baseUrl) return true;
+	const lower = baseUrl.toLowerCase();
+	return lower === OFFICIAL_ANTHROPIC_URL || lower.startsWith(`${OFFICIAL_ANTHROPIC_URL}/`);
+}
+
+/** Build the resolved anthropic-messages compat record for a model spec. */
+export function buildAnthropicCompat(spec: ModelSpec<"anthropic-messages">): ResolvedAnthropicCompat {
+	const baseUrl = spec.baseUrl;
+	const official = isOfficialAnthropicApiUrl(baseUrl);
+	// Z.AI's Anthropic-compatible proxy lives at `api.z.ai/api/anthropic`.
+	const isZai = modelMatchesHost(spec, "zai");
+	const compat: ResolvedAnthropicCompat = {
+		officialEndpoint: official,
+		disableStrictTools: false,
+		disableAdaptiveThinking: false,
+		supportsEagerToolInputStreaming: true,
+		// Long cache retention is only sent to the official API by default;
+		// proxies opt in explicitly via `compat.supportsLongCacheRetention: true`.
+		supportsLongCacheRetention: official,
+		// First-party Claude API only. Bedrock/Vertex/Foundry and other
+		// Anthropic-compatible gateways reject mid-conversation system roles, so
+		// detection requires the canonical api.anthropic.com host plus a
+		// supported model id.
+		supportsMidConversationSystem: official && supportsMidConversationSystemMessages(spec.id),
+		supportsForcedToolChoice: !isAnthropicFableOrMythosModel(spec.id),
+		// Opus 4.7+ and Fable/Mythos reject temperature/top_p/top_k with a 400.
+		supportsSamplingParams: !hasOpus47ApiRestrictions(spec.id),
+		// Z.AI workaround (issue #814): its proxy deserializes tool_result blocks
+		// into a class that reads `.id`.
+		requiresToolResultId: isZai,
+		// Official Anthropic enforces signature-based thinking-chain integrity, so
+		// unsigned thinking blocks must stay text there. Anthropic-compatible
+		// reasoning endpoints commonly emit unsigned thinking blocks while still
+		// expecting them back as `type: "thinking"` on continuation; demoting them
+		// loses the reasoning chain and can destabilize the next tool-call
+		// arguments (#2005). Known non-signing hosts (Z.AI, DeepSeek) are also
+		// preserved for compatibility.
+		replayUnsignedThinking: isZai || modelMatchesHost(spec, "deepseekFamily") || (spec.reasoning && !official),
+	};
+	applyCompatOverrides(compat, spec.compat);
+	return compat;
+}

package/src/compat/apply.ts

@@ -0,0 +1,15 @@
+/**
+ * Assign defined override values onto a freshly-built resolved compat record,
+ * in place. Keys the record doesn't declare are ignored (loosely-typed config
+ * may carry junk). `buildModel` is the only intended caller — the record being
+ * mutated is the single per-model allocation; nothing here runs per request.
+ */
+export function applyCompatOverrides(compat: object, overrides: object | undefined): void {
+	if (!overrides) return;
+	for (const key in overrides) {
+		const value = (overrides as Record<string, unknown>)[key];
+		if (value !== undefined && key in compat) {
+			(compat as Record<string, unknown>)[key] = value;
+		}
+	}
+}

package/src/compat/openai.ts

@@ -0,0 +1,365 @@
+/**
+ * OpenAI-API compat builders — chat-completions and Responses flavors.
+ *
+ * `buildOpenAICompat`/`buildOpenAIResponsesCompat` run exactly once per model
+ * (from `buildModel`): detection writes a fresh record, sparse spec overrides
+ * are assigned onto it in place, and conditional policies are materialized as
+ * complete alternate views. Request handlers read `model.compat` fields and
+ * never detect, resolve, or allocate.
+ */
+import { hostMatchesUrl, modelMatchesHost } from "../hosts";
+import { bareModelId, isFableOrMythos, parseAnthropicModel, semverGte } from "../identity/classify";
+import {
+	isAnthropicNamespacedModelId,
+	isClaudeModelId,
+	isDeepseekModelIdOrName,
+	isKimiK26ModelId,
+	isKimiModelId,
+	isMimoModelIdOrName,
+	isQwenModelId,
+} from "../identity/family";
+import { ANTHROPIC_ADAPTIVE_EFFORT_MAP_4_TIER, ANTHROPIC_ADAPTIVE_EFFORT_MAP_5_TIER } from "../model-thinking";
+import type { ModelSpec, OpenAICompat, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat } from "../types";
+import { applyCompatOverrides } from "./apply";
+
+type OpenAIReasoningEffort = "minimal" | "low" | "medium" | "high" | "xhigh";
+
+/** GLM coding-plan SKUs idle for minutes mid-reasoning; see `streamIdleTimeoutMs`. */
+const GLM_CODING_PLAN_MODEL_PATTERN = /^glm-5(?:[.-]|$)/i;
+const GLM_CODING_PLAN_STREAM_IDLE_TIMEOUT_MS = 600_000;
+/** Direct DeepSeek reasoning models stall between thinking and answer phases. */
+const DEEPSEEK_REASONING_STREAM_IDLE_TIMEOUT_MS = 300_000;
+
+/**
+ * OpenCode's gateways (https://opencode.ai/zen|go) gate `reasoning_content`
+ * on the request's thinking state for every model they front (Kimi K2.x,
+ * DeepSeek V4, GLM-5.x, Qwen3.x, MiMo, MiniMax, …): they 400 with `Extra
+ * inputs are not permitted` when thinking is off but the field is supplied
+ * (#1071), and 400 with `thinking is enabled but reasoning_content is missing
+ * in assistant tool call message at index N` (#1484) when thinking is on and
+ * the field is absent. The base compat therefore leaves the replay off, and
+ * this `whenThinking` policy reactivates it for thinking-engaged requests.
+ * `allowsSyntheticReasoningContentForToolCalls` is forced to `false` on the
+ * same path: the gateway specifically requires `reasoning_content`, and the
+ * synthetic-friendly default would echo whichever field the upstream streamed
+ * (e.g. `reasoning` for many opencode turns), landing the replay in the wrong
+ * key and re-triggering the 400.
+ */
+const OPENCODE_WHEN_THINKING: NonNullable<OpenAICompat["whenThinking"]> = {
+	requiresReasoningContentForToolCalls: true,
+	allowsSyntheticReasoningContentForToolCalls: false,
+	reasoningContentField: "reasoning_content",
+};
+
+function detectStrictModeSupport(provider: string, baseUrl: string): boolean {
+	if (
+		provider === "openai" ||
+		provider === "openrouter" ||
+		provider === "cerebras" ||
+		provider === "together" ||
+		provider === "github-copilot" ||
+		provider === "zenmux"
+	) {
+		return true;
+	}
+	return (
+		hostMatchesUrl(baseUrl, "openai") ||
+		hostMatchesUrl(baseUrl, "azureOpenAI") ||
+		hostMatchesUrl(baseUrl, "cerebras") ||
+		hostMatchesUrl(baseUrl, "together") ||
+		hostMatchesUrl(baseUrl, "openrouter") ||
+		hostMatchesUrl(baseUrl, "deepseekFamily")
+	);
+}
+
+function getOpenRouterAnthropicReasoningEffortMap(
+	modelId: string,
+): Partial<Record<OpenAIReasoningEffort, string>> | undefined {
+	const parsed = parseAnthropicModel(bareModelId(modelId));
+	if (!parsed) return undefined;
+	// Adaptive efforts on OpenRouter's completions front: Fable/Mythos and
+	// Opus 4.6+ only — Sonnet stays on the plain effort vocabulary there.
+	const isOpusAdaptive = parsed.kind === "opus" && semverGte(parsed.version, "4.6");
+	if (!isFableOrMythos(parsed.kind) && !isOpusAdaptive) return undefined;
+
+	const hasRealXHigh = isFableOrMythos(parsed.kind) || semverGte(parsed.version, "4.7");
+	return (hasRealXHigh ? ANTHROPIC_ADAPTIVE_EFFORT_MAP_5_TIER : ANTHROPIC_ADAPTIVE_EFFORT_MAP_4_TIER) as Partial<
+		Record<OpenAIReasoningEffort, string>
+	>;
+}
+
+/**
+ * Build the resolved chat-completions compat record for a model spec.
+ * Provider takes precedence over URL-based detection since it's explicitly configured.
+ */
+export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): ResolvedOpenAICompat {
+	const provider = spec.provider;
+	const baseUrl = spec.baseUrl;
+	const hostModel = { provider, baseUrl };
+
+	const isCerebras = modelMatchesHost(hostModel, "cerebras");
+	const isZai = modelMatchesHost(hostModel, "zai");
+	const isZhipu = modelMatchesHost(hostModel, "zhipu");
+	const isKilo = modelMatchesHost(hostModel, "kilo");
+	const isKimiModel = isKimiModelId(spec.id);
+	const isMoonshotKimi = isKimiModel && modelMatchesHost(hostModel, "moonshotNative");
+	const usesMoonshotKimiPreservedThinking = isMoonshotKimi && isKimiK26ModelId(spec.id);
+	const isAnthropicModel =
+		modelMatchesHost(hostModel, "anthropic") || isClaudeModelId(spec.id) || isAnthropicNamespacedModelId(spec.id);
+	const isAlibaba = modelMatchesHost(hostModel, "alibabaDashscope");
+	const isQwen = isQwenModelId(spec.id);
+	// DeepSeek V4 (and other reasoning-capable DeepSeek models) reject follow-up requests in
+	// thinking mode unless prior assistant tool-call turns include `reasoning_content`. The
+	// upstream model is reachable through many OpenAI-compat hosts (api.deepseek.com, Deepinfra,
+	// Kilo, NVIDIA NIM, Zenmux, OpenRouter, …), so we match by model id/name as well as by
+	// provider/baseUrl. The flag is gated by `spec.reasoning` because the invariant only
+	// applies when thinking mode is actually engaged.
+	const lowerId = spec.id.toLowerCase();
+	const lowerName = (spec.name ?? "").toLowerCase();
+	const isXiaomiHost = modelMatchesHost(hostModel, "xiaomi");
+	const isXiaomiMimo = isXiaomiHost && (isMimoModelIdOrName(spec.id) || isMimoModelIdOrName(spec.name ?? ""));
+	// OpenCode Zen's `big-pickle` is a DeepSeek reasoning alias; the upstream
+	// 400s come from DeepSeek and require exact reasoning_content replay.
+	const isOpenCodeDeepseekAlias =
+		provider === "opencode-zen" && (lowerId === "big-pickle" || lowerName === "big pickle");
+	const isDeepseekFamily =
+		modelMatchesHost(hostModel, "deepseekFamily") ||
+		isDeepseekModelIdOrName(spec.id) ||
+		isDeepseekModelIdOrName(spec.name ?? "") ||
+		isOpenCodeDeepseekAlias;
+	const isDirectDeepseekApi = modelMatchesHost(hostModel, "deepseekDirect");
+	const isDirectDeepseekReasoning = isDirectDeepseekApi && isDeepseekFamily && Boolean(spec.reasoning);
+	const isGrok = modelMatchesHost(hostModel, "xai");
+	const isMistral = modelMatchesHost(hostModel, "mistral");
+	const isOpenCodeHost = modelMatchesHost(hostModel, "opencode");
+	const isNonStandard =
+		isCerebras ||
+		isGrok ||
+		isMistral ||
+		hostMatchesUrl(baseUrl, "chutes") ||
+		hostMatchesUrl(baseUrl, "deepseekFamily") ||
+		hostMatchesUrl(baseUrl, "fireworks") ||
+		isAlibaba ||
+		isZai ||
+		isZhipu ||
+		isKilo ||
+		isQwen ||
+		isXiaomiHost ||
+		isOpenCodeHost;
+	const isOpenCodeProvider = provider === "opencode-go" || provider === "opencode-zen";
+
+	const useMaxTokens =
+		isMistral || hostMatchesUrl(baseUrl, "chutes") || hostMatchesUrl(baseUrl, "fireworks") || isDirectDeepseekApi;
+
+	// Hosts whose chat-completions endpoints are known to accept multiple
+	// leading `system`/`developer` messages (preferred for KV-cache reuse).
+	// Anything outside this allowlist defaults to coalescing because
+	// strict chat templates (Qwen 3.5+ via vLLM, MiniMax, etc.) reject
+	// follow-up system messages with a 400.
+	const isOpenAIHost = modelMatchesHost(hostModel, "openai");
+	const isAzureHost = modelMatchesHost(hostModel, "azureOpenAI");
+	const isOpenRouter = modelMatchesHost(hostModel, "openrouter");
+	const isVercelGateway = modelMatchesHost(hostModel, "vercelAIGateway");
+	const isTogether = modelMatchesHost(hostModel, "together");
+	const isFireworks = hostMatchesUrl(baseUrl, "fireworks");
+	const isGroqHost = modelMatchesHost(hostModel, "groq");
+	const isCopilotHost = provider === "github-copilot";
+	const isZenmuxHost = provider === "zenmux";
+	// Endpoints that MUST receive a single system block. MiniMax's OpenAI
+	// endpoint returns error 2013 on multiple system messages; Alibaba's
+	// Dashscope and Qwen Portal serve Qwen models whose chat template
+	// raises "System message must be at the beginning" if any system
+	// message appears past index 0.
+	const isMiniMaxHost = modelMatchesHost(hostModel, "minimax");
+	const isQwenPortal = modelMatchesHost(hostModel, "qwenPortal");
+	const supportsMultipleSystemMessagesDefault =
+		!isMiniMaxHost &&
+		!isAlibaba &&
+		!isQwenPortal &&
+		(isOpenAIHost ||
+			isAzureHost ||
+			isOpenRouter ||
+			isCerebras ||
+			isTogether ||
+			isFireworks ||
+			isGroqHost ||
+			isDeepseekFamily ||
+			isMistral ||
+			isGrok ||
+			isZai ||
+			isZhipu ||
+			isCopilotHost ||
+			isZenmuxHost);
+
+	const openRouterAnthropicReasoningEffortMap = isOpenRouter
+		? getOpenRouterAnthropicReasoningEffortMap(lowerId)
+		: undefined;
+	const detectedReasoningEffortMap: NonNullable<OpenAICompat["reasoningEffortMap"]> =
+		provider === "groq" && spec.id === "qwen/qwen3-32b"
+			? ({
+					minimal: "default",
+					low: "default",
+					medium: "default",
+					high: "default",
+					xhigh: "default",
+				} satisfies Partial<Record<OpenAIReasoningEffort, string>>)
+			: isDeepseekFamily && spec.reasoning
+				? ({
+						minimal: "high",
+						low: "high",
+						medium: "high",
+						high: "high",
+						xhigh: "max",
+					} satisfies Partial<Record<OpenAIReasoningEffort, string>>)
+				: openRouterAnthropicReasoningEffortMap
+					? openRouterAnthropicReasoningEffortMap
+					: isFireworks
+						? ({
+								// Fireworks' OpenAI-compatible endpoint rejects OpenAI's
+								// `minimal` literal but accepts `none` for the lowest setting.
+								minimal: "none",
+							} satisfies Partial<Record<OpenAIReasoningEffort, string>>)
+						: {};
+
+	// Stream-watchdog floor: GLM coding-plan SKUs and direct DeepSeek reasoning
+	// models idle for minutes mid-reasoning; widen the idle timeout so warm-ups
+	// stop aborting and retrying.
+	const streamIdleTimeoutMs =
+		GLM_CODING_PLAN_MODEL_PATTERN.test(spec.id) && (isZai || isZhipu)
+			? GLM_CODING_PLAN_STREAM_IDLE_TIMEOUT_MS
+			: spec.reasoning && isDirectDeepseekApi
+				? DEEPSEEK_REASONING_STREAM_IDLE_TIMEOUT_MS
+				: undefined;
+
+	const compat: ResolvedOpenAICompat = {
+		supportsStore: !isNonStandard,
+		// `developer` is an OpenAI-Responses-era extension to the chat-completions schema. Almost
+		// every OpenAI-compatible host other than OpenAI itself (and Azure OpenAI, which mirrors
+		// the schema exactly) treats it as an unknown role: Moonshot returns a 400 "tokenization
+		// failed", Groq/Cerebras/etc. error or silently misroute. Default to `system` and require
+		// callers to opt in via `compat.supportsDeveloperRole: true` for hosts known to mirror
+		// OpenAI's reasoning-API surface.
+		supportsDeveloperRole: isOpenAIHost || isAzureHost,
+		supportsMultipleSystemMessages: supportsMultipleSystemMessagesDefault,
+		supportsReasoningEffort: !isGrok && !isZai && !isZhipu && !isXiaomiMimo,
+		// GitHub Copilot's chat-completions endpoint rejects reasoning params wholesale.
+		supportsReasoningParams: provider !== "github-copilot",
+		reasoningEffortMap: detectedReasoningEffortMap,
+		supportsUsageInStreaming: !isCerebras,
+		// Kimi (including via OpenRouter and Fireworks router-form IDs such as
+		// `accounts/fireworks/routers/kimi-*`) calculates TPM rate limits based on
+		// max_tokens, not actual output. The official Kimi K2 model guidance
+		// (https://docs.fireworks.ai/models/kimi-k2) also requires `max_tokens` for
+		// every call since the family can otherwise emit very long reasoning traces
+		// before the final answer.
+		alwaysSendMaxTokens: isKimiModel,
+		disableReasoningOnForcedToolChoice: isKimiModel || isAnthropicModel,
+		disableReasoningOnToolChoice: isDeepseekFamily && Boolean(spec.reasoning) && !isOpenRouter,
+		supportsToolChoice: !isDirectDeepseekReasoning,
+		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
+		requiresToolResultName: isMistral,
+		requiresAssistantAfterToolResult: false,
+		requiresThinkingAsText: isMistral,
+		requiresMistralToolIds: isMistral,
+		// Only Kimi's native hosts (Moonshot / Kimi-code, matched by `isMoonshotKimi`)
+		// speak the z.ai binary `thinking: { type }` field. Kimi reached through
+		// OpenAI-compatible proxies — Fireworks' Fire Pass router, OpenCode's gateway,
+		// etc. — drives reasoning via OpenAI-style `reasoning_effort`
+		// (low|medium|high|xhigh|max|none), so those stay on the "openai" path.
+		thinkingFormat:
+			isZai || isZhipu || isMoonshotKimi || isXiaomiMimo
+				? "zai"
+				: isOpenRouter
+					? "openrouter"
+					: isAlibaba || isQwen
+						? "qwen"
+						: "openai",
+		thinkingKeep: usesMoonshotKimiPreservedThinking ? "all" : undefined,
+		reasoningContentField: "reasoning_content",
+		// Backends that 400 follow-up requests when prior assistant tool-call turns lack `reasoning_content`:
+		//   - Kimi: documented invariant on its native API.
+		//   - DeepSeek-family reasoning models, including aliased OpenCode Zen models
+		//     like `big-pickle`, validate exact thinking-mode replay.
+		//   - Xiaomi MiMo models require exact `reasoning_content` replay on
+		//     thinking-mode tool-call continuations across standard and Token Plan hosts.
+		//   - Any reasoning-capable model reached through OpenRouter can enforce this
+		//     server-side whenever the request is in thinking mode. We can't translate
+		//     Anthropic's redacted/encrypted reasoning into provider-native plaintext,
+		//     so cross-provider continuations rely on a placeholder.
+		// OpenCode Kimi aliases handle reasoning content internally and reject
+		// client-sent `reasoning_content`, so exclude only that Kimi-on-OpenCode path
+		// (the `whenThinking` policy below re-enables the replay for thinking turns).
+		requiresReasoningContentForToolCalls:
+			(isKimiModel && !isOpenCodeProvider) ||
+			(isDeepseekFamily && Boolean(spec.reasoning)) ||
+			isXiaomiMimo ||
+			(isOpenRouter && Boolean(spec.reasoning)),
+		// DeepSeek V4 and Xiaomi MiMo reject synthetic reasoning_content placeholders (".") on tool-call turns.
+		// Kimi and OpenRouter accept them when actual reasoning is unavailable.
+		allowsSyntheticReasoningContentForToolCalls: (!isDeepseekFamily || !spec.reasoning) && !isXiaomiMimo,
+		requiresAssistantContentForToolCalls: isKimiModel || isDirectDeepseekReasoning,
+		cacheControlFormat: isOpenRouter && spec.id.startsWith("anthropic/") ? "anthropic" : undefined,
+		openRouterRouting: undefined,
+		vercelGatewayRouting: undefined,
+		isOpenRouterHost: isOpenRouter,
+		isVercelGatewayHost: isVercelGateway,
+		supportsStrictMode: detectStrictModeSupport(provider, baseUrl),
+		extraBody: isDirectDeepseekReasoning ? { thinking: { type: "enabled" } } : undefined,
+		toolStrictMode: isCerebras ? "all_strict" : "mixed",
+		streamIdleTimeoutMs,
+	};
+
+	applyCompatOverrides(compat, spec.compat);
+	if (spec.compat?.reasoningEffortMap) {
+		// Effort maps merge per level instead of replacing wholesale.
+		compat.reasoningEffortMap = { ...detectedReasoningEffortMap, ...spec.compat.reasoningEffortMap };
+	}
+
+	const whenThinkingPolicy =
+		spec.compat?.whenThinking ?? (isOpenCodeProvider && spec.reasoning ? OPENCODE_WHEN_THINKING : undefined);
+	if (whenThinkingPolicy) {
+		const variant: ResolvedOpenAICompat = { ...compat };
+		applyCompatOverrides(variant, whenThinkingPolicy);
+		compat.whenThinking = variant;
+	}
+
+	return compat;
+}
+
+interface OpenAIResponsesSpecLike {
+	provider: string;
+	baseUrl: string;
+	compat?: OpenAICompat;
+}
+
+/**
+ * Build the resolved Responses-API compat record. The Responses flavor
+ * deliberately differs from chat-completions: GitHub Copilot's responses
+ * endpoint accepts the `developer` role, while strict tool mode is scoped to
+ * first-party OpenAI/Azure/Copilot providers. Developer-role and prompt-cache
+ * detection are URL-only on purpose — the historical call sites never
+ * consulted the provider id for them.
+ */
+export function buildOpenAIResponsesCompat(spec: OpenAIResponsesSpecLike): ResolvedOpenAIResponsesCompat {
+	const baseUrl = spec.baseUrl ?? "";
+	const compat: ResolvedOpenAIResponsesCompat = {
+		supportsDeveloperRole:
+			hostMatchesUrl(baseUrl, "openai") ||
+			hostMatchesUrl(baseUrl, "azureOpenAI") ||
+			hostMatchesUrl(baseUrl, "githubCopilot"),
+		supportsStrictMode:
+			spec.provider === "openai" ||
+			spec.provider === "azure" ||
+			spec.provider === "github-copilot" ||
+			hostMatchesUrl(baseUrl, "openai") ||
+			hostMatchesUrl(baseUrl, "azureOpenAI"),
+		supportsReasoningEffort: true,
+		supportsLongPromptCacheRetention: hostMatchesUrl(baseUrl, "openai"),
+		// Azure OpenAI and GitHub Copilot Responses paths require tool results
+		// to strictly match prior tool calls when building Responses inputs.
+		strictResponsesPairing: hostMatchesUrl(baseUrl, "azureOpenAI") || spec.provider === "github-copilot",
+		reasoningEffortMap: {},
+	};
+	applyCompatOverrides(compat, spec.compat);
+	return compat;
+}