@lorion-org/provider-selection 1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the 'Software'), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,173 @@
+# @lorion-org/provider-selection
+
+`@lorion-org/provider-selection` is a small framework-free core for selecting one
+provider per capability from multiple candidates.
+
+It solves four things:
+
+- collect provider candidates by capability
+- optionally collect and resolve in one call
+- pick one provider with configured and fallback preferences
+- report misconfigured provider selections
+- return excluded providers that lost the selection
+
+Selection order is always:
+
+1. configured provider
+2. fallback provider
+3. first provider in deterministic sort order
+
+If a configured provider is set but not present among the candidates, the package
+does not silently fall back. It reports a mismatch and leaves that capability
+unselected.
+
+Example files in this repository:
+
+- `examples/command-handlers.ts`
+- `examples/storage-drivers.ts`
+
+It does not know anything about:
+
+- framework runtime config
+- feature manifests
+- plugins
+- filesystems
+- application-specific contract names
+
+## Install
+
+```shell
+pnpm add @lorion-org/provider-selection
+```
+
+## Example
+
+```ts
+import { resolveItemProviderSelection } from '@lorion-org/provider-selection';
+
+const result = resolveItemProviderSelection({
+  items: [
+    { capability: 'auth', providerId: 'keycloak' },
+    { capability: 'auth', providerId: 'auth-local-jwt' },
+    { capability: 'mailer', providerId: 'mailer-postmark' },
+  ],
+  getCapabilityId: (item) => item.capability,
+  getProviderId: (item) => item.providerId,
+  configuredProviders: {
+    auth: 'keycloak',
+  },
+  fallbackProviders: {
+    mailer: 'mailer-postmark',
+  },
+});
+
+result.selections;
+result.providersByCapability;
+result.mismatches;
+result.excludedProviderIds;
+```
+
+If you already have a `Map<capability, providers>`, use the lower-level
+resolver directly:
+
+```ts
+import { resolveProviderSelection } from '@lorion-org/provider-selection';
+
+const result = resolveProviderSelection({
+  providersByCapability: new Map([['auth', ['auth-local-jwt', 'keycloak']]]),
+  configuredProviders: {
+    auth: 'missing-provider',
+  },
+});
+
+result.selections;
+result.mismatches;
+// => [{ capabilityId: 'auth', configuredProviderId: 'missing-provider' }]
+```
+
+## Example: command handlers
+
+```ts
+import { resolveItemProviderSelection } from '@lorion-org/provider-selection';
+
+const result = resolveItemProviderSelection({
+  items: [
+    { commandId: 'open', handlerId: 'open-native' },
+    { commandId: 'open', handlerId: 'open-web' },
+    { commandId: 'share', handlerId: 'share-link' },
+  ],
+  getCapabilityId: (item) => item.commandId,
+  getProviderId: (item) => item.handlerId,
+  configuredProviders: {
+    open: 'open-web',
+  },
+});
+```
+
+## Example: storage drivers
+
+```ts
+import { resolveItemProviderSelection } from '@lorion-org/provider-selection';
+
+const result = resolveItemProviderSelection({
+  items: [
+    { storageKind: 'blob', driverId: 's3' },
+    { storageKind: 'blob', driverId: 'filesystem' },
+    { storageKind: 'queue', driverId: 'redis-streams' },
+  ],
+  getCapabilityId: (item) => item.storageKind,
+  getProviderId: (item) => item.driverId,
+  fallbackProviders: {
+    blob: 'filesystem',
+  },
+});
+```
+
+## API
+
+```ts
+type CapabilityId = string;
+type ProviderId = string;
+type ProviderSelectionMode = 'configured' | 'fallback' | 'first';
+type ProviderPreferenceMap = Partial<Record<CapabilityId, ProviderId>>;
+type ProvidersByCapability = Map<CapabilityId, ProviderId[]>;
+
+type ProviderSelection = {
+  capabilityId: CapabilityId;
+  selectedProviderId: ProviderId;
+  candidateProviderIds: ProviderId[];
+  mode: ProviderSelectionMode;
+};
+
+type ProviderMismatch = {
+  capabilityId: CapabilityId;
+  configuredProviderId: ProviderId;
+};
+
+type ProviderSelectionResolution = {
+  selections: Map<CapabilityId, ProviderSelection>;
+  mismatches: ProviderMismatch[];
+  excludedProviderIds: ProviderId[];
+};
+
+type ItemProviderSelectionResolution = ProviderSelectionResolution & {
+  providersByCapability: ProvidersByCapability;
+};
+```
+
+The package exposes:
+
+- `collectProvidersByCapability()`
+- `resolveItemProviderSelection()`
+- `resolveProviderSelection()`
+
+## Local commands
+
+```shell
+cd packages/provider-selection
+pnpm build
+pnpm test
+pnpm coverage
+pnpm typecheck
+pnpm package:check
+```

