@lorion-org/runtime-config 1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the 'Software'), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,309 @@
+# @lorion-org/runtime-config
+
+Pure runtime-config contracts and helpers.
+
+This package is free from file-system and framework dependencies.
+
+It models small runtime-config fragments, projects them into runtime objects, and
+creates deterministic environment variable names for adapter layers.
+
+## Install
+
+```shell
+pnpm add @lorion-org/runtime-config
+```
+
+## What it is
+
+- typed contracts for runtime-config fragments
+- deterministic scope/key normalization
+- projection helpers for flat sectioned runtime config
+- projection helpers for namespaced runtime config objects
+- configurable context input keys for adapter-specific fragment shapes
+- context-aware lookup helpers
+- scope-view helpers for reading flat runtime config through unprefixed keys
+- environment variable rendering helpers
+
+## What it is not
+
+- not a framework module
+- not a file-system loader
+- not a schema validator
+- not a config-file parser
+- not an application-specific naming policy
+
+## Adapter integration
+
+Framework adapters can wire this package into their runtime config transport.
+For Nuxt, use `@lorion-org/nuxt`.
+
+The intended adapter shape is:
+
+- projects define local fragments with unprefixed keys
+- adapters map those fragments into the target runtime transport
+- usage code can read back unprefixed public/private scope views
+- application-specific names, file names, and defaults stay in the consuming adapter
+
+Adapters may accept existing fragment field names and map them to generic
+contexts with `contextInputKey`. For example, a project can read `tenants`
+from its files while this package still works with the generic `contexts`
+model internally.
+
+## The three runtime-config shapes
+
+This package separates the local config shape from the runtime transport shape.
+
+### 1. Fragment shape
+
+Fragments are written in local scope vocabulary. The scope id is not repeated in
+the keys.
+
+```ts
+const authFragment = {
+  public: {
+    url: 'https://auth.example.test',
+    realm: 'main',
+  },
+  private: {
+    clientSecret: 'secret',
+  },
+};
+```
+
+This is the shape that JSON files and schemas usually describe.
+
+### 2. Flat runtime shape
+
+Some runtimes need one shared `public` and `private` object. The scope id becomes
+a transport prefix so many fragments can coexist without key collisions.
+
+```ts
+const runtimeConfig = projectSectionedRuntimeConfig(new Map([['auth', authFragment]]));
+
+// For a single fragment, use:
+projectRuntimeConfigFragment('auth', authFragment);
+
+runtimeConfig.public.authUrl;
+// => 'https://auth.example.test'
+runtimeConfig.private.authClientSecret;
+// => 'secret'
+```
+
+### 3. Environment variable shape
+
+Environment variables keep the same transport prefix and add visibility.
+
+```ts
+toRuntimeEnvVars(runtimeConfig, 'APP');
+// => {
+//   APP_PUBLIC_AUTH_URL: 'https://auth.example.test',
+//   APP_PUBLIC_AUTH_REALM: 'main',
+//   APP_PRIVATE_AUTH_CLIENT_SECRET: 'secret'
+// }
+```
+
+Usage code can read the flat runtime shape back through local keys:
+
+```ts
+const auth = getPublicRuntimeConfigScope(runtimeConfig, 'auth');
+
+auth.url;
+// => 'https://auth.example.test'
+```
+
+## Basic example
+
+```ts
+import {
+  getPublicRuntimeConfigScope,
+  projectSectionedRuntimeConfig,
+  resolveRuntimeConfigValue,
+} from '@lorion-org/runtime-config';
+
+const fragments = new Map([
+  [
+    'billing',
+    {
+      public: {
+        apiBase: '/api/billing',
+      },
+      private: {
+        apiSecret: 'secret',
+      },
+      contexts: {
+        tenantA: {
+          public: {
+            apiBase: '/tenant-a/billing',
+          },
+        },
+      },
+    },
+  ],
+]);
+
+const runtimeConfig = projectSectionedRuntimeConfig(fragments);
+
+runtimeConfig.public.billingApiBase;
+// => '/api/billing'
+
+resolveRuntimeConfigValue(runtimeConfig.public, 'billing', 'apiBase', {
+  contextId: 'tenantA',
+});
+// => '/tenant-a/billing'
+
+getPublicRuntimeConfigScope(runtimeConfig, 'billing');
+// => { apiBase: '/api/billing' }
+```
+
+## Example: custom context input key
+
+```ts
+import { projectSectionedRuntimeConfig } from '@lorion-org/runtime-config';
+
+projectSectionedRuntimeConfig(
+  [
+    {
+      scopeId: 'billing',
+      config: {
+        public: {
+          apiBase: '/api/billing',
+        },
+        tenants: {
+          tenantA: {
+            public: {
+              apiBase: '/tenant-a/billing',
+            },
+          },
+        },
+      },
+    },
+  ],
+  {
+    contextInputKey: 'tenants',
+    contextOutputKey: '__tenants',
+  },
+);
+// => {
+//   public: {
+//     billingApiBase: '/api/billing',
+//     __tenants: {
+//       tenantA: {
+//         billingApiBase: '/tenant-a/billing'
+//       }
+//     }
+//   },
+//   private: {}
+// }
+```
+
+## Example: namespaced projection
+
+Use `projectRuntimeConfigNamespace()` when one local fragment becomes one
+runtime namespace. Use `projectRuntimeConfigNamespaces()` when combining many
+fragments; in that case each item needs a `scopeId` so the output namespace is
+explicit.
+
+```ts
+import {
+  projectRuntimeConfigNamespace,
+  projectRuntimeConfigNamespaces,
+} from '@lorion-org/runtime-config';
+
+const runtimeConfig = projectRuntimeConfigNamespace('mail', {
+  public: {
+    apiBase: '/api/mail',
+  },
+  private: {
+    token: 'mail-token',
+  },
+});
+
+runtimeConfig.public.mail;
+// => { apiBase: '/api/mail' }
+runtimeConfig.mail;
+// => { token: 'mail-token' }
+
+const combinedRuntimeConfig = projectRuntimeConfigNamespaces([
+  {
+    scopeId: 'mail',
+    config: {
+      public: {
+        apiBase: '/api/mail',
+      },
+      private: {
+        token: 'mail-token',
+      },
+    },
+  },
+]);
+
+combinedRuntimeConfig.public.mail;
+// => { apiBase: '/api/mail' }
+combinedRuntimeConfig.mail;
+// => { token: 'mail-token' }
+```
+
+## Example: environment variables
+
+Adapters choose their own prefix. The default prefix is deliberately generic.
+
+```ts
+import {
+  projectRuntimeConfigEnvVars,
+  runtimeEnvVarsToShellAssignments,
+  runtimeEnvVarsToString,
+  toRuntimeEnvVars,
+} from '@lorion-org/runtime-config';
+
+const envVars = toRuntimeEnvVars(
+  {
+    public: {
+      billingApiBase: '/api/billing',
+    },
+    private: {
+      billingApiSecret: 'secret',
+    },
+  },
+  'APP',
+);
+
+runtimeEnvVarsToString(envVars);
+// => APP_PUBLIC_BILLING_API_BASE=/api/billing
+// => APP_PRIVATE_BILLING_API_SECRET=secret
+
+runtimeEnvVarsToShellAssignments(envVars);
+// => APP_PUBLIC_BILLING_API_BASE='"/api/billing"'
+// => APP_PRIVATE_BILLING_API_SECRET='"secret"'
+
+projectRuntimeConfigEnvVars(
+  new Map([
+    [
+      'billing',
+      {
+        public: {
+          apiBase: '/api/billing',
+        },
+      },
+    ],
+  ]),
+  {
+    prefix: 'APP',
+  },
+);
+// => {
+//   APP_PUBLIC_BILLING_API_BASE: '/api/billing'
+// }
+```
+
+Runnable example files live in [`examples/`](./examples).
+
+## Local commands
+
+```shell
+cd packages/runtime-config
+pnpm build
+pnpm test
+pnpm coverage
+pnpm typecheck
+pnpm package:check
+```

