@lorion-org/nuxt 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/index.js

@@ -6,6 +6,7 @@ import {
   addServerImports,
   addServerTemplate,
   addTemplate,
+  addTypeTemplate,
   createResolver,
   defineNuxtModule,
   useLogger
@@ -14,12 +15,19 @@ import {
 // src/extensions.ts
 import { existsSync } from "fs";
 import { join } from "path";
+import process from "process";
 import {
-  createDescriptorCatalog
+  createDescriptorCatalog,
+  parseDescriptorIds,
+  resolveDescriptorSelectionSeed
 } from "@lorion-org/composition-graph";
 import { discoverDescriptors } from "@lorion-org/descriptor-discovery";
 import {
-  resolveItemProviderSelection
+  collectProviderDefaults,
+  collectProviderPreferences,
+  collectSelectedProviderPreferences,
+  resolveItemProviderSelection,
+  resolveSelectedProviderRelationPreferences
 } from "@lorion-org/provider-selection";
 
 // src/extension-descriptor.schema.json
@@ -45,8 +53,19 @@ var extension_descriptor_schema_default = {
         },
         version: { $ref: "#/$defs/semver" },
         providesFor: {
-          type: "string",
-          minLength: 1
+          oneOf: [
+            {
+              type: "string",
+              minLength: 1
+            },
+            {
+              type: "array",
+              items: {
+                type: "string",
+                minLength: 1
+              }
+            }
+          ]
         },
         capabilities: {
           type: "array",
@@ -58,6 +77,21 @@ var extension_descriptor_schema_default = {
         dependencies: { $ref: "#/$defs/dependencyMap" },
         disabled: { type: "boolean" },
         location: { type: "string" },
+        defaultFor: {
+          oneOf: [
+            {
+              type: "string",
+              minLength: 1
+            },
+            {
+              type: "array",
+              items: {
+                type: "string",
+                minLength: 1
+              }
+            }
+          ]
+        },
         providerPreferences: {
           type: "object",
           additionalProperties: {
@@ -69,6 +103,16 @@ var extension_descriptor_schema_default = {
           type: "object",
           additionalProperties: true
         },
+        runtimeConfig: {
+          type: "object",
+          properties: {
+            validation: {
+              type: "string",
+              enum: ["none", "optional", "startup", "onUse"]
+            }
+          },
+          additionalProperties: false
+        },
         bundles: {
           type: "array",
           items: { $ref: "#/$defs/extension" }
@@ -89,20 +133,38 @@ var defaultExtensionOptions = {
   publicRuntimeConfigKey: "extensionSelection",
   descriptorPaths: ["extensions/*/extension.json"]
 };
+var defaultExtensionSelectionSeedKey = "capability";
+var defaultExtensionResolutionRelations = [
+  "dependencies",
+  "defaultProviders",
+  "providerPreferences"
+];
+var defaultNuxtRelationDescriptors = [
+  {
+    direction: "incoming",
+    field: "defaultFor",
+    id: "defaultProviders"
+  },
+  {
+    id: "providerPreferences",
+    field: "providerPreferences",
+    targetMode: "values"
+  }
+];
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function asArray(value) {
-  if (value === void 0) return [];
-  return Array.isArray(value) ? value : [value];
-}
-function splitSelectionValue(value) {
-  return value.split(/[,\s]+/).map((entry) => entry.trim()).filter(Boolean);
-}
 function normalizeSelection(value) {
-  return asArray(value).flatMap((entry) => {
-    if (typeof entry !== "string") return [];
-    return splitSelectionValue(entry);
+  return parseDescriptorIds(value);
+}
+function resolveNuxtExtensionSelectionSeed(seedOptions) {
+  if (seedOptions === false) return [];
+  return resolveDescriptorSelectionSeed({
+    argv: seedOptions?.argv ?? process.argv,
+    env: seedOptions?.env ?? process.env,
+    key: seedOptions?.key ?? defaultExtensionSelectionSeedKey,
+    ...seedOptions?.cliKeys ? { cliKeys: seedOptions.cliKeys } : {},
+    ...seedOptions?.envKeys ? { envKeys: seedOptions.envKeys } : {}
   });
 }
 function resolveExtensionOptions(options) {
@@ -132,6 +194,10 @@ function findNuxtConfigFile(cwd) {
   return ["nuxt.config.ts", "nuxt.config.mts", "nuxt.config.js", "nuxt.config.mjs"].map((fileName) => optionalFile(join(cwd, fileName))).find(Boolean);
 }
 function createExtensionEntry(input) {
+  const descriptor = {
+    ...input.descriptor,
+    location: input.descriptor.location ?? input.cwd
+  };
   const appDir = optionalDir(join(input.cwd, "app"));
   const modulesDir = optionalDir(join(input.cwd, "modules"));
   const publicDir = optionalDir(join(input.cwd, "public"));
@@ -140,7 +206,7 @@ function createExtensionEntry(input) {
   const configFile = findNuxtConfigFile(input.cwd);
   const entry = {
     cwd: input.cwd,
-    descriptor: input.descriptor
+    descriptor
   };
   if (appDir) entry.appDir = appDir;
   if (configFile) entry.configFile = configFile;
@@ -158,7 +224,7 @@ function canRegisterExtensionLayer(entry) {
 function canExtendExtensionLayer(entry) {
   return Boolean(entry.configFile);
 }
-function discoverExtensionEntries(input) {
+function discoverNuxtExtensionEntries(input) {
   const resolvedOptions = resolveExtensionOptions(input.options);
   return discoverDescriptors({
     cwd: input.projectRootDir,
@@ -176,9 +242,47 @@ function discoverExtensionEntries(input) {
     })
   );
 }
+function createNuxtExtensionCatalog(input) {
+  return createDescriptorCatalog({
+    descriptors: input.entries.map((entry) => entry.descriptor),
+    relationDescriptors: [...defaultNuxtRelationDescriptors, ...input.relationDescriptors ?? []]
+  });
+}
+function createNuxtExtensionEntryMap(entries) {
+  return new Map(entries.map((entry) => [entry.descriptor.id, entry]));
+}
 function pickEntriesById(ids, entryById) {
   return ids.map((id) => entryById.get(id)).filter((entry) => Boolean(entry));
 }
+function createNuxtSelectedProviderPreferences(input) {
+  return collectSelectedProviderPreferences({
+    items: input.entries,
+    getCapabilityId: (entry) => entry.descriptor.providesFor,
+    getProviderId: (entry) => entry.descriptor.id,
+    selectedProviderIds: input.selectedExtensions
+  });
+}
+function createProviderSelectionAwareEntries(entries, selectedProviders) {
+  if (!Object.keys(selectedProviders).length) return entries;
+  return entries.map((entry) => {
+    const descriptor = { ...entry.descriptor };
+    const preferences = resolveSelectedProviderRelationPreferences({
+      providerId: entry.descriptor.id,
+      defaultFor: entry.descriptor.defaultFor,
+      providerPreferences: entry.descriptor.providerPreferences,
+      selectedProviders
+    });
+    delete descriptor.defaultFor;
+    delete descriptor.providerPreferences;
+    return {
+      ...entry,
+      descriptor: {
+        ...descriptor,
+        ...preferences
+      }
+    };
+  });
+}
 function mergeRuntimeConfigSection(target = {}, source = {}) {
   const merged = { ...target };
   for (const [key, value] of Object.entries(source)) {
@@ -215,10 +319,10 @@ function createNuxtExtensionBootstrap(input) {
   const options = input.options ?? {};
   const selectedExtensions = resolveExtensionSelection({
     ...options.defaultSelection ? { defaultSelection: options.defaultSelection } : {},
-    ...options.selected ? { selected: options.selected } : {}
+    selected: options.selected ?? resolveNuxtExtensionSelectionSeed(options.selectionSeed)
   });
-  const createCatalog = (entries2) => createDescriptorCatalog({
-    descriptors: entries2.map((entry) => entry.descriptor),
+  const createCatalog = (entries2) => createNuxtExtensionCatalog({
+    entries: entries2,
     ...options.relationDescriptors ? { relationDescriptors: options.relationDescriptors } : {}
   });
   if (options.enabled === false) {
@@ -233,7 +337,7 @@ function createNuxtExtensionBootstrap(input) {
       selectedExtensions
     };
   }
-  const entries = discoverExtensionEntries({
+  const entries = discoverNuxtExtensionEntries({
     projectRootDir: input.rootDir,
     options
   });
@@ -242,7 +346,6 @@ function createNuxtExtensionBootstrap(input) {
     options,
     selectedExtensions
   });
-  const entryById = new Map(entries.map((entry) => [entry.descriptor.id, entry]));
   if (!entries.length) {
     return {
       activeExtensions: [],
@@ -255,13 +358,26 @@ function createNuxtExtensionBootstrap(input) {
       selectedExtensions
     };
   }
-  const catalog = createCatalog(entries);
+  const selectedProviders = createNuxtSelectedProviderPreferences({
+    entries,
+    selectedExtensions
+  });
+  const resolutionEntries = createProviderSelectionAwareEntries(entries, selectedProviders);
+  const catalog = createCatalog(resolutionEntries);
   const selection = catalog.resolveSelection({
     baseDescriptors: baseExtensionIds,
+    policy: {
+      inspectionRelationIds: defaultExtensionResolutionRelations,
+      provenanceRelationIds: defaultExtensionResolutionRelations,
+      resolutionRelationIds: defaultExtensionResolutionRelations
+    },
     selected: selectedExtensions
   });
   const resolvedExtensionIds = selection.getResolved();
-  const resolvedExtensions = pickEntriesById(resolvedExtensionIds, entryById);
+  const resolvedExtensions = pickEntriesById(
+    resolvedExtensionIds,
+    createNuxtExtensionEntryMap(resolutionEntries)
+  );
   const activeExtensions = resolvedExtensions.filter(canRegisterExtensionLayer);
   return {
     activeExtensions,
@@ -284,38 +400,38 @@ function createNuxtExtensionBootstrap(input) {
 function createNuxtExtensionLayerPaths(bootstrap) {
   return bootstrap.activeExtensions.filter(canExtendExtensionLayer).map((extension) => extension.cwd);
 }
-function collectProviderPreferences(extensions) {
-  return extensions.reduce((preferences, extension) => {
-    const value = extension.descriptor.providerPreferences;
-    if (!isRecord(value)) return preferences;
-    return {
-      ...preferences,
-      ...Object.fromEntries(
-        Object.entries(value).filter(
-          (entry) => typeof entry[1] === "string" && entry[1].length > 0
-        )
-      )
-    };
-  }, {});
-}
 function createNuxtProviderSelectionRuntimeConfig(extensions, options = {}) {
   const publicRuntimeConfigKey = "providerSelection";
-  const descriptorPreferences = collectProviderPreferences(extensions);
-  const configuredProviders = {
+  const descriptorPreferences = collectProviderPreferences({
+    items: extensions,
+    getProviderPreferences: (extension) => extension.descriptor.providerPreferences
+  });
+  const providerDefaults = collectProviderDefaults({
+    items: extensions,
+    getDefaultFor: (extension) => extension.descriptor.defaultFor,
+    getProviderId: (extension) => extension.descriptor.id
+  });
+  const configuredProviders = options.configuredProviders ?? {};
+  const selectedProviders = options.selectedProviders ?? {};
+  const fallbackProviders = {
+    ...providerDefaults,
     ...descriptorPreferences,
-    ...options.configuredProviders ?? {}
+    ...options.fallbackProviders ?? {}
   };
   const resolution = resolveItemProviderSelection({
     items: extensions,
     getCapabilityId: (extension) => extension.descriptor.providesFor,
     getProviderId: (extension) => extension.descriptor.id,
-    configuredProviders
+    configuredProviders,
+    fallbackProviders,
+    selectedProviders
   });
   return {
     public: {
       [publicRuntimeConfigKey]: {
         configuredProviders,
         excludedProviderIds: resolution.excludedProviderIds,
+        fallbackProviders,
         mismatches: resolution.mismatches,
         selections: Object.fromEntries(resolution.selections)
       }
@@ -468,14 +584,27 @@ function validateNuxtRuntimeConfigSourceScopes(source, targets, options = {}) {
 }
 
 // src/module.ts
+import {
+  resolveRuntimeConfigValidationMode,
+  shouldRequireRuntimeConfigAtStartup
+} from "@lorion-org/runtime-config";
+import {
+  assertRequiredRuntimeConfigValidationTargets,
+  readRuntimeConfigSchemaRegistry
+} from "@lorion-org/runtime-config-node";
 var runtimeConfigImportNames = [
   "useRuntimeConfigFragment",
+  "useValidatedRuntimeConfigFragment",
   "useRuntimeConfigScope",
+  "useValidatedRuntimeConfigScope",
   "usePublicRuntimeConfigScope",
+  "usePublicValidatedRuntimeConfigScope",
   "usePrivateRuntimeConfigScope",
+  "usePrivateValidatedRuntimeConfigScope",
   "useRuntimeConfigValue"
 ];
-var runtimeConfigComposablesTemplate = "lorion/runtime-config-composables.ts";
+var runtimeConfigComposablesTemplate = "lorion/runtime-config-composables.mjs";
+var runtimeConfigComposablesImport = "#build/lorion/runtime-config-composables";
 var serverRuntimeConfigComposablesTemplate = "#internal/lorion-runtime-config-composables.mjs";
 var defaultRuntimeConfigSource = {
   contextInputKey: "contexts",
@@ -513,6 +642,7 @@ function normalizeImportPath(path) {
   return path.replace(/\\/g, "/");
 }
 function createRuntimeConfigComposablesSource(input) {
+  const validationSchemasSource = JSON.stringify(input.validationSchemas);
   const typeImports = input.typed ? `
 import type {
   GetRuntimeConfigFragmentOptions,
@@ -569,6 +699,7 @@ export type UseRuntimeConfigFragmentOptions =
     valueReturn: ""
   };
   return `import { useRuntimeConfig } from '${input.useRuntimeConfigFrom}'
+import { createRuntimeConfigValidatorRegistry } from '@lorion-org/runtime-config'
 import {
   getNuxtRuntimeConfigFragment,
   getNuxtRuntimeConfigScope,
@@ -578,6 +709,12 @@ import {
 } from '${input.runtimeConfigFrom}'
 ${typeImports}
 const runtimeConfigDefaultsKey = '__lorionNuxt'
+const runtimeConfigValidationSchemas = ${validationSchemasSource}
+const runtimeConfigValidatorRegistry = createRuntimeConfigValidatorRegistry(runtimeConfigValidationSchemas)
+
+function assertValidatedRuntimeConfigFragment(scopeId, fragment) {
+  runtimeConfigValidatorRegistry.assert(scopeId, fragment)
+}
 
 function getComposableDefaults(runtimeConfig${typeAnnotations.runtimeConfig})${typeAnnotations.defaults} {
   const container = runtimeConfig.public?.[runtimeConfigDefaultsKey]
@@ -606,24 +743,66 @@ export function useRuntimeConfigFragment(scopeId, options${typeAnnotations.fragm
   return getNuxtRuntimeConfigFragment(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options))
 }
 
+export function useValidatedRuntimeConfigFragment(scopeId, options${typeAnnotations.fragmentOptions} = {})${typeAnnotations.fragmentReturn} {
+  const runtimeConfig = useRuntimeConfig()
+  const fragment = getNuxtRuntimeConfigFragment(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options))
+
+  assertValidatedRuntimeConfigFragment(scopeId, fragment)
+
+  return fragment
+}
+
 export function useRuntimeConfigScope${typeAnnotations.scopeReturn}(scopeId, options${typeAnnotations.scopeOptions} = {}) {
   const runtimeConfig = useRuntimeConfig()
 
   return getNuxtRuntimeConfigScope(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options))
 }
 
+export function useValidatedRuntimeConfigScope${typeAnnotations.scopeReturn}(scopeId, options${typeAnnotations.scopeOptions} = {}) {
+  const runtimeConfig = useRuntimeConfig()
+
+  assertValidatedRuntimeConfigFragment(
+    scopeId,
+    getNuxtRuntimeConfigFragment(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options)),
+  )
+
+  return getNuxtRuntimeConfigScope(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options))
+}
+
 export function usePublicRuntimeConfigScope${typeAnnotations.scopeReturn}(scopeId, options${typeAnnotations.publicOptions} = {}) {
   const runtimeConfig = useRuntimeConfig()
 
   return getPublicNuxtRuntimeConfigScope(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options))
 }
 
+export function usePublicValidatedRuntimeConfigScope${typeAnnotations.scopeReturn}(scopeId, options${typeAnnotations.publicOptions} = {}) {
+  const runtimeConfig = useRuntimeConfig()
+
+  assertValidatedRuntimeConfigFragment(
+    scopeId,
+    getNuxtRuntimeConfigFragment(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options)),
+  )
+
+  return getPublicNuxtRuntimeConfigScope(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options))
+}
+
 export function usePrivateRuntimeConfigScope${typeAnnotations.scopeReturn}(scopeId, options${typeAnnotations.privateOptions} = {}) {
   const runtimeConfig = useRuntimeConfig()
 
   return getPrivateNuxtRuntimeConfigScope(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options))
 }
 
+export function usePrivateValidatedRuntimeConfigScope${typeAnnotations.scopeReturn}(scopeId, options${typeAnnotations.privateOptions} = {}) {
+  const runtimeConfig = useRuntimeConfig()
+
+  assertValidatedRuntimeConfigFragment(
+    scopeId,
+    getNuxtRuntimeConfigFragment(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options)),
+  )
+
+  return getPrivateNuxtRuntimeConfigScope(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options))
+}
+
 export function useRuntimeConfigValue${typeAnnotations.valueOptions}(scopeId, key, options${typeAnnotations.valueOptionsType} = {})${typeAnnotations.valueReturn} {
   const runtimeConfig = useRuntimeConfig()
 
@@ -631,6 +810,72 @@ export function useRuntimeConfigValue${typeAnnotations.valueOptions}(scopeId, ke
 }
 `;
 }
+function createRuntimeConfigComposablesTypesSource() {
+  return `declare module '${runtimeConfigComposablesImport}' {
+  import type {
+    GetRuntimeConfigFragmentOptions,
+    GetRuntimeConfigScopeOptions,
+    ResolveRuntimeConfigValueFromRuntimeConfigOptions,
+    RuntimeConfigContext,
+    RuntimeConfigSection,
+  } from '@lorion-org/runtime-config'
+
+  type NuxtPrivateRuntimeConfigMode = 'root' | 'section'
+  type ReadNuxtRuntimeConfigOptions = {
+    privateInput?: NuxtPrivateRuntimeConfigMode
+  }
+
+  export function useRuntimeConfigFragment(
+    scopeId: string,
+    options?: GetRuntimeConfigFragmentOptions & ReadNuxtRuntimeConfigOptions,
+  ): RuntimeConfigContext
+  export function useValidatedRuntimeConfigFragment(
+    scopeId: string,
+    options?: GetRuntimeConfigFragmentOptions & ReadNuxtRuntimeConfigOptions,
+  ): RuntimeConfigContext
+  export function useRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(
+    scopeId: string,
+    options?: GetRuntimeConfigScopeOptions & ReadNuxtRuntimeConfigOptions,
+  ): T
+  export function useValidatedRuntimeConfigScope<
+    T extends RuntimeConfigSection = RuntimeConfigSection,
+  >(scopeId: string, options?: GetRuntimeConfigScopeOptions & ReadNuxtRuntimeConfigOptions): T
+  export function usePublicRuntimeConfigScope<
+    T extends RuntimeConfigSection = RuntimeConfigSection,
+  >(
+    scopeId: string,
+    options?: Omit<GetRuntimeConfigScopeOptions, 'visibility'> & ReadNuxtRuntimeConfigOptions,
+  ): T
+  export function usePublicValidatedRuntimeConfigScope<
+    T extends RuntimeConfigSection = RuntimeConfigSection,
+  >(
+    scopeId: string,
+    options?: Omit<GetRuntimeConfigScopeOptions, 'visibility'> & ReadNuxtRuntimeConfigOptions,
+  ): T
+  export function usePrivateRuntimeConfigScope<
+    T extends RuntimeConfigSection = RuntimeConfigSection,
+  >(
+    scopeId: string,
+    options?: Omit<GetRuntimeConfigScopeOptions, 'visibility'> & ReadNuxtRuntimeConfigOptions,
+  ): T
+  export function usePrivateValidatedRuntimeConfigScope<
+    T extends RuntimeConfigSection = RuntimeConfigSection,
+  >(
+    scopeId: string,
+    options?: Omit<GetRuntimeConfigScopeOptions, 'visibility'> & ReadNuxtRuntimeConfigOptions,
+  ): T
+  export function useRuntimeConfigValue<T = unknown>(
+    scopeId: string,
+    key: string,
+    options?: ResolveRuntimeConfigValueFromRuntimeConfigOptions<T> & ReadNuxtRuntimeConfigOptions,
+  ): T | undefined
+}
+
+declare module '${serverRuntimeConfigComposablesTemplate}' {
+  export * from '${runtimeConfigComposablesImport}'
+}
+`;
+}
 function createDefaultRuntimeConfigOptions(rootDir) {
   const paths = defaultRuntimeConfigSource.paths.map((pattern) => join2(rootDir, pattern));
   const runtimeConfigDir = join2(rootDir, ".runtimeconfig", "runtime-config");
@@ -660,43 +905,115 @@ function registerRuntimeConfigPublicAssets(options, nuxt) {
   });
 }
 function resolveRuntimeConfigValidationTargets(bootstrap) {
-  return bootstrap?.resolvedExtensions.map((extension) => ({
+  return bootstrap?.resolvedExtensions.filter((extension) => extension.descriptor.runtimeConfig !== void 0).map((extension) => ({
     scopeId: extension.descriptor.id,
-    cwd: extension.cwd
+    cwd: extension.cwd,
+    policy: extension.descriptor.runtimeConfig
   })) ?? [];
 }
+function createRuntimeConfigValidationSchemas(options, bootstrap) {
+  if (options.validation === false || !options.validation) return {};
+  return readRuntimeConfigSchemaRegistry(resolveRuntimeConfigValidationTargets(bootstrap), {
+    ...options.validation.schemaFileName ? { schemaFileName: options.validation.schemaFileName } : {}
+  });
+}
+function createRuntimeConfigValidationPolicyByScope(targets) {
+  return new Map(targets.map((target) => [target.scopeId, target.policy]));
+}
+function formatRuntimeConfigValidationMode(policy) {
+  return resolveRuntimeConfigValidationMode(policy);
+}
+function isRuntimeConfigValidationFatal(scopeId, policyByScope) {
+  return shouldRequireRuntimeConfigAtStartup(policyByScope.get(scopeId));
+}
+function formatRuntimeConfigSkippedValidationDetails(skipped, mode) {
+  if (skipped.reason === "missing-schema") {
+    return [
+      `RuntimeConfig schema file missing for "${skipped.scopeId}" (${mode}).`,
+      ...skipped.schemaPath ? [`missing schema file: ${skipped.schemaPath}`] : [],
+      ...skipped.configPath ? [`runtime config file: ${skipped.configPath}`] : []
+    ].join(" ");
+  }
+  if (skipped.reason === "missing-config") {
+    return [
+      `RuntimeConfig file missing for "${skipped.scopeId}" (${mode}).`,
+      ...skipped.configPath ? [`expected runtime config file: ${skipped.configPath}`] : [],
+      ...skipped.schemaPath ? [`schema file: ${skipped.schemaPath}`] : []
+    ].join(" ");
+  }
+  return [
+    `RuntimeConfig validation target has no schema directory for "${skipped.scopeId}" (${mode}).`,
+    ...skipped.configPath ? [`runtime config file: ${skipped.configPath}`] : [],
+    ...skipped.schemaPath ? [`schema file: ${skipped.schemaPath}`] : []
+  ].join(" ");
+}
+function reportRuntimeConfigValidationResult(result, targets) {
+  if (!result.skipped.length && !result.invalid.length) return;
+  const logger = useLogger("lorion");
+  const policyByScope = createRuntimeConfigValidationPolicyByScope(targets);
+  for (const skipped of result.skipped) {
+    const fatal = isRuntimeConfigValidationFatal(skipped.scopeId, policyByScope);
+    const mode = formatRuntimeConfigValidationMode(policyByScope.get(skipped.scopeId));
+    const details = formatRuntimeConfigSkippedValidationDetails(skipped, mode);
+    logger[fatal ? "error" : "warn"](details);
+  }
+  for (const invalid of result.invalid) {
+    const fatal = isRuntimeConfigValidationFatal(invalid.scopeId, policyByScope);
+    const mode = formatRuntimeConfigValidationMode(policyByScope.get(invalid.scopeId));
+    logger[fatal ? "error" : "warn"](
+      [
+        `RuntimeConfig validation failed for "${invalid.scopeId}" (${mode}).`,
+        `runtime config file: ${invalid.configPath}`,
+        `schema file: ${invalid.schemaPath}`,
+        invalid.error.message
+      ].join(" ")
+    );
+  }
+}
 function validateRuntimeConfigSource(options, bootstrap) {
   if (!options.source || options.validation === false || !options.validation) return;
   const targets = resolveRuntimeConfigValidationTargets(bootstrap);
   if (!targets.length) return;
-  validateNuxtRuntimeConfigSourceScopes(options.source, targets, {
+  const result = validateNuxtRuntimeConfigSourceScopes(options.source, targets, {
     ...options.validation.formatError ? { formatError: options.validation.formatError } : {},
     ...options.validation.schemaFileName ? { schemaFileName: options.validation.schemaFileName } : {}
   });
+  reportRuntimeConfigValidationResult(result, targets);
+  assertRequiredRuntimeConfigValidationTargets(result, targets);
 }
-function addRuntimeConfigImports(options) {
-  if (options.imports === false) return;
+function addRuntimeConfigComposables(options, bootstrap, hostImports, registerImports = true) {
   const resolver = createResolver(import.meta.url);
   const runtimeConfigFrom = normalizeImportPath(resolver.resolve("./runtime-config"));
-  const template = addTemplate({
+  const validationSchemas = createRuntimeConfigValidationSchemas(options, bootstrap);
+  addTemplate({
     filename: runtimeConfigComposablesTemplate,
+    write: true,
     getContents: () => createRuntimeConfigComposablesSource({
       runtimeConfigFrom,
-      typed: true,
-      useRuntimeConfigFrom: "nuxt/app"
+      typed: false,
+      useRuntimeConfigFrom: "nuxt/app",
+      validationSchemas
     })
   });
+  addTypeTemplate(
+    {
+      filename: "types/lorion-runtime-config-composables.d.ts",
+      getContents: createRuntimeConfigComposablesTypesSource
+    },
+    { nitro: true, nuxt: true }
+  );
   addServerTemplate({
     filename: serverRuntimeConfigComposablesTemplate,
     getContents: () => createRuntimeConfigComposablesSource({
       runtimeConfigFrom,
       typed: false,
-      useRuntimeConfigFrom: "nitropack/runtime"
+      useRuntimeConfigFrom: "nitropack/runtime",
+      validationSchemas
     })
   });
   const imports = runtimeConfigImportNames.map((name) => ({
     as: name,
-    from: `#build/${template.filename}`,
+    from: runtimeConfigComposablesImport,
     name
   }));
   const serverImports = runtimeConfigImportNames.map((name) => ({
@@ -704,9 +1021,15 @@ function addRuntimeConfigImports(options) {
     from: serverRuntimeConfigComposablesTemplate,
     name
   }));
+  if (!registerImports) return;
+  if (!shouldRegisterRuntimeConfigImports(options, hostImports)) return;
   addImports(imports);
   addServerImports(serverImports);
 }
+function shouldRegisterRuntimeConfigImports(options, hostImports) {
+  if (options.imports !== void 0) return options.imports;
+  return hostImports?.scan !== false;
+}
 function createRuntimeConfigDefaultsConfig(options) {
   return {
     public: {
@@ -727,8 +1050,13 @@ function applyRuntimeConfigModule(input) {
     input.rootDir
   );
   const runtimeConfig = runtimeConfigOptions ? createConfiguredNuxtRuntimeConfig({ runtimeConfig: runtimeConfigOptions }, input.bootstrap) : void 0;
+  addRuntimeConfigComposables(
+    runtimeConfigOptions ?? {},
+    input.bootstrap,
+    input.nuxt.options.imports,
+    Boolean(runtimeConfigOptions)
+  );
   if (!runtimeConfigOptions) return input.currentRuntimeConfig;
-  addRuntimeConfigImports(runtimeConfigOptions);
   registerRuntimeConfigPublicAssets(runtimeConfigOptions, input.nuxt);
   validateRuntimeConfigSource(runtimeConfigOptions, input.bootstrap);
   return mergeNuxtRuntimeConfig(
@@ -738,7 +1066,16 @@ function applyRuntimeConfigModule(input) {
 }
 function createProviderSelectionRuntimeConfig(bootstrap, options) {
   if (options?.enabled === false) return void 0;
-  return createNuxtProviderSelectionRuntimeConfig(bootstrap.resolvedExtensions, options);
+  return createNuxtProviderSelectionRuntimeConfig(bootstrap.resolvedExtensions, {
+    ...options,
+    selectedProviders: {
+      ...createNuxtSelectedProviderPreferences({
+        entries: bootstrap.resolvedExtensions,
+        selectedExtensions: bootstrap.selectedExtensions
+      }),
+      ...options?.selectedProviders ?? {}
+    }
+  });
 }
 function createNuxtExtensionBootstrapLogEvent(input) {
   const providerSelection = input.providerSelectionRuntimeConfig ? getNuxtProviderSelection(input.providerSelectionRuntimeConfig) : void 0;
@@ -855,10 +1192,14 @@ var module_default = lorionNuxtModule;
 export {
   createNuxtExtensionBootstrap,
   createNuxtExtensionBootstrapLogEvent,
+  createNuxtExtensionCatalog,
+  createNuxtExtensionEntryMap,
   createNuxtExtensionLayerPaths,
   createNuxtProviderSelectionRuntimeConfig,
   module_default as default,
+  discoverNuxtExtensionEntries,
   formatNuxtExtensionBootstrapLog,
+  nuxtExtensionDescriptorSchema,
   reportNuxtExtensionBootstrap,
   resolveExtensionSelection
 };