package/dist/index.cjs

@@ -0,0 +1,161 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  collectProvidersByCapability: () => collectProvidersByCapability,
+  resolveItemProviderSelection: () => resolveItemProviderSelection,
+  resolveProviderSelection: () => resolveProviderSelection
+});
+module.exports = __toCommonJS(index_exports);
+function toSortedUniqueProviderIds(providerIds) {
+  return Array.from(new Set(Array.from(providerIds).filter(Boolean))).sort();
+}
+function getSelectedProvider(input) {
+  const firstProviderId = input.candidateProviderIds[0];
+  if (!firstProviderId) {
+    return void 0;
+  }
+  const configuredProviderId = input.configuredProviders?.[input.capabilityId];
+  if (configuredProviderId) {
+    if (input.candidateProviderIds.includes(configuredProviderId)) {
+      return {
+        selectedProviderId: configuredProviderId,
+        mode: "configured"
+      };
+    }
+    return void 0;
+  }
+  const fallbackProviderId = input.fallbackProviders?.[input.capabilityId];
+  if (fallbackProviderId && input.candidateProviderIds.includes(fallbackProviderId)) {
+    return {
+      selectedProviderId: fallbackProviderId,
+      mode: "fallback"
+    };
+  }
+  return {
+    selectedProviderId: firstProviderId,
+    mode: "first"
+  };
+}
+function selectProviders(input) {
+  const selections = /* @__PURE__ */ new Map();
+  for (const [capabilityId, candidateProviderIds] of Array.from(
+    input.providersByCapability.entries()
+  ).sort(([left], [right]) => left.localeCompare(right))) {
+    const normalizedCandidateProviderIds = toSortedUniqueProviderIds(candidateProviderIds);
+    const selected = getSelectedProvider({
+      capabilityId,
+      candidateProviderIds: normalizedCandidateProviderIds,
+      ...input.configuredProviders ? { configuredProviders: input.configuredProviders } : {},
+      ...input.fallbackProviders ? { fallbackProviders: input.fallbackProviders } : {}
+    });
+    if (!selected) {
+      continue;
+    }
+    selections.set(capabilityId, {
+      capabilityId,
+      selectedProviderId: selected.selectedProviderId,
+      candidateProviderIds: normalizedCandidateProviderIds,
+      mode: selected.mode
+    });
+  }
+  return selections;
+}
+function findConfiguredProviderMismatches(input) {
+  const mismatches = [];
+  for (const [capabilityId, configuredProviderId] of Object.entries(
+    input.configuredProviders ?? {}
+  ).sort(([left], [right]) => left.localeCompare(right))) {
+    if (!configuredProviderId) {
+      continue;
+    }
+    const candidateProviderIds = toSortedUniqueProviderIds(
+      input.providersByCapability.get(capabilityId) ?? []
+    );
+    if (!candidateProviderIds.length) {
+      continue;
+    }
+    if (candidateProviderIds.includes(configuredProviderId)) {
+      continue;
+    }
+    mismatches.push({
+      capabilityId,
+      configuredProviderId
+    });
+  }
+  return mismatches;
+}
+function getExcludedProviders(selections) {
+  const excludedProviderIds = [];
+  for (const selection of selections) {
+    if (selection.candidateProviderIds.length <= 1) {
+      continue;
+    }
+    for (const candidateProviderId of selection.candidateProviderIds) {
+      if (candidateProviderId !== selection.selectedProviderId) {
+        excludedProviderIds.push(candidateProviderId);
+      }
+    }
+  }
+  return toSortedUniqueProviderIds(excludedProviderIds);
+}
+function collectProvidersByCapability(input) {
+  const providersByCapability = /* @__PURE__ */ new Map();
+  for (const item of input.items) {
+    const capabilityId = input.getCapabilityId(item);
+    if (!capabilityId) {
+      continue;
+    }
+    const providerId = input.getProviderId(item);
+    const currentProviderIds = providersByCapability.get(capabilityId) ?? [];
+    currentProviderIds.push(providerId);
+    providersByCapability.set(capabilityId, toSortedUniqueProviderIds(currentProviderIds));
+  }
+  return providersByCapability;
+}
+function resolveProviderSelection(input) {
+  const selections = selectProviders(input);
+  const mismatches = findConfiguredProviderMismatches(input);
+  const excludedProviderIds = getExcludedProviders(selections.values());
+  return {
+    selections,
+    mismatches,
+    excludedProviderIds
+  };
+}
+function resolveItemProviderSelection(input) {
+  const providersByCapability = collectProvidersByCapability(input);
+  const resolution = resolveProviderSelection({
+    providersByCapability,
+    ...input.configuredProviders ? { configuredProviders: input.configuredProviders } : {},
+    ...input.fallbackProviders ? { fallbackProviders: input.fallbackProviders } : {}
+  });
+  return {
+    providersByCapability,
+    ...resolution
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectProvidersByCapability,
+  resolveItemProviderSelection,
+  resolveProviderSelection
+});

