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

package/dist/vite.js

@@ -1,30 +1,39 @@
-import {
-  createCapabilityCompositionPolicy,
-  defaultCapabilityRelationDescriptors
-} from "./chunk-5FUI4JPB.js";
-
 // src/vite.ts
 import { existsSync, readFileSync } from "fs";
-import { dirname, join, relative, resolve, sep } from "path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
 import process from "process";
-import {
-  createCompositionSelection,
-  createDescriptorCatalog,
-  resolveDescriptorSelectionSeed
-} from "@lorion-org/composition-graph";
+import { loadEnv } from "vite";
 import {
   descriptorSchema,
-  discoverDescriptors
+  discoverDescriptors,
+  requirePackageName
 } from "@lorion-org/descriptor-discovery";
+import { resolveDescriptorSelection, selectDescriptors } from "@lorion-org/descriptor-selection";
 import {
-  collectSelectedProviderPreferences,
-  resolveSelectedProviderRelationPreferences
-} from "@lorion-org/provider-selection";
+  createRuntimeConfigValidatorRegistry,
+  projectRuntimeConfigNamespaces,
+  resolveRuntimeConfigValidationMode,
+  toRuntimeConfigFragment,
+  toSnakeUpperCase
+} from "@lorion-org/runtime-config";
+import {
+  loadRuntimeConfigSourceTree,
+  readJsonFile,
+  resolveRuntimeConfigSource as resolveRuntimeConfigVarDirSource
+} from "@lorion-org/runtime-config-node";
+import { capabilitySpecifier } from "@lorion-org/surface-activation";
 var virtualModuleId = "virtual:capabilities";
 var resolvedVirtualModuleId = `\0${virtualModuleId}`;
+var runtimeConfigModuleId = "virtual:capability-runtime-config";
+var resolvedRuntimeConfigModuleId = `\0${runtimeConfigModuleId}`;
+var serverRuntimeConfigModuleId = "virtual:capability-runtime-config/server";
+var resolvedServerRuntimeConfigModuleId = `\0${serverRuntimeConfigModuleId}`;
+var defaultRuntimeConfigFileName = "capability.runtime.json";
+var defaultRuntimeConfigSchemaFileName = "capability.schema.json";
 function capabilityLoader(options = {}) {
   let config;
   let capabilities = [];
+  let runtimeConfig = { private: {}, public: {} };
   return {
     name: "lorion-react-capability-loader",
     enforce: "pre",
@@ -34,107 +43,110 @@ function capabilityLoader(options = {}) {
         resolveWorkspaceRoot(config.root, options),
         options
       );
+      runtimeConfig = createReactRuntimeConfig(
+        capabilities,
+        resolveWorkspaceRoot(config.root, options),
+        options.runtimeConfig,
+        config
+      );
     },
     resolveId(id) {
       if (id === virtualModuleId) return resolvedVirtualModuleId;
+      if (id === runtimeConfigModuleId) return resolvedRuntimeConfigModuleId;
+      if (id === serverRuntimeConfigModuleId) return resolvedServerRuntimeConfigModuleId;
       return capabilities.find((capability) => capability.importSpecifier === id)?.entryFile;
     },
-    load(id) {
+    load(id, loadOptions) {
+      if (id === resolvedRuntimeConfigModuleId) return renderRuntimeConfigModule(runtimeConfig);
+      if (id === resolvedServerRuntimeConfigModuleId) {
+        if (!loadOptions?.ssr) {
+          throw new Error(
+            "virtual:capability-runtime-config/server may only be imported from SSR/server code."
+          );
+        }
+        return renderServerRuntimeConfigModule(runtimeConfig);
+      }
       if (id !== resolvedVirtualModuleId) return null;
       return renderCapabilityModule(capabilities, resolveSelectionSeed(options));
     }
   };
 }
