@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/collapse-_nkb2dn7.mjs

@@ -0,0 +1,1945 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import "./src-BhinCSpi.mjs";
+import { c as compareRevision, d as parseRevisionConstraint, h as isRecord, p as revisionSatisfies, u as parseRevision } from "./cascade-BWjRTD1q.mjs";
+import { L as THINKING_EFFORTS, h as MODEL_KINDS, s as resolveModelPolicy, t as bareModelId } from "./id-EJwVLDHE.mjs";
+import { t as cleanModelName } from "./utils-DrDwmNtu.mjs";
+import { a as dueEffectiveRate, d as collapseVocabulary, l as classifyModel, n as NO_RECURRING_TARIFF, o as materializeTimeBasedCost, p as stripThinkingVariantSuffix, r as applyDueDatedCostCard, s as parseDatedCostCards, t as EARLIEST_EFFECTIVE_FROM, u as collapseVariantId } from "./pricing-DusBEhwm.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/model-tokenizer.ts
+const MAX_TOKENIZER_CACHE_ENTRIES = 2048;
+const modelTokenizerCache = /* @__PURE__ */ new Map();
+function revisionAtLeast$1(revision, floor) {
+	if (revision === void 0) return false;
+	const parsedRevision = parseRevision(revision);
+	const parsedFloor = parseRevision(floor);
+	return parsedRevision !== void 0 && parsedFloor !== void 0 && compareRevision(parsedRevision, parsedFloor) >= 0;
+}
+function claudeTokenizer(identity) {
+	if (identity.class !== "anthropic") return void 0;
+	if (identity.family === "opus") {
+		if (revisionAtLeast$1(identity.revision, "5")) return "claude-v5";
+		if (revisionAtLeast$1(identity.revision, "4.7")) return "claude-v47";
+		return "claude-v3";
+	}
+	if (identity.family === "sonnet" || identity.family === "fable" || identity.family === "mythos") return revisionAtLeast$1(identity.revision, "5") ? "claude-v5-sonnet" : "claude-v3";
+	if (identity.family === "haiku" && revisionAtLeast$1(identity.revision, "5.5")) return "claude-v5-sonnet";
+	return "claude-v3";
+}
+function qwenTokenizer(identity) {
+	return identity.class === "qwen" && revisionAtLeast$1(identity.revision, "3.5") ? "qwen3" : void 0;
+}
+function deepSeekTokenizer(identity) {
+	return identity.class === "deepseek" ? "deepseek-v3" : void 0;
+}
+function kimiTokenizer(identity) {
+	return identity.class === "kimi" ? "kimi-k2" : void 0;
+}
+function glmTokenizer(identity) {
+	return identity.class === "glm" && revisionAtLeast$1(identity.revision, "5") ? "glm5" : void 0;
+}
+function openAITokenizer(identity) {
+	return identity.class === "openai" && revisionAtLeast$1(identity.revision, "5") ? "o200k" : void 0;
+}
+/**
+* Resolve the exact locally embedded tokenizer for a canonical model id.
+*
+* This is catalog policy, not a runtime caller heuristic: [`buildModel`](./build.ts)
+* materializes the result as `Model.tokenizer`; consumers read that property.
+*/
+function resolveModelTokenizer(modelId, provider = "") {
+	const cacheKey = `${provider}\0${modelId}`;
+	const cached = modelTokenizerCache.get(cacheKey);
+	if (cached !== void 0) return cached ?? void 0;
+	const identity = classifyModel(provider, bareModelId(modelId), { lenient: true });
+	const tokenizer = claudeTokenizer(identity) ?? qwenTokenizer(identity) ?? deepSeekTokenizer(identity) ?? kimiTokenizer(identity) ?? glmTokenizer(identity) ?? openAITokenizer(identity);
+	if (modelTokenizerCache.size === MAX_TOKENIZER_CACHE_ENTRIES) modelTokenizerCache.clear();
+	modelTokenizerCache.set(cacheKey, tokenizer ?? null);
+	return tokenizer;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/build.ts
+/**
+* The single Model constructor. Resolution runs through the compat engine
+* (`compat/resolve`): identity classification, cascade-rule axes, host
+* detection, and spec overrides materialize exactly once per spec.
+*
+* Request handlers read fields — they never detect, parse ids, or allocate
+* compat per request.
+*/
+function numberField(source, key) {
+	const value = Reflect.get(source, key);
+	return typeof value === "number" ? value : void 0;
+}
+/** Narrow an unknown compiled-axis payload to an object payload. */
+function objectPayload(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+/** Narrow a compiled `input-modalities` axis value to the model input union. */
+function isInputModalities(value) {
+	return Array.isArray(value) && value.every((entry) => entry === "text" || entry === "image");
+}
+/**
+* Applies resolved catalog-data axes onto the model: reviewed metadata
+* corrections (`cost-patch`, `limits-patch`, `long-context-cost`,
+* `context-window-floor`) overwrite upstream values; selection metadata
+* (`priority`, `apply-patch-tool-type`, `service-tier-cost`,
+* `requires-cursor-tool-schema-projection`, `requires-tool-result-image-hoisting`,
+* `supports-assistant-prefill`) is rule-owned; `context-promotion-target` fills
+* only when the spec left it unset.
+*/
+function applyCatalogAssignments(model, catalog) {
+	const kind = MODEL_KINDS.find((value) => value === catalog.kind);
+	if (kind !== void 0) model.kind = kind;
+	if (catalog.contextWindowAuthoritative === true) model.contextWindowAuthoritative = true;
+	else delete model.contextWindowAuthoritative;
+	if (catalog.longContextWindowUncapped === true) model.longContextWindowUncapped = true;
+	else delete model.longContextWindowUncapped;
+	const webSearch = catalog.webSearch;
+	if (webSearch === "gemini" || webSearch === "anthropic" || webSearch === "codex" || webSearch === "xai" || webSearch === "openrouter" || webSearch === "openai") model.webSearch = webSearch;
+	if (typeof catalog.webSearchModel === "string") model.webSearchModel = catalog.webSearchModel;
+	if (catalog.hostedImage === true) model.hostedImage = true;
+	else if (catalog.hostedImage === false) delete model.hostedImage;
+	if (typeof catalog.imageModel === "string") model.imageModel = catalog.imageModel;
+	else if (catalog.imageModel === false) delete model.imageModel;
+	const serviceTierCost = objectPayload(catalog.serviceTierCost);
+	if (serviceTierCost !== void 0) {
+		const flex = numberField(serviceTierCost, "flex");
+		const priorityTier = numberField(serviceTierCost, "priority");
+		const ultrafast = numberField(serviceTierCost, "ultrafast");
+		model.serviceTierCost = {
+			...flex !== void 0 && { flex },
+			...priorityTier !== void 0 && { priority: priorityTier },
+			...ultrafast !== void 0 && { ultrafast }
+		};
+	}
+	const priority = catalog.priority;
+	if (typeof priority === "number") model.priority = priority;
+	const promptCache = objectPayload(catalog.promptCache);
+	if (promptCache !== void 0) {
+		const short = numberField(promptCache, "short");
+		const long = numberField(promptCache, "long");
+		model.promptCache = {
+			...short !== void 0 && { short },
+			...long !== void 0 && { long }
+		};
+	}
+	const applyPatchToolType = catalog.applyPatchToolType;
+	if (applyPatchToolType === "freeform" || applyPatchToolType === "function") model.applyPatchToolType = applyPatchToolType;
+	const editPromptVariant = catalog.editPromptVariant;
+	if (editPromptVariant === "full" || editPromptVariant === "compact") model.editPromptVariant = editPromptVariant;
+	const pricingStatus = catalog.pricingStatus;
+	if (pricingStatus === "free" || pricingStatus === "included" || pricingStatus === "variable" || pricingStatus === "unknown") model.pricingStatus = pricingStatus;
+	if (catalog.requiresCursorToolSchemaProjection === true) model.requiresCursorToolSchemaProjection = true;
+	else delete model.requiresCursorToolSchemaProjection;
+	if (catalog.toolSchemasInContext === false) model.toolSchemasInContext = false;
+	else delete model.toolSchemasInContext;
+	if (catalog.requiresToolResultImageHoisting === true) model.requiresToolResultImageHoisting = true;
+	else delete model.requiresToolResultImageHoisting;
+	if (catalog.supportsAssistantPrefill === true) model.supportsAssistantPrefill = true;
+	else delete model.supportsAssistantPrefill;
+	if (typeof catalog.omitMaxOutputTokens === "boolean" && model.omitMaxOutputTokens === void 0) model.omitMaxOutputTokens = catalog.omitMaxOutputTokens;
+	const contextPromotionTarget = catalog.contextPromotionTarget;
+	if (typeof contextPromotionTarget === "string" && model.contextPromotionTarget === void 0) model.contextPromotionTarget = contextPromotionTarget;
+}
+/**
+* The row's corrected price card at `now`: `cost-patch`, then `cost-fallback`
+* (each with its dated card due at `now`), then the long-context tier and
+* cache-rate derivations, all from the upstream card.
+*/
+function correctedCost(upstream, catalog, cards, now) {
+	let cost = { ...upstream };
+	const upstreamCard = upstream.timeBased?.effectiveRates?.[0]?.effectiveFrom === -864e13 ? dueEffectiveRate(upstream.timeBased, now) : void 0;
+	if (upstreamCard !== void 0) {
+		const { effectiveFrom: _effectiveFrom, ...card } = upstreamCard;
+		const { longContext: _longContext, ...base } = cost;
+		cost = {
+			...base,
+			...card
+		};
+	}
+	const patch = objectPayload(catalog.costPatch);
+	if (patch !== void 0) {
+		const input = numberField(patch, "input");
+		if (input !== void 0) cost.input = input;
+		const output = numberField(patch, "output");
+		if (output !== void 0) cost.output = output;
+		const cacheRead = numberField(patch, "cacheRead");
+		if (cacheRead !== void 0) cost.cacheRead = cacheRead;
+		const cacheWrite = numberField(patch, "cacheWrite");
+		if (cacheWrite !== void 0) cost.cacheWrite = cacheWrite;
+		applyDueDatedCostCard(cost, cards.patch, now);
+	}
+	const fallback = objectPayload(catalog.costFallback);
+	if (fallback !== void 0) {
+		if (!(cost.input !== 0 || cost.output !== 0 || cost.cacheRead !== 0 || cost.cacheWrite !== 0)) {
+			const input = numberField(fallback, "input");
+			if (input !== void 0) cost.input = input;
+			const output = numberField(fallback, "output");
+			if (output !== void 0) cost.output = output;
+			const cacheRead = numberField(fallback, "cacheRead");
+			if (cacheRead !== void 0) cost.cacheRead = cacheRead;
+			const cacheWrite = numberField(fallback, "cacheWrite");
+			if (cacheWrite !== void 0) cost.cacheWrite = cacheWrite;
+			applyDueDatedCostCard(cost, cards.fallback, now);
+		}
+	}
+	const longContext = objectPayload(catalog.longContext);
+	if (longContext !== void 0) {
+		const inputThreshold = numberField(longContext, "inputThreshold");
+		const inclusive = Reflect.get(longContext, "inputThresholdInclusive") === true;
+		const multiplier = numberField(longContext, "multiplier");
+		const input = numberField(longContext, "input");
+		const output = numberField(longContext, "output");
+		const cacheRead = numberField(longContext, "cacheRead");
+		const cacheWrite = numberField(longContext, "cacheWrite");
+		const hasTokenPrice = cost.input !== 0 || cost.output !== 0 || cost.cacheRead !== 0 || cost.cacheWrite !== 0;
+		if (inputThreshold !== void 0 && multiplier !== void 0 && hasTokenPrice) cost = {
+			...cost,
+			longContext: {
+				inputThreshold,
+				...inclusive && { inputThresholdInclusive: true },
+				input: cost.input * multiplier,
+				output: cost.output * (numberField(longContext, "outputMultiplier") ?? multiplier),
+				cacheRead: cost.cacheRead * multiplier,
+				cacheWrite: cost.cacheWrite * multiplier
+			}
+		};
+		else if (inputThreshold !== void 0 && input !== void 0 && output !== void 0 && cacheRead !== void 0 && cacheWrite !== void 0) cost = {
+			...cost,
+			longContext: {
+				inputThreshold,
+				input,
+				output,
+				cacheRead,
+				cacheWrite
+			}
+		};
+	}
+	if (catalog.cacheReadAtInputRate === true) {
+		const { longContext } = cost;
+		cost = {
+			...cost,
+			cacheRead: cost.input,
+			...longContext && { longContext: {
+				...longContext,
+				cacheRead: longContext.input
+			} }
+		};
+	}
+	const cacheWriteRate = catalog.cacheWriteRate;
+	if (typeof cacheWriteRate === "number") {
+		const { longContext } = cost;
+		cost = {
+			...cost,
+			cacheWrite: cost.input * cacheWriteRate,
+			...longContext && { longContext: {
+				...longContext,
+				cacheWrite: longContext.input * cacheWriteRate
+			} }
+		};
+	}
+	return cost;
+}
+/**
+* Every price period the dated `cost-patch`/`cost-fallback` cards define, for
+* request-time selection (`calculateUsageCost`): a row built before a change
+* still bills requests after it at the new price, and a leading card keeps
+* earlier requests at the old one on rows built after it. Undefined when no
+* card changes the price (no cards, or a fallback the upstream price outranks).
+*/
+function scheduledRates(upstream, catalog, cards) {
+	const dates = [...cards.patch, ...cards.fallback].map((card) => card.effectiveFrom).sort((a, b) => a - b);
+	if (dates.length === 0) return void 0;
+	const periods = [];
+	let previousPrice;
+	for (const effectiveFrom of [EARLIEST_EFFECTIVE_FROM, ...dates]) {
+		const { input, output, cacheRead, cacheWrite, longContext } = correctedCost(upstream, catalog, cards, effectiveFrom);
+		const price = {
+			input,
+			output,
+			cacheRead,
+			cacheWrite,
+			...longContext && { longContext }
+		};
+		const key = JSON.stringify(price);
+		if (key === previousPrice) continue;
+		previousPrice = key;
+		periods.push({
+			effectiveFrom,
+			...price
+		});
+	}
+	return periods.length > 1 ? periods : void 0;
+}
+/**
+* Applies reviewed catalog-data value corrections (`cost-patch`,
+* `cache-read-at-input-rate`, `cache-write-rate`, `limits-patch`,
+* `long-context-cost`, `context-window-floor`, `input-modalities`) onto an
+* upstream-sourced spec. Applied by
+* `buildModel` to every upstream-sourced spec; user-authored overrides are
+* recomposed after building by the override applicators, so explicit user
+* limits and pricing still win.
+*/
+function applyCatalogCorrections(model, catalog) {
+	const upstream = model.cost;
+	const cards = {
+		patch: parseDatedCostCards(catalog.costPatch, "cost-patch"),
+		fallback: parseDatedCostCards(catalog.costFallback, "cost-fallback")
+	};
+	model.cost = correctedCost(upstream, catalog, cards, Date.now());
+	const recurring = catalog.timeBased === void 0 ? void 0 : materializeTimeBasedCost(catalog.timeBased);
+	const dated = scheduledRates(upstream, catalog, cards);
+	if (dated !== void 0) {
+		if (recurring?.effectiveRates !== void 0) throw new Error("Dated cost-patch/cost-fallback effective-rates cannot combine with time-based-cost effective-rates");
+		model.cost = {
+			...model.cost,
+			timeBased: {
+				...recurring ?? NO_RECURRING_TARIFF,
+				effectiveRates: dated
+			}
+		};
+	} else if (recurring !== void 0) model.cost = {
+		...model.cost,
+		timeBased: recurring
+	};
+	const limitsPatch = objectPayload(catalog.limitsPatch);
+	if (limitsPatch !== void 0) {
+		const contextWindow = numberField(limitsPatch, "contextWindow");
+		if (contextWindow !== void 0) model.contextWindow = contextWindow;
+		const maxTokens = numberField(limitsPatch, "maxTokens");
+		if (maxTokens !== void 0) model.maxTokens = maxTokens;
+	}
+	const maxTokensFallback = catalog.maxTokensFallback;
+	if (typeof maxTokensFallback === "number" && model.maxTokens === null) model.maxTokens = maxTokensFallback;
+	const maxTokensCeiling = catalog.maxTokensCeiling;
+	if (typeof maxTokensCeiling === "number" && model.maxTokens !== null && model.maxTokens > maxTokensCeiling) model.maxTokens = maxTokensCeiling;
+	const contextWindowFloor = catalog.contextWindowFloor;
+	if (typeof contextWindowFloor === "number") model.contextWindow = Math.max(model.contextWindow ?? 0, contextWindowFloor);
+	const inputModalities = catalog.inputModalities;
+	if (isInputModalities(inputModalities)) model.input = inputModalities;
+}
+/**
+* Direct first-party OpenAI Responses endpoints (api.openai.com, Azure OpenAI
+* deployments). Gates GA computer-use detection; identity supplies the model
+* generation.
+*/
+function isDirectOpenAIResponsesEndpoint(spec) {
+	if (spec.api === "openai-responses") {
+		if (spec.provider !== "openai") return false;
+		if (!spec.baseUrl) return true;
+		try {
+			const url = new URL(spec.baseUrl);
+			return url.protocol === "https:" && url.hostname === "api.openai.com";
+		} catch {
+			return false;
+		}
+	}
+	if (spec.api !== "azure-openai-responses" || spec.provider !== "azure" && spec.provider !== "azure-openai") return false;
+	if (!spec.baseUrl) return true;
+	try {
+		const url = new URL(spec.baseUrl);
+		return url.protocol === "https:" && (url.hostname.endsWith(".openai.azure.com") || url.hostname === "models.inference.ai.azure.com");
+	} catch {
+		return false;
+	}
+}
+function explicitComputerUseConfig(spec) {
+	if (!("supportsComputerUseConfig" in spec)) return spec.supportsComputerUse;
+	const value = Reflect.get(spec, "supportsComputerUseConfig");
+	return typeof value === "boolean" ? value : void 0;
+}
+function revisionAtLeast(identity, major, minor) {
+	if (identity.revision === void 0) return false;
+	const [revMajor = 0, revMinor = 0] = identity.revision.split(".").map(Number);
+	return revMajor > major || revMajor === major && revMinor >= minor;
+}
+function supportsOpenAIGAComputerUse(spec, identity, explicitSupport) {
+	if (explicitSupport !== void 0) return explicitSupport;
+	if (!isDirectOpenAIResponsesEndpoint(spec)) return false;
+	const wireIdentity = spec.requestModelId === void 0 ? identity : resolveModelPolicy({
+		...spec,
+		id: spec.requestModelId
+	}).identity;
+	return wireIdentity.class === "openai" && revisionAtLeast(wireIdentity, 5, 4);
+}
+/**
+* Build one model from an authored spec. Bundled models.json rows are fully
+* materialized by the generator and consumed directly (see `models.ts`), so
+* this only runs for discovered/custom/override specs.
+*/
+function buildModel(spec) {
+	const policy = resolveModelPolicy(spec);
+	const supportsComputerUseConfig = explicitComputerUseConfig(spec);
+	const model = {
+		...spec,
+		reasoning: spec.reasoning || policy.thinking !== void 0,
+		name: cleanModelName(spec.name),
+		identity: policy.identity,
+		requiresGlyphTokenization: policy.identity.class === "anthropic",
+		tokenizer: spec.tokenizer ?? resolveModelTokenizer(spec.requestModelId ?? spec.id, spec.provider),
+		thinking: policy.thinking,
+		supportsComputerUse: supportsOpenAIGAComputerUse(spec, policy.identity, supportsComputerUseConfig),
+		supportsComputerUseConfig,
+		compat: policy.compat,
+		compatConfig: spec.compat
+	};
+	applyCatalogAssignments(model, policy.catalog);
+	applyCatalogCorrections(model, policy.catalog);
+	if (spec.kindConfig !== void 0) model.kind = spec.kindConfig;
+	if (spec.promptCacheConfig !== void 0) model.promptCache = { ...spec.promptCacheConfig };
+	return model;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/discovery/protobuf.ts
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder("utf-8", { fatal: true });
+/** Creates a high-performance, lazy protobuf message codec from an IR field descriptor list. */
+function pb(typeName, fields = []) {
+	let compiled;
+	function getCodec() {
+		if (!compiled) compiled = compileCodec(typeName, fields);
+		return compiled;
+	}
+	const codec = ((arg) => {
+		if (arg instanceof Uint8Array) return getCodec().decode(arg);
+		return getCodec().encode(arg);
+	});
+	codec.create = (value) => getCodec().create(value);
+	codec.encode = (value) => getCodec().encode(value);
+	codec.decode = (value) => getCodec().decode(value);
+	codec.toJson = (value) => getCodec().toJson(value);
+	return codec;
+}
+/** Creates a message using its codec's protobuf defaults. */
+function create(codec, value) {
+	return codec.create(value);
+}
+/** Encodes a message using its codec. */
+function toBinary(codec, value) {
+	return codec.encode(value);
+}
+/** Decodes wire bytes using a message codec. */
+function fromBinary(codec, value) {
+	return codec.decode(value);
+}
+/** Encodes a JSON value as `google.protobuf.Value`. */
+function encodeJsonValue(value) {
+	const writer = new Writer();
+	writeJsonValue(writer, value);
+	return writer.finish();
+}
+/** Decodes `google.protobuf.Value` wire bytes into a JSON value. */
+function decodeJsonValue(value) {
+	return readJsonValue(new Reader(value));
+}
+function compileCodec(typeName, fieldDescs) {
+	const compiledFields = [];
+	const byNumber = /* @__PURE__ */ new Map();
+	for (const desc of fieldDescs) if (desc.kind === "oneof") {
+		const oneofHandler = compileOneofField(desc);
+		compiledFields.push(oneofHandler);
+		for (const v of desc.variants) byNumber.set(v.no, oneofHandler);
+	} else if (desc.kind === "map") {
+		const mapHandler = compileMapField(desc);
+		compiledFields.push(mapHandler);
+		byNumber.set(desc.no, mapHandler);
+	} else if (desc.kind === "message") {
+		const msgHandler = desc.repeat ? compileRepeatedField(desc.name, desc.no, messageValue(desc.T)) : compileSingularField(desc.name, desc.no, messageValue(desc.T));
+		compiledFields.push(msgHandler);
+		byNumber.set(desc.no, msgHandler);
+	} else {
+		const valCodec = scalarValue(desc.kind);
+		const scalarHandler = desc.repeat ? compileRepeatedField(desc.name, desc.no, valCodec) : compileSingularField(desc.name, desc.no, valCodec, desc.optional);
+		compiledFields.push(scalarHandler);
+		byNumber.set(desc.no, scalarHandler);
+	}
+	const codec = ((arg) => {
+		if (arg instanceof Uint8Array) return codec.decode(arg);
+		return codec.encode(arg);
+	});
+	codec.create = (value) => {
+		const message = typeName ? { $typeName: typeName } : {};
+		for (const f of compiledFields) f.initDefault(message);
+		if (value) for (const key in value) {
+			const v = Reflect.get(value, key);
+			if (v !== void 0) Reflect.set(message, key, v);
+		}
+		return message;
+	};
+	codec.encode = (value) => {
+		const writer = new Writer();
+		for (const f of compiledFields) f.encode(value, writer);
+		writeUnknownFields(value, writer);
+		return writer.finish();
+	};
+	codec.decode = (value) => {
+		const reader = new Reader(value);
+		const message = typeName ? { $typeName: typeName } : {};
+		for (const f of compiledFields) f.initDefault(message);
+		while (reader.pos < reader.len) {
+			const tag = reader.uint32();
+			const fieldNumber = tag >>> 3;
+			const wireType = tag & 7;
+			if (!isWireType(wireType)) throw new Error(`Unsupported protobuf wire type ${wireType} at byte ${reader.pos}`);
+			const field = byNumber.get(fieldNumber);
+			if (field) field.decode(message, reader, wireType, fieldNumber);
+			else {
+				const start = reader.pos;
+				reader.skip(wireType);
+				appendUnknownField(message, {
+					no: fieldNumber,
+					wireType,
+					data: reader.slice(start, reader.pos)
+				});
+			}
+		}
+		return message;
+	};
+	codec.toJson = (value) => {
+		const output = {};
+		for (const f of compiledFields) f.toJson(value, output);
+		return output;
+	};
+	return codec;
+}
+function compileSingularField(name, number, value, optional = false) {
+	return {
+		number,
+		initDefault(message) {
+			if (!optional && value.defaultValue !== void 0) Reflect.set(message, name, value.defaultValue);
+		},
+		encode(message, writer) {
+			const input = Reflect.get(message, name);
+			if (input === void 0 || !optional && value.isDefault(input)) return;
+			writer.tag(number, value.wireType);
+			value.encode(input, writer);
+		},
+		decode(message, reader, wireType, _fieldNumber) {
+			assertWireType(wireType, value.wireType);
+			Reflect.set(message, name, value.decode(reader));
+		},
+		toJson(message, output) {
+			const input = Reflect.get(message, name);
+			if (input === void 0 || !optional && value.isDefault(input)) return;
+			output[name] = value.toJson(input);
+		}
+	};
+}
+function compileRepeatedField(name, number, value) {
+	return {
+		number,
+		initDefault(message) {
+			Reflect.set(message, name, []);
+		},
+		encode(message, writer) {
+			const items = Reflect.get(message, name);
+			if (!Array.isArray(items) || items.length === 0) return;
+			if (value.wireType !== 2 && isPackableScalar(value)) {
+				const packed = new Writer();
+				for (const item of items) value.encode(item, packed);
+				writer.tag(number, 2);
+				writer.lengthDelimited(packed.finish());
+				return;
+			}
+			for (const item of items) {
+				writer.tag(number, value.wireType);
+				value.encode(item, writer);
+			}
+		},
+		decode(message, reader, wireType, _fieldNumber) {
+			const target = arrayField(message, name);
+			if (wireType === 2 && value.wireType !== 2 && isPackableScalar(value)) {
+				const limit = reader.uint32();
+				const end = reader.pos + limit;
+				while (reader.pos < end) target.push(value.decode(reader));
+				return;
+			}
+			assertWireType(wireType, value.wireType);
+			target.push(value.decode(reader));
+		},
+		toJson(message, output) {
+			const items = Reflect.get(message, name);
+			if (!Array.isArray(items) || items.length === 0) return;
+			output[name] = items.map((item) => value.toJson(item));
+		}
+	};
+}
+function compileMapField(desc) {
+	const name = desc.name;
+	const number = desc.no;
+	const key = scalarValue("string");
+	const valCodec = typeof desc.V === "function" ? messageValue(desc.V) : scalarValue(desc.V);
+	return {
+		number,
+		initDefault(message) {
+			Reflect.set(message, name, Object.create(null));
+		},
+		encode(message, writer) {
+			const input = Reflect.get(message, name);
+			if (!isMessageObject(input)) return;
+			for (const entryKey in input) {
+				const entry = new Writer();
+				if (!key.isDefault(entryKey)) {
+					entry.tag(1, key.wireType);
+					key.encode(entryKey, entry);
+				}
+				const entryValue = input[entryKey];
+				if (!valCodec.isDefault(entryValue)) {
+					entry.tag(2, valCodec.wireType);
+					valCodec.encode(entryValue, entry);
+				}
+				writer.tag(number, 2);
+				writer.lengthDelimited(entry.finish());
+			}
+		},
+		decode(message, reader, wireType, _fieldNumber) {
+			assertWireType(wireType, 2);
+			const target = mapField(message, name);
+			const limit = reader.uint32();
+			const end = reader.pos + limit;
+			let entryKey = "";
+			let entryValue = valCodec.defaultValue;
+			while (reader.pos < end) {
+				const tag = reader.uint32();
+				const entryNumber = tag >>> 3;
+				const entryWireType = tag & 7;
+				if (!isWireType(entryWireType)) throw new Error(`Unsupported wire type ${entryWireType} in map entry`);
+				if (entryNumber === 1) {
+					assertWireType(entryWireType, key.wireType);
+					entryKey = requireString(key.decode(reader));
+				} else if (entryNumber === 2) {
+					assertWireType(entryWireType, valCodec.wireType);
+					entryValue = valCodec.decode(reader);
+				} else reader.skip(entryWireType);
+			}
+			target[entryKey] = entryValue;
+		},
+		toJson(message, output) {
+			const input = Reflect.get(message, name);
+			if (!isMessageObject(input)) return;
+			const mapOutput = Object.create(null);
+			for (const entryKey in input) mapOutput[entryKey] = valCodec.toJson(input[entryKey]);
+			output[name] = mapOutput;
+		}
+	};
+}
+function compileOneofField(desc) {
+	const name = desc.name;
+	const variantsByName = /* @__PURE__ */ new Map();
+	const variantsByNumber = /* @__PURE__ */ new Map();
+	for (const variant of desc.variants) {
+		const codec = variant.kind === "message" ? messageValue(variant.T) : scalarValue(variant.kind);
+		variantsByName.set(variant.name, {
+			no: variant.no,
+			codec
+		});
+		variantsByNumber.set(variant.no, {
+			name: variant.name,
+			codec
+		});
+	}
+	return {
+		number: 0,
+		initDefault(message) {
+			Reflect.set(message, name, { case: void 0 });
+		},
+		encode(message, writer) {
+			const oneof = Reflect.get(message, name);
+			if (!oneof || typeof oneof !== "object" || !("case" in oneof) || typeof oneof.case !== "string") return;
+			const variant = variantsByName.get(oneof.case);
+			if (!variant) return;
+			const value = Reflect.get(oneof, "value");
+			if (value === void 0) return;
+			writer.tag(variant.no, variant.codec.wireType);
+			variant.codec.encode(value, writer);
+		},
+		decode(message, reader, wireType, fieldNumber) {
+			const variant = variantsByNumber.get(fieldNumber);
+			if (!variant) throw new Error(`Unknown oneof field ${fieldNumber}`);
+			assertWireType(wireType, variant.codec.wireType);
+			Reflect.set(message, name, {
+				case: variant.name,
+				value: variant.codec.decode(reader)
+			});
+		},
+		toJson(message, output) {
+			const oneof = Reflect.get(message, name);
+			if (!oneof || typeof oneof !== "object" || !("case" in oneof) || typeof oneof.case !== "string") return;
+			const variant = variantsByName.get(oneof.case);
+			if (!variant) return;
+			const value = Reflect.get(oneof, "value");
+			if (value === void 0) return;
+			output[oneof.case] = variant.codec.toJson(value);
+		}
+	};
+}
+function isPackableScalar(value) {
+	return value.wireType === 0 || value.wireType === 1 || value.wireType === 5;
+}
+function scalarValue(kind) {
+	switch (kind) {
+		case "bool": return scalar(0, false, requireBoolean, (value, writer) => writer.bool(value), (reader) => reader.bool(), (value) => value);
+		case "bytes": return scalar(2, /* @__PURE__ */ new Uint8Array(0), requireBytes, (value, writer) => writer.bytes(value), (reader) => reader.bytes(), (value) => value.toBase64(), (value) => value.byteLength === 0);
+		case "double": return scalar(1, 0, requireNumber, (value, writer) => writer.double(value), (reader) => reader.double(), (value) => value);
+		case "enum": return scalar(0, 0, requireInt32, (value, writer) => writer.int32(value), (reader) => reader.int32(), (value) => value);
+		case "float": return scalar(5, 0, requireNumber, (value, writer) => writer.float(value), (reader) => reader.float(), (value) => value);
+		case "int32": return scalar(0, 0, requireInt32, (value, writer) => writer.int32(value), (reader) => reader.int32(), (value) => value);
+		case "int64": return scalar(0, 0n, requireBigInt, (value, writer) => writer.int64(value), (reader) => reader.int64(), (value) => value.toString());
+		case "string": return scalar(2, "", requireString, (value, writer) => writer.string(value), (reader) => reader.string(), (value) => value);
+		case "uint32": return scalar(0, 0, requireUint32, (value, writer) => writer.uint32(value), (reader) => reader.uint32(), (value) => value);
+		case "uint64": return scalar(0, 0n, requireUnsignedBigInt, (value, writer) => writer.uint64(value), (reader) => reader.uint64(), (value) => value.toString());
+	}
+}
+function scalar(wireType, defaultValue, validate, write, read, toJson, isDefault = (value) => value === defaultValue) {
+	return {
+		wireType,
+		defaultValue,
+		encode(value, writer) {
+			write(validate(value), writer);
+		},
+		decode(reader) {
+			return read(reader);
+		},
+		toJson(value) {
+			return toJson(validate(value));
+		},
+		isDefault(value) {
+			return isDefault(validate(value));
+		}
+	};
+}
+function messageValue(factory) {
+	let cached;
+	function getCodec() {
+		if (!cached) cached = factory();
+		return cached;
+	}
+	return {
+		wireType: 2,
+		defaultValue: void 0,
+		encode(value, writer) {
+			writer.lengthDelimited(getCodec().encode(value));
+		},
+		decode(reader) {
+			return getCodec().decode(reader.bytes());
+		},
+		toJson(value) {
+			return getCodec().toJson(value);
+		},
+		isDefault(value) {
+			return value === void 0;
+		}
+	};
+}
+function requireBoolean(value) {
+	if (typeof value === "boolean") return value;
+	throw new Error(`Expected boolean, got ${typeof value}`);
+}
+function requireBytes(value) {
+	if (value instanceof Uint8Array) return value;
+	throw new Error("Expected Uint8Array");
+}
+function requireNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	throw new Error(`Expected number, got ${typeof value}`);
+}
+function requireInt32(value) {
+	if (typeof value === "number" && Number.isInteger(value)) return value | 0;
+	throw new Error(`Expected int32, got ${typeof value}`);
+}
+function requireString(value) {
+	if (typeof value === "string") return value;
+	throw new Error(`Expected string, got ${typeof value}`);
+}
+function requireBigInt(value) {
+	if (typeof value === "bigint") return value;
+	if (typeof value === "number" && Number.isInteger(value)) return BigInt(value);
+	if (typeof value === "string") return BigInt(value);
+	throw new Error(`Expected bigint, got ${typeof value}`);
+}
+function requireUint32(value) {
+	if (typeof value === "number" && Number.isInteger(value) && value >= 0) return value >>> 0;
+	throw new Error(`Expected uint32, got ${typeof value}`);
+}
+function requireUnsignedBigInt(value) {
+	const b = requireBigInt(value);
+	if (b < 0n) throw new Error("Expected unsigned bigint");
+	return b;
+}
+function arrayField(message, name) {
+	let arr = Reflect.get(message, name);
+	if (!Array.isArray(arr)) {
+		arr = [];
+		Reflect.set(message, name, arr);
+	}
+	return arr;
+}
+function mapField(message, name) {
+	const value = Reflect.get(message, name);
+	if (isRecord(value)) return value;
+	const map = Object.create(null);
+	Reflect.set(message, name, map);
+	return map;
+}
+function appendUnknownField(message, field) {
+	const existing = Reflect.get(message, "$unknown");
+	if (isUnknownFields(existing)) {
+		existing.push(field);
+		return;
+	}
+	Reflect.set(message, "$unknown", [field]);
+}
+function isUnknownFields(value) {
+	return Array.isArray(value) && value.every(isUnknownField);
+}
+function writeUnknownFields(message, writer) {
+	const bag = Reflect.get(message, "$unknown");
+	if (!Array.isArray(bag)) return;
+	for (const field of bag) if (isUnknownField(field)) {
+		writer.tag(field.no, field.wireType);
+		writer.raw(field.data);
+	}
+}
+function isUnknownField(value) {
+	return isRecord(value) && typeof value.no === "number" && typeof value.wireType === "number" && isWireType(value.wireType) && value.data instanceof Uint8Array;
+}
+function isMessageObject(value) {
+	return isRecord(value) && !(value instanceof Uint8Array);
+}
+function isWireType(value) {
+	return value === 0 || value === 1 || value === 2 || value === 5;
+}
+function assertWireType(actual, expected) {
+	if (actual !== expected) throw new Error(`Unexpected protobuf wire type ${actual}; expected ${expected}`);
+}
+function isArrayBufferBacked(bytes) {
+	return bytes?.buffer instanceof ArrayBuffer;
+}
+var Writer = class {
+	#chunks = [];
+	#length = 0;
+	tag(number, wireType) {
+		this.uint32(number << 3 | wireType);
+	}
+	uint32(value) {
+		let v = value >>> 0;
+		const buffer = /* @__PURE__ */ new Uint8Array(5);
+		let pos = 0;
+		while (v > 127) {
+			buffer[pos++] = v & 127 | 128;
+			v >>>= 7;
+		}
+		buffer[pos++] = v;
+		this.raw(buffer.subarray(0, pos));
+	}
+	int32(value) {
+		if (value >= 0) {
+			this.uint32(value);
+			return;
+		}
+		this.int64(BigInt(value));
+	}
+	int64(value) {
+		let v = BigInt.asUintN(64, value);
+		const buffer = /* @__PURE__ */ new Uint8Array(10);
+		let pos = 0;
+		while (v > 127n) {
+			buffer[pos++] = Number(v & 127n) | 128;
+			v >>= 7n;
+		}
+		buffer[pos++] = Number(v);
+		this.raw(buffer.subarray(0, pos));
+	}
+	uint64(value) {
+		this.int64(value);
+	}
+	bool(value) {
+		this.raw(new Uint8Array([value ? 1 : 0]));
+	}
+	float(value) {
+		const buffer = /* @__PURE__ */ new Uint8Array(4);
+		new DataView(buffer.buffer).setFloat32(0, value, true);
+		this.raw(buffer);
+	}
+	double(value) {
+		const buffer = /* @__PURE__ */ new Uint8Array(8);
+		new DataView(buffer.buffer).setFloat64(0, value, true);
+		this.raw(buffer);
+	}
+	string(value) {
+		this.lengthDelimited(textEncoder.encode(value));
+	}
+	bytes(value) {
+		this.lengthDelimited(value);
+	}
+	lengthDelimited(value) {
+		this.uint32(value.byteLength);
+		this.raw(value);
+	}
+	raw(chunk) {
+		this.#chunks.push(chunk);
+		this.#length += chunk.byteLength;
+	}
+	/** Wire bytes on a plain `ArrayBuffer`, so they satisfy `fetch`'s `BodyInit` as-is. */
+	finish() {
+		const [only] = this.#chunks;
+		if (this.#chunks.length === 1 && isArrayBufferBacked(only)) return only;
+		const result = new Uint8Array(this.#length);
+		let offset = 0;
+		for (const chunk of this.#chunks) {
+			result.set(chunk, offset);
+			offset += chunk.byteLength;
+		}
+		return result;
+	}
+};
+var Reader = class {
+	buf;
+	len;
+	pos = 0;
+	constructor(buf) {
+		this.buf = buf;
+		this.len = buf.byteLength;
+	}
+	uint32() {
+		let result = 0;
+		let shift = 0;
+		while (this.pos < this.len) {
+			const byte = this.buf[this.pos++];
+			result |= (byte & 127) << shift;
+			if ((byte & 128) === 0) return result >>> 0;
+			shift += 7;
+			if (shift >= 32) throw new Error("Varint exceeds 32 bits");
+		}
+		throw new Error("Unexpected end of protobuf varint");
+	}
+	int32() {
+		return Number(BigInt.asIntN(32, this.uint64()));
+	}
+	int64() {
+		let result = 0n;
+		let shift = 0n;
+		while (this.pos < this.len) {
+			const byte = this.buf[this.pos++];
+			result |= BigInt(byte & 127) << shift;
+			if ((byte & 128) === 0) return BigInt.asIntN(64, result);
+			shift += 7n;
+			if (shift >= 64n) throw new Error("Varint exceeds 64 bits");
+		}
+		throw new Error("Unexpected end of protobuf 64-bit varint");
+	}
+	uint64() {
+		return BigInt.asUintN(64, this.int64());
+	}
+	bool() {
+		return this.uint32() !== 0;
+	}
+	float() {
+		if (this.pos + 4 > this.len) throw new Error("Unexpected EOF reading float");
+		const view = new DataView(this.buf.buffer, this.buf.byteOffset + this.pos, 4);
+		this.pos += 4;
+		return view.getFloat32(0, true);
+	}
+	double() {
+		if (this.pos + 8 > this.len) throw new Error("Unexpected EOF reading double");
+		const view = new DataView(this.buf.buffer, this.buf.byteOffset + this.pos, 8);
+		this.pos += 8;
+		return view.getFloat64(0, true);
+	}
+	string() {
+		return textDecoder.decode(this.bytes());
+	}
+	bytes() {
+		const length = this.uint32();
+		if (this.pos + length > this.len) throw new Error("Unexpected EOF reading bytes");
+		const result = this.buf.subarray(this.pos, this.pos + length);
+		this.pos += length;
+		return result;
+	}
+	slice(start, end) {
+		return this.buf.subarray(start, end);
+	}
+	skip(wireType) {
+		switch (wireType) {
+			case 0:
+				this.int64();
+				return;
+			case 1:
+				if (this.pos + 8 > this.len) throw new Error("Unexpected EOF skipping 64-bit");
+				this.pos += 8;
+				return;
+			case 2:
+				this.bytes();
+				return;
+			case 5:
+				if (this.pos + 4 > this.len) throw new Error("Unexpected EOF skipping 32-bit");
+				this.pos += 4;
+				return;
+		}
+	}
+};
+function writeJsonValue(writer, value) {
+	if (value === null) {
+		writer.tag(1, 0);
+		writer.uint32(0);
+		return;
+	}
+	if (typeof value === "number") {
+		writer.tag(2, 1);
+		writer.double(value);
+		return;
+	}
+	if (typeof value === "string") {
+		writer.tag(3, 2);
+		writer.string(value);
+		return;
+	}
+	if (typeof value === "boolean") {
+		writer.tag(4, 0);
+		writer.bool(value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		const listWriter = new Writer();
+		for (const item of value) {
+			listWriter.tag(1, 2);
+			const itemWriter = new Writer();
+			writeJsonValue(itemWriter, item);
+			listWriter.lengthDelimited(itemWriter.finish());
+		}
+		writer.tag(6, 2);
+		writer.lengthDelimited(listWriter.finish());
+		return;
+	}
+	if (isRecord(value)) {
+		const structWriter = new Writer();
+		for (const key in value) {
+			const item = value[key];
+			const entryWriter = new Writer();
+			entryWriter.tag(1, 2);
+			entryWriter.string(key);
+			entryWriter.tag(2, 2);
+			const valueWriter = new Writer();
+			writeJsonValue(valueWriter, item);
+			entryWriter.lengthDelimited(valueWriter.finish());
+			structWriter.tag(1, 2);
+			structWriter.lengthDelimited(entryWriter.finish());
+		}
+		writer.tag(5, 2);
+		writer.lengthDelimited(structWriter.finish());
+	}
+}
+function readJsonValue(reader) {
+	let value = null;
+	while (reader.pos < reader.len) {
+		const tag = reader.uint32();
+		const fieldNumber = tag >>> 3;
+		const wireType = tag & 7;
+		if (!isWireType(wireType)) throw new Error(`Unsupported wire type ${wireType} in google.protobuf.Value`);
+		switch (fieldNumber) {
+			case 1:
+				assertWireType(wireType, 0);
+				reader.uint32();
+				value = null;
+				break;
+			case 2:
+				assertWireType(wireType, 1);
+				value = reader.double();
+				break;
+			case 3:
+				assertWireType(wireType, 2);
+				value = reader.string();
+				break;
+			case 4:
+				assertWireType(wireType, 0);
+				value = reader.bool();
+				break;
+			case 5:
+				assertWireType(wireType, 2);
+				value = readJsonStruct(new Reader(reader.bytes()));
+				break;
+			case 6:
+				assertWireType(wireType, 2);
+				value = readJsonList(new Reader(reader.bytes()));
+				break;
+			default: reader.skip(wireType);
+		}
+	}
+	return value;
+}
+function readJsonStruct(reader) {
+	const output = {};
+	while (reader.pos < reader.len) {
+		const tag = reader.uint32();
+		const fieldNumber = tag >>> 3;
+		const wireType = tag & 7;
+		if (!isWireType(wireType)) throw new Error(`Unsupported wire type ${wireType} in Struct`);
+		if (fieldNumber === 1) {
+			assertWireType(wireType, 2);
+			const entryReader = new Reader(reader.bytes());
+			let entryKey = "";
+			let entryVal = null;
+			while (entryReader.pos < entryReader.len) {
+				const entryTag = entryReader.uint32();
+				const entryNo = entryTag >>> 3;
+				const entryWire = entryTag & 7;
+				if (entryNo === 1) entryKey = entryReader.string();
+				else if (entryNo === 2) entryVal = readJsonValue(new Reader(entryReader.bytes()));
+				else if (isWireType(entryWire)) entryReader.skip(entryWire);
+			}
+			output[entryKey] = entryVal;
+		} else reader.skip(wireType);
+	}
+	return output;
+}
+function readJsonList(reader) {
+	const list = [];
+	while (reader.pos < reader.len) {
+		const tag = reader.uint32();
+		const fieldNumber = tag >>> 3;
+		const wireType = tag & 7;
+		if (!isWireType(wireType)) throw new Error(`Unsupported wire type ${wireType} in ListValue`);
+		if (fieldNumber === 1) {
+			assertWireType(wireType, 2);
+			list.push(readJsonValue(new Reader(reader.bytes())));
+		} else reader.skip(wireType);
+	}
+	return list;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/compat/types.ts
+/**
+* Revision placeholder in a templated `variant-family` (`gemini-{rev}-flash`).
+* A family whose id carries it is instantiated once per live revision that
+* discovery advertises, so new generations of a lineage collapse without a
+* new reviewed entry.
+*/
+const REVISION_PLACEHOLDER = "{rev}";
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/compat/collapse.ts
+const VARIANT_ROUTING_KEYS = ["off", ...THINKING_EFFORTS];
+const DEFAULT_PAIR_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high"
+];
+/**
+* Build one effort-tier family from a tier→wire-id map: routing keeps only the
+* listed efforts, `members` dedupes the targets in tier order, and thinking is
+* `mode: "effort"` (mandatory when the family has no `off` route). Shared by the
+* Devin and Cursor tables, whose per-effort siblings follow the same shape.
+*/
+function tierFamily(id, name, routes, efforts, defaultMember) {
+	const routing = {};
+	if (routes.off) routing.off = routes.off;
+	for (const effort of efforts) switch (effort) {
+		case "minimal":
+			if (routes.minimal) routing[effort] = routes.minimal;
+			break;
+		case "low":
+			if (routes.low) routing[effort] = routes.low;
+			break;
+		case "medium":
+			if (routes.medium) routing[effort] = routes.medium;
+			break;
+		case "high":
+			if (routes.high) routing[effort] = routes.high;
+			break;
+		case "xhigh":
+			if (routes.xhigh) routing[effort] = routes.xhigh;
+			break;
+		case "max": if (routes.max) routing[effort] = routes.max;
+	}
+	return {
+		id,
+		name,
+		members: [
+			routes.off,
+			routes.minimal,
+			routes.low,
+			routes.medium,
+			routes.high,
+			routes.xhigh,
+			routes.max
+		].filter((member, index, items) => typeof member === "string" && items.indexOf(member) === index),
+		routing,
+		thinking: {
+			mode: "effort",
+			efforts,
+			...routes.off ? void 0 : { requiresEffort: true }
+		},
+		...defaultMember !== void 0 ? { defaultMember } : void 0
+	};
+}
+/** One reviewed family from the compiled collapse vocabulary → runtime shape. */
+function compiledFamily(compiled) {
+	const family = {
+		id: compiled.id,
+		name: compiled.name,
+		members: compiled.members,
+		routing: compiled.routing
+	};
+	if (compiled.defaultMember !== void 0) family.defaultMember = compiled.defaultMember;
+	if (compiled.retiredMembers?.length) family.retiredMembers = compiled.retiredMembers;
+	if (!compiled.noThinking && compiled.mode !== void 0) family.thinking = {
+		mode: compiled.mode,
+		efforts: compiled.efforts ?? [],
+		...compiled.effortBudgets !== void 0 && { effortBudgets: compiled.effortBudgets },
+		...compiled.defaultLevel !== void 0 && { defaultLevel: compiled.defaultLevel },
+		...compiled.requiresEffort === true && { requiresEffort: true }
+	};
+	if (compiled.suppressWhenOff) family.suppressWhenOff = true;
+	if (compiled.preserveAbsentEffortRoutes) family.preserveAbsentEffortRoutes = true;
+	if (compiled.extraAliases?.length) family.extraAliases = compiled.extraAliases;
+	return family;
+}
+const REVISION_CAPTURE = String.raw`(\d+(?:\.\d+){0,2})`;
+/** One compiled `{rev}` family → runtime template with its id matcher. */
+function compiledTemplate(compiled) {
+	const family = compiledFamily(compiled);
+	const alternatives = [
+		family.id,
+		...family.members,
+		...family.extraAliases ?? []
+	].map((id) => id.split(REVISION_PLACEHOLDER).map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(REVISION_CAPTURE));
+	const template = {
+		family,
+		pattern: new RegExp(`^(?:${alternatives.join("|")})$`, "i")
+	};
+	if (compiled.revision !== void 0) {
+		const terms = parseRevisionConstraint(compiled.revision);
+		if (terms !== void 0) template.revision = terms;
+	}
+	return template;
+}
+/** Substitute the placeholder throughout one templated family. */
+function instantiateTemplate(template, rev) {
+	if (template.revision !== void 0) {
+		const parsed = parseRevision(rev);
+		if (parsed === void 0 || !revisionSatisfies(parsed, template.revision)) return void 0;
+	}
+	const fill = (id) => id.replaceAll(REVISION_PLACEHOLDER, rev);
+	const source = template.family;
+	const routing = {};
+	for (const effort of VARIANT_ROUTING_KEYS) {
+		const target = source.routing[effort];
+		if (target !== void 0) routing[effort] = fill(target);
+	}
+	const family = {
+		...source,
+		id: fill(source.id),
+		name: fill(source.name),
+		members: source.members.map(fill),
+		routing
+	};
+	if (source.defaultMember !== void 0) family.defaultMember = fill(source.defaultMember);
+	if (source.retiredMembers !== void 0) family.retiredMembers = source.retiredMembers.map(fill);
+	if (source.extraAliases !== void 0) family.extraAliases = source.extraAliases.map(fill);
+	return family;
+}
+/**
+* The family a template yields for `id` (logical id, member, or alias), or
+* undefined when no template matches or the revision is out of range.
+*/
+function templateFamilyFor(templates, id) {
+	for (const template of templates) {
+		const match = template.pattern.exec(id);
+		if (match === null) continue;
+		let rev;
+		for (let group = 1; group < match.length && rev === void 0; group++) rev = match[group];
+		if (rev === void 0) continue;
+		const family = instantiateTemplate(template, rev);
+		if (family !== void 0) return family;
+	}
+}
+/**
+* Concrete families for every revision present in `ids`, one per
+* instantiated id, skipping ids a concrete family in `table` already owns.
+*/
+function instantiateTemplates(table, ids) {
+	const templates = table.templates;
+	if (templates === void 0 || templates.length === 0) return [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const family of table.families) seen.add(family.id);
+	const out = [];
+	for (const id of ids) {
+		const family = templateFamilyFor(templates, id);
+		if (family === void 0 || seen.has(family.id)) continue;
+		seen.add(family.id);
+		out.push(family);
+	}
+	return out;
+}
+/** Provider id → reviewed collapse table, built once from the compiled vocabulary. */
+function buildCompiledTables() {
+	const { variantFamilies, providerAliases } = collapseVocabulary();
+	const tables = {};
+	for (const compiled of variantFamilies) {
+		const table = tables[compiled.provider] ??= { families: [] };
+		if (compiled.id.includes("{rev}")) (table.templates ??= []).push(compiledTemplate(compiled));
+		else table.families.push(compiledFamily(compiled));
+	}
+	for (const [provider, aliases] of Object.entries(providerAliases)) {
+		tables[provider] ??= { families: [] };
+		tables[provider].providerAliases = aliases;
+	}
+	return tables;
+}
+const CURSOR_TIER_ID_PATTERN = /^(.+?)-(extra-high|none|minimal|low|medium|high|xhigh|max)(-fast)?$/;
+const CURSOR_TIER_BASE_PATTERN = /-(extra-high|none|minimal|low|medium|high|xhigh|max)$/;
+const CURSOR_THINKING_TOKEN_PATTERN = /(^|-)thinking($|-)/;
+const CURSOR_TIER_BY_TOKEN = {
+	none: "none",
+	minimal: "minimal",
+	low: "low",
+	medium: "medium",
+	high: "high",
+	"extra-high": "xhigh",
+	xhigh: "xhigh",
+	max: "max"
+};
+/** Whether an existing logical row already routes every live member in `members`. */
+function collapsedCursorLogicalMatches(spec, members) {
+	const routing = spec.thinking?.effortRouting;
+	if (!routing) return false;
+	for (const member of members) {
+		if (spec.requestModelId === member.spec.id) continue;
+		let matched = false;
+		for (const effort of VARIANT_ROUTING_KEYS) if (routing[effort] === member.spec.id) {
+			matched = true;
+			break;
+		}
+		if (!matched) return false;
+	}
+	return true;
+}
+/**
+* Derive safe Cursor per-effort families from live wire ids. A family is
+* intentionally left expanded when its base is an independent live SKU, any
+* member already has a thinking ladder, member metadata differs, or a tier
+* token is also part of a product name.
+*/
+function deriveCursorEffortFamilies(specs) {
+	const byId = /* @__PURE__ */ new Map();
+	const groups = /* @__PURE__ */ new Map();
+	const candidateBases = /* @__PURE__ */ new Set();
+	for (const spec of specs) {
+		if (!byId.has(spec.id)) byId.set(spec.id, spec);
+		const match = CURSOR_TIER_ID_PATTERN.exec(spec.id);
+		if (!match) continue;
+		const baseId = match[1];
+		const tier = CURSOR_TIER_BY_TOKEN[match[2] ?? ""];
+		const fast = match[3] !== void 0;
+		if (!baseId || !tier) continue;
+		const member = {
+			baseId,
+			fast,
+			spec,
+			tier
+		};
+		const key = `${baseId}\0${fast ? "fast" : "standard"}`;
+		const group = groups.get(key);
+		if (group) group.push(member);
+		else groups.set(key, [member]);
+		candidateBases.add(baseId);
+	}
+	const unsafeBases = /* @__PURE__ */ new Set();
+	for (const group of groups.values()) {
+		const first = group[0];
+		if (!first) continue;
+		const { baseId } = first;
+		const standardGroup = groups.get(`${baseId}\0standard`) ?? [];
+		const standardBase = byId.get(baseId);
+		const laneBase = byId.get(`${baseId}${first.fast ? "-fast" : ""}`);
+		const independentStandardBase = standardBase !== void 0 && !collapsedCursorLogicalMatches(standardBase, standardGroup);
+		const independentLaneBase = laneBase !== void 0 && !collapsedCursorLogicalMatches(laneBase, group);
+		if (independentStandardBase || independentLaneBase || new Set(group.map((member) => member.tier)).size !== group.length || CURSOR_TIER_BASE_PATTERN.test(baseId) || CURSOR_THINKING_TOKEN_PATTERN.test(baseId) || candidateBases.has(`${baseId}-thinking`) || byId.has(`${baseId}-thinking`) || byId.has(`${baseId}-thinking-fast`) || byId.has(`${baseId}-fast-thinking`) || group.some((member) => member.spec.thinking !== void 0 || member.spec.requestModelId !== void 0) || group.some((member) => candidateBases.has(`${baseId}-${member.tier}`))) unsafeBases.add(baseId);
+	}
+	const families = [];
+	for (const group of groups.values()) {
+		const first = group[0];
+		if (!first || group.length < 2 || unsafeBases.has(first.baseId)) continue;
+		if (group.some((member) => member.spec.api !== first.spec.api || member.spec.baseUrl !== first.spec.baseUrl || member.spec.contextWindow !== first.spec.contextWindow || member.spec.maxTokens !== first.spec.maxTokens || member.spec.cursorMaxMode !== first.spec.cursorMaxMode || !Bun.deepEquals(member.spec.cost, first.spec.cost) || !Bun.deepEquals(member.spec.compat, first.spec.compat))) continue;
+		const routes = {};
+		for (const member of group) if (member.tier === "none") routes.off = member.spec.id;
+		else routes[member.tier] = member.spec.id;
+		const efforts = THINKING_EFFORTS.filter((effort) => routes[effort] !== void 0);
+		if (efforts.length === 0) continue;
+		const strippedName = first.spec.name.replace(/\s+(extra-high|none|minimal|low|medium|high|xhigh|max)(\s+fast)?$/i, "").trim();
+		const baseName = strippedName === first.spec.id ? first.baseId : strippedName || first.baseId;
+		const suffix = first.fast ? "-fast" : "";
+		families.push(tierFamily(`${first.baseId}${suffix}`, `${baseName}${first.fast ? " Fast" : ""}`, routes, efforts));
+	}
+	return families;
+}
+/** Provider id → reviewed collapse table. The CCA providers diverge on thinking transport. */
+const REVIEWED_COLLAPSE_TABLES = buildCompiledTables();
+/**
+* Return the reviewed collapse table compiled for `provider`, when declared.
+* Discovery uses this accessor to preserve injectable table seams.
+*/
+function reviewedCollapseTable(provider) {
+	return REVIEWED_COLLAPSE_TABLES[provider] ?? REVIEWED_COLLAPSE_TABLES[provider.toLowerCase()];
+}
+/**
+* Logical id of the reviewed `provider` family claiming `memberId` as a member
+* or extra alias, or `undefined` when no reviewed family owns it. Cursor's rich
+* discovery names lanes with it so they keep the id the legacy-slug collapse
+* (and the bundled catalog) assigns.
+*/
+function reviewedVariantFamilyId(provider, memberId) {
+	const table = reviewedCollapseTable(provider);
+	return table ? getAliasIndex(table).resolve(memberId.trim()) : void 0;
+}
+/**
+* The global automatic rule: derive an `X` + `X-thinking` family for every
+* pair where both ids are live in `specs` (trailing or infix token). Gates:
+* - both members share the same `api`,
+* - known pricing must match — all-zero cost rows count as unknown
+*   (aggregators routinely ship them), but twins that BOTH carry real,
+*   differing prices are distinct SKUs and never merge,
+* - ids claimed by the provider's reviewed table are skipped (curation wins).
+* The capability surface prefers the thinking member's metadata, then the
+* bare member's, then the canonical deriver (aggregators often ship
+* `reasoning: false` and no thinking config on the twin), then a budget
+* default. `off` routes to the bare id; every supported effort routes to the
+* thinking id.
+*/
+function deriveThinkingPairFamilies(specs, table, provider) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const spec of specs) if (!byId.has(spec.id)) byId.set(spec.id, spec);
+	const claimed = table ? getAliasIndex(table) : void 0;
+	const families = [];
+	for (const spec of specs) {
+		const collapsed = provider === void 0 ? void 0 : collapseVariantId(provider, spec.id);
+		const baseId = collapsed?.thinkingVariant ? collapsed.logicalId : stripThinkingVariantSuffix(spec.id);
+		if (baseId === void 0 || baseId === spec.id) continue;
+		const base = byId.get(baseId);
+		if (!base) continue;
+		if (claimed && (claimed.resolve(spec.id) !== void 0 || claimed.resolve(baseId) !== void 0 || claimed.isFamily(spec.id) || claimed.isFamily(baseId))) continue;
+		if (spec.api !== base.api) continue;
+		const specPriced = spec.cost.input !== 0 || spec.cost.output !== 0;
+		const basePriced = base.cost.input !== 0 || base.cost.output !== 0;
+		if (specPriced && basePriced && (spec.cost.input !== base.cost.input || spec.cost.output !== base.cost.output || spec.cost.cacheRead !== base.cost.cacheRead || spec.cost.cacheWrite !== base.cost.cacheWrite)) continue;
+		const surface = derivePairThinkingSurface(spec, base);
+		const routing = { off: base.id };
+		for (const effort of surface.efforts) routing[effort] = spec.id;
+		families.push({
+			id: base.id,
+			name: base.name,
+			members: [base.id, spec.id],
+			routing,
+			thinking: surface
+		});
+	}
+	return families;
+}
+function derivePairThinkingSurface(thinkingSpec, baseSpec) {
+	const baked = thinkingSpec.thinking ?? baseSpec.thinking;
+	if (baked && baked.efforts.length > 0) {
+		const { effortRouting: _routing, suppressWhenOff: _suppress, requiresEffort: _required, ...surface } = baked;
+		return surface;
+	}
+	const { compat: _compat, ...policySpec } = thinkingSpec;
+	const derived = resolveModelPolicy({
+		...policySpec,
+		reasoning: true,
+		thinking: void 0
+	}).thinking;
+	if (derived && derived.efforts.length > 0) {
+		const { effortRouting: _dRouting, suppressWhenOff: _dSuppress, requiresEffort: _dRequired, ...surface } = derived;
+		return surface;
+	}
+	return {
+		mode: "budget",
+		efforts: DEFAULT_PAIR_EFFORTS
+	};
+}
+/**
+* Re-point a stale collapsed spec whose `requestModelId` or routing still
+* targets a retired wire id. Collapsed snapshots (bundled catalog, cache
+* rows, previous-generation fallbacks) pass through collapsing untouched, so
+* a reviewed-table routing fix would otherwise never reach them. Only retired
+* targets are rewritten — presence-filtered routing decisions from live
+* discovery stay authoritative for everything else. Per retired entry the
+* table's route for that effort wins, then the off/first-live-member wire id,
+* then the route is dropped (falls back to `requestModelId ?? id`). Returns
+* `spec` by reference when nothing targets a retired id.
+*/
+function reconcileRetiredRouting(spec, family, retired) {
+	const currentThinking = spec.thinking;
+	const routing = currentThinking?.effortRouting;
+	const requestRetired = spec.requestModelId !== void 0 && retired.has(spec.requestModelId);
+	let routingRetired = false;
+	if (routing !== void 0) for (const key of VARIANT_ROUTING_KEYS) {
+		const target = routing[key];
+		if (target !== void 0 && retired.has(target)) {
+			routingRetired = true;
+			break;
+		}
+	}
+	if (!requestRetired && !routingRetired) return spec;
+	const offTarget = family.routing.off;
+	const fallbackWireId = offTarget !== void 0 && !retired.has(offTarget) ? offTarget : family.members.find((id) => !retired.has(id));
+	const next = { ...spec };
+	if (routingRetired && routing !== void 0 && currentThinking !== void 0) {
+		const nextRouting = {};
+		for (const effortKey of VARIANT_ROUTING_KEYS) {
+			const target = routing[effortKey];
+			if (target === void 0) continue;
+			if (!retired.has(target)) {
+				nextRouting[effortKey] = target;
+				continue;
+			}
+			const tableTarget = family.routing[effortKey];
+			if (tableTarget !== void 0 && !retired.has(tableTarget)) nextRouting[effortKey] = tableTarget;
+			else if (fallbackWireId !== void 0) nextRouting[effortKey] = fallbackWireId;
+		}
+		next.thinking = {
+			...currentThinking,
+			effortRouting: nextRouting
+		};
+	}
+	if (requestRetired) {
+		if (fallbackWireId !== void 0 && fallbackWireId !== spec.id) next.requestModelId = fallbackWireId;
+		else delete next.requestModelId;
+	}
+	return next;
+}
+/**
+* Refresh a collapsed snapshot's thinking surface in place. Bundled catalog and
+* prev-generation snapshots freeze a family's transport, budgets, and routing;
+* discovery emits the canonical id but the exact-id merge never overwrites a
+* stale `family.id` row (e.g. `gemini-3.1-pro`) nor a recycled `extraAliases`
+* row (e.g. `gemini-3-flash`). This re-applies the reviewed-table family's thinking,
+* routing, and default wire id while keeping the spec id (load-bearing for exact
+* selectors and bundled lookups). Returns `spec` by reference when unchanged.
+*/
+function refreshCollapsedThinking(spec, family, retired) {
+	const familyThinking = family.thinking;
+	if (!spec.reasoning || familyThinking?.effortBudgets === void 0) return spec;
+	const routing = {};
+	let hasRouting = false;
+	for (const effortKey of VARIANT_ROUTING_KEYS) {
+		const target = family.routing[effortKey];
+		if (target !== void 0 && !retired?.has(target)) {
+			routing[effortKey] = target;
+			hasRouting = true;
+		}
+	}
+	const thinking = { ...familyThinking };
+	if (hasRouting) thinking.effortRouting = routing;
+	if (family.suppressWhenOff) thinking.suppressWhenOff = true;
+	const offTarget = family.routing.off;
+	const requestModelId = offTarget !== void 0 && !retired?.has(offTarget) && offTarget !== spec.id ? offTarget : spec.requestModelId;
+	if (Bun.deepEquals(thinking, spec.thinking) && requestModelId === spec.requestModelId) return spec;
+	return {
+		...spec,
+		thinking,
+		...requestModelId !== void 0 ? { requestModelId } : {}
+	};
+}
+/**
+* Re-point a collapsed snapshot's default wire id to the family's declared
+* {@link EffortVariantFamily.defaultMember} when the snapshot still advertises a
+* different default. Bundled catalog and cache rows freeze `requestModelId` from
+* before a family gained a preferred default (Cursor Grok 4.5/4.6 → `-medium`),
+* and neither the existing-collapsed pass-through nor `refreshCollapsedThinking`
+* (scoped to `effortBudgets` families) would otherwise correct them — leaving an
+* effort-less request clamped to the refused `-low` tier (issue #9478). Only
+* re-points when the target is a live route in the snapshot's own
+* `effortRouting`. Returns `spec` by reference when unchanged.
+*/
+function reconcileDefaultMember(spec, family, presentMembers) {
+	const defaultMember = family.defaultMember;
+	if (defaultMember === void 0 || defaultMember === spec.id) return spec;
+	const target = presentMembers === void 0 || presentMembers.has(defaultMember) ? defaultMember : family.members.find((id) => presentMembers.has(id));
+	if (target === void 0 || spec.requestModelId === target) return spec;
+	const routing = spec.thinking?.effortRouting;
+	if (routing === void 0) return spec;
+	for (const key of VARIANT_ROUTING_KEYS) if (routing[key] === target) return {
+		...spec,
+		requestModelId: target
+	};
+	return spec;
+}
+/**
+* Whether a Cursor wire id names an extended tier that upstream serves only in
+* max mode. The compiled taxonomy identifies `xhigh`/`extra-high`/`max`
+* efforts and their optional service lanes. This is an inference, not an
+* upstream marker: it is the only per-tier signal available for bundled rows
+* and for routes live discovery never advertised.
+*/
+function isCursorMaxModeWireId(wireModelId) {
+	const effort = collapseVariantId("cursor", wireModelId).effort;
+	return effort === "xhigh" || effort === "max";
+}
+/**
+* Recover Cursor's max-mode marker for a bundled collapsed row. The bundled
+* snapshot may contain only the logical row, but its effort routing still
+* records the wire ids, so {@link isCursorMaxModeWireId} preserves the
+* transport invariant even when live discovery contributes no raw members.
+*/
+function reconcileCursorMaxModeFromRouting(spec) {
+	if (spec.provider !== "cursor" || spec.cursorMaxMode === true) return spec;
+	const routing = spec.thinking?.effortRouting;
+	if (routing === void 0) return spec;
+	return Object.values(routing).some((target) => typeof target === "string" && isCursorMaxModeWireId(target)) ? {
+		...spec,
+		cursorMaxMode: true
+	} : spec;
+}
+/**
+* Index the discovered `max_mode` marker of every live Cursor member by its own
+* wire id. The collapsed row's `cursorMaxMode` is an OR across members, so it
+* says nothing per tier; the transport needs the marker addressable by the wire
+* id it actually sends, because upstream marks tiers the slug cannot identify
+* (the whole Opus `-fast` lane is max-mode, `-low-fast` included). Returns
+* `undefined` when no member carries a marker, so unmarked rosters add no field.
+*/
+function cursorMaxModeRoutesOf(provider, memberSpecs) {
+	if (provider !== "cursor") return void 0;
+	let routes;
+	for (const member of memberSpecs) {
+		if (member.cursorMaxMode === void 0) continue;
+		routes ??= {};
+		routes[member.id] = member.cursorMaxMode;
+	}
+	return routes;
+}
+/**
+* Lift Cursor's max-mode markers from live member rows onto an already-collapsed
+* snapshot. Bundled catalog and cache rows froze the flag from `memberSpecs[0]`
+* — the `-none`/`-low` tier — so the committed `gpt-5.6-*` / `cursor-grok-*`
+* rows carry `cursorMaxMode: false`. The existing-collapsed pass-through keeps
+* the snapshot verbatim, so a live `GetUsableModels` roster that marks the
+* `-xhigh`/`-max` tiers would be discarded and max-tier requests would keep
+* sending `max_mode: false` on a max-mode-only wire id. The row-level flag
+* mirrors the fresh-collapse aggregation: only the positive case is lifted, so
+* a roster that marks nothing leaves the snapshot alone. The per-wire-id
+* markers are merged on top of the snapshot's own so live rows win per route.
+* Returns `spec` by reference when unchanged.
+*/
+function reconcileCursorMaxMode(spec, memberSpecs) {
+	const routes = cursorMaxModeRoutesOf(spec.provider, memberSpecs);
+	const lifts = spec.cursorMaxMode !== true && memberSpecs.some((member) => member.cursorMaxMode === true);
+	if (routes === void 0 && !lifts) return spec;
+	return {
+		...spec,
+		...lifts ? { cursorMaxMode: true } : {},
+		...routes === void 0 ? {} : { cursorMaxModeRoutes: {
+			...spec.cursorMaxModeRoutes,
+			...routes
+		} }
+	};
+}
+/**
+* Collapse every family in `table` found in `specs`. Non-member specs pass
+* through verbatim (by reference), order preserved; the collapsed spec
+* replaces the first occurrence of its family.
+*/
+function collapseWithTable(specs, table) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const spec of specs) if (!byId.has(spec.id)) byId.set(spec.id, spec);
+	/** family id → spec to emit at the family's first occurrence. */
+	const replacement = /* @__PURE__ */ new Map();
+	/** spec ids that belong to a touched family (members + logical id). */
+	const familyIdBySpecId = /* @__PURE__ */ new Map();
+	const instantiated = instantiateTemplates(table, byId.keys());
+	const families = instantiated.length === 0 ? table.families : [...table.families, ...instantiated];
+	for (const family of families) {
+		const retired = family.retiredMembers !== void 0 && family.retiredMembers.length > 0 ? new Set(family.retiredMembers) : void 0;
+		const existing = byId.get(family.id);
+		const existingCollapsed = existing !== void 0 && (existing.requestModelId !== void 0 || existing.thinking?.effortRouting !== void 0);
+		const reconciled = existing !== void 0 && existingCollapsed && retired !== void 0 ? reconcileRetiredRouting(existing, family, retired) : existing;
+		const rawPresent = family.members.filter((id) => byId.has(id) && !(id === family.id && existingCollapsed));
+		if (rawPresent.length === 0) {
+			const refreshed = existing !== void 0 && existingCollapsed ? reconcileCursorMaxModeFromRouting(reconcileDefaultMember(refreshCollapsedThinking(reconciled ?? existing, family, retired), family)) : reconciled;
+			if (refreshed !== void 0 && refreshed !== existing) {
+				familyIdBySpecId.set(family.id, family.id);
+				replacement.set(family.id, refreshed);
+			}
+			continue;
+		}
+		for (const id of rawPresent) familyIdBySpecId.set(id, family.id);
+		if (existing) familyIdBySpecId.set(family.id, family.id);
+		const memberSpecs = [];
+		for (const id of rawPresent) {
+			const member = byId.get(id);
+			if (member !== void 0) memberSpecs.push(member);
+		}
+		if (existingCollapsed && reconciled !== void 0) {
+			replacement.set(family.id, reconcileCursorMaxMode(reconcileDefaultMember(reconciled, family, new Set(rawPresent)), memberSpecs));
+			continue;
+		}
+		const firstMember = memberSpecs[0];
+		if (firstMember === void 0) continue;
+		const presentSet = new Set(rawPresent);
+		const routing = {};
+		let hasRouting = false;
+		let hasEffortRoute = false;
+		let usedAbsentEffortRoute = false;
+		for (const effort of VARIANT_ROUTING_KEYS) {
+			const target = family.routing[effort];
+			const targetPresent = target !== void 0 && presentSet.has(target);
+			const preserveAbsentEffort = target !== void 0 && effort !== "off" && family.preserveAbsentEffortRoutes === true;
+			if (target !== void 0 && (targetPresent || preserveAbsentEffort) && !retired?.has(target)) {
+				routing[effort] = target;
+				hasRouting = true;
+				if (effort !== "off") hasEffortRoute = true;
+				if (!targetPresent && effort !== "off") usedAbsentEffortRoute = true;
+			}
+		}
+		const reasoning = memberSpecs.some((spec) => spec.reasoning) || hasEffortRoute;
+		const familyThinking = family.thinking;
+		const thinking = familyThinking ? { ...familyThinking } : void 0;
+		if (thinking !== void 0) {
+			if (hasRouting) thinking.effortRouting = routing;
+			if (family.suppressWhenOff) thinking.suppressWhenOff = true;
+		}
+		const input = [];
+		if (memberSpecs.some((spec) => spec.input.includes("text"))) input.push("text");
+		if (memberSpecs.some((spec) => spec.input.includes("image"))) input.push("image");
+		const cursorMaxMode = memberSpecs.some((spec) => spec.cursorMaxMode === true) ? true : void 0;
+		const cursorMaxModeRoutes = cursorMaxModeRoutesOf(firstMember.provider, memberSpecs);
+		const collapsed = {
+			...firstMember,
+			id: family.id,
+			name: family.name,
+			reasoning,
+			input,
+			contextWindow: maxOrNull(memberSpecs.map((spec) => spec.contextWindow)),
+			maxTokens: maxOrNull(memberSpecs.map((spec) => spec.maxTokens)),
+			...cursorMaxMode === void 0 ? {} : { cursorMaxMode },
+			...cursorMaxModeRoutes === void 0 ? {} : { cursorMaxModeRoutes }
+		};
+		if (memberSpecs.some((spec) => spec.isProviderDefault === true)) collapsed.isProviderDefault = true;
+		const defaultWireId = (family.defaultMember !== void 0 && presentSet.has(family.defaultMember) && !retired?.has(family.defaultMember) ? family.defaultMember : void 0) ?? rawPresent.find((id) => !retired?.has(id)) ?? rawPresent[0];
+		if (defaultWireId === void 0) continue;
+		if (defaultWireId === family.id) {
+			if (usedAbsentEffortRoute) collapsed.requestModelId = defaultWireId;
+			else delete collapsed.requestModelId;
+		} else collapsed.requestModelId = defaultWireId;
+		if (reasoning && thinking !== void 0) collapsed.thinking = thinking;
+		else delete collapsed.thinking;
+		replacement.set(family.id, collapsed);
+	}
+	for (const family of table.families) {
+		if (family.extraAliases === void 0) continue;
+		const retired = family.retiredMembers !== void 0 && family.retiredMembers.length > 0 ? new Set(family.retiredMembers) : void 0;
+		for (const alias of family.extraAliases) {
+			if (alias === family.id || familyIdBySpecId.has(alias)) continue;
+			const aliasSpec = byId.get(alias);
+			if (aliasSpec === void 0) continue;
+			const refreshed = refreshCollapsedThinking(aliasSpec, family, retired);
+			if (refreshed !== aliasSpec) {
+				familyIdBySpecId.set(alias, alias);
+				replacement.set(alias, refreshed);
+			}
+		}
+	}
+	if (replacement.size === 0) return [...specs];
+	const emitted = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const spec of specs) {
+		const familyId = familyIdBySpecId.get(spec.id);
+		if (familyId === void 0) {
+			out.push(spec);
+			continue;
+		}
+		if (emitted.has(familyId)) continue;
+		emitted.add(familyId);
+		const familySpec = replacement.get(familyId);
+		if (familySpec !== void 0) out.push(familySpec);
+	}
+	return out;
+}
+/**
+* Re-key model-to-model configuration after collapse removes a referenced
+* member id. Qualified targets keep their provider; bare targets remain bare.
+*/
+function retargetCollapsedModelReferences(specs) {
+	const liveIdsByProvider = /* @__PURE__ */ new Map();
+	for (const spec of specs) {
+		const provider = spec.provider.toLowerCase();
+		let liveIds = liveIdsByProvider.get(provider);
+		if (!liveIds) {
+			liveIds = /* @__PURE__ */ new Set();
+			liveIdsByProvider.set(provider, liveIds);
+		}
+		liveIds.add(spec.id.toLowerCase());
+	}
+	for (let index = 0; index < specs.length; index++) {
+		const spec = specs[index];
+		if (!spec) continue;
+		const contextPromotionTarget = resolveCollapsedModelReference(spec.contextPromotionTarget, spec.provider, liveIdsByProvider);
+		const compactionModel = resolveCollapsedModelReference(spec.compactionModel, spec.provider, liveIdsByProvider);
+		const webSearchModel = resolveCollapsedModelReference(spec.webSearchModel, spec.provider, liveIdsByProvider);
+		const imageModel = resolveCollapsedModelReference(spec.imageModel, spec.provider, liveIdsByProvider);
+		if (contextPromotionTarget === spec.contextPromotionTarget && compactionModel === spec.compactionModel && webSearchModel === spec.webSearchModel && imageModel === spec.imageModel) continue;
+		specs[index] = {
+			...spec,
+			contextPromotionTarget,
+			compactionModel,
+			webSearchModel,
+			imageModel
+		};
+	}
+}
+function resolveCollapsedModelReference(target, currentProvider, liveIdsByProvider) {
+	if (target === void 0) return void 0;
+	const separator = target.indexOf("/");
+	const provider = separator >= 0 ? target.slice(0, separator) : currentProvider;
+	const providerId = provider.toLowerCase();
+	const normalizedModelId = (separator >= 0 ? target.slice(separator + 1) : target).trim().toLowerCase();
+	const liveIds = liveIdsByProvider.get(providerId);
+	if (liveIds?.has(normalizedModelId)) return target;
+	const alias = resolveRegisteredVariantAlias(provider, normalizedModelId);
+	if (alias === void 0 || !liveIds?.has(alias.toLowerCase())) return target;
+	return separator >= 0 ? `${provider}/${alias}` : alias;
+}
+/**
+* Collapse a full mixed-provider list: per provider, the compiled reviewed table, Cursor's
+* conservative live effort-sibling rule, and the automatic `X`/`X-thinking`
+* pair rule. Used by the catalog generator; the runtime equivalent lives at
+* the model-manager merge point. Output is regrouped by provider — callers
+* re-sort.
+*/
+function collapseVariants(specs, opts) {
+	if (opts?.table !== void 0) return collapseWithTable(specs, opts.table);
+	const byProvider = /* @__PURE__ */ new Map();
+	for (const spec of specs) {
+		const slice = byProvider.get(spec.provider);
+		if (slice) slice.push(spec);
+		else byProvider.set(spec.provider, [spec]);
+	}
+	const out = [];
+	for (const [provider, slice] of byProvider) {
+		const table = reviewedCollapseTable(provider);
+		let result = table ? collapseWithTable(slice, table) : slice;
+		if (provider === "cursor") {
+			const cursorDerived = deriveCursorEffortFamilies(result);
+			if (cursorDerived.length > 0) result = collapseWithTable(result, { families: cursorDerived });
+		}
+		const derived = deriveThinkingPairFamilies(result, table, provider);
+		if (derived.length > 0) result = collapseWithTable(result, { families: derived });
+		registerCollapsedVariantAliases(provider, result);
+		out.push(...result);
+	}
+	retargetCollapsedModelReferences(out);
+	return out;
+}
+/**
+* Alias index over a collapse table (or the live families observed at
+* runtime). Templated families are materialized on first lookup of any id
+* they match, so a revision discovery has never advertised still resolves.
+*/
+var VariantAliasIndex = class {
+	/** lowercased retired id → replacement model id. */
+	#forward = /* @__PURE__ */ new Map();
+	/**
+	* lowercased provider-scoped alias → replacement model id. Kept apart from
+	* `#forward` so bare-id and reverse lookups never see it.
+	*/
+	providerScoped = /* @__PURE__ */ new Map();
+	/** replacement model id → retired ids that resolve to it. */
+	#reverse = /* @__PURE__ */ new Map();
+	/** Collapsed logical ids declared by the table or observed at runtime. */
+	#familyIds = /* @__PURE__ */ new Set();
+	#templates;
+	constructor(templates = []) {
+		this.#templates = templates;
+	}
+	/** Register `from` → `to`; false when `from` is already claimed. */
+	add(from, to) {
+		if (from === to || this.#forward.has(from.toLowerCase())) return false;
+		this.#forward.set(from.toLowerCase(), to);
+		const sources = this.#reverse.get(to);
+		if (sources) sources.push(from);
+		else this.#reverse.set(to, [from]);
+		return true;
+	}
+	/** Register a family: its logical id plus every member and extra alias. */
+	addFamily(family) {
+		this.#familyIds.add(family.id);
+		for (const member of family.members) this.add(member, family.id);
+		for (const alias of family.extraAliases ?? []) this.add(alias, family.id);
+	}
+	markFamily(id) {
+		this.#familyIds.add(id);
+	}
+	/** Replacement model id for a retired/member id (case-insensitive). */
+	resolve(id) {
+		const lower = id.toLowerCase();
+		this.#learn(lower);
+		return this.#forward.get(lower);
+	}
+	/** Whether `id` is a collapsed logical id of this index. */
+	isFamily(id) {
+		this.#learn(id);
+		return this.#familyIds.has(id);
+	}
+	/** Retired ids that resolve to logical `id`. */
+	sourcesOf(id) {
+		this.#learn(id);
+		return this.#reverse.get(id);
+	}
+	/** Materialize the template family that owns `id`, once. */
+	#learn(id) {
+		if (this.#templates.length === 0) return;
+		const family = templateFamilyFor(this.#templates, id);
+		if (family === void 0 || this.#familyIds.has(family.id)) return;
+		this.addFamily(family);
+	}
+};
+const dynamicAliasIndexes = /* @__PURE__ */ new Map();
+const kAliasIndex = Symbol("compat-collapse.aliasIndex");
+/**
+* Persist aliases embedded in collapsed routing so generated catalog rows and
+* newly discovered families expose the same selector migrations as reviewed tables.
+*/
+function registerCollapsedVariantAliases(provider, specs) {
+	const providerId = provider.toLowerCase();
+	let index = dynamicAliasIndexes.get(providerId);
+	for (const spec of specs) {
+		const routing = spec.thinking?.effortRouting;
+		if (!routing) continue;
+		let registered = false;
+		for (const effort of VARIANT_ROUTING_KEYS) {
+			const source = routing[effort];
+			if (!source || source === spec.id) continue;
+			index ??= new VariantAliasIndex();
+			registered = index.add(source, spec.id) || registered;
+		}
+		if (spec.requestModelId && spec.requestModelId !== spec.id) {
+			index ??= new VariantAliasIndex();
+			registered = index.add(spec.requestModelId, spec.id) || registered;
+		}
+		if (registered) index?.markFamily(spec.id);
+	}
+	if (index) dynamicAliasIndexes.set(providerId, index);
+}
+function resolveRegisteredVariantAlias(provider, normalizedModelId) {
+	const providerId = provider.toLowerCase();
+	const table = reviewedCollapseTable(provider) ?? reviewedCollapseTable(providerId);
+	return (table ? getAliasIndex(table).resolve(normalizedModelId) : void 0) ?? dynamicAliasIndexes.get(providerId)?.resolve(normalizedModelId);
+}
+function getAliasIndex(table) {
+	const cached = Reflect.get(table, kAliasIndex);
+	if (cached instanceof VariantAliasIndex) return cached;
+	const index = new VariantAliasIndex(table.templates);
+	for (const family of table.families) index.addFamily(family);
+	for (const alias in table.providerAliases) {
+		const target = table.providerAliases[alias];
+		if (target !== void 0 && alias !== target) index.providerScoped.set(alias.toLowerCase(), target);
+	}
+	Reflect.set(table, kAliasIndex, index);
+	return index;
+}
+function maxOrNull(values) {
+	const known = values.filter((v) => v != null);
+	return known.length ? Math.max(...known) : null;
+}
+//#endregion
+export { decodeJsonValue as a, pb as c, create as i, toBinary as l, isCursorMaxModeWireId as n, encodeJsonValue as o, reviewedVariantFamilyId as r, fromBinary as s, collapseVariants as t, buildModel as u };