package/dist/index.d.cts

@@ -0,0 +1,42 @@
+type CapabilityId = string;
+type ProviderId = string;
+type ProviderSelectionMode = 'configured' | 'fallback' | 'first';
+type ProviderPreferenceMap = Partial<Record<CapabilityId, ProviderId>>;
+type ProviderSelection = {
+    capabilityId: CapabilityId;
+    selectedProviderId: ProviderId;
+    candidateProviderIds: ProviderId[];
+    mode: ProviderSelectionMode;
+};
+type ProviderMismatch = {
+    capabilityId: CapabilityId;
+    configuredProviderId: ProviderId;
+};
+type ProvidersByCapability = Map<CapabilityId, ProviderId[]>;
+type ProviderSelectionResolution = {
+    selections: Map<CapabilityId, ProviderSelection>;
+    mismatches: ProviderMismatch[];
+    excludedProviderIds: ProviderId[];
+};
+type ItemProviderSelectionResolution = ProviderSelectionResolution & {
+    providersByCapability: ProvidersByCapability;
+};
+type ProviderCollectionInput<T> = {
+    items: Iterable<T>;
+    getCapabilityId: (item: T) => CapabilityId | undefined;
+    getProviderId: (item: T) => ProviderId;
+};
+type ResolveProviderSelectionInput = {
+    providersByCapability: ProvidersByCapability;
+    configuredProviders?: ProviderPreferenceMap;
+    fallbackProviders?: ProviderPreferenceMap;
+};
+type ResolveItemProviderSelectionInput<T> = ProviderCollectionInput<T> & {
+    configuredProviders?: ProviderPreferenceMap;
+    fallbackProviders?: ProviderPreferenceMap;
+};
+declare function collectProvidersByCapability<T>(input: ProviderCollectionInput<T>): ProvidersByCapability;
+declare function resolveProviderSelection(input: ResolveProviderSelectionInput): ProviderSelectionResolution;
+declare function resolveItemProviderSelection<T>(input: ResolveItemProviderSelectionInput<T>): ItemProviderSelectionResolution;
+
+export { type CapabilityId, type ItemProviderSelectionResolution, type ProviderId, type ProviderMismatch, type ProviderPreferenceMap, type ProviderSelection, type ProviderSelectionMode, type ProviderSelectionResolution, type ProvidersByCapability, type ResolveItemProviderSelectionInput, type ResolveProviderSelectionInput, collectProvidersByCapability, resolveItemProviderSelection, resolveProviderSelection };

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+type CapabilityId = string;
+type ProviderId = string;
+type ProviderSelectionMode = 'configured' | 'fallback' | 'first';
+type ProviderPreferenceMap = Partial<Record<CapabilityId, ProviderId>>;
+type ProviderSelection = {
+    capabilityId: CapabilityId;
+    selectedProviderId: ProviderId;
+    candidateProviderIds: ProviderId[];
+    mode: ProviderSelectionMode;
+};
+type ProviderMismatch = {
+    capabilityId: CapabilityId;
+    configuredProviderId: ProviderId;
+};
+type ProvidersByCapability = Map<CapabilityId, ProviderId[]>;
+type ProviderSelectionResolution = {
+    selections: Map<CapabilityId, ProviderSelection>;
+    mismatches: ProviderMismatch[];
+    excludedProviderIds: ProviderId[];
+};
+type ItemProviderSelectionResolution = ProviderSelectionResolution & {
+    providersByCapability: ProvidersByCapability;
+};
+type ProviderCollectionInput<T> = {
+    items: Iterable<T>;
+    getCapabilityId: (item: T) => CapabilityId | undefined;
+    getProviderId: (item: T) => ProviderId;
+};
+type ResolveProviderSelectionInput = {
+    providersByCapability: ProvidersByCapability;
+    configuredProviders?: ProviderPreferenceMap;
+    fallbackProviders?: ProviderPreferenceMap;
+};
+type ResolveItemProviderSelectionInput<T> = ProviderCollectionInput<T> & {
+    configuredProviders?: ProviderPreferenceMap;
+    fallbackProviders?: ProviderPreferenceMap;
+};
+declare function collectProvidersByCapability<T>(input: ProviderCollectionInput<T>): ProvidersByCapability;
+declare function resolveProviderSelection(input: ResolveProviderSelectionInput): ProviderSelectionResolution;
+declare function resolveItemProviderSelection<T>(input: ResolveItemProviderSelectionInput<T>): ItemProviderSelectionResolution;
+
+export { type CapabilityId, type ItemProviderSelectionResolution, type ProviderId, type ProviderMismatch, type ProviderPreferenceMap, type ProviderSelection, type ProviderSelectionMode, type ProviderSelectionResolution, type ProvidersByCapability, type ResolveItemProviderSelectionInput, type ResolveProviderSelectionInput, collectProvidersByCapability, resolveItemProviderSelection, resolveProviderSelection };