+function createReactRuntimeConfig(capabilities, workspaceRoot, options = {}, viteConfig = {}) {
+  const normalizedOptions = normalizeRuntimeConfigOptions(options);
+  if (!normalizedOptions.enabled) return { private: {}, public: {} };
+  const runtimeEnv = resolveRuntimeConfigEnv(viteConfig, normalizedOptions.env ?? {});
+  const sourceFragments = normalizedOptions.source ? loadRuntimeConfigSourceTree(
+    resolveRuntimeConfigPatternSource(workspaceRoot, normalizedOptions, runtimeEnv)
+  ) : /* @__PURE__ */ new Map();
+  const schemaEntries = readRuntimeConfigSchemas(capabilities, normalizedOptions.schemaFileName);
+  const envFragments = normalizedOptions.env === false ? /* @__PURE__ */ new Map() : createRuntimeConfigEnvFragments(
+    createRuntimeConfigEnvFragmentOptions(
+      capabilities,
+      schemaEntries.schemas,
+      runtimeEnv,
+      normalizedOptions.env
+    )
+  );
+  const fragments = mergeRuntimeConfigFragmentMaps(sourceFragments, envFragments);
+  validateReactRuntimeConfig(capabilities, fragments, schemaEntries, normalizedOptions.validation);
+  const projected = projectRuntimeConfigNamespaces(fragments, {
+    namespaceStrategy: "nested",
+    scopeIds: capabilities.map((capability) => capability.id)
+  });
+  const { public: publicConfig, ...privateConfig } = projected;
+  return {
+    public: publicConfig,
+    private: privateConfig
+  };
+}
 function lorionReact(options) {
   return {
     capabilityLoader: capabilityLoader(options),
     routeConfig: createCapabilityRouteConfig(options)
   };
 }
