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

package/dist/index.d.ts

@@ -1,10 +1,31 @@
 import { ReactNode, ReactElement } from 'react';
 import { Descriptor, DescriptorCatalog } from '@lorion-org/composition-graph';
 import { ProviderPreferenceMap, ProviderSelectionResolution } from '@lorion-org/provider-selection';
+import { RuntimeConfigSection, RuntimeConfigValidationPolicy } from '@lorion-org/runtime-config';
+export { descriptorSelectionPolicy as createCapabilityCompositionPolicy, providerRelationDescriptors as defaultCapabilityRelationDescriptors, defaultResolutionRelations as defaultCapabilityResolutionRelations } from '@lorion-org/descriptor-selection';
+
+type CapabilityRuntimeConfig = {
+    public: Record<string, RuntimeConfigSection>;
+};
+type CapabilityRuntimeConfigFragment<T extends RuntimeConfigSection = RuntimeConfigSection> = {
+    public: T;
+};
+type CapabilityRuntimeConfigProviderProps = {
+    children: ReactNode;
+    runtimeConfig: CapabilityRuntimeConfig;
+};
+declare function CapabilityRuntimeConfigProvider({ children, runtimeConfig, }: CapabilityRuntimeConfigProviderProps): ReactElement;
+declare function useCapabilityRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(capabilityId: string): T;
+declare function useCapabilityRuntimeConfig<T extends RuntimeConfigSection = RuntimeConfigSection>(capabilityId: string): CapabilityRuntimeConfigFragment<T>;
+declare function useCapabilityRuntimeConfigRoot(): CapabilityRuntimeConfig;
+declare function getCapabilityRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(runtimeConfig: CapabilityRuntimeConfig, capabilityId: string): T;
+declare function getCapabilityRuntimeConfig<T extends RuntimeConfigSection = RuntimeConfigSection>(runtimeConfig: CapabilityRuntimeConfig, capabilityId: string): CapabilityRuntimeConfigFragment<T>;
 
 type CapabilityManifest = Descriptor & {
+    defaultFor?: string | string[];
     description?: string;
     providerPreferences?: ProviderPreferenceMap;
+    runtimeConfig?: RuntimeConfigValidationPolicy;
 };
 type ExtensionPoint<T> = {
     id: string;
@@ -36,6 +57,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 +69,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, type CapabilityRuntimeConfig, type CapabilityRuntimeConfigFragment, CapabilityRuntimeConfigProvider, type CapabilityRuntimeConfigProviderProps, CapabilityRuntimeProvider, type CapabilityRuntimeProviderProps, type ContributionContract, type ExtensionPoint, type RuntimeCapability, createCapabilityRuntime, createContributionContract, defineCapability, defineContribution, defineExtensionPoint, getCapabilityProviderSelection, getCapabilityRuntimeConfig, getCapabilityRuntimeConfigScope, useCapabilityRuntime, useCapabilityRuntimeConfig, useCapabilityRuntimeConfigRoot, useCapabilityRuntimeConfigScope };

package/dist/index.js

@@ -1,13 +1,52 @@
 // src/index.ts
-import { createContext, createElement, useContext } from "react";
+import { createContext as createContext2, createElement as createElement2, useContext as useContext2 } from "react";
 import {
   assertKnownDescriptorIds,
   createDescriptorCatalog
 } from "@lorion-org/composition-graph";
 import {
+  collectProviderDefaults,
   collectProviderPreferences,
   resolveItemProviderSelection
 } from "@lorion-org/provider-selection";
+
+// src/relations.ts
+import {
+  providerRelationDescriptors,
+  descriptorSelectionPolicy,
+  defaultResolutionRelations
+} from "@lorion-org/descriptor-selection";
+
+// src/runtime-config.ts
+import { createContext, createElement, useContext } from "react";
+var emptyRuntimeConfig = Object.freeze({ public: Object.freeze({}) });
+var CapabilityRuntimeConfigContext = createContext(emptyRuntimeConfig);
+function CapabilityRuntimeConfigProvider({
+  children,
+  runtimeConfig
+}) {
+  return createElement(CapabilityRuntimeConfigContext.Provider, { value: runtimeConfig }, children);
+}
+function useCapabilityRuntimeConfigScope(capabilityId) {
+  return getCapabilityRuntimeConfigScope(useCapabilityRuntimeConfigRoot(), capabilityId);
+}
+function useCapabilityRuntimeConfig(capabilityId) {
+  return getCapabilityRuntimeConfig(useCapabilityRuntimeConfigRoot(), capabilityId);
+}
+function useCapabilityRuntimeConfigRoot() {
+  return useContext(CapabilityRuntimeConfigContext);
+}
+function getCapabilityRuntimeConfigScope(runtimeConfig, capabilityId) {
+  const publicConfig = runtimeConfig.public[capabilityId];
+  return publicConfig && typeof publicConfig === "object" && !Array.isArray(publicConfig) ? publicConfig : {};
+}
+function getCapabilityRuntimeConfig(runtimeConfig, capabilityId) {
+  return {
+    public: getCapabilityRuntimeConfigScope(runtimeConfig, capabilityId)
+  };
+}
+
+// src/index.ts
 function defineExtensionPoint(id) {
   return { id };
 }