package/dist/index.js

@@ -0,0 +1,134 @@
+// src/index.ts
+function toSortedUniqueProviderIds(providerIds) {
+  return Array.from(new Set(Array.from(providerIds).filter(Boolean))).sort();
+}
+function getSelectedProvider(input) {
+  const firstProviderId = input.candidateProviderIds[0];
+  if (!firstProviderId) {
+    return void 0;
+  }
+  const configuredProviderId = input.configuredProviders?.[input.capabilityId];
+  if (configuredProviderId) {
+    if (input.candidateProviderIds.includes(configuredProviderId)) {
+      return {
+        selectedProviderId: configuredProviderId,
+        mode: "configured"
+      };
+    }
+    return void 0;
+  }
+  const fallbackProviderId = input.fallbackProviders?.[input.capabilityId];
+  if (fallbackProviderId && input.candidateProviderIds.includes(fallbackProviderId)) {
+    return {
+      selectedProviderId: fallbackProviderId,
+      mode: "fallback"
+    };
+  }
+  return {
+    selectedProviderId: firstProviderId,
+    mode: "first"
+  };
+}
+function selectProviders(input) {
+  const selections = /* @__PURE__ */ new Map();
+  for (const [capabilityId, candidateProviderIds] of Array.from(
+    input.providersByCapability.entries()
+  ).sort(([left], [right]) => left.localeCompare(right))) {
+    const normalizedCandidateProviderIds = toSortedUniqueProviderIds(candidateProviderIds);
+    const selected = getSelectedProvider({
+      capabilityId,
+      candidateProviderIds: normalizedCandidateProviderIds,
+      ...input.configuredProviders ? { configuredProviders: input.configuredProviders } : {},
+      ...input.fallbackProviders ? { fallbackProviders: input.fallbackProviders } : {}
+    });
+    if (!selected) {
+      continue;
+    }
+    selections.set(capabilityId, {
+      capabilityId,
+      selectedProviderId: selected.selectedProviderId,
+      candidateProviderIds: normalizedCandidateProviderIds,
+      mode: selected.mode
+    });
+  }
+  return selections;
+}
+function findConfiguredProviderMismatches(input) {
+  const mismatches = [];
+  for (const [capabilityId, configuredProviderId] of Object.entries(
+    input.configuredProviders ?? {}
+  ).sort(([left], [right]) => left.localeCompare(right))) {
+    if (!configuredProviderId) {
+      continue;
+    }
+    const candidateProviderIds = toSortedUniqueProviderIds(
+      input.providersByCapability.get(capabilityId) ?? []
+    );
+    if (!candidateProviderIds.length) {
+      continue;
+    }
+    if (candidateProviderIds.includes(configuredProviderId)) {
+      continue;
+    }
+    mismatches.push({
+      capabilityId,
+      configuredProviderId
+    });
+  }
+  return mismatches;
+}
+function getExcludedProviders(selections) {
+  const excludedProviderIds = [];
+  for (const selection of selections) {
+    if (selection.candidateProviderIds.length <= 1) {
+      continue;
+    }
+    for (const candidateProviderId of selection.candidateProviderIds) {
+      if (candidateProviderId !== selection.selectedProviderId) {
+        excludedProviderIds.push(candidateProviderId);
+      }
+    }
+  }
+  return toSortedUniqueProviderIds(excludedProviderIds);
+}
+function collectProvidersByCapability(input) {
+  const providersByCapability = /* @__PURE__ */ new Map();
+  for (const item of input.items) {
+    const capabilityId = input.getCapabilityId(item);
+    if (!capabilityId) {
+      continue;
+    }
+    const providerId = input.getProviderId(item);
+    const currentProviderIds = providersByCapability.get(capabilityId) ?? [];
+    currentProviderIds.push(providerId);
+    providersByCapability.set(capabilityId, toSortedUniqueProviderIds(currentProviderIds));
+  }
+  return providersByCapability;
+}
+function resolveProviderSelection(input) {
+  const selections = selectProviders(input);
+  const mismatches = findConfiguredProviderMismatches(input);
+  const excludedProviderIds = getExcludedProviders(selections.values());
+  return {
+    selections,
+    mismatches,
+    excludedProviderIds
+  };
+}
+function resolveItemProviderSelection(input) {
+  const providersByCapability = collectProvidersByCapability(input);
+  const resolution = resolveProviderSelection({
+    providersByCapability,
+    ...input.configuredProviders ? { configuredProviders: input.configuredProviders } : {},
+    ...input.fallbackProviders ? { fallbackProviders: input.fallbackProviders } : {}
+  });
+  return {
+    providersByCapability,
+    ...resolution
+  };
+}
+export {
+  collectProvidersByCapability,
+  resolveItemProviderSelection,
+  resolveProviderSelection
+};