+function toResolveActivation(options) {
+  if (options.surface) {
+    if (options.activation) {
+      throw new Error("capabilityLoader: pass either `surface` or `activation`, not both.");
+    }
+    const { name, resolver } = options.surface;
+    return ({ capabilityDir, descriptor }) => resolver(name, { directory: capabilityDir, id: descriptor.id });
+  }
+  return options.activation;
+}
 function discoverCapabilities(workspaceRoot, options = {}) {
   const capabilitiesRoot = resolve(workspaceRoot, options.capabilitiesDir ?? "capabilities");
   if (!existsSync(capabilitiesRoot)) {
     throw new Error(`Capabilities directory not found: ${capabilitiesRoot}`);
   }
-  return discoverCapabilityDescriptors(workspaceRoot, options).map(discoverCapability).sort((left, right) => left.id.localeCompare(right.id));
+  const resolveActivation = toResolveActivation(options);
+  return discoverCapabilityDescriptors(workspaceRoot, options).map((entry) => discoverCapability(entry, resolveActivation)).sort((left, right) => left.id.localeCompare(right.id));
 }
 function discoverSelectedCapabilities(workspaceRoot, options = {}) {
   return selectCapabilities(discoverCapabilities(workspaceRoot, options), options);
 }
 function selectCapabilities(capabilities, options = {}) {
-  const enabledCapabilities = capabilities.filter((capability) => capability.disabled !== true);
-  const selected = resolveCapabilitySelectionSeed(options);
-  if (!selected.length && !options.baseDescriptors?.length) {
-    return [...enabledCapabilities];
-  }
-  const selectedProviders = collectSelectedProviderPreferences({
-    items: enabledCapabilities,
-    getCapabilityId: (capability) => capability.manifest.providesFor,
-    getProviderId: (capability) => capability.id,
-    selectedProviderIds: selected
-  });
-  const selectionCapabilities = createProviderSelectionAwareCapabilities(
-    enabledCapabilities,
-    selectedProviders
-  );
-  const catalog = createDescriptorCatalog({
-    descriptors: selectionCapabilities.map((capability) => capability.manifest),
-    relationDescriptors: [
-      ...defaultCapabilityRelationDescriptors,
-      ...options.relationDescriptors ?? []
-    ]
-  });
-  const selection = createCompositionSelection({
-    catalog,
-    selected: [...selected],
-    baseDescriptors: [...options.baseDescriptors ?? []],
-    policy: createCapabilityCompositionPolicy(options.policy)
-  });
-  const selectedIds = new Set(selection.getResolved());
-  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 = resolveSelectedProviderRelationPreferences({
-      providerId: capability.id,
-      defaultFor: manifest.defaultFor,
-      providerPreferences: manifest.providerPreferences,
-      selectedProviders
-    });
-    delete manifest.defaultFor;
-    delete manifest.providerPreferences;
-    return {
-      ...capability,
-      manifest: {
-        ...manifest,
-        ...preferences
-      }
-    };
+  return selectDescriptors({
+    items: capabilities,
+    getDescriptor: (capability) => capability.manifest,
+    withDescriptor: (capability, manifest) => ({ ...capability, manifest }),
+    seed: options,
+    ...options.relationDescriptors ? { relationDescriptors: options.relationDescriptors } : {},
+    ...options.policy ? { policy: options.policy } : {}
   });
 }
 function resolveSelectionSeed(options) {
-  return resolveCapabilitySelectionSeed(options);
-}
-function resolveCapabilitySelectionSeed(options) {
-  if (options.selected?.length) return [...options.selected];
-  if (options.selectionSeed === false) return [...options.defaultSelection ?? []];
-  const seedOptions = options.selectionSeed ?? {};
-  const selected = resolveDescriptorSelectionSeed({
-    argv: seedOptions.argv ?? process.argv,
-    env: seedOptions.env ?? process.env,
-    key: seedOptions.key ?? "capability",
-    ...seedOptions.cliKeys ? { cliKeys: seedOptions.cliKeys } : {},
-    ...seedOptions.envKeys ? { envKeys: seedOptions.envKeys } : {}
-  });
-  return selected.length ? selected : [...options.defaultSelection ?? []];
+  return resolveDescriptorSelection(options);
 }
 function renderCapabilityModule(capabilities, selected = []) {
-  const imports = capabilities.map(
-    (capability) => `import { capability as ${capability.variableName} } from '${capability.importSpecifier}'`
+  const activated = capabilities.filter(
+    (capability) => capability.exportName && capability.importSpecifier
+  );
+  const imports = activated.map(
+    (capability) => `import { ${capability.exportName} as ${capability.variableName} } from '${capability.importSpecifier}'`
   ).join("\n");
-  const variables = capabilities.map((capability) => `  ${capability.variableName},`).join("\n");
+  const variables = activated.map((capability) => `  ${capability.variableName},`).join("\n");
   const capabilityIds = capabilities.map((capability) => capability.id);
   return `${imports}
 
@@ -147,6 +159,16 @@ ${variables}
 ]
 `;
 }
+function renderRuntimeConfigModule(runtimeConfig) {
+  return `export const capabilityRuntimeConfig = ${JSON.stringify({ public: runtimeConfig.public })}
+
+export const publicCapabilityRuntimeConfig = capabilityRuntimeConfig.public
+`;
+}
+function renderServerRuntimeConfigModule(runtimeConfig) {
+  return `export const capabilityServerRuntimeConfig = ${JSON.stringify(runtimeConfig)}
+`;
+}
 function createCapabilityRouteConfig(options) {
   if (!options?.workspaceRoot) {
     throw new Error("createCapabilityRouteConfig requires a workspaceRoot option.");
@@ -185,7 +207,7 @@ function discoverCapabilityDescriptors(workspaceRoot, options) {
     }
   });
 }
