@lorion-org/react 1.0.0-beta.1 → 1.0.0-beta.2

package/README.md

@@ -10,6 +10,9 @@ Use this package when a React application is assembled from local capability pac
 pnpm add @lorion-org/react react
 ```
 
+Host configs that import selection helpers from `@lorion-org/composition-graph`
+should declare that package directly too.
+
 Add Vite, TanStack Router, or another router in the host application as needed.
 The runtime helpers do not own routing; the Vite entry point only prepares
 capability discovery and TanStack-compatible virtual route config.
@@ -117,13 +120,10 @@ import { lorionReact } from '@lorion-org/react/vite';
 The Vite helper discovers `capabilities/*/capability.json`, validates the descriptor shape with LORION, resolves selected descriptors through the LORION composition graph, resolves each package `./capability` export, and exposes `virtual:capabilities`.
 
 ```ts
-const capabilityComposition = {
-  selected: ['default'],
-};
 const lorion = lorionReact({
   workspaceRoot,
   routesDirectory,
-  ...capabilityComposition,
+  defaultSelection: ['default'],
 });
 
 export default defineConfig({
@@ -138,32 +138,59 @@ export default defineConfig({
 });
 ```
 
-Route config generation stays TanStack-focused and only includes enabled, selected capability route directories. If no `selected` or `baseDescriptors` are provided, every enabled local capability remains active. Use `indexRouteFile: false` when `/` is owned by a capability route.
+By default the Vite helper reads the shared capability seed from
+`--capabilities`, `npm_config_capabilities`, and `LORION_CAPABILITIES` before it
+falls back to `defaultSelection`. No `selectionSeed.key` option is required for
+that default. Pass `selectionSeed` only to override the seed names, inject custom
+`argv`/`env` for tests, or set `selectionSeed: false` to disable CLI/env lookup.
+
+Route config generation stays TanStack-focused and only includes enabled,
+selected capability route directories. If no `selected`, seed value,
+`defaultSelection`, or `baseDescriptors` are provided, every enabled local
+capability remains active.
+Use `indexRouteFile: false` when `/` is owned by a capability route.
+
+The virtual module exports `capabilityModules`, `selectedCapabilityIds`, and
+`resolvedCapabilityIds` so host code can distinguish the seed from the final
+graph resolution.
 
 ## Provider Selection
 
-Capabilities that implement another capability can declare `providesFor`:
+Capabilities that implement another capability can declare `providesFor`.
+Provider-owned defaults use `defaultFor` on the provider descriptor:
 
 ```json
 {
   "id": "payment-provider-stripe",
   "version": "1.0.0",
-  "providesFor": "payment-checkout"
+  "providesFor": "checkout",
+  "defaultFor": "checkout"
 }
 ```
 
-Any active descriptor can declare preferences with `providerPreferences`:
+`providesFor` and `defaultFor` both accept a string or string array. If a
+capability descriptor exists, `defaultFor` also creates the composition relation
+from that capability to the default provider.
+
+Profiles can still declare descriptor preferences with `providerPreferences`.
+Use this when the profile, not the provider package, owns the default choice:
 
 ```json
 {
   "id": "web",
   "version": "1.0.0",
   "providerPreferences": {
-    "payment-checkout": "payment-provider-stripe"
+    "checkout": "payment-provider-stripe"
   }
 }
 ```
 
+When a provider capability is explicitly selected through the normal selection
+seed, the Vite helper removes lower-priority `defaultFor` and
+`providerPreferences` relations for that capability before graph resolution.
+That selected provider wins over descriptor defaults and preferences. A losing
+provider is only present if another hard dependency still requires it.
+
 Read the resolved provider selection from the runtime:
 
 ```ts
@@ -172,7 +199,16 @@ import { getCapabilityProviderSelection } from '@lorion-org/react';
 const selection = getCapabilityProviderSelection(capabilityRuntime);
 ```
 
-Explicit `configuredProviders` passed to `getCapabilityProviderSelection()` override descriptor preferences. `fallbackProviders` are only used when no configured provider exists.
+Explicit `configuredProviders` passed to `getCapabilityProviderSelection()`
+override selected providers, provider-owned defaults, and descriptor
+preferences. `selectedProviders` can mirror the descriptor seed at runtime, and
+`fallbackProviders` are merged with descriptor defaults and only used when no
+configured or selected provider exists.
+
+The React playground uses the first variant by default: Stripe declares
+`defaultFor: "checkout"` and is selected as the fallback provider. Selecting
+`web payment-provider-invoice` through the seed switches checkout to Invoice and
+leaves Stripe out of the resolved capabilities.
 
 ## API
 
@@ -189,7 +225,12 @@ The package includes a React playground that mirrors the Nuxt package playground
 pnpm --filter @lorion-org/react dev:playground
 ```
 
+The playground scripts run with Lorion's `lorion-source` export condition so
+local workspace package imports resolve to `src` instead of stale `dist` output.
+
 The playground runs on `http://localhost:3200` and uses local demo capabilities under `playground/capabilities`.
+Select a different profile or provider with `--capabilities=admin`,
+`--capabilities=web,payment-provider-invoice`, or `LORION_CAPABILITIES="web payment-provider-invoice"`.
 
 ## Local Commands
 

package/dist/chunk-5FUI4JPB.js

@@ -0,0 +1,38 @@
+// src/relations.ts
+var defaultCapabilityResolutionRelations = [
+  "dependencies",
+  "defaultProviders",
+  "providerPreferences"
+];
+var defaultCapabilityRelationDescriptors = [
+  {
+    direction: "incoming",
+    field: "defaultFor",
+    id: "defaultProviders"
+  },
+  {
+    field: "providerPreferences",
+    id: "providerPreferences",
+    targetMode: "values"
+  }
+];
+function createCapabilityCompositionPolicy(policy) {
+  return {
+    ...policy,
+    inspectionRelationIds: policy?.inspectionRelationIds ?? [
+      ...defaultCapabilityResolutionRelations
+    ],
+    provenanceRelationIds: policy?.provenanceRelationIds ?? [
+      ...defaultCapabilityResolutionRelations
+    ],
+    resolutionRelationIds: policy?.resolutionRelationIds ?? [
+      ...defaultCapabilityResolutionRelations
+    ]
+  };
+}
+
+export {
+  defaultCapabilityResolutionRelations,
+  defaultCapabilityRelationDescriptors,
+  createCapabilityCompositionPolicy
+};

package/dist/index.cjs

@@ -21,8 +21,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   CapabilityRuntimeProvider: () => CapabilityRuntimeProvider,
+  createCapabilityCompositionPolicy: () => createCapabilityCompositionPolicy,
   createCapabilityRuntime: () => createCapabilityRuntime,
   createContributionContract: () => createContributionContract,
+  defaultCapabilityRelationDescriptors: () => defaultCapabilityRelationDescriptors,
+  defaultCapabilityResolutionRelations: () => defaultCapabilityResolutionRelations,
   defineCapability: () => defineCapability,
   defineContribution: () => defineContribution,
   defineExtensionPoint: () => defineExtensionPoint,
@@ -33,6 +36,41 @@ module.exports = __toCommonJS(index_exports);
 var import_react = require("react");
 var import_composition_graph = require("@lorion-org/composition-graph");
 var import_provider_selection = require("@lorion-org/provider-selection");
+
+// src/relations.ts
+var defaultCapabilityResolutionRelations = [
+  "dependencies",
+  "defaultProviders",
+  "providerPreferences"
+];
+var defaultCapabilityRelationDescriptors = [
+  {
+    direction: "incoming",
+    field: "defaultFor",
+    id: "defaultProviders"
+  },
+  {
+    field: "providerPreferences",
+    id: "providerPreferences",
+    targetMode: "values"
+  }
+];
+function createCapabilityCompositionPolicy(policy) {
+  return {
+    ...policy,
+    inspectionRelationIds: policy?.inspectionRelationIds ?? [
+      ...defaultCapabilityResolutionRelations
+    ],
+    provenanceRelationIds: policy?.provenanceRelationIds ?? [
+      ...defaultCapabilityResolutionRelations
+    ],
+    resolutionRelationIds: policy?.resolutionRelationIds ?? [
+      ...defaultCapabilityResolutionRelations
+    ]
+  };
+}
+
+// src/index.ts
 function defineExtensionPoint(id) {
   return { id };
 }
@@ -54,16 +92,25 @@ function getCapabilityProviderSelection(runtime, options = {}) {
     items: descriptors,
     getProviderPreferences: (descriptor) => descriptor.providerPreferences
   });
-  const configuredProviders = {
+  const providerDefaults = (0, import_provider_selection.collectProviderDefaults)({
+    items: descriptors,
+    getDefaultFor: (descriptor) => descriptor.defaultFor,
+    getProviderId: (descriptor) => descriptor.id
+  });
+  const configuredProviders = options.configuredProviders ?? {};
+  const selectedProviders = options.selectedProviders ?? {};
+  const fallbackProviders = {
+    ...providerDefaults,
     ...descriptorPreferences,
-    ...options.configuredProviders ?? {}
+    ...options.fallbackProviders ?? {}
   };
   const resolution = (0, import_provider_selection.resolveItemProviderSelection)({
     items: descriptors,
     getCapabilityId: (descriptor) => descriptor.providesFor,
     getProviderId: (descriptor) => descriptor.id,
     configuredProviders,
-    ...options.fallbackProviders ? { fallbackProviders: options.fallbackProviders } : {}
+    fallbackProviders,
+    selectedProviders
   });
   return {
     excludedProviderIds: resolution.excludedProviderIds,
@@ -138,14 +185,18 @@ function collectContributions(capabilities) {
 }
 function createCapabilityCatalog(capabilities) {
   return (0, import_composition_graph.createDescriptorCatalog)({
-    descriptors: capabilities.map((capability) => capability.manifest)
+    descriptors: capabilities.map((capability) => capability.manifest),
+    relationDescriptors: defaultCapabilityRelationDescriptors
   });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CapabilityRuntimeProvider,
+  createCapabilityCompositionPolicy,
   createCapabilityRuntime,
   createContributionContract,
+  defaultCapabilityRelationDescriptors,
+  defaultCapabilityResolutionRelations,
   defineCapability,
   defineContribution,
   defineExtensionPoint,

package/dist/index.d.cts

@@ -1,8 +1,13 @@
 import { ReactNode, ReactElement } from 'react';
-import { Descriptor, DescriptorCatalog } from '@lorion-org/composition-graph';
+import { CompositionPolicy, RelationDescriptor, Descriptor, DescriptorCatalog } from '@lorion-org/composition-graph';
 import { ProviderPreferenceMap, ProviderSelectionResolution } from '@lorion-org/provider-selection';
 
+declare const defaultCapabilityResolutionRelations: readonly ["dependencies", "defaultProviders", "providerPreferences"];
+declare const defaultCapabilityRelationDescriptors: RelationDescriptor[];
+declare function createCapabilityCompositionPolicy(policy?: Partial<CompositionPolicy>): Partial<CompositionPolicy>;
+
 type CapabilityManifest = Descriptor & {
+    defaultFor?: string | string[];
     description?: string;
     providerPreferences?: ProviderPreferenceMap;
 };
@@ -36,6 +41,7 @@ declare function createContributionContract<T>(id: string): ContributionContract
 type CapabilityProviderSelectionOptions = {
     configuredProviders?: ProviderPreferenceMap;
     fallbackProviders?: ProviderPreferenceMap;
+    selectedProviders?: ProviderPreferenceMap;
 };
 declare function getCapabilityProviderSelection(runtime: CapabilityRuntime, options?: CapabilityProviderSelectionOptions): ProviderSelectionResolution;
 declare function defineCapability(capability: RuntimeCapability): RuntimeCapability;
@@ -47,4 +53,4 @@ type CapabilityRuntimeProviderProps = {
 declare function CapabilityRuntimeProvider({ children, runtime, }: CapabilityRuntimeProviderProps): ReactElement;
 declare function useCapabilityRuntime(): CapabilityRuntime;
 
-export { type CapabilityContribution, type CapabilityManifest, type CapabilityProviderSelectionOptions, type CapabilityRuntime, CapabilityRuntimeProvider, type CapabilityRuntimeProviderProps, type ContributionContract, type ExtensionPoint, type RuntimeCapability, createCapabilityRuntime, createContributionContract, defineCapability, defineContribution, defineExtensionPoint, getCapabilityProviderSelection, useCapabilityRuntime };
+export { type CapabilityContribution, type CapabilityManifest, type CapabilityProviderSelectionOptions, type CapabilityRuntime, CapabilityRuntimeProvider, type CapabilityRuntimeProviderProps, type ContributionContract, type ExtensionPoint, type RuntimeCapability, createCapabilityCompositionPolicy, createCapabilityRuntime, createContributionContract, defaultCapabilityRelationDescriptors, defaultCapabilityResolutionRelations, defineCapability, defineContribution, defineExtensionPoint, getCapabilityProviderSelection, useCapabilityRuntime };

package/dist/index.d.ts

@@ -1,8 +1,13 @@
 import { ReactNode, ReactElement } from 'react';
-import { Descriptor, DescriptorCatalog } from '@lorion-org/composition-graph';
+import { CompositionPolicy, RelationDescriptor, Descriptor, DescriptorCatalog } from '@lorion-org/composition-graph';
 import { ProviderPreferenceMap, ProviderSelectionResolution } from '@lorion-org/provider-selection';
 
+declare const defaultCapabilityResolutionRelations: readonly ["dependencies", "defaultProviders", "providerPreferences"];
+declare const defaultCapabilityRelationDescriptors: RelationDescriptor[];
+declare function createCapabilityCompositionPolicy(policy?: Partial<CompositionPolicy>): Partial<CompositionPolicy>;
+
 type CapabilityManifest = Descriptor & {
+    defaultFor?: string | string[];
     description?: string;
     providerPreferences?: ProviderPreferenceMap;
 };
@@ -36,6 +41,7 @@ declare function createContributionContract<T>(id: string): ContributionContract
 type CapabilityProviderSelectionOptions = {
     configuredProviders?: ProviderPreferenceMap;
     fallbackProviders?: ProviderPreferenceMap;
+    selectedProviders?: ProviderPreferenceMap;
 };
 declare function getCapabilityProviderSelection(runtime: CapabilityRuntime, options?: CapabilityProviderSelectionOptions): ProviderSelectionResolution;
 declare function defineCapability(capability: RuntimeCapability): RuntimeCapability;
@@ -47,4 +53,4 @@ type CapabilityRuntimeProviderProps = {
 declare function CapabilityRuntimeProvider({ children, runtime, }: CapabilityRuntimeProviderProps): ReactElement;
 declare function useCapabilityRuntime(): CapabilityRuntime;
 
-export { type CapabilityContribution, type CapabilityManifest, type CapabilityProviderSelectionOptions, type CapabilityRuntime, CapabilityRuntimeProvider, type CapabilityRuntimeProviderProps, type ContributionContract, type ExtensionPoint, type RuntimeCapability, createCapabilityRuntime, createContributionContract, defineCapability, defineContribution, defineExtensionPoint, getCapabilityProviderSelection, useCapabilityRuntime };
+export { type CapabilityContribution, type CapabilityManifest, type CapabilityProviderSelectionOptions, type CapabilityRuntime, CapabilityRuntimeProvider, type CapabilityRuntimeProviderProps, type ContributionContract, type ExtensionPoint, type RuntimeCapability, createCapabilityCompositionPolicy, createCapabilityRuntime, createContributionContract, defaultCapabilityRelationDescriptors, defaultCapabilityResolutionRelations, defineCapability, defineContribution, defineExtensionPoint, getCapabilityProviderSelection, useCapabilityRuntime };

package/dist/index.js

@@ -1,3 +1,9 @@
+import {
+  createCapabilityCompositionPolicy,
+  defaultCapabilityRelationDescriptors,
+  defaultCapabilityResolutionRelations
+} from "./chunk-5FUI4JPB.js";
+
 // src/index.ts
 import { createContext, createElement, useContext } from "react";
 import {
@@ -5,6 +11,7 @@ import {
   createDescriptorCatalog
 } from "@lorion-org/composition-graph";
 import {
+  collectProviderDefaults,
   collectProviderPreferences,
   resolveItemProviderSelection
 } from "@lorion-org/provider-selection";
@@ -29,16 +36,25 @@ function getCapabilityProviderSelection(runtime, options = {}) {
     items: descriptors,
     getProviderPreferences: (descriptor) => descriptor.providerPreferences
   });
-  const configuredProviders = {
+  const providerDefaults = collectProviderDefaults({
+    items: descriptors,
+    getDefaultFor: (descriptor) => descriptor.defaultFor,
+    getProviderId: (descriptor) => descriptor.id
+  });
+  const configuredProviders = options.configuredProviders ?? {};
+  const selectedProviders = options.selectedProviders ?? {};
+  const fallbackProviders = {
+    ...providerDefaults,
     ...descriptorPreferences,
-    ...options.configuredProviders ?? {}
+    ...options.fallbackProviders ?? {}
   };
   const resolution = resolveItemProviderSelection({
     items: descriptors,
     getCapabilityId: (descriptor) => descriptor.providesFor,
     getProviderId: (descriptor) => descriptor.id,
     configuredProviders,
-    ...options.fallbackProviders ? { fallbackProviders: options.fallbackProviders } : {}
+    fallbackProviders,
+    selectedProviders
   });
   return {
     excludedProviderIds: resolution.excludedProviderIds,
@@ -113,13 +129,17 @@ function collectContributions(capabilities) {
 }
 function createCapabilityCatalog(capabilities) {
   return createDescriptorCatalog({
-    descriptors: capabilities.map((capability) => capability.manifest)
+    descriptors: capabilities.map((capability) => capability.manifest),
+    relationDescriptors: defaultCapabilityRelationDescriptors
   });
 }
 export {
   CapabilityRuntimeProvider,
+  createCapabilityCompositionPolicy,
   createCapabilityRuntime,
   createContributionContract,
+  defaultCapabilityRelationDescriptors,
+  defaultCapabilityResolutionRelations,
   defineCapability,
   defineContribution,
   defineExtensionPoint,

package/dist/vite.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/vite.ts
@@ -30,8 +40,45 @@ __export(vite_exports, {
 module.exports = __toCommonJS(vite_exports);
 var import_node_fs = require("fs");
 var import_node_path = require("path");
+var import_node_process = __toESM(require("process"), 1);
 var import_composition_graph = require("@lorion-org/composition-graph");
 var import_descriptor_discovery = require("@lorion-org/descriptor-discovery");
+var import_provider_selection = require("@lorion-org/provider-selection");
+
+// src/relations.ts
+var defaultCapabilityResolutionRelations = [
+  "dependencies",
+  "defaultProviders",
+  "providerPreferences"
+];
+var defaultCapabilityRelationDescriptors = [
+  {
+    direction: "incoming",
+    field: "defaultFor",
+    id: "defaultProviders"
+  },
+  {
+    field: "providerPreferences",
+    id: "providerPreferences",
+    targetMode: "values"
+  }
+];
+function createCapabilityCompositionPolicy(policy) {
+  return {
+    ...policy,
+    inspectionRelationIds: policy?.inspectionRelationIds ?? [
+      ...defaultCapabilityResolutionRelations
+    ],
+    provenanceRelationIds: policy?.provenanceRelationIds ?? [
+      ...defaultCapabilityResolutionRelations
+    ],
+    resolutionRelationIds: policy?.resolutionRelationIds ?? [
+      ...defaultCapabilityResolutionRelations
+    ]
+  };
+}
+
+// src/vite.ts
 var virtualModuleId = "virtual:capabilities";
 var resolvedVirtualModuleId = `\0${virtualModuleId}`;
 function capabilityLoader(options = {}) {
@@ -53,7 +100,7 @@ function capabilityLoader(options = {}) {
     },
     load(id) {
       if (id !== resolvedVirtualModuleId) return null;
-      return renderCapabilityModule(capabilities);
+      return renderCapabilityModule(capabilities, resolveSelectionSeed(options));
     }
   };
 }
@@ -75,28 +122,85 @@ function discoverSelectedCapabilities(workspaceRoot, options = {}) {
 }
 function selectCapabilities(capabilities, options = {}) {
   const enabledCapabilities = capabilities.filter((capability) => capability.disabled !== true);
-  if (!options.selected?.length && !options.baseDescriptors?.length) {
+  const selected = resolveCapabilitySelectionSeed(options);
+  if (!selected.length && !options.baseDescriptors?.length) {
     return [...enabledCapabilities];
   }
+  const selectedProviders = (0, import_provider_selection.collectSelectedProviderPreferences)({
+    items: enabledCapabilities,
+    getCapabilityId: (capability) => capability.manifest.providesFor,
+    getProviderId: (capability) => capability.id,
+    selectedProviderIds: selected
+  });
+  const selectionCapabilities = createProviderSelectionAwareCapabilities(
+    enabledCapabilities,
+    selectedProviders
+  );
   const catalog = (0, import_composition_graph.createDescriptorCatalog)({
-    descriptors: enabledCapabilities.map((capability) => capability.manifest)
+    descriptors: selectionCapabilities.map((capability) => capability.manifest),
+    relationDescriptors: [
+      ...defaultCapabilityRelationDescriptors,
+      ...options.relationDescriptors ?? []
+    ]
   });
   const selection = (0, import_composition_graph.createCompositionSelection)({
     catalog,
-    selected: [...options.selected ?? []],
+    selected: [...selected],
     baseDescriptors: [...options.baseDescriptors ?? []],
-    ...options.policy ? { policy: options.policy } : {}
+    policy: createCapabilityCompositionPolicy(options.policy)
   });
   const selectedIds = new Set(selection.getResolved());
-  return enabledCapabilities.filter((capability) => selectedIds.has(capability.id));
+  return selectionCapabilities.filter((capability) => selectedIds.has(capability.id));
+}
+function createProviderSelectionAwareCapabilities(capabilities, selectedProviders) {
+  if (!Object.keys(selectedProviders).length) return [...capabilities];
+  return capabilities.map((capability) => {
+    const manifest = { ...capability.manifest };
+    const preferences = (0, import_provider_selection.resolveSelectedProviderRelationPreferences)({
+      providerId: capability.id,
+      defaultFor: manifest.defaultFor,
+      providerPreferences: manifest.providerPreferences,
+      selectedProviders
+    });
+    delete manifest.defaultFor;
+    delete manifest.providerPreferences;
+    return {
+      ...capability,
+      manifest: {
+        ...manifest,
+        ...preferences
+      }
+    };
+  });
+}
+function resolveSelectionSeed(options) {
+  return resolveCapabilitySelectionSeed(options);
 }
-function renderCapabilityModule(capabilities) {
+function resolveCapabilitySelectionSeed(options) {
+  if (options.selected?.length) return [...options.selected];
+  if (options.selectionSeed === false) return [...options.defaultSelection ?? []];
+  const seedOptions = options.selectionSeed ?? {};
+  const selected = (0, import_composition_graph.resolveDescriptorSelectionSeed)({
+    argv: seedOptions.argv ?? import_node_process.default.argv,
+    env: seedOptions.env ?? import_node_process.default.env,
+    key: seedOptions.key ?? "capability",
+    ...seedOptions.cliKeys ? { cliKeys: seedOptions.cliKeys } : {},
+    ...seedOptions.envKeys ? { envKeys: seedOptions.envKeys } : {}
+  });
+  return selected.length ? selected : [...options.defaultSelection ?? []];
+}
+function renderCapabilityModule(capabilities, selected = []) {
   const imports = capabilities.map(
     (capability) => `import { capability as ${capability.variableName} } from '${capability.importSpecifier}'`
   ).join("\n");
   const variables = capabilities.map((capability) => `  ${capability.variableName},`).join("\n");
+  const capabilityIds = capabilities.map((capability) => capability.id);
   return `${imports}
 
+export const selectedCapabilityIds = ${JSON.stringify([...selected])}
+
+export const resolvedCapabilityIds = ${JSON.stringify(capabilityIds)}
+
 export const capabilityModules = [
 ${variables}
 ]

package/dist/vite.d.cts

@@ -1,12 +1,16 @@
-import { DescriptorId, CompositionPolicy, Descriptor } from '@lorion-org/composition-graph';
+import { DescriptorId, CompositionPolicy, RelationDescriptor, DescriptorSelectionSeedInput, Descriptor } from '@lorion-org/composition-graph';
 
 type CapabilityLoaderOptions = {
     capabilitiesDir?: string;
     baseDescriptors?: readonly DescriptorId[];
+    defaultSelection?: readonly DescriptorId[];
     policy?: Partial<CompositionPolicy>;
+    relationDescriptors?: readonly RelationDescriptor[];
     selected?: readonly DescriptorId[];
+    selectionSeed?: false | CapabilitySelectionSeedOptions;
     workspaceRoot?: string;
 };
+type CapabilitySelectionSeedOptions = Omit<DescriptorSelectionSeedInput, 'defaultValue'>;
 type CapabilityRouteConfigOptions = CapabilityLoaderOptions & {
     indexRouteFile?: false | string;
     routesDirectory: string;
@@ -55,7 +59,7 @@ declare function capabilityLoader(options?: CapabilityLoaderOptions): VitePlugin
 declare function lorionReact(options: LorionReactViteOptions): LorionReactViteSetup;
 declare function discoverCapabilities(workspaceRoot: string, options?: Pick<CapabilityLoaderOptions, 'capabilitiesDir'>): DiscoveredCapability[];
 declare function discoverSelectedCapabilities(workspaceRoot: string, options?: CapabilityLoaderOptions): DiscoveredCapability[];
-declare function renderCapabilityModule(capabilities: readonly DiscoveredCapability[]): string;
+declare function renderCapabilityModule(capabilities: readonly DiscoveredCapability[], selected?: readonly DescriptorId[]): string;
 declare function createCapabilityRouteConfig(options: CapabilityRouteConfigOptions): VirtualRootRoute;
 
-export { type CapabilityLoaderOptions, type CapabilityRouteConfigOptions, type DiscoveredCapability, type LorionReactViteOptions, type LorionReactViteSetup, type VirtualIndexRoute, type VirtualPhysicalRouteSubtree, type VirtualRootRoute, type VitePlugin, type ViteResolvedConfig, capabilityLoader, createCapabilityRouteConfig, discoverCapabilities, discoverSelectedCapabilities, lorionReact, renderCapabilityModule };
+export { type CapabilityLoaderOptions, type CapabilityRouteConfigOptions, type CapabilitySelectionSeedOptions, type DiscoveredCapability, type LorionReactViteOptions, type LorionReactViteSetup, type VirtualIndexRoute, type VirtualPhysicalRouteSubtree, type VirtualRootRoute, type VitePlugin, type ViteResolvedConfig, capabilityLoader, createCapabilityRouteConfig, discoverCapabilities, discoverSelectedCapabilities, lorionReact, renderCapabilityModule };

package/dist/vite.d.ts

@@ -1,12 +1,16 @@
-import { DescriptorId, CompositionPolicy, Descriptor } from '@lorion-org/composition-graph';
+import { DescriptorId, CompositionPolicy, RelationDescriptor, DescriptorSelectionSeedInput, Descriptor } from '@lorion-org/composition-graph';
 
 type CapabilityLoaderOptions = {
     capabilitiesDir?: string;
     baseDescriptors?: readonly DescriptorId[];
+    defaultSelection?: readonly DescriptorId[];
     policy?: Partial<CompositionPolicy>;
+    relationDescriptors?: readonly RelationDescriptor[];
     selected?: readonly DescriptorId[];
+    selectionSeed?: false | CapabilitySelectionSeedOptions;
     workspaceRoot?: string;
 };
+type CapabilitySelectionSeedOptions = Omit<DescriptorSelectionSeedInput, 'defaultValue'>;
 type CapabilityRouteConfigOptions = CapabilityLoaderOptions & {
     indexRouteFile?: false | string;
     routesDirectory: string;
@@ -55,7 +59,7 @@ declare function capabilityLoader(options?: CapabilityLoaderOptions): VitePlugin
 declare function lorionReact(options: LorionReactViteOptions): LorionReactViteSetup;
 declare function discoverCapabilities(workspaceRoot: string, options?: Pick<CapabilityLoaderOptions, 'capabilitiesDir'>): DiscoveredCapability[];
 declare function discoverSelectedCapabilities(workspaceRoot: string, options?: CapabilityLoaderOptions): DiscoveredCapability[];
-declare function renderCapabilityModule(capabilities: readonly DiscoveredCapability[]): string;
+declare function renderCapabilityModule(capabilities: readonly DiscoveredCapability[], selected?: readonly DescriptorId[]): string;
 declare function createCapabilityRouteConfig(options: CapabilityRouteConfigOptions): VirtualRootRoute;
 
-export { type CapabilityLoaderOptions, type CapabilityRouteConfigOptions, type DiscoveredCapability, type LorionReactViteOptions, type LorionReactViteSetup, type VirtualIndexRoute, type VirtualPhysicalRouteSubtree, type VirtualRootRoute, type VitePlugin, type ViteResolvedConfig, capabilityLoader, createCapabilityRouteConfig, discoverCapabilities, discoverSelectedCapabilities, lorionReact, renderCapabilityModule };
+export { type CapabilityLoaderOptions, type CapabilityRouteConfigOptions, type CapabilitySelectionSeedOptions, type DiscoveredCapability, type LorionReactViteOptions, type LorionReactViteSetup, type VirtualIndexRoute, type VirtualPhysicalRouteSubtree, type VirtualRootRoute, type VitePlugin, type ViteResolvedConfig, capabilityLoader, createCapabilityRouteConfig, discoverCapabilities, discoverSelectedCapabilities, lorionReact, renderCapabilityModule };