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

package/dist/index.js

@@ -1,11 +1,5 @@
-import {
-  createCapabilityCompositionPolicy,
-  defaultCapabilityRelationDescriptors,
-  defaultCapabilityResolutionRelations
-} from "./chunk-5FUI4JPB.js";
-
 // src/index.ts
-import { createContext, createElement, useContext } from "react";
+import { createContext as createContext2, createElement as createElement2, useContext as useContext2 } from "react";
 import {
   assertKnownDescriptorIds,
   createDescriptorCatalog
@@ -15,6 +9,44 @@ import {
   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 };
 }
@@ -84,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.");
   }
@@ -130,19 +162,25 @@ function collectContributions(capabilities) {
 function createCapabilityCatalog(capabilities) {
   return createDescriptorCatalog({
     descriptors: capabilities.map((capability) => capability.manifest),
-    relationDescriptors: defaultCapabilityRelationDescriptors
+    relationDescriptors: providerRelationDescriptors
   });
 }
 export {
+  CapabilityRuntimeConfigProvider,
   CapabilityRuntimeProvider,
-  createCapabilityCompositionPolicy,
+  descriptorSelectionPolicy as createCapabilityCompositionPolicy,
   createCapabilityRuntime,
   createContributionContract,
-  defaultCapabilityRelationDescriptors,
-  defaultCapabilityResolutionRelations,
+  providerRelationDescriptors as defaultCapabilityRelationDescriptors,
+  defaultResolutionRelations as defaultCapabilityResolutionRelations,
   defineCapability,
   defineContribution,
   defineExtensionPoint,
   getCapabilityProviderSelection,
-  useCapabilityRuntime
+  getCapabilityRuntimeConfig,
+  getCapabilityRuntimeConfigScope,
+  useCapabilityRuntime,
+  useCapabilityRuntimeConfig,
+  useCapabilityRuntimeConfigRoot,
+  useCapabilityRuntimeConfigScope
 };

package/dist/vite.cjs

@@ -32,58 +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_node_process = __toESM(require("process"), 1);
-var import_composition_graph = require("@lorion-org/composition-graph");
+var import_vite = require("vite");
 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 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",
@@ -93,107 +71,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 ? (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);
-  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: selectionCapabilities.map((capability) => capability.manifest),
-    relationDescriptors: [
-      ...defaultCapabilityRelationDescriptors,
-      ...options.relationDescriptors ?? []
-    ]
-  });
-  const selection = (0, import_composition_graph.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 = (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
-      }
-    };
+  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 } : {}
   });
 }
 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 = (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 ?? []];
+  return (0, import_descriptor_selection.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}
 
@@ -206,6 +187,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.");
@@ -244,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)) {
@@ -253,43 +244,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 = (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";
 }
@@ -326,8 +510,11 @@ function toPosixPath(path) {
 0 && (module.exports = {
   capabilityLoader,
   createCapabilityRouteConfig,
+  createReactRuntimeConfig,
   discoverCapabilities,
   discoverSelectedCapabilities,
   lorionReact,
-  renderCapabilityModule
+  renderCapabilityModule,
+  renderRuntimeConfigModule,
+  renderServerRuntimeConfigModule
 });