-function discoverCapability(entry) {
+function discoverCapability(entry, resolveActivation) {
   const capabilityDir = entry.cwd;
   const packagePath = resolve(capabilityDir, "package.json");
   if (!existsSync(packagePath)) {
@@ -194,43 +216,236 @@ function discoverCapability(entry) {
     );
   }
   const packageJson = readJson(packagePath);
-  const packageName = packageJson.name;
-  if (typeof packageName !== "string") {
-    throw new Error(`Capability package is missing "name": ${packagePath}`);
-  }
-  const activationEntry = resolveActivationEntry(capabilityDir, packageJson);
+  const packageName = requirePackageName(packageJson, packagePath);
+  const activationEntry = resolveActivationEntry(
+    capabilityDir,
+    packageJson,
+    packageName,
+    entry.descriptor,
+    resolveActivation
+  );
   const routesDirectory = resolveRouteDirectory(capabilityDir);
   return {
+    capabilityDir,
     id: entry.descriptor.id,
     disabled: entry.descriptor.disabled === true,
-    entryFile: activationEntry.entryFile,
-    importSpecifier: activationEntry.importSpecifier,
     manifest: entry.descriptor,
     packageName,
+    ...activationEntry ? {
+      exportName: activationEntry.exportName,
+      importSpecifier: activationEntry.importSpecifier,
+      ...activationEntry.entryFile ? { entryFile: activationEntry.entryFile } : {}
+    } : {},
     ...routesDirectory ? { routesDirectory } : {},
     variableName: toVariableName(entry.descriptor.id)
   };
 }
-function resolveRouteDirectory(capabilityDir) {
-  const routesDirectory = resolve(capabilityDir, "src", "routes");
-  return existsSync(routesDirectory) ? routesDirectory : void 0;
+function normalizeRuntimeConfigOptions(options) {
+  if (options === false) {
+    return {
+      configFileName: defaultRuntimeConfigFileName,
+      enabled: false,
+      env: false,
+      schemaFileName: defaultRuntimeConfigSchemaFileName,
+      validation: false
+    };
+  }
+  const configFileName = options.configFileName ?? defaultRuntimeConfigFileName;
+  return {
+    configFileName,
+    enabled: options.enabled !== false,
+    env: options.env ?? {},
+    schemaFileName: options.schemaFileName ?? defaultRuntimeConfigSchemaFileName,
+    ...options.source === false ? {} : {
+      source: options.source ?? { paths: [] }
+    },
+    validation: options.validation === false ? false : options.validation ?? {},
+    ...options.varDir ? { varDir: options.varDir } : {}
+  };
 }
-function resolveActivationEntry(capabilityDir, packageJson) {
-  const packageName = packageJson.name;
-  const packageExports = packageJson.exports;
-  if (typeof packageName !== "string") {
-    throw new Error(
-      `Capability package is missing "name": ${resolve(capabilityDir, "package.json")}`
-    );
+function resolveRuntimeConfigPatternSource(workspaceRoot, options, env) {
+  if (!options.source?.paths.length) {
+    const varDir = resolveRuntimeConfigVarDir(workspaceRoot, options.varDir, env);
+    return {
+      paths: [join(varDir, "runtime-config", "*", options.configFileName)]
+    };
   }
-  if (!isRecord(packageExports) || typeof packageExports["./capability"] !== "string") {
-    throw new Error(`Capability package is missing a "./capability" export: ${capabilityDir}`);
+  return {
+    paths: options.source.paths.map(
+      (entry) => isAbsolute(entry) ? entry : resolve(workspaceRoot, entry)
+    )
+  };
+}
+function resolveRuntimeConfigVarDir(workspaceRoot, options, env) {
+  const rawVarDir = typeof options === "string" ? options : resolveRuntimeConfigVarDirSource({
+    defaultVarDir: resolve(workspaceRoot, ".data"),
+    env: options?.env ?? env,
+    envKey: options?.envKey ?? "RUNTIME_CONFIG_VAR_DIR",
+    ...options?.value ? { varDir: options.value } : {},
+    ...options?.defaultValue ? { defaultVarDir: options.defaultValue } : {}
+  }).varDir;
+  return isAbsolute(rawVarDir) ? rawVarDir : resolve(workspaceRoot, rawVarDir);
+}
+function resolveRuntimeConfigEnv(viteConfig, options) {
+  if (options === false) return {};
+  if (options.env) return options.env;
+  const mode = viteConfig.mode ?? process.env.NODE_ENV ?? "development";
+  const envDir = typeof viteConfig.envDir === "string" ? viteConfig.envDir : viteConfig.root ?? process.cwd();
+  return {
+    ...loadEnv(mode, envDir, ""),
+    ...process.env,
+    ...viteConfig.env ?? {}
+  };
+}
+function readRuntimeConfigSchemas(capabilities, schemaFileName) {
+  const paths = /* @__PURE__ */ new Map();
+  const schemas = {};
+  for (const capability of capabilities) {
+    const schemaPath = resolve(capability.capabilityDir, schemaFileName);
+    const schema = readJsonFile(schemaPath, {
+      onParseError: (error, filePath) => {
+        throw new Error(`RuntimeConfig schema JSON parse error in "${filePath}": ${String(error)}`);
+      }
+    });
+    if (!schema) continue;
+    paths.set(capability.id, schemaPath);
+    schemas[capability.id] = schema;
   }
+  return { paths, schemas };
+}
+function isJsonSchemaObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getRuntimeConfigSchemaSectionKeys(schema, visibility) {
+  if (!isJsonSchemaObject(schema)) return [];
+  const section = schema.properties?.[visibility];
+  if (!isJsonSchemaObject(section) || !isJsonSchemaObject(section.properties)) return [];
+  return Object.keys(section.properties).sort();
+}
+function createRuntimeConfigEnvKey(input) {
+  return toSnakeUpperCase([input.prefix, input.scopeId, input.key].filter(Boolean).join("_"));
+}
+function createRuntimeConfigEnvFragments(input) {
+  const fragments = /* @__PURE__ */ new Map();
+  for (const capability of input.capabilities) {
+    const schema = input.schemas[capability.id];
+    const publicConfig = {};
+    const privateConfig = {};
+    for (const key of getRuntimeConfigSchemaSectionKeys(schema, "public")) {
+      const envKey = createRuntimeConfigEnvKey({
+        key,
+        prefix: input.publicPrefix ?? "VITE",
+        scopeId: capability.id
+      });
+      const value = input.env[envKey];
+      if (value !== void 0) publicConfig[key] = value;
+    }
+    for (const key of getRuntimeConfigSchemaSectionKeys(schema, "private")) {
+      const envKey = createRuntimeConfigEnvKey({
+        key,
+        scopeId: capability.id,
+        ...input.privatePrefix !== void 0 ? { prefix: input.privatePrefix } : {}
+      });
+      const value = input.env[envKey];
+      if (value !== void 0) privateConfig[key] = value;
+    }
+    if (Object.keys(publicConfig).length || Object.keys(privateConfig).length) {
+      fragments.set(capability.id, {
+        ...Object.keys(publicConfig).length ? { public: publicConfig } : {},
+        ...Object.keys(privateConfig).length ? { private: privateConfig } : {}
+      });
+    }
+  }
+  return fragments;
+}
+function createRuntimeConfigEnvFragmentOptions(capabilities, schemas, env, options) {
   return {
-    entryFile: resolve(capabilityDir, packageExports["./capability"]),
-    importSpecifier: `${packageName}/capability`
+    capabilities,
+    env,
+    ...options.privatePrefix !== void 0 ? { privatePrefix: options.privatePrefix } : {},
+    ...options.publicPrefix !== void 0 ? { publicPrefix: options.publicPrefix } : {},
+    schemas
   };
 }
+function mergeRuntimeConfigSections(left, right) {
+  const section = {
+    ...left ?? {},
+    ...right ?? {}
+  };
+  return Object.keys(section).length ? section : void 0;
+}
+function mergeRuntimeConfigFragment(left, right) {
+  const publicConfig = mergeRuntimeConfigSections(left?.public, right?.public);
+  const privateConfig = mergeRuntimeConfigSections(left?.private, right?.private);
+  return toRuntimeConfigFragment({
+    ...publicConfig ? { public: publicConfig } : {},
+    ...privateConfig ? { private: privateConfig } : {}
+  });
+}
+function mergeRuntimeConfigFragmentMaps(left, right) {
+  const fragments = new Map(left);
+  for (const [scopeId, config] of right.entries()) {
+    fragments.set(scopeId, mergeRuntimeConfigFragment(fragments.get(scopeId), config));
+  }
+  return fragments;
+}
+function getCapabilityRuntimeConfigPolicy(capability, validation) {
+  return capability.manifest.runtimeConfig ?? validation.policy ?? "optional";
+}
+function shouldValidateRuntimeConfigFragment(input) {
+  if (!input.schema) return false;
+  const mode = resolveRuntimeConfigValidationMode(
+    getCapabilityRuntimeConfigPolicy(input.capability, input.validation)
+  );
+  if (mode === "none" || mode === "onUse") return false;
+  if (mode === "startup") return true;
+  return Boolean(input.fragment);
+}
+function validateReactRuntimeConfig(capabilities, fragments, schemas, validation) {
+  if (validation === false) return;
+  const registry = createRuntimeConfigValidatorRegistry(schemas.schemas, {
+    ...validation.formatError ? {
+      formatError: (target, validationError) => validation.formatError(
+        {
+          configPath: `${target.scopeId} runtime config`,
+          schemaPath: schemas.paths.get(target.scopeId) ?? "",
+          scopeId: target.scopeId
+        },
+        validationError
+      )
+    } : {}
+  });
+  for (const capability of capabilities) {
+    const fragment = fragments.get(capability.id);
+    const schema = schemas.schemas[capability.id];
+    if (!shouldValidateRuntimeConfigFragment({ capability, fragment, schema, validation })) {
+      continue;
+    }
+    registry.assert(capability.id, fragment ?? {});
+  }
+}
+function resolveRouteDirectory(capabilityDir) {
+  const routesDirectory = resolve(capabilityDir, "src", "routes");
+  return existsSync(routesDirectory) ? routesDirectory : void 0;
+}
+function resolveActivationEntry(capabilityDir, packageJson, packageName, descriptor, resolveActivation) {
+  if (!resolveActivation) {
+    const packageExports = packageJson.exports;
+    if (!isRecord(packageExports) || typeof packageExports["./capability"] !== "string") {
+      throw new Error(`Capability package is missing a "./capability" export: ${capabilityDir}`);
+    }
+    return {
+      entryFile: resolve(capabilityDir, packageExports["./capability"]),
+      exportName: "capability",
+      importSpecifier: capabilitySpecifier(packageName, "./capability")
+    };
+  }
+  const activation = resolveActivation({ capabilityDir, descriptor, packageJson, packageName });
+  if (!activation) return null;
+  const exportName = activation.exportName ?? "capability";
+  const exportSubpath = activation.exportSubpath ?? "./capability";
+  return { exportName, importSpecifier: capabilitySpecifier(packageName, exportSubpath) };
+}
 function hasRouteDirectory(capability) {
   return typeof capability.routesDirectory === "string";
 }
@@ -266,8 +481,11 @@ function toPosixPath(path) {
 export {
   capabilityLoader,
   createCapabilityRouteConfig,
+  createReactRuntimeConfig,
   discoverCapabilities,
   discoverSelectedCapabilities,
   lorionReact,
-  renderCapabilityModule
+  renderCapabilityModule,
+  renderRuntimeConfigModule,
+  renderServerRuntimeConfigModule
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lorion-org/react",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.4",
   "description": "React capability runtime and Vite helpers for LORION descriptor-based applications.",
   "license": "MIT",
   "repository": {
@@ -58,11 +58,21 @@
   ],
   "dependencies": {
     "@lorion-org/composition-graph": "^1.0.0-beta.2",
-    "@lorion-org/descriptor-discovery": "^1.0.0-beta.2",
-    "@lorion-org/provider-selection": "^1.0.0-beta.2"
+    "@lorion-org/descriptor-discovery": "^1.0.0-beta.3",
+    "@lorion-org/descriptor-selection": "^1.0.0-beta.3",
+    "@lorion-org/runtime-config": "^1.0.0-beta.1",
+    "@lorion-org/provider-selection": "^1.0.0-beta.2",
+    "@lorion-org/runtime-config-node": "^1.0.0-beta.1",
+    "@lorion-org/surface-activation": "^1.0.0-beta.3"
   },
   "peerDependencies": {
-    "react": "^19.0.0"
+    "react": "^19.0.0",
+    "vite": "^7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@tanstack/react-router": "^1.168.25",
@@ -90,10 +100,7 @@
     "clean": "rimraf coverage dist tsconfig.tsbuildinfo",
     "lint": "eslint src --ext .ts",
     "package:check": "pnpm build && pnpm pack --dry-run && publint",
-    "build:playground": "node ../../tools/run-source-condition.mjs vite build --config playground/vite.config.ts --",
-    "dev:playground": "node ../../tools/run-source-condition.mjs vite dev --config playground/vite.config.ts --host 0.0.0.0 --",
     "test": "vitest run --root ../.. --config vitest.config.mts packages/react/src/index.spec.ts packages/react/src/vite.spec.ts",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "typecheck:playground": "tsc -p playground/tsconfig.json --noEmit"
+    "typecheck": "tsc -p tsconfig.json --noEmit"
   }
 }

package/src/index.ts

@@ -12,6 +12,7 @@ import {
   type ProviderPreferenceMap,
   type ProviderSelectionResolution,
 } from '@lorion-org/provider-selection';
+import type { RuntimeConfigValidationPolicy } from '@lorion-org/runtime-config';
 import { defaultCapabilityRelationDescriptors } from './relations';
 
 export {
@@ -19,11 +20,13 @@ export {
   defaultCapabilityRelationDescriptors,
   defaultCapabilityResolutionRelations,
 } from './relations';
+export * from './runtime-config';
 
 export type CapabilityManifest = Descriptor & {
   defaultFor?: string | string[];
   description?: string;
   providerPreferences?: ProviderPreferenceMap;
+  runtimeConfig?: RuntimeConfigValidationPolicy;
 };
 
 export type ExtensionPoint<T> = {

package/src/relations.ts

@@ -1,37 +1,8 @@
-import type { CompositionPolicy, RelationDescriptor } from '@lorion-org/composition-graph';
-
-export const defaultCapabilityResolutionRelations = [
-  'dependencies',
-  'defaultProviders',
-  'providerPreferences',
-] as const;
-
-export const defaultCapabilityRelationDescriptors: RelationDescriptor[] = [
-  {
-    direction: 'incoming',
-    field: 'defaultFor',
-    id: 'defaultProviders',
-  },
-  {
-    field: 'providerPreferences',
-    id: 'providerPreferences',
-    targetMode: 'values',
-  },
-];
-
-export function createCapabilityCompositionPolicy(
-  policy?: Partial<CompositionPolicy>,
-): Partial<CompositionPolicy> {
-  return {
-    ...policy,
-    inspectionRelationIds: policy?.inspectionRelationIds ?? [
-      ...defaultCapabilityResolutionRelations,
-    ],
-    provenanceRelationIds: policy?.provenanceRelationIds ?? [
-      ...defaultCapabilityResolutionRelations,
-    ],
-    resolutionRelationIds: policy?.resolutionRelationIds ?? [
-      ...defaultCapabilityResolutionRelations,
-    ],
-  };
-}
+// The capability relations and composition policy are owned by
+// @lorion-org/descriptor-selection. They are re-exported here under the React
+// adapter's public names for backward compatibility; no logic is duplicated.
+export {
+  providerRelationDescriptors as defaultCapabilityRelationDescriptors,
+  descriptorSelectionPolicy as createCapabilityCompositionPolicy,
+  defaultResolutionRelations as defaultCapabilityResolutionRelations,
+} from '@lorion-org/descriptor-selection';