@dbx-tools/model 0.9.38 → 0.9.43

package/src/bindings.ts

@@ -0,0 +1,77 @@
+/**
+ * Binding-safe facade for Databricks model discovery and routing.
+ *
+ * Generated language bindings should target this module instead of binding the
+ * full model package. It exposes plain TypeScript records while delegating all
+ * authentication, catalogue caching, fuzzy matching, policy, and URL selection
+ * to {@link createModelClient}.
+ *
+ * @module
+ */
+
+import type { ModelClass, ModelMetadata } from "@dbx-tools/shared-model/contracts";
+import { createModelClient, type ModelProtocol } from "./model-client.ts";
+
+/** Binding-friendly fuzzy model route request. */
+export interface ResolveModelRouteOptions {
+  readonly profile?: string;
+  readonly model?: string;
+  readonly fuzzy?: boolean;
+  readonly threshold?: number;
+  readonly requiresTools?: boolean;
+  readonly modelClass?: ModelClass;
+  readonly fallbacks?: readonly string[];
+  readonly liveOnly?: boolean;
+  readonly protocol?: ModelProtocol;
+  readonly refresh?: boolean;
+  readonly login?: boolean;
+}
+
+/** Binding-friendly model endpoint metadata used by Graphiti and other runtimes. */
+export interface ResolvedModelRoute {
+  readonly modelId: string;
+  readonly endpointName?: string;
+  readonly endpointTask?: string;
+  readonly endpointDimension?: number;
+  readonly source: "explicit" | "fuzzy-match" | "class" | "fallback";
+  readonly protocol: ModelProtocol;
+  readonly host: string;
+  readonly apiBase: string;
+  readonly url: string;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly metadata: ModelMetadata;
+}
+
+/** Resolve one fuzzy model request through the canonical Node model client. */
+export async function resolveModelRoute(
+  options: ResolveModelRouteOptions = {},
+): Promise<ResolvedModelRoute> {
+  const client = await createModelClient({
+    ...(options.profile ? { auth: { profile: options.profile } } : {}),
+  });
+  const route = await client.route({
+    ...(options.model ? { explicit: options.model } : {}),
+    ...(options.fuzzy === undefined ? {} : { fuzzy: options.fuzzy }),
+    ...(options.threshold === undefined ? {} : { threshold: options.threshold }),
+    ...(options.requiresTools === undefined ? {} : { requiresTools: options.requiresTools }),
+    ...(options.modelClass ? { modelClass: options.modelClass } : {}),
+    ...(options.fallbacks ? { fallbacks: [...options.fallbacks] } : {}),
+    ...(options.liveOnly === undefined ? {} : { liveOnly: options.liveOnly }),
+    ...(options.protocol ? { protocol: options.protocol } : {}),
+    ...(options.refresh === undefined ? {} : { refresh: options.refresh }),
+    ...(options.login === undefined ? {} : { login: options.login }),
+  });
+  return {
+    modelId: route.modelId,
+    ...(route.endpoint?.name ? { endpointName: route.endpoint.name } : {}),
+    ...(route.endpoint?.task ? { endpointTask: route.endpoint.task } : {}),
+    ...(route.endpoint?.dimension ? { endpointDimension: route.endpoint.dimension } : {}),
+    source: route.source,
+    protocol: route.protocol,
+    host: route.host,
+    apiBase: route.apiBase,
+    url: route.url,
+    headers: { ...route.headers },
+    metadata: route.metadata,
+  };
+}

package/src/classify.ts

@@ -111,15 +111,24 @@ export function versionTuple(name: string): [number, number, number] {
   return [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0];
 }
 