@@ -29,16 +68,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,
@@ -68,15 +116,15 @@ function createCapabilityRuntime(capabilities) {
     getContributions: (extensionPoint) => [...contributions.get(extensionPoint.id) ?? []]
   };
 }
-var CapabilityRuntimeContext = createContext(null);
+var CapabilityRuntimeContext = createContext2(null);
 function CapabilityRuntimeProvider({
   children,
   runtime
 }) {
-  return createElement(CapabilityRuntimeContext.Provider, { value: runtime }, children);
+  return createElement2(CapabilityRuntimeContext.Provider, { value: runtime }, children);
 }
 function useCapabilityRuntime() {
-  const runtime = useContext(CapabilityRuntimeContext);
+  const runtime = useContext2(CapabilityRuntimeContext);
   if (!runtime) {
     throw new Error("useCapabilityRuntime must be used inside CapabilityRuntimeProvider.");
   }
@@ -113,16 +161,26 @@ function collectContributions(capabilities) {
 }
 function createCapabilityCatalog(capabilities) {
   return createDescriptorCatalog({
-    descriptors: capabilities.map((capability) => capability.manifest)
+    descriptors: capabilities.map((capability) => capability.manifest),
+    relationDescriptors: providerRelationDescriptors
   });
 }
 export {
+  CapabilityRuntimeConfigProvider,
   CapabilityRuntimeProvider,
+  descriptorSelectionPolicy as createCapabilityCompositionPolicy,
   createCapabilityRuntime,
   createContributionContract,
+  providerRelationDescriptors as defaultCapabilityRelationDescriptors,
+  defaultResolutionRelations as defaultCapabilityResolutionRelations,
   defineCapability,
   defineContribution,
   defineExtensionPoint,
   getCapabilityProviderSelection,
-  useCapabilityRuntime
+  getCapabilityRuntimeConfig,
+  getCapabilityRuntimeConfigScope,
+  useCapabilityRuntime,
+  useCapabilityRuntimeConfig,
+  useCapabilityRuntimeConfigRoot,
+  useCapabilityRuntimeConfigScope
 };

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
@@ -22,21 +32,36 @@ var vite_exports = {};
 __export(vite_exports, {
   capabilityLoader: () => capabilityLoader,
   createCapabilityRouteConfig: () => createCapabilityRouteConfig,
+  createReactRuntimeConfig: () => createReactRuntimeConfig,
   discoverCapabilities: () => discoverCapabilities,
   discoverSelectedCapabilities: () => discoverSelectedCapabilities,
   lorionReact: () => lorionReact,
-  renderCapabilityModule: () => renderCapabilityModule
+  renderCapabilityModule: () => renderCapabilityModule,
+  renderRuntimeConfigModule: () => renderRuntimeConfigModule,
+  renderServerRuntimeConfigModule: () => renderServerRuntimeConfigModule
 });
 module.exports = __toCommonJS(vite_exports);
 var import_node_fs = require("fs");
 var import_node_path = require("path");
-var import_composition_graph = require("@lorion-org/composition-graph");
+var import_node_process = __toESM(require("process"), 1);
+var import_vite = require("vite");
 var import_descriptor_discovery = require("@lorion-org/descriptor-discovery");
+var import_descriptor_selection = require("@lorion-org/descriptor-selection");
+var import_runtime_config = require("@lorion-org/runtime-config");
+var import_runtime_config_node = require("@lorion-org/runtime-config-node");
+var import_surface_activation = require("@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",
@@ -46,62 +71,132 @@ 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);
+      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 ? (0, import_runtime_config_node.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 = (0, import_runtime_config.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 = (0, import_node_path.resolve)(workspaceRoot, options.capabilitiesDir ?? "capabilities");
   if (!(0, import_node_fs.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);
-  if (!options.selected?.length && !options.baseDescriptors?.length) {
-    return [...enabledCapabilities];
-  }
-  const catalog = (0, import_composition_graph.createDescriptorCatalog)({
-    descriptors: enabledCapabilities.map((capability) => capability.manifest)
-  });
-  const selection = (0, import_composition_graph.createCompositionSelection)({
-    catalog,
-    selected: [...options.selected ?? []],
-    baseDescriptors: [...options.baseDescriptors ?? []],
+  return (0, import_descriptor_selection.selectDescriptors)({
+    items: capabilities,
+    getDescriptor: (capability) => capability.manifest,
+    withDescriptor: (capability, manifest) => ({ ...capability, manifest }),
+    seed: options,
+    ...options.relationDescriptors ? { relationDescriptors: options.relationDescriptors } : {},
     ...options.policy ? { policy: options.policy } : {}
   });
-  const selectedIds = new Set(selection.getResolved());
-  return enabledCapabilities.filter((capability) => selectedIds.has(capability.id));
 }
-function renderCapabilityModule(capabilities) {
-  const imports = capabilities.map(
-    (capability) => `import { capability as ${capability.variableName} } from '${capability.importSpecifier}'`
+function resolveSelectionSeed(options) {
+  return (0, import_descriptor_selection.resolveDescriptorSelection)(options);
+}
+function renderCapabilityModule(capabilities, selected = []) {
+  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}
 
+export const selectedCapabilityIds = ${JSON.stringify([...selected])}
+
+export const resolvedCapabilityIds = ${JSON.stringify(capabilityIds)}
+
 export const capabilityModules = [
 ${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.");
@@ -140,7 +235,7 @@ function discoverCapabilityDescriptors(workspaceRoot, options) {
     }
   });
 }
-function discoverCapability(entry) {
+function discoverCapability(entry, resolveActivation) {
   const capabilityDir = entry.cwd;
   const packagePath = (0, import_node_path.resolve)(capabilityDir, "package.json");
   if (!(0, import_node_fs.existsSync)(packagePath)) {
@@ -149,42 +244,235 @@ 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 = (0, import_descriptor_discovery.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 = (0, import_node_path.resolve)(capabilityDir, "src", "routes");
-  return (0, import_node_fs.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": ${(0, import_node_path.resolve)(capabilityDir, "package.json")}`
-    );
+function resolveRuntimeConfigPatternSource(workspaceRoot, options, env) {
+  if (!options.source?.paths.length) {
+    const varDir = resolveRuntimeConfigVarDir(workspaceRoot, options.varDir, env);
+    return {
+      paths: [(0, import_node_path.join)(varDir, "runtime-config", "*", options.configFileName)]
+    };
+  }
+  return {
+    paths: options.source.paths.map(
+      (entry) => (0, import_node_path.isAbsolute)(entry) ? entry : (0, import_node_path.resolve)(workspaceRoot, entry)
+    )
+  };
+}
+function resolveRuntimeConfigVarDir(workspaceRoot, options, env) {
+  const rawVarDir = typeof options === "string" ? options : (0, import_runtime_config_node.resolveRuntimeConfigSource)({
+    defaultVarDir: (0, import_node_path.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 (0, import_node_path.isAbsolute)(rawVarDir) ? rawVarDir : (0, import_node_path.resolve)(workspaceRoot, rawVarDir);
+}
+function resolveRuntimeConfigEnv(viteConfig, options) {
+  if (options === false) return {};
+  if (options.env) return options.env;
+  const mode = viteConfig.mode ?? import_node_process.default.env.NODE_ENV ?? "development";
+  const envDir = typeof viteConfig.envDir === "string" ? viteConfig.envDir : viteConfig.root ?? import_node_process.default.cwd();
+  return {
+    ...(0, import_vite.loadEnv)(mode, envDir, ""),
+    ...import_node_process.default.env,
+    ...viteConfig.env ?? {}
+  };
+}
+function readRuntimeConfigSchemas(capabilities, schemaFileName) {
+  const paths = /* @__PURE__ */ new Map();
+  const schemas = {};
+  for (const capability of capabilities) {
+    const schemaPath = (0, import_node_path.resolve)(capability.capabilityDir, schemaFileName);
+    const schema = (0, import_runtime_config_node.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;
   }
-  if (!isRecord(packageExports) || typeof packageExports["./capability"] !== "string") {
-    throw new Error(`Capability package is missing a "./capability" export: ${capabilityDir}`);
+  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 (0, import_runtime_config.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: (0, import_node_path.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 (0, import_runtime_config.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 = (0, import_runtime_config.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 = (0, import_runtime_config.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 = (0, import_node_path.resolve)(capabilityDir, "src", "routes");
+  return (0, import_node_fs.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: (0, import_node_path.resolve)(capabilityDir, packageExports["./capability"]),
+      exportName: "capability",
+      importSpecifier: (0, import_surface_activation.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: (0, import_surface_activation.capabilitySpecifier)(packageName, exportSubpath) };
 }
 function hasRouteDirectory(capability) {
   return typeof capability.routesDirectory === "string";
@@ -222,8 +510,11 @@ function toPosixPath(path) {
 0 && (module.exports = {
   capabilityLoader,
   createCapabilityRouteConfig,
+  createReactRuntimeConfig,
   discoverCapabilities,
   discoverSelectedCapabilities,
   lorionReact,
-  renderCapabilityModule
+  renderCapabilityModule,
+  renderRuntimeConfigModule,
+  renderServerRuntimeConfigModule
 });