package/examples/command-handlers.ts

@@ -0,0 +1,45 @@
+import { resolveItemProviderSelection } from '@lorion-org/provider-selection';
+
+type CommandHandler = {
+  commandId: string;
+  handlerId: string;
+};
+
+const handlers: CommandHandler[] = [
+  {
+    commandId: 'open',
+    handlerId: 'open-native',
+  },
+  {
+    commandId: 'open',
+    handlerId: 'open-web',
+  },
+  {
+    commandId: 'share',
+    handlerId: 'share-link',
+  },
+];
+
+const result = resolveItemProviderSelection({
+  items: handlers,
+  getCapabilityId: (handler) => handler.commandId,
+  getProviderId: (handler) => handler.handlerId,
+  configuredProviders: {
+    open: 'open-web',
+  },
+});
+
+console.log(result.providersByCapability);
+// { open: ['open-native', 'open-web'], share: ['share-link'] }
+
+console.log(result.selections);
+// {
+//   open: { selectedProviderId: 'open-web', mode: 'configured' },
+//   share: { selectedProviderId: 'share-link', mode: 'first' }
+// }
+
+console.log(result.mismatches);
+// []
+
+console.log(result.excludedProviderIds);
+// ['open-native']

package/examples/storage-drivers.ts

@@ -0,0 +1,39 @@
+import { resolveItemProviderSelection } from '@lorion-org/provider-selection';
+
+type StorageDriver = {
+  storageKind: string;
+  driverId: string;
+};
+
+const drivers: StorageDriver[] = [
+  {
+    storageKind: 'blob',
+    driverId: 's3',
+  },
+  {
+    storageKind: 'blob',
+    driverId: 'filesystem',
+  },
+  {
+    storageKind: 'queue',
+    driverId: 'redis-streams',
+  },
+];
+
+const result = resolveItemProviderSelection({
+  items: drivers,
+  getCapabilityId: (driver) => driver.storageKind,
+  getProviderId: (driver) => driver.driverId,
+  fallbackProviders: {
+    blob: 'filesystem',
+  },
+});
+
+console.log(result.selections);
+// {
+//   blob: { selectedProviderId: 'filesystem', mode: 'fallback' },
+//   queue: { selectedProviderId: 'redis-streams', mode: 'first' }
+// }
+
+console.log(result.mismatches);
+// []

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@lorion-org/provider-selection",
+  "version": "1.0.0-beta.0",
+  "description": "Framework-free capability provider selection primitives.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lorion-org/lorion.git",
+    "directory": "packages/provider-selection"
+  },
+  "homepage": "https://github.com/lorion-org/lorion/tree/main/packages/provider-selection#readme",
+  "bugs": {
+    "url": "https://github.com/lorion-org/lorion/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "examples",
+    "LICENSE"
+  ],
+  "keywords": [
+    "provider",
+    "selection",
+    "capability",
+    "typescript"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "clean": "rimraf coverage dist tsconfig.tsbuildinfo",
+    "lint": "eslint src --ext .ts",
+    "test": "vitest run --root ../.. --config vitest.config.mts packages/provider-selection/src/index.spec.ts",
+    "coverage": "node -e \"require('node:fs').mkdirSync('../../coverage/.tmp', { recursive: true })\" && vitest run --coverage --coverage.include=packages/provider-selection/src/**/*.ts --root ../.. --config vitest.config.mts packages/provider-selection/src/index.spec.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "package:check": "pnpm build && pnpm pack --dry-run && publint"
+  }
+}