@lorion-org/nuxt 1.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,864 @@
+// src/module.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import {
+  addImports,
+  addServerImports,
+  addServerTemplate,
+  addTemplate,
+  createResolver,
+  defineNuxtModule,
+  useLogger
+} from "@nuxt/kit";
+
+// src/extensions.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import {
+  createDescriptorCatalog
+} from "@lorion-org/composition-graph";
+import { discoverDescriptors } from "@lorion-org/descriptor-discovery";
+import {
+  resolveItemProviderSelection
+} from "@lorion-org/provider-selection";
+
+// src/extension-descriptor.schema.json
+var extension_descriptor_schema_default = {
+  $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: {
+          type: "string",
+          minLength: 1
+        },
+        capabilities: {
+          type: "array",
+          items: {
+            type: "string",
+            minLength: 1
+          }
+        },
+        dependencies: { $ref: "#/$defs/dependencyMap" },
+        disabled: { type: "boolean" },
+        location: { type: "string" },
+        providerPreferences: {
+          type: "object",
+          additionalProperties: {
+            type: "string",
+            minLength: 1
+          }
+        },
+        publicRuntimeConfig: {
+          type: "object",
+          additionalProperties: true
+        },
+        bundles: {
+          type: "array",
+          items: { $ref: "#/$defs/extension" }
+        }
+      },
+      required: ["id", "version"],
+      additionalProperties: true
+    }
+  }
+};
+
+// src/descriptor-schema.ts
+var nuxtExtensionDescriptorSchema = extension_descriptor_schema_default;
+
+// src/extensions.ts
+var defaultExtensionOptions = {
+  defaultSelection: "default",
+  publicRuntimeConfigKey: "extensionSelection",
+  descriptorPaths: ["extensions/*/extension.json"]
+};
+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);
+  });
+}
+function resolveExtensionOptions(options) {
+  return {
+    descriptorSchema: options.descriptorSchema ?? nuxtExtensionDescriptorSchema,
+    descriptorPaths: options.descriptorPaths ?? [...defaultExtensionOptions.descriptorPaths]
+  };
+}
+function resolveExtensionSelection(input = {}) {
+  const candidates = [
+    normalizeSelection(input.selected),
+    normalizeSelection(input.defaultSelection ?? defaultExtensionOptions.defaultSelection)
+  ];
+  return candidates.find((candidate) => candidate.length > 0) ?? [];
+}
+function resolveBaseExtensionSelection(input) {
+  const baseExtensions = input.options.baseExtensions;
+  return typeof baseExtensions === "function" ? normalizeSelection(baseExtensions(input)) : normalizeSelection(baseExtensions);
+}
+function optionalDir(path) {
+  return existsSync(path) ? path : void 0;
+}
+function optionalFile(path) {
+  return existsSync(path) ? path : void 0;
+}
+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 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 = {
+    cwd: input.cwd,
+    descriptor: input.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) {
+  return Boolean(
+    entry.appDir || entry.configFile || entry.modulesDir || entry.publicDir || entry.serverDir || entry.sharedDir
+  );
+}
+function canExtendExtensionLayer(entry) {
+  return Boolean(entry.configFile);
+}
+function discoverExtensionEntries(input) {
+  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
+    })
+  );
+}
+function pickEntriesById(ids, entryById) {
+  return ids.map((id) => entryById.get(id)).filter((entry) => Boolean(entry));
+}
+function mergeRuntimeConfigSection(target = {}, source = {}) {
+  const merged = { ...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) {
+  const runtimeConfig = input.activeExtensions.reduce(
+    (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
+      }
+    }
+  };
+}
+function createNuxtExtensionBootstrap(input) {
+  const options = input.options ?? {};
+  const selectedExtensions = resolveExtensionSelection({
+    ...options.defaultSelection ? { defaultSelection: options.defaultSelection } : {},
+    ...options.selected ? { selected: options.selected } : {}
+  });
+  const createCatalog = (entries2) => createDescriptorCatalog({
+    descriptors: entries2.map((entry) => entry.descriptor),
+    ...options.relationDescriptors ? { relationDescriptors: options.relationDescriptors } : {}
+  });
+  if (options.enabled === false) {
+    return {
+      activeExtensions: [],
+      baseExtensionIds: [],
+      catalog: createCatalog([]),
+      discoveredExtensions: [],
+      publicRuntimeConfig: { public: {} },
+      resolvedExtensionIds: [],
+      resolvedExtensions: [],
+      selectedExtensions
+    };
+  }
+  const entries = discoverExtensionEntries({
+    projectRootDir: input.rootDir,
+    options
+  });
+  const baseExtensionIds = resolveBaseExtensionSelection({
+    descriptors: entries.map((entry) => entry.descriptor),
+    options,
+    selectedExtensions
+  });
+  const entryById = new Map(entries.map((entry) => [entry.descriptor.id, entry]));
+  if (!entries.length) {
+    return {
+      activeExtensions: [],
+      baseExtensionIds,
+      catalog: createCatalog(entries),
+      discoveredExtensions: entries,
+      publicRuntimeConfig: { public: {} },
+      resolvedExtensionIds: [],
+      resolvedExtensions: [],
+      selectedExtensions
+    };
+  }
+  const catalog = createCatalog(entries);
+  const selection = catalog.resolveSelection({
+    baseDescriptors: baseExtensionIds,
+    selected: selectedExtensions
+  });
+  const resolvedExtensionIds = selection.getResolved();
+  const resolvedExtensions = pickEntriesById(resolvedExtensionIds, entryById);
+  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()
+  };
+}
+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 = {
+    ...descriptorPreferences,
+    ...options.configuredProviders ?? {}
+  };
+  const resolution = resolveItemProviderSelection({
+    items: extensions,
+    getCapabilityId: (extension) => extension.descriptor.providesFor,
+    getProviderId: (extension) => extension.descriptor.id,
+    configuredProviders
+  });
+  return {
+    public: {
+      [publicRuntimeConfigKey]: {
+        configuredProviders,
+        excludedProviderIds: resolution.excludedProviderIds,
+        mismatches: resolution.mismatches,
+        selections: Object.fromEntries(resolution.selections)
+      }
+    }
+  };
+}
+
+// src/runtime-config.ts
+import {
+  getPrivateRuntimeConfigScope,
+  getPublicRuntimeConfigScope,
+  getRuntimeConfigFragment,
+  getRuntimeConfigScope,
+  projectSectionedRuntimeConfig,
+  resolveRuntimeConfigValueFromRuntimeConfig,
+  toRuntimeConfigFragment
+} from "@lorion-org/runtime-config";
+var isObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var toStringArray = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+function createContextInputOptions(contextInputKey) {
+  return contextInputKey === void 0 ? {} : { contextInputKey };
+}
+function createPrivateOutputOptions(privateOutput) {
+  return privateOutput === void 0 ? {} : { privateOutput };
+}
+function withoutPublicRuntimeConfig(config) {
+  const privateConfig = { ...config };
+  delete privateConfig.public;
+  return privateConfig;
+}
+function normalizeNuxtRuntimeConfigFragments(fragments = {}, options = {}) {
+  if (fragments instanceof Map) {
+    const normalizedFragments = /* @__PURE__ */ new Map();
+    for (const [scopeId, config] of fragments.entries()) {
+      normalizedFragments.set(scopeId, toRuntimeConfigFragment(config, options));
+    }
+    return normalizedFragments;
+  }
+  if (Array.isArray(fragments)) {
+    return fragments.map((fragment) => ({
+      scopeId: fragment.scopeId,
+      config: toRuntimeConfigFragment(fragment.config, options)
+    }));
+  }
+  return Object.entries(fragments).map(([scopeId, config]) => ({
+    scopeId,
+    config: toRuntimeConfigFragment(config, options)
+  }));
+}
+function toNuxtRuntimeConfig(runtimeConfig, options = {}) {
+  if (options.privateOutput === "section") {
+    return {
+      private: {
+        ...runtimeConfig.private
+      },
+      public: {
+        ...runtimeConfig.public
+      }
+    };
+  }
+  return {
+    ...runtimeConfig.private,
+    public: {
+      ...runtimeConfig.public
+    }
+  };
+}
+function createNuxtRuntimeConfig(options = {}) {
+  const { contextInputKey, fragments, runtimeConfig, ...projectOptions } = options;
+  const runtimeConfigFragments = fragments ?? {};
+  const sectionedRuntimeConfig = runtimeConfig ?? projectSectionedRuntimeConfig(
+    normalizeNuxtRuntimeConfigFragments(
+      runtimeConfigFragments,
+      createContextInputOptions(contextInputKey)
+    ),
+    projectOptions
+  );
+  return toNuxtRuntimeConfig(
+    sectionedRuntimeConfig,
+    createPrivateOutputOptions(options.privateOutput)
+  );
+}
+function mergeNuxtRuntimeConfig(target = {}, source = {}) {
+  const targetPublic = isObject(target.public) ? target.public : {};
+  const sourcePublic = isObject(source.public) ? source.public : {};
+  return {
+    ...withoutPublicRuntimeConfig(target),
+    ...withoutPublicRuntimeConfig(source),
+    public: {
+      ...targetPublic,
+      ...sourcePublic
+    }
+  };
+}
+function getNuxtExtensionSelection(runtimeConfig) {
+  const selection = isObject(runtimeConfig.public?.extensionSelection) ? runtimeConfig.public.extensionSelection : void 0;
+  if (!selection) {
+    return {
+      discoveredExtensionIds: [],
+      notInjectedExtensionIds: [],
+      resolvedExtensionIds: [],
+      selectedExtensionIds: []
+    };
+  }
+  const discoveredExtensionIds = toStringArray(selection.discoveredExtensionIds);
+  const resolvedExtensionIds = toStringArray(selection.resolvedExtensionIds);
+  const resolvedExtensionIdSet = new Set(resolvedExtensionIds);
+  return {
+    discoveredExtensionIds,
+    notInjectedExtensionIds: discoveredExtensionIds.filter((id) => !resolvedExtensionIdSet.has(id)).sort((left, right) => left.localeCompare(right)),
+    resolvedExtensionIds,
+    selectedExtensionIds: toStringArray(selection.selectedExtensionIds)
+  };
+}
+function getNuxtProviderSelection(runtimeConfig) {
+  const providerSelection = runtimeConfig.public?.providerSelection;
+  return isObject(providerSelection) && isObject(providerSelection.selections) ? providerSelection : void 0;
+}
+
+// src/runtime-config-node.ts
+import {
+  loadRuntimeConfigSourceTree,
+  resolveRuntimeConfigSourcePublicRootPath,
+  validateRuntimeConfigSourceScopes
+} from "@lorion-org/runtime-config-node";
+import { toRuntimeConfigFragment as toRuntimeConfigFragment2 } from "@lorion-org/runtime-config";
+function resolveNuxtRuntimeConfigPublicRootPath(source) {
+  return resolveRuntimeConfigSourcePublicRootPath(source);
+}
+function loadNuxtRuntimeConfigFragments(source, options = {}) {
+  const fragments = loadRuntimeConfigSourceTree(source);
+  const normalizedFragments = /* @__PURE__ */ new Map();
+  for (const [scopeId, config] of fragments.entries()) {
+    normalizedFragments.set(scopeId, toRuntimeConfigFragment2(config, options));
+  }
+  return normalizedFragments;
+}
+function createNuxtRuntimeConfigFromSource(source, options = {}) {
+  return createNuxtRuntimeConfig({
+    ...options,
+    fragments: loadNuxtRuntimeConfigFragments(source, {
+      ...options.contextInputKey ? { contextInputKey: options.contextInputKey } : {}
+    })
+  });
+}
+function validateNuxtRuntimeConfigSourceScopes(source, targets, options = {}) {
+  return validateRuntimeConfigSourceScopes(source, targets, options);
+}
+
+// src/module.ts
+var runtimeConfigImportNames = [
+  "useRuntimeConfigFragment",
+  "useRuntimeConfigScope",
+  "usePublicRuntimeConfigScope",
+  "usePrivateRuntimeConfigScope",
+  "useRuntimeConfigValue"
+];
+var runtimeConfigComposablesTemplate = "lorion/runtime-config-composables.ts";
+var serverRuntimeConfigComposablesTemplate = "#internal/lorion-runtime-config-composables.mjs";
+var defaultRuntimeConfigSource = {
+  contextInputKey: "contexts",
+  contextOutputKey: "__contexts",
+  paths: [".runtimeconfig/runtime-config/*/runtime.config.json"]
+};
+var joinLogIds = (ids) => ids.join(", ");
+var hasLogIds = (ids) => ids.length > 0;
+function pickRuntimeConfigOptions(options, bootstrap) {
+  const runtimeConfigOptions = {};
+  if (options.contextInputKey !== void 0)
+    runtimeConfigOptions.contextInputKey = options.contextInputKey;
+  if (options.contextOutputKey !== void 0)
+    runtimeConfigOptions.contextOutputKey = options.contextOutputKey;
+  if (options.fragments !== void 0) runtimeConfigOptions.fragments = options.fragments;
+  if (options.includeContexts !== void 0)
+    runtimeConfigOptions.includeContexts = options.includeContexts;
+  if (options.keyStrategy !== void 0) runtimeConfigOptions.keyStrategy = options.keyStrategy;
+  if (options.privateOutput !== void 0)
+    runtimeConfigOptions.privateOutput = options.privateOutput;
+  if (options.runtimeConfig !== void 0)
+    runtimeConfigOptions.runtimeConfig = options.runtimeConfig;
+  if (bootstrap?.resolvedExtensionIds.length) {
+    runtimeConfigOptions.scopeIds = bootstrap.resolvedExtensionIds;
+  }
+  return runtimeConfigOptions;
+}
+function createRuntimeConfigComposableDefaults(options) {
+  return {
+    ...options.contextOutputKey ? { contextOutputKey: options.contextOutputKey } : {},
+    privateInput: options.privateOutput === "section" ? "section" : "root"
+  };
+}
+function normalizeImportPath(path) {
+  return path.replace(/\\/g, "/");
+}
+function createRuntimeConfigComposablesSource(input) {
+  const typeImports = input.typed ? `
+import type {
+  GetRuntimeConfigFragmentOptions,
+  GetRuntimeConfigScopeOptions,
+  ResolveRuntimeConfigValueFromRuntimeConfigOptions,
+  RuntimeConfigContext,
+  RuntimeConfigSection,
+} from '@lorion-org/runtime-config'
+import type {
+  NuxtPrivateRuntimeConfigMode,
+  NuxtRuntimeConfigInput,
+  ReadNuxtRuntimeConfigOptions,
+} from '${input.runtimeConfigFrom}'
+
+export type RuntimeConfigComposableDefaults = {
+  contextOutputKey?: string
+  privateInput?: NuxtPrivateRuntimeConfigMode
+}
+
+export type UseRuntimeConfigScopeOptions = GetRuntimeConfigScopeOptions & ReadNuxtRuntimeConfigOptions
+export type UsePublicRuntimeConfigScopeOptions =
+  Omit<GetRuntimeConfigScopeOptions, 'visibility'> &
+  ReadNuxtRuntimeConfigOptions
+export type UseRuntimeConfigValueOptions<T = unknown> =
+  ResolveRuntimeConfigValueFromRuntimeConfigOptions<T> &
+  ReadNuxtRuntimeConfigOptions
+export type UseRuntimeConfigFragmentOptions =
+  GetRuntimeConfigFragmentOptions &
+  ReadNuxtRuntimeConfigOptions
+` : "";
+  const typeAnnotations = input.typed ? {
+    defaults: ": RuntimeConfigComposableDefaults",
+    fragmentReturn: ": RuntimeConfigContext",
+    fragmentOptions: ": UseRuntimeConfigFragmentOptions",
+    privateOptions: ": UsePublicRuntimeConfigScopeOptions",
+    publicOptions: ": UsePublicRuntimeConfigScopeOptions",
+    runtimeConfig: ": NuxtRuntimeConfigInput",
+    scopeOptions: ": UseRuntimeConfigScopeOptions",
+    scopeReturn: "<T extends RuntimeConfigSection = RuntimeConfigSection>",
+    valueOptions: "<T = unknown>",
+    valueOptionsType: ": UseRuntimeConfigValueOptions<T>",
+    valueReturn: ": T | undefined"
+  } : {
+    defaults: "",
+    fragmentReturn: "",
+    fragmentOptions: "",
+    privateOptions: "",
+    publicOptions: "",
+    runtimeConfig: "",
+    scopeOptions: "",
+    scopeReturn: "",
+    valueOptions: "",
+    valueOptionsType: "",
+    valueReturn: ""
+  };
+  return `import { useRuntimeConfig } from '${input.useRuntimeConfigFrom}'
+import {
+  getNuxtRuntimeConfigFragment,
+  getNuxtRuntimeConfigScope,
+  getPrivateNuxtRuntimeConfigScope,
+  getPublicNuxtRuntimeConfigScope,
+  resolveNuxtRuntimeConfigValue,
+} from '${input.runtimeConfigFrom}'
+${typeImports}
+const runtimeConfigDefaultsKey = '__lorionNuxt'
+
+function getComposableDefaults(runtimeConfig${typeAnnotations.runtimeConfig})${typeAnnotations.defaults} {
+  const container = runtimeConfig.public?.[runtimeConfigDefaultsKey]
+
+  if (typeof container !== 'object' || container === null || Array.isArray(container)) {
+    return {}
+  }
+
+  const defaults = container.runtimeConfig
+
+  return typeof defaults === 'object' && defaults !== null && !Array.isArray(defaults)
+    ? defaults
+    : {}
+}
+
+function withComposableDefaults(runtimeConfig${typeAnnotations.runtimeConfig}, options = {}) {
+  return {
+    ...getComposableDefaults(runtimeConfig),
+    ...options,
+  }
+}
+
+export function useRuntimeConfigFragment(scopeId, options${typeAnnotations.fragmentOptions} = {})${typeAnnotations.fragmentReturn} {
+  const runtimeConfig = useRuntimeConfig()
+
+  return getNuxtRuntimeConfigFragment(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options))
+}
+
+export function useRuntimeConfigScope${typeAnnotations.scopeReturn}(scopeId, options${typeAnnotations.scopeOptions} = {}) {
+  const runtimeConfig = useRuntimeConfig()
+
+  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 usePrivateRuntimeConfigScope${typeAnnotations.scopeReturn}(scopeId, options${typeAnnotations.privateOptions} = {}) {
+  const runtimeConfig = useRuntimeConfig()
+
+  return getPrivateNuxtRuntimeConfigScope(runtimeConfig, scopeId, withComposableDefaults(runtimeConfig, options))
+}
+
+export function useRuntimeConfigValue${typeAnnotations.valueOptions}(scopeId, key, options${typeAnnotations.valueOptionsType} = {})${typeAnnotations.valueReturn} {
+  const runtimeConfig = useRuntimeConfig()
+
+  return resolveNuxtRuntimeConfigValue(runtimeConfig, scopeId, key, withComposableDefaults(runtimeConfig, options))
+}
+`;
+}
+function createDefaultRuntimeConfigOptions(rootDir) {
+  const paths = defaultRuntimeConfigSource.paths.map((pattern) => join2(rootDir, pattern));
+  const runtimeConfigDir = join2(rootDir, ".runtimeconfig", "runtime-config");
+  if (!existsSync2(runtimeConfigDir)) return void 0;
+  return {
+    contextInputKey: defaultRuntimeConfigSource.contextInputKey,
+    contextOutputKey: defaultRuntimeConfigSource.contextOutputKey,
+    source: { paths }
+  };
+}
+function resolveRuntimeConfigModuleOptions(options, rootDir) {
+  if (options?.enabled === false) return void 0;
+  return options ?? createDefaultRuntimeConfigOptions(rootDir);
+}
+function registerRuntimeConfigPublicAssets(options, nuxt) {
+  if (options.publicAssets === false || !options.source) return;
+  const publicRoot = resolveNuxtRuntimeConfigPublicRootPath(options.source);
+  if (!publicRoot || !existsSync2(publicRoot)) return;
+  const maxAge = typeof options.publicAssets === "object" ? options.publicAssets.maxAge : void 0;
+  const hook = nuxt.hook;
+  hook("nitro:config", (nitroConfig) => {
+    nitroConfig.publicAssets = nitroConfig.publicAssets ?? [];
+    nitroConfig.publicAssets.push({
+      dir: publicRoot,
+      ...maxAge === void 0 ? {} : { maxAge }
+    });
+  });
+}
+function resolveRuntimeConfigValidationTargets(bootstrap) {
+  return bootstrap?.resolvedExtensions.map((extension) => ({
+    scopeId: extension.descriptor.id,
+    cwd: extension.cwd
+  })) ?? [];
+}
+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, {
+    ...options.validation.formatError ? { formatError: options.validation.formatError } : {},
+    ...options.validation.schemaFileName ? { schemaFileName: options.validation.schemaFileName } : {}
+  });
+}
+function addRuntimeConfigImports(options) {
+  if (options.imports === false) return;
+  const resolver = createResolver(import.meta.url);
+  const runtimeConfigFrom = normalizeImportPath(resolver.resolve("./runtime-config"));
+  const template = addTemplate({
+    filename: runtimeConfigComposablesTemplate,
+    getContents: () => createRuntimeConfigComposablesSource({
+      runtimeConfigFrom,
+      typed: true,
+      useRuntimeConfigFrom: "nuxt/app"
+    })
+  });
+  addServerTemplate({
+    filename: serverRuntimeConfigComposablesTemplate,
+    getContents: () => createRuntimeConfigComposablesSource({
+      runtimeConfigFrom,
+      typed: false,
+      useRuntimeConfigFrom: "nitropack/runtime"
+    })
+  });
+  const imports = runtimeConfigImportNames.map((name) => ({
+    as: name,
+    from: `#build/${template.filename}`,
+    name
+  }));
+  const serverImports = runtimeConfigImportNames.map((name) => ({
+    as: name,
+    from: serverRuntimeConfigComposablesTemplate,
+    name
+  }));
+  addImports(imports);
+  addServerImports(serverImports);
+}
+function createRuntimeConfigDefaultsConfig(options) {
+  return {
+    public: {
+      __lorionNuxt: {
+        runtimeConfig: createRuntimeConfigComposableDefaults(options)
+      }
+    }
+  };
+}
+function createConfiguredNuxtRuntimeConfig(options, bootstrap) {
+  if (!options.runtimeConfig || options.runtimeConfig.enabled === false) return void 0;
+  const runtimeConfigOptions = pickRuntimeConfigOptions(options.runtimeConfig, bootstrap);
+  return options.runtimeConfig.source ? createNuxtRuntimeConfigFromSource(options.runtimeConfig.source, runtimeConfigOptions) : createNuxtRuntimeConfig(runtimeConfigOptions);
+}
+function applyRuntimeConfigModule(input) {
+  const runtimeConfigOptions = resolveRuntimeConfigModuleOptions(
+    input.moduleOptions,
+    input.rootDir
+  );
+  const runtimeConfig = runtimeConfigOptions ? createConfiguredNuxtRuntimeConfig({ runtimeConfig: runtimeConfigOptions }, input.bootstrap) : void 0;
+  if (!runtimeConfigOptions) return input.currentRuntimeConfig;
+  addRuntimeConfigImports(runtimeConfigOptions);
+  registerRuntimeConfigPublicAssets(runtimeConfigOptions, input.nuxt);
+  validateRuntimeConfigSource(runtimeConfigOptions, input.bootstrap);
+  return mergeNuxtRuntimeConfig(
+    input.currentRuntimeConfig,
+    mergeNuxtRuntimeConfig(createRuntimeConfigDefaultsConfig(runtimeConfigOptions), runtimeConfig)
+  );
+}
+function createProviderSelectionRuntimeConfig(bootstrap, options) {
+  if (options?.enabled === false) return void 0;
+  return createNuxtProviderSelectionRuntimeConfig(bootstrap.resolvedExtensions, options);
+}
+function createNuxtExtensionBootstrapLogEvent(input) {
+  const providerSelection = input.providerSelectionRuntimeConfig ? getNuxtProviderSelection(input.providerSelectionRuntimeConfig) : void 0;
+  return {
+    bootstrap: input.bootstrap,
+    ...providerSelection ? { providerSelection } : {}
+  };
+}
+function formatNuxtExtensionBootstrapLog(event) {
+  const lines = ["LORION Nuxt"];
+  const bootstrap = event.bootstrap;
+  const extensionSelection = getNuxtExtensionSelection(bootstrap.publicRuntimeConfig);
+  if (hasLogIds(bootstrap.selectedExtensions)) {
+    lines.push(`Selected: ${joinLogIds(bootstrap.selectedExtensions)}`);
+  }
+  if (hasLogIds(bootstrap.baseExtensionIds)) {
+    lines.push(`Base: ${joinLogIds(bootstrap.baseExtensionIds)}`);
+  }
+  lines.push(`Descriptors found: ${bootstrap.discoveredExtensions.length}`);
+  if (hasLogIds(bootstrap.resolvedExtensionIds)) {
+    lines.push(`Injected: ${joinLogIds(bootstrap.resolvedExtensionIds)}`);
+  }
+  if (hasLogIds(extensionSelection.notInjectedExtensionIds)) {
+    lines.push(`Not injected: ${joinLogIds(extensionSelection.notInjectedExtensionIds)}`);
+  }
+  const providerSelections = Object.values(event.providerSelection?.selections ?? {}).sort(
+    (left, right) => left.capabilityId.localeCompare(right.capabilityId)
+  );
+  for (const selection of providerSelections) {
+    lines.push(`Provider ${selection.capabilityId}: ${selection.selectedProviderId}`);
+  }
+  return lines.join("\n");
+}
+function reportNuxtExtensionBootstrap(input) {
+  if (!input.logging || input.logging === true || !input.logging.reporter) return;
+  input.logging.reporter(
+    createNuxtExtensionBootstrapLogEvent({
+      bootstrap: input.bootstrap,
+      ...input.providerSelectionRuntimeConfig ? { providerSelectionRuntimeConfig: input.providerSelectionRuntimeConfig } : {}
+    })
+  );
+}
+function getLayerRoot(layer) {
+  return layer.config.rootDir ?? layer.cwd;
+}
+function createLayerConfig(extension) {
+  return {
+    cwd: extension.cwd,
+    configFile: "",
+    config: {
+      rootDir: extension.cwd,
+      serverDir: extension.serverDir ?? join2(extension.cwd, "server"),
+      srcDir: extension.appDir ?? extension.cwd
+    }
+  };
+}
+function registerFileOnlyExtensionLayers(bootstrap, nuxtOptions) {
+  const fileOnlyExtensions = bootstrap.activeExtensions.filter(
+    (extension) => !extension.configFile
+  );
+  if (!fileOnlyExtensions.length) return;
+  const options = nuxtOptions;
+  const layers = [...options._layers];
+  const existingRoots = new Set(layers.map((layer) => getLayerRoot(layer)));
+  const extensionLayers = fileOnlyExtensions.filter((extension) => {
+    if (existingRoots.has(extension.cwd)) return false;
+    existingRoots.add(extension.cwd);
+    return true;
+  }).map(createLayerConfig);
+  if (!extensionLayers.length) return;
+  const [projectLayer, ...baseLayers] = layers;
+  options._layers = projectLayer ? [projectLayer, ...extensionLayers, ...baseLayers] : [...extensionLayers];
+}
+var lorionNuxtModule = defineNuxtModule({
+  meta: {
+    name: "@lorion-org/nuxt",
+    configKey: "lorion"
+  },
+  setup(options, nuxt) {
+    const bootstrap = options.extensionBootstrap ?? (options.extensions?.enabled === false || !options.extensions ? void 0 : createNuxtExtensionBootstrap({
+      rootDir: nuxt.options.rootDir,
+      options: options.extensions
+    }));
+    if (bootstrap) {
+      const providerSelectionRuntimeConfig = createProviderSelectionRuntimeConfig(
+        bootstrap,
+        options.providers
+      );
+      const logger = useLogger("@lorion-org/nuxt");
+      const logging = options.logging === true ? {
+        reporter: (event) => logger.info(formatNuxtExtensionBootstrapLog(event))
+      } : options.logging;
+      reportNuxtExtensionBootstrap({
+        bootstrap,
+        logging,
+        ...providerSelectionRuntimeConfig ? { providerSelectionRuntimeConfig } : {}
+      });
+      registerFileOnlyExtensionLayers(bootstrap, nuxt.options);
+      nuxt.options.runtimeConfig = mergeNuxtRuntimeConfig(
+        nuxt.options.runtimeConfig,
+        mergeNuxtRuntimeConfig(bootstrap.publicRuntimeConfig, providerSelectionRuntimeConfig)
+      );
+    }
+    nuxt.options.runtimeConfig = applyRuntimeConfigModule({
+      ...bootstrap ? { bootstrap } : {},
+      currentRuntimeConfig: nuxt.options.runtimeConfig,
+      nuxt,
+      rootDir: nuxt.options.rootDir,
+      ...options.runtimeConfig ? { moduleOptions: options.runtimeConfig } : {}
+    });
+  }
+});
+var module_default = lorionNuxtModule;
+export {
+  createNuxtExtensionBootstrap,
+  createNuxtExtensionBootstrapLogEvent,
+  createNuxtExtensionLayerPaths,
+  createNuxtProviderSelectionRuntimeConfig,
+  module_default as default,
+  formatNuxtExtensionBootstrapLog,
+  reportNuxtExtensionBootstrap,
+  resolveExtensionSelection
+};