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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lorion-org/nuxt",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.3",
   "description": "Nuxt module for LORION libraries and framework adapters.",
   "license": "MIT",
   "repository": {
@@ -21,30 +21,57 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "lorion-source": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
     "./runtime-config": {
+      "lorion-source": {
+        "types": "./src/runtime-config.ts",
+        "default": "./src/runtime-config.ts"
+      },
       "types": "./dist/runtime-config.d.ts",
       "import": "./dist/runtime-config.js",
       "default": "./dist/runtime-config.js"
     },
     "./runtime-config-node": {
+      "lorion-source": {
+        "types": "./src/runtime-config-node.ts",
+        "default": "./src/runtime-config-node.ts"
+      },
       "types": "./dist/runtime-config-node.d.ts",
       "import": "./dist/runtime-config-node.js",
       "default": "./dist/runtime-config-node.js"
     },
     "./descriptor-schema": {
+      "lorion-source": {
+        "types": "./src/descriptor-schema.ts",
+        "default": "./src/descriptor-schema.ts"
+      },
       "types": "./dist/descriptor-schema.d.ts",
       "import": "./dist/descriptor-schema.js",
       "default": "./dist/descriptor-schema.js"
+    },
+    "./extensions": {
+      "lorion-source": {
+        "types": "./src/extensions.ts",
+        "default": "./src/extensions.ts"
+      },
+      "types": "./dist/extensions.d.ts",
+      "import": "./dist/extensions.js",
+      "default": "./dist/extensions.js"
     }
   },
   "files": [
     "dist",
-    "examples",
-    "LICENSE"
+    "LICENSE",
+    "src/**/*.ts",
+    "src/**/*.json",
+    "!src/**/*.spec.ts"
   ],
   "keywords": [
     "lorion",
@@ -56,11 +83,12 @@
     "node": "^20.19.0 || >=22.12.0"
   },
   "dependencies": {
-    "@lorion-org/runtime-config": "^1.0.0-beta.0",
-    "@lorion-org/runtime-config-node": "^1.0.0-beta.0",
-    "@lorion-org/descriptor-discovery": "^1.0.0-beta.1",
-    "@lorion-org/composition-graph": "^1.0.0-beta.1",
-    "@lorion-org/provider-selection": "^1.0.0-beta.1"
+    "@lorion-org/descriptor-selection": "^1.0.0-beta.3",
+    "@lorion-org/provider-selection": "^1.0.0-beta.2",
+    "@lorion-org/runtime-config": "^1.0.0-beta.1",
+    "@lorion-org/runtime-config-node": "^1.0.0-beta.1",
+    "@lorion-org/composition-graph": "^1.0.0-beta.2",
+    "@lorion-org/descriptor-discovery": "^1.0.0-beta.3"
   },
   "peerDependencies": {
     "@nuxt/kit": "^4.0.0",
@@ -71,19 +99,17 @@
     "@nuxt/schema": "^4.4.2",
     "@nuxt/test-utils": "^3.23.0",
     "nuxt": "^4.4.2",
-    "@lorion-org/registry-hub": "^1.0.0-beta.1"
+    "srvx": "^0.11.15",
+    "@lorion-org/registry-hub": "^1.0.0-beta.2"
   },
   "scripts": {
-    "build": "rimraf dist && tsup src/index.ts src/runtime-config.ts src/runtime-config-node.ts src/descriptor-schema.ts --format esm --dts --splitting false",
+    "build": "rimraf dist && tsup src/index.ts src/runtime-config.ts src/runtime-config-node.ts src/descriptor-schema.ts src/extensions.ts --format esm --dts --splitting false",
     "clean": "rimraf coverage dist tsconfig.tsbuildinfo",
     "lint": "eslint src --ext .ts",
     "package:check": "pnpm build && pnpm pack --dry-run && publint",
     "test": "pnpm test:unit && pnpm test:e2e",
     "test:unit": "vitest run --config test/vitest.unit.config.mts",
     "test:e2e": "vitest run --config test/vitest.e2e.config.mts",
-    "build:playground": "nuxi build playground",
-    "dev:playground": "nuxi dev playground",
-    "typecheck:playground": "nuxi typecheck playground",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   }
 }

package/src/descriptor-schema.ts

@@ -0,0 +1,5 @@
+import extensionDescriptorSchemaData from './extension-descriptor.schema.json';
+
+export type JsonSchemaObject = Record<string, unknown>;
+
+export const nuxtExtensionDescriptorSchema = extensionDescriptorSchemaData as JsonSchemaObject;