-/** Compare two version tuples so the higher version sorts first (descending). */
-function compareVersionDesc(a: readonly number[], b: readonly number[]): number {
-  for (let i = 0; i < 3; i++) {
-    const diff = (b[i] ?? 0) - (a[i] ?? 0);
+/**
+ * Compare version tuples component-wise with missing parts as 0.
+ * Positive when `left` is newer.
+ */
+export function compareVersionTuples(left: readonly number[], right: readonly number[]): number {
+  const length = Math.max(left.length, right.length, 3);
+  for (let index = 0; index < length; index += 1) {
+    const diff = (left[index] ?? 0) - (right[index] ?? 0);
     if (diff !== 0) return diff;
   }
   return 0;
 }
 
+/** Compare two version tuples so the higher version sorts first (descending). */
+function compareVersionDesc(a: readonly number[], b: readonly number[]): number {
+  return compareVersionTuples(b, a);
+}
+
 /**
  * Monotonic version key for ordering siblings within a family/tier
  * (e.g. `opus-4-8` over `opus-4-7`). Encodes the {@link versionTuple}

package/src/metadata-cache.ts

@@ -21,6 +21,7 @@ import * as log from "@dbx-tools/shared-core/log";
 import cacache from "cacache";
 import envPaths from "env-paths";
 
+import packageManifest from "../package.json" with { type: "json" };
 import { MODEL_METADATA_TTL_MS } from "./_metadata-contract.ts";
 
 const logger = log.logger("model/metadata-cache");
@@ -30,15 +31,10 @@ interface PackageIdentity {
   readonly version: string;
 }
 
-let packageIdentityPromise: Promise<PackageIdentity> | undefined;
-
-function packageIdentity(): Promise<PackageIdentity> {
-  packageIdentityPromise ??= import("../index.ts").then((mod) => ({
-    identifier: mod.PACKAGE_IDENTIFIER,
-    version: mod.PACKAGE_VERSION,
-  }));
-  return packageIdentityPromise;
-}
+const PACKAGE_IDENTITY: PackageIdentity = {
+  identifier: packageManifest.name,
+  version: packageManifest.version,
+};
 
 /** Envelope stored as JSON bytes in cacache for every key. */
 export interface MetadataCacheRecord<T> {
@@ -247,7 +243,7 @@ async function resolveCacheDir(options: {
   readonly version?: string;
 }): Promise<string> {
   if (options.cacheDir) return options.cacheDir;
-  const version = options.version ?? (await packageIdentity()).version;
+  const version = options.version ?? PACKAGE_IDENTITY.version;
   return defaultMetadataCacheDir(version);
 }
 
@@ -319,4 +315,3 @@ function isCacheMiss(error: unknown): boolean {
     (error as { code?: string }).code === "ENOENT",
   );
 }
-

package/src/metadata.ts

@@ -11,12 +11,10 @@
  * @module
  */
 import * as functionUtils from "@dbx-tools/shared-core/function-utils";
-import * as log from "@dbx-tools/shared-core/log";
 import type {
   ModelCapabilities,
   ModelMetadata,
   ModelRateLimits,
-  ModelStatus,
   ServingEndpointSummary,
 } from "@dbx-tools/shared-model/contracts";
 
@@ -31,7 +29,6 @@ import {
   type ModelCapabilityCatalogue,
   type ModelRateLimitsSnapshot,
   type ReasoningModelsSnapshot,
-  type RetiredModelsSnapshot,
 } from "./_metadata-contract.ts";
 import {
   parseModelCapabilities,
@@ -39,17 +36,22 @@ import {
   parseReasoningModels,
   parseRetiredModels,
 } from "./_metadata-generator.ts";
+import {
+  COMMITTED_RETIRED_MODELS,
+  modelStatusFor,
+  replaceRetiredModelNames,
+  RETIRED_MODELS_GENERATED_AT,
+} from "./_retirement.ts";
+import capabilitiesSnapshotJson from "./generated/model-capabilities.json" with { type: "json" };
+import rateLimitsSnapshotJson from "./generated/model-rate-limits.json" with { type: "json" };
+import reasoningSnapshotJson from "./generated/model-reasoning.json" with { type: "json" };
 import {
   createMetadataCache,
   mergePreferFreshList,
   mergePreferFreshRecord,
   type MetadataCache,
 } from "./metadata-cache.ts";
-import capabilitiesSnapshotJson from "./generated/model-capabilities.json" with { type: "json" };
-import rateLimitsSnapshotJson from "./generated/model-rate-limits.json" with { type: "json" };
-import reasoningSnapshotJson from "./generated/model-reasoning.json" with { type: "json" };
-import retiredModelsSnapshotJson from "./generated/retired-models.json" with { type: "json" };
-import { modelSearchQuery } from "./policy.ts";
+import { inheritsNativeWebSearch, isFoundationModelIdentity, modelSearchQuery } from "./policy.ts";
 import {
   defaultReasoningLevels,
   documentedReasoningLevels,
@@ -69,16 +71,11 @@ export {
   WEB_SEARCH_MODELS_URL,
 };
 
-const logger = log.logger("model/metadata");
-
-const retiredModelsSnapshot = retiredModelsSnapshotJson as RetiredModelsSnapshot;
 const capabilitiesSnapshot = capabilitiesSnapshotJson as ModelCapabilitiesSnapshot;
 const rateLimitsSnapshot = rateLimitsSnapshotJson as ModelRateLimitsSnapshot;
 const reasoningSnapshot = reasoningSnapshotJson as ReasoningModelsSnapshot;
 
 interface MetadataIndex {
-  readonly retiredNames: readonly string[];
-  readonly retiredKeys: ReadonlySet<string>;
   readonly capabilities: {
     readonly [Key in keyof ModelCapabilityCatalogue]: ReadonlySet<string>;
   };
@@ -93,7 +90,7 @@ const USER_AGENT = "dbx-tools-model-metadata/1";
 
 const retiredCache = createMetadataCache<readonly string[]>({
   key: "retired-models",
-  fallback: retiredModelsSnapshot.models,
+  fallback: COMMITTED_RETIRED_MODELS,
   load: async () => parseRetiredModels(await loadPage(RETIRED_MODELS_URL), nowSeconds()).models,
   merge: mergePreferFreshList,
 });
@@ -148,7 +145,9 @@ const reasoningDocsCache = createMetadataCache<Readonly<Record<string, readonly
   merge: mergePreferFreshRecord,
 });
 
-const learnedReasoningCache = createMetadataCache<Readonly<Record<string, readonly ReasoningLevel[]>>>({
+const learnedReasoningCache = createMetadataCache<
+  Readonly<Record<string, readonly ReasoningLevel[]>>
+>({
   key: "learned-reasoning",
   fallback: {},
   merge: mergePreferFreshRecord,
@@ -156,11 +155,13 @@ const learnedReasoningCache = createMetadataCache<Readonly<Record<string, readon
 
 let liveIndex: MetadataIndex | undefined;
 
-const metadataIndex = functionUtils.memoize<MetadataIndex>(() => liveIndex ?? buildIndexFromCommitted());
+const metadataIndex = functionUtils.memoize<MetadataIndex>(
+  () => liveIndex ?? buildIndexFromCommitted(),
+);
 
 function buildIndexFromCommitted(): MetadataIndex {
   return buildIndex({
-    retiredNames: retiredModelsSnapshot.models,
+    retiredNames: COMMITTED_RETIRED_MODELS,
     capabilities: capabilitiesSnapshot.capabilities,
     rateLimits: rateLimitsSnapshot.catalogue.models,
     reasoning: reasoningSnapshot.catalogue.models,
@@ -175,9 +176,8 @@ function buildIndex(input: {
   readonly reasoning: Readonly<Record<string, readonly string[]>>;
   readonly learnedReasoning: Readonly<Record<string, readonly ReasoningLevel[]>>;
 }): MetadataIndex {
+  replaceRetiredModelNames(input.retiredNames);
   return {
-    retiredNames: Object.freeze([...input.retiredNames]),
-    retiredKeys: new Set(input.retiredNames.map(retiredModelKey).filter(Boolean)),
     capabilities: {
       responses: new Set(input.capabilities.responses),
       imageInput: new Set(input.capabilities.imageInput),
@@ -228,13 +228,15 @@ let refreshInflight: Promise<MetadataIndex> | undefined;
 export async function refreshModelMetadata(): Promise<MetadataIndex> {
   if (refreshInflight) return refreshInflight;
   refreshInflight = (async () => {
-    const [retiredNames, capabilities, rateLimits, reasoning, learnedReasoning] = await Promise.all([
-      retiredCache.get(),
-      capabilitiesCache.get(),
-      rateLimitsCache.get(),
-      reasoningDocsCache.get(),
-      learnedReasoningCache.get(),
-    ]);
+    const [retiredNames, capabilities, rateLimits, reasoning, learnedReasoning] = await Promise.all(
+      [
+        retiredCache.get(),
+        capabilitiesCache.get(),
+        rateLimitsCache.get(),
+        reasoningDocsCache.get(),
+        learnedReasoningCache.get(),
+      ],
+    );
     liveIndex = buildIndex({
       retiredNames,
       capabilities,
@@ -249,14 +251,10 @@ export async function refreshModelMetadata(): Promise<MetadataIndex> {
   return refreshInflight;
 }
 
-void hydrateModelMetadata().catch((error) => {
-  logger.warn("metadata cache hydrate failed; using committed snapshots", { error });
-});
-
 /** Load cacache / memory entries without forcing a network refresh. */
 export async function hydrateModelMetadata(): Promise<MetadataIndex> {
   const [retiredNames, capabilities, rateLimits, reasoning, learnedReasoning] = await Promise.all([
-    peekOrFallback(retiredCache, retiredModelsSnapshot.models),
+    peekOrFallback(retiredCache, COMMITTED_RETIRED_MODELS),
     peekOrFallback(capabilitiesCache, capabilitiesSnapshot.capabilities),
     peekOrFallback(rateLimitsCache, rateLimitsSnapshot.catalogue.models),
     peekOrFallback(reasoningDocsCache, reasoningSnapshot.catalogue.models),
@@ -283,10 +281,7 @@ export function modelMetadataCachePath(): string {
   return retiredCache.path;
 }
 
-/** Return the committed retired-model names. The array is cached and immutable. */
-export function retiredModelNames(): readonly string[] {
-  return metadataIndex().retiredNames;
-}
+export { modelStatusFor, retiredModelNames } from "./_retirement.ts";
 
 /** Return the committed reasoning-effort catalogue. Cached per process. */
 export function reasoningModelCatalogue(): ReasoningModelCatalogue {
@@ -338,32 +333,23 @@ export async function learnReasoningLevelsFromError(
   return rememberReasoningLevels(model, parseReasoningLevels(body));
 }
 
-/** Resolve whether any supplied identity is listed in the retirement snapshot. */
-export function modelStatusFor(
-  ...models: readonly (string | ServingEndpointSummary)[]
-): ModelStatus {
-  const retired = metadataIndex().retiredKeys;
-  const deprecated = models
-    .flatMap((model) => modelIdentities(model))
-    .some((identity) => {
-      const candidate = retiredModelKey(identity);
-      for (const key of retired) {
-        if (candidate === key || candidate.startsWith(`${key}-`)) return true;
-      }
-      return false;
-    });
-  return { deprecated };
-}
-
 /** Resolve documented model capabilities from a name or endpoint summary. */
 export function modelCapabilitiesFor(model: string | ServingEndpointSummary): ModelCapabilities {
   const capabilities = metadataIndex().capabilities;
-  const keys = modelIdentities(model, false).flatMap((identity) => modelKey(identity) ?? []);
+  const identities = modelIdentities(model, false);
+  const keys = identities.flatMap((identity) => modelKey(identity) ?? []);
   return {
     responses: keys.some((key) => capabilities.responses.has(key)),
     imageInput: keys.some((key) => capabilities.imageInput.has(key)),
     applyPatch: keys.some((key) => capabilities.applyPatch.has(key)),
-    webSearch: keys.some((key) => capabilities.webSearch.has(key)),
+    // Version inheritance only applies to hosted foundation identities.
+    webSearch:
+      keys.some((key) => capabilities.webSearch.has(key)) ||
+      identities.some(
+        (identity) =>
+          isFoundationModelIdentity(identity) &&
+          inheritsNativeWebSearch(identity, capabilities.webSearch),
+      ),
   };
 }
 
@@ -388,9 +374,7 @@ export function modelRateLimitsFor(
  * Does not parse error bodies; callers should use {@link parseReasoningLevels}
  * and then {@link rememberReasoningLevels}.
  */
-export function modelReasoningLevelsFor(
-  model: string | ServingEndpointSummary,
-): ReasoningLevel[] {
+export function modelReasoningLevelsFor(model: string | ServingEndpointSummary): ReasoningLevel[] {
   const index = metadataIndex();
   for (const identity of modelIdentities(model)) {
     const learned = documentedReasoningLevels(identity, index.learnedReasoning);
@@ -400,8 +384,7 @@ export function modelReasoningLevelsFor(
     const documented = documentedReasoningLevels(identity, index.reasoning);
     if (documented?.length) return documented;
   }
-  const primary =
-    typeof model === "string" ? model : (model.modelServiceName ?? model.name);
+  const primary = typeof model === "string" ? model : (model.modelServiceName ?? model.name);
   return defaultReasoningLevels(primary);
 }
 
@@ -423,7 +406,7 @@ export function modelMetadataGeneratedAt(): Readonly<{
   reasoning: number;
 }> {
   return {
-    retiredModels: retiredModelsSnapshot.generatedAt,
+    retiredModels: RETIRED_MODELS_GENERATED_AT,
     capabilities: capabilitiesSnapshot.generatedAt,
     rateLimits: rateLimitsSnapshot.generatedAt,
     reasoning: reasoningSnapshot.generatedAt,
@@ -447,23 +430,6 @@ function modelKey(value: string): string | undefined {
   return modelSearchQuery(value)?.replaceAll(" ", "-");
 }
 
-const RETIRED_MODEL_PREFIXES = new Set([
-  "ai",
-  "anthropic",
-  "databricks",
-  "dbx",
-  "google",
-  "meta",
-  "openai",
-  "system",
-]);
-
-function retiredModelKey(value: string): string {
-  const tokens = value.toLowerCase().match(/[a-z0-9]+/g) ?? [];
-  while (tokens[0] && RETIRED_MODEL_PREFIXES.has(tokens[0])) tokens.shift();
-  return tokens.join("-");
-}
-
 async function loadPage(url: string): Promise<string> {
   const response = await fetch(url, {
     headers: { "user-agent": USER_AGENT },

package/src/model-client.ts

@@ -3,16 +3,17 @@
  *
  * This is the portable entry point used by generated Python bindings. It keeps
  * authentication, endpoint discovery, caching, normalization, ranking, route
- * selection, and published metadata in Node while exposing one small client.
+ * selection, route construction, and published metadata in Node while exposing
+ * one small client.
  *
  * @module
  */
 import {
-  client as authClient,
-  profile as authProfile,
+  createAuthClient,
   type AuthClient,
   type DatabricksAuthDependencies,
-} from "@dbx-tools/auth";
+} from "@dbx-tools/auth/client";
+import { listProfiles as listAuthProfiles } from "@dbx-tools/auth/profile";
 import type { DatabricksProfileSummary } from "@dbx-tools/shared-auth";
 import * as log from "@dbx-tools/shared-core/log";
 import * as object from "@dbx-tools/shared-core/object";
@@ -29,7 +30,7 @@ import {
 import { normalizeEndpoints } from "./_ranking.ts";
 import { lookupModels, resolveModel } from "./_selection.ts";
 import { chatCompletionsUrl, invocationsUrl, responsesUpstreamUrl } from "./invoke.ts";
-import { modelMetadataFor } from "./metadata.ts";
+import { hydrateModelMetadata, modelMetadataFor } from "./metadata.ts";
 import { modelServingApi } from "./policy.ts";
 
 const logger = log.logger("model/client");
@@ -49,6 +50,8 @@ export interface ModelClientOptions {
   auth?: ModelAuthOptions;
   /** In-memory endpoint catalogue TTL in milliseconds. */
   cacheTtlMs?: number;
+  /** Hydrate Node-only metadata caches before constructing the client. */
+  hydrateMetadata?: boolean;
 }
 
 /** Secret-free runtime identity and cache configuration. */
@@ -246,15 +249,16 @@ class DefaultModelClient implements ModelClient {
 /** Create an authentication-aware Databricks model client. */
 export async function createModelClient(options: ModelClientOptions = {}): Promise<ModelClient> {
   const cacheTtlMs = validateCacheTtl(options.cacheTtlMs);
+  if (options.hydrateMetadata ?? true) await hydrateModelMetadata();
   return new DefaultModelClient(
-    new AuthenticatedModelClient(await authClient.createAuthClient(options.auth), globalThis.fetch),
+    new AuthenticatedModelClient(await createAuthClient(options.auth), globalThis.fetch),
     cacheTtlMs,
   );
 }
 
 /** List configured Databricks profiles outside the model client facade. */
 export function listProfiles(refresh = false): DatabricksProfileSummary[] {
-  return authProfile.listProfiles({ refresh });
+  return listAuthProfiles({ refresh });
 }
 
 /** @internal Construct a model client around a test or host-owned Databricks client. */
@@ -270,9 +274,10 @@ export async function createModelClientWithDependencies(
   options: ModelClientOptions,
   dependencies: DatabricksAuthDependencies,
 ): Promise<ModelClient> {
+  if (options.hydrateMetadata ?? true) await hydrateModelMetadata();
   return new DefaultModelClient(
     new AuthenticatedModelClient(
-      await authClient.createAuthClient(options.auth, dependencies),
+      await createAuthClient(options.auth, dependencies),
       dependencies.fetch ?? globalThis.fetch,
     ),
     validateCacheTtl(options.cacheTtlMs),

package/src/policy.ts

@@ -6,7 +6,7 @@ import {
   type ServingEndpointSummary,
 } from "@dbx-tools/shared-model/contracts";
 
-import { supportsToolsByFamily } from "./classify.ts";
+import { compareVersionTuples, supportsToolsByFamily, versionTuple } from "./classify.ts";
 
 const FAMILIES = [
   "claude",
@@ -54,6 +54,50 @@ export function modelSearchQuery(name: string): string | undefined {
   return [parsed.family, ...parsed.version.map(String), ...parsed.model].join(" ");
 }
 
+/**
+ * Return whether `name` has native web search: an exact documented identity, or
+ * a later {@link versionTuple} in the same family as a documented native
+ * web-search model. Intra-family floors use the name digit parser so identities
+ * like `databricks-claude-opus-4-8` and `system.ai.gpt-6-1-sol` compare.
+ * Hosted GPT-OSS weights never inherit.
+ */
+export function inheritsNativeWebSearch(name: string, documented: Iterable<string>): boolean {
+  const documentedKeys = documented instanceof Set ? documented : new Set(documented);
+  const key = modelSearchQuery(name)?.replaceAll(" ", "-");
+  if (key && documentedKeys.has(key)) return true;
+  const family = modelFamily(name);
+  if (!family || isOpenWeightsGpt(name)) return false;
+  const version = versionTuple(name);
+  if (isZeroVersion(version)) return false;
+  let floor: readonly number[] | undefined;
+  for (const entry of documentedKeys) {
+    if (modelFamily(entry) !== family || isOpenWeightsGpt(entry)) continue;
+    const documentedVersion = versionTuple(entry);
+    if (isZeroVersion(documentedVersion)) continue;
+    if (!floor || compareVersionTuples(documentedVersion, floor) < 0) {
+      floor = documentedVersion;
+    }
+  }
+  return floor !== undefined && compareVersionTuples(version, floor) >= 0;
+}
+
+/**
+ * Return whether an identity names a Databricks-hosted foundation model
+ * (`databricks-*` endpoint or `system.ai.*` model service). Custom and
+ * external endpoints use arbitrary names, so their digits are not versions.
+ */
+export function isFoundationModelIdentity(name: string): boolean {
+  return /^(?:databricks-|system\.ai\.)/i.test(name.trim());
+}
+
+function isOpenWeightsGpt(name: string): boolean {
+  return modelFamily(name) === "gpt" && /(?:^|[-_.])oss(?:[-_.]|$)/i.test(name);
+}
+
+function isZeroVersion(version: readonly number[]): boolean {
+  return version.every((part) => (part ?? 0) === 0);
+}
+
 /** Return the reasoning efforts accepted by a model family. */
 export function modelReasoningEfforts(name: string): ReasoningEffort[] {
   const normalized = name.toLowerCase();

package/src/reasoning-translation.ts

@@ -129,9 +129,10 @@ interface AliasDocument {
   readonly level: ReasoningLevel;
 }
 
-const aliasDocuments: readonly AliasDocument[] = Object.entries(ALIASES).map(
-  ([token, level]) => ({ token, level }),
-);
+const aliasDocuments: readonly AliasDocument[] = Object.entries(ALIASES).map(([token, level]) => ({
+  token,
+  level,
+}));
 
 const aliasFuse = new Fuse(aliasDocuments, {
   keys: ["token"],
@@ -384,7 +385,9 @@ export function adaptRequestReasoning(
     }
   }
 
-  return changed ? { body: next, changed: true, wireEffort: wire } : { body, changed: false, wireEffort: wire };
+  return changed
+    ? { body: next, changed: true, wireEffort: wire }
+    : { body, changed: false, wireEffort: wire };
 }
 
 /** Normalize labels for alias lookup (`Extra High` → `extra-high`). */