package/dist/index.cjs

@@ -0,0 +1,368 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createRuntimeConfigEnvKey: () => createRuntimeConfigEnvKey,
+  createRuntimeConfigKey: () => createRuntimeConfigKey,
+  getPrivateRuntimeConfigScope: () => getPrivateRuntimeConfigScope,
+  getPublicRuntimeConfigScope: () => getPublicRuntimeConfigScope,
+  getRuntimeConfigFragment: () => getRuntimeConfigFragment,
+  getRuntimeConfigScope: () => getRuntimeConfigScope,
+  injectRuntimeEnvVars: () => injectRuntimeEnvVars,
+  normalizeRuntimeConfigFragments: () => normalizeRuntimeConfigFragments,
+  projectRuntimeConfigEnvVars: () => projectRuntimeConfigEnvVars,
+  projectRuntimeConfigFragment: () => projectRuntimeConfigFragment,
+  projectRuntimeConfigNamespace: () => projectRuntimeConfigNamespace,
+  projectRuntimeConfigNamespaces: () => projectRuntimeConfigNamespaces,
+  projectSectionedRuntimeConfig: () => projectSectionedRuntimeConfig,
+  resolveRuntimeConfigValue: () => resolveRuntimeConfigValue,
+  resolveRuntimeConfigValueFromRuntimeConfig: () => resolveRuntimeConfigValueFromRuntimeConfig,
+  runtimeConfigVisibilities: () => runtimeConfigVisibilities,
+  runtimeEnvValueToShellLiteral: () => runtimeEnvValueToShellLiteral,
+  runtimeEnvVarsToShellAssignments: () => runtimeEnvVarsToShellAssignments,
+  runtimeEnvVarsToString: () => runtimeEnvVarsToString,
+  stripRuntimeConfigScopePrefix: () => stripRuntimeConfigScopePrefix,
+  toRuntimeConfigFragment: () => toRuntimeConfigFragment,
+  toRuntimeEnvVars: () => toRuntimeEnvVars,
+  toSnakeUpperCase: () => toSnakeUpperCase
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/key.ts
+function upperFirst(input) {
+  return input ? input[0].toUpperCase() + input.slice(1) : input;
+}
+function uncapitalize(input) {
+  return input ? input[0].toLowerCase() + input.slice(1) : input;
+}
+function camelCase(input) {
+  return input.replace(/['\u2019]/g, "").split(/[^A-Za-z0-9]+|(?=[A-Z][a-z])/).map((part) => part.trim()).filter(Boolean).map((part) => part.toLowerCase()).map((part, index) => index === 0 ? part : upperFirst(part)).join("");
+}
+function createRuntimeConfigKey(scopeId, key, options = {}) {
+  return options.keyStrategy?.(scopeId, key) ?? camelCase(`${scopeId} ${key}`);
+}
+function stripRuntimeConfigScopePrefix(scopeId, configKey, options = {}) {
+  const prefix = createRuntimeConfigKey(scopeId, "", options);
+  if (!prefix || !configKey.startsWith(prefix) || configKey.length <= prefix.length) {
+    return void 0;
+  }
+  return uncapitalize(configKey.slice(prefix.length));
+}
+function toSnakeUpperCase(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toUpperCase();
+}
+
+// src/fragment.ts
+var isObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+function toRuntimeConfigFragment(config, options = {}) {
+  const contextInputKey = options.contextInputKey ?? "contexts";
+  const contexts = contextInputKey === "contexts" ? config.contexts : config.contexts ?? config[contextInputKey];
+  return {
+    ...isObject(config.public) ? { public: config.public } : {},
+    ...isObject(config.private) ? { private: config.private } : {},
+    ...isObject(contexts) ? { contexts } : {}
+  };
+}
+
+// src/types.ts
+var runtimeConfigVisibilities = ["public", "private"];
+
+// src/project.ts
+function normalizeRuntimeConfigFragments(fragments, options = {}) {
+  const entries = fragments instanceof Map ? Array.from(fragments.entries()).map(([scopeId, config]) => ({ scopeId, config })) : Array.from(fragments);
+  return entries.map((fragment) => ({
+    scopeId: fragment.scopeId.trim(),
+    config: toRuntimeConfigFragment(fragment.config, options)
+  })).filter((fragment) => fragment.scopeId.length > 0).sort((left, right) => left.scopeId.localeCompare(right.scopeId));
+}
+function filterFragments(input) {
+  const scopeIdSet = input.scopeIds ? new Set(input.scopeIds.map((id) => id.trim()).filter(Boolean)) : void 0;
+  return normalizeRuntimeConfigFragments(input.fragments, {
+    ...input.contextInputKey ? { contextInputKey: input.contextInputKey } : {}
+  }).filter((fragment) => !scopeIdSet || scopeIdSet.has(fragment.scopeId));
+}
+function getSection(config, visibility) {
+  return config?.[visibility];
+}
+function assignDefined(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+function projectSectionedRuntimeConfig(fragments, options = {}) {
+  const result = {
+    public: {},
+    private: {}
+  };
+  const contextOutputKey = options.contextOutputKey ?? "__contexts";
+  const filteredFragments = filterFragments({
+    fragments,
+    ...options.contextInputKey ? { contextInputKey: options.contextInputKey } : {},
+    ...options.scopeIds ? { scopeIds: options.scopeIds } : {}
+  });
+  for (const fragment of filteredFragments) {
+    for (const visibility of runtimeConfigVisibilities) {
+      const section = getSection(fragment.config, visibility);
+      if (!section) continue;
+      for (const [key, value] of Object.entries(section)) {
+        assignDefined(
+          result[visibility],
+          createRuntimeConfigKey(fragment.scopeId, key, options),
+          value
+        );
+      }
+    }
+    if (options.includeContexts === false) continue;
+    for (const [contextId, context] of Object.entries(fragment.config.contexts ?? {})) {
+      for (const visibility of runtimeConfigVisibilities) {
+        const section = getSection(context, visibility);
+        if (!section) continue;
+        const contexts = result[visibility][contextOutputKey] ?? {};
+        const contextValues = contexts[contextId] ?? {};
+        for (const [key, value] of Object.entries(section)) {
+          assignDefined(
+            contextValues,
+            createRuntimeConfigKey(fragment.scopeId, key, options),
+            value
+          );
+        }
+        contexts[contextId] = contextValues;
+        result[visibility][contextOutputKey] = contexts;
+      }
+    }
+  }
+  return result;
+}
+function projectRuntimeConfigFragment(scopeId, config, options = {}) {
+  return projectSectionedRuntimeConfig(/* @__PURE__ */ new Map([[scopeId, config]]), options);
+}
+function projectRuntimeConfigNamespace(scopeId, config, options = {}) {
+  return projectRuntimeConfigNamespaces([{ scopeId, config }], options);
+}
+function projectRuntimeConfigNamespaces(fragments, options = {}) {
+  const result = {
+    public: {}
+  };
+  const namespaceStrategy = options.namespaceStrategy ?? "nested";
+  const filteredFragments = filterFragments({
+    fragments,
+    ...options.contextInputKey ? { contextInputKey: options.contextInputKey } : {},
+    ...options.scopeIds ? { scopeIds: options.scopeIds } : {}
+  });
+  for (const fragment of filteredFragments) {
+    const context = options.contextId ? fragment.config.contexts?.[options.contextId] : void 0;
+    const publicSection = {
+      ...fragment.config.public ?? {},
+      ...context?.public ?? {}
+    };
+    const privateSection = {
+      ...fragment.config.private ?? {},
+      ...context?.private ?? {}
+    };
+    if (namespaceStrategy === "flat") {
+      Object.assign(result.public, publicSection);
+      Object.assign(result, privateSection);
+      continue;
+    }
+    if (Object.keys(publicSection).length) {
+      result.public[fragment.scopeId] = {
+        ...result.public[fragment.scopeId] ?? {},
+        ...publicSection
+      };
+    }
+    if (Object.keys(privateSection).length) {
+      result[fragment.scopeId] = {
+        ...result[fragment.scopeId] ?? {},
+        ...privateSection
+      };
+    }
+  }
+  return result;
+}
+
+// src/env.ts
+function createRuntimeConfigEnvKey(input) {
+  return toSnakeUpperCase(
+    [input.prefix ?? "APP", input.visibility, input.scopeId, input.key].filter(Boolean).join("_")
+  );
+}
+function toRuntimeEnvVars(runtimeConfig, prefix = "APP") {
+  const envVars = {};
+  for (const visibility of runtimeConfigVisibilities) {
+    for (const [key, value] of Object.entries(runtimeConfig[visibility])) {
+      if (key.startsWith("__")) continue;
+      envVars[createRuntimeConfigEnvKey({ prefix, visibility, key })] = value;
+    }
+  }
+  return envVars;
+}
+function projectRuntimeConfigEnvVars(fragments, options = {}) {
+  const { prefix = "APP", ...projectOptions } = options;
+  return toRuntimeEnvVars(
+    projectSectionedRuntimeConfig(fragments, {
+      ...projectOptions,
+      includeContexts: false
+    }),
+    prefix
+  );
+}
+function injectRuntimeEnvVars(envVars, processEnv) {
+  const items = {};
+  for (const key of Object.keys(envVars)) {
+    items[key] = processEnv[key] ?? envVars[key];
+  }
+  return items;
+}
+function runtimeEnvVarsToString(envVars) {
+  return Object.entries(envVars).map(([key, value]) => `${key}=${String(value)}`).join("\n");
+}
+function runtimeEnvValueToShellLiteral(value) {
+  const json = JSON.stringify(value) ?? "undefined";
+  return `'${json.replace(/'/g, "'\\''")}'`;
+}
+function runtimeEnvVarsToShellAssignments(envVars) {
+  return Object.entries(envVars).map(([key, value]) => `${key}=${runtimeEnvValueToShellLiteral(value)}`).join("\n");
+}
+
+// src/resolve.ts
+function resolveRuntimeConfigValue(scopeConfig, scopeId, key, options = {}) {
+  const configKey = createRuntimeConfigKey(scopeId, key, options);
+  const contextOutputKey = options.contextOutputKey ?? "__contexts";
+  if (options.contextId) {
+    const contexts = scopeConfig?.[contextOutputKey];
+    const contextValue = contexts?.[options.contextId]?.[configKey];
+    if (contextValue !== void 0) {
+      return contextValue;
+    }
+  }
+  const globalValue = scopeConfig?.[configKey];
+  if (globalValue !== void 0) {
+    return globalValue;
+  }
+  return options.defaultValue;
+}
+function resolveRuntimeConfigValueFromRuntimeConfig(runtimeConfig, scopeId, key, options = {}) {
+  const { visibility = "public", ...resolveOptions } = options;
+  return resolveRuntimeConfigValue(runtimeConfig[visibility], scopeId, key, resolveOptions);
+}
+
+// src/scope.ts
+function assignDefined2(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+function collectRuntimeConfigScopeValues(input) {
+  const values = {};
+  for (const [configKey, value] of Object.entries(input.scopeConfig ?? {})) {
+    if (configKey.startsWith("__")) continue;
+    const key = stripRuntimeConfigScopePrefix(input.scopeId, configKey, input.options);
+    if (key) assignDefined2(values, key, value);
+  }
+  return values;
+}
+function getRuntimeConfigScope(runtimeConfig, scopeId, options = {}) {
+  const {
+    contextId,
+    contextOutputKey = "__contexts",
+    keys,
+    visibility = "public",
+    ...keyOptions
+  } = options;
+  const scopeConfig = runtimeConfig[visibility];
+  if (keys) {
+    return Object.fromEntries(
+      keys.map((key) => {
+        const value = resolveRuntimeConfigValue(scopeConfig, scopeId, key, {
+          ...keyOptions,
+          ...contextId ? { contextId } : {},
+          contextOutputKey
+        });
+        return [key, value];
+      }).filter(([, value]) => value !== void 0)
+    );
+  }
+  const values = collectRuntimeConfigScopeValues({
+    scopeConfig,
+    scopeId,
+    options: keyOptions
+  });
+  if (!contextId) return values;
+  const contexts = scopeConfig?.[contextOutputKey];
+  const contextValues = collectRuntimeConfigScopeValues({
+    scopeConfig: contexts?.[contextId],
+    scopeId,
+    options: keyOptions
+  });
+  return {
+    ...values,
+    ...contextValues
+  };
+}
+function getPublicRuntimeConfigScope(runtimeConfig, scopeId, options = {}) {
+  return getRuntimeConfigScope(runtimeConfig, scopeId, {
+    ...options,
+    visibility: "public"
+  });
+}
+function getPrivateRuntimeConfigScope(runtimeConfig, scopeId, options = {}) {
+  return getRuntimeConfigScope(runtimeConfig, scopeId, {
+    ...options,
+    visibility: "private"
+  });
+}
+function getRuntimeConfigFragment(runtimeConfig, scopeId, options = {}) {
+  const { keys, ...scopeOptions } = options;
+  const publicOptions = keys?.public ? { ...scopeOptions, keys: keys.public } : scopeOptions;
+  const privateOptions = keys?.private ? { ...scopeOptions, keys: keys.private } : scopeOptions;
+  return {
+    public: getPublicRuntimeConfigScope(runtimeConfig, scopeId, publicOptions),
+    private: getPrivateRuntimeConfigScope(runtimeConfig, scopeId, privateOptions)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRuntimeConfigEnvKey,
+  createRuntimeConfigKey,
+  getPrivateRuntimeConfigScope,
+  getPublicRuntimeConfigScope,
+  getRuntimeConfigFragment,
+  getRuntimeConfigScope,
+  injectRuntimeEnvVars,
+  normalizeRuntimeConfigFragments,
+  projectRuntimeConfigEnvVars,
+  projectRuntimeConfigFragment,
+  projectRuntimeConfigNamespace,
+  projectRuntimeConfigNamespaces,
+  projectSectionedRuntimeConfig,
+  resolveRuntimeConfigValue,
+  resolveRuntimeConfigValueFromRuntimeConfig,
+  runtimeConfigVisibilities,
+  runtimeEnvValueToShellLiteral,
+  runtimeEnvVarsToShellAssignments,
+  runtimeEnvVarsToString,
+  stripRuntimeConfigScopePrefix,
+  toRuntimeConfigFragment,
+  toRuntimeEnvVars,
+  toSnakeUpperCase
+});