package/src/extension-descriptor.schema.json

@@ -0,0 +1,92 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://lorion.dev/schemas/nuxt-extension-descriptor.schema.json",
+  "$ref": "#/$defs/extension",
+  "$defs": {
+    "semver": {
+      "type": "string",
+      "pattern": "^(\\^|~)?\\d+\\.\\d+\\.\\d+$"
+    },
+    "dependencyMap": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#/$defs/semver" }
+    },
+    "extension": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "string",
+          "minLength": 1
+        },
+        "version": { "$ref": "#/$defs/semver" },
+        "providesFor": {
+          "oneOf": [
+            {
+              "type": "string",
+              "minLength": 1
+            },
+            {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "minLength": 1
+              }
+            }
+          ]
+        },
+        "capabilities": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "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": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "publicRuntimeConfig": {
+          "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" }
+        }
+      },
+      "required": ["id", "version"],
+      "additionalProperties": true
+    }
+  }
+}

package/src/extensions.ts

@@ -0,0 +1,458 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+import {
+  createDescriptorCatalog,
+  parseDescriptorIds,
+  resolveDescriptorSelectionSeed,
+  type DescriptorCatalog,
+  type Descriptor,
+  type RelationDescriptor,
+} from '@lorion-org/composition-graph';
+import { discoverDescriptors } from '@lorion-org/descriptor-discovery';
+import {
+  collectProviderDefaults,
+  collectProviderPreferences,
+  collectSelectedProviderPreferences,
+  resolveItemProviderSelection,
+  type ProviderPreferenceMap,
+} from '@lorion-org/provider-selection';
+import {
+  applyProviderSelection,
+  assertSingleDefaultProvider,
+  descriptorSelectionPolicy,
+  providerRelationDescriptors,
+} from '@lorion-org/descriptor-selection';
+import type { RuntimeConfigValidationPolicy } from '@lorion-org/runtime-config';
+import type {
+  NuxtBaseExtensionSelectionInput,
+  NuxtExtensionSelectionRuntimeConfig,
+  NuxtExtensionModuleOptions,
+  NuxtExtensionSelectionSeedOptions,
+  NuxtProviderSelectionModuleOptions,
+  NuxtProviderSelectionRuntimeConfig,
+  NuxtRuntimeConfig,
+} from './types';
+import { nuxtExtensionDescriptorSchema } from './descriptor-schema';
+
+export type {
+  LorionNuxtModuleOptions,
+  NuxtExtensionModuleOptions,
+  NuxtExtensionSelectionSeedOptions,
+  RuntimeConfigNuxtModuleOptions,
+} from './types';
+
+export type NuxtExtensionDescriptor = Descriptor & {
+  defaultFor?: string | string[];
+  providerPreferences?: ProviderPreferenceMap;
+  publicRuntimeConfig?: NuxtRuntimeConfig['public'];
+  runtimeConfig?: RuntimeConfigValidationPolicy;
+};
+
+export type NuxtExtensionEntry = {
+  appDir?: string;
+  configFile?: string;
+  cwd: string;
+  descriptor: NuxtExtensionDescriptor;
+  modulesDir?: string;
+  publicDir?: string;
+  serverDir?: string;
+  sharedDir?: string;
+};
+
+export type NuxtExtensionBootstrap = {
+  activeExtensions: NuxtExtensionEntry[];
+  baseExtensionIds: string[];
+  catalog: DescriptorCatalog;
+  discoveredExtensions: NuxtExtensionEntry[];
+  publicRuntimeConfig: NuxtRuntimeConfig;
+  resolvedExtensionIds: string[];
+  resolvedExtensions: NuxtExtensionEntry[];
+  selectedExtensions: string[];
+};
+
+type NuxtProviderSelectionOptions = Omit<NuxtProviderSelectionModuleOptions, 'enabled'>;
+
+type ResolvedNuxtExtensionOptions = {
+  descriptorSchema: false | object;
+  descriptorPaths: string[];
+};
+
+const defaultExtensionOptions = {
+  defaultSelection: 'default',
+  publicRuntimeConfigKey: 'extensionSelection',
+  descriptorPaths: ['extensions/*/extension.json'],
+} as const;
+const defaultExtensionSelectionSeedKey = 'capability';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function normalizeSelection(value: string | string[] | undefined): string[] {
+  return parseDescriptorIds(value);
+}
+
+function resolveNuxtExtensionSelectionSeed(
+  seedOptions: false | NuxtExtensionSelectionSeedOptions | undefined,
+): string[] {
+  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: NuxtExtensionModuleOptions,
+): ResolvedNuxtExtensionOptions {
+  return {
+    descriptorSchema: options.descriptorSchema ?? nuxtExtensionDescriptorSchema,
+    descriptorPaths: options.descriptorPaths ?? [...defaultExtensionOptions.descriptorPaths],
+  };
+}
+
+export function resolveExtensionSelection(
+  input: {
+    defaultSelection?: string | string[];
+    selected?: string | string[];
+  } = {},
+): string[] {
+  const candidates = [
+    normalizeSelection(input.selected),
+    normalizeSelection(input.defaultSelection ?? defaultExtensionOptions.defaultSelection),
+  ];
+
+  return candidates.find((candidate) => candidate.length > 0) ?? [];
+}
+
+function resolveBaseExtensionSelection(
+  input: NuxtBaseExtensionSelectionInput & {
+    options: NuxtExtensionModuleOptions;
+  },
+): string[] {
+  const baseExtensions = input.options.baseExtensions;
+
+  return typeof baseExtensions === 'function'
+    ? normalizeSelection(baseExtensions(input))
+    : normalizeSelection(baseExtensions);
+}
+
+function optionalDir(path: string): string | undefined {
+  return existsSync(path) ? path : undefined;
+}
+
+function optionalFile(path: string): string | undefined {
+  return existsSync(path) ? path : undefined;
+}
+
+function findNuxtConfigFile(cwd: string): string | undefined {
+  return ['nuxt.config.ts', 'nuxt.config.mts', 'nuxt.config.js', 'nuxt.config.mjs']
+    .map((fileName) => optionalFile(join(cwd, fileName)))
+    .find(Boolean);
+}
+
+function createExtensionEntry(input: {
+  cwd: string;
+  descriptor: NuxtExtensionDescriptor;
+}): NuxtExtensionEntry {
+  const descriptor: NuxtExtensionDescriptor = {
+    ...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'));
+  const serverDir = optionalDir(join(input.cwd, 'server'));
+  const sharedDir = optionalDir(join(input.cwd, 'shared'));
+  const configFile = findNuxtConfigFile(input.cwd);
+  const entry: NuxtExtensionEntry = {
+    cwd: input.cwd,
+    descriptor,
+  };
+
+  if (appDir) entry.appDir = appDir;
+  if (configFile) entry.configFile = configFile;
+  if (modulesDir) entry.modulesDir = modulesDir;
+  if (publicDir) entry.publicDir = publicDir;
+  if (serverDir) entry.serverDir = serverDir;
+  if (sharedDir) entry.sharedDir = sharedDir;
+
+  return entry;
+}
+
+function canRegisterExtensionLayer(entry: NuxtExtensionEntry): boolean {
+  return Boolean(
+    entry.appDir ||
+    entry.configFile ||
+    entry.modulesDir ||
+    entry.publicDir ||
+    entry.serverDir ||
+    entry.sharedDir,
+  );
+}
+
+function canExtendExtensionLayer(entry: NuxtExtensionEntry): boolean {
+  return Boolean(entry.configFile);
+}
+
+export function discoverNuxtExtensionEntries(input: {
+  projectRootDir: string;
+  options: NuxtExtensionModuleOptions;
+}): NuxtExtensionEntry[] {
+  const resolvedOptions = resolveExtensionOptions(input.options);
+
+  return discoverDescriptors({
+    cwd: input.projectRootDir,
+    descriptorPaths: resolvedOptions.descriptorPaths,
+    nestedField: 'bundles',
+    ...(resolvedOptions.descriptorSchema === false
+      ? {}
+      : {
+          validation: {
+            schema: resolvedOptions.descriptorSchema,
+          },
+        }),
+  }).map((entry) =>
+    createExtensionEntry({
+      cwd: entry.cwd,
+      descriptor: entry.descriptor,
+    }),
+  );
+}
+
+export function createNuxtExtensionCatalog(input: {
+  entries: NuxtExtensionEntry[];
+  relationDescriptors?: RelationDescriptor[];
+}): DescriptorCatalog {
+  return createDescriptorCatalog({
+    descriptors: input.entries.map((entry) => entry.descriptor),
+    relationDescriptors: [...providerRelationDescriptors, ...(input.relationDescriptors ?? [])],
+  });
+}
+
+export function createNuxtExtensionEntryMap(
+  entries: NuxtExtensionEntry[],
+): Map<string, NuxtExtensionEntry> {
+  return new Map(entries.map((entry) => [entry.descriptor.id, entry]));
+}
+
+function pickEntriesById(
+  ids: string[],
+  entryById: Map<string, NuxtExtensionEntry>,
+): NuxtExtensionEntry[] {
+  return ids
+    .map((id) => entryById.get(id))
+    .filter((entry): entry is NuxtExtensionEntry => Boolean(entry));
+}
+
+// The capability -> selected-provider map, used by the module to expose provider
+// selection through runtime config. The selection cleaning itself is delegated to
+// @lorion-org/descriptor-selection's `applyProviderSelection`.
+export function createNuxtSelectedProviderPreferences(input: {
+  entries: NuxtExtensionEntry[];
+  selectedExtensions: string[];
+}): ProviderPreferenceMap {
+  return collectSelectedProviderPreferences({
+    items: input.entries,
+    getCapabilityId: (entry) => entry.descriptor.providesFor,
+    getProviderId: (entry) => entry.descriptor.id,
+    selectedProviderIds: input.selectedExtensions,
+  });
+}
+
+function mergeRuntimeConfigSection(
+  target: NuxtRuntimeConfig['public'] = {},
+  source: NuxtRuntimeConfig['public'] = {},
+): NuxtRuntimeConfig['public'] {
+  const merged: NuxtRuntimeConfig['public'] = { ...target };
+
+  for (const [key, value] of Object.entries(source)) {
+    const current = merged[key];
+
+    merged[key] =
+      isRecord(current) && isRecord(value) ? mergeRuntimeConfigSection(current, value) : value;
+  }
+
+  return merged;
+}
+
+function createExtensionSelectionRuntimeConfig(input: {
+  activeExtensions: NuxtExtensionEntry[];
+  baseExtensionIds: string[];
+  discoveredExtensions: NuxtExtensionEntry[];
+  publicRuntimeConfigKey: false | string;
+  resolvedExtensionIds: string[];
+  selectedExtensions: string[];
+}): NuxtRuntimeConfig {
+  const runtimeConfig = input.activeExtensions.reduce<NuxtRuntimeConfig>(
+    (current, extension) => ({
+      ...current,
+      public: mergeRuntimeConfigSection(
+        current.public,
+        extension.descriptor.publicRuntimeConfig ?? {},
+      ),
+    }),
+    { public: {} },
+  );
+
+  if (input.publicRuntimeConfigKey === false) return runtimeConfig;
+
+  return {
+    ...runtimeConfig,
+    public: {
+      ...runtimeConfig.public,
+      [defaultExtensionOptions.publicRuntimeConfigKey]: {
+        discoveredExtensionIds: input.discoveredExtensions
+          .map((extension) => extension.descriptor.id)
+          .sort((left, right) => left.localeCompare(right)),
+        resolvedExtensionIds: input.resolvedExtensionIds,
+        selectedExtensionIds: input.selectedExtensions,
+      } satisfies NuxtExtensionSelectionRuntimeConfig,
+    },
+  };
+}
+
+export function createNuxtExtensionBootstrap(input: {
+  options?: NuxtExtensionModuleOptions;
+  rootDir: string;
+}): NuxtExtensionBootstrap {
+  const options = input.options ?? {};
+  const selectedExtensions = resolveExtensionSelection({
+    ...(options.defaultSelection ? { defaultSelection: options.defaultSelection } : {}),
+    selected: options.selected ?? resolveNuxtExtensionSelectionSeed(options.selectionSeed),
+  });
+  const createCatalog = (entries: NuxtExtensionEntry[]): DescriptorCatalog =>
+    createNuxtExtensionCatalog({
+      entries,
+      ...(options.relationDescriptors ? { relationDescriptors: options.relationDescriptors } : {}),
+    });
+
+  if (options.enabled === false) {
+    return {
+      activeExtensions: [],
+      baseExtensionIds: [],
+      catalog: createCatalog([]),
+      discoveredExtensions: [],
+      publicRuntimeConfig: { public: {} },
+      resolvedExtensionIds: [],
+      resolvedExtensions: [],
+      selectedExtensions,
+    };
+  }
+
+  const entries = discoverNuxtExtensionEntries({
+    projectRootDir: input.rootDir,
+    options,
+  });
+  const baseExtensionIds = resolveBaseExtensionSelection({
+    descriptors: entries.map((entry) => entry.descriptor),
+    options,
+    selectedExtensions,
+  });
+
+  if (!entries.length) {
+    return {
+      activeExtensions: [],
+      baseExtensionIds,
+      catalog: createCatalog(entries),
+      discoveredExtensions: entries,
+      publicRuntimeConfig: { public: {} },
+      resolvedExtensionIds: [],
+      resolvedExtensions: [],
+      selectedExtensions,
+    };
+  }
+
+  assertSingleDefaultProvider(entries.map((entry) => entry.descriptor));
+
+  const resolutionEntries = applyProviderSelection({
+    items: entries,
+    selected: selectedExtensions,
+    getDescriptor: (entry) => entry.descriptor,
+    withDescriptor: (entry, descriptor) => ({ ...entry, descriptor }),
+  });
+  const catalog = createCatalog(resolutionEntries);
+  const selection = catalog.resolveSelection({
+    baseDescriptors: baseExtensionIds,
+    policy: descriptorSelectionPolicy(),
+    selected: selectedExtensions,
+  });
+  const resolvedExtensionIds = selection.getResolved();
+  const resolvedExtensions = pickEntriesById(
+    resolvedExtensionIds,
+    createNuxtExtensionEntryMap(resolutionEntries),
+  );
+  const activeExtensions = resolvedExtensions.filter(canRegisterExtensionLayer);
+
+  return {
+    activeExtensions,
+    baseExtensionIds: selection.getBaseDescriptors(),
+    catalog,
+    discoveredExtensions: entries,
+    publicRuntimeConfig: createExtensionSelectionRuntimeConfig({
+      activeExtensions,
+      baseExtensionIds: selection.getBaseDescriptors(),
+      discoveredExtensions: entries,
+      publicRuntimeConfigKey: defaultExtensionOptions.publicRuntimeConfigKey,
+      resolvedExtensionIds,
+      selectedExtensions,
+    }),
+    resolvedExtensionIds,
+    resolvedExtensions,
+    selectedExtensions: selection.getSelected(),
+  };
+}
+
+export function createNuxtExtensionLayerPaths(bootstrap: NuxtExtensionBootstrap): string[] {
+  return bootstrap.activeExtensions
+    .filter(canExtendExtensionLayer)
+    .map((extension) => extension.cwd);
+}
+
+export function createNuxtProviderSelectionRuntimeConfig(
+  extensions: NuxtExtensionEntry[],
+  options: NuxtProviderSelectionOptions = {},
+): NuxtRuntimeConfig {
+  const publicRuntimeConfigKey = 'providerSelection';
+  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.fallbackProviders ?? {}),
+  };
+  const resolution = resolveItemProviderSelection({
+    items: extensions,
+    getCapabilityId: (extension) => extension.descriptor.providesFor,
+    getProviderId: (extension) => extension.descriptor.id,
+    configuredProviders,
+    fallbackProviders,
+    selectedProviders,
+  });
+
+  return {
+    public: {
+      [publicRuntimeConfigKey]: {
+        configuredProviders,
+        excludedProviderIds: resolution.excludedProviderIds,
+        fallbackProviders,
+        mismatches: resolution.mismatches,
+        selections: Object.fromEntries(resolution.selections),
+      } satisfies NuxtProviderSelectionRuntimeConfig,
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+export {
+  createNuxtExtensionBootstrapLogEvent,
+  default,
+  formatNuxtExtensionBootstrapLog,
+  reportNuxtExtensionBootstrap,
+} from './module';
+export {
+  createNuxtExtensionBootstrap,
+  createNuxtExtensionCatalog,
+  createNuxtExtensionEntryMap,
+  createNuxtExtensionLayerPaths,
+  createNuxtProviderSelectionRuntimeConfig,
+  discoverNuxtExtensionEntries,
+  resolveExtensionSelection,
+  type NuxtExtensionBootstrap,
+  type NuxtExtensionDescriptor,
+  type NuxtExtensionEntry,
+  type NuxtExtensionModuleOptions,
+  type NuxtExtensionSelectionSeedOptions,
+} from './extensions';
+export { nuxtExtensionDescriptorSchema, type JsonSchemaObject } from './descriptor-schema';
+export type {
+  LorionNuxtModuleOptions,
+  NuxtBaseExtensionSelection,
+  NuxtBaseExtensionSelectionInput,
+  NuxtExtensionBootstrapLogEvent,
+  NuxtExtensionBootstrapReporter,
+  NuxtProviderSelectionModuleOptions,
+  NuxtProviderSelectionRuntimeConfig,
+  RuntimeConfigNuxtModuleOptions,
+} from './types';